text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Tableau Hyper API – BI-команда скажет вам спасибо
Мы хотим рассказать вам о том, как мы помогли нашей BI-команде организовать автоматический процесс доставления данных на Tableau-сервер из MongoDB, используя таблошный формат хранения данных ”hyper”, а сам процесс настройки формирования данных осуществляется через простой веб-интерфейс.
В начале коротко расскажем, как выглядел процесс до и после того, как мы научили наш внутренний продукт А1 программно собирать датасорсы и публиковать их на Tableau Server. Затем подробнее разберем проблему BI-команды и найденное решение, а также заглянем под капот (здесь о создании .hyper файла, публикации файла на tableau-сервере и обновлении хайпера). Добро пожаловать под кат!
Мы в рекламной группе DAN много работаем с данными мониторинга рекламы от [Mediascope](https://mediascope.net/), индустриального измерителя на медиарынке. Сценарии бывают разные: некоторые сотрудники выгружают сырые данные, другие пользуются готовыми предобработанными базами, а кто-то заказывает разработку автоматизированных дашбордов на этих данных. О последнем сценарии расскажем подробнее – дашборды наши BI-разработчики собирают в Tableau, но прежде чем начать «рисовать», им тоже необходимо привести данные к нужному удобному для разработки формату.
Жизненный путь данных от сырья до красивых автоматизированных графиков можно условно разбить на 4 шага:
1. Получение сырых данных
2. Чистка и доработка данных
3. Создание источников данных для Tableau
4. Разработка визуализаций
#### Было
До того, как мы научились программно генерировать источники данных для Tableau, процесс выглядел так:
**1. Получение сырых данных**
Пользователи формируют табличные-отчеты через внутренний инструмент А1. О нем мы подробнее расскажем далее.
**2. Чистка и доработка данных**
Возможность трансформации данных также заложена в инструмент А1, после чего очищенные данные можно выгрузить в xslx/csv и продолжить с ними работу вне инструмента. Тут стоит отметить, что некоторые пользователи ограничиваются 1ым пунктом и после выгрузки отчетов дорабатывают данные своими силами.
**3. Создание источников данных для Tableau**
Раньше заказчики дашбордов приходили с набором экселей, которые они сгенерировали на предыдущих пунктах. А BI-разработчики сводили эти эксели в единый датасорс (таблошный сленг) своими силами. Не всегда удавалось ограничиться только инструментами Tableau, часто писали скрипты на Python.
**4. Разработка визуализаций**
Наконец, вершина айсберга – создание дашборда и публикация его на Tableau Server, где его увидит заказчик. На практике визуализация часто занимает меньше времени, чем сбор данных и настройка обновлений.
Боль копилась на третьем шаге, так как росло количество кастомных решений, которые было затратно поддерживать и реализовывать. Также регулярно просачивались ошибки в данных со второго шага – промежуточный эксель между двух систем (А1 и Tableau) прямо-таки подталкивал пользователя: «давай поправь что-нибудь ручками, никто не заметит».
#### Стало
Основной задачей было исключить эксели между 2 и 3 шагом. В итоге мы научили А1 собирать датасорсы и публиковать их на Tableau Server. Вот что получилось:
Сейчас шаги с 1 по 3 происходят в А1, на выходе BI-команда получает опубликованный на Tableau Server датасорс для разработки визуализаций. Связующим звеном стал Hyper API, о котором дальше и пойдет речь.
#### Результаты
**Уменьшили кол-во узлов** при работе в разных инструментах. Сейчас ошибиться где-то в процессе сложнее, а отловить, где произошла ошибка проще, расследование сбоев занимает меньше времени. Система предупреждает пользователей о распространенных ошибках.
**Освободили время BI команды**. Раньше было мало шаблонных решений и много кастомизаций. Чаще всего под каждый проект дописывали обработку на Python. В редких случаях, где обработка не нужна была, работали сразу в Tableau Desktop (основной инструмент разработки).
Сейчас подготовка датасорса это: накликать нужные поля в интерфейсе А1, отметить, какие из них разворачиваем в строки (если это необходимо) и опционально заранее определить тип полей.
**Не нагружаем Tableau Server** обновлением громоздких датасорсов – обновление происходит силами А1, а на сервер закачивается уже готовый hyper.
**\*Бонус – стимулируем пользователей работать внутри А1.** Если раньше некоторые пользователи после выгрузки сырых отчетов, дорабатывали их вручную вне инструмента, то теперь, так как весь процесс с 1 по 3 шаг происходит в А1, пользователям проще настраивать процесс чистки там же.
### Проблема и решение
#### Немного о А1
Прежде чем мы начнем рассказывать про наше решение, нужно рассказать о нашем внутреннем продукте А1, к которому прикрутили генерацию датасорсов.
А1 – это внутренний продукт компании, который призван упростить рабочий процесс сотрудникам, у которых основная работа заключается в следующем:
* Забирать данные из программных продуктов компании MediaScope
* Приводить эти данные (чистить) в удобный для аналитиков-предметников вид
* По необходимости подготавливать данные для создания дашбордов (об этом мы сегодня и поговорим)
После того, как пользователь завершает “чистку” данных, они хранятся в системе А1. В нашей терминологии это называется «Контейнером». Контейнер – это обычный документ в MongoDB, который нам и надо передавать на Tableau-сервер.
#### Проблема BI-команды
Нашей команде BI-разработчиков нужно было как-то получать данные из А1, которые хранились в MongoDB, и на основе полученных данных строить дашборды. В первую очередь мы попробовали забирать данные из MongoDB штатными средствами табло, но проблему это не решало:
* Поскольку данные хранятся в MongoDB, то на вход в табло поступают данные с произвольной структурой, а это значит, что постоянно пришлось бы заниматься поддержкой данной логики.
* Для агрегации данных из MongoDB нужно было тащить определенные записи из коллекции, а не коллекцию целиком – драйвер Tableau делать это не умеет.
* Кроме всего прочего, мало было получить данные: иногда их нужно было «разворачивать» – делать «unpivot» некоторых столбцов в строки. Что тоже не так просто было сделать, от слова совсем.
#### Что мы придумали
Было принято решение попробовать решить данную задачу своим велосипедом, используя библиотеку [Tableau Hyper API](https://help.tableau.com/current/api/hyper_api/en-us/index.html). Данная библиотека позволяет создавать файл в формате .hyper, в который легко складывать данные, а потом использовать как источник данных для создания дашборда на табло сервере.
Как описывают хайпер сами разработчики табло:
> Hyper – это высокопроизводительный in-memory механизм обработки данных, который помогает клиентам быстро анализировать большие или комплексные датасеты, эффективно оценивая запросы в базу данных. Основанная на платформе Tableau, Hyper использует собственные методы динамической генерации кода и передовые технологии параллелизма, позволяющие достигать высокой производительности при создании экстрактов и выполнение запросов.
Примерный процесс работы в нашей программе выглядит следующим образом:
* Пользователь выбирает контейнеры и нужные колонки
* Система выдергивает из контейнеров данные
* По полученным данным система определяет типы колонок
* Инициализируется создание хайпера и вставка в него данных
* Загружается хайпер на табло-сервер
* BI-разработчики видят хайпер на сервере и создает на его основе дашборд
Когда в контейнеры зальют новые данные системе будет подан сигнал, что нужно обновить хайпер:
* Система скачает с табло-сервера хайпер
* Заберет из MongoDB свежие данные и обновит хайпер
* После система загружает на сервер новый хайпер с перезаписью существующего
* Пользователю достаточно просто нажать на кнопку «Refresh», чтобы в дашборде отобразилась актуальная информация
#### Что видит пользователь
Как уже говорилось ранее, А1 является веб-приложением. Для создания сервиса генерации хайпера на фронте мы использовали Vue.js и Vuetify.
Интерфейс приложения разделен на три экрана.
На первом экране пользователь выбирает нужные контейнеры и колонки.
Если включена опция «Unpivot», то в хайпере будут созданы две дополнительные колонки: variable- наименования колонок, которые выбираются столбцом Metrics и values- значения из этих колонок.
Столбец Dimension добавляет в хайпер колонку с одноименной выбранной колонкой. Количество выбранных колонок Dimensions и их названия должны быть одинаковые во всех контейнерах, чтобы не нарушилась целостность таблицы в хайпере, поэтому присутствует столбец «Имя hyper», который позволяет указать имя выбранной колонке, если в контейнерах они называются по-разному.
На этом процесс настройки хайпера заканчивается. Пользователю достаточно перейти на второй экран, нажать «Создать hyper» и наблюдать за ходом событий в логах.
На третьем экране находятся дополнительные настройки:
* Можно включить игнорирование обновлений, если нам не нужно, чтобы система автоматически обновляла хайпер
* Можно указать email, на который отправлять отчеты об обновлениях
* Можно руками указать тип данных для колонки values (используется только при unpivot режиме): float, string или автоматически определять системой (про типы поговорим дальше)
* Также можно указать типы данных для выбранных колонок у контейнеров.
#### Что под капотом
А1 написан на Python. Для работы с данными мы используем Pandas, а сами данные мы сериализуем из pandas в pickle и храним в MongoDB GridFS.
Когда поступает команда на создание хайпера, система выполняет следующие операции:
* Выгружает из MongoDB все необходимые контейнеры и десиреализует данные в датайфремы pandas
* Производит подготовку данных: оставляет в датафреймах только нужные колонки, дает им новые имена, при необходимости разворачивает таблицы через pandas.melt
* Если пользователь выставил тип данных у колонок, то произвести конвертацию данных либо во float32, либо в string
* После всех подготовительных работ с данными система через hyper api создает файл и через tabcmd отправляет файл на табло-сервер.
Стоит немного поговорить о типах данных у колонок. Одной из особенностей хранения данных в контейнерах А1 является то, что пользователи не заморачиваются над тем, какие типы назначать колонкам, за них это прекрасно делает pandas: система спокойно справляется с ситуациями, когда в колонке присутствуют числа и строковые значения. Однако хайперу это не нравится: если сказать ему, что колонка должна иметь тип int, то система ругнется при попытке вставить что угодно кроме целого числа. Поэтому было принято решение использовать в хайперах только два типа данных: string и float.
Итак, с общим принципом работы мы разобрались, давайте поговорим уже про саму работу с hyper.
#### Создание .hyper файла
Для работы с Hyper API понадобится установить библиотеку, скачать ее можно с официально сайта [тут](https://help.tableau.com/current/api/hyper_api/en-us/index.html). Там же есть неплохие примеры, как работать с этим инструментом. Мы же кратко укажем основные моменты.
Сам файл хайпера из себя представляет эдакую базу данных, чем-то напоминает SQLite.Через api можно обращаться к данным, используя like SQL синтаксис:
```
f"SELECT {escape_name('Customer ID')} FROM {escape_name('Customer')}"
```
Поскольку система у нас написана на Python, то и библиотеку мы будем использовать для соответствующего языка. При создании файла мы должны указать имя схемы, имя таблицы и колонки с типами. Имя схемы и таблицы должны называться “Extract”, поскольку именно в эту схему с таблицей залезает Tableau Server, чтобы вытащить данные для книжек.
```
with HyperProcess(Telemetry.SEND_USAGE_DATA_TO_TABLEAU) as hyper:
with Connection(
hyper.endpoint, self.fullpath_hyper, CreateMode.CREATE_AND_REPLACE
) as connection:
connection.catalog.create_schema("Extract")
main_table = TableName("Extract", "Extract")
example_table = TableDefinition(main_table)
```
После создания таблицы нам нужно создать колонки и задать типы. Как мы уже говорили ранее, данные у нас имеют только два типа (float или string), поэтому отталкиваясь от того, какой тип стоит у колонок в датафрейме, такой мы и выставляем для колонок:
```
for column in dataframe.columns:
if dataframe[column].dtype.name in ("category", "object"):
example_table.add_column(TableDefinition.Column(column, SqlType.text()))
elif dataframe[column].dtype.name in ("float32"):
example_table.add_column(
TableDefinition.Column(column, SqlType.double())
)
connection.catalog.create_table(example_table)
```
После создания таблицы можно и вставить данные:
```
with Inserter(connection, example_table) as inserter:
for val in dataframe.values:
inserter.add_row(val.tolist())
inserter.execute()
```
Здесь мы построчно бежим по датафрейму и накапливаем список значениями через **inserter.add\_row()**. На самом деле в апи хайпера есть функция **add\_rows()**, которая принимает список списков и вставляет уже значения. Почему не было так сделано? Ради экономии оперативной памяти: для того чтобы предоставить список списков значений из датафрейма, нужно попросить pandas сделать **values.tolist()**. А когда у тебя 150 млн строк данных, получается очень дорогая операция для оперативки, при этом на производительности это никак не сказывается (во всяком случае, не было замечено, что из-за итерационного перебора строк как-то просела скорость создания хайпера). Плюс ко всему, **add\_rows()** работает как синтаксический сахар: на деле он принимает список списков и так же итерационно добавляет данные.
На этом создание нашего хайпера заканчивается. Дальше нам нужно опубликовать его на сервере.
#### Публикация файла на tableau-сервере
Для обращения к tableau-серверу мы будем использовать утилиту [tabcmd](https://help.tableau.com/current/server/en-us/tabcmd.htm) — это консольная утилита, позволяющая подключаться к серверу и выполнять административные функции – создавать пользователей, группы, книжки и прочее.
Запускать команду tabcmd будем через питоновский subprocess.Popen:
```
popen = subprocess.Popen(
f'/opt/tableau/tabcmd/bin/tabcmd publish "{fullpath_hyper}" -n "{filename}" -o -r "A1_test" '
'-s http://tableau.domain.com -u "username" -p "password" --no-certcheck',
shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE,
)
return_code = popen.wait()
if return_code:
error = str(popen.communicate()[1])
return f"Ошибка сервера во время публикации файла. {error}"
```
Мы передаем tabcmd следующую команду и ключи:
* **publish**: залить файл на сервер
* **-n (--name)**: какое имя файла будет на сервере
* **-o (--overwrite)**: если присутствует файл с таким именем, то перезаписать
* **-r “A1\_test” (--project)**: положить файл в папку (он же проект)
* **-s (--server)**: адрес tableau-сервера
* **-u -p**: логин и пароль для авторизации на сервере
* **--no-certcheck**: игнорировать проверку SSL-сертификата
#### Обновление хайпера
Как создавать новый хайпер мы разобрались, но что делать, когда хайпер состоит из десятка контейнеров и в один из них поступили новые данные? Будем обновлять хайпер.
Когда в контейнер поступают новые данные, система смотрит, есть ли хайперы, которые используют этот контейнер. Если есть, то ставится задача на обновление хайпера.
Чтобы понимать, какие данные из какого контейнера лежат в хайпере, система при создании хайпера также создает дополнительную колонку container\_id. При таком подходе обновление становится очень простым:
* Забираем файл с сервера
* Удаляем все строки в хайпере, где container\_id равняется обновляемому контейнеру
* Вставляем новые строчки
* Загружаем обратно на сервер файл с перезаписью.
Процесс забора файла немного отличается от процесса его загрузки. В первую очередь, с сервера мы будем забирать не .hyper файл, а архив .tdsx, который уже после будем распаковывать и открывать сам .hyper.
Для того, чтобы забрать файл, мы используем tabcmd:
```
popen = subprocess.Popen(
f'/opt/tableau/tabcmd/bin/tabcmd get "datasources/{filename_tdsx}" '
f'-s http://tableau.domain.com -u "username" -p "password" '
f'--no-certcheck -f "{fullpath_tdsx}"',
shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE,
)
return_code = popen.wait()
if return_code:
error = str(popen.communicate()[1])
return f"Ошибка. {error}"
```
Тут используем следующую команду и ключи:
* **get**: забрать с сервера файл. Если на сервере лежит файл test.hyper, то обращаться надо к файлу test.tdsx, а лежат они все в директории datasource (я не смог нагуглить, почему такая особенность работы в табло, если знаете, поделитесь в комментариях )
* **-f (--filename)**: полный путь, включая имя файла и его расширение, куда надо сохранить файл
После того, как файл будет скачен, его надо разархивировать через zipfile:
```
with zipfile.ZipFile(fullpath_tdsx, "r") as zip_ref:
zip_ref.extractall(path)
```
После разархивации хайпер будет лежать в директории **./Data/Extracts**.
Теперь, когда у нас есть актуальная версия файла, мы можем удалить из него ненужные строки:
```
table_name = TableName("Extract", "Extract")
with HyperProcess(Telemetry.SEND_USAGE_DATA_TO_TABLEAU) as hyper:
with Connection(hyper.endpoint, self.fullpath_hyper) as connection:
connection.execute_query(
f"DELETE FROM {table_name} WHERE "
f'{escape_name("container_id")}={container_id}'
).close()
```
Ну а вставка и публикация файла были уже описаны выше.
### Заключение
Что в итоге? Проделав работу по внедрению генерации hyper-файлов и автоматической доставки их на tableau-сервер, мы в разы снизили нагрузку на BI-команду, данные в дашборде обновлять стало проще и, самое главное, быстрее. Само знакомство с hyper api не было болезненным, документация неплохо написана, а сама интеграция технологии в нашу систему прошла легко.
Благодарим за внимание! Если у вас есть вопросы или замечания, пожалуйста, оставляйте их в комментариях.
*Статья написана совместно с Василием Лавровым ([VasilyFromOpenSpace](https://habr.com/ru/users/vasilyfromopenspace/)) — Старшим разработчиком бизнес-аналитики* | https://habr.com/ru/post/516886/ | null | ru | null |
# KiCad: скругление дорожек и каплевидные пады, часть 2
[](https://habr.com/ru/company/ruvds/blog/661823/)
В [первой части](https://habr.com/ru/company/ruvds/blog/661103/) мы разобрались, зачем вообще могут быть нужны скруглённые дорожки и каплевидные подводы, а также реализовали необходимые для этого плагины. Эта же часть будет посвящена подстройке полученных плагинов под версию KiCad 6, в которой, к сожалению, пока полноценного функционала для скругления не появилось.
Вот мы и дождались KiCad 6, в котором появился новый функционал и кое-какие улучшения. Можно обратить внимание, что пользовательский интерфейс теперь поддерживает функцию *Endless Pan* (бесконечное панорамирование), также называемую *Continuous Drag* или *Cursor Warping*. Теперь, когда при панорамировании курсор мыши достигает края окна или монитора, это больше не становится преградой. Однажды попробовав эту возможность, жизнь без неё уже не представляешь.
Естественно, сама идея была позаимствована у Blender и привнесена в код KiCad не кем иным, как автором этих строк. В ходе этого процесса мы также исправили некоторые баги интерфейса в сборке для Windows. И хоть совершенным его не назовёшь, работает бесконечное панорамирование KiCad вполне неплохо.
Тем не менее больше всего пользователи ожидали от KiCad 6 нативной поддержки скруглённых дорожек. И они, наконец, появились. Но прежде чем мы попрощаемся с нашим [плагином скругления](https://github.com/mitxela/kicad-round-tracks), должен оговориться, что получили мы лишь ограниченную их поддержку, которая всё ещё находится на ранней стадии. Появившийся функционал вполне годится, чтобы скруглить пару углов, но далёк от того, чтобы сделать это для всей платы.
Нам обещали появление в KiCad 6 нового Python API, но это изменение было отложено до седьмой версии. Однако вполне ожидаемо, что сгенерированная SWIG обёртка не совпадает с её версией для KiCad 5. Изменились некоторые имена и методы, а значит, плагин скругления для работы в шестой версии нужно будет обновить. Ну а раз мы возьмёмся его обновлять, то можно попутно внести и кое-какие доработки.
▍ Fillet Tracks
---------------
Если в KiCad 6 выбрать две соединённые дорожки, вызвать контекстное меню, нажать *Fillet Tracks* и ввести значение радиуса, то сформируется дуга.
Затем заданный радиус можно изменять с помощью клика и перетаскивания созданного изгиба (без перетаскивания крайних точек).
В идеале должна быть возможность выбрать всё и нажать *Fillet Tracks*, чтобы применить скругление ко всей топологии. Но этот вариант не работает по ряду причин.
Во-первых, если радиус окажется слишком большим для выбранных дорожек, то программа выбросит предупреждение и дугу создавать откажется.
Во-вторых, если два угла находятся близко друг к другу, то скругление будет применено только к одному из них.
В-третьих, радиус не подстраивается на основе угла дорожки. Это становится наиболее заметно при наличии очень острых углов. На скриншоте ниже синим показаны исходные дорожки, зелёным — скругления, полученные в результате применения моего плагина, а красным – полученные через функцию *Fillet Tracks*. Во всех случаях радиус был установлен на 3мм.
Когда угол равен 90°, оба метода скругления дают одинаковую форму, но для очень острого угла слева слепое использование радиуса в 3мм привело к съеданию большого объёма фигуры. В случае тупого угла справа изгиб с радиусом 3мм эффекта вообще почти не произвёл.
Четвёртая причина неудовлетворительности изгибов в том, что T-перекрёстки (или соединения от большего числа точек) полностью игнорируются.
Самым удачным вариантом здесь будет изменить плагин скругления для генерации изогнутых линий при помощи нативных дуг, решив тем самым перечисленные проблемы. В идеале применение этого плагина к топологии должно давать одинаковый визуальный результат при любом методе. Насколько это будет сложно сделать?
▍ Генерация дуг
---------------
Новый тип дорожек, `PCB_ARC`, можно инстанцировать несколькими способами. Метод, используемый внутренне при выборе *Fillet Tracks*, заключается в создании `SHAPE_ARC`, определении её радиуса и её касательного расположения относительно дорожек с каждого края. Затем из `SHAPE_ARC` инстанцируется `PCB_ARC`.
К сожалению, интерфейс Python не позволяет нам особых манипуляций с `PCB_ARC`. Можно считывать сгенерированные свойства, такие как радиус и угол, но при создании новой `PCB_ARC` единственными доступными для установки параметрами являются *StartPoint*, *EndPoint* и *MidPoint*.
Начальную и конечную точки найти несложно – достаточно укоротить дорожки, ведущие к пересечению. А вот для выяснения средней точки уже потребуется помощь тригонометрии.
Эта точка должна определять радиус, а также выравнивать дугу так, чтобы она располагалась касательно относительно ведущих к ней дорожек – в противном случае подстроить её впоследствии не получится, да и выглядеть она будет неправильно.
Решением, естественно, будет среднее взвешенное точек, основанное на факторе косинуса. Здесь я решил просто попробовать угадать — в итоге всё либо сработает идеально, либо получится в корне неверно. Часто бывает, что быстрее, оказывается, перебрать несколько догадок, прежде чем прибегать к рисованию чертежей.
К сожалению, несмотря на то, что новые дуги, очевидно, получились касательными (и с неверным радиусом, с чем мы разберёмся позже), интерактивная корректировка их скругления не помогала. Поначалу я решил, что это была ошибка скругления, но проблему удалось исправить, просто закрыв и повторно открыв файл.
Видимо, есть этап, анализирующий выравнивание дуг относительно дорожек, который не был автоматически активирован. Для исправления оказалось достаточно вызвать `pcbnew.UpdateUserInterface()`. Опробованное мной перед этим выполнение `pcbnew.Refresh()` привело к набору глюков, когда дуги отказывались двигаться. Надеюсь, эти детские болячки к следующим релизам подправят.
▍ Подбор радиуса
----------------
Похоже, что в ходе этих проектов «смягчались» не только схемы в KiCad, но и мои мозги. Чуть позже вы поймёте, о чём я.
Коэффициентом коррекции радиуса будет ещё одно тригонометрическое уравнение, и если с угадыванием предыдущего мне очень повезло, то на этот раз без рисования треугольников на бумаге, казалось, было не обойтись. О боже, избавь меня от этих треугольников на бумаге!
Вместо этого я решил поэкспериментировать — визуально выровнять множество дуг с их полученными подразделением двойниками при разных углах и записать координаты в электронной таблице. Это позволит построить график зависимости угла пересечения от поправочного коэффициента (соотношения ожидаемого и полученного радиусов). На основе этого будет уже намного проще подобрать уравнение, соответствующее точкам.
«Полезный» метод полиномиального приближения для кривой, очевидно, не даёт никакой подсказки, но искомый ответ был `( sin( angle/2 ) +1 ) * constant`, где константа оказалась равна 0.585786…
Опишу процесс:
* очевидно, что эта фигура является частью синусоиды;
* это четверть сегмента, значит, она будет представлять функцию половинного угла;
* регулировка смещения и усиления примерно в районе 0.6 для того и другого;
* смещение и усиление одинаковы, значит, это константа, умноженная на `sin(angle/2) + 1`;
* при повороте 90° коэффициент должен быть равен 1 по определению, значит, константа будет `1/(sin( 45 degrees )+1)`.
Вот чёрт! Константа 1/1.707… уже использовалась в другой части этого же фрагмента кода. Отсюда и доводы про размягчение мозга.
Ладно. Самое сложное позади, очередной задачей будут крутые повороты. При работе с квадратом (и радиусом больше его размера) процесс подразделения формирует круг. На первом этапе скругления отрезается около четверти участка вдоль линии. В результате от исходной дорожки остаётся лишь одна точка в центре.
В случае нативных дуг мы переходим сразу к результату: никогда не укорачивая дорожку больше, чем наполовину от её исходной длины. Если укорачивание происходит с двух сторон, удалите дорожку и привяжите обе дуги к центральной точке.
*Красиво!*
▍ T-образные и X-образные пересечения
-------------------------------------
T-пересечения относятся к допустимым случаям. А вот пересечения более высокого порядка – не совсем.
Эти пересечения уже почти работоспособны. В обоих случаях присутствует некая неравномерность из-за порядка, в котором обрабатываются дорожки. Если я когда-нибудь посчитаю, что пересечения от нескольких точек окажутся полезны на плате, то можно будет заняться доработкой.
▍ Каплевидные пады
------------------
Для полноценной работы этот плагин скругления необходимо подружить с плагином создания каплевидных подводов, над которым мы трудились в первой части.
К сожалению, апгрейд под нативные дуги их совместимость нарушил. Плагин для каплевидных подводов предполагает, что все дорожки у нас прямые, в результате чего нативные дуги ведут к созданию неправильных форм.
Но решить эту проблему будет несложно. Нужно лишь выяснить положение и вектор точки на определённом расстоянии вдоль дуги.
Интерфейс для добавления дуг весьма ограничен, но получить производные свойства дуг позволяет без проблем. У нас есть возможность взять углы (начальный, конечный и внутренний), а также радиус, центр дуги и именно фактическую длину, а не просто расстояние между крайними точками. Я мог бы утомить вас подробностями, но этого для решения проблемы уже достаточно.
В случае с прослеживаемыми дорожками всё немного хитрее, получается некий гибрид между прежним вариантом прослеживания для построения подразделяемых дуг и их новым форматом, но поскольку `GetLength()` возвращает правильную величину, большую часть кода можно оставить нетронутой.
На момент написания я отправил очередной запрос на слияние в репозиторий плагина для создания каплевидных подводов, но сам плагин ещё находится в процессе переноса в KiCad 6 (прим. пер.: возможно, к сегодняшнему дню этот процесс уже завершён).
▍ Заключение
------------
Работа над плагином продолжается, но это уже всё довольно скучная рутина вроде исправления пограничных случаев и предотвращения аварийных завершений программы.
Одним из заметных бонусов в KiCad 6 стало добавление *Plugin and Content Manager* – репозитория плагинов, устанавливаемых одним кликом. Поскольку он никак не связан со скруглением, я не стану распинаться по поводу этого процесса, но, надеюсь, что в ближайшем будущем вы уже сможете установить [плагин *Round Tracks*](https://github.com/mitxela/kicad-round-tracks) из этого менеджера.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=kicad_skruglenie_dorozhek_i_kaplevidnye_pady_chast_2) | https://habr.com/ru/post/661823/ | null | ru | null |
# Изучаем внутренние компоненты Docker — Объединённая файловая система
Создавать, запускать, просматривать, перемещать контейнеры и образы с помощью интерфейса командной строки Docker (Docker CLI) проще простого, но задумывались ли вы когда-нибудь, как на самом деле работают внутренние компоненты, обеспечивающие работу интерфейса Docker? За этим простым интерфейсом скрывается множество продвинутых технологий, и специально к старту нового потока [курса по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=090421) в этой статье мы рассмотрим одну из них — объединённую файловую систему, используемую во всех слоях контейнеров и образов. Маститым знатокам контейнеризации и оркестрации данный материал навряд ли откроет что-то новое, зато будет полезен тем, кто делает первые шаги в DevOps.
---
### Что такое объединённая файловая система?
Каскадно-объединённое монтирование — это тип файловой системы, в которой создается иллюзия объединения содержимого нескольких каталогов в один без изменения исходных (физических) источников. Такой подход может оказаться полезным, если имеются связанные наборы файлов, хранящиеся в разных местах или на разных носителях, но отображать их надо как единое и совокупное целое. Например, набор пользовательских/корневых каталогов, расположенных на удалённых NFS-серверах, можно свести в один каталог или можно объединить разбитый на части ISO-образ в один целый образ.
Однако технологию объединённого монтирования (или объединённой файловой системы), по сути, нельзя считать отдельным типом файловой системы. Это, скорее, особая концепция с множеством реализаций. Некоторые реализации работают быстрее, некоторые медленнее, некоторые проще в использовании, некоторые сложнее — проще говоря, у разных реализаций разные цели и разные уровни зрелости. Поэтому, прежде чем углубиться в детали, ознакомимся с некоторыми наиболее популярными реализациями объединённой файловой системы:
* Начнём с исходной объединённой файловой системы, а именно UnionFS. На данный момент поддержка файловой система UnionFS прекращена, [последнее изменение кода](http://git.fsl.cs.sunysb.edu/?p=unionfs-2.6.39.y.git;a=summary) было зафиксировано в августе 2014 года. Более подробная информация об этой файловой системе приведена здесь: [unionfs.filesystems.org](https://unionfs.filesystems.org/).
* aufs — альтернативная версия исходной файловой системы UnionFS с добавлением множества новых функций. Данную файловую систему нельзя использовать в составе ванильного ядра Linux. Aufs использовалась в качестве файловой системы по умолчанию для Docker на Ubuntu/Debian, однако со временем она была заменена на OverlayFS (для ядра Linux >4.0). По сравнению с другими объединёнными файловыми системами эта система имеет ряд преимуществ, описанных в [Docker Docs](https://docs.docker.com/storage/storagedriver/aufs-driver/%23aufs-and-docker-performance).
* Следующая система — OverlayFS — была включена в ядро Linux Kernel, начиная с версии 3.18 (26 октября 2014 года). Данная файловая система используется по умолчанию драйвером overlay2 Docker (это можно проверить, запустив команду docker system info | grep Storage). Данная файловая система в целом обеспечивает лучшую, чем aufs, производительность и имеет ряд интересных функциональных особенностей, например функцию [разделения страничного кэша](https://docs.docker.com/storage/storagedriver/overlayfs-driver/%23overlayfs-and-docker-performance).
* ZFS — объединённая файловая система, разработанная Sun Microsystems (в настоящее время эта компания называется Oracle). В этой системе реализован ряд полезных функций, таких как функция иерархического контрольного суммирования, функция обработки снимков, функция резервного копирования/репликации или архивирования и дедупликации (исключения избыточности) внутренних данных. Однако, поскольку автором этой файловой системы является Oracle, её выпуск осуществлялся под общей лицензией на разработку и распространение (CDDL), не распространяемой на программное обеспечение с открытым исходным кодом, поэтому данная файловая система не может поставляться как часть ядра Linux. Тем не менее можно воспользоваться проектом ZFS on Linux (ZoL), который в документации Docker описывается как работоспособный и хорошо проработанный..., но, увы, непригодный к промышленной эксплуатации. Если вам захочется поработать с этой файловой системой, её можно найти [здесь](https://zfsonlinux.org/).
* Btrfs — ещё один вариант файловой системы, представляющий собой совместный проект [множества компаний](https://btrfs.wiki.kernel.org/index.php/Contributors), в том числе SUSE, WD и Facebook. Данная файловая система выпущена под лицензией GPL и является частью ядра Linux. Btrfs — файловая система по умолчанию дистрибутива Fedora 33. В ней также реализованы некоторые полезные функции, такие как операции на уровне блоков, дефрагментация, доступные для записи снимки и [множество других](https://btrfs.wiki.kernel.org/index.php/Main_Page). Если вас не пугают трудности, связанные с переходом на специализированный драйвер устройств памяти для Docker, файловая система Btrfs с её функциональными и производительными возможностями может стать лучшим вариантом.
Если вы хотите более глубоко изучить характеристики драйверов, используемых в Docker, в [Docker Docs](https://docs.docker.com/storage/storagedriver/select-storage-driver/) можно ознакомиться с таблицей сравнения разных драйверов. Если вы затрудняетесь с выбором файловой системы (не сомневаюсь, есть и такие программисты, которые знают все тонкости файловых систем, но эта статья предназначена не для них), возьмите за основу файловую систему по умолчанию overlay2 — именно её я буду использовать в примерах в оставшейся части данной статьи.
### Почему именно она?
В предыдущем разделе мы рассказали о некоторых полезных возможностях файловой системы такого типа, но почему именно она является оптимальным выбором для работы Docker и контейнеров в целом?
Многие образы, используемые для запуска контейнеров, занимают довольно большой объём, например, ubuntu занимает 72 Мб, а nginx — 133 Мб. Было бы довольно разорительно выделять столько места всякий раз, когда потребуется из этих образов создать контейнер. При использовании объединённой файловой системы Docker создаёт поверх образа тонкий слой, а остальная часть образа может быть распределена между всеми контейнерами. Мы также получаем дополнительное преимущество за счёт сокращения времени запуска, так как отпадает необходимость в копировании файлов образа и данных.
Объединённая файловая система также обеспечивает изоляцию, поскольку контейнеры имеют доступ к общим слоям образа только для чтения. Если контейнерам когда-нибудь понадобится внести изменения в любой файл, доступный только для чтения, они используют стратегию копирования при записи copy-on-write (её мы обсудим чуть позже), позволяющую копировать содержимое на верхний слой, доступный для записи, где такое содержимое может быть безопасно изменено.
### Как это работает?
Теперь вы вправе задать мне важный вопрос: как же это всё работает на практике? Из сказанного выше может создаться впечатление, что объединённая файловая система работает с применением некой чёрной магии, но на самом деле это не так. Сейчас я попытаюсь объяснить, как это работает в общем (неконтейнерном) случае. Предположим, нам нужно объединить два каталога (верхний и нижний) в одной точке монтирования и чтобы такие каталоги были представлены унифицированно:
```
.
├── upper
│ ├── code.py # Content: `print("Hello Overlay!")`
│ └── script.py
└── lower
├── code.py # Content: `print("This is some code...")`
└── config.yaml
```
В терминологии объединённого монтирования такие каталоги называются ветвями. Каждой из таких ветвей присваивается свой приоритет. Приоритет используется для того, чтобы решить, какой именно файл будет отображаться в объединённом представлении, если в нескольких исходных ветках присутствуют файлы с одним и тем же именем. Если проанализировать представленные выше файлы и каталоги, станет понятно, что такой конфликт может возникнуть, если мы попытаемся использовать их в режиме наложения (файл code.py). Давайте попробуем и посмотрим, что у нас получится:
```
~ $ mount -t overlay \
-o lowerdir=./lower,\
upperdir=./upper,\
workdir=./workdir \
overlay /mnt/merged
~ $ ls /mnt/merged
code.py config.yaml script.py
~ $ cat /mnt/merged/code.py
print("Hello Overlay!")
```
В приведённом выше примере мы использовали команду mount с type overlay, чтобы объединить нижний каталог (только для чтения; более низкий приоритет) и верхний каталог (чтение-запись; более высокий приоритет) в объединённое представление в каталоге /mnt/merged. Мы также включили опцию workdir=./workdir. Этот каталог служит местом для подготовки объединённого представления нижнего каталога (lowerdir) и верхнего каталога (upperdir) перед их перемещением в каталог /mnt/merged.
Если посмотреть на выходные данные команды cat, можно заметить, что в объединённом представлении приоритет получили файлы верхнего каталога.
Теперь мы знаем, как объединить два каталога и что произойдёт при возникновении конфликта. Но что произойдёт, если попытаться изменить определенные файлы в объединённом представлении? Здесь в игру вступает функция копирования при записи (CoW). Что именно делает эта функция? CoW — это способ оптимизации, при котором, если две вызывающих программы обращаются к одному и тому же ресурсу, можно дать им указатель на один и тот же ресурс, не копируя его. Копирование необходимо только тогда, когда одна из вызывающих программ пытается осуществить запись собственной "копии" — отсюда в названии способа появилось слово "копия", то есть копирование осуществляется при (первой попытке) записи.
В случае объединённого монтирования это означает, что, если мы пытаемся изменить совместно используемый файл (или файл только для чтения), он вначале копируется в верхнюю ветвь, доступную для записи (upperdir), имеющую более высокий приоритет, чем нижние ветви (lowerdir), доступные только для чтения. Когда файл попадает в ветвь, доступную для записи, его можно безопасно изменить, и его новое содержимое отобразится в объединённом представлении, так как верхний слой имеет более высокий приоритет.
Последняя операция, которую мы, возможно, захотим выполнить, — это удаление файлов. Чтобы "удалить" файл, в ветви, доступной для записи, создается файл whiteout для очистки "удаляемого" файла. На самом деле файл не будет удалён физически. Вернее сказать, что он будет скрыт в объединённом представлении.
Мы много говорили о принципах объединённого монтирования, но как все эти принципы работают на платформе Docker и её контейнерах? Рассмотрим многоуровневую архитектуру Docker. Песочница контейнера состоит из нескольких ветвей образа, или, как мы их называем, слоёв. Такими слоями являются часть объединённого представления, доступная только для чтения (lowerdir), и слой контейнера — тонкая верхняя часть, доступная для записи (upperdir).
Не считая терминологических различий, речь фактически идёт об одном и том же — слои образа, извлекаемые из реестра, представляют собой lowerdir, и, если запускается контейнер, upperdir прикрепляется поверх слоев образа, обеспечивая рабочую область, доступную для записи в контейнер. Звучит довольно просто, не так ли? Давайте проверим, как всё работает!
### Проверяем
Чтобы показать, как Docker использует файловую систему OverlayFS, попробуем смоделировать процесс монтирования Docker контейнеров и слоев образа. Прежде чем мы приступим, нужно вначале очистить рабочее пространство и получить образ, с которым можно работать:
```
~ $ docker image prune -af
...
Total reclaimed space: ...MB
~ $ docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
a076a628af6f: Pull complete
0732ab25fa22: Pull complete
d7f36f6fe38f: Pull complete
f72584a26f32: Pull complete
7125e4df9063: Pull complete
Digest: sha256:10b8cc432d56da8b61b070f4c7d2543a9ed17c2b23010b43af434fd40e2ca4aa
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest
```
Итак, у нас имеется образ (nginx), с которым можно работать, далее нужно проверить его слои. Проверить слои образа можно, либо запустив проверку образа в Docker и изучив поля GraphDriver, либо перейдя в каталог /var/lib/docker/overlay2, в котором хранятся все слои образа. Выполним обе эти операции и посмотрим, что получится:
```
~ $ cd /var/lib/docker/overlay2
~ $ ls -l
total 0
drwx------. 4 root root 55 Feb 6 19:19 3d963d191b2101b3406348217f4257d7374aa4b4a73b4a6dd4ab0f365d38dfbd
drwx------. 3 root root 47 Feb 6 19:19 410c05aaa30dd006fc47d8c23ba0d173c6d305e4d93fdc3d9abcad9e78862b46
drwx------. 4 root root 72 Feb 6 19:19 685374e39a6aac7a346963bb51e2fc7b9f5e2bdbb5eac6c76ccdaef807abc25e
brw-------. 1 root root 253, 0 Jan 31 18:15 backingFsBlockDev
drwx------. 4 root root 72 Feb 6 19:19 d487622ece100972afba76fda13f56029dec5ec26ffcf552191f6241e05cab7e
drwx------. 4 root root 72 Feb 6 19:19 fb18be50518ec9b37faf229f254bbb454f7663f1c9c45af9f272829172015505
drwx------. 2 root root 176 Feb 6 19:19 l
~ $ tree 3d963d191b2101b3406348217f4257d7374aa4b4a73b4a6dd4ab0f365d38dfbd/
3d963d191b2101b3406348217f4257d7374aa4b4a73b4a6dd4ab0f365d38dfbd/
├── diff
│ └── docker-entrypoint.d
│ └── 20-envsubst-on-templates.sh
├── link
├── lower
└── work
~ $ docker inspect nginx | jq .[0].GraphDriver.Data
{
"LowerDir": "/var/lib/docker/overlay2/fb18be50518ec9b37faf229f254bbb454f7663f1c9c45af9f272829172015505/diff:
/var/lib/docker/overlay2/d487622ece100972afba76fda13f56029dec5ec26ffcf552191f6241e05cab7e/diff:
/var/lib/docker/overlay2/685374e39a6aac7a346963bb51e2fc7b9f5e2bdbb5eac6c76ccdaef807abc25e/diff:
/var/lib/docker/overlay2/410c05aaa30dd006fc47d8c23ba0d173c6d305e4d93fdc3d9abcad9e78862b46/diff",
"MergedDir": "/var/lib/docker/overlay2/3d963d191b2101b3406348217f4257d7374aa4b4a73b4a6dd4ab0f365d38dfbd/merged",
"UpperDir": "/var/lib/docker/overlay2/3d963d191b2101b3406348217f4257d7374aa4b4a73b4a6dd4ab0f365d38dfbd/diff",
"WorkDir": "/var/lib/docker/overlay2/3d963d191b2101b3406348217f4257d7374aa4b4a73b4a6dd4ab0f365d38dfbd/work"
}
```
Если внимательно посмотреть на полученные результаты, можно заметить, что они весьма похожи на те, что мы уже наблюдали после применения команды mount, не находите?
* LowerDir: это каталог, в котором слои образа, доступные только для чтения, разделены двоеточиями.
* MergedDir: объединённое представление всех слоев образа и контейнера.
* UpperDir: слой для чтения и записи, на котором записываются изменения.
* WorkDir: рабочий каталог, используемый Linux OverlayFS для подготовки объединённого представления.
Сделаем ещё один шаг — запустим контейнер и изучим его слои:
```
~ $ docker run -d --name container nginx
~ $ docker inspect container | jq .[0].GraphDriver.Data
{
"LowerDir": "/var/lib/docker/overlay2/59bcd145c580de3bb3b2b9c6102e4d52d0ddd1ed598e742b3a0e13e261ee6eb4-init/diff:
/var/lib/docker/overlay2/3d963d191b2101b3406348217f4257d7374aa4b4a73b4a6dd4ab0f365d38dfbd/diff:
/var/lib/docker/overlay2/fb18be50518ec9b37faf229f254bbb454f7663f1c9c45af9f272829172015505/diff:
/var/lib/docker/overlay2/d487622ece100972afba76fda13f56029dec5ec26ffcf552191f6241e05cab7e/diff:
/var/lib/docker/overlay2/685374e39a6aac7a346963bb51e2fc7b9f5e2bdbb5eac6c76ccdaef807abc25e/diff:
/var/lib/docker/overlay2/410c05aaa30dd006fc47d8c23ba0d173c6d305e4d93fdc3d9abcad9e78862b46/diff",
"MergedDir": "/var/lib/docker/overlay2/59bcd145c580de3bb3b2b9c6102e4d52d0ddd1ed598e742b3a0e13e261ee6eb4/merged",
"UpperDir": "/var/lib/docker/overlay2/59bcd145c580de3bb3b2b9c6102e4d52d0ddd1ed598e742b3a0e13e261ee6eb4/diff",
"WorkDir": "/var/lib/docker/overlay2/59bcd145c580de3bb3b2b9c6102e4d52d0ddd1ed598e742b3a0e13e261ee6eb4/work"
}
~ $ tree -l 3 /var/lib/docker/overlay2/59bcd145c580de3bb3b2b9c6102e4d52d0ddd1ed598e742b3a0e13e261ee6eb4/diff # The UpperDir
/var/lib/docker/overlay2/59bcd145c580de3bb3b2b9c6102e4d52d0ddd1ed598e742b3a0e13e261ee6eb4/diff
├── etc
│ └── nginx
│ └── conf.d
│ └── default.conf
├── run
│ └── nginx.pid
└── var
└── cache
└── nginx
├── client_temp
├── fastcgi_temp
├── proxy_temp
├── scgi_temp
└── uwsgi_temp
```
Из представленных выше выходных данных следует, что те же каталоги, которые были перечислены в выводе команды docker inspect nginx ранее как MergedDir, UpperDir и WorkDir (с id 3d963d191b2101b3406348217f4257d7374aa4b4a73b4a6dd4ab0f365d38dfbd), теперь являются частью LowerDir контейнера. В нашем случае LowerDir составляется из всех слоев образа nginx, размещённых друг на друге. Поверх них размещается слой в UpperDir, доступный для записи, содержащий каталоги /etc, /run и /var. Также, раз уж мы выше упомянули MergedDir, можно видеть всю доступную для контейнера файловую систему, в том числе всё содержимое каталогов UpperDir и LowerDir.
И, наконец, чтобы эмулировать поведение Docker, мы можем использовать эти же каталоги для ручного создания собственного объединённого представления:
```
~ $ mount -t overlay -o \
lowerdir=/var/lib/docker/overlay2/59bcd145c580de3bb3b2b9c6102e4d52d0ddd1ed598e742b3a0e13e261ee6eb4-init/diff:
/var/lib/docker/overlay2/3d963d191b2101b3406348217f4257d7374aa4b4a73b4a6dd4ab0f365d38dfbd/diff:
/var/lib/docker/overlay2/fb18be50518ec9b37faf229f254bbb454f7663f1c9c45af9f272829172015505/diff:
/var/lib/docker/overlay2/d487622ece100972afba76fda13f56029dec5ec26ffcf552191f6241e05cab7e/diff:
/var/lib/docker/overlay2/685374e39a6aac7a346963bb51e2fc7b9f5e2bdbb5eac6c76ccdaef807abc25e/diff:
/var/lib/docker/overlay2/410c05aaa30dd006fc47d8c23ba0d173c6d305e4d93fdc3d9abcad9e78862b46/diff,\
upperdir=/var/lib/docker/overlay2/59bcd145c580de3bb3b2b9c6102e4d52d0ddd1ed598e742b3a0e13e261ee6eb4/diff,\
workdir=/var/lib/docker/overlay2/59bcd145c580de3bb3b2b9c6102e4d52d0ddd1ed598e742b3a0e13e261ee6eb4/work \
overlay /mnt/merged
~ $ ls /mnt/merged
bin dev docker-entrypoint.sh home lib64 mnt proc run srv tmp var
boot docker-entrypoint.d etc lib media opt root sbin sys usr
~ $ umount overlay
```
В нашем случае мы просто взяли значения из предыдущего фрагмента кода и передали их в качестве соответствующих аргументов в команду mount. Разница лишь в том, что для объединённого представления вместо /var/lib/docker/overlay2/.../merged мы использовали /mnt/merged.
Именно к этому сводится действие файловой системы OverlayFS в Docker — на множестве уложенных друг на друга слоев может использоваться одна команда монтирования. Ниже приводится отвечающая за это часть кода Docker — заменяются значения lowerdir=...,upperdir=...,workdir=..., после чего следует команда unix.Mount.
```
// https://github.com/moby/moby/blob/1ef1cc8388165b2b848f9b3f53ec91c87de09f63/daemon/graphdriver/overlay2/overlay.go#L580
opts := fmt.Sprintf("lowerdir=%s,upperdir=%s,workdir=%s", strings.Join(absLowers, ":"), path.Join(dir, "diff"), path.Join(dir, "work"))
mountData := label.FormatMountLabel(opts, mountLabel)
mount := unix.Mount
mountTarget := mergedDir
rootUID, rootGID, err := idtools.GetRootUIDGID(d.uidMaps, d.gidMaps)
// ...
```
### Заключение
Интерфейс Docker может показаться чёрным ящиком с большим количеством скрытых внутри непонятных технологий. Эти технологии — пусть непонятные — довольно интересны и полезны. Я вовсе не хочу сказать, что для эффективного использования Docker нужно досконально знать все их тонкости, но, на мой взгляд, если вы потратите немного времени и поймёте, как они работают, это пойдёт вам только на пользу. Ясное понимание принципов работы инструмента облегчает принятие правильных решений — в нашем случае речь идёт о повышении производительности и возможных аспектах, связанных с безопасностью. Кроме того, вы сможете ознакомиться с некоторыми продвинутыми технологиями, и кто знает, в каких областях знаний они могут вам пригодится в будущем!
В этой статье мы рассмотрели только часть архитектуры Docker — файловую систему. Есть и другие части, с которыми стоит ознакомиться более внимательно, например контрольные группы (cgroups) или пространства имен Linux. Если вы их освоите — можно уже задуматься о переходе в востребованный DevOps. А с остальными знаниями, необходимыми для данной профессии мы поможем на курсе по профессии [DevOps-инженер](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=090421).
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=090421), как прокачаться в других специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=090421)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=090421)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=090421)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=090421)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=090421)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=090421)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=090421)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=090421)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=090421)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=090421)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=090421)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=090421)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=090421)
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=090421)
* [Курс "Machine Learning и Deep Learning"](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=090421)
* [Курс "Математика для Data Science"](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=090421)
* [Курс "Математика и Machine Learning для Data Science"](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=090421)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=090421)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=090421)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=090421)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=090421) | https://habr.com/ru/post/547116/ | null | ru | null |
# Решаем задачи devops-инженера с Chat GPT
### Что такое ChatGPT
ChatGPT - это модель языка, которая используется для генерации текста и диалогов, разработаная исследовательской организацией OpenAI. Использует глубокое обучение для предсказания следующего слова в последовательности текста. Она может быть использована для автоматизации задач, таких как генерация текста, диалоговые системы, поиск информации и даже для написания кода, с пояснениями что именно было написано и как он работает.
### Задачи DevOps-инженера которые решаются с помощью ChatGPT
Чтобы получить правильный ответ, нужно задавать правильный вопрос.
Какие задачи будем решать:
* контейнеризация и сборка приложения
* Создания плейбука
* Создание helm chart для kubernetes
Для начала представим , что неожиданно оказались в команде разработки, где срочно нужно доставить код написанный разработчиками (*возможно тоже с использованием AI*) на production. Первое что придется сделать - написать Dockerfile. Тут конечно лучше всего пойти и почитать официальную документацию, в которой все подробно описывается, или на основе опыта написать самостоятельно, но мы в 2023 году, поэтому можем пойти другим путем - отправимся в ChatGPT.
Просим: напиши Dockerfile для golang приложения
Считаные секунды и у нас есть Dockerfile, причем с разъяснениями что он будет делать, куда копировать файлы и что в итоге запускать.
Ответ:
```
Для создания Dockerfile для golang приложения вам потребуется следующий код:
```Dockerfile
FROM golang:latest
WORKDIR /app
COPY . .
RUN go build -o main .
CMD ["./main"]
```
Этот Dockerfile будет создавать докер-образ из последней версии golang, копировать все файлы из текущей директории в директорию /app, собирать приложение и запускать его при запуске докер-контейнера.
```
Dockerfile написан, теперь можно приступить к написанию CI. Допустим есть Jenkins, создаем джобу и идем просить ChatGPT написать pipeline.
Спрашиваем (теперь по-английский): Write Jenkins pipeline for build docker image with golang app
Ответ:
```
```groovy
pipeline {
agent any
stages {
stage('Build') {
steps {
sh 'go build -o main .'
}
}
stage('Docker Build') {
steps {
sh 'docker build -t my-golang-app .'
}
}
stage('Docker Push') {
steps {
sh 'docker push my-golang-app'
}
}
}
}
```
```
А может нам лучше запускать сборку в gitlab ci. Только вот снова придется писать там еще один пайплайн. Попробуем попросить конвертировать Jenkins pipeline в gitlab ci, и через пару секунд у нас есть gitlab pipeline.
Ответ:
```
Для конвертации Jenkins pipeline в gitlab ci pipeline вы можете использовать следующий код:
```yaml
stages:
- build
- docker_build
- docker_push
build:
stage: build
script:
- go build -o main .
docker_build:
stage: docker_build
script:
- docker build -t my-golang-app .
docker_push:
stage: docker_push
script:
- docker push my-golang-app
```
```
И наконец попросим написать helm chart для деплоя в kubernetes.
Ответ:
```
Для создания helm-чарта для golang приложения вы можете использовать следующий код:
```yaml
apiVersion: v1
kind: Chart
metadata:
name: my-golang-app
version: 0.1.0
description: A Helm chart for my golang application
# Specify the chart's dependencies
dependencies:
- name: my-golang-app
version: 0.1.0
repository: "https://example.com/my-golang-app"
# Specify the values for the chart
values:
image:
repository: my-golang-app
tag: 0.1.0
service:
type: ClusterIP
port: 8080
# Specify the templates for the chart
templates:
- deployment.yaml
- service.yaml
```
Вы также можете использовать шаблоны для деплоя и сервиса, как показано ниже:
```yaml
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-golang-app
spec:
replicas: 1
selector:
matchLabels:
app: my-golang-app
template:
metadata:
labels:
app: my-golang-app
spec:
containers:
- name: my-golang-app
image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
ports:
- containerPort: 8080
# service.yaml
apiVersion: v1
kind: Service
metadata:
name: my-golang-app
spec:
type: {{ .Values.service.type }}
ports:
- port: {{ .Values.service.port }}
targetPort: 8080
selector:
app: my-golang-app
```
```
### Немного про образование
В классической системе образования основная задача состоит в получении знаний путем запоминания (заучивания). В современном мире это не так эффективно, получить необходимую информацию теперь можно очень быстро. Основная современная задача уметь анализировать и выбирать правильную информацию. Для этого развивайте творческое, логическое, креативное мышление. А все остальное, что можно автоматизировать, немедленн автоматизируйте!
### Вместо заключения
ChatGPT может использоваться для автоматизации некоторых задач, которые обычно выполняют DevOps-инженеры. Это позволит сэкономить время и ресурсы, которые иначе были бы потрачены на выполнение этих задач руками.
Это не замена инженеров, а инструмент чтобы быть продуктивнее. Пока что это точно не попытка уменьшить количество инженеров, просто инженеры теперь будут более эффективнее работать - смогут делать быстрее типовые задачи, а освободившиеся время использовать для по настоящему сложных и интересные задач.
**Внимание: статья написана с использованием AI** | https://habr.com/ru/post/714952/ | null | ru | null |
# Поиск текстов, не соответствующих тематике и нахождение похожих статей
У меня есть сайт со статьями схожей тематики. На сайте было две проблемы: спамерские сообщения и дубликаты статей, причём дубликаты часто являлись не точными копиями.
Данный пост повествует о том, как я решил эти проблемы.
Дано:
* общее количество статей 140 000;
* количество спама: примерно 16%;
* количество не чётких дубликатов: примерно 63%;
Задача: избавиться от спама и дубликатов, а так же не допустить их дальнейшего появления.
Часть 1. Классификация на спам/не спам
======================================
Все статьи на моём сайте относятся к одной и той же тематике и, как правило, спамерсие/рекламные сообщения прилично отличаются по содержанию. Я решил вручную отсортировать некоторое количество статей. И на их основе построить классификатор. Для классификации будем считать [косинусное расстояние](http://en.wikipedia.org/wiki/Cosine_similarity) между вектором проверяемой статьи и векторами двух групп (спам/не спам). К какой группе проверяемая статья ближе, к той и будем относить статью.
Сначала надо вручную классифицировать статьи. Набросал для этого форму с чекбоксами и собрал за несколько часов 650 статей спама и 2000 не спама.
Все посты очищаются от мусора – шумовых слов, которые не несут полезной нагрузки (причастия, междометия и пр). Для этого я собрал из разных словарей, которые нашёл в интернете, свой [словарь шумовых слов](https://github.com/shurik2533/erofeyPavlovich/blob/master/stop.txt).
Чтобы минимизировать количество различных форм одного слова, можно использовать [стеммиг Портера](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BC%D0%BC%D0%B5%D1%80_%D0%9F%D0%BE%D1%80%D1%82%D0%B5%D1%80%D0%B0). Я взял готовую реализацию на Java [отсюда](http://www.algorithmist.ru/2010/12/porter-stemmer-russian.html). Спасибо, [Edunov](http://habrahabr.ru/users/edunov/)
Из слов классифицированных статей, очищенных от шумовых слов и прогнанных через стемминг надо собрать словарь.
Из словаря удалим слова, которые встречаются только в одной статье.
Для каждой классифицированной вручную статьи считаем количество вхождений каждого слова из словаря. Получатся векторы, похожие на следующие:
Усиливаем в каждом векторе веса слов, считая для них [TF-IDF](http://en.wikipedia.org/wiki/Tf%E2%80%93idf). TF-IDF считается отдельно для каждой группы спам/не спам.
Сначала считаем TF (term frequency — частота слова) для каждой статьи. Это отношение количества вхождений конкретного слова к общему числу слов в статье:
где ni есть число вхождений слова в документ, а в знаменателе — общее число слов в данном документе.
Дальше считаем IDF (inverse document frequency — обратная частота документа). Инверсия частоты, с которой некоторое слово встречается в документах группы (спам/не спам). IDF уменьшает вес слов, которые часто употребляются в группе. Считается для каждой группы.
где
* |D| — количество документов в группе;
* di⊃ti — количество документов, в которых встречается ti (когда ni≠0).
Считаем TF-IDF:
Большой вес в TF-IDF получат слова с высокой частотой в пределах конкретного документа и с низкой частотой употреблений в других документах.
Для каждой группы формируем по одному вектору, считая среднее арифметическое каждого параметра внутри группы:
Чтобы проверить статью на спам, надо получить для нее количество вхождений слов из словаря. Посчитать для этих слов TF-IDF для спама и не спама. Получится два вектора (на изображении TF-IDF не спам и TF-IDF спам). IDF для расчётов, берём тот, который считали для классифицирующей выборки.
Для каждого вектора считаем косинусное расстояние с векторами для спама и не спама, соответственно. Косинусное расстояние – это мера похожести двух векторов. Скалярное произведение векторов и косинус угла θ между ними связаны следующим соотношением:
Имея два вектора A и B, получаем косинусное расстояние – cos(θ)
**Код на Java**
```
public static double cosine(double[] a, double[] b) {
double dotProd = 0;
double sqA = 0;
double sqB = 0;
for (int i = 0; i < a.length; i++) {
dotProd += a[i] * b[i];
sqA += a[i] * a[i];
sqB += b[i] * b[i];
}
return dotProd/(Math.sqrt(sqA)*Math.sqrt(sqB));
}
```
В результате получается диапазон от -1 до 1. -1 означает, что вектора полностью противоположны, 1, что они одинаковы.
Какое из полученных значений (для спама и не спама) будет ближе к 1, к той группе и будем относить статью.
При проверке схожести на не спам получилось число 0.87:
на спам – 0.62:
Следовательно, считаем, что статья – не спам.
Для тестирования я вручную отобрал ещё 700 записей. Точность результатов была 98%. При этом то, что классифицировалось ошибочно даже мне было сложно отнести к той или иной категории.
---
Часть 2. Поиск нечётких дубликатов
==================================
После очистки от спама осталось 118 000 статей.
Для поиска дубликатов я решил использовать инвертированный индекс ([Inverted index](http://en.wikipedia.org/wiki/Inverted_index)). Индекс представляет собой структуру данных, где для каждого слова указывается, в каких документах оно содержится. Соответственно, если у нас есть набор слов, можно легко сделать запрос документов, содержащих эти слова.
Пример с Вики. Допустим, у нас есть следующие документы:
```
T[0] = "it is what it is"
T[1] = "what is it"
T[2] = "it is a banana"
```
Для этих документов построим индекс, указав, в каком документе содержится слово:
```
"a": {2}
"banana": {2}
"is": {0, 1, 2}
"it": {0, 1, 2}
"what": {0, 1}
```
Все слова «what», «is» и «it» находятся в документах 0 и 1:
```
{0,1} ∩ {0,1,2} ∩ {0,1,2} = {0,1}
```
Индекс я сохранял в БД MySQL. Индексирование заняло около 2-х дней.
Для поиска похожих статей не надо, чтобы совпадали все слова, поэтому при запросе по индексу получаем все статьи, у которых совпало хотя бы 75% слов. В найденных содержатся похожие дубликаты, а так же другие статьи, которые включают в себя 75% слов изначальной, например, это могут быть очень длинные статьи.
Чтобы отсеять то, что дубликатом не является, надо посчитать косинусное расстояние между исходной и найденными. То, что совпадает больше, чем на 75% считаю дубликатом. Число в 75% выводил эмпирически. Оно позволяет находить достаточно изменённые версии одной и той же статьи.
**Пример найденных дубликатов:****Вариант 1:**
Чизкейк со сгущенкой (без выпечки)
Ингредиенты:
\* 450 гр Сметана от 20 % жирности
\* 300 гр печенья
\* 100 гр растопленного сливочного масла
\* 300 гр хорошего сгущенного молока
\* 10 гр быстрорастворимого желатина
\* 3/4 стакана холодной кипяченой воды
Приготовление:
Разборную форму выстелить пергаментной бумагой.
Размельченное в мелкую крошку печенье смешать с растопленным маслом. Смесь должна быть не жирной, но и не сухой. Выложить смесь в форму и хорошо уплотнить. Убрать в холодильник на 30 минут.
Сметану смешать со сгущенным молоком.
Желатин залить 3/4 стакана воды и поставить на 10 минут набухать. Затем растопить его на водяной бане так, чтобы он весь растворился.
В смесь сгущенки и сметаны осторожно влить желатин, тщательно помешивая. Перелить затем в форму. И убрать в холодильник до полного застывания примерно на 2-3 часа.
При застывании можно добавить ягоды свежей клюквы или посыпать тертым шоколадом или орехами.
Приятного аппетита!
**Вариант 2:**
«Чизкейк» без выпечки со сгущенкой
Ингредиенты:
-Сметана от 20 % жирности 450 гр
-300 гр печенья ( я брала овсяные)
-100 гр растопленного сливочного масла
-300 гр качественного сгущенного молока
-10 гр быстрорастворимого желатина
-3/4 стакана холодной кипяченой воды
Приготовление:
1). Форму (лучше разъёмную) застелить пергаментной бумагой.
2). Печенье измельчить в мелкую крошку и смешать с растопленным маслом. Масса не должна быть жирной, но и не слишком сухой. Уложить массу в форму и хорошо утрамбовать. Поставить в холодильник на полчаса.
3). Сметану смешать со сгущенным молоком (можно добавить больше или меньше сгущенки, это уже дело вкуса).
4) Желатин залить 3/4 стакана воды и оставить на 10 мин. набухать. Затем растопить его на водяной бане так, чтобы он полностью растворился.
5) В сметано-сгущенную массу потихоньку ввести желатин, хорошо помешивая. Перелить затем в форму. И отправить в холодильник до полного застывания. У меня застыл быстро. Где-то 2 часа.
Я при застывании добавила еще ягоды свежей клюквы — это придало пикантность и кислинку. Можно посыпать тертым шоколадом или орехами.
Полная чистка заняла около 5 часов.
Чтобы обновлять индекс для поиска дубликатов, не надо перестраивать уже существующие данные. Индекс достраивается инкрементально.
Из-за ограниченного количества оперативки на сервере у меня нет возможности держать индекс в памяти, поэтому я и держу его MySQL-е, где хранятся сами статьи. Проверка одной статьи, если не грузить всё в память, занимает у программы около 9 сек. Это долго, но т.к. новых статей в сутки появляется лишь несколько десятков, решил не заморачиваться со скоростью, пока этого не потребуется. | https://habr.com/ru/post/252265/ | null | ru | null |
# Доступ к контенту Modern-приложения на HTML\JS из Desktop-приложения под Windows 8
Иногда бывает нужно из одной программы добраться до содержимого другой программы. Ну, например, получить из неё какой-нибудь контент, или автоматизировать действия. В случае классических приложений Windows эта проблема решается весьма просто — находим родительское окно через [FindWindow](http://msdn.microsoft.com/en-us/library/windows/desktop/ms633499(v=vs.85).aspx), далее, зная его HWND, можем перечислить дочерние окна и элементы управления на них. А тут уже полная свобода — можем получить текст, написанный на этих элементах, изменить их размеры и положение, отправить сообщения для эмуляции клика мышью или набора текста с клавиатуры, даже удалить имеющиеся элементы и создать новые.
Но для Modern-приложений всё иначе. Давайте возьмём, к примеру, приложение «Погода» из стандартного набора Windows8. Допустим, мы открыли его в боковой панели и хотим как-то узнать из нашего обычного (Desktop) приложения, а какую же оно показывает температуру. Если посмотреть на окно «Погоды» с помощью Spy++ мы увидим родительское окно типа Windows.UI.Core.CoreWindow и вложенное в него окно Web Platform Embedding. А значит перед нами Modern-приложение написанное на HTML\Js и живущее внутри встроенного компонента браузера. То есть вышеописанные манипуляции с Windows-контролами не имеют смысла — их в этом окне попросту нет, поскольку всё его содержимое рендерится целиком.
Но давайте же всё-таки попробуем вытащить из него текущую температуру.
Начнём с того, что на MSDN, в его стиле, есть две статьи с противоположным содержанием — одна предостерегает нас от того, чтобы лазить руками в IE, встроенный в чужие компоненты, потому что это небезопасно и можно всё сломать (*«This function is designed for internal use by Active Accessibility and is documented for informational purposes only. Neither clients nor servers should call this function. Бла-бла-бла...»*). А вторая говорит, что всё ок, можно, и даже даёт код, как это сделать. Первая нам не интереса, а вторая — [KB 249232](http://support.microsoft.com/kb/q249232).
Правда, в ней есть ошибка — в вызове функции `ObjectFromLresult` они пытаются взять неверный интерфейс и в итоге ничего не работает. Но это вообще стиль MSDN, надо привыкать.
Итак, в чём же суть нашей затеи?
1. Находим окно верхнего уровня с заданным заголовком и классом («Weather» и «Windows.UI.Core.CoreWindow», соответственно).
2. Перечисляем его «детей», находим окно класса «Internet Explorer\_Server».
3. Отправляем этому окну сообщение WM\_HTML\_GETOBJECT, получаем в ответ указатель, который с помощь функции `ObjectFromLresult` может быть преобразован к указателю на интерфейс IHTMLDocument2.
4. Имея IHTMLDocument2 мы уже можем делать с документом всё, что угодно — получить его контент, изменить, сэмулировать «клик», выполнить Javascript.
Я практически был уверен, что где-то в районе пунктов 3-4 на пути встанет механизм безопасности Windows, отделяющий Modern-приложения друг от друга и от десктопных, и уже был готов применять что-то из средств, описанных мною в [прошлой статье](http://habrahabr.ru/company/infopulse/blog/186812/). Но… Этого не понадобилось. Несмотря на то, что приложение «Погода» работает вроде бы в песочнице, вроде бы с Low Integrity — мы спокойно можем отправлять ему сообщения, получать указатель на IHTMLDocument2, обмениваться с ним данными. Никаких барьеров безопасности преодолевать не пришлось — их просто нет.
Итог:
**Основной код**
```
#include "stdafx.h"
#include
#include
#include
#include
#include
#include "conio.h"
using namespace std;
BOOL CALLBACK EnumChildProc(HWND hwnd,LPARAM lParam)
{
TCHAR buf[100];
::GetClassName( hwnd, (LPTSTR)&buf, 100 );
if ( \_tcscmp( buf, \_T("Internet Explorer\_Server") ) == 0 )
{
\*(HWND\*)lParam = hwnd;
return FALSE;
}
else
return TRUE;
};
void GetDocInterface(HWND hWnd)
{
CoInitialize( NULL );
// Explicitly load MSAA so we know if it's installed
HINSTANCE hInst = ::LoadLibrary( \_T("OLEACC.DLL") );
if ( hInst != NULL )
{
if ( hWnd != NULL )
{
HWND hWndChild=NULL;
// Get 1st document window
::EnumChildWindows( hWnd, EnumChildProc, (LPARAM)&hWndChild );
if ( hWndChild )
{
CComPtr spDoc;
LRESULT lRes;
UINT nMsg = ::RegisterWindowMessage( \_T("WM\_HTML\_GETOBJECT") );
::SendMessageTimeout( hWndChild, nMsg, 0L, 0L, SMTO\_ABORTIFHUNG, 1000, (DWORD\*)&lRes );
LPFNOBJECTFROMLRESULT pfObjectFromLresult = (LPFNOBJECTFROMLRESULT)::GetProcAddress( hInst, "ObjectFromLresult" );
if ( pfObjectFromLresult != NULL )
{
HRESULT hr;
hr = (\*pfObjectFromLresult)( lRes, IID\_IHTMLDocument2, 0, (void\*\*)&spDoc );
if ( SUCCEEDED(hr) )
{
BSTR bstrContent = NULL;
IHTMLElement \*p = 0;
spDoc->get\_body(&p);
if (p)
{
p->get\_innerHTML( &bstrContent );
std::wstring ws(bstrContent, SysStringLen(bstrContent));
std::string s(ws.begin(), ws.end());
cout << s;
p->Release();
}
}
}
} // else document not ready
} // else Internet Explorer is not running
::FreeLibrary( hInst );
} // else Active Accessibility is not installed
CoUninitialize();
}
int \_tmain(int argc, \_TCHAR\* argv[])
{
wstring windowTitle, windowClass;
wcout << "Please enter parent window title (you can find it by Spy++):" << endl;
std::getline(std::wcin, windowTitle);
wcout << "Please enter parent window class (you can find it by Spy++):" << endl;
std::getline(std::wcin, windowClass);
HWND hwnd = FindWindow(windowClass.c\_str(), windowTitle.c\_str());
wcout << "HWND is " << hwnd << endl;
GetDocInterface(hwnd);
\_getch();
return 0;
}
```
[Весь проект на Github](https://github.com/ezhikus/StealFromMetro) | https://habr.com/ru/post/206656/ | null | ru | null |
# WebSocket: Реализация web-приложения с использованием Jetty Web Socket. Часть 1
Добрый день, Хабражитель!
Поздравляю всех и каждого с великим Днем Программиста! Желаю рабочего кода, уверенных сокетов и самых продвинутых пользователей!
Работая над автоматизацией концертного агентства, мне на каком-то этапе разработки понадобилась система уведомлений. Доступ к автоматизации происходит через написанное мною web-приложение. И, соответственно, моментальные уведомления должны приходить в браузер пользователя.
Для реализации такой задачи есть три решения:
* «бесконечный iframe»,
* используя XMLHttpRequest (a.k.a. Ajax),
* используя [WebSocket](http://dev.w3.org/html5/websockets/).
Первое решение я сразу «отметаю» (причины объяснять не буду, web-разработчики меня поймут).
Второе решение нравится гораздо больше, но у него есть свои минусы:
* браузер отправляет запрос каждую секунду создавая лишнюю нагрузку на:
+ сервер;
+ ОС, на которой работает браузер;
+ и еще раз на сервер, так как сервер постоянно выполняет запрос БД на выборку последних уведомлений.
* тяжело отследить онлайн-статус пользователя (то есть нужно, например, хранить сессии в БД и постоянно мониторить каждую на timeout).
Третье решение — как раз то, что доктор прописал.
Итак, WebSocket.
Среди минусов WebSocket важен только тот, что его пока поддерживают только браузеры webkit (они же Google Chrome и Apple Safari).
Давайте попробуем реализовать простой чат, как web-приложение c базовой возможностью полнодуплексного обмена сообщениями между клиентом и сервером.
##### Реализация клиентской части
Реализация WebSocket-ов на JavaScript на клиентской стороне простая, на неё не будем тратить много времени. Смотрим листинг.
```
var socket = new WebSocket("ws://myserver.com:8081/");
socket.onopen = function () {
console.log("Соединение открылось");
};
socket.onclose = function () {
console.log ("Соединение закрылось");
};
socket.onmessage = function (event) {
console.log ("Пришло сообщение с содержанием:", event.data);
};
```
Отправлять сообщения на сервер можно методом send():
`socket.send(messageString);`
##### Реализация серверной части
Реализация решения на сервере выглядит заметно сложнее. В сети можно найти несколько вариантов реализации, из них наиболее ближе ко мне были:
* [JWebSocket](http://www.jwebsocket.org/),
* [Jetty](http://www.eclipse.org/jetty/) WebSocket,
* [node.js](http://nodejs.org/) WebSocket.
Из них JWebSocket выделяется тем, что это большой фреймворк для работы с WebSocket, одновременно являющийся еще и надежным standalone-сервером. JWebSocket требует отдельного поста. А сейчас мы остановимся на самом простом варианте решения на платформе J2EE: Jetty.
Что мы имеем? Давайте взглянем на схему.
В моем случае мы имеем контейнер сервлетов GlassFish на порту 8080. Браузер отправляет запрос на GlassFish [1], который передает браузеру страничку чата [2], которая по желанию пользователя соединяется с сервером через порт 8081 по протоколу WebSocket [3]. Далее происходит полнодуплексный обмен данными между браузером и сервером [4].
На момент написания поста последняя версия Jetty 8.0.1.v20110908. Скачиваем, распаковываем (извиняюсь перед всеми разработчиками, использующих Maven), из дистрибутива нас интересуют 6 библиотек:
* jetty-continuation-8.0.1.v20110908.jar,
* jetty-http-8.0.1.v20110908.jar,
* jetty-io-8.0.1.v20110908.jar,
* jetty-server-8.0.1.v20110908.jar,
* jetty-util-8.0.1.v20110908.jar,
* jetty-websocket-8.0.1.v20110908.jar.
Добавляем эти библиотеки в проект.
Возвращаясь к клиентской части, скачиваем ее [отсюда](http://ipadzee.com/storage/chat.html.zip) (не хочу засорять пост листингом HTML-кода). Добавляем файл chat.html в Web Pages проекта. В дескрипторе развёртывания (web.xml) указываем chat.html как «welcome-file».
Теперь немного о Jetty.
Embedded-сервер Jetty находится в классе org.eclipse.jetty.server.Server. И конструктор может содержать либо адрес сервера, либо, как в нашем случае номер порта:
`Server jetty = new Server(8081);`
Далее нам нужно добавить в jetty нужные handlerы и запустить его. Запускается и останавливается jetty методами без параметров start() и stop() соответственно. А вот handler нам надо будет написать свой, создаем новый класс. Чтобы у нас был handler для обработки соединений по протоколу WebSocket, мы должны его наследовать от org.eclipse.jetty.websocket.WebSocketHandler:
`public class ChatWebSocketHandler extends WebSocketHandler {
…
}`
У класса WebSocketHandler есть один абстрактный метод doWebSocketConnect(). Он, собственно, и вызывается, когда браузер открывает новое соединение с jetty, и возвращает объект WebSocketа.
Класс WebSocket нам тоже следует определить свой, и наследовать мы его будем от интерфейса org.eclipse.jetty.websocket.WebSocket.OnTextMessage — этот интерфейс работает с данными, проходящими через протокол WebSocket, как с текстовыми данными. Интерфейс org.eclipse.jetty.websocket.WebSocket.OnTextMessage содержит три метода:
* onOpen() – вызывается после открытия сокета;
* onClose() – вызывается перед закрытием сокета;
* onMessage() – вызывается когда приходит сообщение от клиента.
Вроде бы, все просто! Давайте посмотрим на листинг ChatWebSocketHandler.
```
import java.io.IOException;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.servlet.http.HttpServletRequest;
import org.eclipse.jetty.websocket.WebSocket;
import org.eclipse.jetty.websocket.WebSocketHandler;
public class ChatWebSocketHandler extends WebSocketHandler {
/**
* Набор открытых сокетов
*/
private final Set webSockets = new CopyOnWriteArraySet();
/\*\*
\* Выполняется когда пытается открыться новое соединение
\* @param request
\* @param protocol протокол (бывает двух видов ws и wss)
\* @return
\*/
@Override
public WebSocket doWebSocketConnect(HttpServletRequest request,
String protocol) {
// У нас есть два варианта
// Либо мы не пускаем клиента и вызываем исключение
// throw new Exception();
// Либо возвращаем объект, который будет соединять сервер с клиентом
// и обрабатывать запросы от клиента
return new ChatWebSocket();
}
private class ChatWebSocket implements WebSocket.OnTextMessage {
/\*\*
\* Хранилище соединения
\*/
private Connection connection;
/\*\*
\* Ник пользователя
\*/
private String userName = null;
/\*\*
\* Шаблон входящей команды авторизации
\*/
private final Pattern authCmdPattern = Pattern.compile("^\\/auth ([\\S]+).\*");
/\*\*
\* Шаблон входящей команды получения списка пользователей
\*/
private final Pattern getUsersCmdPattern = Pattern.compile("^\\/getUsers.\*");
/\*\*
\* Шаблон входящей команды получения помощи
\*/
private final Pattern helpCmdPattern = Pattern.compile("^\\/help.\*");
/\*\*
\* Выполняется когда открыто новое соединение
\* @param connection
\*/
@Override
public void onOpen(Connection connection) {
// Сохраняем соединение в свойство ChatWebSocket::connection
this.connection = connection;
// Добавляем себя в глобальный набор ChatWebSocketHandler::webSockets
webSockets.add(this);
}
/\*\*
\* Выполняется когда пришло новое сообщение
\* @param data
\*/
@Override
public void onMessage(String data) {
// На всякий случай удаляем теговые дескрипторы
data = data.replaceAll("<", "<").replaceAll(">", ">");
// Если пришла команда авторизации
if (authCmdPattern.matcher(data).matches()) {
Matcher matcher = authCmdPattern.matcher(data);
matcher.find();
// Устанавливаем новый ник пользователю
userName = matcher.group(1);
try {
// Цикл шарит по набору сокетов ChatWebSocketHandler::webSockets
for (ChatWebSocket webSocket : webSockets) {
// и отправляет сообщение, что подключился новый пользователь
webSocket.connection.sendMessage("inf|"
+ (webSocket.equals(this)
? "Вы успешно авторизировались"
: ("В чат подключился **" + userName + "**")));
}
} catch (IOException x) {
// Все ошибки будут приводить к разъединению клиента от сервера
connection.disconnect();
}
// Если пришла команда получения списка пользователей
} else if (getUsersCmdPattern.matcher(data).matches()) {
String userList = "";
// Цикл шарит по набору сокетов ChatWebSocketHandler::webSockets
for (ChatWebSocket webSocket : webSockets) {
userList += webSocket.userName + ", ";
}
userList = userList.substring(0, userList.length() - 2);
try {
// Отсылаем список активных пользователей
connection.sendMessage("inf|Список активных пользователей: " + userList);
} catch (IOException x) {
// Все ошибки будут приводить к разъединению клиента от сервера
connection.disconnect();
}
// Если пришла команда получения помощи
} else if (helpCmdPattern.matcher(data).matches()) {
String helpMessage = "Отправлять сообщения можно просто написав "
+ "их в поле для ввода и нажать Enter.
"
+ "Чат поддерживает три команды:
"
+ "* **/help** - для распечатки этого сообщения
"
+ "* **/getUsers** - для получения списка пользователей
"
+ "* **/auth *ник*** - для авторизации
";
try {
// Отсылаем инструкцию
connection.sendMessage("inf|" + helpMessage);
} catch (IOException x) {
// Все ошибки будут приводить к разъединению клиента от сервера
connection.disconnect();
}
// Если пришла не команда а сообщение
} else {
try {
// Если пользователь не авторизирован
if (userName == null) {
connection.sendMessage("err|Вы не авторизированны
"
+ "Используйте команду **/help** для помощи");
return;
}
// Цикл шарит по набору сокетов ChatWebSocketHandler::webSockets
for (ChatWebSocket webSocket : webSockets) {
// и каждому рассылает сообщение с флагом in для всех
// кроме автора, автору - флаг out
webSocket.connection.sendMessage((webSocket.equals(this) ? "out|" : ("in|" + userName + "|")) + data);
}
} catch (IOException x) {
// Все ошибки будут приводить к разъединению клиента от сервера
connection.disconnect();
}
}
}
/\*\*
\* Выполняется когда клиент разъединяется от сервера
\* @param closeCode
\* @param message
\*/
@Override
public void onClose(int closeCode, String message) {
// Удаляем себя из глобального набора ChatWebSocketHandler::webSockets
webSockets.remove(this);
}
}
}
```
И так, что мы видим в ChatWebSocketHandler:
* 1 свойство – набор сокетов;
* 1 метод, который нам создает и возвращает новый сокет;
* 1 приватный класс, который реализует этот WebSocket.
В классе ChatWebSocket нас интересует метод onMessage(). В нем мы будем реализовывать протокол обмена данными клиентской и серверной части. По комментариям видно, принцип его работы.
Что из себя представляет протокол обмена?
Сервер принимает от клиента все текстовые сообщения, из них может выделить три команды:
* /auth ник //Для авторизации
* /getUsers //Для получения списка пользователей
* /help //Для получения помощи
Клиент принимает от сервера сообщения с такими шаблонами:
* inf|информация // Пришла информация
* in|ник|сообщение // Входящее сообщение от пользователя ник
* out|сообщение // Мое сообщение отправлено
* err|ошибка // Пришла информация об ошибке
Остальное не буду расписывать повторно, — все описано в комментариях.
Теперь перейдем к самому ответственному моменту — запуск сервера jetty. Значит, у нас задача: при старте контейнера сервлетов запустить jetty; перед остановкой контейнера сервлетов — остановить jetty. Самый простой способ это реализовать в GlassFish — написать свой ContextListener. Давайте посмотрим почему? Создаем новый класс и наследуем его от интерфейса javax.servlet.ServletContextListener. Смотрим листинг.
```
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.DefaultHandler;
public class ChatServerServletContextListener implements ServletContextListener {
/**
* Хранилище сервера Jetty
*/
private Server server = null;
/**
* Метод вызывается когда контейнер сервлетов запускается
* @param event
*/
@Override
public void contextInitialized(ServletContextEvent event) {
try {
// Создание сервера Jetty на 8081 порту
this.server = new Server(8081);
// Регистрируем ChatWebSocketHandler в сервере Jetty
ChatWebSocketHandler chatWebSocketHandler = new ChatWebSocketHandler();
// Это вариант хэндлера для WebSocketHandlerContainer
chatWebSocketHandler.setHandler(new DefaultHandler());
// Вставляем наш хэндлер слушаться jetty
server.setHandler(chatWebSocketHandler);
// Запускаем Jetty
server.start();
} catch (Throwable e) {
e.printStackTrace();
}
}
/**
* Метод вызывается когда контейнер сервлетов останавливается
* @param event
*/
@Override
public void contextDestroyed(ServletContextEvent event) {
// Если сервер jetty когда-нибудь запустился
if (server != null) {
try {
// останавливаем Jetty
server.stop();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
```
Интерфейс javax.servlet.ServletContextListener имеет два метода с говорящими самими за себя именами: contextInitialized(), contextDestroyed().
Теперь нам остается только подключить наш ContextListener в дескриптор развёртывания (web.xml). Приведу его листинг:
```
xml version="1.0" encoding="UTF-8"?
30
chat.html
ChatServerServletContextListener
```
Ну теперь можно и запустить проект. В браузере открываем сразу два окна и балуемся. Прошу обратить внимание на время, сообщения доходят практически моментально. Такую скорость работы на ajax получить практически невозможно.
##### Заключение
Весь проект в сборе можно скачать по [ссылке](http://ipadzee.com/storage/BasicChatWebApp.zip)
Проект полностью совместим с GlassFish 2.x, 3.x и Tomcat не ниже 5.0. Проект создавал в Netbeans 7.0.1. Внутри проекта можно найти ant-deploy.xml для развертки на Ant. Еще раз дико извиняюсь перед разработчиками, использующих Maven.
Во второй части статьи я подробно опишу проблемы, которые возникают при работе с WebSocket, и их решения.
В третьей части я опишу способы борьбы с ddos-атаками на серверы Jetty.
Спасибо за внимание. Всех еще раз с праздником! | https://habr.com/ru/post/128380/ | null | ru | null |
# Год приключений с graphene-python
Год приключений с graphene-python
=================================
Всем привет, я python-разработчик. Последний год я работал с graphene-python + django ORM и за это время я пытался создать какой-то инструмент, чтобы сделать работу с graphene удобнее. В результате у меня получилась небольшая кодовая база `graphene-framework` и набор некоторых правил, чем я бы и хотел поделиться.
Что такое graphene-python?
Если верить [graphene-python.org](https://graphene-python.org/), то:
> Graphene-Python — это библиотека для простого создания GraphQL APIs используя Python. Ее главная задача — предоставить простое, но в то же время расширяемое API, чтобы сделать жизнь программистов проще.
**Ее главная задача — предоставить простое, но в то же время расширяемое API, чтобы сделать жизнь программистов проще.**
Да, в действительности graphene простой и расширяемый, но, как мне кажется, слишком простой для больших и быстрорастущих приложений. Короткая документация (вместо нее я использовал исходных код — он намного более многословен), а также отсутствие стандартов написания кода делает эту библиотеку не лучшим выбором для вашего следующего API.
Как бы то ни было, я решил использовать ее в проекте и столкнулся с рядом проблем, к счастью, решив большую часть из них (спасибо богатым недокументированным возможностям graphene). Некоторые из моих решений чисто архитектурные и могут быть использованы "из коробки", без моего "фреймворка". Однако остальная их часть все же требует некоторой кодовой базы.
Эта статья — не документация, а в каком-то смысле короткое описание того пути, что я прошел и проблем, что я решил тем или иным способом с кратким обоснованием моего выбора. В этой части я уделил внимание мутациям и вещам, связанным с ними.
Цель написания статьи — получить **любую значимую обратную связь**, так что буду ждать критику в комментариях!
*Замечание: перед тем, как продолжить чтение статьи, настоятельно рекомендую ознакомиться с тем, что такое GraphQL.*
---
Мутации
-------
> Большая часть обсуждений о GraphQL сфокусирована на получении данных, однако любая уважающая себя платформа также требует способ изменять данные, хранящиеся на сервере.
Давайте начнем с мутаций.
Рассмотрим следующий код:
```
class UpdatePostMutation(graphene.Mutation):
class Arguments:
post_id = graphene.ID(required=True)
title = graphene.String(required=True)
content = graphene.String(required=True)
image_urls = graphene.List(graphene.String, required=False)
allow_comments = graphene.Boolean(required=True)
contact_email = graphene.String(required=True)
ok = graphene.Boolean(required=True)
errors = graphene.List(graphene.String, required=True)
def mutate(_, info, post_id, title, content, image_urls, allow_comments, contact_email):
errors = []
try:
post = get_post_by_id(post_id)
except PostNotFound:
return UpdatePostMutation(ok=False, errors=['post_not_found'])
if not info.context.user.is_authenticated:
errors.append('not_authenticated')
if len(title) < TITLE_MIN_LENGTH:
errors.append('title_too_short')
if not is_email(contact_email):
errors.append('contact_email_not_valid')
if post.owner != info.context.user:
errors.append('not_post_owner')
if Post.objects.filter(title=title).exists():
errors.append('title_already_taken')
if not errors:
post = Utils.update_post(post, title, content, image_urls, allow_comments, contact_email)
return UpdatePostMutation(ok=bool(errors), errors=errors)
```
`UpdatePostMutation` изменяет пост с заданным `id`, используя переданные данные и возвращает ошибки, если какие-то условия не соблюдены.
Стоит лишь взглянуть на этот код, как становится видна его нерасширяемость и неподдерживаемость из-за:
1. Слишком большое количество аргументов у функции `mutate`, число которых может увеличиться еще, если мы захотим добавить еще поля, подлежащие редактированию.
2. Чтобы мутации выглядели одинаково со стороны клиента, они должны возвращать `errors` и `ok`, чтобы всегда можно было понять их статус и чем он обусловлен.
3. Поиск и извлечение *объекта* в функции `mutate`. Функция мутация оперирует постом, а если его нет, то и мутация не должна происходить.
4. Проверка прав доступа в мутации. Мутация не должна происходить, если пользователь не имеет прав на это (редактировать некоторый пост).
5. Бесполезный первый аргумент (*корень*, который всегда `None` для полей верхнего уровня, чем и является наша мутация).
6. Непредсказуемый набор ошибок: если у вас нет исходного кода или документации, то вы не узнаете, какие ошибки может вернуть эта мутация, так как они не отражены в схеме.
7. Слишком много шаблонных проверок ошибок, которые проводятся непосредственно в методе `mutate`, который предполагает *изменение* данных, а не разнообразные проверки. Идеальный `mutate` должен состоять из одной строки — вызова функции редактирования поста.
Вкратце, **`mutate` должен изменять данные**, а не заботиться о таких сторонних задачах, как доступ к объектам и проверка входных данных. Наша цель прийти к чему-то вроде:
```
def mutate(post, info, input):
post = Utils.update_post(post, **input)
return UpdatePostMutation(post=post)
```
А теперь давайте разберем пункты выше.
---
### Пользовательские типы
Поле `email` передается как строка, в то время как это *строка определенного формата*. Каждый раз API принимает email, он должен проверять его корректность. Так что лучшим решением будет создать пользовательский тип.
```
class Email(graphene.String):
# ...
```
Это может выглядеть очевидным, однако стоило упоминания.
---
### Входные типы
Используйте входные типы для своих мутаций. Даже если они не подлежат переиспользованию в других местах. Благодаря входным типам запросы становятся меньше, следовательно их проще читать и быстрее писать.
```
class UpdatePostInput(graphene.InputObjectType):
title = graphene.String(required=True)
content = graphene.String(required=True)
image_urls = graphene.List(graphene.String, required=False)
allow_comments = graphene.Boolean(required=True)
contact_email = graphene.String(required=True)
```
До:
```
mutation(
$post_id: ID!,
$title: String!,
$content: String!,
$image_urls: String!,
$allow_comments: Boolean!,
$contact_email: Email!
) {
updatePost(
post_id: $post_id,
title: $title,
content: $content,
image_urls: $image_urls,
allow_comments: $allow_comments,
contact_email: $contact_email,
) {
ok
}
}
```
После:
```
mutation($id: ID!, $input: UpdatePostInput!) {
updatePost(id: $id, input: $input) {
ok
}
}
```
Код мутации изменяется на:
```
class UpdatePostMutation(graphene.Mutation):
class Arguments:
input = UpdatePostInput(required=True)
id = graphene.ID(required=True)
ok = graphene.Boolean(required=True)
errors = graphene.List(graphene.String, required=True)
def mutate(_, info, input, id):
# ...
if not errors:
post = Utils.update_post(post, **input.__dict__)
return UpdatePostMutation(errors=errors)
```
---
### Базовый класс мутаций
Как упомянуто в пункте №2, *мутации должны возвращать `errors` и `ok`, чтобы всегда можно было понять их статус и чем он обусловлен*. Это достаточно просто, мы создаем базовый класс:
```
class MutationPayload(graphene.ObjectType):
ok = graphene.Boolean(required=True)
errors = graphene.List(graphene.String, required=True)
query = graphene.Field('main.schema.Query', required=True)
def resolve_ok(self, info):
return len(self.errors or []) == 0
def resolve_errors(self, info):
return self.errors or []
def resolve_query(self, info):
return {}
```
Несколько замечаний:
* Реализован метод `resolve_ok`, так что нам не придется рассчитывать `ok` самим.
* Поле `query` — это корневой `Query`, который позволяет запрашивать данные прямо внутри запроса мутации (данные будут запрошены после выполнения мутации).
```
mutation($id: ID!, $input: PostUpdateInput!) {
updatePost(id: $id, input: $input) {
ok
query {
profile {
totalPosts
}
}
}
}
```
Это очень удобно, когда клиент обновляет некоторые данные после выполнения мутации и не хочет просить бекендера вернуть весь этот набор. Чем меньше кода вы пишете, тем проще его обслуживать. Эту идею я взял [отсюда](https://github.com/nodkz/conf-talks/tree/master/articles/graphql/schema-design#rule-6.6.3).
С базовым классом мутации код превращается в:
```
class UpdatePostMutation(MutationPayload, graphene.Mutation):
class Arguments:
input = UpdatePostInput(required=True)
id = graphene.ID(required=True)
def mutate(_, info, input, id):
# ...
```
---
### Корневые мутации
Наш запрос мутации сейчас выглядит так:
```
mutation($id: ID!, $input: PostUpdateInput!) {
updatePost(id: $id, input: $input) {
ok
}
}
```
Содержать все мутации в глобальной области видимости не лучшая практика. Вот несколько причин почему:
1. С ростом количества мутаций, все сложнее и сложнее становится найти ту мутацию, которая вам нужна.
2. Из-за одного пространства имен, необходимо включать в название мутации "название ее модуля", например `update`**`Post`**.
3. Необходимо передавать `id` в качестве аргумента мутации.
Я предлагаю использовать *корневые мутации*. Их цель решить эти проблемы посредством разделения мутаций в отдельные области видимости и освободить мутации от логики по доступу к объектам и правам доступа к ним.
Новый запрос выглядит так:
```
mutation($id: ID!, $input: PostUpdateInput!) {
post(id: $id) {
update(input: $input) {
ok
}
}
}
```
Аргументы запроса остаются прежними. Теперь функция изменения "вызывается" внутри `post`, что позволяет реализовать следующую логику:
1. Если `id` не передается в `post`, то он возвращает `{}`. Это позволяет продолжить выполнение мутаций внутри. Используется для мутаций, которые не требуют корневого элемента (например, для создания объектов).
2. Если `id` передается, происходит извлечение соответствующего элемента.
3. Если объект не найден, возвращается `None` и на этом выполнение запроса завершается, мутация не вызывается.
4. Если объект найден, то проверить права пользователя на манипуляции над ним.
5. Если у пользователя нет прав, возвращается `None` и на этом выполнение запроса завершается, мутация не вызывается.
6. Если у пользователя права есть, то возвращается найденный объект и мутация получает его в качестве корня — первого аргумента.
Таким образом, код мутации меняется на:
```
class UpdatePostMutation(MutationPayload, graphene.Mutation):
class Arguments:
input = UpdatePostInput()
def mutate(post, info, input):
if post is None:
return None
errors = []
if not info.context.user.is_authenticated:
errors.append('not_authenticated')
if len(title) < TITLE_MIN_LENGTH:
errors.append('title_too_short')
if Post.objects.filter(title=title).exists():
errors.append('title_already_taken')
if not errors:
post = Utils.update_post(post, **input.__dict__)
return UpdatePostMutation(errors=errors)
```
* Корень мутации — первый аргумент — теперь объект типа `Post`, над которым и производится мутация.
* Проверка прав доступа перенесена в код корневой мутации.
Код корневой мутации:
```
class PostMutationRoot(MutationRoot):
class Meta:
model = Post
has_permission = lambda post, user: post.owner == user
update = UpdatePostMutation.Field()
```
---
### Интерфейс ошибок
Чтобы сделать набор ошибок предсказуемым, они должны быть отражены в схеме.
* Так как мутации могут вернуть несколько ошибок, то ошибки должны быть быть списком
* Так как ошибки представлены разными типами, для конкретной мутации должен существовать свой `Union` ошибок.
* Чтобы ошибки оставались похожими друг на друга, они должны реализовывать интерфейс, назовем его `ErrorInterface`. Пусть он содержит два поля: `ok` и `message`.
Таким образом, ошибки должны иметь тип `[SomeMutationErrorsUnion]!`. Все подтипы `SomeMutationErrorsUnion` должны реализовывать `ErrorInterface`.
Получаем:
```
class NotAuthenticated(graphene.ObjectType):
message = graphene.String(required=True, default_value='not_authenticated')
class Meta:
interfaces = [ErrorInterface, ]
class TitleTooShort(graphene.ObjectType):
message = graphene.String(required=True, default_value='title_too_short')
class Meta:
interfaces = [ErrorInterface, ]
class TitleAlreadyTaken(graphene.ObjectType):
message = graphene.String(required=True, default_value='title_already_taken')
class Meta:
interfaces = [ErrorInterface, ]
class UpdatePostMutationErrors(graphene.Union):
class Meta:
types = [NotAuthenticated, TitleIsTooShort, TitleAlreadyTaken, ]
```
Выглядит неплохо, но слишком много кода. Используем метакласс, чтобы генерировать эти ошибки на лету:
```
class PostErrors(metaclass=ErrorMetaclass):
errors = [
'not_authenticated',
'title_too_short',
'title_already_taken',
]
class UpdatePostMutationErrors(graphene.Union):
class Meta:
types = [PostErrors.not_authenticated, PostErrors.title_too_short, PostErrors.title_already_taken, ]
```
Добавим объявление возвращаемых ошибок в мутацию:
```
class UpdatePostMutation(MutationPayload, graphene.Mutation):
class Arguments:
input = UpdatePostInput()
errors = graphene.List(UpdatePostMutationErrors, required=True)
def mutate(post, info, input):
# ...
```
---
### Проверка на наличие ошибок
Мне кажется, что метод `mutate` не должен заботиться о чем-либо, кроме *мутации данных*. Чтобы этого достичь, необходимо вынести проверку на наличие ошибок их кода этой функции.
Опуская реализацию, вот результат:
```
class UpdatePostMutation(DefaultMutation):
class Arguments:
input = UpdatePostInput()
class Meta:
root_required = True
authentication_required = True # Может быть опущено, так как равно True по умолчанию
# An iterable of tuples (error_class, checker)
checks = [
(
PostErrors.title_too_short,
lambda post, input: len(input.title) < TITLE_MIN_LENGTH
),
(
PostErrors.title_already_taken,
lambda post, input: Post.objects.filter(title=input.title).exists()
),
]
def mutate(post, info, input):
post = Utils.update_post(post, **input.__dict__)
return UpdatePostMutation()
```
Перед началом выполнения функции `mutate`, вызывается каждый *checker* (второй элемент членов массива `checks`). Если возвращено `True` — найдена соответствующая ошибка. Если ни одной ошибки не найдено, происходит вызов функции `mutate`.
Поясню:
* Функции-проверки принимают те же аргументы, что и функция `mutate`.
* Функции проверки должны вернуть `True`, если найдена ошибка.
* Проверки авторизации и наличия корневого элемента достаточно общие и вынесены в флаги `Meta`.
* `authentication_required` добавляет проверку авторизации если равно `True`.
* `root_required` добавляет "`root is not None`" проверку.
* `UpdatePostMutationErrors` больше не требуется. Юнион возможных ошибок создается на лету в зависимости от классов ошибок массива `checks`.
---
### Дженерики
`DefaultMutation`, использованная в прошлом разделе, добавляет `pre_mutate` метод, который позволяет изменить входные аргументы до проверки ошибок, и, соответственно, вызова мутации.
Также присутствует стартовый набор дженериков, которые делают код короче, а жизнь проще.
*Примечание: на данный момент код дженериков специфичен для django ORM*
#### CreateMutation
Требует один из параметров `model` или `create_function`. По умолчанию `create_function` выглядит так:
```
model._default_manager.create(**data, owner=user)
```
Это может выглядеть небезопасно, однако не забывайте о том, что есть встроенная проверка типов в graphql, а также проверки в мутации.
Также предоставляет `post_mutate` метод, который вызывается после `create_function` с аргументами `(instance_created, user)`, результат которой будет возвращен клиенту.
#### UpdateMutation
Позволяет задать `update_function`. По умолчанию:
```
def default_update_function(instance, user=None, **data):
instance.__dict__.update(data)
instance.save()
return instance
```
`root_required` равен `True` по умолчанию.
Также предоставляет `post_mutate` метод, который вызывается после `update_function` с аргументами `(instance_updated, user)`, результат которой будет возвращен клиенту.
И это то, что нам нужно!
Итоговый код:
```
class UpdatePostMutation(UpdateMutation):
class Arguments:
input = UpdatePostInput()
class Meta:
checks = [
(
PostErrors.title_too_short,
lambda post, input: len(input.title) < TITLE_MIN_LENGTH
),
(
PostErrors.title_already_taken,
lambda post, input: Post.objects.filter(title=input.title).exists()
),
]
```
#### DeleteMutation
Позволяет задать `delete_function`. По умолчанию:
```
def default_delete_function(instance, user=None, **data):
instance.delete()
```
---
### Заключение
В данной статье рассмотрен только один аспект, хоть на мой взгляд он и самый сложный. У меня есть некоторые мысли о резолверах и типах, а также общих вещах в graphene-python.
Мне сложно назвать себя опытным разработчиком, поэтому буду очень рад любой обратной связи, а также предложениям.
[Исходный код можно посмотреть здесь](https://github.com/Donnyyyyy/graphene-framework). | https://habr.com/ru/post/461939/ | null | ru | null |
# Используем Computer Vision для получения €6,147,455 за ночь во внутриигровой валюте
Последние 10 лет я играл в такие игры, как TownsMen 6, Clash of the Clans, SimCity и мою любимую OpenTTD (с открытым исходным кодом!).
Попробовав City Island 5, я был раздражен от того, что предметы не накапливались, пока я находился вне игры. У меня может быть самый лучший бизнес, стратегия и т.д., но я должен быть в игре, чтобы обеспечить сбор денег/ключей/золота с течением времени. Например, если моя пекарня зарабатывает 100 евро в минуту, я заработаю 100 евро только после того, как выйду из игры и вернусь через 24 часа.
Это стало особенно утомительным, когда я пытался накопить €5 000 000, необходимых для покупки острова, показанного ниже. Это займет у меня примерно две недели игры, если я не буду тратить деньги - оно того не стоит!
Создание скрипта Python для сбора ценностей для меня
----------------------------------------------------
Это проблема, которую можно решить с помощью машинного обучения.
**a. Захват фреймов игры**
Мне нужен был способ захвата фреймов игры в реальном времени.
Проще всего сделать снимок экрана в игре и передать его на следующие шаги сценария.
Для создания скриншота я использую библиотеку [Python MSS](https://paulonteri.com/thoughts/play-game-with-computer-vision#:~:text=I%20use%20the-,Python%20MSS,-library.%20It%27s%20a). Это простая библиотека, которая позволяет захватить экран и сохранить его в файл. Мы также можем использовать библиотеку для выбора монитора и получения его [свойств](https://python-mss.readthedocs.io/api.html#mss.tools.mss.base.MSSBase.monitors), таких как ширина и высота.
Мы будем использовать [OpenCv](https://docs.opencv.org/4.x/) (cv2) для части сценария, связанной с компьютерным зрением. Это библиотека, которая позволяет нам выполнять задачи обработки изображений и компьютерного зрения. Здесь мы используем метод *cv2.imread()* для загрузки изображения из указанного файла.
```
import cv2
import mss
sct = mss.mss()
default_monitor = sct.monitors[1]
def click_template_image(monitor=default_monitor):
# Screenshot
game_screenshot_path = "sct_{width}x{height}.png".format(**monitor)
sct_img = sct.grab((0, 0, monitor["width"], monitor["height"]))
mss.tools.to_png(sct_img.rgb, sct_img.size, output=game_screenshot_path)
game_screenshot = cv2.imread(game_screenshot_path, 1)
```
#### b. Распознаем ресурсы на скриншоте
Нам нужен способ обнаружить ресурсы игры и затем вернуть их координаты.
Алгоритмы OpenCv TemplateMatching идеально подходят для этого.
Они используются для поиска и определения местоположения шаблонного изображения (например, ценного предмета) в большом изображении (например, в фиде игры). OpenCV просто накладывает изображение шаблона на входное изображение (как в 2D-свертке) и сравнивает шаблон и участок входного изображения под изображением шаблона. В OpenCV реализовано несколько методов сравнения. (Более подробную информацию вы можете найти в [документации](https://docs.opencv.org/4.x/d4/dc6/tutorial_py_template_matching.html)). Мы используем его в методе: *cv2.matchTemplate(... ).*
Для достижения этой цели мне понадобились изображения шаблонов. Я сделал скриншоты вручную, а затем обрезал кеш, звезду и ключ:
В приведенном ниже примере кода мы распознаем кеш.
```
import cv2
import mss
import numpy as np
sct = mss.mss()
default_monitor = sct.monitors[1]
def click_template_image(monitor=default_monitor):
# 1. Screenshot
game_screenshot_path = "sct_{width}x{height}.png".format(**monitor)
sct_img = sct.grab((0, 0, monitor["width"], monitor["height"]))
mss.tools.to_png(sct_img.rgb, sct_img.size, output=game_screenshot_path)
game_screenshot = cv2.imread(game_screenshot_path, 1)
# 2. Find a way to identify the valuables in the screenshot
template_image = cv2.imread("images/cash.png", 1)
search_result = cv2.matchTemplate(game_screenshot, template_image, cv2.TM_CCOEFF_NORMED)
y_coords, x_coords = np.where(search_result >= threshold)
for idx in range(len(x_coords)):
x, y = x_coords[idx], y_coords[idx]
```
**c. Собираем ресурсы кликом**
Получив координаты элемента, мы должны кликнуть по нему.
Функция *pyautogui.click(x,y)* работает для этого замечательно. Она щелкает по экрану по координатам x,y. Подробнее о ней можно узнать [здесь](https://pyautogui.readthedocs.io/en/latest/mouse.html#mouse-clicks).
Примечание:
* Мы выбираем координаты, которые соответствуют определенному порогу доверия. Показатель уверенности - это число от 0 до 1, которое представляет собой вероятность того, что результат модели верен и удовлетворит запрос пользователя. Например, мы можем отобрать координаты, уровень доверия к которым составляет 0,7 или выше. Именно для этого мы и используем пороговую переменную. Алгоритм matchTemplate() дает нам несколько точек на карте, которые соответствуют нашему запросу. Затем я решил отфильтровать точки, которые находятся ниже порога: *y\_coords, x\_coords = np.where(search\_result >= threshold).*
* После нескольких проб я понял, что многократное нажатие на карту за один запуск алгоритма приводит к ошибкам и неточностям. Например, прежде чем щелкнуть на движущемся автомобиле, он мог немного сдвинуться с места. Я решил поэкспериментировать с количеством щелчков при каждом вызове функции *click\_template\_image()* с помощью переменной *number\_of\_clicks* и остановился на одном щелчке за шаг.
* Я обнаружил, что щелчок по центру изображения работает лучше, чем щелчок по левому верхнему краю, то есть по координатам, которые нам дала наша функция подбора шаблона. Мы можем использовать высоту и ширину изображения шаблона для вычисления координат центра: *x\_c = int((x + x + w) // 2) & y\_c = int((y + y + h) // 2)*
```
import cv2
import mss
import numpy as np
import pyautogui
pyautogui.FAILSAFE = False
sct = mss.mss()
default_monitor = sct.monitors[1]
def click_template_image(monitor=default_monitor, number_of_clicks=1, threshold=0.7):
# 1. Screenshot
game_screenshot_path = "sct_{width}x{height}.png".format(**monitor)
sct_img = sct.grab((0, 0, monitor["width"], monitor["height"]))
mss.tools.to_png(sct_img.rgb, sct_img.size, output=game_screenshot_path)
game_screenshot = cv2.imread(game_screenshot_path, 1)
# 2. Find a way to identify the valuables in the screenshot
template_image = cv2.imread("images/cash.png", 1)
search_result = cv2.matchTemplate(game_screenshot, template_image, cv2.TM_CCOEFF_NORMED)
y_coords, x_coords = np.where(search_result >= threshold)
# get the width and height of the template image
w, h = template_image.shape[1], template_image.shape[0]
for idx in range(number_of_clicks):
if idx + 1 > len(x_coords):
continue
x, y = x_coords[idx], y_coords[idx]
# 3. Collect the valuables by clicking on them
# get centres
x_c = int((x + x + w) // 2)
y_c = int((y + y + h) // 2)
pyautogui.click(x=x_c, y=y_c)
```
**d. Закрываем всплывающие окна**
Наши нажатия выше могут привести к появлению всплывающих окон, когда мы получаем награду, повышаем уровень и т.д.
Нам нужно закрыть окно, прежде чем снова попытаться собрать ценности. Мы используем ту же логику, что и при поиске и нажатии на ценные вещи.
Для этого мне понадобились шаблонные изображения для кнопок закрытия всплывающих окон, чтобы их можно было нажать. Я сделал скриншоты вручную, а затем обрезал различные кнопки закрытия:
Для закрытия я использовал тот же код, что выше.
Результаты после запуска на ночь
--------------------------------
Я начал игру с €316,415 в кармане.
На следующее утро у меня было €6,463,870.
И я смог купить тот остров, что я хотел
В заключение
------------
Вообще-то это называется использовать читы, но так ли это плохо в данном случае?
Полный код автора доступен по [ссылке](https://github.com/paulonteri/play-game-with-computer-vision).
Еще больше примеров использования ML в современных сервисах можно посмотреть в [**моем телеграм канале**](https://t.me/dat2art). Я пишу про ML, стартапы и релокацию в UK для IT специалистов. | https://habr.com/ru/post/708618/ | null | ru | null |
# Подробный обзор нововведений Silverlight 4
Эта статья содержит более подробное описание нововведений Silverlight 4, таких как:
* Печать из приложений
* Обработка нажатий правой кнопки мыши и движений колеса
* Работа с веб-камерой и микрофоном
* Работа с буфером обмена
* Особености trusted-приложений
* Взаимодействие с объектами COM
* и многое другое…
Для большинства приведены примеры кода и изображения.
#### Инструменты разработки
В Visual Studio 2010 появился полный визуальный конструктор интерфейсов Silverlight. Теперь вы сможете редактировать интерфейс для приложений на Silverlight версий 3 и 4. Реализована поддержка привязки данных.
Кроме того, в VS2010 для WCF RIA Services появился продвинутый редактор с поддержкой класса DomainSource в качестве Data Source.
А благодаря «multi-targeting», в VS2010 можно одновременно разрабатывать приложения на Silverlight версий 3 и 4.
**Видео:** [Поддержка RIA Services в Visual Studio 2010](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/RIA-Services-Support-Visual-Studio-2010)
#### Печать из Silverlight (Printing API)
Одной из наиболее запрашиваемых нововведений была поддержка печати на стороне клиента. В Silverlight 4 появился такой API.
Пример кода:
> `private void PrintAll\_Click(object sender, RoutedEventArgs e)
>
> {
>
> // инициализация нового PrintDocument
>
> PrintDocument docToPrint = new PrintDocument();
>
>
>
> // установка названия для отображения в очереди печати
>
> docToPrint.DocumentName = "Entire Screen Sample";
>
>
>
> // подготовка к печати
>
> docToPrint.StartPrint += (s, args) =>
>
> {
>
> ActivityDisplay.IsActive = true;
>
> };
>
>
>
> // установка объекта для печати
>
> docToPrint.PrintPage += (s, args) =>
>
> {
>
> args.PageVisual = this.StackOfStuff;
>
> };
>
>
>
> // завершение подготовки к печати
>
> docToPrint.EndPrint += (s, args) =>
>
> {
>
> ActivityDisplay.IsActive = false;
>
> };
>
>
>
> // зупуск печати
>
> docToPrint.Print();
>
> }`
Как видно выше, есть возможность добавления пре- и пост- кода для подготовки к печати. PrintPage это поле, в которое разработчик может установить элемент интерфейса, который необходимо напечатать. Это может быть уже существующий элемент визуального дерева или что-то созданное в виртуальной памяти.
**Видео и примеры кода:** [Printing API](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/Printing-API-Basics)
#### Обработка нажатия правой кнопки мыши
В приложении необходимо сделать контекстное меню? Теперь, в дополнение к событиям MouseLeftButtonUp/Dow, появились события MouseRightButtonUp/Down. Это позволяет разработчку настроить выполнение любого кода при нажатии кнопок мыши, будь это команда управления в игре или открытие контекстного меню.
Пример кода:
> `public partial class MainPage : UserControl
>
> {
>
> public MainPage()
>
> {
>
> InitializeComponent();
>
>
>
> // добавление выполнения функций при нажатии правой кнопки мыши
>
> ChangingRectangle.MouseRightButtonDown += new MouseButtonEventHandler(RectangleContextDown);
>
> ChangingRectangle.MouseRightButtonUp += new MouseButtonEventHandler(RectangleContextUp);
>
> }
>
>
>
> void RectangleContextUp(object sender, MouseButtonEventArgs e)
>
> {
>
> // создание контекстного меню и его показ
>
> ColorChangeContextMenu contextMenu = new ColorChangeContextMenu(ChangingRectangle);
>
> contextMenu.Show(e.GetPosition(LayoutRoot));
>
> }
>
>
>
> void RectangleContextDown(object sender, MouseButtonEventArgs e)
>
> {
>
> // по-умолчанию комнекстное меню должно быть скрыто
>
> e.Handled = true;
>
> }
>
> }`
Этот исходный код представляет собой заготовку для добавления контекстного меню в приложение на Silverlight 4. Результат будет выглядить так:
**Видео и примеры кода:** [Обработка нажатия правой кнопки мыши](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/Right-Click-Mouse-Events)
#### Доступ к веб-камере и микрофону
Нужен доступ к веб-камере и/или к микрофону? В Silverlight 4 это можно сделать. С помощью нескольких строк кода разработчик может запросить у пользователя разрешение на доступ к его устройству видео- или аудио- захвата.
Пример кода для запроса разрешения:
> `// запрос разрешения у пользователя и показ изображения
>
> if (CaptureDeviceConfiguration.AllowedDeviceAccess || CaptureDeviceConfiguration.RequestDeviceAccess())
>
> {
>
> \_captureSource.Start();
>
> }`
Пример кода для захвата изображения:
> `if (\_captureSource != null)
>
> {
>
> \_captureSource.Stop(); // остановка устройства захвата
>
>
>
> // установка устройств захвата
>
> \_captureSource.VideoCaptureDevice = (VideoCaptureDevice)VideoSources.SelectedItem;
>
> \_captureSource.AudioCaptureDevice = (AudioCaptureDevice)AudioSources.SelectedItem;
>
>
>
> // создание кисти
>
> VideoBrush vidBrush = new VideoBrush();
>
> vidBrush.SetSource(\_captureSource);
>
> WebcamCapture.Fill = vidBrush; // закраска области этой кистью =)
>
>
>
> // запрос разрешения у пользователя и показ изображения
>
> if (CaptureDeviceConfiguration.AllowedDeviceAccess || CaptureDeviceConfiguration.RequestDeviceAccess())
>
> {
>
> \_captureSource.Start();
>
> }
>
> }`
Также добавлен простой API для фотографирования с помощью веб-камеры:
> `private void TakeSnapshot\_Click(object sender, RoutedEventArgs e)
>
> {
>
> if (\_captureSource != null)
>
> {
>
> // захват текучего кадра и добавление его в коллекцию
>
> \_captureSource.AsyncCaptureImage((snapImage) =>
>
> {
>
> \_images.Add(snapImage);
>
> });
>
> }
>
> }`
Более подробно об этом на русском языке можно прочитать в статье на Хабре «[Работа с веб камерой и микрофоном в Silverlight 4](http://habrahabr.ru/blogs/silverlight/75744/)» Сергея Пугачева [WizardBox](https://habrahabr.ru/users/wizardbox/).
**Видео и примеры кода:** [Поддержка веб-камеры и микрофона](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/Access-Web-Camera-Microphone)
#### Поддержка колеса мыши
В предыдущих верисиях Silverlight для обработки событий колеса мыши нужно было использовать какие-либо вспомогательные классы, например от DeepZoom. В четвертой версии был добавлен соответствующий API.
Пример кода:
> `// привязка события
>
> myRectangle.MouseWheel += new MouseWheelEventHandler(RectangleZoom);
>
>
>
> void RectangleZoom(object sender, MouseWheelEventArgs e)
>
> {
>
> // какой-либо код
>
> }`
Как видно, можно легко привязать обработку события колеса мыши для конкретного элемента.
**Видео и примеры кода:** [Обработка событий колеса мыши](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/MouseWheel-API)
#### Элемент RichTextArea
Одним из запрашиваемых пользователями нововведением был элемент интерфейса с редактируемым богатым текстом (поддержка жирного, курсива, разных размеров, цветов и т.д.). Используя RichTextArea, теперь можно получить такой элемент.
Вот как может выглядеть RichTextArea:
**Видео и примеры кода:** [Элемент RichTextArea](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/RichTextArea)
#### API буфера обмена
В Silverlight 4 был добавлен простой API для работы с буфером обмена. Он работает на всех платформах, поддерживаемых Silverlight.
Пример кода:
> `Clipboard.SetText("Некоторый текст в буфере обмена");`
Этот код показывает возможность записи некоторого текста в буфер обмена операционной системы из приложения Silverlight.
Метод GetText() возвращает текст, содержащийся в буфере, а ContainsText() определяет, хранится ли в настоящий момент в буфере текст.
**Видео и примеры кода:** [Доступ к буферу обмена](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/Accessing-Global-Clipboard)
> `Clipboard.SetText("Некоторый текст в буфере обмена");`
#### Отображение HTML-документа с помощью элемента WebBrowser
Когда мы работаем в вебе, почти всегда приходится иметь дело с документами HTML. В Silverlight 4 стало возможным отображение HTML-документов в интерфейсе приложения. Для этого используется элемент WebBrowser, HTML-код в который можно загружать как из строковой переменной, так и из удаленной странице по URL.
Пример кода (XAML):
> `<WebBrowser x:Name="MyBrowserControl" Width="800" Height="600" />`
Пример кода (C#):
> `MyBrowserControl.NavigateToString("**Example HTML**");`
Вот изображение примера, где приложение Silverlight отображает HTML-документ с плеером YouTube на Flash:
Кроме того, можно использовать кисть HtmlBrush, чтобы заполнять произвольные элементы интерфейса.
**Видео и примеры кода:** [Отображение HTML-документов в Silverlight](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/Hosting-HTML-Content)
#### Доверенные приложения
Иногда для работы внебраузерного приложения Silverlight требуются повышенные права. В четвертой версии появилась возможность запросить повышенние прав. Это можно сделать в свойствах приложения в VS:
В результате этого при установки внебраузерного приложения появится предупреждение:
Следующие нововведения показывают возможность доверенных приложений.
#### Доступ к локальным файлам на клиентском компьютере
Для чтения/записи данных с компьютера пользователя обычно используются механизмы типа OpenFileDialog (для чтения) и SaveFileDialog (для записи). В Silverlight 4 появился прямой доступ к локальным файлам пользователя в «Моих»-папках. Это «Мои документы», «Мое видео», «Моя музыка» и т.д. В MacOS X это директории типа «/users/username/Videos».
Чтобы получить путь к файлам, нужно использовать пространство имен Environment.
Пример кода:
> `private void EnumerateFiles(object sender, RoutedEventArgs e)
>
> {
>
> // создание списка для имен файлов
>
> List<string> videosInFolder = new List<string>();
>
>
>
> // используя Directory API,
>
> // используя SpecialFolder API, получаем путь к папке "Мое видео"
>
> var videos = Directory.EnumerateFiles(Environment.GetFolderPath(Environment.SpecialFolder.MyVideos));
>
>
>
> // перечисляем файлы
>
> foreach (var item in videos)
>
> {
>
> videosInFolder.Add(item);
>
> }
>
>
>
> // привязываем данные
>
> VideoFileListing.ItemsSource = videosInFolder;
>
> }`
Требуются расширенные права (доверенное приложение).
**Видео и примеры кода:** [Доступ к локальным файлам](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/Local-File-Access)
#### COM взаимодействие
В приложении нужно сделать взаимодействие с переферийным устройством, которое предоставляет только COM-интерфейс? Или нужно работать с приложениями Office? Используя ComAutomationFactory API в приложении Silverlight 4, можно создавать и взаимодействовать с COM-объектами.
Пример кода (взаимодействие с Excel):
> `// создание экземпляра Excel
>
> dynamic excel = ComAutomationFactory.CreateObject("Excel.Application");
>
>
>
> excel.Visible = true; // включение его видимости для пользователя
>
>
>
> // добавление книги
>
> dynamic workbook = excel.workbooks;
>
> workbook.Add();
>
>
>
> dynamic sheet = excel.ActiveSheet; // получение активного листа`
Требуются расширенные права (доверенное приложение).
**Видео и примеры кода:** [Доступ к COM объектам в доверенных приложениях](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/COM-Object-Access-Trusted-Applications)
**API всплывающих уведомлений (Notification API)**
Нужен удобный механизм уведомлений пользователей? В Silverlight 4 появилась возможность показа всплывающих уведомлений рядом с треем.
Используя NotificationWindow в Silverlight, вы получите простой или настраиваемый механизм уведомлений для вашего приложения.
Пример кода:
> `private void CustomNotificationButton\_Click(object sender, RoutedEventArgs e)
>
> {
>
> // создание окна уведомления
>
> NotificationWindow notify = new NotificationWindow();
>
> notify.Height = 74;
>
> notify.Width = 329;
>
>
>
> // создание содержимого этого окна
>
> CustomNotification custom = new CustomNotification();
>
> custom.Header = "Sample Header";
>
> custom.Text = "Hey this is a better looking notification!";
>
> custom.Width = notify.Width;
>
> custom.Height = notify.Height;
>
>
>
> // установка этого содержимого
>
> notify.Content = custom;
>
>
>
> // показ уведомления
>
> notify.Show(4000);
>
> }`
Вот как может выглядеть элемент NotificationWindow:
Уведомления могут быть использованы только в приложениях вне браузера.
Более подробно об этом на русском языке можно почитать в статье на Хабре «[Silverlight 4: NotificationWindow](http://habrahabr.ru/blogs/silverlight/75727/)» [jeje](https://habrahabr.ru/users/jeje/).
**Видео и примеры кода:** [Notification Window API](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/Notification-API)
#### Аутентификация в веб-запросах
В Silverlight 4 есть возможность передавать NetworkCredential информацию, используя стек ClientHttp, который был представлен в Silverlight 3. Например, чтобы передать логин/пароль сервису, можно сделать так:
> `// NetworkCredential passing is available in ClientHttp networking stack
>
> WebRequest.RegisterPrefix("http://", System.Net.Browser.WebRequestCreator.ClientHttp);
>
>
>
> WebClient myService = new WebClient();
>
> myService.Credentials = new NetworkCredential("someusername", "somepassword");
>
> myService.UseDefaultCredentials = false; // Иначе будут использованы значения по-умолчанию
>
> myService.DownloadStringCompleted += new DownloadStringCompletedEventHandler(OnResultCompleted);
>
> myService.DownloadStringAsync(new Uri(http://somewebsite.com/authenticatedservice));`
**Видео и примеры кода:** [Аутентификация в веб-запросах](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/Network-Authentication-Trusted-Network-Access)
#### Изменения в кросс-доменной работе
Если ваше Silverlight 4 приложение работает в режиме повышенных привелегий (доверенное приложение), то для работы с веб-сервисами из другого домена вам больше не требуется использовать файлы «clientaccesspolicy.xml» или «crossdomain.xml».
**Видео и примеры кода:** [Кросс-доменные запросы в доверенных приложениях](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/Network-Authentication-Trusted-Network-Access)
#### Полный доступ к клавиатуре в режим full-screen
Если ваше приложение Silverlight работает в полном экране (IsFullScreen=”true”), вам был доступен лишь ограниченный ввод с клавиатуры. В доверенных приложениях на Silverlight 4 в режиме полного экрана полностью поддерживается ввод с клавиатуры для элементов типа TextBox и др.
Требуются расширенные права (доверенное приложение).
#### Обрезание текста
Элемент TextBlock имеет новое свойство, называемое TextTrimming, которое позволяет может быть установлено в значение WordElipse. Когда это сделано, любой текст, непомещающийся в ширину элемента, будет обрезан, а вместо его непоказанной части будет многоточие.
Пример кода:
> `<TextBlock HorizontalAlignment="Left" VerticalAlignment="Top"
>
> Text="The quick brown fox jumped over the tall white fence"
>
> TextTrimming="WordEllipsis" Width="120" />`
Выглядеть это будет так:
#### Поддержка написания справа-налево
Если в вашем приложении необходима поддержка написания справа-налево (RTL), вы можете использовать новый аттрибут элементов – FlowDirection.
Пример кода:
> `<StackPanel HorizontalAlignment="Center" VerticalAlignment="Center" x:Name="ControlSamples">
>
> <TextBlock FlowDirection="LeftToRight" Foreground="White" Text="BiDi and RTL Sample" FontSize="20" Margin="20" />
>
> <RichTextArea TextWrapping="Wrap" Width="600" Height="150">RichTextArea>
>
> <TextBlock FontSize="24" Foreground="White" Text="قفز الثعلب البني السريع فوق الكلب الكسول." />
>
> <ListBox>
>
> <ListBox.Items>
>
> <ListBoxItem Content="قفز الثعلب البني السريع فوق الكلب الكسول." />
>
> <ListBoxItem Content="Option 1" />
>
> <ListBoxItem Content="Option 2" />
>
> <ListBoxItem Content="Option 3" />
>
> <ListBoxItem Content="Option 4" />
>
> ListBox.Items>
>
> ListBox>
>
> StackPanel>`
Это наследуемое свойство.
**Видео и примеры кода:** [Поддержка двунаправленного текста и написания справа-налево](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/BiDi-Right-to-Left)
#### Использования приложения Silverlight в качестве контейнера для drag-n-drop
Иногда удобно просто перетащить файл на окно приложения, чтобы загрузить его. Вы сможете использовать этот сценарий, установив атрибут AllowDrop для какого-либо элемента интерфеса.
Пример кода:
> `public MainPage()
>
> {
>
> InitializeComponent();
>
> Loaded += new RoutedEventHandler(MainPage\_Loaded);
>
>
>
> // установка обработки событий перетаскиания
>
> InstallButton.Drop += new DragEventHandler(InstallButton\_Drop);
>
> InstallButton.DragOver += new DragEventHandler(InstallButton\_DragOver);
>
> InstallButton.DragEnter += new DragEventHandler(InstallButton\_DragEnter);
>
> InstallButton.DragLeave += new DragEventHandler(InstallButton\_DragLeave);
>
> }
>
>
>
>
>
> void InstallButton\_Drop(object sender, DragEventArgs e)
>
> {
>
> IDataObject foo = e.Data; // обработка данных
>
> }`
Это очень удобно использовать, например при загрузки файлов на сервер.
**Видео и примеры кода:** [Использования Silverlight в качестве контейнера для drag-n-drop](http://www.silverlight.net/learn/videos/Silverlight-4-Beta-Videos/Silverlight-Controls-Drop-Targets)
Ссылки на другие материалы и ресурсы по Silverlight 4 можно найти в статье на Хабре «[Silverlight 4 Beta уже доступна. Что внутри?](http://habrahabr.ru/blogs/silverlight/75735/)» Михаила Черномордикова [mixen](https://habrahabr.ru/users/mixen/).
Запись в моем блоге: [Oбзор нововведений Silverlight 4](http://tinyakov.net/post/Silverlight-4-бета.aspx) | https://habr.com/ru/post/75839/ | null | ru | null |
# Необязательные аргументы в функциях Go
В Go нет синтаксиса для определения необязательных аргументов в функциях, поэтому приходится использовать обходные пути. Я знаю 2:
1. Передавать структуру, содержащую все необязательные аргументы в полях:
```
funcStructOpts(Opts{p1: 1, p2: 2, p8: 8, p9: 9, p10: 10})
```
2. Способ предложенный Робом Пайком с использованием функциональных аргументов:
```
funcWithOpts(WithP1(1), WithP2(2), WithP8(8), WithP9(9), WithP10(10))
```
Второй способ в принципе делает тоже самое, но с синтаксическим сахаром. Мне не давала покоя мысль, а сколько же стоит этот сахар, кому ещё интересно прошу под кат.
Для тестов я использовал структуру с 10 опциями:
```
type Opts struct {
p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 int
}
```
и 2 пустые функции:
```
func funcStructOpts(o Opts) {
}
```
```
func funcWithOpts(opts ...OptsFunc) {
o := &Opts{}
for _, opt := range opts {
opt(o)
}
}
```
Для тех, кто не работал с функциональными аргументами немного расскажу как они работают. Каждая опция описывается в виде функции, которая возвращает функцию, которая изменяет структуру с параметрами, например:
```
func WithP1(v int) OptsFunc {
return func(opts *Opts) {
opts.p1 = v
}
}
```
где `OptsFunc` — это `type OptsFunc func(*Opts)`
При вызове функции их передают в качестве аргументов, а внутри функции в цикле заполняют структуру с аргументами:
```
o := &Opts{}
for _, opt := range opts {
opt(o)
}
```
Здесь магия и заканчивается, теперь у нас есть заполненная структура, осталось только выяснить, сколько стоит сахар. Для этого я написал простой benchmark:
```
func BenchmarkStructOpts(b *testing.B) {
for i := 0; i < b.N; i++ {
funcStructOpts(Opts{
p1: i,
p2: i + 2,
p3: i + 3,
p4: i + 4,
p5: i + 5,
p6: i + 6,
p7: i + 7,
p8: i + 8,
p9: i + 9,
p10: i + 10,
})
}
}
func BenchmarkWithOpts(b *testing.B) {
for i := 0; i < b.N; i++ {
funcWithOpts(WithP1(i), WithP2(i+2), WithP3(i+3), WithP4(i+4), WithP5(i+5), WithP6(i+6), WithP7(i+7),
WithP8(i+8), WithP9(i+9), WithP10(i+10))
}
}
```
Для тестирования я использовал Go 1.9 на Intel® Core(TM) i7-4700HQ CPU @ 2.40GHz.
Результаты:
`BenchmarkStructOpts-8 100000000 10.7 ns/op 0 B/op 0 allocs/op
BenchmarkWithOpts-8 3000000 399 ns/op 240 B/op 11 allocs/op`
Результаты противоречивые, с одной стороны разница почти в 40 раз, с другой — это сотни наносекунд.
Мне стало интересно, а на что же тратится время, ниже вывод pprof:
Всё логично, время тратится на выделение памяти под анонимные функции, а как известно `malloc` — это время, много времени…
Для чистоты эксперимента я проверил, что происходит при вызове без аргументов:
```
func BenchmarkEmptyStructOpts(b *testing.B) {
for i := 0; i < b.N; i++ {
funcStructOpts(Opts{})
}
}
func BenchmarkEmptyWithOpts(b *testing.B) {
for i := 0; i < b.N; i++ {
funcWithOpts()
}
}
```
Здесь разница немного меньше, примерно в 20 раз:
`BenchmarkEmptyStructOpts-8 1000000000 2.75 ns/op 0 B/op 0 allocs/op
BenchmarkEmptyWithOpts-8 30000000 57.0 ns/op 80 B/op 1 allocs/op`
#### Выводы
Для себя я так и не решил, что же лучше. Предлагаю похоливарить в комментариях, а для сбора статистики опрос ниже. | https://habr.com/ru/post/344352/ | null | ru | null |
# Реализация метода главных компонент на C#
Всем привет. На этой неделе в курсе по [машинному обучению](http://class.coursera.org/ml) профессор Andrew Ng рассказал слушателям про [метод главных компонент](http://ru.wikipedia.org/wiki/Метод_главных_компонент), с помощью которого можно уменьшить размерность пространства признаков ваших данных. Но к сожалению он не рассказал про метод вычисления собственных векторов и собственных чисел матрицы, просто сказал, что это сложно и посоветовал использовать матлаб/октавовскую функцию [U S V] = svd(a).
Для моего проекта мне понадобилась реализация этого метода на c#, чем я сегодня и занимался. Сам метод главных компонент очень элегантный и красивый, а если не понимать математику которая лежит за всем этим, то это можно это все назвать шаманством. Проблема вычисления собственных векторов матрицы в том, что не существует *быстрого* способа вычисления их точных значений, так что приходится выкручиваться. Я хочу рассказать об одном из таких способов выкрутиться, а так же приведу код на c# выполняющий эту процедуру. Прошу под кат.
Метод главных компонент (пока без кода)
=======================================
Часть первая: инициализация алгоритма. На вход алгоритму подается массив данных, а так же размерность пространства, до которой необходимо уменьшить данные.
1. Вычисляется [ковариационная матрица](http://ru.wikipedia.org/wiki/Ковариационная_матрица) (у этой матрицы есть замечательное свойство — она симметричная, это нам очень пригодится)
2. Вычисляются собственные вектора матрицы
3. Выбираются первые эн собственных векторов, где эн это та самая размерность, до которой нужно уменьшить размерность пространства признаков; выбранные векторы можно записать вертикально и собрать в матрицу 
Часть вторая: уменьшение размерности входного вектора. На вход подается вектор, размерности как и в массиве данных, использованном на шаге инициализации; на выходе вектор меньшей размерности (или проекция входного вектора на ортонормированный базис образованный выборкой из собственных векторов).
* Умножив скалярно входной вектор на все вектора из выборки собственных векторов, получается *уменьшенный* вектор: 
Часть третья: восстановление размерность вектора (конечно же с потерей информации). На вход подается вектор размерности равной той, до которой мы *уменьшали* векторы; на выходе вектор исходной размерности.
* Если транспонировать матрицу  то в ней окажется столько же строк как и размерность входного вектора на предыдущем шаге, а искомый вектор восстанавливается по формуле: 
Как видно вся вычислительная сложность находится в шаге инициализации при вычислении матрицы ковариации и собственных векторов. На вычислении ковариационной матрицы я не буду останавливаться, т.к. она вычисляется наивно по определению. Изучив несколько алгоритмов вычисления собственных векторов матрицы я остановился на итеративном методе QR декомпозиции. У него есть существенно ограничение, он выдает более менее точный результат только для симметричных матриц, но нам повезло :), матрица ковариации как раз именно такая. Вторым ограничение этого алгоритма является то, что матрица должна быть [полноранговой](http://ru.wikipedia.org/wiki/Ранг_матрицы).
QR декомпозиция
===============
Итеративный QR метод поиска собственных векторов, очевидно использует [QR разложение](http://ru.wikipedia.org/wiki/QR-разложение), так что для начала придется реализовать этот процесс. Для реализации этого процесса был выбран алгоритм [Грэма-Шмидта](http://ru.wikipedia.org/wiki/Процесс_Грама_―_Шмидта).
Для этого нам понадобится функция, которая вычисляет проекцию вектора **a** на вектор **b**: , где <> — обозначают скалярное произведение векторов.
```
public static double[] VectorProjection(double[] a, double[] b)
{
double k = ScalarVectorProduct(a, b)/ScalarVectorProduct(b, b);
return ScalarToVectorProduct(k, b);
}
```
Я не буду останавливаться на еще более простых функциях, типа ScalarVectorProduct, для того что бы размер кода в тексте не превысил критическую норму.
Итак собственно сама процедура QR разложения **IList DecompositionGS(double[][] a)** получает на вход матрицу, и выдает в ответ две матрицы:
1. первая содержит в своих колонках ортонормированный базис, такой что ;
2. вторая матрица будет [верхней треугольной](http://ru.wikipedia.org/wiki/Треугольная_матрица).
Первым делом мы разбиваем матрицу на столбцы и записываем их в список **av**:
```
List av = new List();
foreach (double[] vector in DecomposeMatrixToColumnVectors(a))
{
av.Add(vector);
}
```
Инициализируем два вспомогательных списка:
```
List u = new List();
u.Add(av[0]);
List e = new List();
e.Add(ScalarToVectorProduct(1 / NormOfVector(u[0]), u[0]));
```
Это те самые одноименные списки, использующиеся на схеме алгоритма:
После инициализации, первые **u** и **e** у нас вычислены, продолжаем в цикле вычислять последующие значения:
```
for (int i = 1; i < a.Length; i++)
{
double[] projAcc = new double[a.Length];
for (int j = 0; j < projAcc.Length; j++)
{
projAcc[j] = 0;
}
for (int j = 0; j < i; j++)
{
double[] proj = VectorProjection(av[i], e[j]);
for (int k = 0; k < projAcc.Length; k++)
{
projAcc[k] += proj[k];
}
}
double[] ui = new double[a.Length];
for (int j = 0; j < ui.Length; j++)
{
ui[j] = a[j][i] - projAcc[j];
}
u.Add(ui);
e.Add(ScalarToVectorProduct(1/NormOfVector(u[i]), u[i]));
}
```
И наконец формируем данные в выходном формате:
```
double[][] q = new double[a.Length][];
for (int i = 0; i < q.Length; i++)
{
q[i] = new double[a.Length];
for (int j = 0; j < q[i].Length; j++)
{
q[i][j] = e[j][i];
}
}
double[][] r = new double[a.Length][];
for (int i = 0; i < r.Length; i++)
{
r[i] = new double[a.Length];
for (int j = 0; j < r[i].Length; j++)
{
if (i >= j)
{
r[i][j] = ScalarVectorProduct(e[j], av[i]);
}
else {
r[i][j] = 0;
}
}
}
r = Transpose(r);
List res = new List();
res.Add(q);
res.Add(r);
return res;
```
Ура! Теперь для этого нужен тест:
```
[Test(Description = "Test of QRDecompositionGS")]
public void QRDecompositionGSTest()
{
double[][] a = new double[][]
{
new double[] {12, -51, 4},
new double[] {6, 167, -68},
new double[] {-4, 24, -41}
};
IList res = LinearAlgebra.QRDecompositionGS(a);
double[][] expQ = new double[][]
{
new double[] {6.0/7, -69.0/175, -58.0/175},
new double[] {3.0/7, 158.0/175, 6.0/175},
new double[] {-2.0/7, 6.0/35, -33.0/35}
};
double[][] expR = new double[][]
{
new double[] {14, 21, -14},
new double[] {0, 175, -70},
new double[] {0, 0, 35}
};
Assert.True(Helper.AreEqualMatrices(expQ, res[0], 0.0001), "expQ != Q");
Assert.True(Helper.AreEqualMatrices(expR, res[1], 0.0001), "expR != R");
}
```
Функция **Helper.AreEqualMatrices** сравнивает поэлементно матрицы с точностью до третьего параметра.
Итеративный QR метод
====================
Итеративный QR метод основан на замечательной теореме, суть которой в том, что если инициализировать матрицу А ноль как  и повторять следующий процесс бесконечно много раз:
1. 
2. 
а затем перемножить все полученные **Q**, то в результате получится матрица, в колонках которой будут собственные вектора исходной матрицы, значения которых будут тем точнее, чем дольше выполнялся процесс. Другими словами, при стремлении количества итераций к бесконечности, произведение  будет стремиться к точным значениям собственных векторов. В то же время последняя  будет на главной диагонали содержать собственные числа матрицы, приближенные конечно. Напоминаю что этот алгоритм более менее точно работает только для симметричных матриц.
Итак, метод QR итерации **IList EigenVectorValuesExtractionQRIterative(double[][] a, double accuracy, int maxIterations)** получает на вход по мимо самой матрицы, так же еще несколько параметров:
* **double accuracy** — точность которой мы хотим достичь, алгоритм остановится если изменения в значениях собственных векторов будут не более чем это значение;
* **int maxIterations** — максимальное количество итераций.
На выходе получаем две матрицы:
1. первая содержит в своих колонках собственные векторы матрицы **a**;
2. вторая матрица на своей главной диагонали содержит собственные значения матрицы **a**.
Итак начнем писать алгоритм, для начала создадим матрицы, которые будут содержать собственные векторы и собственные значения исходной матрицы:
```
double[][] aItr = a;
double[][] q = null;
```
И запустим цикл до остановки алгоритма:
```
for (int i = 0; i < maxIterations; i++)
{
IList qr = QRDecompositionGS(aItr);
aItr = MatricesProduct(qr[1], qr[0]);
if (q == null)
{
q = qr[0];
}
else {
double[][] qNew = MatricesProduct(q, qr[0]);
bool accuracyAcheived = true;
for (int n = 0; n < q.Length; n++)
{
for (int m = 0; m < q[n].Length; m++)
{
if (Math.Abs(Math.Abs(qNew[n][m]) - Math.Abs(q[n][m])) > accuracy)
{
accuracyAcheived = false;
break;
}
}
if (!accuracyAcheived)
{
break;
}
}
q = qNew;
if (accuracyAcheived)
{
break;
}
}
}
```
Сформируем выходные данные:
```
List res = new List();
res.Add(q);
res.Add(aItr);
return res;
```
И конечно же тест:
```
[Test(Description = "Test of Eigen vectors extraction")]
public void EigenVectorExtraction()
{
double[][] a = new double[][]
{
new double[] {1, 2, 4},
new double[] {2, 9, 8},
new double[] {4, 8, 2}
};
IList ev = LinearAlgebra.EigenVectorValuesExtractionQRIterative(a, 0.001, 1000);
double expEV00 = 15.2964;
double expEV11 = 4.3487;
double expEV22 = 1.0523;
Assert.AreEqual(expEV00, Math.Round(Math.Abs(ev[1][0][0]), 4));
Assert.AreEqual(expEV11, Math.Round(Math.Abs(ev[1][1][1]), 4));
Assert.AreEqual(expEV22, Math.Round(Math.Abs(ev[1][2][2]), 4));
}
```
Стоит отметить, что собственные векторы могут менять направление от итерации к итерации, что будет видно по смене знаков их координат, но очевидно, что это не существенно.
Реализация метода главных компонент
===================================
Теперь все готово для имплементации сабжа статьи.
Скрытым параметром модели (класса) будет являться некоторое подмножество собственных векторов матрицы ковариации от исходных данных:
```
private IList \_eigenVectors = null;
```
Конструктор принимает на вход массив данных и размерность, до которой следует уменьшить пространство признаков, а так же параметры для QR декомпозиции. Внутри вычисляется матрица ковариации и берутся первые несколько собственных векторов. Вообще существует способ выбрать оптимальное количество собственных векторов для нужного параметра потери информации, т.е. до какой размерности можно уменьшить пространство, потеряв при этом не более фиксированного процента информации, но я этот шаг опускаю, про него можно послушать в лекции Andrew Ng на сайте курса.
```
internal DimensionalityReductionPCA(IList dataSet, double accuracyQR, int maxIterationQR, int componentsNumber)
{
double[][] cov = BasicStatFunctions.CovarianceMatrixOfData(dataSet);
IList eigen = LinearAlgebra.EigenVectorValuesExtractionQRIterative(cov, accuracyQR, maxIterationQR);
IList eigenVectors = LinearAlgebra.DecomposeMatrixToColumnVectors(eigen[0]);
if (componentsNumber > eigenVectors.Count)
{
throw new ArgumentException("componentsNumber > eigenVectors.Count");
}
\_eigenVectors = new List();
for (int i = 0; i < componentsNumber; i++)
{
\_eigenVectors.Add(eigenVectors[i]);
}
}
```
Затем реализуем прямое и обратное преобразование по формулам из начала статьи.
```
public double[] Transform(double[] dataItem)
{
if (_eigenVectors[0].Length != dataItem.Length)
{
throw new ArgumentException("_eigenVectors[0].Length != dataItem.Length");
}
double[] res = new double[_eigenVectors.Count];
for (int i = 0; i < _eigenVectors.Count; i++)
{
res[i] = 0;
for (int j = 0; j < dataItem.Length; j++)
{
res[i] += _eigenVectors[i][j]*dataItem[j];
}
}
return res;
}
public double[] Reconstruct(double[] transformedDataItem)
{
if (_eigenVectors.Count != transformedDataItem.Length)
{
throw new ArgumentException("_eigenVectors.Count != transformedDataItem.Length");
}
double[] res = new double[_eigenVectors[0].Length];
for (int i = 0; i < res.Length; i++)
{
res[i] = 0;
for (int j = 0; j < _eigenVectors.Count; j++)
{
res[i] += _eigenVectors[j][i]*transformedDataItem[j];
}
}
return res;
}
```
Тестирование
============
Для тестирования придумаем небольшой массив данных, и проверяя на матлабе значения (используя код из домашки по PCA =), напишем класс для тестирования:
```
[TestFixture(Description = "Test of DimensionalityReductionPCA")]
public class DimensionalityReductionPCATest
{
private IList \_data = null;
private IDataTransformation \_transformation = null;
private double[] \_v = null;
[SetUp]
public void SetUp()
{
\_v = new double[] { 1, 0, 3 };
\_data = new List()
{
new double[] {1, 2, 23},
new double[] {-3, 17, 5},
new double[] {13, -6, 7},
new double[] {7, 8, -9}
};
\_transformation = new DimensionalityReductionPCA(\_data, 0.0001, 1000, 2);
}
[Test(Description = "Test of DimensionalityReductionPCA transform")]
public void DimensionalityReductionPCATransformTest()
{
double[] reduced = \_transformation.Transform(\_v);
double[] expReduced = new double[] {-2.75008, 0.19959};
Assert.IsTrue(Helper.AreEqualVectors(expReduced, reduced, 0.001));
double[] reconstructed = \_transformation.Reconstruct(reduced);
double[] expReconstructed = new double[] {-0.21218, -0.87852, 2.60499};
Assert.IsTrue(Helper.AreEqualVectors(expReconstructed, reconstructed, 0.001));
}
```
Ссылки
======
* курс по [machine learning](http://class.coursera.org/ml)
* статья в которой описан [итеративный QR метод](http://mathreview.uwaterloo.ca/archive/voli/1/panju.pdf)
* куча ссылок на википедию в тексте статьи | https://habr.com/ru/post/146236/ | null | ru | null |
# Шифруем передаваемые на сайт данные с алгоритмом на основе хаотической системы Лоренца
Привет! Меня зовут Михаил, работаю в компании DataLine сетевым инженером. По специальности я радиофизик, но со школьной скамьи интересуюсь криптографией.
В этом году научная работа в университете помогла совместить два этих интереса. Я посвятил свое исследование применению [теории хаоса](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B8%D1%8F_%D1%85%D0%B0%D0%BE%D1%81%D0%B0) и задался вопросом: как физические хаотические системы могут помочь в решении задач классической криптографии и спроектировать сильный шифровальный алгоритм.
За основу взял систему дифференциальных уравнений Лоренца и написал новый алгоритм шифрования на njs – на практике это можно применить, например, для шифрования данных на веб-сервере. В посте расскажу, почему Лоренц, почему njs, какие есть варианты реализации и ограничения у выбранного решения.
Немного теории: какие задачи криптозащиты данных мы решали
----------------------------------------------------------
**В чем проблема**. Для надежной защиты данных нам необходимы алгоритмы, которые обеспечат конфиденциальность, целостность информации, а также ее доступность для доверенной стороны при дешифровке. В современной классике криптографии для соблюдения этих условий часто используются алгоритмы несимметричного шифрования на основе открытого и закрытого ключа. Их применение регулируется на законодательном уровне: средства шифрования проходят государственную сертификацию, например, в России – ФСТЭК и ФСБ.
Но даже если алгоритм несимметричного шифрования признан криптостойким по всем нормам, вероятность его взлома никогда не равна нулю. Успешность взлома во многом зависит от вычислительных мощностей: если у хакера есть достаточные ресурсы для перебора всех вариантов ключа, он сможет его подобрать. Сейчас на практике этот риск не столь высок, но с распространением квантовых вычислений может стать реальной проблемой. Более подробно об этой трудности уже много писали на Хабре, например, наши коллеги переводили одно из последних исследований [вот тут](https://habr.com/ru/company/dataline/blog/591379/).
**Чем поможет хаос**. Теория хаоса не раз привлекала исследователей как возможное решение проблемы криптостойкости алгоритма. Этому способствуют отличия хаотических систем от классических криптографических:
* Если криптография изучает результат конечного числа итерационных преобразований, то в теории хаоса рассматривается асимптотическое поведение системы, или бесконечное пространство.
Другими словами, количество криптографических состояний ограничено и конечно, а пространство состояний хаоса – это бесконечное множество непрерывных и дискретных значений.
* При этом в теории хаоса существуют динамические законы, которые, по известной предыстории, позволяют однозначно определить эволюцию системы во времени.
То есть, в отличие от конечных и линейных вычислений в рамках классической криптографической системы, хаос изменяется постоянно и по более сложным законам. Поэтому несколько принципов теории хаоса можно использовать для защиты информации:
* **Высокую чувствительность к начальным условиям**. Начальное состояние системы в теории хаоса – это практически аналогия открытому тексту в криптографии. Чувствительность хаотической системы к изменениям начальных условий можно сопоставить с чувствительностью криптосистем к открытому тексту и ключу.
* **Асимптотическую независимость начального и конечного состояния.** Это понятие теории хаоса, близкое «запутыванию» в криптографии.
* **Синхронизацию хаотических ошибок**. У двух хаотических систем есть способность синхронизироваться друг с другом. Из этого есть интересное следствие: после синхронизации дальнейшее развитие систем во времени будет происходить одинаково, но лишь при одинаковых начальных условиях. Возможность синхронизации можно использовать в процессе дешифровки.
* **Стойкость траектории, или асимптотическую устойчивость**. Это свойство возникает вследствие синхронизации и проявляется в том, что любые небольшие колебания, которые могут нарушить синхронизацию, быстро затухают. По итогу синхронное колебание остается практически без изменений, то есть устойчивым к небольшим помехам.
* **Топологическую транзитивность.** Она свойственна и динамическим, и криптографическим системам. С точки зрения криптографии, топологическая транзитивность необходима для сохранения состояния криптосистемы в тех пределах, которые допускает носитель информации.
Вот эти аналогии чуть нагляднее:
| | |
| --- | --- |
| **Криптографические объекты** | **Состояния хаотической системы** |
| Открытый текст | Начальное состояние системы и исходное сообщение |
| Зашифрованный текст | Заключительное состояние системы |
| Ключ | Начальные условия с параметрами |
| Запутывание | Асимптотическая независимость начального и конечного состояния |
Исходя из этого я увидел реальные возможности применить хаотическую систему в проектировании криптографической системы.
**Что конкретно взял в работу**. В первичном эксперименте я хотел проверить теорию, что хаотические системы подходят для использования в алгоритмах шифрования. Для проверки гипотезы остановился на системе дифференциальных уравнений Лоренца – самой простой из многообразия хаотических систем.
Система Лоренца описывается тремя уравнениями:
где `x, y, z` – безразмерные переменные, `а β, ρ и σ` – параметры, при определенных значениях которых в системе наблюдается хаотический режим `(β=8/3,σ=10 и ρ=28)`.
Для того чтобы использовать эту систему при создании алгоритма, я выбрал метод хаотической маскировки. Вот его схема:
Отправитель с помощью передающего устройства подмешивает исходное сообщение `m(t)` к несущему хаотическому сигналу `x(t)`. Плюсом на схеме обозначен сумматор – он создает смесь сигналов CS, которая передается дальше.
Сигнал проходит канал связи и попадает на принимающее устройство получателя, где генератор хаотического сигнала `u(t)` с помощью пришедшей смеси сигналов CS синхронизируется с генератором отправителя. Минусом на схеме обозначено вычитающее устройство, которое восстанавливает исходное сообщение: оно равно разности принятой смеси CS сигналов и синхронного отклика `u(t)`.
Практика: как реализовали модуль Nginx для шифрования
-----------------------------------------------------
Изначально метод хаотической маскировки был востребован для создания устройств связи. Глядя на схему, можно представить себе аппаратную реализацию: берем устройство типа роутера и добавляем к нему генератор, который подмешивает шум к основному сигналу. В результате получаем зашифрованные радиоволны, которые для недоверенных устройств выглядят просто как шум.
У аппаратного варианта есть свои нюансы – если на сигнал будут действовать реальные шумы, возможны проблемы с дешифровкой. Но я в своей работе решил сосредоточиться на программной реализации – для шифрования данных при отправке к серверу или от сервера. Таких практических примеров в доступных мне исследованиях не встречалось, а потенциал для применения тут огромный.
Так что на основе предложенной схемы попробуем создать алгоритм для шифрования на стороне веб-сервера. Для начала определимся, какое ПО и язык программирования подойдут для этой задачи.
**Почему Nginx.**Это довольно популярное решение, которое обслуживает серверы многих высоконагруженных сайтов. Nginx используется для создания HTTP-сервера, обратного прокси-сервера, почтового прокси-сервера и TCP/UDP прокси-сервера общего назначения.
Основные функции веб-сервера в нем ложатся на модули трех типов:
* обработчик – обрабатывает запрос и генерирует ответ;
* фильтр – обрабатывает результаты обработчика;
* балансировщик – выбирают какому бэкенду передать запрос, если бэкендов несколько.
Ядро Nginx берет на себя работу с сетью и реализацию протоколов, а также запускает необходимые для обработки запроса модули. За счет этого у нас есть возможность создавать отдельные компоненты для выполнения конкретных функций и реализовывать децентрализованную архитектуру. При этом обработку запросов в Nginx можно настраивать как угодно – у разработчика есть возможность определить, когда и как должен запускаться нужный модуль. При грамотном использовании это дает гибкость в распределении ресурсов и хороший потенциал для масштабирования.
Для нашей задачи архитектурные особенности Nginx тоже подходят – можем создать отдельный модуль шифрования с использованием нужного алгоритма.
**Почему njs.** Модуль njs был создан специально под сервер Nginx для написания гибких решений на популярном JavaScript. Модуль очень скоростной благодаря следующим особенностям:
* Компиляция кода происходит сразу после старта Nginx, что экономит память и CPU
* Для каждого запроса создается копия виртуальной машины: многие объекты можно использовать повторно.
* Отсутствует сборка мусора: виртуальные микромашины обрабатывают короткоживущие запросы, поэтому не создают много временных объектов. Опять же, экономим память и CPU.
**Как выглядят выбранные алгоритмы шифрования/дешифрования в модуле Nginx.** При реализации было важно выбрать конкретный метод решения системы дифференциальных уравнений. Наиболее точный и производительный в рамках компьютерных вычислений – [метод Рунге-Кутта](https://habr.com/ru/post/418139/).
В цикле преобразования данных с использованием этого метода в качестве параметра интегрирования выступает константа `DELTA_TIME_STEP`. Она определена в начале кода и равна 100. Где это используется, покажу ниже.
```
const DELTA_TIME_STEP = 100;
const MAX_CHAR_CODE = 65535;
```
Архитектура алгоритма выглядит следующим образом: сначала задается система дифференциальных уравнений Лоренца с фиксированными параметрами, при которых наблюдается хаотический характер системы.
```
/**
* Первое уравнение системы Лоренца
*
* @param {Number} t - время
* @param {Number} x – координата по оси X
* @param {Number} y – координата по оси Y
* @param {Number} z – координата по оси Z
* @param {Number} U – сигнал сообщения
* @returns value of function
*/
function fX(t, x, y, z, U) {
return 10 * (U - x);
}
/**
* Второе уравнение системы Лоренца
*
* @param {Number} t - время
* @param {Number} x – координата на оси X
* @param {Number} y – координата на оси Y
* @param {Number} z – координата на оси Z
* @returns value of function
*/
function fY(t, x, y, z) {
return 28 * x - y - x * z;
}
/**
* Третье уравнение системы Лоренца
* @param {Number} t - время
* @param {Number} x – координата на оси X
* @param {Number} y – координата на оси Y
* @param {Number} z – координата на оси Z
* @returns value of function
*/
function fZ(t, x, y, z) {
return -(8/3) * z + x * y;
}
```
Наши алгоритмы шифрования и расшифровывания обрабатывают наборы символов. Поэтому сначала мы объявляем функцию `stringToCharCodes(data)`, которая принимает в качестве аргумента данные типа «строка» и возвращает массив символов.
Для обратного процесса функция `charCodesToString(data)` принимает символьный массив и возвращает данным исходный вид строки.
```
/**
* Преобразует формат строки в коды символов
*
* @param {String} data
* @returns array of char codes
*/
function stringToCharCodes(data) {
const outputNumbersArray = [];
for (let i = 0; i < data.length; i++) {
outputNumbersArray.push(data.charCodeAt(i) / MAX_CHAR_CODE);
}
return outputNumbersArray;
}
/**
* Преобразование кодов символов в формат строки
*
* @param {Массив чисел} данные
* @ возвращает строку из массива кодов символов
*/
function charCodesToString(data) {
const outputString = '';
for (let i = 0; i < data.length; i++) {
outputString += String.fromCharCode(data[i] * MAX_CHAR_CODE);
}
return outputString;
}
```
Затем в дело вступает функция `encodeMesage(dataString)`. Она принимает в качестве аргумента данные типа «строка» и выполняет их шифрование. В начале функции вызывается уже упомянутая `stringToCharCodes(data)` для получения нужного формата данных и определяются переменные, используемые в процессе шифрования.
После этого определяем основной цикл преобразования данных с использованием метода Рунге-Кутта. Здесь нам и пригодится константа `DELTA_TIME_STEP` в качестве параметра интегрирования.
Цикл будет работать до тех пор, пока не обработает каждый символ поступающих данных. В ходе каждой итерации, согласно выбранному методу интегрирования, пошагово вычисляются все решения системы дифференциальных уравнений Лоренца для четырех начальных условий. На выходе получается массив символов зашифрованных данных.
Для выполнения обратного преобразования используется функция `decodeMesage(data)`– она принимает в качестве аргумента данные типа «строка». Операции над данными в процессе расшифровки практически идентичны тем, что выполнялись при шифровании. Отличие – в выражениях для шифрованного и расшифрованного символов. Функция возвращает массив символов расшифрованного сообщения, которое можно преобразовать в строку с помощью функции `charCodesToString(data).`
```
/**
* Дешифровщик на основе хаотической системы уравнений
* Решение уравнений с использованием метода Рунге-Кутта
*
* @param {String} dataString a message
* @returns string of decoded message
*/
function decodeMessage(dataString) { let t = 0;
let x = 0.1;
let y = 0;
let z = 0;
let S = 0;
const charCodes = stringToCharCodes(dataString);
const output = [];
for (i = 0; i < charCodes.length; i++) {
S = charCodes[i] - y;
k1 = DELTA_TIME_STEP * fX(t, x, y, z, charCodes[i]);
m1 = DELTA_TIME_STEP * fY(t, x, y, z);
r1 = DELTA_TIME_STEP * fZ(t, x, y, z);
k2 = DELTA_TIME_STEP * fX(t + DELTA_TIME_STEP / 2, x + k1 / 2, y + m1
/ 2, z + r1 / 2, charCodes[i]);
m2 = DELTA_TIME_STEP * fY(t + DELTA_TIME_STEP / 2, x + k1 / 2, y +
m1 / 2, z + r1 / 2);
r2 = DELTA_TIME_STEP * fZ(t + DELTA_TIME_STEP / 2, x + k1 / 2, y + m1
/ 2, z + r1 / 2);
k3 = DELTA_TIME_STEP * fX(t + DELTA_TIME_STEP, x + k2 / 2, y + m2 /
2, z + r2 / 2, charCodes[i]);
m3 = DELTA_TIME_STEP * fY(t + DELTA_TIME_STEP, x + k2 / 2, y + m2 / 2, z + r2 / 2);
r3 = DELTA_TIME_STEP * fZ(t + DELTA_TIME_STEP, x + k2 / 2, y + m2 / 2, z + r2 / 2);
k4 = DELTA_TIME_STEP * fX(t + DELTA_TIME_STEP, x + k3, y + m3, z +
r3, charCodes[i]);
m4 = DELTA_TIME_STEP * fY(t + DELTA_TIME_STEP, x + k3, y + m3, z + r3);
r4 = DELTA_TIME_STEP * fZ(t + DELTA_TIME_STEP, x + k3, y + m3, z + r3);
x = x + (k1 + k2 * 2 + k3 * 2 + k4) / 6 ;
y = y + (m1 + m2 * 2 + m3 * 2 + m4) / 6;
z = z + (r1 + r2 * 2 + r3 * 2 + r4) / 6;
output.push(S);
t = t + DELTA_TIME_STEP;
}
return charCodesToString(output);
}
/**
* Шифровщик на основе хаотической системы уравнений
* Решение уравнений с использованием метода Рунге-Кутта
*
* @param {String} dataString a message
* @returns string of encoded message
*/
function encodeMesage(dataString) {
let t = 0;
let x = 0.1;
let y = 0;
let z = 0;
let S = 0;
const charCodes = stringToCharCodes(dataString);
const output = [];
/* Perform calculations */
for (i = 0; i < charCodes.length; i++) {
U = y + charCodes[i];
k1 = DELTA_TIME_STEP * fX(t, x, y, z, U);
m1 = DELTA_TIME_STEP * fY(t, x, y, z);
r1 = DELTA_TIME_STEP * fZ(t, x, y, z);
k2 = DELTA_TIME_STEP * fX(t + DELTA_TIME_STEP / 2, x + k1 / 2, y + m1
/ 2, z + r1 / 2, U);
m2 = DELTA_TIME_STEP * fY(t + DELTA_TIME_STEP / 2, x + k1 / 2, y +
m1 / 2, z + r1 / 2);
r2 = DELTA_TIME_STEP * fZ(t + DELTA_TIME_STEP / 2, x + k1 / 2, y + m1
/ 2, z + r1 / 2);
k3 = DELTA_TIME_STEP * fX(t + DELTA_TIME_STEP, x + k2 / 2, y + m2 / 2, z + r2 / 2, U);
m3 = DELTA_TIME_STEP * fY(t + DELTA_TIME_STEP, x + k2 / 2, y + m2 / 2, z + r2 / 2);
r3 = DELTA_TIME_STEP * fZ(t + DELTA_TIME_STEP, x + k2 / 2, y + m2 / 2, z + r2 / 2);
k4 = DELTA_TIME_STEP * fX(t + DELTA_TIME_STEP, x + k3, y + m3, z + r3, U);
m4 = DELTA_TIME_STEP * fY(t + DELTA_TIME_STEP, x + k3, y + m3, z + r3);
r4 = DELTA_TIME_STEP * fZ(t + DELTA_TIME_STEP, x + k3, y + m3, z + r3);
x = x + (k1 + k2 * 2 + k3 * 2 + k4) / 6;
y = y + (m1 + m2 * 2 + m3 * 2 + m4) / 6;
z = z + (r1 + r2 * 2 + r3 * 2 + r4) / 6;
output.push(U);
t = t + DELTA_TIME_STEP;
}
return charCodesToString(output);
}
```
В конце кода определены 2 служебных функции, которые используются при создании модулей: `receive(r, data, flags)`, `transmit(r, data, flags)`. Эти функции вызывают `sendBuffer` – функцию для модуля `njs_stream_js_module`, который позволяет задавать обработчики на njs.
Затем с помощью модуля `export default` регулируется область видимости: в случае обращения к скрипту извне будет видна только та часть кода, которая включена в модуль, а все остальное остается скрытым.
```
function receive(r, data, flags) {
r.sendBuffer(decodeMessage(data), flags);
}
function transmit(r, data, flags) {
r.sendBuffer(encodeMesage(data), flags);
export default {
transmit, receive
};
```
Работу модуля я проверял на «голом» веб-сервере. В дальнейшем хочу проверить программную реализацию алгоритма на производительность и криптостойкость. В рамках этой задачи нужно будет задать конфигурацию серверу, смоделировать реальную ситуацию высоконагруженного сайта и протестировать процесс реального приема и передачи данных в нескольких тест-кейсах. Получается довольно объемная работа, так что об этом расскажу как-нибудь в следующий раз. | https://habr.com/ru/post/680758/ | null | ru | null |
# ГОСТы по GreaseMonkey'вски
Подошла недавно коллега и поведала, что никак у нее не получается сохранить страничку ГОСТа с ~~нелюбимого~~ сайта <http://protect.gost.ru>.
«Нам ли быть в печали, старушка» — сказал я ей, открыл вышеупомянутый сайт и начал ~~ковырять~~ смотреть.
Выяснилось, что алгоритм «защиты» достаточно прост — картинка со станицей ГОСТа накладывается css-стилем на прозрачную картинку pixel.gif. В результате при попытке сохранения картинки через «Сохранить изображение как..» в Firefox мы сохраняем не нужную нам страничку ГОСТа, а pixel.gif.
«Лень — двигатель прогресса» — подумал я и накидал небольшой скриптик для GreaseMonkey, которым и делюсь с хабрачитателями.
> ````
>
> // ==UserScript==
> // @name GostRu
> // @namespace http://protect.gost.ru/*
> // @description Delete pixel image under Gost
> // @include http://protect.gost.ru/*
> // ==/UserScript==
> var s_l=document.styleSheets.length;
> for (j=0;j
> ````
После установки скрипта мы получаем возможность сохранять именно нужную нам страницу.
Прекрасно работает в Firefox 3.6.3 + GreaseMonkey 0.8.20100408.6
Хабрапользователь [nanodust](https://habrahabr.ru/users/nanodust/) подсказал уже существующий скрипт с аналогичным функционалом на [UserScript.org](http://bit.ly/17ckis) (прошу прощения за укорот ссылки, не хватает опыта для «обмана» хабрапарсера).
Хабрапользователь [david\_mz](https://habrahabr.ru/users/david_mz/) написал букмарклет для разворачивания ГОСТов:
«рабочая» версия:
> ````
> javascript:(function() { var ids = []; for(var i=0;i'); document.close(); for(var i=0;i
> ````
«читабельная» версия:
> ````
> javascript:(
> function() {
> var ids = [];
> for(var i=0;i');
> document.close();
> for(var i=0;i
> ````
Способ применения: для реальной работы необходимо взять кусок букмарклета в «рабочем» виде и сделать в браузере закладку, у которой вместо URL — этот код. Потом зайти на любую страницу нужного ГОСТ (именно на страницу, а не на аннотацию) и нажать на закладку. Появятся все страницы данного ГОСТ в виде картинок без всякой защиты. | https://habr.com/ru/post/90615/ | null | ru | null |
# Marshmallow. Это должен сделать каждый. Добавляем поддержку SDK 23 в наши приложения
Мне повезло стать [Google Developer Expert Android в России](https://developers.google.com/experts/people/denis-neklyudov.html), и поэтому я вдвойне переживаю, что не все из вас подготовились к релизу заранее. Сейчас мы с вами постараемся запрыгнуть на уплывающий пароход с зефирками.
Вы можете не читать, а просто посмотреть [мой доклад на прошедшем DroidCon](http://www.youtube.com/watch?v=oa4ZrBFexcc).
Но специально для тех, кто любит читать хабр больше чем смотреть youtube — добро пожаловать под кат. Там мы пройдемся по чеклисту действий, которые каждый обязательно должен сделать в своем приложении, а потом посмотрим на новые возможности для разработчиков в sdk 23.
Важное замечание
================
Всё нижесказанное относится только к приложениям с *targetSdk = 23* и выше! Как будут вести себя приложения с более старыми sdk на зефирке готов обсудить в комментариях.
Doze Mode, App Standby и Runtime Permissions
============================================
К сожалению длина статьи не смогла вместить эти три важнейших изменения в Android Marshmallow. Пожалуйста, [прочтите о них в отдельной статье](http://habrahabr.ru/post/269491/).
Autobackup
==========
Теперь Android приложения каждую ночь, пока девайс на зарядке, будут сливать в пользовательский Drive все настройки. Вернее, те которые мы разрешим.
Зачем?
Пользователь при покупке нового сразу восстанавливает из Google Play не только все приложения, но и их настройки.
Чем плохо для нас?
В облако и на новые девайсы улетают из shared preferences данные аккаунтов и ключи GCM (пуши перестают работать). Нужно это предотвратить!
По дефолту бэкапятся все папки нашего приложения и все SharedPreferences. Не сохраняются лишь:
— пути на SD карте, не находящиеся в *android/data/...*
— *getCacheDir()*
— *getCodeCacheDir()*
— *getNoBackupFilesDir()*
Последняя папочка специально для этого как раз и создана.
Чтобы предотвратить часть файлов от бекапа пишем вот такую xml, где перечисляем все данные, которые не желаем пускать в бекап:
```
developer.android.com/intl/ru/training/backup/autosyncapi.html
Пример: [developer.android.com/intl/ru/samples/AutoBackupForApps/index.html](http://developer.android.com/intl/ru/samples/AutoBackupForApps/index.html)
Deprecated
==========
Если вы еще используете *Apache Http client* и напрочь отказываетесь перейти на современные аналоги, например, [OkHttp](http://square.github.io/okhttp/), то вам срочно нужно добавить в *build.gradle*:
```
android { useLibrary 'org.apache.http.legacy' }
```
Теперь из sdk выпилили OpenSSL: libcrypto.so и libssl.so заменены на BoringSSL.
Если вы вдруг не знали до сегодняшнего дня о *Notification.Builder*, а использовали для содания нотификаций *notification.setLatestEventInfo()*, хватит, он удален. Прочитайте хотя бы [мою статью](http://habrahabr.ru/post/140928/), а лучше [официальные доки](http://developer.android.com/intl/ru/guide/topics/ui/notifiers/notifications.html), как правильно создавать и обновлять уведомления.
Adoptable storage
=================
Теперь пользователь может отформатировать sd-карточку, превратив ее в почти внутреннее шифрованное хранилище. И тем самым система будет переносить и устанавливать приложения на новое хранилище. Чем это грозит для нас?
Если мы не используем в приложении стандартные методы и константы для получения путей (*getFilesDir()*, *getCacheDir()* и т.д.), а хардкодим пути к внутреннему хранилищу, то после перемещения файлов на карту точка монтирования сменится, и все наши старательно прописанные пути перестанут быть валидными.
Подробнее: [developer.android.com/intl/ru/about/versions/marshmallow/android-6.0.html#adoptable-storage](https://developer.android.com/intl/ru/about/versions/marshmallow/android-6.0.html#adoptable-storage)
Небольшие, но важные дополнения
===============================
Доступ к мак адресам устройств в округе теперь возможен только при сканировании методами *WifiManager.getScanResults()* *BluetoothLeScanner.startScan()* и при запрошенных пермишенах *ACCESS\_FINE\_LOCATION* или *ACCESS\_COARSE\_LOCATION*. А вот методы *WifiInfo.getMacAddress()* и *BluetoothAdapter.getAddress()* вернут всегда пустышку *02:00:00:00:00:00*. это сделано в целях повышения секьюрности пользователя. Жаль не все обновятся на marshmallow, да и кастомные прошивки вряд ли сохранят это ограничение.
Из Android Keystore provider выкинули поддержку DSA-шифрования.
Теперь состояния *WifiConfiguration* объектов наши приложения могут менять только, если они сами их создали.
У камеры хорошие изменения по работе с доступом к сервису. Если приложение ушло в фон, а другое приложение наоборот вышло на первый план, то ему отдастся приоритет, а первое лишится сервиса. А еще, теперь можно использовать из разных приложений одновременно доступ к разным камерам устройства.
Изменения в ART
===============
* Теперь корректно реализована обработка прав на *newInstance()*.
* Динамический линкер теперь понимает различия между *soname* библиотеки и ее путем, а еще появился поиск по *soname*.
* Починили флаг *dlopen(3) RTLD\_LOCAL*.
Новые возможности Android
=========================
С обязательными изменениями в нашем приложении покончено. Перейдем к основным фичам, которые нам предоставляет новый SDK.
App Linking
-----------
Многие разработчики встраивают в свои приложения фильтры url-схем, чтобы пользователю было предложено открыть определенный url с помощью приложения. Теперь появилась возможность лишить возможности других разработчиков обрабатывать url вашего сайта. Допустим если вы делаете банкинг, то точно не хотите, чтобы другие приложения, кроме приложения-клиента вашего банка могли открываться по нажатию пользователем на ссылку.
В манифесте нужно добавить вот такого вида фильтр:
```
```
И положить JSON на свой сайт (https://www.domain1.com/.well-known/assetlinks.json), вставив sha256 из кейстора, которым подписано приложение.
```
[{
"relation": ["delegate_permission/common.handle_all_urls"],
"target": {
"namespace": "android_app",
"package_name": "com.example",
"sha256_cert_fingerprints":
["14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5"]
}
}]
```
Единственное, о чем стоит помнить: если ваше приложение не будет установлено, то выскочит диалог «открыть с помощью» и приложение злоумышленника сможет открыться.
Подробнее: [developer.android.com/intl/ru/training/app-links/index.html](http://developer.android.com/intl/ru/training/app-links/index.html)
Fingerprint API
---------------
Наконец-то в Android появилась нативная поддержка сенсоров отпечатков пальцев. Теперь с помощью класса *android.hardware.fingerprint.FingerprintManager* проверяем наличие в устройстве сенсора *isHardwareDetected()*, запрашиваем разрешение *USE\_FINGERPRINT*, и если у пользователя есть откатанные пальчики *hasEnrolledFingerprints()*, показываем стандартный диалог авторизации по отпечатку *authentificate()*.
[Подробнее](https://www.youtube.com/watch?t=1&v=VOn7VrTRlA4).
[Пример](http://developer.android.com/intl/ru/samples/FingerprintDialog/index.html).
Confirm Credentials
-------------------
Теперь у нас есть возможность перепроверить, что сейчас устройство в руках у его владельца, показав экран разблокировки перед важным действием в приложении, например, при попытке открыть папку "/отдых в Адлере 2007/".
[Подробнее](https://github.com/googlesamples/androidConfirmCredential/blob/master/Application/src/main/java/com/example/android/confirmcredential/MainActivity.java).
[Пример](http://developer.android.com/intl/ru/samples/ConfirmCredential/index.html).
Text Selection
--------------
Теперь контекстное меню для действий с выделенным текстом появляется непосредственно рядом с кареткой, для добавления своих действий мы так же можем воспользоваться меню, описанным в *menu.xml*, и добавить его с помощью метода *startActionMode(Callback, ActionMode.TYPE\_FLOATING)*.
[Подробнее](http://developer.android.com/intl/ru/about/versions/marshmallow/android-6.0-changes.html#behavior-text-selection).
Direct share
------------
Важным дополнением в Marshmallow является возможность добавлять одному приложению до восьми различных объектов в стандартный диалог шаринга:
Главное не захламить диалог бесполезными вариантами шаринга. Старайтесь не злоупотреблять.
Подробнее: [developer.android.com/intl/ru/about/versions/marshmallow/android-6.0.html#direct-share](http://developer.android.com/intl/ru/about/versions/marshmallow/android-6.0.html#direct-share)
Пример: [developer.android.com/intl/ru/samples/DirectShare/index.html](http://developer.android.com/intl/ru/samples/DirectShare/index.html)
Voice Interaction
-----------------
Важная, но не так подробно освещенная фишка, в отличии от [«Now on tap»](https://www.android.com/versions/marshmallow-6-0/) . Наше приложение, будучи запущенным из Google Now может вести диалог с пользователем с помощью класса *android.app.VoiceInteractor*.
Подробнее: [developers.google.com/voice-actions/interaction/voice-interactions](https://developers.google.com/voice-actions/interaction/voice-interactions).
На этом список не заканчивается. Более мелкие нововведения можно прочитать [тут](http://developer.android.com/intl/ru/about/versions/marshmallow/android-6.0.html).
Обязательно пройдитесь по всем пунктам выше. Проверьте autobackup, doze mode и запросите все пермишены. На все вопросы буду рад ответить в комментариях.
``` | https://habr.com/ru/post/269471/ | null | ru | null |
# Web-Drawing библиотеки: Paper.js Vs. Processing.js Vs. Raphael.js
Набрёл на статью со сравнением трёх JS библиотек для рисования в WEB [Paper.js](http://paperjs.org/), [Processing.js](http://processingjs.org/) и [Raphael.js](http://raphaeljs.com/). Думаю она будет интересна не только мне.
**Прежде чем начать рисовать что-либо в браузере, спросите себя о следующих трёх вещах:**
* **Вам нужна поддержка старых браузеров?**
Если ответ **да**, тогда единственный выбор, это Raphaël. Он поддерживает браузеры вплоть до IE 7 и Firefox 3. У Raphaël есть даже ограниченная поддержка IE 6, несмотря на то, что некоторые базовые для библиотеки технологии не могут быть реализованы в этом браузере.
* **Вам нужна поддержка Android?**
Android не поддерживает SVG, так что вам придется использовать Paper.js или Processing.js. Существуют слухи, что Android 4 будет поддерживать SVG, но большинство современных Android устройств уже не будет его поддерживать.
* **Ваш рисунок интерактивный?**
Raphaël и Paper.js сосредоточены на взаимодействии с рисуемыми элементами посредством клика мышкой, перетаскивания и касания. Processing.js не поддерживает никаких события уровня объекта, потому обработать движения пользователя в нём довольно сложно. Processing.js может рисовать классную анимацию на Вашей домашней страничке, а Raphaël и Paper.js более подходят для интерактивных приложений.
Paper.js, Processing.js и Raphaël на данный момент являются лидирующими библиотеками для рисования в Web. Также есть пара новичков, чья популярность растёт, и конечно Вы всегда можете использовать Flash, но эта троица хорошо работает с HTML5 и имеет широчайшую поддержку среди производителей браузеров.
Выбор наиболее подходящего фреймворка может определить успех Вашего проекта. Эта статья опишет преимущества и недостатки каждой библиотеки и даст достаточно информации чтобы сделать верный выбор.
Весь код приведённый в статье является Open Source и доступен на [демонстрационной странице](http://zgrossbart.github.com/3gears/) созданной специально для поддержки этой статьи.
#### Общие характеристики
| | **Paper.js** | **Processing.js** | **Raphaël** |
| --- | --- | --- | --- |
| **Технология** | Тэг **canvas** | Тэг **canvas** | SVG |
| **Язык** | PaperScript | Processing script | JavaScript |
| **Браузеры с** | IE 9 | IE 9 | IE 7 |
| **Мобильные браузеры** | Да | Да | Только iOS |
| **Модель** | Векторная и растровая | Растровая | Векторная |
| **Размер файла ядра** | 56 KB | 64 KB | 20 KB |
Все используют исключительно JavaScript, но каждый из фреймворков реализуют свой подход. Raphaël написан непосредственно на JavaScript, зато Paper.js использует PaperScript, а Processing.js использует свой собственный язык. Все они поддерживаются в Firefox, Chrome и Safari, проблема только с Internet Explorer — Paper.js и Processing.js используют тэг canvas и поэтому требуют минимум IE 9.
PaperScript это расширение языка JavaScript позволяющие писать код не загрязняющий глобальное пространство имён. Это уменьшает вероятность конфликтов в JavaScript. PaperScript также напрямую поддерживает математические примитивы, такие как [**Point**](http://paperjs.org/reference/point) и [**Size**](http://paperjs.org/reference/size): Вы можете складывать две точки вместе, так, как-будто это простые числа.
Processing.js основан на фреймворке под названием [**Processing**](http://processing.org/), который использует для работы Виртуальную Java машину. Вы определяете int и float вместо var, а также можете использовать наследование в Java-стиле. Не смотря на то, что скрипт на Processing.js более походит на Java, это всё же JavaScript и не требует более специфических для Java вещей.
Использование любой из трёх библиотек не составит проблем, если Вы знакомы с JavaScript.
#### Начнём
Для начала импортируем каждую библиотеку. В каждом случае этот процесс несколько различается
##### Подключаем Paper.js
Paper.js определяет тип скрипта как text/paperscript и ID целевого элемента canvas на котором мы будем рисовать.
```
```
##### Подключаем Processing.js
Processing.js использует data-processing-sources атрибут тега canvas для инициализации. Автор использовал .java расширение для скрипта с файлом Processing, чтобы его редактор кода правильно отобразил подсветку синтаксиса. Другие авторы могут использовать расширения .pde или .pjs. Как Вам удобнее.
```
```
##### Подключаем Raphaël
Raphaël подключается как и любой другой JavaScript файл. Он отлично работает совместно с [**jQuery’s ready**](http://api.jquery.com/ready/) функцией и со всеми остальными JS фреймворками.
```
```
**Теперь мы готовы рисовать**
#### Объектно-Ориентированное рисование
Оба Paper.js и Raphaël используют объектно-ориентированный подход к процессу рисования: Вы рисуете круг и получаете объект Круг. Processing.js просто рисует круг и ничего не возвращает. Следующий код иллюстрирует как это происходит. Давайте начнём с кружка размерами 100 на 100 по центру экрана.
##### Paper.js:
```
var circle = new Path.Circle(new Point(100, 100), 10);
circle.fillColor = '#ee2a33';
```
##### Raphaël:
```
var paper = Raphael('raphaelCircle', 200, 200);
var c = paper.ellipse(100, 100, 10, 10);
c.attr({'fill': '#00aeef', 'stroke': '#00aeef'});
```
##### Processing.js:
```
void setup() {
size(200, 200);
}
void draw() {
background(#ffffff);
translate(100, 100);
fill(#52b755);
noStroke();
ellipse(0, 0, 20, 20);
}
```
Каждый кусок кода рисует один и тот же круг. Разница в том, что Вы можете потом с ним сделать.
Paper.js создаёт круг как [**path**](http://paperjs.org/reference/path) объект. Мы можем сохранить его и изменить в дальнейшем. В Paper.js, circle.fillColor = 'red'; рисует красным цветом круг, а circle.scale(2) делает его в два раза больше.
Raphaël как и Paper.js’ реализует объектно-ориентированную модель. В Raphaël, мы можем изменить цвет нашего круга используя circle.attr('fill', 'red'); и изменить его размеры написав circle.scale(2, 2);. Главная идея состоит в том, что круг, это объект к свойствам которого мы можем получить доступ позднее.
Processing.js не использует объектов; функция **ellipse()** не возвращает значения. Как только мы нарисовали круг используя Processing.js, он становится частью создаваемого изображения, как при обычном рисовании чернилами по бумаге; это ни какой-то отдельный объект, которому можно изменить свойства. Для изменения цвета мы должны нарисовать такой же круг, но другого цвета поверх первого.
Когда мы вызываем функцию [**fill()**](http://processingjs.org/reference/fill_), изменяется цвет для всех примитивов отображаемых далее. После вызова функции [**translate()**](http://processingjs.org/reference/translate_) и [**fill()**](http://processingjs.org/reference/fill_), все фигуры будут закрашены зелёным.
Так как функции изменяют сразу всё, мы легко можем получить совсем неожиданные эффекты. Вызываешь безвредную функцию и вдруг всё становится зелёным! Processing.js предоставляет функции [**pushMatrix()**](http://processingjs.org/reference/pushMatrix_) и [**popMatrix()**](http://processingjs.org/reference/popMatrix_) для изоляции изменений, но их ещё надо не забыть вызвать.
Отсутствие объектов у Processing.js означает то, что сложные рисунки обрабатываются значительно быстрее. Paper.js и Raphaël хранят ссылки на все нарисованные объекты, что увеличивает количествотребуемой памяти и на сложной графике заметно замедляют приложение. Processing.js не содержит ссылок на создаваемые объекты, в итоге каждая часть рисунка занимает очень мало памяти. Объектный подход оправдан в случае, если Вы хотите получить доступ к объекту позже, в противном случае это напрасная трата ресурсов. Paper.js даёт возможность избежать ненужного расхода памяти там, где это не нужно, для этого используется [**Symbol**](http://paperjs.org/reference/symbol) который растеризует объект, но конечно нужно всё спланировать заранее чтобы приложение работало достаточно быстро.
**Различные подходы определяют весь стиль работы с библиотеками. Конечно это влияет и на то, как в них работать с анимацией.**
#### Заставим их двигаться
Вращение кругов не слишком зрелищно, поэтому давайте пусть вокруг круга вертится квадрат.
#### Анимация в Processing.js
Processing.js поддерживает анимацию используя функции [**setup()**](http://processingjs.org/reference/setup_) и [**draw()**](http://processingjs.org/reference/draw_) функции, примерно так:
```
float angle = 0.0;
void setup() {
size(200, 200);
frameRate(30);
}
void draw() {
background(#ffffff);
translate(100, 100);
fill(#52b755);
noStroke();
ellipse(0, 0, 20, 20);
rotate(angle);
angle += 0.1;
noFill();
stroke(#52b755);
strokeWeight(2);
rect(-40, -40, 80, 80);
}
```
Setup функция вызывается в момент старта приложения. Мы говорим Processing.js с частотой 30 кадров в секунду, в итоге наша функция draw() будет вызываться 30 раз в секунду. Это число может показаться высоким, но это нормально если мы хотим получить плавную анимацию.
Функция draw() вначале заливает весь холст одним цветом; это закрасит всё, что осталось от предыдущего кадра. Это главная особенность Processing.js: мы не манипулируем объектами, поэтому мы должны очистить всё, что осталось с предыдущего кадра.
Далее, мы переводим фокус в точку 100,100. Это позиционирует отрисовку на 100 пикселей слева и 100 пикселей от верха холста для всех операций рисования, пока мы не изменим координаты. Далее мы изменяем предыдущее значение угла наклона. Это значение увеличивается с каждым кадром заставляя квадрат вращаться. И последний шаг, это отображение квадрата с использованием функций [**fill**](http://processingjs.org/reference/fill_) и [**rect**](http://processingjs.org/reference/rect_).
Обычно функция rotate() Processing.js оперирует [**радианами**](http://ru.wikipedia.org/wiki/Радиан) вместо [**градусов**](http://ru.wikipedia.org/wiki/Градус_(геометрия)). Поэтому мы каждый раз увеличиваем значение угла на 0.2, а не большее значение, к примеру 3. Это один из многих случаев при программном рисовании когда нам нужна тригонометрия.
#### Анимация Paper.js
В Paper.js простую анимация реализовать проще, чем в Processing.js, используя постоянный объект rectangle:
```
var r;
function init() {
var c = new Path.Circle(new Point(100, 100), 10);
c.fillColor = '#ee2a33';
var point = new Point(60, 60);
var size = new Size(80, 80);
var rectangle = new Rectangle(point, size);
r = new Path.Rectangle(rectangle);
r.strokeColor = '#ee2a33';
r.strokeWidth = 2;
}
function onFrame(event) {
r.rotate(3);
}
init();
```
Мы используем состояние нашего квадрата в виде объекта, и Paper.js управляет рисованием на экране. С каждым кадром мы вращаем его понемногу. Paper.js управляет всеми трансформациями, поэтому мы не должны перерисовывать всё в ручную в начале каждого кадра или следить за текущим значением угла поворота или беспокоится о том, чтобы не задеть другие объекты.
#### Анимация Raphaël
Анимация на Raphaël написана на стандартном JavaScript, т.е. Raphaël не определяет каких-то специальных функций для управления кадрами. Вместо этого мы используем обычную функцию setInterval().
```
var paper = Raphael('raphaelAnimation', 200, 200);
var c = paper.ellipse(100, 100, 10, 10);
c.attr({
'fill': '#00aeef',
'stroke': '#00aeef'
});
var r = paper.rect(60, 60, 80, 80);
r.attr({
'stroke-width': 2,
'stroke': '#00aeef'
});
setInterval(function() {
r.rotate(6);
}, 33);
```
Raphaël похож на Paper.js в своём объектно-ориентированном подходе. У нас есть квадрат, и мы вызываем его метод [**rotate()**](http://raphaeljs.com/reference.html#Element.rotate). Таким образом мы можем вращать квадрат используя всего несколько строк кода.
#### Взаимодействие
Raphaël раскрывает свои преимущества когда появляется нужда в добавлении интерактивности в рисунок. Он предоставляет событийную модель, сходную с обычной для JavaScript, позволяя легко обнаруживать клики мышкой, начало перетаскивания или прикосновения пользователя. Давайте добавим квадрату реакцию на клик мышкой.
#### Взаимодействие в Raphaël
```
var paper = Raphael('raphaelInteraction', 200, 200);
var r = paper.rect(60, 60, 80, 80);
r.attr({'fill': '#00aeef', 'stroke': '#00aeef'});
var clicked = false;
r.click(function() {
if (clicked) {
r.attr({'fill': '#00aeef', 'stroke': '#00aeef'});
} else {
r.attr({'fill': '#f00ff0', 'stroke': '#f00ff0'});
}
clicked = !clicked;
});
```
Функция click() в Raphaël работает как в jQuery, и её можно навесить на любой объект. Получив событие клика, изменить цвет квадрата не составляет проблемы. Raphaël имеет дополнительные функции для поддержки перетаскивания, прохождения курсора над объектом и все другие события которые доступны в JavaScript.
#### Взаимодействие в Paper.js
Paper.js идёт другим путём для обслуживания задач взаимодействия, но и он довольно прост:
```
var hitOptions = {
fill: true,
tolerance: 5
};
function init() {
var point = new Point(60, 60);
var size = new Size(80, 80);
var rectangle = new Rectangle(point, size);
r = new Path.Rectangle(rectangle);
r.fillColor = '#ee2a33';
}
function onMouseUp(event) {
var hitResult = project.hitTest(event.point, hitOptions);
if (hitResult && hitResult.item) {
if (hitResult.item.clicked) {
hitResult.item.fillColor = '#ee2a33';
} else {
hitResult.item.fillColor = '#f00ff0';
}
hitResult.item.clicked = !hitResult.item.clicked;
}
}
init();
```
Paper.js работает с курсором используя концепцию названную “[hit testing](http://paperjs.org/examples/hit-testing/)” Точка нажатия высчитывается по текущим координатам курсора и библиотека получает расположенный там объект. Настройки позволяют конфигурировать поведение программы: можно указать такие вещи как: на сколько близко курсор должен быть, чтобы засчитать объекту клик, является-ли объектом всё его внутренне пространство или только край. Мы можем применить это обнаружение кликов к любому объекту (или группе объектов) в Paper.js.
Команда Paper.js также добавила объектный подход, сходный с Raphaël всего несколько недель назад (на февраль 2012). События должны появиться в следующей версии.
#### Взаимодействие в Processing.js
У Processing.js обнаружение клика мышки достаточно запутано. Объектный стиль не поддерживается, так-что мы должны рассчитывать в основном на свои собственные силы.
```
float bx;
float by;
int bs = 20;
boolean bover = false;
boolean clicked = false;
void setup() {
size(200, 200);
bx = width/2.0;
by = height/2.0;
noStroke();
fill(#52b755);
frameRate(10);
}
void draw() {
background(#ffffff);
// Test if the cursor is over the box
if (mouseX > bx-bs && mouseX < bx+bs && mouseY > by-bs && mouseY < by+bs) {
bover = true;
} else {
bover = false;
}
translate(100, 100);
rect(-40, -40, 80, 80);
}
void mousePressed() {
if (bover) {
if (clicked) {
fill(#52b755);
} else {
fill(#f00ff0);
}
clicked = !clicked;
}
}
```
Как только Processing.js отрисовывает квадрат, он забывает о нём. Мы хотим, чтобы при клике на квадрат он менял свой цвет, но скрипт этого не знает, поэтому мы должны делать все вычисления сами. Функция draw() определяет позицию курсора и высчитывает лежит-ли он в пределах нашего квадрата.
Для одного квадрата код не такой уж и страшный, но к примеру для круга нужно будет считать каждый раз Пr2. А более сложные фигуры, такие как овалы, кривые и сложные формы потребует еще больше математики.
#### Нет явного победителя
Каждый фреймворк имеет свои преимущества. Каждая библиотека предоставляет возможности для создания классных демок и ещё более классных приложений.
#### Преимущества Paper.js
Paper.js отлично подходит для манипулирования сложными фигурами. Он может вращать, скручивать и трансформировать любой объект сотней различных методов. Это даёт возможность модифицировать объекты используя жесты мышкой (gestures). Новый [Google Music Tour](http://music.google.com/about/tour/), заставляет цветные линии двигаться под музыку, показывая как эта библиотека справляется со сложными изменениями простых фигур.
Ещё один вау-фактор в Paper.js это поддержка [растровой графики](http://ru.wikipedia.org/wiki/Растровая_графика) . Paper.js может полностью изменить способы, которыми отображаются изображения — к примеру превращая их в [**спирали**](http://paperjs.org/examples/spiral-raster/) или [**кубиковые полотна (Q\*bert boards)**](http://paperjs.org/examples/q-bertify/).
#### Преимущества Processing.js
Основное преимущество Processing.js’ это его скорость, которая позволяет создавать сложную анимацию даже на слабых машинах. [Тут](http://processingjs.org/exhibition) есть много примеров, также отличный пример плавности анимации на Processing.js используется на сайте [Ricardo Sánchez](http://nardove.com).
Рассекающие воду хвосты и плавающие тела рыб выглядят очень натурально. Processing.js позволяет добиться этого просто, используя кривые и настраиваемые анимации.
Processing.js также поддерживает сложные эффекты на элементах, такие как затенение, освещение и 3-D трансформации. Если Вы хотите быстро создать сложные анимации на канве, то Processing.js является лучшим выбором.
#### Преимущества Raphaël
Одной из лучших возможностей Raphaël является поддержка Internet Explorer 7 и 8. Если Ваше приложение должно поддерживать старые браузеры, то Raphaël является единственным выбором.
Ещё одним важным преимуществом Raphaël является его общество. Raphaël старше чем Paper.js и Processing.js и поэтому у него было больше времени на создание галереи примеров, туториала и описания типичных проблем и способов их решения. У него есть встроенная поддержка [easing](http://raphaeljs.com/easing.html), [анимации трансформаций](http://raphaeljs.com/animation.html) и обработчиков событий, которую мы видели в интерактивном примере; также у него есть собственная библиотека для [**создания графиков**](http://g.raphaeljs.com/).
Также у Raphaël отличный набор разнообразных инструментов.
#### Инструменты
Если Вы работали с Flash, отсутствие инструментов для этих библиотек Вас расстроит. Многие фреймворки позволяют редактировать SVG изображения, но ни один из них не предоставляет drag-and-drop способа для создания приложений.
Тут приведены некоторые простые инструменты, но они скорее могут быть рассмотрены в качестве доказательства самой возможности создавать такие программы, нежели самостоятельные приложения. Adobe работает над программой названной [Edge](http://success.adobe.com/en/na/sem/products/edge.html?sdid=JAPEL&skwcid=TC|23230|HTML5%20animation%20tools||S|b|8325947226), но ей ещё много предстоит пройти чтобы стать нормальным инструментом.
Если Вы хотите, drag and drop, то Web анимация ещё не для Вас. На данный момент создание анимации в этой области более похоже на программирование видео игр. Написание кода для отображения круга сложнее, чем просто кликнуть и перетащить фигуру из палитры, на это даёт много преимуществ при создании более сложных приложений.
#### Давайте создадим что-нибудь более сложное
Итак, мы рассмотрели несколько простых примеров, познакомились в преимуществами и недостатками каждой платформы и поняли, в каком случае какая из них подходит лучше. Каждая библиотека имеет свои плюсы и минусы, но всё-таки основываясь только на примитивных примерах о них довольно сложно судить.
Для сравнения каждой библиотеки были нарисованы несколько шестерёнок. Каждая из которых состоит из двух кругов, с набором зубцов вокруг внешнего круга.
Когда все поверхности залиты одним цветом, фигура похожа на шестерёнку.
Шестерёнка будет немного поворачиваться на каждом кадре анимации. Основная шестерёнка будет задавать скорость, а все остальные будут вращаться зависимо от неё. Шестерёнки будут располагаться, сцепляться и вращаться друг о друга основываясь на сумасшедшем количестве тригонометрии. Расположите их на одном холсте и Вы получите сложную систему шестерёнок.
#### [Paper.js:](http://zgrossbart.github.com/3gears/paper_gears.html)
#### [Processing.js:](http://zgrossbart.github.com/3gears/processing_gears.html)
#### [Raphaël:](http://zgrossbart.github.com/3gears/raphael_gears.html)
Ну, это был не совсем Raphaël. Функция вращения работает в Raphaël не так как в Paper.js и Processing.js. Raphaël не поддерживает вращение вокруг фиксированной точки. Вместо этого зубцы шестерёнки каждый раз перерисовываются независимо и летят вокруг по воздуху вместо того, чтобы вращаться вокруг центра. Единственное как автор может представить себе это можно сделать, это отрисовать шестерёнку целиком и вращать её, но там слишком много математики чем он хотел-бы приводить. Если кто-то хочет попробовать реализовать это сам, добро пожаловать, это Open Source.
#### Будущее рисования в Web
Мы играемся с каждой новой освоенной технологией: мы надеемся, что она решит многие наши проблемы и это окупит инвестиции в её изучение. Технологии набирают и теряют популярность, но в этом участвуют многие факторы, к примеру поддержка производителей или требования бизнеса. Будущее нашей индустрии это частенько игра в догадки.
Сегодня Flash выглядит не лучшей технологией для изучения. У Flash есть классные инструменты разработки, годы накопленного опыта разработки и большое общество, но даже Adobe уходит от него.
С SVG похожая ситуация. Браузеры его поддерживают, но не уделяют слишком много внимания.
Каждый производитель браузеров постоянно работает над увеличением скорости отрисовки **canvas**, для получения возможности использования аппаратной акселерации и лучшей поддержки таких библиотек как Paper.js и Processing.js. Все мобильные браузеры А-класса поддерживают **canvas**, и их разработчики постоянно работают над улучшением качества этой поддержки.
**Upd.**
Cам Dmitry Baranovskiy в комментах к оригинальной статье оспорил следующие утверждения её автора:
**Raphaël не поддерживает вращение вокруг фиксированной точки.** — Поддерживает
**Raphaël не определяет каких-то специальных функций для управления кадрами** — — Определяет
Также он заверил, что Raphaël работает даже в IE 6 | https://habr.com/ru/post/140286/ | null | ru | null |
# Новое в Runkit 1.0.4: PHP 5.6+, closures везде и еще 12 новых фич
Runkit 1.0.4 для PHP выпущен!
-----------------------------
Поздравляю всех пользователей Runkit с новым долгожданным мега-релизом! Если вы постоянно используете Runkit и хорошо знакомы с его возможностями, историей и развитием, то можете сразу переходить к [описанию изменений релиза 1.0.4](http://habrahabr.ru/post/267495/#rel). В любом случае предлагаю прочесть статью целиком.
Что такое Runkit?
-----------------
Runkit – это расширение языка PHP, позволяющее делать вещи, невозможные с точки зрения этого языка. Функционал расширения состоит из трех частей.
### Runtime Manipulations
Первая и самая крупная часть функционала Runkit позволяет динамически (в процессе выполнения PHP-программы) копировать, изменять и удалять такие сущности, динамическое изменение которых самим языком PHP не предусмотрено.
Runkit позволяет копировать, переопределять и удалять существующие функции (в том числе встроенные в язык), динамически делать класс потомком другого класса, наследуя всё содержимое (runkit\_class\_adopt), или откреплять класс от родителя, удаляя унаследованное содержимое (runkit\_class\_emancipate). Также можно добавлять, копировать, переопределять и удалять методы существующих классов, добавлять и удалять их свойства. Кроме того, Runkit позволяет переопределять и удалять определенные ранее константы.
### Runkit\_Sandbox
Вторая большая часть функционала – «песочницы» Runkit\_Sandbox. Они позволяют выполнять часть программы на PHP в изолированном окружении. У каждой «песочницы» могут быть по-своему настроены параметры безопасности PHP такие как safe\_mode, safe\_mode\_gid, safe\_mode\_include\_dir, open\_basedir, allow\_url\_fopen, disable\_functions, disable\_classes. Кроме того, каждая «песочница» может по-своему настраивать внутри себя функционал Runkit: проставлять свои суперглобальные переменные (о них речь пойдет ниже) и запрещать изменение встроенных функций.
«Песочницы» могут подключать PHP-файлы (через include(), include\_once(), require() и require\_once()), вызывать внутри себя функции, выполнять произвольный код на PHP, печатать значения своих внутренних переменных, завершать свою работу. Кроме того, можно указать функцию для перехвата и обработки вывода «песочницы».
Внутри «песочницы» также можно создать объект «анти-песочницы» Runkit\_Sandbox\_Parent для связи «песочницы» с родительским окружением. Функционал «анти-песочниц» очень похож на функционал «песочниц», но из соображений безопасности, каждая связующая с внешним окружением функция должна быть явно включена при создании «песочницы».
### Superglobals
Runkit также позволяет добавлять в PHP новые суперглобальные переменные. Чтобы добавить такие переменные, достаточно перечислить их имена через запятую в свойстве runkit.superglobal внутри файла конфигурации PHP.
### Прочее
Помимо трех основных частей функционала в Runkit также есть средства для проверки синтаксиса кода на PHP (runkit\_lint и runkit\_lint\_file) и функция runkit\_import, позволяющая импортировать PHP-файл подобно include, но игнорирующая весь глобальный код в этом файле. В зависимости от флагов runkit\_import может импортировать функции или классы (полностью или частично), переопределяя или сохраняя уже существующие.
Зачем нужен Runkit?
-------------------
Runkit помогает PHP-программистам решать множество различных задач. Расскажу о нескольких основных.
### Патчинг чужих программ
Представьте, что вы используете стороннюю библиотеку (или фреймворк) и в какой-то момент вам понадобилось изменить ее поведение. Однако код, который нужно изменить находится в private-методе одного из классов библиотеки. Очевидное решение — отредактировать файл, содержащий этот метод. Это рабочее решение, однако код библиотеки теперь изменен и ее обновление становится хлопотной задачей, потому что нужно будет применять патч при каждом обновлении библиотеки. Другое решение — с помощью Runkit переопределить интересующий нас метод, это делается с помощью одного вызова функции runkit\_method\_redefine. Аналогичное решение есть для переопределения уже существующих в программе функций (runkit\_function\_redefine) и констант (runkit\_constant\_redefine). Подобное изменение кода программы во время выполнения называется «monkey patching». На специализированных интернет-форумах можно найти различные рецепты патчинга с помощью Runkit таких библиотек как WordPress, 1С-Битрикс, CodeIngniter, Laravel и т.п. Для решения некоторых проблем бывает полезно заменять функции, встроенные в сам язык PHP, и Runkit это тоже умеет.
### Изолированное окружение для выполнения пользовательских скриптов
С помощью «песочниц» Runkit\_Sandbox часто делают окружения для выполнения пользовательского кода. При правильной настройке это дает возможность изолировать пользовательский код от основной системы. В простейшем виде это выглядит так:
```
$options = […];
$sandbox = new Runkit_Sandbox($options);
$sandbox->ini_set(…);
$sandbox->eval($code);
```
### Другие варианты использования
С помощью runkit можно также организовать обновление кода программы на лету, как это, например, делается в phpdaemon (см. [habrahabr.ru/post/104811](http://habrahabr.ru/post/104811/)).
### Юнит-тесты
Возможности Runkit по переопределению функций и методов делают его крайне полезным при написании unit-тестов на PHP. С помощью Runkit изготовление тестовых двойников (заглушек или «шпионов») во время выполнения тестов становится простым делом, даже если архитектура тестируемого кода не поддерживает [dependency injection](https://ru.wikipedia.org/wiki/%D0%92%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8). Существуют готовые библиотеки, реализующих подмену методов и функций PHP на заглушки в контексте unit-тестов (например, [ytest](https://github.com/rsaugier/ytest), [phpspy](https://github.com/christopheraue/phpspy) и другие). При правильном выборе библиотеки можно получить изумительно простые тесты (см. например, [здесь](https://github.com/zenovich/phptest/blob/master/tests/lib/PHPTest/Spy/StubTest.php)).
История развития Runkit
-----------------------
### Начало
Runkit был создан в 2005-м году Сарой Големон ([Sara Golemon](https://github.com/sgolemon)). Последний авторский релиз (версия 0.9) был выпущен 06.06.06. В октябре 2006-го года Сара перестала поддерживать расширение, так и не выпустив версию 1.0. На тот момент Runkit содержал в себе функции для манипулирования константами, функциями, методами, runkit\_import, функцию добавления свойств в классы, функции проверки синтаксиса, песочницы и суперглобальные переменные. Документация на сайте php.net (<http://php.net/runkit>) застыла в районе версии 0.7, так что в ней до сих пор не описана даже часть функций, сделанных самой Сарой. Кроме того, в этой документации весь функционал Runkit называется экспериментальным, что было актуально в 2006-м, но абсолютно не соответствует действительности сейчас.
### Упадок
С октября 2006-го по октябрь 2009-го расширение никем не поддерживалось, а язык PHP шел вперед, из-за чего, несмотря на правки от участников PHP-сообщества, уже в версии PHP 5.2 Runkit работал нестабильно и вызывал ошибки сегментации.
### Возрождение
В октябре 2009-го я стал чинить Runkit, а потом и развивать его на <https://github.com/zenovich/runkit>. Расскажу, какие релизы выпущены за это время и какие изменения в них включены.
#### Релиз 1.0.0 (1 апреля 2010 года)
На самом деле этого релиза никогда не было, он фиктивный :). К нему относятся все правки сообщества после выпуска версии 0.9 и до релиза 1.0.1.
#### Релиз 1.0.1 (3 октября 2010 года)
Первый настоящий релиз Runkit после 2006-го года. Теперь Runkit поддерживает все версии PHP до 5.3 включительно. Исправлено более десяти серьезных ошибок, в том числе приводивших к падениям PHP. Основные из них:
* устранены падения при импорте через runkit\_import() свойств и констант со значениями-массивами,
* устранены падения при импорте функций и методов со статическими переменными,
* устранено падение при манипуляциях с функциями,
* устранено падение runkit\_method\_copy при работе с protected методами,
* устранено падение при завершении работы PHP после изменения встроенных функций,
* устранено падение при вызове исходного метода после применения к нему функции runkit\_method\_copy, если в методе были статические переменные,
* имена создаваемых методов больше не переводятся в нижний регистр.
В релизе 1.0.1 добавлена возможность определять и модифицировать статические методы с помощью новой константы RUNKIT\_ACC\_STATIC:
```
runkit_method_add('MyClass', 'newMethod', '$arg1, $arg2', '/* some code here*/', RUNKIT_ACC_STATIC);
```
Также добавлена возможность импортировать статические свойства класса. При импорте класса статические свойства будут копироваться по умолчанию, однако их импорт можно отключить с помощью новой константы RUNKIT\_IMPORT\_CLASS\_STATIC\_PROPS:
```
runkit_import('myfile.inc', RUNKIT_IMPORT_CLASSES); // импортировать классы целиком
runkit_import('myfile.inc', RUNKIT_IMPORT_CLASSES & ~ RUNKIT_IMPORT_CLASS_STATIC_PROPS); // импортировать классы, но не импортировать их статические свойства
runkit_import('myfile.inc', RUNKIT_IMPORT_CLASS_STATIC_PROPS); // импортировать только статические свойства классов
```
Кроме того, в релизе была добавлена возможность применять замыкание к песочнице с помощью Runkit\_Sandbox::call\_user\_func().
#### Релиз 1.0.2 (5 октября 2010 года)
Баг-фикс предыдущего релиза. Улучшена совместимость с PHP 5.3.
#### Релиз 1.0.3 (2 января 2012 года)
Исправлено наследование при переименовании методов с помощью runkit\_method\_rename. Починена сборка расширения под Windows.
#### **Релиз 1.0.4 (25 сентября 2015 года)**
Долгожданный Мега-Релиз! Полная поддержка PHP5 (вплоть до PHP 5.6 включительно).
В этом релизе было сделано очень много для стабилизации работы Runkit: тесты прогонялись для каждой версии PHP в четырех вариантах: c ZTS и без, под valgrind и без. Практически по каждому изменению добавлялись новые тесты. Благодаря этому удалось выявить и исправить огромное количество ошибок.
Среди важных исправлений можно выделить следующие:
* устранены падения при изменении, удалении или переименовании функций, методов и свойств классов, для которых ранее были созданы объекты Reflection,
* устранено падение при создании Runkit\_Sandbox при включенной настройке register\_globals,
* устранено падение при ошибке синтаксиса в файле, загружаемом через runkit\_import(),
* устранено падение при работе с константами, имеющими имена из одного символа,
* устранено падение при вызове переименованного private или protected метода.
Всего в релизе было сделано больше сорока (!!!) важных исправлений, их полный список можно посмотреть в файле [package.xml](https://github.com/zenovich/runkit/blob/master/package.xml).
Теперь расскажу о главных изменениях функционала.
##### **Функции и методы**
###### **Closures**
Для PHP 5.3+ функции runkit\_function\_add, runkit\_function\_redefine, runkit\_method\_add и runkit\_method\_redefine теперь поддерживают замыкания (closure) в качестве параметров. Например, если раньше для переопределения функции нужно было писать выражение вида
```
runkit_function_redefine('sprintf', '$s', 'return $s;');
```
которое для превращения строки в байт-код использовало eval, что очень медленно, то теперь можно писать
```
runkit_function_redefine('sprintf', function($s) {return $s;});
```
Никаких eval’ов при этом не выполняется, к тому же поддерживать такой код намного проще – больше нет частей программы внутри строковых литералов! То же самое касается функций runkit\_function\_add, runkit\_method\_add и runkit\_method\_redefine.
###### **Магические методы**
Также в Runkit теперь полностью поддержаны манипуляции с магическими методами \_\_get, \_\_set, \_\_isset, \_\_unset, \_\_clone, \_\_call, \_\_callStatic, serialize, unserialize, \_\_debugInfo и \_\_toString. То же самое касается конструкторов и деструкторов как при современном способе наименования, так и при наименовании в стиле PHP4.
###### **Doc-comments**
Теперь при добавлении или переопределении методов и функций с помощью старого синтаксиса (когда аргументы новой функции и ее тело передаются строками) можно указывать doc-comment’ы. С этой целью у функций runkit\_function\_add, runkit\_function\_redefine, runkit\_method\_add и runkit\_method\_redefine появился новый опциональный (последний по порядку) аргумент – doc\_comment:
```
runkit_method_redefine('MyClass','myMethod', '$arg', 'return $arg', RUNKIT_ACC_PRIVATE, 'my doc_comment'); // переопределяет приватный метод с doc-comment’ом
runkit_method_add('MyClass','myMethod2', '$arg', 'return $arg', NULL, 'my doc_comment2'); // добавляет приватный метод с doc-comment’ом
```
При определении функций и методов в новом стиле (через замыкания) doc-comment’ы можно задавать так же, как это делается при определении обычных функций, – через комментарии над телом функции. Оба способа можно комбинировать – приоритет у doc-comment’а, переданного через аргумент. Кроме того, было починено проставление doc-comment’ов при наследовании, копировании и переименовании методов и функций.
###### **Возврат значений по ссылке**
Добавлена возможность добавлять и переопределять функции и методы так, чтобы новая функция (или метод) возвращала значение по ссылке. Для того чтобы новая функция, заданная с использованием старого синтаксиса (когда аргументы новой функции и ее тело передаются строками), возвращала значение по ссылке, нужно передать в функцию runkit\_function\_add (или runkit\_function\_redefine) новый аргумент – return\_ref – со значением TRUE. Например,
```
runkit_function_redefine('my_function', '$a', 'return $a;', TRUE); // возвращает значение по ссылке
```
При аналогичном добавлении (или переопределении) метода используется аргумент flags с установленным битом RUNKIT\_ACC\_RETURN\_REFERENCE. Например,
```
runkit_method_redefine('MyClass', 'myMethod', '$a', 'return $a;', RUNKIT_ACC_PROTECTED | RUNKIT_ACC_RETURN_REFERENCE); // protected-метод возвращает значение по ссылке
```
Если же вы определяете функцию или метод с помощью нового синтаксиса (через замыкания), то все эти флаги вам не нужны – достаточно добавить амперсанд перед списком аргументов функции:
```
runkit_function_redefine('my_function', function &($a) {return $a;}); // возвращает значение по ссылке
```
##### **Свойства классов**
Внутренняя реализация манипуляций со свойствами классов была полностью переработана. Добавление, удаление и импорт свойств класса теперь правильно отражаются на классах-потомках. Более того, теперь эти действия могут влиять и на объекты класса и его потомков. Чтобы включить такое влияние, нужно установить бит RUNKIT\_OVERRIDE\_OBJECTS в аргументе flags при вызове функций runkit\_default\_property\_add и runkit\_default\_property\_redefine. Например,
```
runkit_default_property_add('MyClass', 'newProperty', 'value'); // не влияет на объекты класса и его потомков
runkit_default_property_add('MyClass', 'newProperty', 'value', RUNKIT_OVERRIDE_OBJECTS); // добавит свойство не только в классы и классы-потомки, но и в их объекты
```
То же самое касается и импорта свойств классов:
```
runkit_import('myfile.inc', RUNKIT_IMPORT_CLASS_PROPS); // импортирует свойства классов, не переопределяя существующие свойства и не затрагивая объекты
runkit_import('myfile.inc', RUNKIT_IMPORT_CLASS_PROPS | RUNKIT_IMPORT_OVERRIDE); // импортирует свойства классов, переопределяя существующие свойства, но не затрагивая объекты
runkit_import('myfile.inc', RUNKIT_IMPORT_CLASS_PROPS | RUNKIT_IMPORT_OVERRIDE | RUNKIT_OVERRIDE_OBJECTS); // импортирует свойства классов, переопределяя существующие свойства и изменяя свойства в объектах
```
Кроме того, была добавлена новая функция runkit\_default\_property\_remove() для удаления свойств из классов. Чтобы удалять свойство не только из класса, но и из его объектов у функции runkit\_default\_property\_remove есть третий необязательный параметр:
```
runkit_default_property_remove('MyClass', 'myProperty'); // удаляет свойство из класса, но оставляет его в объектах
runkit_default_property_remove('MyClass', 'myProperty', TRUE); // удаляет свойство из класса и из его объектов
```
Также теперь при добавлении и переопределении свойств классов теперь можно использовать не только скалярные значения, но и массивы.
##### **Классы**
Раньше функции runkit\_class\_adopt и runkit\_class\_emancipate хотя и меняли содержимое классов, но не влияли на их иерархию (т.е. после применения runkit\_class\_adopt у класса формально по-прежнему не было родителя, а после runkit\_class\_emancipate родитель по-прежнему оставался). Теперь это исправлено.
##### **Регистр в именах сущностей и namespaces**
Работа с константами, функциями, методами и свойствами теперь полностью поддерживает namespace’ы. Также Runkit перестал переводить в нижний регистр названия свойств, классов, методов и функций, которые он создает (как это было раньше).
##### **Дополнительная безопасность песочниц**
Для песочниц Runkit\_Sandbox теперь можно отключать INI-настройку allow\_url\_include. Также теперь, независимо от платформы, настройка open\_basedir поддерживает списки путей (раньше можно было ввести только один путь).
##### **Обновления**
Обновлять Runkit стало намного проще. Теперь это можно делать привычным для всех пользователей PECL способом через **официальный канал pecl.php.net**. Чтобы установить последний релиз Runkit’а, достаточно набрать
```
pecl install runkit
```
Кроме того, все архивы с релизами теперь доступны по адресу <http://pecl.php.net/runkit>.
Заключение
----------
Сейчас Runkit используется во многих известных компаниях и проектах по всему миру как для unit-тестирования, так и для многих других задач. Уверен, что впереди его ждет большое будущее. Это станет возможным благодаря пожертвованиям, которые теперь можно делать одним кликом со страницы проекта [github.com/zenovich/runkit](https://github.com/zenovich/runkit) или прямо из phpinfo().
Спасибо! | https://habr.com/ru/post/267495/ | null | ru | null |
# FreeRTOS: межпроцессное взаимодействие
Здравствуйте. В данной статье я постараюсь описать метод межпроцессного обмена данными и синхронизацию с эвентами.
Ссылки на остальные части:
[FreeRTOS: введение.](http://habrahabr.ru/blogs/controllers/129105/)
[FreeRTOS: мьютексы и критические секции.](http://habrahabr.ru/blogs/controllers/129445/)
Любая многопоточная ОС, не будет считаться полной, без соответствующих средств поддержки многопоточного окружения. FreeRTOS обладает всем необходимым для этого, а именно:
* Очереди, для обмена данными между тасками, или ISR.
* Бинарные семафоры, и счетные семафоры для синхронизации с эвентами (прерываниями).
* Мьютексы, для совместного доступа к ресурсу (например, порт).
* Критические секции, для создания области кода, выполнение которой не может быть прервано планировщиком.
#### Очереди.
Программы, написанные с помощью FreeRTOS представляют собой набор независимых тасков, или миниподпрограмм, которым требуется эффективный и потокобезопасный механизм обмена данными, в случае FreeRTOS — это очереди.
Очередь — это простой FIFO(хотя также можно писать в начало очереди, а не в конец) буфер, который может хранить фиксированное число элементов, известного размера. Запись в очередь — это побайтовое копирование данных в буфер, чтение — копирование данных и удаление из очереди.
Очереди — это, по сути, независимые объекты, которые могут иметь множество писателей, и читателей, без боязни прочитать\записать битые данные. При чтении данных, опционально, мы можем указать время, в течение которого таск должен находится в ожидании получения новых данных. При записи данных мы также можем указать данное время, но уже для ожидания места в очереди.
Рассмотрим более подробно основные функции по работе с очередями в FreeRTOS.
Перед использованием любой очереди, она должна быть создана. RAM память для очереди выделяется из FreeRTOS хипа, и ее размер равен размер данных+размер структуры очереди. В коде каждая очередь представлена ее хэндлом, типа xQueueHandle.
```
xQueueHandle xQueueCreate(unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize);
```
***uxQueueLength*** — максимальное число элементов, которое очередь может хранить в единицу времени.
***uxItemSize*** — размер каждого элемента очереди.
***return xQueueHandle, или NULL*** — в случае если очередь создана будет возвращен соответствующий хэндл, если нет, т.е. недостаточно памяти, то будет возвращен NULL.
Для записи в очередь используют, также специальные функции:
```
portBASE_TYPE xQueueSendToFront(xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait);
portBASE_TYPE xQueueSendToBack(xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait); // Или эквивалент portBASE_TYPE xQueueSend(xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait);
```
***xQueue*** — хэндл очереди, в которую записываем данные.
***pvItemToQueue*** — указатель на элемент, который будет помещен в очередь.
***xTicksToWait*** — время, в течение которого таск должен находиться в заблокированном состоянии, чтобы появилось место в очереди. Можно указать **portMAX\_DELAY**, чтобы таск находился в блокированном состоянии в течение неопределенного времени, т.е. пока не появится место в очереди.
***return pdPASS, или errQUEUE\_FULL*** — в случае, если новый элемент успешно записан в очередь, то функция возвращает pdPASS, если места не достаточно, и указано время xTicksToWait, то таск перейдет в заблокированное время, для ожидания места в очереди.
Для чтения данных, используются 2 функции, основное отличие, которых в том, что xQueueReceive удаляет элемент из очереди, а xQueuePeek — нет.
```
portBASE_TYPE xQueueReceive(xQueueHandle xQueue, const void * pvBuffer, portTickType xTicksToWait);
portBASE_TYPE xQueuePeek(xQueueHandle xQueue, const void * pvBuffer, portTickType xTicksToWait);
```
***xQueue*** — хэндл очереди, в которую записываем данные.
***pvBuffer*** — указатель на буфер памяти, в который будут прочитаны данные из очереди. Тип буфера=типу элементов очереди.
***xTicksToWait*** — время, в течение которого таск должен находиться в заблокированном состоянии, чтобы данные появились в очереди. Можно указать **portMAX\_DELAY**, чтобы таск находился в блокированном состоянии в течение неопределенного времени, т.е. пока не появятся новые данные в очереди. Далее я расскажу, как это используют для создания Gatekeeper Task.
***return pdPASS, или errQUEUE\_EMPTY*** — в случае, если новый элемент успешно прочитан из очереди, то функция возвращает pdPASS, если очередь пуста, и указано время xTicksToWait, то таск перейдет в заблокированное время, для ожидания новых данных в очереди.
Для просмотра количества элементов в очереди, можно использовать функцию
```
unsigned portBASE_TYPE uxQueueMessagesWaiting( xQueueHandle xQueue );
```
Важно: вышерассмотренные функции, нельзя использовать в ISR(прерываниях) и для них существуют, специальные версии со специальным суффиксом **ISR**, поведение которых аналогично предыдущим функциям, за исключением последнего параметра:
```
portBASE_TYPE xQueueSendToFrontFromISR( xQueueHandle xQueue, void *pvItemToQueue, portBASE_TYPE *pxHigherPriorityTaskWoken );
portBASE_TYPE xQueueSendToBackFromISR(xQueueHandle xQueue, void *pvItemToQueue, portBASE_TYPE *pxHigherPriorityTaskWoken);
portBASE_TYPE xQueueReceiveFromISR(xQueueHandle xQueue, const void *pvBuffer, portBASE_TYPE *pxHigherPriorityTaskWoken);
```
***pxHigherPriorityTaskWoken*** — так как запись в очередь может привести к разблокированию таска, ожидающего данных и имеющего большой приоритет, чем текущий таск, то нам необходимо выполнить форсированное переключение контекста (для этого необходимо вызвать макрос taskYIELD()). В случае необходимости данный параметр будет равен **pdTRUE**.
Пару слов об эффективном использовании очередей. Например, рассмотрим UART — при типичном подходе, каждый полученный байт сразу записывают в очередь, что делать не стоит т.к. это жутко неэффективно, уже на достаточно небольших частотах. Более эффективно — проводить базовую обработку данных в ISR и затем передавать их в очередь, но важно понимать — код ISR при этом должен быть как можно короче.
Рассмотрим пример, так называемого gatekeeper task(не знаю, как корректно перевести это, если кто подскажет, буду благодарен:)).
Gatekeeper task — это простой метод, который позволяет избежать главных проблем многопоточного программирования: инвертирования приоритетов, и попадания таска в тупик(deadlock).
Gatekeeper task — это единственный метод, который имеет прямой доступ к ресурсу, все остальные таски должны обращаться к ресурсу через этот таск.
Рассмотрим, простой скелет gatekeeper task. Это чисто надуманный пример, но который поможет понять общий принцип. Примем, что нам необходимо безопасно отправлять некоторые данные, например, через UART.
```
// Gatekeeper фактически является обычным таском.
void vGatekeeperTask( void *pvParameteres ) {
char oneByte;
// Данный таск - это единственное место, которое будет иметь доступ к UART порту, и все остальные таски должны передавать данные через него.
for( ;; ) {
// Но его тело отличается.
// Так как мы указали portMAX_DELAY в качестве времени ожидания, то нет необходимости проверять возвращаемое значение.
// Возврат из функции произойдет только, если данные прочитаны из очереди.
xQueueReceive( xDataQueue, &oneByte, portMAX_DELAY);
// Нижеследующий код исполниться только, если мы получили новые данные.
vSendByteToUART( oneByte );
// Переходим в режим ожидания.
}
}
```
Таким образом, любой таск, который захочет отправить байт с помощью UART может использовать, одну из служебных функций, например, такую:
```
void vUARTPutByte( char byte) {
// Я указал время ожидание равное нулю, хотя можно было также установить некоторое значение, на случай переполнения очереди.
xQueueSend( xDataQueue, &byte, 0 );
}
```
Стоит также отметить, что не стоит ограничиваться, только char в качестве типа данных очереди, а можно организовывать целые конвейеры, используя структуры.
#### Бинарные семафоры.
Бинарные семафоры, могут использоваться для разблокирования таска, всякий раз, когда происходит какой-либо эвент (например, нажатие кнопки).
Типичный сценарий работы: при попадании в ISR определенного прерывания, мы *отдаем* семафор, в результате таск, ожидающий семафора *забирает* семафор и выходит из разблокированного состояния для проведения каких-либо операций. Данный механизм, показан на следующем рисунке.
Для хранения всех типов семафоров, используется тип данных *xSemaphoreHandle*.
Рассмотрим функции для работы с семафорами:
```
void vSemaphoreCreateBinary( xSemaphoreHandle xSemaphore );
```
***xSemaphore*** — данная функция реализована с помощью макроса, поэтому необходимо передавать значение хэндла, а не указатель на него. В случае успешного создания семафора, значение xSemaphore не равно NULL.
Для того чтобы «взять» семафор используется специальная функция:
```
portBASE_TYPE xSemaphoreTake( xSemaphoreHandle xSemaphore, portTickType xTicksToWait );
```
***xSemaphore*** — хэндл семафора, который планируется «взять».
***xTicksToWait*** — время, в течение которого таск должен находиться в заблокированном состоянии, по истечении которого семафор станет доступен. Можно указать **portMAX\_DELAY**, чтобы таск находился в заблокированном состоянии в течение неопределенного времени, т.е. пока семафор не будет доступен.
***return pdPASS, или pdFALSE*** — pdPASS — если семафор получен, pdFALSE — если семафор недоступен.
Для того чтобы «отдать» семафор, также используются специальные функции. Я рассмотрю ISR версию т.к. наиболее часто семафоры применяют в связке с ISR.
```
portBASE_TYPE xSemaphoreGiveFromISR( xSemaphoreHandle xSemaphore, portBASE_TYPE *pxHigherPriorityTaskWoken );
```
***xSemaphore*** — хэндл семафора, который планируется «отдать».
***pxHigherPriorityTaskWoken*** — так как «передача» семафора может привести к разблокированию таска, ожидающего данных семафора имеющего большой приоритет, чем текущий таск, то нам необходимо выполнить форсированное переключение контекста (для этого необходимо вызвать макрос taskYIELD()). В случае необходимости данный параметр будет равен **pdTRUE**.
***return pdPASS, или pdFALSE*** — pdPASS — если семафор отдан, pdFALSE — если семафор уже доступен, но не обработан.
В качестве примера, приведу короткий код программы, для ISR я написал псевдокод:
```
xSemaphoreHandle xButtonSemaphore;
void vButtonHandlerTask( void *pvParameteres ) {
for( ;; ) {
xSemaphoreTake( xButtonSemaphore, portMAX_DELAY );
// Здесь нужно разместить код по нажатию кнопки.
}
}
void main() {
// Инициализация микроконтроллера
vInitSystem();
vSemaphoreCreateBinary( xButtonSemaphore );
if( xButtonSemaphore != NULL ) {
// Создание тасков. Я не включил код проверки ошибок, не стоит забывать об этом!
xTaskCreate( &vButtonHandlerTask, (signed char *)"GreenBlink", configMINIMAL_STACK_SIZE, NULL, 1, NULL );
// Запуск планировщика, т.е. начало работы тасков.
vTaskStartScheduler();
}
// Сюда стоит поместить код обработки ошибок, в случае если планировщик не заработал, или семафор не был создан. Для простоты я использую просто бесконечный цикл.
for( ;; ) { }
}
ISR_FUNCTION processButton() {
portBASE_TYPE xTaskWoken;
if( buttonOnPressed ) {
xSemaphoreGiveFromISR( xButtonSemaphore, &xTaskWoken );
if( xTaskWoken == pdTRUE) {
taskYIELD();
}
}
}
```
#### Счётные семафоры.
Рассмотрим типичную ситуацию, которая существует при использовании семафоров:
1. Произошел какой-то эвент, который вызвал прерывание.
2. ISR «отдает» семафор, т.е. разблокирует ожидающий семафор таск.
3. Ожидающий таск «забирает» семафор.
4. После исполнения нужного кода таск опять переходит в блокированное состояние, ожидая новых эвентов.
Данный алгоритм отлично работает, но только не на больших частотах. На больших частотах необходимо использовать счетные семафоры, которые, как правило, используют в 2-х случаях:
* Также для синхронизации с эвентами, но на больших частотах.
* Управление ресурсами. В данном случае, количество семафоров обозначает количество доступных ресурсов.
Как указывалось выше, для хранения всех типов семафоров используется тип данных xSemaphoreHandle, и так как перед использованием семафора, он должен быть создан, то необходимо использовать специальную функцию для создания счетных семафоров:
```
xSemaphoreHandle xSemaphoreCreateCounting( unsigned portBASE_TYPE uxMaxCount, unsigned portBASE_TYPE uxInitialCount );
```
***uxMaxCount*** — максимальное количество семафоров, которое может хранить счетчик. По аналогии с очередью — это длина очереди.
***uxInitialCount*** — значение счетчика после создания семафора.
***return не NULL*** — функция возвращает не NULL значение, если семафор был создан.
В остальном для работы со счетными семафорами используются функции, аналогичные предыдущим. | https://habr.com/ru/post/129180/ | null | ru | null |
# AutoVIML: Автоматизированное машинное обучение
***Перевод статьи подготовлен специально для студентов курса*** [***«Промышленный ML на больших данных»***](https://otus.pw/A6d1/)
---
Машинное обучение обладает преимуществом обучения алгоритмов, которые автоматически улучшаются, используя полученный опыт. Существует N различных алгоритмов и методов машинного обучения, и вам, как правило, нужно попробовать множество из них, чтобы найти лучшую модель прогнозирования для вашего датасета - ту, которая будет иметь наивысшую точность.
Большинство методов машинного обучения, таких как регрессионные методы, классификация и другие модели, есть в Sklearn, но, чтобы выбрать, какой метод лучше всего подходит в нашем конкретном случае, нужно опробовать все эти модели вместе с настройкой гиперпараметров и найти наиболее эффективную модель. Вся эта работа отнимает много сил и времени, объем которых можно уменьшить с помощью пакета AutoVIML в Python.
AutoVIML – это открытый пакет Python, который упрощает машинное обучение. Что он делает, так это визуализирует ваши данные с помощью различных моделей машинного обучения и находит лучшую модель с наибольшей точностью для данного датасета. Нет необходимости делать предварительную обработку датасета перед передачей его в AutoVIML, он автоматически очищает ваши данные, помогает вам классифицировать переменные, выполняет сокращение функций, может обрабатывать данные различных типов – текстовые, числовые, даты и т.д. с помощью одной модели.
В этой статье мы узнаем, как пользоваться AutoVIML, чтобы сократить время и усилия, затрачиваемые на создание моделей машинного обучения. Мы посмотрим, как различные параметры, которые мы используем в AutoVIML, влияют на прогноз.
**Устанавливаем AutoVIML**
Как и любую другую python-библиотеку, `autoviml` мы будем устанавливать через `pip`.
```
pip install autoviml
```
**Импортируем AutoVIML**
```
from autoviml.Auto_ViML import Auto_ViML
```
**Загружаем датасет**
Для освоения AutoVIML подойдет любой датасет. В этой статье я использую датасет с данными сердечных заболеваний, который вы можете скачать с Kaggle. В нем есть различные атрибуты и целевая переменная.
```
import pandas as pd
df = pd.read_csv('heart_d.csv')
df
```
Dataset Used(Source: By Author) Теперь давайте разберемся, как использовать `autoviml` для создания модели прогнозирования с этим датасетом, и какие параметры есть в AutoVIML.
```
#Basic Example with all parameters
model, features, trainm, testm = Auto_ViML(
train,
target,
test,
sample_submission,
hyper_param="GS",
feature_reduction=True,
scoring_parameter="weighted-f1",
KMeans_Featurizer=False,
Boosting_Flag=False,
Binning_Flag=False,
Add_Poly=False,
Stacking_Flag=False,
Imbalanced_Flag=False,
verbose=0,
)
```
Из кода выше видно, как создать модель с помощью AutoVIML, и какие параметры мы можем использовать. Теперь давайте подробно обсудим, за что эти параметры отвечают.
1. `train`: должен содержать местоположение вашего датасета или, если вы загрузили его в *dataframe*, то имя *dataframe*. В нашем случае мы загрузили его в *dataframe* с именем «*df*», поэтому мы дадим ему значение «*df*».
2. `target`: содержит имя целевой переменной. В нашем случае она называется «*TenYearCHD*».
3. `test`: содержит тестовый датасет. Также мы можем оставить его пустым (и использовать ””), если у вас нет никакого тестового датасета, чтобы AutoVIML разделил датасет на обучающий и тестовый.
4. `sample_submission`*: мы оставим его пустым, чтобы он автоматически создавал представление в локальном каталоге.*
5. `hyper_param`: Мы будем использовать RandomizedSearchCV, потому что он в три раза быстрее, чем Grid Search CV. Дадим ему значение «RS».
6. `feature_reduction`*: Установим значение true, чтобы учитывать самую важную предикторную переменную для создания модели.*
7. `scoring_parameter`: вы можете задать свой собственный параметр для скоринга, либо он будет выбран в соответствии с моделью. Здесь мы используем «*Weighted-f1*».
8. `KMeans_featurizer`*: этот параметр должен стоять в значении true для линейного классификатора и false для XGboost или случайного классификатора, иначе есть риск переобучения.*
9. `boosting_flag`: используется для бустинга. Поставим значение *false*.
10. `binning_flag`*: по умолчанию стоит в значении false, но может быть установлен в true, когда мы хотим преобразовать верхние численные переменные в двоичные.*
11. `add_poly`: установим в *false*.
12. `stacking_flag`*: по умолчанию стоит в false. Если поставим значение true, то будет добавлена дополнительная функция, которая является производной от предсказаний другой модели. Оставим в значении false.*
13. `Imbalanced_flag`: если стоит значение *true*, то проверит данные на сбалансированность и уберет дисбаланс методом *SMOTING*.
14. `Verbose`: обычно используется для вывода выполняемых шагов. Поставим значение 3.
Теперь давайте используем все эти параметры для нашего датасета и создадим наиболее эффективную модель с высокой точностью при помощи AutoVIML.
```
model, features, trainm, testm = Auto_ViML(
train=df,
target="TenYearCHD",
test="",
sample_submission="",
hyper_param="RS",
feature_reduction=True,
scoring_parameter="weighted-f1",
KMeans_Featurizer=False,
Boosting_Flag=True,
Binning_Flag=False,
Add_Poly=False,
Stacking_Flag=True,
Imbalanced_Flag=True,
verbose=3
)
```
Давайте проанализируем полученный результат.
**1. Часть анализа данных**
**2. Чистка данных и отбор признаков**
**3. Балансировка данных и создание моделей**
**4. Отчет о классификации и матрица смежности**
**5. Визуализации моделей**
**6. Важность признаков и прогностическая вероятность**
В наборе выше мы видели, как AutoVIML обрабатывает данные, очищает их, балансирует переменную результата и создает лучшую модель вместе с визуализациями для лучшего понимания.
Аналогичным образом, вы можете изучить AutoVIML, используя различные датасеты, и поделиться своим опытом в комментариях. AutoVIML – простой способ создать эффективные модели машинного обучения, основываясь на вашем датасете.
> [**Узнать подробнее о курсе**](https://otus.pw/A6d1/)
>
>
### Читать ещё:
* [Представляем PyCaret: открытую low-code библиотеку машинного обучения на Python](https://habr.com/ru/company/otus/blog/497770/) | https://habr.com/ru/post/525292/ | null | ru | null |
# Контексты RTTI в Delphi 2010: как это работает и как их использовать
Delphi 2010 включает в себя расширенную поддержку RTTI, также известную как информация о типах времени выполнения (run-time type info) или рефлексия. Множество подходов в проектированию раньше были доступны только в управляемых языках, таких как C# и Java, так как для них необходима аннотация кода ([code annotation](http://en.wikipedia.org/wiki/Source_code_annotation)) и интроспекция (самоанализ). Теперь это возможно и в мире Delphi.
Что интересно в работе RTTI, так это его подход к организации пулов объектов. Delphi — это язык, не использующий «сборку мусора», так что пользователям нужно быть внимательными и уничтожать объекты, когда они больше не нужны, делая это явно, или создавая или используя какие-нибудь схемы владения (объектами), такие как используются TComponent-ом, где владелец (Owner) берет на себя ответственность за уничтожение объектов.
Порядок использования информации о типах не очень хорошо сочетается со схемой владения в стиле TComponent. Обычно, работая с RTTI, вам требуется выполнять поиск интересующих вас объектов, что-то с ними делать и продолжить работу дальше. Это означает, что множество объектов могут быть определены для проверки, но в действительности не использоваться. Управление временем существования этих объектов должно быть довольно утомительно, поэтому использован другой подход: единый глобальный RTTI пул объектов. Пока хотя бы один RTTI контекст активен в программе, пул объектов хранит все свои объекты в актуальном состоянии. Когда последний контекст выходит из области видимости — объекты освобождаются.
Управление пулом для работы использует запись Delphi, которая содержит ссылку на интерфейс. Когда любой переданный RTTI контекст используется в первый раз, он помещается в эту ссылку на интерфейс. Он помещается туда только в первый раз — однократно, потому что записи Delphi не поддерживают конструкторов по умолчанию, которые к тому же имеют свои собственные проблемы. Например, как вы обрабатываете исключения в конструкторе по умолчанию, во всех точках, где они могут возникнуть? Создание массивов, локальных для потока переменных, глобальных переменных, глобальных переменных в модулях, временных объектов в выражениях, и т. д. Это может стать отвратительным, а в C++ иногда и становится.
Таким образом, первое использование создает интерфейс, называющийся токен пула (pool token). Он действует как некий дескриптор со счетчиком ссылок, указывающий на глобальный пул объектов. До тех пор пока этот интерфейс актуален (существует), глобальный пул объектов будет оставаться актуальным. Даже если RTTI контекст куда-то скопирован, встроенная в Delphi логика управления интерфейсами, созданная на базе принципов COM, позволяет быть уверенными, что интерфейс не будет преждевременно удален, счетчик ссылок будет иметь верное значение. И когда RTTI контекст выходит из области видимости, или будучи локальной переменной в функции, которая завершилась, или полем в удаленном объекте, счетчик ссылок уменьшит свое значение. Когда счетчик ссылок достигает нуля — пул опустошается.
Наибольшее преимущество такого подхода состоит в том, что использование RTTI, в сущности, должно быть легким и интуитивно понятным. Нужно только в коде программы объявить переменную соответствующего типа и начать ее использовать:
`procedure Foo;
var
ctx: TRttiContext;
t: TRttiType;
begin
t := ctx.GetType(TypeInfo(Integer));
Writeln(t.Name);
end;`
Однако, обратная сторона, состоит в том, что «ленивая» инициализация может вызвать ошибку. Представим такой сценарий:
1. Библиотека A объявляет RTTI контекст A.C
2. Пользовательский код B объявляет RTTI контекст B.C
3. Код B запрашивает некоторые RTTI объекты O из B.C, для того чтобы передать их библиотеке A
4. B.C выходит из области видимости
5. Библиотека A сейчас пытается работать с O, но обнаруживает к своему удивлению, что объекты были преждевременно удалены, даже если A уже имеет RTTI контекст A.C
Проблема в том, что A никогда не использовала A.C, потому токен пула не был создан. Когда B.C использовал свой контекст, пул начал свое существование, и объекты O были назначены ему; но, после того как B.C вышел из области видимости, объекты были освобождены.
Решение этой проблемы — дать знать библиотеке A, что она использует долгоживущий RTTI контекст и что она рассчитывает взаимодействовать со сторонним кодом, который создает объекты из ее собственного RTTI контекста и передает их обратно, она должна быть уверена, что для этого долгоживущего контекста создан токен пула. Простой способ сделать это выглядит так:
`type
TFooManager = class
FCtx: TRttiContext;
// ...
constructor Create;
// ...
end;
constructor TFooManager.Create;
begin
FCtx.GetType(TypeInfo(Integer));
// ...
end;`
Это создаст только необходимый минимум RTTI объектов, которые нужны для представления типа System.Integer, но что более важно, даст уверенность в том, что FCtx имеет токен пула и оставит глобальный RTTI пул в актуальном состоянии.
В будущих версиях Delphi, статический метод TRttiContext.Create будет следить за тем, чтобы возвращаемое им значение получило токен пула; но пока что это не так. TRttiContext.Create был первоначально определен для того, чтобы сделать запись TRttiContext более похожей на класс для людей незнакомых с идиомой использования интерфейсов для автоматического детерминированного управления временем существования объектов. Соответствующий метод TRttiContext.Free удаляет токен пула, и должен остаться прежним.
[Translated.by: переведено толпой](http://translated.by/you/delphi-2010-rtti-contexts-how-they-work-and-a-usage-note/into-ru/)
Перевод: © [DreamerSole](http://translated.by/DreamerSole/), [r3code](https://habrahabr.ru/users/r3code/), [debose](https://habrahabr.ru/users/debose/). | https://habr.com/ru/post/86840/ | null | ru | null |
# Как ускорить миграцию Zabbix на TimescaleDB
После того, как в прошлой статье [Как мигрировать Zabbix с MySQL на PostgreSQL с минимальным downtime](https://habr.com/ru/post/513470/) я успешно перенес Zabbix с MySQL на PostgreSQL, встала необходимость сделать следующий шаг — мигрировать БД на TimescaleDB, т.к. ради нее все и затевалось.
У читателя может возникнуть вопрос: зачем нужна эта статья, если есть простой и понятный [мануал](https://www.zabbix.com/documentation/5.0/manual/appendix/install/timescaledb)?
Но проблема, как и в прошлой статье, скрыта в downtime. В мануале ясно написано:
> The migration of existing history and trend data may take a lot of time. Zabbix server and frontend must be down for the period of migration.
>
>
>
>
Исходные данные следующие:
* Zabbix 5.0
* СУБД PostgreSQL 12
* Применен патч [ENABLING EXTENDED RANGE OF NUMERIC (FLOAT) VALUES](https://www.zabbix.com/documentation/5.0/manual/installation/upgrade_notes_500)
* Установлен TimescaleDB 1.7 (поддержка 2.0 пока отсутствует)
Я всячески игрался с тюнингом PostgreSQL, добавлял ресурсы на виртуальную машину с PostgreSQL. Испытанный максимум ресурсов — 24 CPU, 64 GB RAM. Но, очевидно, скрипт миграции упирается в дисковую производительность. В итоге при моей базе данных размером в ~350 Гб миграция занимала 15 часов. Все это время мониторинг отключен.
Я пошел читать [документацию TimescaleDB по миграции данных](https://docs.timescale.com/latest/getting-started/migrating-data#same-db) и нашел такой способ, обозначенный как "Faster Method":
* выбираем таблицу, которую хотим мигрировать в гипертаблицу. Например, history
* создаем новую таблицу, аналогичную старой, при этом исключая индексы
```
CREATE TABLE history_new (LIKE history INCLUDING DEFAULTS INCLUDING CONSTRAINTS EXCLUDING INDEXES);
```
* конвертируем новую таблицу в гипертаблицу
```
SELECT create_hypertable('history_new', 'clock', chunk_interval => 86400);
```
* перемещаем все данные из history в history\_new
```
INSERT INTO history_new SELECT * FROM history;
```
* удаляем старую таблицу history
```
DROP TABLE IF EXISTS history;
```
* переименовываем history\_new в history
```
ALTER TABLE IF EXISTS history_new RENAME TO history;
```
* создаем индекс (как — описано в файле схемы БД schema.sql)
```
CREATE INDEX history_1 in history (itemid,clock);
```
И так надо сделать для таблиц:
* history
* history\_log
* history\_str
* history\_text
* history\_uint
* trends
* trends\_uint
Для ускорения процесса я поместил команды для каждой таблицы в отдельные файлы, чтобы запускать их параллельно.
[Ссылка на github репозиторий со скриптами](https://github.com/niklep/zabbix_timescaledb_scripts).
Скрипт finish.sql необходимо выполнить уже после завершения миграции всех таблиц.
В итоге миграция таблиц в гипертаблицы TimescaleDB в моем случае заняла 5 часов, что сильно меньше изначальных 15.
PROFIT. | https://habr.com/ru/post/549428/ | null | ru | null |
# iOS vs WPF — сложное против мелкомягкого
Друзья, ничего умнее этого заголовка не придумал, так что небольшая предыстория.
Как и все программисты, я не мог не услышать про новый язык Swift, на который тут же посыпались разнообразные «хелловорлды»-обучалки. Однако, простые с виду приложения создаются (на мой WPF-ный взгляд) как-то уж слишком сложно даже после введения «упрощённого» языка. Это действительно необходимая сложность или их можно создавать как-то попроще? Наткнулся на [вот такой пример](http://habrahabr.ru/post/225577/) iOS-приложения (что-то вроде браузера приложений в аппсторе) и решил создать его полный аналог на «родном» WPF'е. Цель — сравнить сложность разработки и возможно кто-то поделится более простым методом для iOS (если он есть). Обилия скринов не будет, зато кода — … да и его, в общем-то, кот наплакал. Итак,
Задача: показывать список приложений из АппСтора, найденных по указанному фильтру. Должны быть иконка, заголовок и цена каждого приложения. WPF'ный пример делается абсолютно идентичным оригинальному, вплоть до таких же косяков-задержек при загрузке иконок.
1. Запускаем Студию, создаём WPF приложение — два клика мышью + дать имя приложению.
2. Подключаем в references библиотеку Newtonsoft.Json.dll — она нам поможет разбирать JSON
3. Дополняем XAML-код главной формы нашим списком приложений и полем ввода с кнопкой вверху.
**Разметка формы**
```
Search
```
Как видно, код весьма прост — даже шаблон элементов описывается в привычных терминах.
4. Встаём курсором на SearchButton\_Clicked и жмём F12 — студия прыгнула в код и создала для нас обработчик, ну а мы допишем нужное.
**Немного C# магии**
```
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Net;
using System.Windows;
namespace StoreBrowser
{
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}
private void SearchButton_Clicked(object sender, RoutedEventArgs e)
{
var filter = txtFilter.Text.Trim();// подготовили фильтр
if (string.IsNullOrEmpty(filter)) return;
filter = Uri.EscapeUriString(filter.Replace(' ', '+'));
using (var wc = new WebClient()) {
// вот так двумя вызовами мы скачали JSON-ответ сервера и тут же распарсили в наши заготовленные классы
var res = JsonConvert.DeserializeObject(wc.DownloadString(@"https://itunes.apple.com/search?media=software&term=" + filter));
lstApps.ItemsSource = res.results;// показываем результат
}
}
}
class StoreReply
{
public int resultCount;
public List results;// тут сидит список наших приложений
}
class AppInfo
{ // обратите внимание - здесь далеко не все свойства приложения, мы указали только нужные нам.
public string trackName { get; set; }// title
public string formattedPrice { get; set; }// price
public string artworkUrl60 { get; set; }// icon
}
}
```
Думаю, тут даже излишне объяснять, насколько этот код лаконичнее тех Swift простыней, на двух страницах загружающих ответ.
5. Ну и чего сидим? Жмите F5! Вот результат по фильтру «angrybirds»:
Ещё раз обращу внимание, если вы не заметили: в коде нет ни строчки для загрузки картинок — они загружаются сами по мере прокрутки списка, мы только обеспечили их URL.
Итого, 30 строчек XAML + 44 C# кода. Я нарочно не стал делать всякую асинхронщину, т.к. глупо жать кнопку и тут же что-то менять — нужно дождаться результата, но если кому чешется, можете для [async/await](http://habrahabr.ru/post/107498/) прибавить ещё 4 строчки.
В любом случае, полученный код явно компактнее и проще Swift-оригинала, да и сам проект — всего одна форма:
Ну и обратите внимание на сам стиль работы — не нужно ничего никуда перетаскивать, подстраиваться под чей-то «взгляд на жизнь» (см. главу «Подключение интерфейса» в оригинале) — мы сами творим что хотим, хоть в XAML, хоть в C#.
Итог — «побырому» написанное приложение, которое я не напрягаясь сваял минут за 20 (это вместе с разбором JSON-ответа от Apple, который я впервые вижу). При этом одно только чтение iOS варианта вывихнуло мне весь мозг — там создай, туда перетащи, тут обеспечь функции… Чего ж так сложно, господа? С таким инструментом точно не возникнет желания наполнять аппстор чем-то полезным — слишком уж дорого эта польза даётся. Напомню, это мнение программиста на WPF/WinForms, так что ждём ответов из стана Apple!
PS
Критика — велкам; сначала читаем свои слова, думаем, потом постим. Спасибо!
UPD
Я предвидел, что будет определённая доля «соревновательного эффекта», но почему-то в русских сообществах программистов преобладает примитивно-быдлятский метод обсуждения: «да этот ваш XXX отстой! Вот у нас в YYY — ого-го!». Давайте я ещё раз отдельно напишу для тех, кто прочёл только первый абзац:
Я не пытаюсь воевать с Apple и её фанатами, мне самому было бы интересно (после стольких лет на Windows) освоить что-то новое (причём на удачно подвернувшемся, интересном языке). И когда я читаю урок по созданию (как бы) простейшего приложения, меня обескураживают сложности, с которыми приходится сталкиваться эппл-разработчикам, даже имея современный Swift. Я показал, как можно сделать похожее приложение на WPF (это мог быть вообще TurboPascal + Turbo Vision!). Мне WPF вариант кажется проще (не без помощи фрэймворка, конечно). И на этом фоне мне совсем непонятны жалкие попытки выставить WPF решение каким-то верблюдом — оно ничуть не хуже любого другого решения и в нём нет ничего «десктопного», чтобы его нельзя было сопоставить с iOS вариантом.
Так что заканчиваем мусолить WPF, просто предложите ПРОСТОЙ СПОСОБ сделать аналогичное приложение. Если его нет — упаси небо, я никого винить не буду, будем считать, что Apple уделила недостаточное внимание удобству разработки, только и всего. Пису пис! | https://habr.com/ru/post/231439/ | null | ru | null |
# О том, как мы на PHP запускали настоящий MS Excel и что из этого вышло
Не секрет, что зачастую PHP-программистам приходится решать задачи, весьма далёкие от бытового представления о «веб-разработке». Развитие языка в последние годы привело к тому, что PHP всё чаще считают языком общего назначения, пригодным не только для сайтов, но и для других задач.
Одну из таких «других» задач мне с коллективом пришлось решать совсем недавно. Мы решили поделиться «картой граблей» с теми, кто, возможно, пойдет по этому же пути.
### Дано
* Многие наши партнёры (скажем прямо — это крупные банки) любят считать что-то в Excel. Причем «любят» — это очень нежно сказано. Сложнейшие скоринговые модели могут быть «запрограммированы» в Excel, в файле из сотни листов с десятками макросов
* Перевести «программы», написанные в Excel на какой-либо язык программирования — практически нереально. Это займет уйму времени, а проблема постоянного обновления и проверки корректности делает такую задачу и вовсе нерешаемой
### Требуется
* Основная информационная система нашей компании написана на PHP. Она содержит в себе как веб-интерфейсы, так и множество консольных сервисов и воркеров.
* С этими «программами» в Excel нужно как-то взаимодействовать из консольных приложений на PHP — передавать в них данные, обсчитывать, получать результаты
Некоторое время нам хватало возможностей популярной библиотеки PHPExcel. Но когда от бизнеса поступило очередное требование «нужно, чтобы работали макросы, и еще бы хорошо всё это сохранять в PDF», стало понятно, что выбранный путь — тупиковый. Нужно не парсить файлы xlsx, не имитировать просчёт, и даже не использовать Open Office, а научиться взаимодействовать с «настоящим» Microsoft Excel.
В результате недолгих изысканий было решено создать внутренний микро-веб-сервис, который умел бы принять данные, открыть указанный файл Excel, вставить в него принятые данные, просчитать результат и выдать его в качестве ответа клиенту. Заинтересованность в таком веб-сервисе выразили несколько внутренних проектов и работа закипела.
### Сервер под Windows? А почему бы нет!
Первым под удар попал отдел dev-ops. Им предстояло подготовить сервер для будущего сервиса. Дело было необычным, поскольку актуального опыта работы с Windows ни у кого нет…
В качестве серверной платформы был выбран Windows Server 2012 R2 standart. Нужно сразу отметить, что «из коробки» Windows совершенно не приспособлена к хостингу приложений на PHP. Требовалось доведение системы до нужного уровня.
Для начала был установлен [PowerShellServer](http://www.powershellserver.com). Это позволило нам подключаться к windows-серверу по привычному всем протоколу ssh, не изобретая велосипедов. Поддерживается авторизация по ключам, работает rsync (это важно). Жаль, что в Personal Edition ограничение только на одно одновременное подключение, но для нас это некритично.
Nginx был установлен штатным образом. Взят со страницы [nginx.org/ru/download.html](http://nginx.org/ru/download.html) Имейте в виду — под windows есть существенные ограничения: только один рабочий процесс, который держит не более 1024 соединений. Впрочем, это опять же было некритично для внутреннего микро-сервиса.
PHP 7.0.9 взят с [windows.php.net/download](http://windows.php.net/download), установлен штатным образом.
Для упрощения перезапуска всего этого «добра» был написан несложный cmd-файл:
```
cd C:\nginx
taskkill /f /IM nginx.exe
taskkill /f /IM php-cgi.exe
rm C:\nginx\logs\*
start nginx
start -WindowStyle Hidden php\php-cgi -A "-b 0.0.0.0:9000 -c C:\server\php\php.ini"
```
Первоначальная настройка сервера закончилась успешным выводом страницы с phpinfo(). Однако это было еще только самое начало…
### Настраиваем сборку на Windows или Как наступить на все подводные камни?
Мы внутри компании используем Continuous Integration. Всегда. Для любого, сколь угодно малого проекта. Примерный план развертывания выглядит так:
* Сервер Teamcity следит за изменениями в нужных ветках репозитория (в данном конкретном случае workflow был упрощен до предела и ветка была фактически одна — master)
* Он же запускает сборку проекта при появлении изменений:
+ Содержимое репозитория с сервера TeamCity с помощью rsync доставляется на целевой сервер, во временную папку (это даёт нам возможность сэкономить на агентах TeamCity)
+ Там же, с помощью ssh, запускается билд-скрипт на phing, который и делает основную работу:
- Переносит код в постоянное место
- Устанавливает зависимости через composer
- Раскладывает конфиги
- Применяет миграции и так далее...
- И, наконец, переключает симлинк current (это у нас wwwroot), на новую папку
Что потребовалось далее? ssh-сервер уже установлен, rsync выполняется корректно. Установим phing:
* Исполняемый файл (phing.phar) берем с [www.phing.info/trac/wiki/Users/Installation](https://www.phing.info/trac/wiki/Users/Installation)
* Аккуратный и красивый bat-ник можно взять на [www.phing.info/trac/browser/bin/phing.bat](https://www.phing.info/trac/browser/bin/phing.bat)
* Не забываем добавить путь до phing в PATH, чтобы получить system-wide команду
Git for Windows берем с [git-scm.com](https://git-scm.com/), устанавливаем, проверяем корректную работу.
Точно по такой же схеме поступаем с composer, только bat-файл пишем сами и он будет значительно проще:
```
@echo off
if "%PHPBIN%" == "" set PHPBIN=C:\server\php\php.exe
"%PHPBIN%" "C:\nginx\php\composer.phar" %*
```
Вроде бы всё готово. Запускаем сборку… fail!
Причина 1. Нужно установить расширение php\_openssl.dll, иначе Phing не сможет работать с репозиториями через SSL. Проблем не доставило.
Причина 2. Более серьезная. В нашем сценарии сборки используется техника переключения симлинка на папку со свежей сборкой на последнем шаге. Примерно так:
```
```
В результате получается что-то вроде
`symlink: "c:\server\domains\this.service\master\current" => "c:\server\domains\this.service\master\2016-04-01-12-34-56"`
Оказалось, что создать символическую ссылку на NTFS — не проблема. Проблема ее удалить… Отчего-то операция удаления симлинка требует прав администратора, которых у обычного PHP нет и быть не может.
Нам помогла утилита junction ( [technet.microsoft.com/en-us/sysinternals/bb896768](https://technet.microsoft.com/en-us/sysinternals/bb896768) ). С ней вышеуказанный кусок сценария стал выглядеть примерно так:
```
```
Итак, всё встало на свои места, сборка заработала, как ей и положено. Настала пора писать код!
### COM-объекты в PHP
Надо отметить, что собственно код сервиса не доставил никаких проблем.
Как запустить приложение Microsoft Excel и загрузить в приложение существующий файл?
```
namespace App\Components;
class Excel
{
protected $xls;
public function __construct($filename = null)
{
$this->xls = new \COM("Excel.Application");
// @todo: выключить, если не требуется видеть работу приложения
$this->xls->Application->Visible = 1;
$this->xls->DisplayAlerts = 0;
if (empty($filename)) {
$this->xls->Workbooks->Add();
} else {
$this->xls->Workbooks->Open($filename);
}
$this->xls->Workbooks[1]->Activate();
}
}
```
Как закрыть приложение после окончания работы скрипта?
```
public function __destruct()
{
$this->xls->Workbooks[1]->Close(false);
$this->xls->Quit();
}
```
Получить список всех именованных диапазонов?
```
public function getNames()
{
$names = $this->xls->Names;
if ($names->Count == 0) {
return [];
} else {
$ret = [];
foreach ($names as $name) {
$ret[$name->Name] = $name->Value;
}
return $ret;
}
}
```
Установить значение ячейки или диапазона?
```
public function setValue($range, $value)
{
$this->xls->Range($range)->Value = iconv('UTF-8', 'Windows-1251', $value);
}
```
Прочесть значение из ячейки или диапазона?
Возвращается либо скалярное значение из одной ячейки, либо массив значений, если мы запрашиваем диапазон.
```
public function getValue($range)
{
$range = $this->xls->Range($range);
if ($range->Count == 1) {
$val = $range->Value;
return is_string($val) ? iconv('Windows-1251', 'UTF-8', $val) : $val;
} else {
$ret = [];
foreach ($range as $cell) {
$val = $cell->Value;
$ret[$cell->Address] = is_string($val) ? iconv('Windows-1251', 'UTF-8', $val) : $val;
}
return $ret;
}
}
```
Экспортировать книгу в PDF?
```
const FORMATS = [
'PDF' => 0
];
public function saveAs($filename, $format = self::FORMATS['PDF'])
{
// Будь проклят тот день, когда разработчики MS-DOS придумали обратные слэши!
$this->xls->Workbooks[1]->ExportAsFixedFormat($format, str_replace('/', '\\', $filename));
}
```
Что надо сделать, чтобы вся эта безумная магия заработала?
`Добавить расширение php_com_dotnet.dll`
### Вместо заключения
Довольно феерично наблюдать за сервером: при приходе запроса мгновенно открывается Excel, запускается экспорт и потом также мгновенно всё это хозяйство закрывается.
Удачи и не наступайте на те же грабли!
### Литература
1. [php.net/manual/en/book.com.php](http://php.net/manual/en/book.com.php)
2. [msdn.microsoft.com/ru-ru/library/wss56bz7.aspx](https://msdn.microsoft.com/ru-ru/library/wss56bz7.aspx)
3. [geektimes.ru/post/50878](https://geektimes.ru/post/50878/)
### P.S.
По итогам обсуждения в комментариях я решил добавить к статье несколько важных дополнений.
1. Нет, задача не сводится к тому, чтобы какой-то библиотекой для PHP уметь писать в файлы формата Excel или читать данные из них. Статья не об этом. Задача — запускать расчеты, алгоритм которых задан извне в виде файлов Excel (и нет никакой возможности алгоритм преобразовать во что-то другое), подавать на вход данные, получать ответы, формировать отчет. Для этой цели нет другого решения, кроме как запустить файл в «родном» приложении Microsoft Excel.
2. Файлов — сотни. Запросов на расчеты (то есть на запуск таких файлов) — тысячи в день. Это приводит нас к невозможности решения «а пусть кто-то сам вручную запускает эти файлы». Требуется полная и надежная автоматизация.
3. См. предыдущий пункт. Перевод алгоритмов на какой-либо язык программирования невозможен, поскольку затраты на верификацию и QA превысят затраты на windows-сервер на три порядка.
4. Веб-сервис написан для использования другими сервисами, а не клиентами-людьми.
5. Немного изменил метод public function getValue($range), чтобы показать, как прочесть диапазон ячеек, как одно целое. Добавил метод получения списка всех именованных диапазонов. | https://habr.com/ru/post/306408/ | null | ru | null |
# Сайты для детей — просто ли сделать серьёзный продукт «игрушечно»
В посте хочу поделиться «best practices» создания развивающих сайтов, для детей. Сразу оговорюсь: под словом «дети» я впредь буду иметь в виду не вундеркиндов, которые обыгрывают пап в шахматы и прочли все двенадцать томов «Детской энциклопедии», а обычные малыши, которые учатся читать, считать, постигают элементарную логику.
##### Отказываемся от взрослых догм
При создании веб сайта так и подмывает создать стандартный набор страниц: Контанты, Помощь, Карта Сайта — это все нужно, но не детям, а родителям и поисковому серверу, поэтому, ссылки на них лучше задать на стартовой странице, где родители помогают детям войти в систему, зарегистрироваться. Может, их родители захотят позвонить в службу поддержки или отослать резюме. Как только вход в систему осуществлен — все, начинается детская часть сайта.
**Пример**
Если вы покажете ребенку форму с полями ввода и текстовыми подсказками, он подумает «почему не началась игра, пойду позову папу». Ошибки в данном примере две:
1. ребенок не будет читать сообщений, не заметит или не захочет
2. ребенок не будет вводить много данных, даже если будет знать что ввести
Разберем по порядку:
если наш маленький пользователь не замечает сообщение — выход есть, нужно это сообщение произнести. Для лучшего эффекта — лучше найти человека с приятным голосом и попросить их записать несколько wav файлов. После — использовать звук ан странице.
```
```
или
```
var privetWav = new Audio('privet.wav');
privetWav.play();
```
Итак, вроде протоптана тропинка — мы можем передавать информацию визуально и с помощью звука. Форма с полями все еще здесь? Надо бы ее перенести на часть сайта для родителей.
**другой пример**
Ветвление сайта иногда достигает невероятных размеров. Сайт ориентирован на детского потребителя, а дети
1. не привыкли пользоваться вложенными меню, breadcrumbsm, картой сайта
2. часто не осознают на какой ступени сайта они находятся
3. дети не так фанатично ценят время как взрослые, ускоренных доступ, горячие клавиши им ни к чему
4. дети не самостоятельны в учебном/развивающем процессе, если можно играть или изучать — они предпочтут играть
Решение: меню и прочие элементы контроля выбрасываем — а как переходить с одной страницы на другую? программы/сайта нужно преобразовать в линейную структуру.
Пример преобразования
страница содержит меню:
* пройти занятие,
* посмотреть свои оценки
* поиграть в игру
* завершить занятия
много веток, за каждой стоит свой сценарий.
преобразовываем в линейную структуру:
звуковое сообщение: *Привет, давай начнем занятие, нажми кнопку, если готов*
далее идет учебное занятие
звуковое сообщение: *Молодец, теперь время поиграть, нажми кнопку, если готов*
идет игра
звуковое сообщение: *Молодец, ты побил свой рекорд и получаешь трофеи*
звуковое сообщение: *нажми на кнопку чтобы начать новое задание, или нажми «Выход»*
Меню преобразовалось в последовательность действий, а главное, игры идут не сначала, а на десерт. Программа руководит учебным процессом, она не задает много вопросов, не просит заполнить форм, просто сиди и занимайся.
##### Делаем пользовательский интерфейс «игрушечным».
###### Нажатие кнопки.
Оно должно быть осязаемым, если кому-то не столь важно подсветилась ли кнопка при наведении курсора миши, а важно перечислена ли сумма со счета на счет после нажатия — то для детей важно, чтобы эта кнопка не только подсвечивалась при наведении, но и издавала звук при нажатии — это дает малышу понять, что он попал по кнопке.
###### эффект «сейчас что-то будет».
Когда игра стартует — нельзя начинать ее сию секунду, в настоящем мире мало что происходит мгновенно. Поэтому надо предупредить: «настарт, внимание, марш» или «3 2 1» или по крайней мере немного дольше показать прогресс загрузки (preloader)
###### вознаграждение.
За проделанную работу нужно давать вознаграждение. Иначе пропадает позитивная мотивация, остается только негативная «если не сделаешь задание — не получишь конфету»
В качестве призов могут быть виртуальные «трофеи» или псевдо-деньги, на которые потом можно купить, например, новые антенны для виртуального робота.
###### Персонажи
Персонажи играют важную роль в восприятии. Звери — беспроигрышный вариант и для мальчиков и для девочек. Однако разделять пользователей на мальчиков и девочек не стоит, бывают девочки, которые интересуются робототехникой.
Конечно, для детского сайта нужен художник.
Кнопки, поля ввода — большое, с подсвечивающимся фокусом. Водимые буквы и цифры — тоже большие, чтобы пользователь легко попал мышкой.
##### Вместо завершения
Не такое уж простое дело — сделать простой детский сайт. Домашнее задание — подумайте, а как бы выглядела детская социальная сеть. | https://habr.com/ru/post/203958/ | null | ru | null |
# Переезд с Ubuntu на Windows 10, Hyper-V и избавление от железного маршрутизатора
Купив новый ноутбук, я с сожалением заметил, что моя любимая Ubuntu больше не поддерживает работу сенсоров и вентиляторы постоянно жужжат, делая работу не комфортной. В тоже время, если загрузить предустановленную Windows 10 Pro с оригинального жесткого диска, то наступает приятная для уха тишина. Пока на улице (и дома) было прохладно, было терпимо. Но как наступила жара, терпению пришел конец. Было решено мигрировать на Windows.
В своей работе я использую многочисленные виртуальные машины для сборки, тестирования и отладки разрабатываемого программного обеспечения. Windows 10 Pro включает в себя виртуализацию Hyper-V — раз деньги уплачены, то придеться использовать! В Ubuntu я пользовался libvirt и виртуальными машинами объединенными в одну внутреннюю виртуальную сеть.
Перенеся Windows с оригинального диска на SSD и преобразовав образы виртуальных машин в формат для hyper-v, с болью в сердце, я приступил к осваиванию новой операционной системы.
Оказалось не все так страшно! Виртуальные рабочие столы заменились на рабочие столы windows(к сожалению только горизонтальные), консоль заменила консоль WSL (Windows Subsystem for Linux), для X11 приложений был установлен и добавлен в автозапуск VcXsrv, виртуальные машины заработали в Hyper-V и даже удалось запустить OSX.
Родной терминал оказался не совсем удобным и без вкладок, поэтому был безжалостно заменен на xfce4 терминал, который запускается через ярлык со скрытым окном linux консоли:
Объект:
```
C:\Windows\System32\wscript.exe ./runhidden.vbs bash -c "export DISPLAY=:0.0; export GDK_DPI_SCALE=1.2; cd ~; exec xfce4-terminal"
```
Код скрипта для запуска приложения со скрытым окном (скрывается родная консоль, которая открывается при запуске X11 приложений с командной строки), нагугленного на просторах интернета:
```
' Simple command-line help.
select case WScript.Arguments(0)
case "-?", "/?", "-h", "--help"
WScript.echo "Usage: runHidden executable [...]" & vbNewLine & vbNewLine & "Runs the specified command hidden (without a visible window)."
WScript.Quit(0)
end select
' Separate the arguments into the executable name
' and a single string containing all arguments.
exe = WScript.Arguments(0)
sep = ""
for i = 1 to WScript.Arguments.Count -1
' Enclose arguments in "..." to preserve their original partitioning.
args = args & sep & """" & WScript.Arguments(i) & """"
sep = " "
next
' Execute the command with its window *hidden* (0)
WScript.CreateObject("Shell.Application").ShellExecute exe, args, "", "open", 0
```
В итоге получилось так:
Мне приходится часто ездить, специально для поездок у меня был мелкий маршрутизатор TP-LINK WR703N прошитый OpenWRT:
На маршрутизаторе настроены VPN до рабочих машин и для выхода в интернет. Если есть кабель, то подключается к сети через кабель, раздает по WiFi для ноутбука, телефонов и других устройств, если только WiFi, то подключается к ноутбуку через кабель. Настроить одновременно клиента WiFi и точку доступа можно, но качество сигнала падает, начинаются отключения и падение скорости.
В связи с этим возникла идея вообще избавиться от этого маршрутизатора (заодно повысив пропускную способность подключения), клубка проводов и блока питания, заменив его виртуальным маршрутизатором. Очевидно, что все виртуальные машины и Windows должны быть объединены в одну локальную сеть.
Запускаем Диспетчер Hyper-V и выбираем Диспетчер виртуальных коммутаторов. Создаем новый внутренний виртуальный коммутатор, который будет обслуживать нашу виртуальную локальную сеть. Назовем его LAN Internal:
Выходить в интернет мы будем через беспроводной адаптер и езернет кабель. Создаем два внешних виртуальных коммутатора, не забыв убрать галку «Разрешить управляющей операционной системе предоставлять общий доступ к этому сетевому адаптеру» — незачем Windows ходить в интернет напрямую.
Виртуальный коммутатор для WiFi:
Виртуальный коммутатор для езернет кабеля:
Операционной системой виртуальной машины маршрутизатора я выбрал серверную Ubuntu 16.04. Почему 16.04? Потому что в 18.04 простые настройки сети в /etc/network/interfaces заменили на netplan — не хочу! Создаем новую виртуальную машину и добавляем в нее наши виртуальные коммутаторы:
В закладке Безопасность либо отключаем безопасную загрузку, либо выбираем Центр сертификации Microsoft UEFI и ставим операционную систему как обычно.
После установки, заходим в свежеустановленную систему и проверяем сетевые интерфейсы командой ifconfig. Внешние подключения через кабель и WiFi могут получить ip адреса если они подключены и активны. Если адреса не получены, воспользуемся утилитой получения адреса:
`dhclient eth0 eth1 eth2`
Внутренний будет без адреса, так как в нашей локальной сети еще не работает сервер dhcp.
В моем случае eth0 — внешний езернет, eth1 — локальная сеть, eth2 — внешнее беспроводное подключение (в порядке добавление сетевых карт). Локальная сеть у нас будет 192.168.3.0.
Отредактируем настройки сети в /etc/network/interfaces с помощью, например, редактора nano:
```
source /etc/network/interfaces.d/*
# The loopback network interface
auto lo
iface lo inet loopback
# The primary network interface
allow-hotplug eth0
iface eth0 inet dhcp
# Internal LAN
auto eth1
iface eth1 inet static
address 192.168.3.1
netmask 255.255.255.0
network 192.168.3.0
broadcast 192.168.3.255
# The primary network interface
allow-hotplug eth2
iface eth2 inet dhcp
```
Перезагружаем маршрутизатор и заходим на него опять. Теперь все сетевые интерфейсы должны иметь адреса (внешние если имеют подключение).
Настройке маршрутизации посвящено множество статей и имеется достаточное количество материала, поэтому пробежимся быстро по минимальной настройке.
Устанавливаем необходимые нам приложения:
sudo apt install dnsmasq iptables-persistent netfilter-persistent openvpn
Разрешаем пересылку ip пакетов:
```
cat > /etc/sysctl.d/10-forwarding.conf
net.ipv4.ip_forward=1
```
Настраиваем межсетевой экран:
```
cat > /etc/iptables/rules.v4
# Generated by iptables-save v1.6.0 on Fri Jun 22 11:13:10 2018
*nat
:PREROUTING ACCEPT [2901:568651]
:INPUT ACCEPT [707:80315]
:OUTPUT ACCEPT [445:30025]
:POSTROUTING ACCEPT [14:1200]
-A POSTROUTING -o eth0 -j MASQUERADE
-A POSTROUTING -o eth2 -j MASQUERADE
-A POSTROUTING -o tun+ -j MASQUERADE
COMMIT
# Completed on Fri Jun 22 11:13:10 2018
# Generated by iptables-save v1.6.0 on Fri Jun 22 11:13:10 2018
*filter
:INPUT ACCEPT [57264:68964200]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [44820:7558046]
-A FORWARD -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -i eth1 -o tun+ -j ACCEPT
COMMIT
# Completed on Fri Jun 22 11:13:10 2018
```
Настраиваем dhcp сервер и сервер имен:
```
cat > /etc/dnsmasq.d/router.conf
dhcp-authoritative
domain-needed
localise-queries
read-ethers
bogus-priv
expand-hosts
local-service
domain=lan
server=/lan/
dhcp-leasefile=/tmp/dhcp.leases
interface=eth1
dhcp-range=lan,192.168.3.100,192.168.3.249,255.255.255.0,12h
```
Перезагружаем и получаем работающий маршрутизатор для Windows и других виртуальных машин!
Настраиваем на маршрутизаторе openvpn и наслаждаемся жизнью без дополнительных железок и кабелей.
Но позвольте, спросите вы, а как же быть с телефоном и другими гаджетами?
Простое решение — использовать встроенный в Windows 10 Мобильный хотспот! Но не все так просто. Мобильный хотспот не хочет активироваться на виртуальном интерфейсе нашей виртуальной локальной сети! Незадача…
Погуглив наметившуюся проблему, были найдены несколько альтернативных утилит для запуска мобильной точки доступа. К сожалению, все они были платные. Было решено написать свое приложение, с некоторыми плюшками, бесплатное и с открытым кодом.
Помучившись неделю, приложение было написано (и заодно освоен ранее не изведанный зверь — Visual Studio):
Кроме активации точки доступа, приложение может запускаться при входе в систему, активировать точку по запуску и закрывать приложение после активации.
Исходный код доступен на [github](https://github.com/pdaxrom/NoWiFi).
Для тех, кто не может или кому лень собирать из исходных текстов, приложение (бесплатно, без смс и всякой рекламы) доступно в Windows Магазине [NoWiFi](https://www.microsoft.com/ru-ru/p/nowifi/9nk0dst7hzx5).
Таким образом, поставленная задача была решена, старый маршрутизатор окончательно отправился на пенсию, а в рюкзаке освободилось место!
На этом у меня все, всем спасибо за внимание и терпение при чтении столь нудного материала! | https://habr.com/ru/post/429856/ | null | ru | null |
# Практическое применение преобразования Фурье для обработки сигналов
**Введение**
Книги и публикации по цифровой обработке сигналов пишут авторы зачастую не догадывающиеся и не понимающие задач, стоящих перед разработчиками. Особенно это касается систем, работающих в реальном времени. Эти авторы отводят себе скромную роль бога, существующего вне времени и пространства, что вызывает некоторое недоумение у читателей подобной литературы. Данная публикация имеет целью развеять недоумения, возникающие у большинства разработчиков, и помочь им преодолеть «порог вхождения», для этих целей в тексте сознательно используется аналогии и терминология сферы программирования.
Данный опус не претендует на полноту и связность изложения.
*Добавлено после прочтения комментариев.
Публикаций о том как делать БПФ немеряно, а о том как сделать БПФ, преобразовать спектр, и собрать сигнал заново, да еще и в реальном времени, явно не хватает. Автор пытается восполнить этот пробел.*
**Часть первая, обзорная**
Существуют два основных способа построения дискретных линейных динамических систем. В литературе, такие системы принято называть цифровыми фильтрами, которые подразделяются на два основных типа: фильтры с конечной импульсной характеристикой (КИХ) и фильтры с бесконечной импульсной характеристикой (БИХ).
Алгоритмическая сущность фильтра с КИХ заключается в дискретном вычислении интеграла свертки:
Где x(t) – входной сигнал
y(t) – выходной сигнал
h(t) – импульсная характеристика фильтра или реакция фильтра на дельта функцию. Импульсная характеристика является обратным преобразованием Фурье комплексной частотной характеристики фильтра K(f).
Для формирования ясной картины у читателя, приведем пример дискретного вычисления интеграла свертки на языке С в реальном времени.
```
#define L (4) //длинна фильтра
int FIR(int a)
{
static int i=0; //текущая позиция
static int reg[L]; //массив входных значений
static const int h[L]={1,1,1,1};//импульсная характеристика
int b=0;//выходное значение
reg[i]=a; //копируем входное значение в массив входных значений
for(int j=0;j
```
Вызывая данную функцию через определенные интервалы времени T и передавая ей в качестве аргумента входной сигнал, на выходе мы получим выходной сигнал, соответствующий реакции фильтра с импульсной характеристикой вида:
h(t)=1 при 0
h(t)=0 в остальных случаях.
Всем собравшимся фильтр с такой импульсной характеристикой более известен под названием «фильтр скользящего среднего», и, соответственно, реализуется он гораздо проще. В данном случае такая импульсная характеристика используется для примера.
Синтезу импульсных характеристик КИХ фильтров посвящена масса литературы, также имеются готовые программные продукты для получения фильтров с заданными свойствами. Автор предпочитает глючный инструмент Filter Design из пакета Matlab, но это дело вкуса.
Используя фильтр с конечной импульсной характеристикой, удается немножечко воспарить над привычной реальностью, так как, в природе не существует динамических систем, имеющих конечную импульсную характеристику. Фильтр КИХ — попытка зайти в частотно-временную область с другого конца, не так как ходит природа, поэтому частотные характеристики этих фильтров зачастую обладают неожиданными свойствами.
Намного ближе к природе фильтры с бесконечной импульсной характеристикой. Алгоритмическая сущность фильтров с бесконечной импульсной характеристикой сводится к рекуррентному (не путать с рекурсивным!) решению дифференциального уравнения, описывающего фильтр. То есть, каждое последующие значение выходного сигнала фильтра вычисляется на основании предыдущего значения. Именно так протекают процессы в реальном мире. Камень, падая с небоскреба каждую секунду, увеличивает свою скорость на 9.8м/с Speed=Speed+9.8, и пройденный путь каждую секунду увеличивается Distance=Distance+Speed. Кто скажет, что это не рекуррентный алгоритм, пусть первый бросит в меня камень. Только в нашей *Матрице* временной интервал вызова функции возвращающей положение камня много меньше цены деления доступных нам средств измерения.
Отдельно хотелось бы определить понятие «порядок фильтра». Это количество переменных которые подвергаются рекуррентным операциям. В приведенном примере функция, возвращающая скорость камня — первого порядка, функция, возвращающая пройденный путь — второго порядка.
Для окончательного просветления читателя приведем пример на языке С самого простого фильтра низких частот, широко известного как фильтр «фильтр экспоненциального сглаживания»
```
#define alfa (2) //параметр сглаживания
int filter(int a)
{
static int out_alfa=0;
out_alfa=out_alfa - (out_alfa >>alfa) + a;
return (out_alfa >> alfa);
}
```
Вызывая данную функцию с частотой F и передавая ей в качестве аргумента входной сигнал, на выходе мы получим выходной сигнал, соответствующий реакции фильтра низких частот первого порядка с частотой среза:
Приведенный пример исходного кода совершенно неудобоварим с точки зрения понимания сути алгоритма. С точки зрения рекуррентной сути (смотри «падение камня» ) алгоритма, правильнее y=y+((x-y)>>alfa);, но в этом случае происходит потеря alfa значащих разрядов. Рекуррентное выражение фильтра, из примера кода, построено таким образом, чтобы избежать потери значащих разрядов. Именно конечная точность вычислений может испортить всю прелесть цифрового фильтра с бесконечной импульсной характеристикой. Особенно это заметно на фильтрах высоких порядков, отличающихся высокой добротностью. В реальных динамических системах такая проблема не возникает, наша *Матрица* производит вычисления с невероятной для нас точностью.
Синтезу подобных фильтров посвящена масса литературы, также имеются готовые программные продукты (см. выше).
**Часть вторая. Фурье – фильтр**
Из вузовских курсов (у вашего покорного слуги это был курс ОТЭЦ) многие собравшие помнят два основных подхода к анализу линейных динамических систем: анализ во временной области и анализ в частотной области. Анализ во временной области — это решение дифференциальных уравнений, интегралы свертки и Дюамеля. Эти методы анализа дискретно воплотились в цифровых фильтрах БИХ и КИХ.
Но существует частотный подход к анализу линейных динамических систем. Иногда его называют операторным. В качестве операторов используются преобразование Фурье, Лапласа и т.п. Далее мы будем говорить только о преобразовании Фурье.
Данный метод анализа не получил широкого распространения при построении цифровых фильтров. Автору не удалось найти вменяемых практических рекомендаций по построению подобных фильтров на русском языке. Единственное краткое упоминание такого фильтра в практической литературе [Рабинер Л., Гоулд Б., Теория и применение цифровой обработки сигналов 1978], но в данной книге рассмотрение подобного фильтра очень поверхностно. В указанной книге данная схема построения фильтра называется: «свертка в реальном времени методом БПФ», что, по моему скромному мнению, совершенно не отражает сути, название должно быть коротким, иначе времени на отдых не останется.
Реакция линейной динамической системы есть обратное преобразование Фурье от произведения изображения по Фурье входного сигнала x(t) на комплексный коэффициент передачи K(f):
В практическом плане, данное аналитическое выражение предполагает следующий порядок действий: берем преобразование Фурье от входного сигнала, умножаем результат на комплексный коэффициент передачи, выполняем обратное преобразование Фурье, результатом которого является выходной сигнал. В реальном дискретном времени такой порядок действий выполнить невозможно. Как брать интеграл по времени от минус до плюс бесконечности?! Его можно взять только находясь вне времени…
В дискретном мире для выполнения преобразования Фурье существует инструмент — алгоритм быстрого преобразования Фурье (БПФ). Именно его мы и будем использовать при реализации нашего Фурье-фильтра. Аргументом функции БПФ является массив временных отсчетов из 2^n элементов, результатом два массива длинной 2^n элементов соответствующие действительной и мнимой части преобразования Фурье. Дискретной особенностью алгоритма БПФ является то, что входной сигнал считается периодичным с интервалом 2^n. Это накладывает некоторые ограничения на алгоритм Фурье-фильтра. Если взять последовательность выборок входного сигнала, провести от них БПФ, умножить результат БПФ на комплексный коэффициент передачи фильтра и выполнить обратное преобразование …**ничего получится!** Выходной сигнал будет иметь огромные нелинейные искажения в окрестности стыков выборок.
Для решения этой проблемы необходимо применить два приема:
* 1. Выборки необходимо обрабатывать преобразованием Фурье с перекрытием. То есть, каждая последующая выборка должно содержать часть предыдущей. В идеальном случае выборки должны перекрываться на (2^n-1) отсчетов, но это требует огромных вычислительных затрат. На практике, с лихвой, достаточно трехчетвертного (2^n-2^(n-2)), половинного (2^(n-1)) и даже четвертного перекрытия (2^(n-2)).
* 2. Результаты обратного преобразования Фурье, для получения выходного сигнала, необходимо, перед наложение друг на друга, умножить на весовую функцию (массив весовых коэффициентов). Весовая функция должна удовлетворять следующим условиям:
* 2.1 Равна нулю везде, кроме интервала 2^n.
* 2.2 На краях интервала стремится к нулю.
* 2.3 И, самое главное, сумма весовых функций Fv(t), сдвинутых на интервал перекрытия k должна быть постоянна:
Такие функции широко применяются в технике цифровой обработки сигналов, и называть их принято — окнами. По скромному мнению автора лучшим, с практической точки зрения, является окно имени Хана:
На рисунке приведены графики иллюстрирующие свойства окна Хана длинной 2^n=256. Экземпляры окна построены с половинным перекрытием k=128. Как видно все оговоренные выше свойства имеются в наличии.
По просьбам трудящихся, на следующем рисунке приведена схема вычислений Фурье-фильтра, при длине выборки 2^n=8, количество выборок 3. На подобных рисунках очень сложно отобразить процесс вычислений, особенно тяжело показать его цикличность, поэтому мы и ограничились количеством выборок равным трем.
Входной сигнал разбивается на блоки длинной 2^n=8 с перекрытием 50%, от каждого блока берется БПФ, результаты БПФ подвергаются нужной трансформации, берется обратное БПФ, результат обратного БПФ скалярно умножается на окно, после умножения блоки складываются с перекрытием.
При выполнение трансформаций спектра, не стоит забывать о главном свойстве массива БПФ действительных сигналов, первая половина массива БПФ комплексно сопряжена со второй половиной, т.е Re[i]=Re[(1<
Теперь мы знаем все, что необходимо для написания алгоритма Фурье-фильтра. Опишем алгоритм на языке С.
```
#include
#define FSempl (8000)//частота семплирования Гц
#define BufL (64) //длинна буфера обработки
#define Perk (2) //перекрытие кадров 2-1/2, 4-3/4
//ограничение спектра, полосовой фильтр
#define FsrLow (300)//нижняя частота фильтра Гц
#define FsrHi (3100)//верхняя частота фильтра Гц
#define FsrLowN ((BufL\*FsrLow+(FSempl/2))/FSempl)//нижняя частота в гармониках
#define FsrHiN ((BufL\*FsrHi +(FSempl/2))/FSempl)//верхняя частота в гармониках
//Сдвиг спектра
#define SdvigSp (0)//сдвиг спектра в гармониках +(вниз) -(вверх) 0(без сдвига)
//Фильтр спектра во времени, эхо
#define FilterSpekrtaT\_EN (1)//использовать фильтр спектра 1/0
#define FiltSpektrFsr (0.100025f) //частота среза фильтра спектра
volatile unsigned short ShBuf;//счетчик входного буфера
signed short BufIn[BufL\*2];//входной буфер
signed short BufOut[BufL\*2];//выходной буфер
signed short BufInOut[BufL];//буфер для перезаписи
float FurRe[BufL];//Фурье действительная часть
float FurIm[BufL];//Фурье мнимая часть
#if (FilterSpekrtaT\_EN!=0)
float FStektr[BufL/2];//фильтр амплитудного спектра
#endif
//Таблица синуса косинуса
#if BufL==64
const float SinCosF[]=
{
0.000000000 , 0.098017140 , 0.195090322 , 0.290284677 ,
0.382683432 , 0.471396737 , 0.555570233 , 0.634393284 ,
0.707106781 , 0.773010453 , 0.831469612 , 0.881921264 ,
0.923879533 , 0.956940336 , 0.980785280 , 0.995184727 ,
1.000000000 , 0.995184727 , 0.980785280 , 0.956940336 ,
0.923879533 , 0.881921264 , 0.831469612 , 0.773010453 ,
0.707106781 , 0.634393284 , 0.555570233 , 0.471396737 ,
0.382683432 , 0.290284677 , 0.195090322 , 0.098017140 ,
0.000000000 , -0.098017140, -0.195090322, -0.290284677,
-0.382683432, -0.471396737, -0.555570233, -0.634393284,
-0.707106781, -0.773010453, -0.831469612, -0.881921264,
-0.923879533, -0.956940336, -0.980785280, -0.995184727,
-1.000000000, -0.995184727, -0.980785280, -0.956940336,
-0.923879533, -0.881921264, -0.831469612, -0.773010453,
-0.707106781, -0.634393284, -0.555570233, -0.471396737,
-0.382683432, -0.290284677, -0.195090322, -0.098017140,
0.000000000 , 0.098017140 , 0.195090322 , 0.290284677 ,
0.382683432 , 0.471396737 , 0.555570233 , 0.634393284 ,
0.707106781 , 0.773010453 , 0.831469612 , 0.881921264 ,
0.923879533 , 0.956940336 , 0.980785280 , 0.995184727
};
#endif
//таблица сортировки БПФ
#if BufL==64
const unsigned short sortFFT[]=
{
0x0000,0x0020,0x0010,0x0030,0x0008,0x0028,0x0018,0x0038,
0x0004,0x0024,0x0014,0x0034,0x000C,0x002C,0x001C,0x003C,
0x0002,0x0022,0x0012,0x0032,0x000A,0x002A,0x001A,0x003A,
0x0006,0x0026,0x0016,0x0036,0x000E,0x002E,0x001E,0x003E,
0x0001,0x0021,0x0011,0x0031,0x0009,0x0029,0x0019,0x0039,
0x0005,0x0025,0x0015,0x0035,0x000D,0x002D,0x001D,0x003D,
0x0003,0x0023,0x0013,0x0033,0x000B,0x002B,0x001B,0x003B,
0x0007,0x0027,0x0017,0x0037,0x000F,0x002F,0x001F,0x003F
};
#endif
//Таблица окно Хана
#if BufL==64
const float WinHanF[]=
{
0.0 , 0.002407637 , 0.00960736 , 0.021529832 ,
0.038060234 , 0.059039368 , 0.084265194 , 0.113494773 ,
0.146446609 , 0.182803358 , 0.222214883 , 0.264301632 ,
0.308658284 , 0.354857661 , 0.402454839 , 0.45099143 ,
0.5 , 0.54900857 , 0.597545161 , 0.645142339 ,
0.691341716 , 0.735698368 , 0.777785117 , 0.817196642 ,
0.853553391 , 0.886505227 , 0.915734806 , 0.940960632 ,
0.961939766 , 0.978470168 , 0.99039264 , 0.997592363 ,
1.0 , 0.997592363 , 0.99039264 , 0.978470168 ,
0.961939766 , 0.940960632 , 0.915734806 , 0.886505227 ,
0.853553391 , 0.817196642 , 0.777785117 , 0.735698368 ,
0.691341716 , 0.645142339 , 0.597545161 , 0.54900857 ,
0.5 , 0.45099143 , 0.402454839 , 0.354857661 ,
0.308658284 , 0.264301632 , 0.222214883 , 0.182803358 ,
0.146446609 , 0.113494773 , 0.084265194 , 0.059039368 ,
0.038060234 , 0.021529832 , 0.00960736 , 0.002407637
};
#endif
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
//Вычисление прямого Быстрого Преобразования Фурье
//аргументы
//указатель на массив для действительной ReFT и мнимой части ImFT
//После выполнения массивы содержат коэф. действительной и мнимой части
void FFTnoInv(float\* ReFT,float\* ImFT)
{
//копирование и перестановка
for(int i=0;i>1;
long arg=0; //аргумент ядра, фаза
for(int j=0;j>1;
long arg=0;////аргумент ядра, фаза
for(int j=0;j0
//сдвиг спектра вниз, Карабас-Барабас
for(int i=1;i<(BufL/2);i++)
{
if(i>=(BufL/2-SdvigSp))
{
FurRe[i]=FurIm[i]=0;
FurRe[BufL-i]=FurIm[BufL-i]=0;
continue;
}
FurRe[i]=FurRe[i+SdvigSp];
FurIm[i]=FurIm[i+SdvigSp];
FurRe[BufL-i]=FurRe[i];
FurIm[BufL-i]=-FurIm[i];
}
#endif
#if SdvigSp<0
//сдвиг спектра вверх, Буратино
for(int i=(BufL/2-1);i>0;i--)
{
if(i<=(-SdvigSp))
{
FurRe[i]=FurIm[i]=0;
FurRe[BufL-i]=FurIm[BufL-i]=0;
continue;
}
FurRe[i]=FurRe[i-(-SdvigSp)];
FurIm[i]=FurIm[i-(-SdvigSp)];
FurRe[BufL-i]=FurRe[i];
FurIm[BufL-i]=-FurIm[i];
}
#endif
//обрезание спектра, полосовой фильтр
FurRe[0]=0.0F;FurIm[0]=0.0F; //постоянная составляющая
FurRe[(BufL/2)]=0.0F;FurIm[(BufL/2)]=0.0F;//последняя гармоника
float ZnStektr[BufL/2];//амплитудный спектр кадра
for(int i=1;i<(BufL/2);i++)
{
if(
( i < FsrLowN )//нижняя частота
||
( i > FsrHiN )//верхняя частота
)
{
//обрезание спектра, гармоники вне полосы зануляем
FurRe[i]=0.0F;FurIm[i]=0.0F;//прямые гармоники
FurRe[BufL-i]=0.0F;FurIm[BufL-i]=0.0F;//сопряженные гармоники
}
else //считаем амплитудный спектр не обрезанной части
{
ZnStektr[i]=sqrtf(FurRe[i]\*FurRe[i])+(FurIm[i]\*FurIm[i]);//амплитудный спектр
}
}
//фильтр амплитудного спектра во времени, эхо
for(int i= FsrLowN;//нижняя частота
i<=FsrHiN ;//верхняя частота
i++)
{
#if FilterSpekrtaT\_EN!=0
//фильтр спектра во времени, эхо
FStektr[i]=FStektr[i]+ FiltSpektrFsr\*(ZnStektr[i]-FStektr[i]);
#endif
//переходим от модуля к комплексному числу
FurRe[i]=FurRe[BufL-i]=(FStektr[i]\*FurRe[i])/ZnStektr[i];
FurIm[i]=(FStektr[i]\*FurIm[i])/ZnStektr[i];
FurIm[BufL-i]=-FurIm[i];
}
//выполняем обратное БПФ
FFTInv(FurRe,FurIm);
//копирование буферов
for(int i=0;i<(BufL);i++)
{
BufInOut[i]=((signed short)(FurRe[i]+0.5f));
}
}
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
//Фурье фильтр
signed short FureFilter(signed short t1)
{
//записываем во входной буфер
BufIn[ShBuf]=t1;
//выходное значение
signed short out=BufOut[ShBuf];
//инкремент указателя буфера
ShBuf=(ShBuf+1)&((BufL\*2)-1);
//если в буфере часть кадра обработки
if((ShBuf&((BufL/Perk)-1))==0)
{
//переписываем буфер обработки в выходной буфер
int ShTmpOut=ShBuf;
int ShTmpIn=(ShBuf-BufL)&((BufL\*2)-1);
for(int i=0;i<(BufL);i++)
{
if(i<(BufL-(BufL/Perk)))
{
//переписываем первую часть буфера обработки в выходной буфер
BufOut[ShTmpOut]=BufOut[ShTmpOut]+BufInOut[i];
}
else
{ //переписываем вторую часть буфера обработки в выходной буфер
BufOut[ShTmpOut]=BufInOut[i];
}
//инкремент указателя выходного буфера
ShTmpOut=(ShTmpOut+1)&((BufL\*2)-1);
//переписываем входной буфер в буфер обработки
BufInOut[i]=BufIn[ShTmpIn];
//инкремент указателя входного буфера
ShTmpIn=(ShTmpIn+1)&((BufL\*2)-1);
}
}//конец if((ShBuf&((BufL/Perk)-1))==0)
//вызов функции обработки
//в на реальном процессоре распараллелить!
if((ShBuf&((BufL/Perk)-1))==0)ObrBuf();
return out;
}
```
Вызывая функцию FureFilter() с частотой FSempl и передавая ей в качестве аргумента входной сигнал, результатом получим выходной сигнал. В данном примере входной сигнал обрабатывается следующим образом: сигнал пропускается через полосовой фильтр с частотами среза FsrLow, FsrHi, подавляются все спектральные составляющие выше и ниже указанных частот, сдвигается спектр сигнала (для звуковых сигналов это воспринимается как эффект Буратино-Карабаса), амплитудный спектр сигнала подвергается сглаживанию фильтром низких частот (для звука это эффект гулкого помещения). Данные действия с сигналом выполнены в качестве примера, для того чтобы показать технические приемы обработки сигнала в частотной области, такие как: соблюдение комплексно-сопряженности коэффициентов, восстановление комплексного спектра по амплитудному, не используя тригонометрических функций и т.п.
**Заключение**
Стоит отметить, что, скорее всего, данная функция Фурье-фильтра, на практике окажется неработоспособна. При вызове данной функции даже с невысокой частотой 8000Гц, она не успеет выполнится к моменту следующего вызова, не хватить быстродействия. **Данный программный код Фурье-фильтра приведен в качестве описания алгоритма, без привязки к конкретным аппаратным ресурсам, и имеет чисто образовательные цели** (см. Введение).
При практической реализации следует распараллелить выполнение функции заполнения-опорожнения буфера BufInOut[] (лучше сразу ПДП и т. п.) и функции обработки буфера ObrBuf(), но это уже совсем другая история. | https://habr.com/ru/post/324152/ | null | ru | null |
# Как DDD помог нам построить новые ревизии в пиццериях
В пиццериях важно выстраивать систему учёта и управления запасами. Система нужна, чтобы не терять продукты, не проводить лишние списания и правильно прогнозировать закупки на следующий месяц. Важная роль в учёте у ревизий. Они помогают проверять остатки продуктов и сверять фактическое количество и то, что есть в системе.
Ревизия в Додо не бумажная: у ревизора есть планшет, где ревизор отмечает все продукты и создает отчеты. Но до 2020 года в пиццериях ревизия проводилась именно на бумажках — просто потому что так было проще и легче. Это, конечно, приводило к недостоверным данным, ошибкам и потерям, — люди ошибаются, бумажки теряются, а ещё их много. Мы решили исправить эту проблему и улучшить планшетный способ. В реализации решили использовать DDD. Как у нас это получилось, расскажем дальше.
Сначала кратко о бизнес-процессах, чтобы понять контекст. Рассмотрим схему движения продуктов, и где в ней ревизии, а затем перейдем к техническим деталям, которых будет много.
Схема движения продуктов и зачем нужна ревизия
----------------------------------------------
В нашей сети больше 600 пиццерий (и это количество будет расти). В каждой из них ежедневно происходит движение сырья: от приготовления и продажи продуктов, списаний ингредиентов по сроку годности, до перемещений сырья в другие пиццерии сети. На балансе пиццерии постоянно находятся около 120 позиций, необходимых для производства продуктов, и дополнительно множество расходных, хозяйственных материалов и химии для поддержания чистоты пиццерии. Для всего этого нужен «учёт», чтобы знать, какого сырья с избытком, а какого не хватает.
«Учёт» описывает любое движение сырья в пиццериях. Поставка — это «плюс» на балансе, а списание — «минус». Например, когда мы заказываем пиццу, кассир принимает заказ и передаёт его в обработку. Дальше раскатывают тесто и начиняют ингредиентами, например, сыром, томатным соусом и пепперони. Все эти продукты идут в производство — списываются. Также списание может произойти, когда заканчивается срок годности.
В результате поставок и списаний формируются «складские остатки». Это отчет, в котором отражается сколько сырья на балансе исходя из операций в информационной системе. Всё это «расчетный остаток». Но есть «фактическое значение» — сколько сырья на самом деле сейчас на складе.
#### Ревизии
Для подсчета фактического значения как раз используются «ревизии» (ещё их называют «инвентаризациями»).
Ревизии помогают точно рассчитывать количество сырья для закупок. Слишком много закупок заморозит оборотные средства, и возрастёт риск списания излишка продуктов, что тоже приводит к потерям. Опасен не только излишек сырья, но и его недостаток — это может привести к остановке производства некоторых продуктов, что приведет к снижению выручки. Ревизии помогают видеть, сколько прибыли недополучает бизнес из-за учтённых и неучтённых потерь сырья, и работать над сокращением издержек.
Ревизии делятся своими данными с учётом для дальнейшей обработки, например, построения отчётов.
#### Проблемы в процессе проведения ревизий, или Как работали старые ревизии
Ревизии — трудоемкий процесс. Он занимает много времени и состоит из нескольких этапов: подсчет и фиксация остатков сырья, суммирование результатов сырья по зонам хранения, внесение результатов в информационную систему Dodo IS.
Раньше ревизии проводились с помощью ручки и бумажного бланка, на котором был перечень сырья. При ручном суммировании, сверке и перенесении результатов в Dodo IS есть вероятность совершить ошибку. В полной ревизии подсчитывается больше 100 наименований сырья, а сам подсчёт зачастую проводится поздним вечером или ранним утром, от чего концентрация может страдать.
#### Как решить проблему
Наша команда «Game of Threads» занимается развитием учета в пиццериях. Мы решили запустить проект «планшет ревизора», который упростит проведение ревизий в пиццериях. Всё решили делать в собственной информационной системе Dodo IS, в которой реализованы основные компоненты для ведения учета, поэтому нам не нужны интеграции со сторонними системами. К тому же инструментом смогут пользоваться все страны нашего присутствия, не прибегая к дополнительным интеграциям.
Ещё до начала работы над проектом мы в команде обсуждали желание применить DDD на практике. К счастью, на одном из проектов уже успешно применили этот подход, поэтому у нас был пример, на который можно посмотреть — это проект «[касса доставки](https://habr.com/ru/company/dododev/blog/485098/)».
В статье я расскажу о тактических паттернах DDD, которые мы применяли в разработке: агрегатах, командах, доменных эвентах, прикладной службе и интеграции ограниченных контекстов. Стратегические паттерны и основы DDD не будем описывать, иначе статья будет очень длинной. Об этом мы уже рассказывали в материале «[Что можно узнать о Domain Driven Design за 10 минут?](https://habr.com/ru/company/dododev/blog/489352/)»
#### Новая версия ревизий
Перед началом ревизии нужно знать, что конкретно считать. Для этого нам понадобятся **шаблоны ревизии**. Их настраивает роль «менеджер офиса». Шаблон ревизии — это сущность InventoryTemplate. Она содержит следующие поля:
* идентификатор шаблона;
* идентификатор пиццерии;
* название шаблона;
* категория ревизии: месячная, недельная, дневная;
* единицы измерения;
* зоны хранения и сырьё в этой зоне хранения
Для этой сущности реализован CRUD-функционал и подробно на ней останавливаться не будем.
Как только у ревизора есть список шаблонов, он может начать **ревизию**. Обычно это происходит, когда пиццерия закрыта. В этот момент заказов нет и сырьё не движется — можно достоверно получить данные по остаткам.
Начиная ревизию ревизор выбирает зону, например холодильник, и идёт считать сырьё там. В холодильнике он видит 5 пачек сыра по 10 кг, вводит в калькулятор 10 кг \* 5, нажимает «Ввести ещё». Затем замечает на верхней полке ещё 2 пачки, и нажимает «Добавить». В результате у него есть 2 замера — по 50 и 20 кг.
**Замером** мы называем введенное количество сырья ревизором в определённой зоне, но не обязательно суммарное. Ревизор может ввести два замера по одному килограмму или просто два килограмма в одном замере — сочетания могут быть любыми. Главное, чтобы самому ревизору было понятно.
*Интерфейс калькулятора.*
Так, по шагам, ревизор за 1-2 часа считает всё сырьё, а потом завершает ревизию.
Алгоритм действий довольно простой:
* ревизор может начать ревизию;
* ревизор может добавлять замеры в начатой ревизии;
* ревизор может завершить ревизию.
Из этого алгоритма формируются бизнес-требования к системе.
Реализация первой версии агрегата, команды и события предметной области
-----------------------------------------------------------------------
Сначала определимся с терминами, которые входят в набор тактических шаблонов DDD. К ним мы будем обращаться в этой статье.
#### Тактические шаблоны DDD
**Агрегат** — кластер объектов сущностей и значений. Объекты в кластере — единое целое с точки зрения изменения данных. Каждый агрегат имеет корневой элемент, через который происходит обращение к сущностям и значениям. Агрегаты не стоит проектировать слишком большими. Они будут потреблять много памяти, а вероятность успешного завершения транзакции уменьшается.
**Граница агрегата** — набор объектов, которые должны быть согласованы в рамках одной транзакции: должны быть соблюдены все инварианты в рамках этого кластера.
**Инварианты** — бизнес-правила, которые не могут быть противоречивыми.
**Команда** — это какое-то действие над агрегатом. В результате этого действия может быть изменено состояние агрегата, и может быть сгенерировано одно или несколько событий предметной области.
**Событие предметной области** — это уведомление об изменении состояния агрегата, нужно для обеспечения согласованности. Агрегат обеспечивает транзакционную согласованность: все данные должны быть изменены здесь и сейчас. Итоговая согласованность гарантирует согласованность в конечном счете — данные изменятся, но не здесь и сейчас, а через неопределенный промежуток времени. Этот промежуток зависит от многих факторов: загруженность очередей сообщений, готовность внешних сервисов к обработке этих сообщений, сеть.
**Корневой элемент** — это сущность с уникальным глобальным идентификатором. Дочерние элементы могут иметь только локальную идентичность в рамках целого агрегата. Они могут ссылаться друг на друга и могут иметь ссылку только на свой корневой элемент.
#### Команды и события
Опишем бизнес-требование командой. Команды — это просто DTO с описательными полями.
В команде «добавление замера» есть следующие поля:
* значение замера — количество сырья в определенной единице измерения, может быть null, если замер удалили;
* версия — замер можно редактировать, поэтому нужна версия;
* идентификатор сырья;
* единица измерения: кг/г, л/мл, штуки;
* идентификатор зоны хранения.
**Код команды добавления замера**
```
public sealed class AddMeasurementCommand
{
// ctor
public double? Value { get; }
public int Version { get; }
public UUId MaterialTypeId { get; }
public UUId MeasurementId { get; }
public UnitOfMeasure UnitOfMeasure { get; }
public UUId InventoryZoneId { get; }
}
```
Также нам понадобится событие, которое получится в результате отработки этих команд. Мы помечаем событие интерфейсом `IPublicInventoryEvent` — понадобится нам для интеграции с внешними потребителями в дальнейшем.
В событии «замер» поля такие же, как и в команде «Добавление замера», кроме того, что событие хранит ещё идентификатор агрегата на котором оно произошло и его версию.
**Код события «замер»**
```
public class MeasurementEvent : IPublicInventoryEvent
{
public UUId MaterialTypeId { get; set; }
public double? Value { get; set; }
public UUId MeasurementId { get; set; }
public int MeasurementVersion { get; set; }
public UUId AggregateId { get; set; }
public int Version { get; set; }
public UnitOfMeasure UnitOfMeasure { get; set; }
public UUId InventoryZoneId { get; set; }
}
```
Когда мы описали команды и события, можем реализовать агрегат `Inventory`.
#### Реализация агрегата Inventory
*UML диаграмма агрегата Inventory.*
Подход такой: начало ревизии инициирует создание агрегата `Inventory`, для этого мы используем фабричный метод `Create` и начинаем ревизию командой `StartInventoryCommand`.
Каждая команда мутирует состояние агрегата и сохраняет события в списке `changes`, которые как раз и отправятся в хранилище на запись. Также на основе этих изменений будут сгенерированы события для внешнего мира.
Когда агрегат `Inventory` был создан, мы можем его восстанавливать на каждый последующий запрос на изменение его состояния.
* Изменения (`changes`) хранятся с момента последнего восстановления агрегата.
* Состояние восстанавливается методом `Restore`, который проигрывает все предыдущие события, отсортированные по версии, на текущем экземпляре агрегата `Inventory`.
Это реализация идеи `Event Sourcing` в рамках агрегата. О том, как реализовать идею `Event Sourcing` в рамках хранилища поговорим немного позже. Есть хорошая иллюстрация из книги Вон Вернона:
*Состояние агрегата восстанавливается путем применения событий в порядке их появления.*
Дальше происходит несколько замеров командой `AddMeasurementCommand`. Ревизия завершается командой `FinishInventoryCommand`. Агрегат валидирует своё состояние в мутирующих методах для соблюдения своих инвариантов.
Важно отметить, что агрегат `Inventory` версионируется целиком, а также каждый его замер. С замерами сложнее — приходится решать конфликты в методе обработки события `When(MeasurementEvent e)`. В коде я приведу только обработку команды `AddMeasurementCommand`.
**Код агрегата Inventory**
```
public sealed class Inventory : IEquatable
{
private readonly List \_changes = new List();
private readonly List \_inventoryMeasurements = new List();
internal Inventory(UUId id, int version, UUId unitId, UUId inventoryTemplateId,
UUId startedBy, InventoryState state, DateTime startedAtUtc, DateTime? finishedAtUtc)
: this(id)
{
Version = version;
UnitId = unitId;
InventoryTemplateId = inventoryTemplateId;
StartedBy = startedBy;
State = state;
StartedAtUtc = startedAtUtc;
FinishedAtUtc = finishedAtUtc;
}
private Inventory(UUId id)
{
Id = id;
Version = 0;
State = InventoryState.Unknown;
}
public UUId Id { get; private set; }
public int Version { get; private set; }
public UUId UnitId { get; private set; }
public UUId InventoryTemplateId { get; private set; }
public UUId StartedBy { get; private set; }
public InventoryState State { get; private set; }
public DateTime StartedAtUtc { get; private set; }
public DateTime? FinishedAtUtc { get; private set; }
public ReadOnlyCollection Changes => \_changes.AsReadOnly();
public ReadOnlyCollection Measurements => \_inventoryMeasurements.AsReadOnly();
public static Inventory Restore(UUId inventoryId, IInventoryEvent[] events)
{
var inventory = new Inventory(inventoryId);
inventory.ReplayEvents(events);
return inventory;
}
public static Inventory Restore(UUId id, int version, UUId unitId, UUId inventoryTemplateId,
UUId startedBy, InventoryState state, DateTime startedAtUtc, DateTime? finishedAtUtc,
InventoryMeasurement[] measurements)
{
var inventory = new Inventory(id, version, unitId, inventoryTemplateId,
startedBy, state, startedAtUtc, finishedAtUtc);
inventory.\_inventoryMeasurements.AddRange(measurements);
return inventory;
}
public static Inventory Create(UUId inventoryId)
{
if (inventoryId == null)
{
throw new ArgumentNullException(nameof(inventoryId));
}
return new Inventory(inventoryId);
}
public void ReplayEvents(params IInventoryEvent[] events)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
foreach (var @event in events.OrderBy(e => e.Version))
{
Mutate(@event);
}
}
public void AddMeasurement(AddMeasurementCommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
Apply(new MeasurementEvent
{
AggregateId = Id,
Version = Version + 1,
UnitId = UnitId,
Value = command.Value,
MeasurementVersion = command.Version,
MaterialTypeId = command.MaterialTypeId,
MeasurementId = command.MeasurementId,
UnitOfMeasure = command.UnitOfMeasure,
InventoryZoneId = command.InventoryZoneId
});
}
private void Apply(IInventoryEvent @event)
{
Mutate(@event);
\_changes.Add(@event);
}
private void Mutate(IInventoryEvent @event)
{
When((dynamic) @event);
Version = @event.Version;
}
private void When(MeasurementEvent e)
{
var existMeasurement = \_inventoryMeasurements.SingleOrDefault(x => x.MeasurementId == e.MeasurementId);
if (existMeasurement is null)
{
\_inventoryMeasurements.Add(new InventoryMeasurement
{
Value = e.Value,
MeasurementId = e.MeasurementId,
MeasurementVersion = e.MeasurementVersion,
PreviousValue = e.PreviousValue,
MaterialTypeId = e.MaterialTypeId,
UserId = e.By,
UnitOfMeasure = e.UnitOfMeasure,
InventoryZoneId = e.InventoryZoneId
});
}
else
{
if (!existMeasurement.Value.HasValue)
{
throw new InventoryInvalidStateException("Change removed measurement");
}
if (existMeasurement.MeasurementVersion == e.MeasurementVersion - 1)
{
existMeasurement.Value = e.Value;
existMeasurement.MeasurementVersion = e.MeasurementVersion;
existMeasurement.UnitOfMeasure = e.UnitOfMeasure;
existMeasurement.InventoryZoneId = e.InventoryZoneId;
}
else if (existMeasurement.MeasurementVersion < e.MeasurementVersion)
{
throw new MeasurementConcurrencyException(Id, e.MeasurementId, e.Value);
}
else if (existMeasurement.MeasurementVersion == e.MeasurementVersion &&
existMeasurement.Value != e.Value)
{
throw new MeasurementConcurrencyException(Id, e.MeasurementId, e.Value);
}
else
{
throw new NotChangeException();
}
}
}
// Equals
// GetHashCode
}
```
При возникновении события «Произведен замер» проверяется наличие существующего замера с таким идентификатором. Если такого нет — добавляется новый замер.
Если есть — нужны дополнительные проверки:
* нельзя редактировать удаленный замер;
* входящая версия должна быть больше предыдущей.
Если условия выполняются — можем установить новое значение и новую версию для существующего замера. Если версия меньше, то это конфликт. Для этого мы генерируем исключение `MeasurementConcurrencyException`. Если версия совпадает и значения отличаются, то это тоже конфликтная ситуация. Ну и если совпадает как версия, так и значение, то изменений не произошло. Таких ситуаций обычно не возникает.
Сущность «замер» содержит точно такие же поля, что и команда «Добавление замера».
**Код сущности «замер»**
```
public class InventoryMeasurement
{
public UUId MeasurementId { get; set; }
public UUId MaterialTypeId { get; set; }
public UUId UserId { get; set; }
public double? Value { get; set; }
public int MeasurementVersion { get; set; }
public UnitOfMeasure UnitOfMeasure { get; set; }
public UUId InventoryZoneId { get; set; }
}
```
Использование публичных методов агрегата хорошо демонстрируют Unit-тесты.
**Код юнит теста «добавление замера после начала ревизии»**
```
[Fact]
public void WhenAddMeasurementAfterStartInventory_ThenInventoryHaveOneMeasurement()
{
var inventoryId = UUId.NewUUId();
var inventory = Domain.Inventories.Entities.Inventory.Create(inventoryId);
var unitId = UUId.NewUUId();
inventory.StartInventory(Create.StartInventoryCommand()
.WithUnitId(unitId)
.Please());
var materialTypeId = UUId.NewUUId();
var measurementId = UUId.NewUUId();
var measurementVersion = 1;
var value = 500;
var cmd = Create.AddMeasurementCommand()
.WithMaterialTypeId(materialTypeId)
.WithMeasurement(measurementId, measurementVersion)
.WithValue(value)
.Please();
inventory.AddMeasurement(cmd);
inventory.Measurements.Should().BeEquivalentTo(new InventoryMeasurement
{
MaterialTypeId = materialTypeId,
MeasurementId = measurementId,
MeasurementVersion = measurementVersion,
Value = value,
UnitOfMeasure = UnitOfMeasure.Quantity
});
}
```
#### Собираем всё вместе: команды, события, агрегат Inventory
*Жизненный цикл агрегата Inventory при выполнении команды Finish Inventory.*
На схеме изображен процесс обработки команды `FinishInventoryCommand`. Перед обработкой необходимо восстановить состояние агрегата `Inventory` на момент выполнения команды. Для этого мы загружаем все события, которые были произведены над данным агрегатом, в память и проигрываем их (п. 1).
На момент завершения ревизии у нас уже есть следующие события — начало ревизии и добавление трех замеров. Эти события появились в результате обработки команд `StartInventoryCommand` и `AddMeasurementCommand`, соответственно. В базе данных каждая строка в таблице содержит идентификатор ревизии, версию и тело самого события.
На этом этапе мы выполняем команду `FinishInventoryCommand` (п. 2). Эта команда сначала проверит валидность текущего состояния агрегата — то, что ревизия находится в состоянии `InProgress`, а затем породит новое изменение состояния, добавив событие `FinishInventoryEvent` в список `changes` (п. 3).
Когда команда завершится, все изменения сохранятся в базу данных. В результате в базе появится новая строка с событием `FinishInventoryEvent` и последней версией агрегата (п. 4).
Тип `Inventory` (ревизия) — агрегат и корневой элемент по отношению к своим вложенным сущностям. Таким образом, тип `Inventory` определяет границы агрегата. В границы агрегата входит список сущностей типа `Measurement` (замер), и список всех событий, произведенных над агрегатом (`changes`).
#### Реализация всей фичи
Под фичей мы понимаем реализацию конкретного бизнес-требования. В нашем примере мы рассмотрим фичу «Добавление замера». Для реализации фичи нам понадобится разобраться с понятием «прикладная служба» (`ApplicationService`).
**Прикладная служба** — непосредственный клиент модели предметной области. Прикладные службы гарантируют транзакции при использовании базы данных ACID, гарантируя атомарное сохранение переходов между состояниями. Кроме того, прикладные службы также решают задачи безопасности.
У нас уже есть агрегат `Inventory`. Для реализации всей фичи целиком воспользуемся прикладной службой. В ней необходимо проверить наличие всех связных сущностей, а также права доступа у пользователя. Только после соблюдения всех условий можно выполнять сохранение текущего состояния агрегата и отправлять события во внешний мир. Для реализации прикладной службы мы используем `MediatR`.
**Код фичи «добавление замера»**
```
public class AddMeasurementChangeHandler
: IRequestHandler
{
// dependencies
// ctor
public async Task Handle(
AddMeasurementChangeRequest request,
CancellationToken ct)
{
var inventory =
await \_inventoryRepository.GetAsync(request.AddMeasurementChange.InventoryId, ct);
if (inventory == null)
{
throw new NotFoundException($"Inventory {request.AddMeasurementChange.InventoryId} is not found");
}
var user = await \_usersRepository.GetAsync(request.UserId, ct);
if (user == null)
{
throw new SecurityException();
}
var hasPermissions =
await \_authPermissionService.HasPermissionsAsync(request.CountryId, request.Token, inventory.UnitId, ct);
if (!hasPermissions)
{
throw new SecurityException();
}
var unit = await \_unitRepository.GetAsync(inventory.UnitId, ct);
if (unit == null)
{
throw new InvalidRequestDataException($"Unit {inventory.UnitId} is not found");
}
var unitOfMeasure =
Enum.Parse(request.AddMeasurementChange.MaterialTypeUnitOfMeasure);
var addMeasurementCommand = new AddMeasurementCommand(
request.AddMeasurementChange.Value,
request.AddMeasurementChange.Version,
request.AddMeasurementChange.MaterialTypeId,
request.AddMeasurementChange.Id,
unitOfMeasure,
request.AddMeasurementChange.InventoryZoneId);
inventory.AddMeasurement(addMeasurementCommand);
await HandleAsync(inventory, ct);
return new AddMeasurementChangeResponse(request.AddMeasurementChange.Id, user.Id, user.GetName());
}
private async Task HandleAsync(Domain.Inventories.Entities.Inventory inventory, CancellationToken ct)
{
await \_inventoryRepository.AppendEventsAsync(inventory.Changes, ct);
try
{
await \_localQueueDataService.Publish(inventory.Changes, ct);
}
catch (Exception ex)
{
\_logger.LogError(ex, "error occured while handling action");
}
}
}
```
#### Event sourcing
Во время реализации мы решили выбрать подход ES по нескольким причинам:
* В Dodo есть примеры успешного использования этого подхода.
* С помощью ES проще разобраться в проблеме во время инцидента — хранятся все действия пользователя.
* Если выбрать традиционный подход, то перейти к ES будет невозможно.
Идея реализации достаточно проста — все новые события, которые появились в результате команд мы складываем в базу данных. Для восстановления агрегата мы получаем все события и проигрываем их на экземпляре. Чтобы не доставать каждый раз большую пачку событий, мы снимаем состояния каждые N событий и проигрываем оставшуюся часть с этого снимка.
**Код хранилища агрегатов Inventory**
```
internal sealed class InventoryRepository : IInventoryRepository
{
// dependencies
// ctor
static InventoryRepository()
{
EventTypes = typeof(IEvent)
.Assembly.GetTypes().Where(x => typeof(IEvent).IsAssignableFrom(x))
.ToDictionary(t => t.FullName, x => x);
}
public async Task AppendAsync(IReadOnlyCollection events, CancellationToken ct)
{
using (var session = await \_dbSessionFactory.OpenAsync())
{
if (events.Count == 0) return;
try
{
foreach (var @event in events)
{
await session.ExecuteAsync(Sql.AppendEvent,
new
{
@event.AggregateId,
@event.Version,
@event.UnitId,
Type = @event.GetType().FullName,
Data = JsonConvert.SerializeObject(@event),
CreatedDateTimeUtc = DateTime.UtcNow
}, cancellationToken: ct);
}
}
catch (MySqlException e)
when (e.Number == (int) MySqlErrorCode.DuplicateKeyEntry)
{
throw new OptimisticConcurrencyException(events.First().AggregateId, "");
}
}
}
public async Task GetInventoryAsync(
UUId inventoryId,
CancellationToken ct)
{
var events = await GetEventsAsync(inventoryId, 0, ct);
if (events.Any()) return Domain.Models.Inventory.Restore(inventoryId, events);
return null;
}
private async Task GetEventsAsync(
UUId id,
int snapshotVersion,
CancellationToken ct)
{
using (var session = await \_dbSessionFactory.OpenAsync())
{
var snapshot = await GetInventorySnapshotAsync(session, inventoryId, ct);
var version = snapshot?.Version ?? 0;
var events = await GetEventsAsync(session, inventoryId, version, ct);
if (snapshot != null)
{
snapshot.ReplayEvents(events);
return snapshot;
}
if (events.Any())
{
return Domain.Inventories.Entities.Inventory.Restore(inventoryId, events);
}
return null;
}
}
private async Task GetInventorySnapshotAsync(
IDbSession session,
UUId id,
CancellationToken ct)
{
var record =
await session.QueryFirstOrDefaultAsync(Sql.GetSnapshot, new {AggregateId = id},
cancellationToken: ct);
return record == null ? null : Map(record);
}
private async Task GetEventsAsync(
IDbSession session,
UUId id,
int snapshotVersion,
CancellationToken ct)
{
var rows = await session.QueryAsync(Sql.GetEvents,
new
{
AggregateId = id,
Version = snapshotVersion
}, cancellationToken: ct);
return rows.Select(Map).ToArray();
}
private static IEvent Map(EventRecord e)
{
var type = EventTypes[e.Type];
return (IEvent) JsonConvert.DeserializeObject(e.Data, type);
}
}
internal class EventRecord
{
public string Type { get; set; }
public string Data { get; set; }
}
```
После нескольких месяцев эксплуатации мы поняли, что у нас нет большой необходимости хранить все действия пользователя над экземпляром агрегата. Бизнес никак не использует эту информацию. При этом есть накладные расходы на поддержание такого подхода. Оценив все плюсы и минусы мы планируем уйти от ES к традиционному подходу — заменить табличку `Events` на `Inventories` и `Measurements`.
Интеграция с внешними ограниченными контекстами
-----------------------------------------------
Так выглядит схема взаимодействия ограниченного контекста `Inventory` с внешним миром.
*Взаимодействие контекста ревизий с остальными контекстами. На схеме изображены контексты, сервисы и их принадлежность друг другу.*
В случае с `Auth`, `Inventory` и `Datacatalog` на каждый сервис приходится один ограниченный контекст. Монолит выполняет несколько функций, но сейчас нас интересуют только функционал учета в пиццериях. Помимо ревизий, к учету также относится движения сырья в пиццериях: поступления, перемещения, списания.
#### HTTP
Сервис `Inventory` взаимодействует с `Auth` по HTTP. Первым делом пользователь сталкивается с `Auth`, который предлагает пользователю выбрать одну из доступных ему ролей.
* В системе есть роль «ревизор», которую как раз и выбирает пользователь при проведении ревизии.
* Пользователь выбирает пиццерию.
* Перенаправляется на сервис ревизий.
На последнем этапе у пользователя есть токен от `Auth`. Сервис ревизий должен проверить этот токен, поэтому он обращается к `Auth` за проверкой. `Auth` проверит не истекло ли время жизни токена, его принадлежность владельцу, а также наличие необходимых прав доступа. Если всё хорошо, то `Inventory` сохраняет в куки клеймы — идентификатор пользователя, логин, идентификатор пиццерии и устанавливает время жизни кук.
**Примечание**. Как работает сервис `Auth` мы подробнее рассказали в статье «[Тонкости авторизации: обзор технологии OAuth 2.0](https://habr.com/ru/company/dododev/blog/520046/)».
С остальными сервисами `Inventory` взаимодействует посредством очередей сообщений. В качестве брокера сообщений в компании используется RabbitMQ, а также обвязка над ним — MassTransit.
#### RMQ: потребление событий
Сервис справочников — `Datacatalog` — обеспечит `Inventory` всеми необходимыми сущностями: сырьем для учета, странами, подразделениями и пиццериями.
Не вдаваясь в подробности инфраструктуры, опишу основную идею потребления событий. На стороне сервиса справочников уже всё готово для публикации событий, рассмотрим на примере сущности сырья.
**Код контракта события Datacatalog**
```
namespace Dodo.DataCatalog.Contracts.Products.v1
{
public class MaterialType
{
public UUId Id { get; set; }
public int Version { get; set; }
public int CountryId { get; set; }
public UUId DepartmentId { get; set; }
public string Name { get; set; }
public MaterialCategory Category { get; set; }
public UnitOfMeasure BasicUnitOfMeasure { get; set; }
public bool IsRemoved { get; set; }
}
public enum UnitOfMeasure
{
Quantity = 1,
Gram = 5,
Milliliter = 7,
Meter = 8,
}
public enum MaterialCategory
{
Ingredient = 1,
SemiFinishedProduct = 2,
FinishedProduct = 3,
Inventory = 4,
Packaging = 5,
Consumables = 6
}
}
```
Это сообщение публикуется в `exchange`. Каждый сервис может создать свою связку `exchange-queue` для потребления событий.
*Схема публикации события и его потребление через примитивы RMQ.*
В конечном итоге для каждой сущности есть очередь, на которую может подписаться сервис. Остается только сохранить новую версию в базу данных.
**Код потребителя события из Datacatalog**
```
public class MaterialTypeConsumer : IConsumer
{
private readonly IMaterialTypeRepository \_materialTypeRepository;
public MaterialTypeConsumer(IMaterialTypeRepository materialTypeRepository)
{
\_materialTypeRepository = materialTypeRepository;
}
public async Task Consume(ConsumeContext context)
{
var materialType = new AddMaterialType(context.Message.Id,
context.Message.Name,
(int)context.Message.Category,
(int)context.Message.BasicUnitOfMeasure,
context.Message.CountryId,
context.Message.DepartmentId,
context.Message.IsRemoved,
context.Message.Version);
await \_materialTypeRepository.SaveAsync(materialType, context.CancellationToken);
}
}
```
#### RMQ: публикация событий
Часть монолита, которая отвечает за учёт, потребляет данные `Inventory` для поддержки остального функционала, где требуются данные ревизий. Все события, о которых мы хотим уведомить другие сервисы, мы помечали интерфейсом `IPublicInventoryEvent`. Когда происходит событие подобного рода, мы их вычленяем из списка изменений (`changes`) и отправляем в очередь на отправку. Для этого используются две таблицы `publicqueue` и `publicqueue_archive`.
Для гарантии доставки сообщений мы используем паттерн, который у нас обычно называют «локальная очередь», подразумевая `Transactional outbox pattern`. Сохранение состояния агрегата `Inventory` и отправка событий в локальную очередь происходят в одной транзакции. Как только произошла фиксация транзакции, мы сразу же пытаемся отправить сообщения брокеру.
Если сообщение получилось отправить, то оно удаляется из очереди `publicqueue`. Если нет, то будет предпринята попытка отправить сообщение позднее. Далее подписчики монолита и пайплайны данных потребляют сообщения. Таблица `publicqueue_archive` вечно хранит данные для удобной переотправки событий, если это в какой-то момент потребуется.
**Код публикации событий в брокер сообщений**
```
internal sealed class BusDataService : IBusDataService
{
private readonly IPublisherControl _publisherControl;
private readonly IPublicQueueRepository _repository;
private readonly EventMapper _eventMapper;
public BusDataService(
IPublicQueueRepository repository,
IPublisherControl publisherControl,
EventMapper eventMapper)
{
_repository = repository;
_publisherControl = publisherControl;
_eventMapper = eventMapper;
}
public async Task ConsumePublicQueueAsync(int batchEventSize, CancellationToken cancellationToken)
{
var events = await _repository.GetAsync(batchEventSize, cancellationToken);
await Publish(events, cancellationToken);
}
public async Task Publish(IEnumerable events, CancellationToken ct)
{
foreach (var @event in events)
{
var publicQueueEvent = \_eventMapper.Map((dynamic) @event);
await \_publisherControl.Publish(publicQueueEvent, ct);
await \_repository.DeleteAsync(@event, ct);
}
}
}
```
События монолиту мы отправляем для отчетов. Отчет «потери и избыток» позволяет сравнивать две любые ревизии между собой. Помимо этого, есть важный отчет «складские остатки», о котором уже было сказано ранее.
Зачем отправлять события пайплайну данных? Все также — для отчетов, но только на новых рельсах. Раньше все отчеты жили в монолите, но теперь их выносят. Это разделяет две ответственности — хранение и обработку производственных и аналитических данных: OLTP и OLAP. Это важно как с точки зрения инфраструктуры, так и разработки.
Заключение
----------
Следуя принципам и практикам Domain-Driven Design, нам удалось построить надежную и гибкую систему, которая удовлетворяет бизнес-потребностям пользователей. У нас получился не только достойный продукт, но и хороший код, который легко модифицировать. Надеемся, что и в ваших проектах найдётся место для использования Domain-Driven Design.
> Больше информации о DDD вы можете найти в нашем сообществе [DDDevotion](https://t.me/dddevotion) и на Youtube-канале [DDDevotion](https://www.youtube.com/dddevotion). Обсудить статью можно в Телеграм в [Dodo Engineering chat](https://t.me/dododevchat). | https://habr.com/ru/post/523540/ | null | ru | null |
# Альтернативный способ кэширования UserControl`ов в Asp.net
Думаю все, кто использует Asp.net для разработки web-сайтов, прекрасно знают, что в Asp.net имеет встроенное кеширование UserControl`ов.
Любой пользовательский элемент может быть закеширован на определённое время в зависимости от различных условий. такой кэш работает крайне быстро и в большинстве случаев этого вполне достаточно, однако в проектах, в которых я принимаю участие, этого оказалось мало.
Основные недостатки заключались в следующем:
* Кэш может зависеть не только от параметров строки запроса, но и от каких-то других параметров, например от файлов-cookie или типа пользователя (например, в интернет-магазине это может быть физическое или юридическое лицо)
* Весь кэш не должен пропадать при перекомпиляции проекта (это обычно происходит при изменении файла конфигурации web.config)
* При необходимости нужно иметь возможность очистить весь кэш
Изначально мы периодически генерировали кэш для всего сайта, но со временем это стало очень большой проблемой из-за усложнения контролов, поэтому я решил поискать другое решение.
Суть его заключается в том, чтобы создать контрол, который бы сам знал, как себя кэшировать.
Для этого берем класс UserControl и создаем производный от него класс CacheUserControl:
> `public abstract class CacheUserControl : UserControl
>
> {
>
> public abstract string GetCachePath();
>
> public abstract TimeSpan GetCacheTime();
>
>
>
> public bool IsCache { get; protected set; }
>
>
>
> protected string cacheText;
>
> protected string cachePath;
>
> protected sealed override void OnInit(EventArgs e)
>
> {
>
> ...
>
> }
>
> public sealed override void RenderControl(HtmlTextWriter htmlTextWriter)
>
> {
>
> ...
>
> }
>
> }`
Как видно, тут имеются два абстрактных метода.
Метод GetCachePath возвращает путь к файлу с кешем. Этот путь должен отражать все зависимости контрола, чтобы тот смог выбрать правильный файл.
Метод GetCacheTime возвращает интервал времени, через который кэш будет считаться устаревшим и будет обновлён при необходимости.
Далее необходимо переопределить два метода класса UserControl:
Метод OnInit должен проверять существует ли файл с кэшем, и если это так, то элемент управления должен удалять все свои дочерние контролы, чтобы в них не вызывались никакие их события и загружать кэш из файла:
> `protected sealed override void OnInit(EventArgs e)
>
> {
>
> try
>
> {
>
> cachePath = GetCachePath();
>
> if (cachePath != null)
>
> {
>
> var cacheFile = new FileInfo(cachePath);
>
> if (cacheFile.Exists)
>
> {
>
> var cacheTime = GetCacheTime();
>
>
>
> var cacheTimeExpired = cacheFile.CreationTime + cacheTime < DateTime.Now;
>
> if (!cacheTimeExpired)
>
> {
>
> using (var reader = cacheFile.OpenText())
>
> {
>
> cacheText = reader.ReadToEnd();
>
> IsCache = true;
>
> Controls.Clear();
>
> }
>
> }
>
> }
>
> }
>
> }
>
> catch (IOException)
>
> {
>
> }
>
>
>
> base.OnInit(e);
>
> }`
Метод RenderControl должен проверять, загружен ли кэш, и если загружен, то рендерить именно его, а если нет, то рендерить контрол в обычном режиме и дополнительно создавать файл с кэшем:
> `public sealed override void RenderControl(HtmlTextWriter htmlTextWriter)
>
> {
>
> if(IsCache)
>
> {
>
> htmlTextWriter.Write(cacheText);
>
> }
>
> else
>
> {
>
> base.RenderControl(htmlTextWriter);
>
>
>
> try
>
> {
>
> if (cachePath != null)
>
> {
>
> using (var streamWriter = new StreamWriter(cachePath, false, Encoding.UTF8))
>
> {
>
> using (htmlTextWriter = new HtmlTextWriter(streamWriter))
>
> {
>
> base.RenderControl(htmlTextWriter);
>
> }
>
> }
>
> }
>
> }
>
> catch (IOException)
>
> {
>
> }
>
> }
>
> }`
В итоге, для использования самокэширующегося контрола необходимо изменить базовый класс с UserControl на CacheUserConrtol и дополнительно определить два метода, например так:
> `public override string GetCachePath()
>
> {
>
> var id = Request.QueryString["id"];
>
> if(string.IsNullOrEmpty(id)) return null;
>
>
>
> var currency = "rur";
>
> var cookie = Request.Cookies["currency"];
>
> if(cookie != null)
>
> {
>
> var value = cookie.Value;
>
> if (value == "usd") currency = "usd";
>
> else if (value == "euro") currency = "euro";
>
> }
>
>
>
> var path = string.Format("~/cache/cat\_{0}\_cur\_{1}.html", id, currency);
>
> return Server.MapPath(path);
>
> }
>
> public override TimeSpan GetCacheTime()
>
> {
>
> return TimeSpan.FromDays(7);
>
> }`
Теперь контрол сам будет создавать отдельные файлы с кэшем для различных категорий (определяется по id) для каждой валюты каталога (определяется из cookie)
Единственный минус данного подхода в том, что со временем в кэше будет накапливаться мусор, поэтому его периодически придётся полностью очищать. Также следует отметить, метод Page\_Load такого контрола вызывается в любом случае, а вот события дочерних контролов только в случае, если содержимое берётся не из файла.
Ну вот собственно и всё. | https://habr.com/ru/post/60352/ | null | ru | null |
# Как связать две АТС на базе FreePBX через IAX2 с применением шифрования
Хочу рассмотреть простейший способ соединить две АТС на базе популярнейшей системы FreePBX. А чтобы нас не слушало ни АНБ, ни ФСБ — добавим шифрование.
В этом примере соединяем Москву и Питер. В Москве у нас номера вида 1XX, в Питере вида 2XX.
1. В Москве создаём новый IAX2 транк
Trunk name: spb
Outbound Caller ID: не важен
Trunk name (повторно): spb
Peer details:
```
username=msk
secret=<длинный пароль>
host=
type=friend
context=from-internal
qualify=yes
trunk=yes
forceencryption=yes
auth=md5
disallow=all
allow=speex
```
Подставьте свои пароль (подлиннее) и host (имя а лучше адрес удалённого сервера).
В теге allow замените кодек на тот, который вам нравится. Я рекомендую [Speex](https://ru.wikipedia.org/wiki/Speex) и [iLBC](https://ru.wikipedia.org/wiki/ILBC) как современные и свободные кодеки с хорошим качеством звука и хорошим сжатием.
Если сеть плохая, можно добавить jitterbuffer=yes обязательно в комплекте с trunktimestamps=yes
Всё! Здесь больше ничего не нужно заполнять.
2. В Питере делаем всё то же самое, но немного наоборот — где в пункте один spb, там пишем msk, а где msk, пишем spb.
3. Создаём outbound route. Ставим галочку intra-company, а в поле match pattern в Москве пишем 2XX, в Питере 1XX.
4. Если нужно — открываете/пробрасываете UDP порт 4569
5. В консоли (или в меню tools) команда iax2 show peers должна показать что-то вроде:
```
Name/Username Host Mask Port Status Description
spb/msk x.x.x.x (S) 255.255.255.255 4569 (T) (E) OK (12 ms)
1 iax2 peers [1 online, 0 offline, 0 unmonitored]
```
Всё в порядке, теперь можно звонить напрямую, просто набрав внутренний номер офиса в другом городе. | https://habr.com/ru/post/200416/ | null | ru | null |
# Начинаем изучать Cortex-M на примере STM32, часть 2
Данная статья является продолжением цикла по программированию микроконтроллеров на базе ядра Cortex-M.
Первую статью можно прочитать здесь:
[Начинаем изучать Cortex-M на примере STM32](http://habrahabr.ru/post/216843)
Задачей статей является подробное описание особенностей, возникающих при программировании МК. Материал не предназначен для желающих за 10 минут запустить пример мигания светодиодом. Я постараюсь подробно описать то, что часто скрывают от новичков, чтобы их не напугать.
Мне очень хочется, чтобы программисты использующие стандартные библиотеки, шаблоны, примеры и т.д. понимали как все это работает. А при отсутствии этих самых библиотек и примеров могли самостоятельно решить свою задачу.
Основной акцент сделан на изучение документации на ядро Cortex-M и документации на конкретный контроллер.
На этот раз речь пойдет про прерывания, а так же будут затронуты некоторые вопросы архитектуры памяти и структуры прошивки МК.
#### Несколько слов про документацию ARM
По не совсем ясным для меня причинам, нельзя зайти на сайт [ARM](http://www.arm.com/) и скачать полную документацию на ядро Cortex-M4. Да и на Cortex-M3 тоже нельзя.
Придется почитать несколько документов.
1. Изучение придется начать с [Cortex ™-M3 TechnicalReference Manual Revision: r1p1](http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337e/DDI0337E_cortex_m3_r1p1_trm.pdf) — самой первой ревизии технической спецификации на ядро Cortex-M3
2. Во всех дальнейших ревизиях и описании [Cortex ™-M4 TechnicalReference Manual](http://infocenter.arm.com/help/topic/com.arm.doc.ddi0439d/DDI0439D_cortex_m4_processor_r0p1_trm.pdf) описаны лишь общие данные и изменения относительно предыдущего документа.
Так что прошу не удивляться ссылкам на спецификации другого ядра.
#### Interrupt and Events
Прежде всего необходимо разобраться с тем, что такое прерывания.
В МК Cortex-M есть два понятия, которые часто путают *Interrupt* и *Event*.
*Event* — это событие (аппаратное или программное), на которое могут реагировать ядро или периферийные блоки. Одним из вариантов реакции может быть — прерывание.
*Interrupt* — это прерывание работы программы и переход управления в специализированный участок обработчик прерывания.
Взаимосвязь между *Event* и *Interrupt* заключается в следующем:
*Каждый Interrupt вызывается Event, но не каждый Event вызывает Interrupt.*
Помимо прерываний, события могут активировать и другие возможности МК.
#### NVIC
Управление и обработка прерываниями производится *контроллером приоритетных векторных прерываний NVIC (Nested Vectored Interrupt Controller)*. Контроллер прерываний часть ядра Cortex-M. Документацию на этот контроллер необходимо начинать изучать с [Cortex ™-M3 TechnicalReference Manual Revision: r1p1](http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337e/DDI0337E_cortex_m3_r1p1_trm.pdf)
При возникновении, некоторого события контроллер прерываний автоматически прерывает выполнение основной программы, и вызывает соответствующую функцию обработки прерываний. После выхода из функции обработчика прерываний программа продолжает выполнение с того места, где произошло прерывание. Все происходит автоматически (при правильной настройке NVIC, но об этом ниже).
Из самого названия видно, что контроллер NVIC поддерживает вложенность прерываний и приоритеты. Каждому прерыванию при настройке NVIC присваивается свой приоритет. Если во время обработки низкоприоритетного прерывания возникает высокоприоритетное, то оно, в свою очередь, прервет обработчик низкоприоритетного прерывания.
#### Как это работает?
Данный пост не претендует на абсолютную полноту, я советую изучить раздел прерываний в [Cortex™-M3 Technical Reference Manual](http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337e/DDI0337E_cortex_m3_r1p1_trm.pdf). Поскольку эта часть ядра не претерпела изменений, ее описание дано в первой ревизии r1p1 на ядро Cortex-M3.
##### Вход в прерывание и выход из него
При инициации прерывания NVIC переключает ядро в режим обработки прерывания. После перехода в режим обработки прерывания регистры ядра помещаются в стек. Непосредственно во время записи значения регистров в стек осуществляется выборка начального адреса функции обработки прерывания.
В стек перемещается регистр регистр статуса программы ( *Program Status Register (PSR)*), счетчик программы (*Program Counter (PC)*) и регистр связи (*Link Register (LR)* ). Описание регистров ядра приведено в [Cortex-M4 Generic User Guide](http://infocenter.arm.com/help/topic/com.arm.doc.dui0553a/DUI0553A_cortex_m4_dgug.pdf). Благодаря этому, запоминается состояние, в котором находилось ядро перед переходом в режим обработки прерываний.
Также сохраняются регистры R0 — R3 и R12. Эти регистры используются в инструкциях для передачи параметров, поэтому, помещение в стек делает возможным их использование в функции обработки прерывания, а R12 часто выступает в роли рабочего регистра программы.
По завершении обработки прерывания все действия выполнятся в обратном порядке: извлекается содержимое стека и, параллельно с этим, осуществляется выборка адреса возврата.
С момента инициации прерывания до выполнения первой команды обработчика прерывний проходит 12 тактов, такое же время необходимо для возобновления основной программы после завершения обработки прерывания.
##### Вложенность прерываний
Как было сказано выше NVIC поддерживает прерывания с различными приоритетами, которые могут прерывать друг друга. При этом, могут возникнуть различные ситуации, обработка которых по разному оптимизирована.
*1. Приостановка низкоприоритетного прерывания*
В этой ситуации, обработка низкоприоритетного прерывания прекращается. Следующие 12 циклов выполняется сохранение в стек нового набора данных и запускается обработка высокоприоритетного прерывания. После его обработки, содержимое стека автоматически извлекается и возобновляется обработка низкоприоритетного прерывания.
Больших отличий от прерывания основной программы не наблюдается.
*2. Непрерывная обработка прерываний*
Эта ситуация может возникнуть в двух случаях: если два прерывания имеют одинаковый приоритет и возникают одновременно, если низкоприоритетное прерывание возникает во время обработки высокоприоритетного.
В этом случае, промежуточные операции над стеком не производятся. Происходит только загрузка адреса обработчика низкоприоритетного прерывания и переход к его выполнению. Отказ от операций над стеком экономит 6 тактов. Переход к следующему прерыванию происходит не за 12 тактов, а всего за 6.
*3. Запаздывание высокприоритетного прерывания*
Ситуация возникает, если высокоприоритетное прерывание происходит во перехода к обработке низкоприоритетного (за те самые 12 тактов). В этом случае переход к высокоприоритетному прерыванию будет происходить не менее 6 тактов с момента его возникновения (время необходимое для загрузки адреса обработчика прерывания и перехода к нему). Возврат в низкоприоритетное уже описан выше.
##### Приоритеты прерываний
Помимо простой установки приоритета прерываний, NVIC реализует возможность группировки приоритетов.
Прерывания в группе с более высоким приоритетом могут прерывать обработчики прерываний группы с более низким приоритетом. прерывания из одной группы, но с разным приоритетом внутри группы не могут прерывать друг друга. Приоритет внутри группы определяет только порядок вызова обработчика, когда были активизированы оба события.
Значение приоритета прерывания задается в регистрах *Interrupt Priority Registers* (см. [Cortex-M4 Generic User Guide](http://infocenter.arm.com/help/topic/com.arm.doc.dui0553a/DUI0553A_cortex_m4_dgug.pdf)). При этом, часть бит отвечает за приоритет группы, в которой находится прерывание, а часть — за приоритет внутри группы.
Настройка распределение бит на приоритет группы или приоритет внутри группы осуществляется с помощью регистра *Application Interrupt and Reset Control Register* (ВНИМАТЕЛЬНО!!! см. [Cortex-M4 Generic User Guide](http://infocenter.arm.com/help/topic/com.arm.doc.dui0553a/DUI0553A_cortex_m4_dgug.pdf)).
Как вы, наверно, заметили, в [Cortex-M4 Generic User Guide](http://infocenter.arm.com/help/topic/com.arm.doc.dui0553a/DUI0553A_cortex_m4_dgug.pdf) сказано, что настройка приоритетов и группировки приоритетов зависят от конкретной реализации *implementation defined*.
А вот дальше не очень приятная вещь. В [Reference manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/DM00046982.pdf) к МК STM32F407 про NVIC почти нет информации. Но есть ссылка на отдельный документ. Для того, чтобы разобраться с реализацией NVIC в STM32 придется прочитать еще один документ — [STM32F3xxx and STM32F4xxx Cortex-M4 programming manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/DM00046982.pdf). Вообще говоря, я советую внимательно изучить данный документ и по всем другим вопросам, в нем работа ядра расписана более подробно, чем в документации от ARM.
В нем, уже можно найти:
> A programmable priority level of 0-15 for each interrupt. A higher level corresponds to a
>
> lower priority, so level 0 is the highest interrupt priority
Из возможных 8 бит приоритета используются только 4. Но этого вполне достаточно для большинства задач.
##### Маскирование прерываний
Предположим, что у нас стоит задача запуска ракеты-носителя при нажатии на красную кнопку, но только при условии, что повернут ключ.
Нет совершенно ни какого смысла генерировать прерывание на поворот ключа. А вот прерывание на нажатие красной копки нам понадобится. Для того, чтобы включать/выключать различные вектора прерываний, существует маскирование прерываний.
Маскирование прерывания осуществляется с помощью регистров [*Interrupt Set-enable Registers*](http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337e/DDI0337E_cortex_m3_r1p1_trm.pdf).
Если прерывание замаскировано, это не означает, что периферия не генерирует события! Просто NVIC не вызывает обработчик этого события.
##### Таблица векторов прерываний
Все возможные прерывания, поддерживаемые NVIC, записываются в таблицу векторов прерываний. По сути своей, таблица векторов прерываний есть ни что иное, как список адресов функций обработчиков прерываний. Номер в списке соответствует номеру прерывания.
Как написано в [Cortex-M4 Generic User Guide](http://infocenter.arm.com/help/topic/com.arm.doc.dui0553a/DUI0553A_cortex_m4_dgug.pdf), NVIC поддерживает до 240 различных векторов прерываний. Но реализация уже зависит от конкретного производителя.
В описании ядра стандартизованы только прерывания исключений ядра (см. раздел *2.3.2 Exception types* в [Cortex-M4 Generic User Guide](http://infocenter.arm.com/help/topic/com.arm.doc.dui0553a/DUI0553A_cortex_m4_dgug.pdf)):
* Reset
* NMI
* HardFault
* MemManage
* BusFault
* UsageFault
* SVCall
* PendSV
* SysTick
С описанием этих исключений я предлагаю вам ознакомиться самостоятельно. Некоторые из них будут затронуты в следующих статьях.
Остальные прерывания уникальны для МК. Описание таблицы векторов вашего МК вы можете найти в соответствующем [Reference manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/DM00031020.pdf) (см. Vector table for STM32F405xx/07xx and STM32F415xx/17xx). Контроллеры STM32F4xx поддерживают 81 вектор прерываний. Можно заметить, что в этой таблице перечислены все периферийные блоки (а некоторые не единожды).
Практически все периферийные блоки генерируют прерывания, чтобы ядро отвлекалось на работку с ним только по наступлению какого-либо значимого события (например, получении данных по UART).
##### Расположение векторов прерываний и загрузка МК
Разобравшись с принципами работы прерываний в Cortex-M осталось понять только где хранится таблица прерываний.
Для этого стоит рассмотреть процесс загрузки и структуру прошивки контроллера. На этот раз мы будем рассматривать только загрузку из встроенной флеш памяти.
В таблице векторов, находящейся в начале адресного пространства флеш памяти должны находиться по крайней мере (см. [Cortex-M3 Technical Reference Manual](http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337e/DDI0337E_cortex_m3_r1p1_trm.pdf):
> • stack top address
>
> • reset routine location
>
> • NMI ISR location
>
> • Hard Fault ISR location.
Из начала флеш памяти ядро считывает значение SP (stack top addres) и PC (reset routine location). Таким образом, автоматически начинает выполняться функция, с адресом считанным в регистр PC. Это может быть, например main.
После обязательных четырех компонентов, может находиться дальнейшая таблица векторов прерываний. Главное сохранить порядок.
При желании, можно разместить таблицу векторов прерываний в другой области памяти, но тогда, необходимо сообщить NVIC, куда мы передвинули таблицу. За это смещение таблицы векторов отвечает регистр *Vector Table Offset Register* (см. [Cortex-M4 Technical Reference Manual](http://infocenter.arm.com/help/topic/com.arm.doc.ddi0439d/DDI0439D_cortex_m4_processor_r0p1_trm.pdf). Это может понадобиться для написание встроенного загрузчика нового ПО (bootloader), но об этом как-нибудь в другой раз.
#### От теории к практике
##### ТЗ второго проекта
Пример создается для отладочной платы [STM32F4Discovery](http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/PF252419#).
При нажатии на кнопку должен загореться светодиод LED3. При замыкании контактов PC6 и GND загорается светодиод LED5.
В процессе программирования поиграемся с приоритетами прерываний и посмотрим к чему это приведет.
##### Железная часть
Найдем в [документации к плате](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00039084.pdf) кнопку и светодиод:
При ненажатой кнопке на пине PA0 будет логический ноль, при нажатии на кнопку на кнопке появится логическая 1 (3.3В).
Светодиод LED3 подключен к пину PD13.
Светодиод LED5 подключен к пину PD14.
Интересней всего с контактом PC6 — он напрямую выведен на штыревой разъем. Нам будет необходимо обеспечить регистрацию логической 1, когда он не закорочен с контактом GND. О том, как это сделать пойдет речь ниже.
##### Настройка GPIO
Для нашей задачи необходимо настроить пины PD13 и PD14 как выходные. О том, как это делать можно прочитать в [предыдущей статье](http://habrahabr.ru/post/216843).
С настройкой пина PA0 тоже все достаточно просто — его нужно настроить на вход. Не смотря на то, что после ресчета МК почти все пины настроены на вход, крайне желательно явно прописать эту инициализацию.
С пином PC7 все несколько интереснее. Поскольку он «висит в воздухе», его состояние не определено. Нам же необходимо, чтобы при этом его состояние всегда было «1». Для этого, в блоке GPIO активировать подтяжку. В нашем случае, необходима подтяжка к питанию — PULL UP.
Активация подтяжки осуществляется с помощью регистра *GPIO port pull-up/pull-down register*.
##### Прерывания EXTI
Для выполнения нашего «ТЗ» с использованием прерываний, нам необходимо настроить прерывания, которые будут срабатывать при переходе контакта PA0 из состояния «0» в состояние «1», и прерывание при переходе контакта PC6 из состояния «1» в состояние «0».
В МК STM32F4xx для этой цели служит контроллер внешних прерываний/событий - *EXTI* (External interrupt/event controller). Я настоятельно рекомендую ознакомиться с его функционалом в [Reference manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/DM00031020.pdf). Нам необходимо поступить в соответствии с описанным:
> Hardware interrupt selection
>
> To configure the 23 lines as interrupt sources, use the following procedure:
>
> • Configure the mask bits of the 23 interrupt lines (EXTI\_IMR)
>
> • Configure the Trigger selection bits of the interrupt lines (EXTI\_RTSR and EXTI\_FTSR)
>
> • Configure the enable and mask bits that control the NVIC IRQ channel mapped to the external interrupt controller (EXTI) so that an interrupt coming from one of the 23 lines can be correctly acknowledged.
Нам понадобятся 0 и 6 линии EXTI. Для размаскирования соответствующих линий прерываний необходимо записать в регистр EXTI\_IMR значение 0x9.
Для линии PA0, необходима генерация события прерывания по переходу из состояния «0» в состояние «1» — по возрастающему фронту. То есть, необходимо записать 1 в нулевой бит регистра EXTI\_RTSR.
Для линии PC6, наоборот, необходима генерация события прерывания по переходу из состояния «1» в состояние «0» — по падающему фронту. То есть, необходимо записать 1 в шестой бит регистра EXTI\_FTSR.
На этом настройка блока EXTI закончена. Последний пункт будет реализован при настойке NVIC.
По мимо этого, необходимо определиться, пин с какого порта подключается к определенной линии EXTI. Делается это с помощью регистров *SYSCFG external interrupt configuration register* ([Reference manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/DM00031020.pdf)). Эти регистры находятся в *System configuration controller*, что мне кажется не очень логичным (почему было не включить эту насторойку в EXTI?), но оставим сей факт на совести ST.
##### Настройка NVIC
Активация обработки определенного вектора прерывания осуществляется с помощью регистров *Interrupt set-enable registers (NVIC\_ISERx)*. Описание регистров приведено в [Cortex-M4 Generic User Guide](http://infocenter.arm.com/help/topic/com.arm.doc.dui0553a/DUI0553A_cortex_m4_dgug.pdf). Сама таблицу векторов прерываний для нашего МК приведена в [Reference manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/DM00031020.pdf) (см. Table 61).
Из таблицы можно увидеть, что для 0 линии есть отдельное прерывание, а вот линии с 5 по 9 генерируют одно прерывание на всех.
Кроме того, из таблицы мы узнали номера векторов, необходимых нам прерываний. Теперь нужно записать «1» в 6 бит (активация прерываний линии 0 EXTI) регистра NVIC\_ISER0 (адрес 0xE000E100) и в 23 бит того же регистра (активация прерываний линий 5-9).
##### Настройка приоритетов
Для того, чтобы можно было побаловаться с приоритетами прерываний настроим группы приоритетов так, чтобы 2 бита отвечали за приоритет внутри группы, и 2 бита — за приоритет самой группы. Для этого необходимо записать значение 0х05FA0500 в регистр *Application interrupt and reset control register* ([STM32F3xxx and STM32F4xxx Cortex-M4 programming manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/DM00046982.pdf)).
Настройка приоритетов осуществляется с помощью регистров *Interrupt Priority Registers* ([STM32F3xxx and STM32F4xxx Cortex-M4 programming manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/DM00046982.pdf)). Нас будут интересовать регистры Interrupt Priority Register 2 (0xE000E4008) и регистр Interrupt Priority Register 5(0xE000E401C).
Пока не будем изменять приоритеты. Пусть будут одинаковы для обоих прерываний.
##### Обработка прерываний
Функции обработчики прерываний — ни что иное, как просто функции языка C, который ни чего не получают и не возвращают (и правильно — не от кого и не кому).
*Главное правило — обработка прерываний должна осуществляться как можно быстрее!!!* Иначе низкоприоритетные прерывания могут слишком долго ждать.
После окончания обработки прерывания необходимо сбросить активность события, вызвавшего прерывание — «очистить прерывание». Очистка прерывания EXTI производится с помощью регистра EXTI\_PR . Обратите внимание: запись «1» очищает прерывание, запись «0» не имеет ни какого воздействия.
Если с обработкой прерывания линии 0 EXTI все достаточно просто, то с группой линий 5-9 возникает вопрос — как определить какая линия вызвала прерывание. Узнать это можно проверкой бит регистра Pending register (EXTI\_PR) — [Reference manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/DM00031020.pdf).
##### Создаем таблицу векторов и располагаем ее в правильном месте
Для тог, чтобы таблица векторов с правильными адресами функций обработчиков прерываний располагались в начале флеш памяти МК, создадим и подключим к проекту файл startup.c.
**Содержимое файла**
```
// Enable the IAR extensions for this source file.
#pragma language=extended
#pragma segment="CSTACK"
// Forward declaration of the default fault handlers.
void ResetISR(void);
static void NmiSR(void);
static void FaultISR(void);
static void IntDefaultHandler(void);
// The entry point for the application startup code.
extern void __iar_program_start(void);
extern void EXTI_Line0_IntHandler(void);
extern void EXTI_Line6_IntHandler(void);
// A union that describes the entries of the vector table. The union is needed
// since the first entry is the stack pointer and the remainder are function
// pointers.
typedef union
{
void (*pfnHandler)(void);
void * ulPtr;
}
uVectorEntry;
// The vector table. Note that the proper constructs must be placed on this to
// ensure that it ends up at physical address 0x0000.0000.
__root const uVectorEntry __vector_table[] @ ".intvec" =
{
{ .ulPtr = __sfe( "CSTACK" ) },
// The initial stack pointer
ResetISR, // The reset handler
NmiSR, // The NMI handler
FaultISR, // The hard fault handler
IntDefaultHandler, // MPU Fault Handler
IntDefaultHandler, // Bus Fault Handler
IntDefaultHandler, // Usage Fault Handler
IntDefaultHandler, // Reserved
IntDefaultHandler, // Reserved
IntDefaultHandler, // Reserved
IntDefaultHandler, // Reserved
IntDefaultHandler, // SVCall Handler
IntDefaultHandler, // Debug Monitor Handler
IntDefaultHandler, // Reserved
IntDefaultHandler, // PendSV Handler
IntDefaultHandler, // SysTick Handler
//External Interrupts
IntDefaultHandler, // Window WatchDog
IntDefaultHandler, // PVD through EXTI Line detection
IntDefaultHandler, // Tamper and TimeStamps through the EXTI line
IntDefaultHandler, // RTC Wakeup through the EXTI line
IntDefaultHandler, // FLASH
IntDefaultHandler, // RCC
EXTI_Line0_IntHandler, // EXTI Line0
IntDefaultHandler, // EXTI Line1
IntDefaultHandler, // EXTI Line2
IntDefaultHandler, // EXTI Line3
IntDefaultHandler, // EXTI Line4
IntDefaultHandler, // DMA1 Stream 0
IntDefaultHandler, // DMA1 Stream 1
IntDefaultHandler, // DMA1 Stream 2
IntDefaultHandler, // DMA1 Stream 3
IntDefaultHandler, // DMA1 Stream 4
IntDefaultHandler, // DMA1 Stream 5
IntDefaultHandler, // DMA1 Stream 6
IntDefaultHandler, // ADC1, ADC2 and ADC3s
IntDefaultHandler, // CAN1 TX
IntDefaultHandler, // CAN1 RX0
IntDefaultHandler, // CAN1 RX1
IntDefaultHandler, // CAN1 SCE
EXTI_Line6_IntHandler, // External Line[9:5]s
IntDefaultHandler, // TIM1 Break and TIM9
IntDefaultHandler, // TIM1 Update and TIM10
IntDefaultHandler, // TIM1 Trigger and Commutation and TIM11
IntDefaultHandler, // TIM1 Capture Compare
IntDefaultHandler, // TIM2
IntDefaultHandler, // TIM3
IntDefaultHandler, // TIM4
IntDefaultHandler, // I2C1 Event
IntDefaultHandler, // I2C1 Error
IntDefaultHandler, // I2C2 Event
IntDefaultHandler, // I2C2 Error
IntDefaultHandler, // SPI1
IntDefaultHandler, // SPI2
IntDefaultHandler, // USART1
IntDefaultHandler, // USART2
IntDefaultHandler, // USART3
IntDefaultHandler, // External Line[15:10]s
IntDefaultHandler, // RTC Alarm (A and B) through EXTI Line
IntDefaultHandler, // USB OTG FS Wakeup through EXTI line
IntDefaultHandler, // TIM8 Break and TIM12
IntDefaultHandler, // TIM8 Update and TIM13
IntDefaultHandler, // TIM8 Trigger and Commutation and TIM14
IntDefaultHandler, // TIM8 Capture Compare
IntDefaultHandler, // DMA1 Stream7
IntDefaultHandler, // FSMC
IntDefaultHandler, // SDIO
IntDefaultHandler, // TIM5
IntDefaultHandler, // SPI3
IntDefaultHandler, // UART4
IntDefaultHandler, // UART5
IntDefaultHandler, // TIM6 and DAC1&2 underrun errors
IntDefaultHandler, // TIM7
IntDefaultHandler, // DMA2 Stream 0
IntDefaultHandler, // DMA2 Stream 1
IntDefaultHandler, // DMA2 Stream 2
IntDefaultHandler, // DMA2 Stream 3
IntDefaultHandler, // DMA2 Stream 4
IntDefaultHandler, // Ethernet
IntDefaultHandler, // Ethernet Wakeup through EXTI line
IntDefaultHandler, // CAN2 TX
IntDefaultHandler, // CAN2 RX0
IntDefaultHandler, // CAN2 RX1
IntDefaultHandler, // CAN2 SCE
IntDefaultHandler, // USB OTG FS
IntDefaultHandler, // DMA2 Stream 5
IntDefaultHandler, // DMA2 Stream 6
IntDefaultHandler, // DMA2 Stream 7
IntDefaultHandler, // USART6
IntDefaultHandler, // I2C3 event
IntDefaultHandler, // I2C3 error
IntDefaultHandler, // USB OTG HS End Point 1 Out
IntDefaultHandler, // USB OTG HS End Point 1 In
IntDefaultHandler, // USB OTG HS Wakeup through EXTI
IntDefaultHandler, // USB OTG HS
IntDefaultHandler, // DCMI
IntDefaultHandler, // CRYP crypto
IntDefaultHandler, // Hash and Rng
IntDefaultHandler, // FPU
};
// This is the code that gets called when the processor first starts execution
// following a reset event. Only the absolutely necessary set is performed,
// after which the application supplied entry() routine is called. Any fancy
// actions (such as making decisions based on the reset cause register, and
// resetting the bits in that register) are left solely in the hands of the
// application.
void
ResetISR(void)
{
//
// Call the application's entry point.
//
__iar_program_start();
}
// This is the code that gets called when the processor receives a NMI. This
// simply enters an infinite loop, preserving the system state for examination
// by a debugger.
static void
NmiSR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
// This is the code that gets called when the processor receives a fault
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
static void
FaultISR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
// This is the code that gets called when the processor receives an unexpected
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
static void
IntDefaultHandler(void)
{
//
// Go into an infinite loop.
//
while(1)
{
}
}
```
Использование
```
@ ".intvec"
```
Располагает таблицу \_\_vector\_table в начале секции, объявленной в файле линкера. Сам файл можно посмотреть тут:
Сама секция задается в начале ROM памяти. Адреса можно посмотреть [тут](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/DM00023388.pdf) (документ, в котором описана адресация флеш памяти STM32):
Комбинация директивы IAR и спецфункции IAR:
```
#pragma segment="CSTACK"
__sfe( "CSTACK" )
```
Записывает в начале флеша указатель на верхушку стека.
Саму таблицу заполняют адреса функций, реализующий вечный цикл. Исключение сделано только для интересующих нас функций:
```
extern void EXTI_Line0_IntHandler(void);
extern void EXTI_Line6_IntHandler(void);
```
В функции, вызываемой при старте, просто производится переход к
```
extern void __iar_program_start(void);
```
Это функция — main(). Сам символ можно переопределить, если возникнет желание:
##### Переходим к основному файлу
Для начала выпишем и переопределим все адреса и битовые поля, которые нам понадобятся.
**Листинг**
```
//Definitions for SCB_AIRCR register
#define SCB_AIRCR (*(unsigned volatile long*)0xE000ED0C) //acces to SCB_AIRCR
#define SCB_AIRCR_GROUP22 0x05FA0500 //change priority data
//Definitions for RCC_AHB1_ENR register
#define RCC_AHB1_ENR (*(unsigned volatile long *)(0x40023830)) //acces to RCC_AHB1ENR reg
#define RCC_AHB1_ENR_GPIOA 0x1 //GPIOA bitfield
#define RCC_AHB1_ENR_GPIOC 0x4 //GPIOC bitfield
#define RCC_AHB1_ENR_GPIOD 0x8 //GPIOD bitfield
//Definitions for RCC_APB2_ENR register
#define RCC_APB2_ENR (*(unsigned volatile long *)(0x40023844)) //acces to RCC_APB2ENR reg
#define RCC_APB2_ENR_SYSCFG 0x4000 //SYSCFG bitfield
//Definitions for GPIO MODE registers
#define GPIOA_MODER (*(unsigned volatile long*)(0x40020000)) //acces to GPIOA_MODER reg
#define GPIOC_MODER (*(unsigned volatile long*)(0x40020800)) //acces to GPIOC_MODER reg
#define GPIOD_MODER (*(unsigned volatile long*)(0x40020C00)) //acces to GPIOD_MODER reg
//GPIO ODR register definition
#define GPIOD_ODR (*(unsigned volatile long*)(0x40020C14)) //acces to GPIOD_MODER reg
#define GPIO_ODR_13PIN 0x2000
#define GPIO_ODR_14PIN 0x4000
//Bitfields definitions
#define GPIO_MODER_0BITS 0x3 //Pin 0 mode bits
#define GPIO_MODER_0IN 0x0 //Pin 0 input mode
#define GPIO_MODER_6BITS 0x300 //Pin 6 mode bits
#define GPIO_MODER_6IN 0x000 //Pin 6 input mode
#define GPIO_MODER_13BITS 0xC000000 //Pin 13 mode bits
#define GPIO_MODER_13OUT 0x4000000 //Pin 13 output mode
#define GPIO_MODER_14BITS 0x30000000 //Pin 14 mode bits
#define GPIO_MODER_14OUT 0x10000000 //Pin 14 output mode
//GPIOC_PUPDR register definition
#define GPIOC_PUPDR (*(unsigned volatile long*)(0x4002080C)) //acces to GPIOC_PUPDR reg
#define GPIOC_PUPDR_6BITS 0x3000 //PC6 bitfield
#define GPIOC_PUPDR_6PU 0x1000 //PC6 pull-up enable
//SYSCFG_EXTIx registers definitions
#define SYSCFG_EXTICR1 (*(unsigned volatile long*)0x40013808) //SYSCFG_EXTICR1 acces
#define SYSCFG_EXTICR1_0BITS 0xF //EXTI 0 bits
#define SYSCFG_EXTICR1_0PA 0x0 //EXTI 0 - port A
#define SYSCFG_EXTICR2 (*(unsigned volatile long*)0x4001380C) //SYSCFG_EXTICR2 acces
#define SYSCFG_EXTICR2_6BITS 0xF00 //EXTI 6 bits
#define SYSCFG_EXTICR2_6PC 0x200 //EXTI 6 - port C
//EXTI definitions
#define EXTI_IMR (*(unsigned volatile long*)0x40013C00) //EXTI_IMR reg acces
#define EXTI_LINE0 0x1 //LINE 0 definition
#define EXTI_LINE6 0x40 //LINE 6 definition
#define EXTI_RTSR (*(unsigned volatile long*)0x40013C08) //EXTI_RTSR reg acces
#define EXTI_FTSR (*(unsigned volatile long*)0x40013C0C) //EXTI_FTSR reg acces
#define EXTI_PR (*(unsigned volatile long*)0x40013C14) //EXTI_PR reg acces
//NVIC registers and bits definitions
#define NVIC_ISER0_REG (*(unsigned volatile long*)0xE000E100) //NVIC_ISER0 reg acces
#define NVIC_ISER0_6VECT 0x40 //vect 6 definition
#define NVIC_ISER0_23VECT 0x800000 //vect 30 definition
#define NVIC_IPR0_ADD (0xE000E400)
#define NVIC_IPR23_REG (*(unsigned volatile char*)(NVIC_IPR0_ADD + 23))
#define NVIC_IPR6_REG (*(unsigned volatile char*)(NVIC_IPR0_ADD + 6))
```
Обратите внимание на то, что значения спецрегистров МК объявлены как *volatile*. Это необходимо, чтобы компилятор не пытался оптимизировать операции обращения к ним, поскольку это не просто участки памяти и их значения могут изменяться без участия ядра.
###### Настраиваем группирование приоритетов
В первую очередь стоит настроить группировку приоритетов прерываний:
```
SCB_AIRCR = SCB_AIRCR_GROUP22;
```
.Данное действие должно выполняться только один раз. В сложных проектах, использующих сторонние библиотеки стоит проверять данный факт. Изменение разбиения приоритетов на группы может привести к некорректной работе прошивки.
###### Включение тактирование используемой периферии
Напомню, что перед началом работы с периферийными блоками необходимо включить их тактирование:
```
//Enable SYSCFG , GPIO port A and D clocking
RCC_AHB1_ENR |= RCC_AHB1_ENR_GPIOA|RCC_AHB1_ENR_GPIOC|RCC_AHB1_ENR_GPIOD;
RCC_APB2_ENR |= RCC_APB2_ENR_SYSCFG;
```
Работать сразу с SYSCFG нельзя, нужно подождать несколько тактов. Но мы и не будем. Займемся инициализацией GPIO.
###### Инициализация GPIO
Светодиоды инициализируются так же как и в прошлый раз:
```
//LED3 and LED5 initialization
GPIOD_MODER = (GPIOD_MODER & (~GPIO_MODER_13BITS)) | GPIO_MODER_13OUT;
GPIOD_MODER = (GPIOD_MODER & (~GPIO_MODER_14BITS)) | GPIO_MODER_14OUT;
```
Кнопка PA0 и контакт PC7 инициализируются как входные:
```
//PA0 and PC6 pins initialization
GPIOA_MODER = (GPIOA_MODER & (~GPIO_MODER_0BITS)) | GPIO_MODER_0IN;
GPIOC_MODER = (GPIOC_MODER & (~GPIO_MODER_6BITS)) | GPIO_MODER_6IN;
```
Вот только для контакта PC6 необходимо включить подтяжку питания. Активация подтяжки производится с помощью регистра GPIOC\_PUPDR:
```
//Enable PC6 pull-up
GPIOC_PUPDR = (GPIOC_PUPDR & (~GPIOC_PUPDR_7BITS)) | GPIOC_PUPDR_6PU;
```
###### Настройка EXTI
И так, на нужно настроить следующие параметры — включить прерывания для линий 0 и 6, для линии 0 прерывание по растущему фронту, для линии 6 — прерывание по падающему фронту:
```
//Set up EXTI
EXTI_RTSR |= EXTI_LINE0;
EXTI_FTSR |= EXTI_LINE6;
EXTI_IMR = EXTI_LINE0|EXTI_LINE6;
```
Осталось настроить пины каких портов подключены к линии EXTI (странное решение, например МК stellaris могут генерировать прерывание при любой комбинации пинов, у STM32 с этим сложнее):
```
//EXTI to port connection
SYSCFG_EXTICR1 = (SYSCFG_EXTICR1&(~SYSCFG_EXTICR1_0BITS)) | SYSCFG_EXTICR1_0PA;
SYSCFG_EXTICR2 = (SYSCFG_EXTICR2&(~SYSCFG_EXTICR2_6BITS)) | SYSCFG_EXTICR2_6PC;
```
###### Настройка NVIC
Осталось настроить приоритеты прерываний и маскировать их для инициации обработки. Обратите внимание, что регистры *NVIC\_IPR* доступны для побайтового обращения, что значительно упрощает доступ только к необходимым байтам приоритетов отдельных векторов прерываний. Достаточно только сделать сдвиг на величину номера вектора прерывания (см. листинг определений). Еще раз напомним, что EXTI Line 0 имеет 6 номер в таблице векторов, а EXTI line 5\_9 — номер 23. У STM32 значение имеют только старшие 4 бита приоритета:
```
//Set interrupts priority
NVIC_IPR6_REG = 0xF0;
NVIC_IPR23_REG = 0x0;
```
Для демонстрации приоритеты установлены различными.
Теперь можно включить прерывания:
```
//Enable interrupts
NVIC_ISER0_REG |= NVIC_ISER0_6VECT | NVIC_ISER0_23VECT;
```
С этого момента нажатие на кнопку и закоротки PC6 и GND будет приводить к вызову функций обработчиков прерываний EXTI\_Line0\_IntHandler и EXTI\_Line6\_IntHandler соответственно.
###### Обработка прерываний
В функциях обработки прерываний в первую очередь необходимо очистить прерывание, после этого можно зажечь светодиоды. Для демонстрации приоритетов прерываний в один из обработчиков добавлен вечный цикл. Если приоритет прерывания с вечным циклом ниже приоритета второго — то оно не сможет быть вызвано. Иначе, оно сможет прервать первое. Я предлагаю вам самим попробовать различные знчения приоритетов прерываний и наглядно увидеть к чему это приводит (*ВНИМАНИЕ — не забудьте про группы прерываний!*).
```
void EXTI_Line0_IntHandler(void)
{
//Clear interrupt
EXTI_PR = EXTI_LINE0;
//Turn on LED 3
GPIOD_ODR |= GPIO_ODR_13PIN;
}
void EXTI_Line6_IntHandler(void)
{
//Clear interrupt
EXTI_PR = EXTI_LINE6;
//Turn LED4
GPIOD_ODR |= GPIO_ODR_14PIN;
while(1);
}
```
#### Вместо заключения
На всякий случай приведу полный листинг получившейся программы.
**Листинг**
```
//Definitions for SCB_AIRCR register
#define SCB_AIRCR (*(unsigned volatile long*)0xE000ED0C) //acces to SCB_AIRCR
#define SCB_AIRCR_GROUP22 0x05FA0500 //change priority data
//Definitions for RCC_AHB1_ENR register
#define RCC_AHB1_ENR (*(unsigned volatile long *)(0x40023830)) //acces to RCC_AHB1ENR reg
#define RCC_AHB1_ENR_GPIOA 0x1 //GPIOA bitfield
#define RCC_AHB1_ENR_GPIOC 0x4 //GPIOC bitfield
#define RCC_AHB1_ENR_GPIOD 0x8 //GPIOD bitfield
//Definitions for RCC_APB2_ENR register
#define RCC_APB2_ENR (*(unsigned volatile long *)(0x40023844)) //acces to RCC_APB2ENR reg
#define RCC_APB2_ENR_SYSCFG 0x4000 //SYSCFG bitfield
//Definitions for GPIO MODE registers
#define GPIOA_MODER (*(unsigned volatile long*)(0x40020000)) //acces to GPIOA_MODER reg
#define GPIOC_MODER (*(unsigned volatile long*)(0x40020800)) //acces to GPIOC_MODER reg
#define GPIOD_MODER (*(unsigned volatile long*)(0x40020C00)) //acces to GPIOD_MODER reg
//GPIO ODR register definition
#define GPIOD_ODR (*(unsigned volatile long*)(0x40020C14)) //acces to GPIOD_MODER reg
#define GPIO_ODR_13PIN 0x2000
#define GPIO_ODR_14PIN 0x4000
//Bitfields definitions
#define GPIO_MODER_0BITS 0x3 //Pin 0 mode bits
#define GPIO_MODER_0IN 0x0 //Pin 0 input mode
#define GPIO_MODER_6BITS 0x300 //Pin 6 mode bits
#define GPIO_MODER_6IN 0x000 //Pin 6 input mode
#define GPIO_MODER_13BITS 0xC000000 //Pin 13 mode bits
#define GPIO_MODER_13OUT 0x4000000 //Pin 13 output mode
#define GPIO_MODER_14BITS 0x30000000 //Pin 14 mode bits
#define GPIO_MODER_14OUT 0x10000000 //Pin 14 output mode
//GPIOC_PUPDR register definition
#define GPIOC_PUPDR (*(unsigned volatile long*)(0x4002080C)) //acces to GPIOC_PUPDR reg
#define GPIOC_PUPDR_6BITS 0x3000 //PC6 bitfield
#define GPIOC_PUPDR_6PU 0x1000 //PC6 pull-up enable
//SYSCFG_EXTIx registers definitions
#define SYSCFG_EXTICR1 (*(unsigned volatile long*)0x40013808) //SYSCFG_EXTICR1 acces
#define SYSCFG_EXTICR1_0BITS 0xF //EXTI 0 bits
#define SYSCFG_EXTICR1_0PA 0x0 //EXTI 0 - port A
#define SYSCFG_EXTICR2 (*(unsigned volatile long*)0x4001380C) //SYSCFG_EXTICR2 acces
#define SYSCFG_EXTICR2_6BITS 0xF00 //EXTI 6 bits
#define SYSCFG_EXTICR2_6PC 0x200 //EXTI 6 - port C
//EXTI definitions
#define EXTI_IMR (*(unsigned volatile long*)0x40013C00) //EXTI_IMR reg acces
#define EXTI_LINE0 0x1 //LINE 0 definition
#define EXTI_LINE6 0x40 //LINE 6 definition
#define EXTI_RTSR (*(unsigned volatile long*)0x40013C08) //EXTI_RTSR reg acces
#define EXTI_FTSR (*(unsigned volatile long*)0x40013C0C) //EXTI_FTSR reg acces
#define EXTI_PR (*(unsigned volatile long*)0x40013C14) //EXTI_PR reg acces
//NVIC registers and bits definitions
#define NVIC_ISER0_REG (*(unsigned volatile long*)0xE000E100) //NVIC_ISER0 reg acces
#define NVIC_ISER0_6VECT 0x40 //vect 6 definition
#define NVIC_ISER0_23VECT 0x800000 //vect 30 definition
#define NVIC_IPR0_ADD (0xE000E400)
#define NVIC_IPR23_REG (*(unsigned volatile char*)(NVIC_IPR0_ADD + 23))
#define NVIC_IPR6_REG (*(unsigned volatile char*)(NVIC_IPR0_ADD + 6))
void EXTI_Line0_IntHandler(void);
void EXTI_Line6_IntHandler(void);
void main()
{
//NVIC
SCB_AIRCR = SCB_AIRCR_GROUP22;
//Enable SYSCFG , GPIO port A,C and D clocking
RCC_AHB1_ENR |= RCC_AHB1_ENR_GPIOA|RCC_AHB1_ENR_GPIOC|RCC_AHB1_ENR_GPIOD;
RCC_APB2_ENR |= RCC_APB2_ENR_SYSCFG;
//LED3 and LED5 initialization
GPIOD_MODER = (GPIOD_MODER & (~GPIO_MODER_13BITS)) | GPIO_MODER_13OUT;
GPIOD_MODER = (GPIOD_MODER & (~GPIO_MODER_14BITS)) | GPIO_MODER_14OUT;
//PA0 and PC6 pins initialization
GPIOA_MODER = (GPIOA_MODER & (~GPIO_MODER_0BITS)) | GPIO_MODER_0IN;
GPIOC_MODER = (GPIOC_MODER & (~GPIO_MODER_6BITS)) | GPIO_MODER_6IN;
//Enable PC7 pull-up
GPIOC_PUPDR = (GPIOC_PUPDR & (~GPIOC_PUPDR_6BITS)) | GPIOC_PUPDR_6PU;
//Set up EXTI
EXTI_RTSR |= EXTI_LINE0;
EXTI_FTSR |= EXTI_LINE6;
EXTI_IMR = EXTI_LINE0|EXTI_LINE6;
//EXTI to port connection
SYSCFG_EXTICR1 = (SYSCFG_EXTICR1&(~SYSCFG_EXTICR1_0BITS)) | SYSCFG_EXTICR1_0PA;
SYSCFG_EXTICR2 = (SYSCFG_EXTICR2&(~SYSCFG_EXTICR2_6BITS)) | SYSCFG_EXTICR2_6PC;
//Set interrupts priority
NVIC_IPR6_REG = 0xF0;
NVIC_IPR23_REG = 0x00;
//Enable interrupts
NVIC_ISER0_REG |= NVIC_ISER0_6VECT | NVIC_ISER0_23VECT;
while(1)
{
}
}
void EXTI_Line0_IntHandler(void)
{
//Clear interrupt
EXTI_PR = EXTI_LINE0;
//Turn on LED 3
GPIOD_ODR |= GPIO_ODR_13PIN;
}
void EXTI_Line6_IntHandler(void)
{
//Clear interrupt
EXTI_PR = EXTI_LINE6;
//Turn LED4
GPIOD_ODR |= GPIO_ODR_14PIN;
while(1);
}
```
Для проверки влияния приоритетов прерываний и приоритетов групп прерываний попробуйте менять приоритеты и наблюдать, что будет происходить (два бита — приоритет внутри группы, 2 бита — приоритет группы). | https://habr.com/ru/post/218825/ | null | ru | null |
# Анимация в Spine, советы и рекомендации, псевдо 3D эффект
Хочу поделиться своим опытом работы со Spine — программой для создания скелетной анимации, специально заточенной под игры.
После просмотра официального гайда возникает много вопросов, поговорим про то, какие подводные камни ожидают нас при работе с этой программой на каждом этапе рабочего процесса (на примере Spine — Unity), как можно оптимизировать свою работу, а так же рассмотрим некоторые популярные фишки типа 3D эффекта. В статье будет много тяжелых гифок.
**UPD: После недавнего релиза Spine версии 3.6 фишки с Json описанные в конце статьи актуальны разве что для общего развития, т.к. разработчики добавили данный функционал «из коробки».**
**UPD2:
Layers to PNG теперь называется Photoshop to Spine, сохраняет картинки сразу в нормальном размере, а так же после появления в версии 3.8 функции trace для автоматической генерации меша по контуру текстуры и встроенной полигональной паковки атласов так заморачиваться с подготовкой картинок теперь не обязательно.
Теперь в Spine уже встроен предпросмотр готовой анимации, делается это в окне preview, там можно посмотреть как отрабатывают бленды и как одна анимация накладывается на другую. Отдельно Skeleton viewer теперь искать не обязательно. Проблем со смешиванием чаще всего удается избежать просто внимательно следя за тем какие ключи и где вы ставите.**
*Сразу оговорюсь, для создания программной анимации в играх есть и другие решения, Dragon Bones, Spriter, Creature, Marionette studio, плагин Puppet 2D и наверняка найдутся другие, просто я как аниматор работаю в Spine.*
**Наглядная демонстрация принципа скелетной анимации**
### Схема работы
Когда у нас на руках есть информация и понимание какие персонажи/анимации должны быть созданы для игры, отрисован необходимый материал — можно приступать.
Общая схема работы такова:
Первым делом необходимо подготовить рабочий материал из графических редакторов. Затем ассеты (assets, текстуры) импортируются в Spine и анимируются. На выходе мы получаем Json — файл в котором записаны все ключевые кадры трансформации костей, слотов и проч. Данный файл импортируется в движок, создается специальная skeleton data, которая добавляется на сцене в Spine game object, где наша анимация визуализируется по средствам mesh renderer, запуском можно управлять с помощью кода или же стандартным unity animator.
Непосредственно рабочий процесс в спайне выглядит следующим образом:
1. Импорт текстур
2. Риггинг (настройка скелета)
3. Скиннинг (настройка меша и привязка его к костям)
4. Анимация
5. Экспорт Json и проверка
В качестве примера попробуем сделать анимацию вот такого персонажа:
### Импорт текстур
На этапе подготовки текстур нам важно понимать сколько необходимо проекций персонажа, какая часть работы будет сделана покадрово, какая программно, как грамотно разрезать персонажа и подготовить ассеты.
Типичные ошибки:
**не рисовать текстуры движущихся частей где их не видно:**
**неправильно поставленные тени**
А также недостаточное число проекций если персонаж меняет ракурс.
Часто у персонажей есть парные элементы с идентичными изображениями — руки, ноги, глаза, и проч. В таком случае целесообразно сохранить только одну текстуру, и использовать ее два, или более, раз.
В данном случае нам будет достаточно одной проекции, и ассеты художник отрисовал хорошо. Можно приступать к импорту в спайн.
Процесс импорта текстур можно существенно ускорить используя **скрипт layers to PNG**, который сохраняет каждый слой из фотошопа в отдельное png изображение, при этом записывает Json файл в котором содержится информация о расположении текстур, импортируя его в спайн мы получаем готового собранного персонажа.
**Как пользоваться скриптом layers to PNG**1) Экспортируем из фотошопа с помощью скрипта Json и PNG картинки (можно указать скеил фактор)
2) Импортируем json в спайн file-import data
3) Указываем путь к текстурам
[подробнее](http://ru.esotericsoftware.com/spine-images#Photoshop)
Однако у такого способа есть **ряд недостатков** — скрипт сохраняет изображения без сжатия, что непрактично. Просто пересохранив слои через file-generate-image assets мы уменьшим вес изображения приблизительно в 10 раз.
Далее, необходимо не забывать разворачивать ваши в спрайты в горизонтальное или вертикальное положение, и стирать все лишнее, т.к. скрипт сохранит изображения прямо в том положении в котором они находятся в фотошопе.
Если для проекта необходима **покадровая анимация** (напр. огонь, спецэффекты, и проч.) — материалы необходимо отрисовать заранее. Далее с помощью adobe after effects и скрипта ae\_to\_spine мы можем в пару кликов перенести последовательность кадров в Spine.
**Как пользоваться скриптом AE to Spine**Аналогично скрипту layers to png. [Подробнее](http://esotericsoftware.com/forum/viewtopic.php?f=11%5E_%5Eamp%5E_%5Et=2983)
Рекомендую заранее продумать **концепцию наименования**, материалы часто приходят в формате «слой 1 (копия) 5», это не слишком практично, для каждой текстуры в проекте необходимо сделать уникальное название, что бы не вызвать проблемы при запаковке атласов. Вполне пригоден вариант формата **CharacterVyasya\_Skin\_a\_Hand\_R\_1**.
Тут во многом нам может помочь **инструмент find and replace** который позволяет быстро переименовывать, указывать путь для большого количества объектов.
**инструмент find and replace**
### Риггинг
Настраивая скелет для персонажа нужно уже думать о том, что, скорее всего, в процессе работы над игрой анимацию нужно будет корректировать, подправлять, поэтому желательно сделать его максимально гибким, что бы процесс правок был максимально простым и быстрым.
Тут может помочь введение дополнительных костей-контролов для разбиения движения по осям X и Y (т.к. в спайне остутствует функция separate dimentions).
**Пример рига с дополнительными контролами**Сложное движение ящера суммируется из нескольких составляющих: вертикального, горизонтального и для возможности быстрой корректировки добавлен глобальный контрол.
Тут же маленький типс, если вдруг чувствуется нагромождение из за излишнего количества костей — попробуйте покрутить настройку bone scale:
Смотрите примеры готовых ригов из образцов поставляемых вместе со спайном, или в сети.
**Небольшая подборка достаточно известных авторов, у которых есть что подсмотреть:**[Søren Nielsen](https://www.youtube.com/channel/UC_ijsuTUdxMjjM1P30f8Gaw)
[Hwadock Jang](https://www.youtube.com/user/hwadock1/videos)
[Charles Duchesne](https://www.youtube.com/user/Lhescar/videos)
[Dao Le Trong](https://www.youtube.com/channel/UC56PA4QoDwdiX0qP5X-vB2A/videos)
[Spine progress](https://youtu.be/OU-MkV4N67Q)
[Walk test](https://www.youtube.com/embed/JHoigf53-O0)
Так же полезные материалы можно искать на [behanсe](https://www.behance.net/search?search=spine+animation+), [форуме](http://ru.esotericsoftware.com/forum/viewforum.php?f=5%5E_%5Eamp%5E_%5Esid=9d77051b99070534b227a07930749766), [соответствующих сообществах](https://vk.com/spine_tutorial) в социальных сетях.
### Скиннинг
Меш — Один из ключевых инструментов в спайне, накладывая на его текстуру мы получаем возможность ее деформировать, искажать, создавать иллюзию 3D.
При создании меша помните: чем меньше вертексов — тем проще контролировать анимацию.
**Демонстрация**
Т.к. деформация меша потребляет ресурсы CPU, при создании сетки стоит руководствоваться принципом необходимого минимума, наглядно это можно рассмотреть на примере рига кончика хвоста динозавра:
**1 вариант - недостаточно точек, видны изломы на картинке:**
**2, 3 вариант - хорошо:**
**4 вариант - излишнее количество точек, которые не выполняют никакой функции, никуда не годится:**
Не забывайте про возможность дублирования целой иерархии меша вместе с костями и весами. Это поможет значительно сэкономить время при риге повторяющихся объектов.
**Лайфхак как продублировать целую иерархию**
### Производительность
В конечном итоге у нас возникает вопрос — а сколько вертексов можно использовать?
Разработчики спайна конкретно не отвечают на этот вопрос, и отсылают к вкладке [**Spine Metrics**](http://ru.esotericsoftware.com/spine-metrics), где мы можем отследить суммарное количество элементов в сцене, но при этом говорят о необходимости проведения кастомных тестов производительности.
Важно помнить что трансформация меша, таймлайны, констрейны грузят CPU, а статичная геометрия — GPU. В общем, я бы советовал в случае работы над ключевыми персонажами не сильно заморачиваться по поводу точек, плюс минус десяток не сыграет никакой роли, однако в случае объекта из окружения, который будет повторяться сотню раз, каждый сэкономленный вертекс пойдет на пользу.
И так, когда наш персонаж настроен можно переходить к анимации:
### Анимация
Сама по себе анимация это очень большая тема и явно не для обсуждения в рамках одной статьи.
Тут я ограничусь банальными советами в ключе:
* Не забывайте про художественную часть, старайтесь сделать анимацию максимально выразительной
* Следуйте диснеевским принципам анимации
* Импортируйте материал в локацию, часто только после этого становятся видны косяки.
### 3D-эффект
Это то за что так любят спайн — возможность деформировать изображение с помощью меша тем самым создавая трехмерный эффект.
**Демонстрация**
Для себя я отметил несколько способов создания псевдо 3Д:
1. Анимация непосредственно вертексов в меше
2. Много костей в ключевых точках меша, анимируются кости
3. Кости ставятся выборочно, а далее тщательно настраиваются веса в меше
4. Комбинированный способ, все сведено под глобальные контролы
Наглядно принцип построения трехмерного эффекта можно рассмотреть на геометрических примитивах:
**Куб**Проставляются кости в ключевых точках меша:
Анимируя кости создаем трехмерный эффект:
**Немного сложнее пример со сферой:**
Можно сделать анимацией вертексов в меше, но как мы видим по сравнению с кубом точек значительно больше:
Аналогично кубу, кости в ключевых точках меша. По затраченному времени этот способ не лучше предыдущего:
Было бы гораздо более гибко свести риг под один глобальный контрол с помощью констрейнов, двигая одним управлять всеми костями:
То же самое, можно сделать без лишней массы костей,
Для этого каждому вертексу тщательно подбирается значение в весах. Такой способ можно считать оптимальным для округлых поверхностей.
Из примеров видно что анимация непосредственно точек в меше это один из самых негибких вариантов, который в случае необходимости будет трудозатратно переделывать. К этому стоит добавить что в некоторых других рантаймах, помимо юнити, эта фича не поддерживается. Поэтому рекомендую по возможности не трогать меш и управлять им с помощью костей.
По аналогии можно сделать деформацию любой геометрической формы, тем самым добавив вашей анимации выразительности.
И так, мы просидели несколько часов над ключевыми кадрами, мешами, и сделали анимацию персонажа:
**Что получилось**
### Тестирование
Далее можно отправлять нашу анимацию в движок. Однако часто возникают ситуации когда внешний вид анимации в спайне и в рантайме существенно отличается, а т.к. каждое взаимодействие аниматор-программист занимает определенное время, лучше заранее провести тест анимации в рантайме, в ходе которого выявятся основные косяки, и только потом отдать работу будучи уверенным что все хорошо.
*Если ваш аниматор не дружит с движком, можно использовать [Skeleton Viewer](http://ru.esotericsoftware.com/spine-skeleton-viewer)*
Какие проблемы возникают наиболее часто:
1. Вы забыли положить некоторые ассеты, или наоборот в экспорт попало лишнего (рабочие файлы, референсы, и проч) — тут все очевидно — перед тем как отдать материал тщательно проверяйте что должно быть в проекте а что нет
2. несовпадение на стыках анимации — можно попробовать выставить в юнити длительность перехода, тем самым сгладив стык. Или поправить ключи если такое возможно
3. текстуры отображаются некорректно
4. после отработки анимация выглядит не так как раньше
#### Некорректное отображение текстур
Чаще всего такое происходит из за неправильной композиции текстуры — меш должен четко соответствовать размеру спрайта.
**Иначе будет вот так.**
#### После отработки анимация выглядит не так как раньше
**Пример**Изначально овираптор сидит на гнезде с яйцами, потом встает и отходит в сторону. Казалось бы, когда анимация начнется с начала, он должен таким же образом сидеть на гнезде, однако т.к. мы сдвинули его в предыдущей анимации он будет смещен до тех пор пока не будет поставлен ключом в соответствующую позицию.
Происходит это потому что в рантайме анимация просчитывается не из дефолтного положения, а как бы из текущего. Т.е. если мы один раз включим текстуру и не выключим — она останется в таком положении во всех анимациях. Тоже самое и с другими ключами. Это скорее не баг, а фича, но к сожалению аниматор не видит реальной картины пока не импортирует свой материал в рантайм. Решить данный вопрос можно несколькими способами:
1) Проставить ключи на всех свойствах всех объектов в начале и в конце каждой анимации. На первый взгляд слегка муторно, но таким образом вы полностью обезопасите себя от нежданных сюрпризов. Использование фильтров и горячих клавиш ускорит процесс.
Красным выделена иконка фильтра объектов по костям и кнопка для быстрого разворачивания иерархии:
Горячие клавиши по умолчанию:
> Key Active: L
>
> Key Selected: ctrl + L
>
> Key Dopesheet: ctrl + shift + L
>
> Key Translation, Key Rotation, Key Scale, Key Shear, Key Color — нужно настраивать самому
2) Использовать [скрипт setToSetupPose](https://gist.github.com/pharan/a910e129337b71f57a92), который как бы и заставляет проигрываться анимацию из дефолтного состояния. Но такой метод имеет существенный недостаток — Setup Pose выставляется мгновенно, а рендер меняет картинку на соответствующую только со следующего кадра. Таким образом мы имеем проскакивание лишнего кадра между анимациями, выглядит это неприятно. Соответствующее issue уже стоит на доске у разработчиков.
**Setup Pose баг**
### JSON
Мы можем экспортировать из спайна Json, провести с ним какие-либо манипуляции, и импортировать обратно, получив определенный результат. Это очень мощный инструмент т.к. мы получаем доступ ко всем компонентам проекта, в свою очередь нам это может очень помочь в определенных ситуациях:
1. При необходимости смержить несколько проектов
2. При необходимости скопировать иерархию костей вместе с анимацией
3. При необходимости откатиться на более старую версию
4. Любое другое применение, которое придет вам на ум
#### Мержинг проектов
Часто возникает необходимость держать анимации в одной сцене, например как тут:
**Лягушка ест жука**Сам жук в игре появляется в множестве других сцен и был скопирован из одной из них. Однако теперь в проекте два скелета, и соответственно на выходе будет 2 json и 2 объекта на сцене, что добавит необходимость делать определенную логику синхронного запуска этих анимаций для их совмещения во времени, а так же нужно будет точно совместить объекты по положению в локации. Можно упростить себе жизнь отдав материал в одной сцене. Для этого два json нужно смержить.
Для этого есть как минимум два способа: руками и скриптом.
##### Руками
Копируем куски кода из одного json в другой, в соответствующие категории: слоты к слотам, кости к костям, анимации к анимациям, и т.д. Что бы не возникло конфликтов, важно соблюсти корректность наименования объектов, что бы названия из одного json не совпадали с названиями из другого. Проще всего этого добиться заранее в спайне присвоив всем объектам в именах свой уникальный индекс типа \_skel1\_ и \_skel2\_. Этот способ слегка затратный по времени, но меня еще не подводил.
**Примеры**Предельно простой пример для демонстрации принципа, два скелета с костями в одном проекте:
**Скелет 1**
```
{
"skeleton": { "hash": "ZMTMZiuTD2M2gnBhJR0JLPQWOws", "spine": "3.4.02", "width": 0, "height": 0, "images": "" },
"bones": [
{ "name": "root_skel1_" },
{ "name": "bone1_skel1_", "parent": "root_skel1_", "length": 26.95, "rotation": 360, "x": 11.09, "y": -9.65, "color": "00ff00ff" },
{ "name": "bone2_skel1_", "parent": "bone1_skel1_", "length": 26.95, "x": 26.27, "color": "00ff00ff" },
{ "name": "bone3_skel1_", "parent": "bone2_skel1_", "length": 26.95, "x": 26.57, "color": "00ff00ff" },
{ "name": "bone4_skel1_", "parent": "bone3_skel1_", "length": 26.95, "x": 25.97, "color": "00ff00ff" }
],
"animations": {
"animation": {}
}
}
```
**Скелет 2**
```
{
"skeleton": { "hash": "osF6oBu7PH6sMNfjN7pm2EwQ8fY", "spine": "3.4.02", "width": 0, "height": 0, "images": "" },
"bones": [
{ "name": "root_skel2_" },
{ "name": "bone1_skel2_", "parent": "root_skel2_", "x": 19.25, "y": 26.63, "color": "fff100ff" },
{ "name": "bone2_skel2_", "parent": "bone1_skel2_", "x": 27.14, "color": "fff100ff" },
{ "name": "bone3_skel2_", "parent": "bone2_skel2_", "x": 25.57, "color": "fff100ff" },
{ "name": "bone4_skel2_", "parent": "bone3_skel2_", "x": 27.14, "color": "fff100ff" }
],
"animations": {
"animation": {}
}
}
```
**Соединенные скелеты**
```
{
"skeleton": { "hash": "ZMTMZiuTD2M2gnBhJR0JLPQWOws", "spine": "3.4.02", "width": 0, "height": 0, "images": "" },
"bones": [
{ "name": "root" },
{ "name": "root_skel1_", "parent": "root" },
{ "name": "bone1_skel1_", "parent": "root_skel1_", "length": 26.95, "rotation": 360, "x": 11.09, "y": -9.65, "color": "00ff00ff" },
{ "name": "bone2_skel1_", "parent": "bone1_skel1_", "length": 26.95, "x": 26.27, "color": "00ff00ff" },
{ "name": "bone3_skel1_", "parent": "bone2_skel1_", "length": 26.95, "x": 26.57, "color": "00ff00ff" },
{ "name": "bone4_skel1_", "parent": "bone3_skel1_", "length": 26.95, "x": 25.97, "color": "00ff00ff" },
{ "name": "root_skel2_", "parent": "root" },
{ "name": "bone1_skel2_", "parent": "root_skel2_", "x": 19.25, "y": 26.63, "color": "fff100ff" },
{ "name": "bone2_skel2_", "parent": "bone1_skel2_", "x": 27.14, "color": "fff100ff" },
{ "name": "bone3_skel2_", "parent": "bone2_skel2_", "x": 25.57, "color": "fff100ff" },
{ "name": "bone4_skel2_", "parent": "bone3_skel2_", "x": 27.14, "color": "fff100ff" }
],
"animations": {
"animation": {}
}
}
```
В результате имеем все в одном проекте:
Проблемы могут возникнуть в проектах с скинами, по возможности старайтесь не менять иерархию костей.
Более сложный пример с лягушкой:
*(Осторожно, длинные файлы)*
[Жук](https://gist.github.com/Borovikmotion/eb1dc1b772998e441fc5e0e598873946#file-beatle)
[Лягушка](https://gist.github.com/Borovikmotion/eb1dc1b772998e441fc5e0e598873946#file-frog)
[Жук+Лягушка](https://gist.github.com/Borovikmotion/eb1dc1b772998e441fc5e0e598873946#file-merged-beatle-frog)
##### Skeleton Merger Tool
Добрые люди написали специальную тулзу для мержинга. Ознакомиться и скачать можно [по ссылке](http://esotericsoftware.com/forum/Skeleton-Merger-Tool-5070?sid=c7593ff312f890f059ee5fe8688240c2) . Использовать ее достаточно удобно, включен автоматический ренейминг объектов, однако я не раз сталкивался с ошибками.
#### Дублирование объектов вместе с анимацией
В спайне отсутствует вложенность композиций (аналог прекомпоз в After Effects или символ во Flash), однако, как показывалось выше, есть возможность продублировать объекты, с сохранением всех зависимостей, но ключи анимации в таком случае не копируются. Не сложно догадаться что, для того что бы не делать анимацию заново, можно переназначить ее на дубликат костей, для этого надо всего лишь перебить в Json имена. Опять же, это проще сделать если у каждой кости будет свой уникальный индекс.
**Пример**Есть муравей с анимацией. Задача сделать в спайне целую цепочку бегающих друг за другом муравьев. При дублировании муравья анимация не копируется. Обратите внимание, у первого муравья в названии стоит индекс \_skel\_1\_, у второго \_skel\_2\_.
Экспортируем Json и открываем его текстовым редактором. Код анимации walk\_1 копируем, находим там все участки \_skel\_1\_:
```
"animations": {
"walk_1": {
"bones": {
"US_2_skel_1_": {
"rotate": [
{
"time": 0,
"angle": -42.21,
"curve": [ 0.25, 0, 0.75, 1 ]
},
{
"time": 0.4,
"angle": -0.92,
"curve": [ 0.25, 0, 0.75, 1 ]
},
{ "time": 0.8, "angle": -42.21 }
]
},
....
```
заменяем их на \_skel\_2\_
```
....
"US_2_skel_2_": {
"rotate": [
{
"time": 0,
"angle": -42.21,
"curve": [ 0.25, 0, 0.75, 1 ]
},
{
"time": 0.4,
"angle": -0.92,
"curve": [ 0.25, 0, 0.75, 1 ]
},
{ "time": 0.8, "angle": -42.21 }
},
...
```
Вставляем обратно. Таким образом мы переназначили анимацию на другие кости. Сохраняем json, и импортируем его в спайн путем file — import data. Теперь у нас два бегающих муравья.
#### Откатиться до старой версии
Проекты сохраненные в более новой версии будут не совместимы со старыми. Иногда это может стать проблемой, и для ее решения есть несколько способов:
##### Руками перебить версию в json
```
"skeleton": { "hash": "", "spine": "3.4.02", "width": 0, "height": 0, "images": "" },
```
Поможет если между версиями небольшой промежуток, и нет принципиальных различий в алгоритмах работы анимации.
##### JsonRollback tool
Ознакомиться с принципом работы и скачать можно [по ссылке](http://ru.esotericsoftware.com/forum/Spine-editor-and-runtime-version-management-6534).
### Резюме
* Четко обозначайте какие задачи в чем вы делаете
* Используйте скрипты для ускорения работы
* Делайте гибкий риг и не перебарщивайте с мешем
* Перед отправкой тестируйте материал в рантайме
* Не стесняйтесь залезть в json если это вам сэкономит время
Спасибо за внимание, наверняка если вы дочитали статью до этого момента у вас возникли вопросы или замечания, с удовольствием прочитаю все в комментариях.
**P.S.** Статья писалась аниматором по большей части для аниматоров, если вы программист и у вас «рукалицо», можете высказаться в комментариях. | https://habr.com/ru/post/315950/ | null | ru | null |
# Сделано на Python: экспорт статистики ВКонтакте с помощью Prometeus и Grafana
Выпускник курса [Python для инженеров](https://slurm.club/3k8UJc2) **Денис Алексеев** рассказал о своем проекте, который защитил на итоговой презентации.
Мой проект помогает упростить экспорт статистики из сообществ в социальных сетях и поставить этот процесс на рельсы автоматизации. С ним поначалу были сложности. Надо было взять реальную задачу и сделать ее на Python, но моя основная работа связана с написанием микросервисов на Go, и задачи на Пайтоне носят скорее вспомогательный характер. Конечно, на курсе была возможность поговорить с наставниками и получить задачу от них, но хотелось чего-то своего.
Дальше события развивались стремительно.
В марте 22 года в связи с санкциями стало наблюдаться возрождение исконно русской социальной сети ВКонтакте. Давно покинутые паблики и сообщества оживали и наполнялись новым контентом, новыми пользователями. У SMM-щиков наблюдался богатый урожай на новых клиентов и головная боль с обработкой запросов.
У меня есть несколько друзей, которые занимаются продвижением сообществ ВКонтакте. Весной этого года у них появилось множество заказов и, как следствие, необходимость в удобном отображении некоторых значений статистики сообществ — если не в масштабе реального времени, то хотя бы автоматически. На ум пришли панельки Grafana, в которых можно не только отслеживать нужные параметры, но и компоновать их различными способами. Допустим, вывести на одной панели посещаемость всех сообществ определенной тематики.
В это время на курсе как раз проходили создание Prometheus Exporter.
В общем, я решил попробовать экспортировать статистику сообщества ВКонтакте, в Prometeus и вывести ее в Grafana. Сразу говорю, что полностью проект завершить не удалось в связи с хроническим отсутствием времени, но показать кое-что интересное, я надеюсь, у меня получится.
Логика работы простая, как три копейки.
1. Описываем набор желаемых метрик для экспорта в Prometheus и web-сервис, который сможет авторизоваться ВКонтакте и получить оттуда статистику.
2. Авторизовываемся в соцсети и получаем access\_token (как это делается, можно посмотреть в документации).
3. Делаем метод, который будет обращаться к API, получать статистику и отправлять ее в Prometheus.
4. Создаем тред, который будет вызывать метод сбора статистики и ждать определенный промежуток времени (промежуток задается в конфигурации, о ней не забываем).
5. Не забываем также о graceful shutdown, обработке Sigterm и прочих полезных вещах.
Давайте остановимся на некоторых из этих шагов подробнее. Отправка набора метрик делается вот таким образом:
```
class VKMetrics:
"""
Экспортер метрик группы вконтакте,
"""
metrics = {}
def collect(self):
group_activity_views = GaugeMetricFamily(
'views_value',
'Group views value',
labels=['group_name']
)
group_activity_reposts = GaugeMetricFamily(
'reposts_value',
'Group reposts value',
labels=['group_name']
)
group_activity_likes = GaugeMetricFamily(
'likes_value',
'Group likes value',
labels=['group_name']
)
group_activity_comments = GaugeMetricFamily(
'comments_value',
'Group comments value',
labels=['group_name']
)
group_activity_subscribed = GaugeMetricFamily(
'subscribed_value',
'Group subscribed value',
labels=['group_name']
)
group_activity_unsubscribed = GaugeMetricFamily(
'unsubscribed_value',
'Group unsubscribed value',
labels=['group_name']
)
for group, metrics in self.metrics.items():
group_activity_views.add_metric([group], metrics['views'])
yield group_activity_views
group_activity_reposts.add_metric([group], metrics['reposts'])
yield group_activity_reposts
group_activity_likes.add_metric([group], metrics['likes'])
yield group_activity_likes
group_activity_comments.add_metric([group], metrics['comments'])
yield group_activity_comments
group_activity_subscribed.add_metric([group], metrics['subscribed'])
yield group_activity_subscribed
group_activity_unsubscribed.add_metric([group], metrics['unsubscribed'])
yield group_activity_unsubscribed
app = Flask(__name__)
REGISTRY.register(VKMetrics())
```
Как несложно догадаться, для авторизации используются Flask и достаточно простые методы, описывать которые здесь не вижу смысла: все это легко гуглится.
Давайте также остановимся на методе из пункта 3 выше, который получает статистику группы и отправляет данные в exporter:
```
@app.route('/stat')
def stat():
"""
```
Получение статистики сообщества и отправка ее в Prometheus:
```
# https://dev.vk.com/method/stats.get
if config['token'] is None:
print("no token")
return ""
url = f"{vk_method_url}/stats.get"
now = datetime.now()
from_time = now.replace(second=0, microsecond=0, minute=0, hour=now.hour) - timedelta(
hours=config['interval_hours'])
to_time = now.replace(second=0, microsecond=0, minute=0, hour=now.hour) + timedelta(
hours=1
)
params = {
"group_id": config['group_id'],
"timestamp_from": str(from_time.timestamp()),
"timestamp_to": str(to_time.timestamp()),
"intervals_count": config['interval_ranges'],
"extended": "true",
"access_token": config['token'],
"v": 5.131
}
r = requests.get(url, params=params)
if r.status_code == 200:
js = r.json()
response = js["response"][0]
visitors = response.setdefault('visitors', {})
activity = response.setdefault('activity', {})
metrics = VKMetrics.metrics.setdefault(config["screen_name"], {})
metrics["views"] = visitors.get("views", 0)
metrics["likes"] = activity.get("likes", 0)
metrics["reposts"] = activity.get("copies", 0)
metrics["comments"] = activity.get("comments", 0)
metrics["subscribed"] = activity.get("subscribed", 0)
metrics["unsubscribed"] = activity.get("unsubscribed", 0)
return js, 200
else:
return f"Error **{r.status\_code}**
{r.text}", 500
```
Метод для Prometheus, откуда он будет забирать статистику:
```
@app.route("/metrics")
def metrics():
return Response(generate_latest(), mimetype=CONTENT_TYPE_LATEST)
```
Вот скриншоты из Grafana того, что получилось в результате:
Ссылка на репозиторий проекта: <https://github.com/widler/vk_exporter>. Критика, багрепорты, feature requests приветствуются.
Дальше можно было бы рассказать историю успеха о том, как мы с друзьями основали собственное SMM-агентство. Но нет. Часть знакомых уехала из страны, некоторые сменили род деятельности, а мне хронически не хватает времени, чтобы доделать проект полностью.
В заключение немного расскажу о себе и о курсе Python для инженеров, который проходил.Я более 10 лет занимаюсь программированием. Профессиональную карьеру начал с PHP и долгое время работал только на нем. Несмотря на хлебную работу и востребованность, постоянно смотрел специализации: узнавал, что нового есть в мире языков программирования. В какой-то момент стало интересно, что за язык Go. И началось всякое, в результате чего я сменил очередную уютную фирму, создающую сайты для зарубежных заказчиков, на одну из компаний, работающих на отечественном рынке. И ни разу об этом не пожалел!
В какой-то момент возникла необходимость понимать скрипты, написанные на Пайтоне. Дело в том, что в нашей компании практически все E2E тесты написаны на этом языке, и при взаимодействии с ребятами из команды тестирования приходится понимать: что тут написано и что хотел сказать автор. Кроме того, по работе часто возникает задача сделать разовую отправку большого числа сообщений в очередь, вызвать метод API с параметрами из csv-файла и т. д. Задачи из разряда «*на Go делать смысла особого нет, можно быстренько сделать на Python, запустить и не возвращаться больше к этой задаче*».
Начал потихоньку погружаться в тему, но не хватало системности подхода, да и всегда находилось много других задач по работе. На учебу просто не оставалось сил или времени. В какой-то момент решил, что нужно найти курсы, где мне расскажут все с самых основ, посмотрят на код, накидают замечаний. Начал искать курсы, на Слёрм сначала даже не обратил внимания. Но после вечерней школы Kubernetes для разработчиков понял, что зря.
Курс помог мне систематизировать знания по Python и начать писать на нем программы, а не бегать по Stackoverflow в поисках того, что можно доработать напильником. По ходу курса особо проблем не возникало. Смотришь теорию, делаешь практическое задание. Если есть вопросы — спрашиваешь в чате курса в телеге. Просто берешь и делаешь.
**От редакции*: новый поток курса стартует 16 января и продлится 3 месяца. Посмотреть программу и записаться можно здесь:*** [***https://slurm.club/3k8UJc2***](https://slurm.club/3k8UJc2) | https://habr.com/ru/post/709980/ | null | ru | null |
# Погружение в разработку на Ethereum. Часть 1
Технология блокчейна завладела умами. Покупаются фермы, ICO собирают миллионы долларов. Наша компания тоже захотела приобщиться. Решили начать с малого. В серии статей будет описан наш путь от новичков в сфере блокчейна до общепризнанных гуру. На момент написания этих слов мы все еще на этапе новичков, предлагаем следить за нашим развитием и развиваться с нами.
Чем хорош блокчейн?
-------------------
Судя из названия блокчейн — это цепочка блоков. Так и есть. Но что дает эта цепочка? По сути это технология децентрализованного хранения данных с особой структурой, позволяющей быть уверенным, что манипуляции с данными происходили в рамках четко заданных правил. Обеспечивается эта уверенность тем, что массив данных хранится сразу у всех, кто подключился к сети блокчейна — это значит, что недостаточно будет просто подменить весь массив в одном месте. А еще каждая следующая порция данных, так называемый блок, содержит в себе хэш предыдущего блока, это дает два плюса:
* в готовую цепочку невозможно подставить промежуточный блок,
* сам блок нельзя изменить, не поменяв при этом его хэш, следовательно это невозможно сделать без нарушения целостности цепочки.
*Дерево Меркла — дерево хешей, в данном случае используется для независимого подтверждения валидности отдельных транзакций. Транзакции — это и есть данные в блокчейне*
Работу по добавлению блоков обеспечивают сами участники сети. Кому будет предоставлено право добавления следующего блока определяется специальным механизмом. Самые распространенные из таких механизмов — это Proof-of-Work и Proof-of-Stake. В первом блоки добавляют майнеры — участники сети, решающие вычислительно сложные задачи, конкурируя друг с другом за право создания блока на основе своего решения, а в награду за успешное создание блока получающие некоторое количество валюты этой сети. В Proof-of-Stake блоки добавляют валидаторы — участники сети, конкурирующие не за счет производительности, а на основе количества внутренней валюты этой сети на их аккаунте. Получают они при этом меньше, но и работы от них требуется меньше. В обоих случаях логика в том, что злоумышленнику для добавления поддельного блока придется потратить больше, чем удастся заработать. В первом случае — на оборудование для майнинга, соизмеримое по мощности с остальными майнерами вместе взятыми. Во втором случае — на покупку 50% валюты сети.
Ethereum
--------
Существуют разные реализации блокчейнов, среди которых самыми популярными сейчас являются Bitcoin и Ethereum. В то время как Bitcoin — это реализация криптовалюты на базе blockchain, целью Ethereum является создание платформы, позволяющей решать самые разные задачи с помощью умных контрактов. Поэтому логично первое знакомство начать именно с Ethereum
Smart Contracts
---------------
Манипулирование данными в блокчейне обеспечивается так называемыми умными контрактами (smart contracts). Они описывают какие данные хранить на блокчейне и набор функций для операций над ними. Выполнение функций и получение доступа к данным осуществляется через предоставляемый каждым контрактом интерфейс. Этот интерфейс генерируется из исходного кода отдельно от компиляции и позволяет выполнять бинарный код. Данные для участников сети открыты, и чтение их ничего не стоит, ведь как уже было сказано, данные хранятся у всех участников сети. Изменение данных происходит посредством транзакций. Каждую транзакцию можно представить структурой следующего вида:
1. Получатель транзакции
2. Цифровая подпись отправителя
3. Количество отправляемой валюты
4. Произвольные данные (необязательно)
5. Лимит газа на транзакцию
6. Цена за единицу газа
Что такое газ из пунктов 5 и 6 будет рассказано в следующих пунктах и еще более подробно рассказано в отдельной статье.
Выполнение транзакций требует затрат внутренней валюты и ожидания когда очередной созданный майнером блок с вашей транзакцией включится в общую цепочку. Код контракта выполняется на компьютере майнера, в виртуальной машине EVM, а в награду майнер получает комиссию.
DApp
----
DApp — Decentralized Application или децентрализованное приложение. В идеале пишется как ĐApp, но мы будем использовать упрощенное написание. Приложение может быть построено на разных технологиях, но среди них есть и блокчейн со смарт контрактами. Можно сказать, что на данный момент DApp — это логика на смарт контрактах плюс некий пользовательский интерфейс. Хранение более-менее объемных данных и обмен сообщениями в идеальном DApp тоже должны быть децентрализованными, однако эти технологии только начинают появляться и заслуживают отдельной статьи. Блокчейн же обеспечивает хранение текущего состояния и реализует бизнес-логику через смарт-контракты.
*Идеал, к которому стремится развитие децентрализованных приложений. Картинка позаимствована [отсюда](https://www.fastcompany.com/3047462/the-humans-who-dream-of-companies-that-wont-need-them)*
Используя DApp, пользователь может получить доступ к блокчейну напрямую на своем компьютере, установив специальное ПО. Блокчейн также может использоваться для каких-то отдельных операций на стороне сервера привычных нам мобильных и веб приложений. Выбор зависит от конкретной задачи. Упрощенный вариант DApp можно представить в таком виде:
*Картинка взята и переведена из [презентации Игоря Баринова](https://www.youtube.com/watch?v=FPuKCmFN2c8)*
Фронтенд и бэкенд в данном случае это классические элементы приложения, а функциональность с задействованием блокчейна выполняется на виртуальной машине EVM. Пользователю доступны стандартные функции виртуальной машины — такие как отправка транзакции или просмотр баланса аккаунта, — а также функции, описанные в смарт контрактах, например на языке solidity. Доступ к этой виртуальной машине предоставляется через RPC интерфейс.
Создание распределенных приложений должно, по нашему мнению, стать довольно востребованным направлением, так как они позволяют решать многие проблемы: отсутствие доверия к хранителю данных, уязвимые для атак серверы в централизованных системах, закрытость систем.
Первое подключение к блокчейну
------------------------------
Чтобы хоть как-то увидеть что значит быть участником сети мы скачали [Mist](https://github.com/ethereum/mist/releases) (на момент написания последняя версия под номером 0.9.0) — кошелек Ethereum. Кошельком Mist называется потому, что в нем можно управлять своими аккаунтами и балансом на них. Основная валюта — ether (эфир), но можно выпускать собственные токены, они также будут отображаться в кошельке. Но Mist — это не только кошелек, а еще и браузер DApp для Ethereum-блокчейна. Он позволяет выкладывать и использовать смарт контракты, а также пользоваться DApp-приложениями.
Для наглядности работы с блокчейном рекомендуем использовать пару клиентов на разных компьютерах: можно будет увидеть, что создаваемые данные доступны не только локально — но это не обязательно.
> UPD для Windows: Для пользователей Windows следующие пункты несколько осложнены. Требуется установить еще и [Geth](https://geth.ethereum.org/downloads/) — клиент командной строки. Перед запуском Mist надо будет выполнить в командной строке
>
> `geth --rinkeby`
>
> (вместо флага --rinkeby можно использовать --testnet если нужна сеть Ropsten, либо вообще опустить флаг, если нужна главная сеть). Из пользовательского интерфейса уже не получится изменить сеть или начать майнить. Если вы собираетесь подключаться и пробовать майнить на Ropsten — запустите geth такой командой
>
> `geth --testnet console 2>nul`
>
> В geth-консоли можно будет выполнить
>
> `miner.setEtherbase("<адрес вашего кошелька>")`
>
> после чего запустить
>
> `miner.start(4)`
>
> (4 — количество потоков, можно выставить сколько хотите). Имейте в виду, что лучше дождаться окончания синхронизации перед тем, как начинать майнить
1. Во время запуска Mist предлагает выбрать сеть — Main network или Test network. Выбираем Test network.
*Для выполнения любых операций на блокчейне требуется валюта этой сети, в данном случае ether. В Main network эфир стоит реальных денег, а в Test network — ничего не стоит и его легче получить. Кроме того, перед запуском к вам на компьютер скачиваются все данные сети, для testnet Ropsten на момент написания статьи это меньше 7 GB, для testnet Rinkeby — 800 MB, для реальной сети — больше 40 GB. Поэтому для начала выбираем Testnet. В реальной сети эфир можно получить купив его на бирже за реальные деньги (на момент написания статьи это около $300), либо намайнить, но для этого требуются довольно большие мощности и затраты времени. В тестовых сетях источники варьируются: это либо майнинг для Ropsten (получение из других источников Ropsten у нас не заработало), либо получение через такие источники как [www.rinkeby.io](https://www.rinkeby.io/) ->Crypto\_Faucet для Rinkeby. Майнинг в Testnet занимает значительно меньше времени, чем в реальной сети, например на ноутбучном процессоре i5 6200u мы получали 5 эфиров в зависимости от везения за пару-тройку часов. Скорость майнинга в этом случае была около 50 KH/s (50 KH — 50 килохэшей, или 50 000 хешей в секунду), вы сможете ее увидеть у себя и прикинуть сколько времени потребуется лично вам. Кстати намайнив несколько эфиров на одном клиенте можно будет без проблем передать часть на другой, например если тот майнит медленнее. Стоит упомянуть, что в дальнейшем мы будем использовать только Ropsten, которая является Proof-of-Work сетью, поэтому в ней и используется майнинг. В версиях Mist после 0.9 эта сеть больше не является сетью по умолчанию, поэтому если хотите использовать ее — сначала запустите Mist, нажав Launch Application, затем в пункте меню Develop->Network выберите нужную сеть. В целом надо отметить, что Rinkeby более удобен, так как не требует майнинга, быстрее и легче, поэтому вы не много потеряете используя его. Однако Ropsten более приближен к реальной сети и позволяет почувствовать ее особенности.*
2. Итак, запущен Mist, предлагает задать пароль для своего аккаунта. Логин не нужен, так как для идентификации используется файл приватного ключа.
*Приватный ключ хранится на линуксе в папке ~/.ethereum/testnet/keystore/ для Ropsten, ~/.ethereum/rinkeby/keystore/ — для Rinkeby. Обратите внимание, что для разных сетей создаются отдельные ключи и если вы собираетесь использовать Ropsten, как и мы, то потребуется создать еще один аккаунт. Имя состоит из даты и времени создания и адреса. Под адресом понимается шестнадцатеричная строка в 20 байтов вида 0xe03269461f7672494fb0dbbe89c00614601b5d24. В названии файла начальный 0x опущен. Адрес используется для идентификации вашего аккаунта в блокчейне, на него можно отправлять ether с других аккаунтов.*
3. Как уже говорилось, требуется синхронизация локальной базы, на это для testnet Ropsten может уйти пару часов и больше, но необходимо дождаться завершения процесса. Иначе есть вероятность получить рассинхронизированную базу.
*По крайней мере в нашем случае была ситуация, что при запущенном майнинге эфир начал набираться чересчур быстрыми темпами, но при этом его невозможно было использовать — все операции не были видны другим участникам сети. Проблема выяснилась следующим образом — в Mist в левом нижнем углу отображается номер последнего блока (либо сколько блоков остается до окончания синхронизации, в этом случае все нормально и нужно лишь дождаться окончания процесса). Номер последнего блока в локальной копии можно сравнить с реальным значением для данного блокчейна например на [ropsten.etherscan.io](https://ropsten.etherscan.io/) можно узнать последние номера блоков для сети Ropsten. Если ваше значение намного отличается в меньшую сторону — возможно ваша база не синхронизирована. Итак, что делать если синхронизация в mist дошла до конца, но номер блока неправильный? Мы решали эту проблему удалением данных и скачиванием их заново. Данные на Линуксе для сети Ropsten лежат в папке ~/.ethereum/testnet, нам помогло удаление всего из подпапки chaindata. После чего запустили mist и уже на этот раз терпеливо дождались окончания синхронизации.*
4. После окончания синхронизации можно выбрать пункт меню Develop->Start mining. Это необходимо для того, чтобы получить хоть немного эфира. Это актуально только для сети Ropsten. Если хотите использовать сеть Rinkeby — зайдите на [www.rinkeby.io](https://www.rinkeby.io/), вкладка Crypto Faucet, и следуйте приведенным инструкциям.
*Эфир нужен для любых операций по изменению данных, им оплачивается так называемый gas — абстрактная единица измерения, которая служит для оценки требующейся работы по выполнению транзакции. Она нужна для независимости этой оценки от текущей рыночной стоимости эфира. При отправке транзакции можно задать сколько эфира вы платите за каждую единицу газа и максимальное количество газа, которое вы готовы оплатить. Чем больше вы выделяете — тем более приоритетна ваша транзакция для потенциальных майнеров. Ведь по сути плата за gas — это оплата работы майнеров по выполнению вашей транзакции и включению ее в очередной блок. Поэтому при майнинге кроме фиксированной платы за найденный блок — на момент написания это 5 эфиров, — майнер также получает плату за транзакции, как правило это несколько сотых эфира. Количество газа за транзакцию зависит от вычислительной сложности операций над данными. Пример того как расходуется и оценивается газ мы приведем в следующей статье.*
Простейший Smart Contract
-------------------------
Как только у вас на аккаунте будет какое-то количество эфира — можно начинать эксперименты со смарт контрактами. Язык, на котором пишутся контракты — Solidity, — напоминает С++ и JavaScript. Есть и другие языки, но Solidity самый популярный, активно поддерживаемый и хорошо документированный, поэтому рекомендуем использовать именно его. Рассмотрим простой контракт, единственная цель которого — хранить и обеспечивать возможность менять единственную строку.
Код контракта:
```
pragma solidity ^0.4.10;
contract StringHolder {
string savedString;
function setString( string newString ) {
savedString = newString;
}
function getString() constant returns( string ) {
return savedString;
}
}
```
Строка `pragma solidity ^0.4.10` означает, что минимальный требуемый компилятор для данного контракта — 0.4.10, а символ ^ запрещает использование компилятора начиная с 0.5.0. Это актуально, так как Solidity развивающийся язык и несмотря на желание разработчиков сохранять совместимость — это не всегда возможно.
Имя контракта задается после ключевого слова `contract`. В теле контракта описываются все хранящиеся данные, в данном случае это поле `savedString` типа `string`. Манипуляции с данными осуществляются через сеттеры и геттеры. В данном случае функция `setString( string newString )` присваивает в переменную контракта новое значение для строки. Функция `getString() constant returns( string )` возвращает значение строки (тип возвращаемого значения задается как `returns(<тип>)`). Стоит особо отметить ключевое слово `constant` — оно гарантирует, что никакие из данных не будут изменены при выполнении функции. Если данные не меняются — то не нужно платить за газ. Поэтому геттеры выполняются моментально и бесплатно. Сеттеры требуют оплаты и выполняются не моментально (только в результате включения транзакции в очередной блок блокчейна).
Для начальных экспериментов с контрактами очень удобна [Remix IDE](https://ethereum.github.io/browser-solidity). Достаточно скопировать приведенный код контракта и вставить его в окошко для кода. В правой панели нажать Create — создастся контракт без публикации в блокчейн. Увидите следующее.
Синим отмечаются геттеры (getString), красным — сеттеры (setString). Показано сколько расходуется газа.
*Для задания строки в поле setString не забудьте поставить кавычки, иначе получите ошибку*
Проверив, что get и set работают как надо можно деплоить контракт в настоящий блокчейн. Для этого переключаемся обратно в Mist, заходим в Contracts и нажимаем Deploy New Contract. Копируем код в поле Solidity Contract Source Code и справа видим выпадающий список Pick a contract. Выбираем StringHolder, единственный пункт в данном случае. Выбираем размер оплаты, от которого будет зависеть время выполнения деплоя, нажимаем Deploy, в окне отобразится примерная стоимость, вводим пароль от аккаунта и нажимаем Send Transaction. В кошельке появится новая транзакция с прогрессом “x of 12 Confirmations” (x из 12 подтверждений). Первое подтверждение будет означать, что транзакция включена майнером в блок, последующие — что создано соответствующее количество блоков после блока с нашей транзакцией. Это дает большую гарантию, что блок с нашей транзакцией не будет отменен. Но для того чтобы контракт стал активным достаточно одного подтверждения. После подтверждения заходим в Contracts → String Holder. В mist отображается интерфейс контракта: слева геттеры (Read from contract), справа сеттеры (Write to contract) в виде выпадающего списка. Работает так же, как в Remix IDE, только задание строки — это уже настоящая транзакция, которая так же, как создание контракта, будет требовать подтверждения паролем и будет ожидать 12 подтверждений от майнеров.
Как другим пользователям увидеть этот контракт? Контракт определяется двумя составляющими: адрес и интерфейс ABI. Все это можно узнать на странице контракта в Mist, по кнопкам “Copy address” и “Show Interface”. Адрес — это такое же 20-байтное шестнадцатеричное число, например в нашем случае это 0x65cA73D13a2cc1dB6B92fd04eb4EBE4cEB70c5eC. А интерфейс — JSON-текст, для нашего смарт контракта он выглядит следующим образом:
```
[ {
"constant": false,
"inputs": [ { "name": "newString", "type": "string" } ],
"name": "setString",
"outputs": [],
"payable": false,
"type": "function"
}, {
"constant": true,
"inputs": [],
"name": "getString",
"outputs": [ { "name": "", "type": "string", "value": "Hello World!" } ],
"payable": false,
"type": "function"
} ]
```
Интерфейс генерируется автоматически из кода контракта и не должен меняться после деплоя, адрес контракта возвращается после деплоя и указывает на бинарный код контракта. Mist сохраняет эти данные и предоставляет интерфейс для их получения только если деплой выполнялся через него. Кстати список выполненных/выполняемых транзакций Mist тоже хранит локально и только если они совершались через его интерфейс.
Клиент, желающий использовать контракт, должен получить эти данные, и в случае с Mist выбрать Contracts->Watch Contract. Название можно выбирать любое, оно нужно лишь для удобства. Нажали ОК — контракт появился в списке, можно заходить в него и изменять строку уже с другого клиента. При этом после выполнения транзакции (получения хотя бы одного подтверждения) строка изменится у всех клиентов.
Этот пример описывает настоящее распределенное приложение, где каждый клиент скачивает на компьютер весь блокчейн, что не очень удобно в реальности, хоть и обеспечивает отсутствие посредников (на самом деле Mist тоже посредник, хоть и надежный). В реальности приходится идти на компромисс: например узел блокчейна разворачивается у третьей стороны, пользователю предоставляется веб-интерфейс. Или в браузер устанавливается специальный плагин (такой как Metamask), который использует ключ пользователя для подписи транзакций. В любом случае возникает проблема доверия к посреднику. Надеемся в будущем эта проблема решится или за счет реализации протокола легкого клиента, которому не требуются данные целиком, или каким-то еще способом. А пока приходится работать с тем что есть.
В [следующей статье](https://habrahabr.ru/post/336770/) мы подробнее рассмотрим как это работает. | https://habr.com/ru/post/336132/ | null | ru | null |
# Можно ли вычислить массу монеты по звуку её падения?
Однажды я случайно задел книжный шкаф и с него упала монета. Это натолкнуло меня на мысль: можно ли вычислить массу монеты на основании звука, который она издала при падении?
Если у нас есть размеры и материал объекта, то можно вычислить и массу, и тип нормального колебания. Одной лишь массы недостаточно — большая бумажная «монета» будет иметь сильно отличающуюся основную частоту от маленького вольфрамового шара.
> Связь между основной частотой звяканья монеты и её массой задаётся (приблизительно) уравнением
>
>
>
> 
>
>
>
> где
>
>
>
>  = модуль Юнга
>
>
>
>  = толщина
>
>
>
>  = масса монеты
>
>
>
>  = диаметр монеты
>
>
>
>  = основная частота
Сейчас я подробно расскажу, как вывел это уравнение…
Если предположить, что все «монеты» имеют одинаковое соотношение размеров (отношение диаметра к толщине) и изготовлены из одинакового материала, то действительно можно вычислить связь между основной частотой и массой. По анализу размерностей, если мы предположим, что частота — функция от
* : соотношения размеров (безразмерная величина: изначально предполагается константой, игнорируется)
* : диаметра ()
* : плотности ()
* : модуля ()
Тогда сочетание всего вышеуказанного, дающее нам размерность  — это
Скомбинировав это с массой объекта, которая пропорциональна , и допустив, что  постоянна (чтобы можно было устранить её из уравнения), мы получим
Другими словами, масса снижается с третьей степенью частоты для монет с одинаковым материалом и соотношением размеров.
Но монеты США устроены иначе. На [сайте Монетного двора США](http://www.usmint.gov/about_the_mint/index.cfm?action=Coin_specifications) я нашёл следующую информацию:
````
Соотношение
монета масса диаметр толщина материал размерностей
пенни 2,500 19,05 1,52 Zn* 12,53
5 центов 5,000 21,21 1,95 Cu-Ni 10,88
10 центов 2,268 17,91 1,35 Cu-Ni 13,27
25 центов 5,670 24,26 1,75 Cu-Ni 13,86
старый 1 ц. 3.11 19,05 1,52 Бронза. 12,53
* с медным покрытием...
````
То есть материал, как и соотношение размерностей, не всегда одинаковы. Это немного усложнит доказательство взаимосвязи.
Но давайте всё-таки попробуем. Из экспериментальных данных ([информация alemi](https://physics.stackexchange.com/a/121932/29216)) я получил следующие основные частоты:
````
пенни 12,6
5 центов 12,4
10 центов 12,8
25 центов 9,2
````
Здесь интересны 25 и 10 центов, потому что они состоят из одного материала и имеют самое близкое соотношение размеров (13,3 и 13,9, то есть разница всего 5%). Из соотношения их масс (2,500), можно ожидать, что соотношение частот будет 0,74 (). А измеренное соотношение оказалось равным 0,72. На самом деле, очень близко…
Иными словами, если мы знаем частоты 10 и 25 центов, и нам нужно вычислить массу 25 центов по 10 центам, мы получим
что даёт погрешность около 7%, или меньше 0,5 г. Мне кажется, это потрясающе, учитывая разницу масс в 2,5 раза между 25 и 10 центами.
Вдохновлённый этим результатом, я решил посмотреть, можно ли найти общее для всех четырёх монет, учитывая их разные соотношения размеров и материал. Так как и бронза, и медно-никелевые сплавы имеют широкий диапазон модулей Юнга, мне пришлось немного погадать (все значения указаны в ГПа):
````
материал диапазон (ГПа) значение (ГПа)
бронза 96 - 120 110
Cu-Ni 120 - 156 120
````
Далее мне нужно было разобраться с соотношением размеров. Поразмыслив над этим, я подумал, что при большем соотношении размеров (более тонкой монете) частота будет ниже, поэтому решил посмотреть, что произойдёт, если я сделаю частоту зависимой от . Это привело к выводу следующей формулы «ожидаемой частоты»:
Выполнив расчёты с новой массой пенни (3,11 г), я получил для каждой из монет следующий график зависимости:
На этом графике красными звёздочками показаны числа (отмасштабированные, чтобы уместиться на том же графике), которые бы мы получили *без* учёта соотношения размеров; синими окружностями показаны значения *с учётом* зависимости от . Как видите, они ложатся гораздо ближе к графику. Достаточно убедительно, учитывая довольно шумные данные…
Мысли в заключение
------------------
На записях звука видны множественные частоты. Некоторые из них легко объяснить, посмотрев на разные гармоники одной круглой тарелки. См. например, [Waller, 1938 Proc. Phys. Soc. 50 70](http://iopscience.iop.org/0959-5309/50/1/306/pdf/0959-5309_50_1_306.pdf).
Два изображения из этой публикации:
Первая, гармоники колебаний:
Вторая, их относительные частоты:
Это показывает нам, что первая гармоника в 1,7 раза выше, чем основная частота. Взглянув на данные, мы видим, что это и в самом деле так: в действительности для 25 центов (на графике quarter) мы даже видим вторую гармонику (в 2,3 раза выше от основной).
Вопрос разделения основной частоты немного хитрее. Если вы когда-нибудь играли с пустой кофейной кружкой, то могли заметить, что когда бьёшь по ободку, высота звука меняется в зависимости от места удара — прямо над ручкой, или смещённый на 45 градусов. Так получается, потому что есть две симметричные гармоники — там, где находится ручка, расположен узел, в другой точке расположена пучность. Последняя имеет чуть меньшую частоту.
То же самое может произойти и с 10 центами: если посмотреть на изображение монеты, изготовленной до 2005 года, можно заметить, что больше материала в направлении «север-юг» и «восток-запад». Это означает, что есть две гармоники колебаний: одна с узлами, отмеченными синим, другая — с красными:
Очевидно, что когда синие линии являются узлами, частота чуть выше.
Литература
----------
Я нашёл статью, в которой эта тема рассматривается чуть подробнее — в целом она соответствует сказанному выше, и даже выводит очень похожие значения частот (измеренные и промоделированные). Её можно прочитать здесь: <http://me363.byu.edu/sites/me363.byu.edu/files/Emerson_Steed_CoinIdentification.pdf>.
Любопытно, что авторам не удалось записать звук пенни, хотя их модель предполагала, что её частота близка к той, которую замерил alemi (13,1 кГц). Они показали первую гармонику колебаний так:
что является красивым цветным 3D-представлением гармоники, описанной в статье 1938 года Уоллером (Waller). | https://habr.com/ru/post/557394/ | null | ru | null |
# Почему HeadHunter это Tinder
И причем тут поиски счастья**Дисклеймер:** данная статья носит скорее философский, чем технический характер рассуждений и рассчитана на людей, имеющих небольшой опыт собеседований. С повышением квалификации может меняться отношение к поиску работы и пропадать ощущение романтики при переменах в жизни. *Это печально.*
Cервис для поиска работы это не место для романтических знакомств и речь в статье не о том, как завести оношения с HR. Последние две недели я искал работу и мне иногда казалось, что я сижу в Tinder. Не вьетнамские флешбеки, но похожие ощущения, что и 2-3 года назад, когда я пользовался сервисом онлайн знакомств.
И сейчас, когда мой поиск работы завершен, я решил поддаться рефлексии. Так что же общего у ~~ворона и письменного стола~~ HeadHunter и Tinder? Что похожего мы делаем, когда ищем работу или вторую половинку? Давайте по порядку.
Необязательные подробностиДанная статья это мой личный, субъективный взгляд на поиск работы в сфере IT. Знаниями и опытом похвастаться не могу - превращение из джуна в мидла ещё в процессе. Хочется поделиться мыслями и ощущениями и в то же время избежать "тухлых" советов по прохождению собеседований.
Понимаю, что некоторые выводы и аналогии могут оказаться моими когнитивными искажениями. Но, цитируя Роулинг: "Конечно, это происходит у тебя в голове, но кто сказал тебе, что поэтому оно не должно быть правдой?"
Наводим красоту
---------------
Первое, что мы делаем, когда собираемся искать работу - составляем резюме или редактируем уже существующее. Другими словами, мы приводим себя в порядок. Точнее ту часть, что будет на виду и по которой нас будут оценивать. Ведь, с плохим резюме у нас меньше шансов получить приглашение на ~~свидание~~ собеседование.
Не стоит пренебрегать и внешним видом. Хоть собеседование это не свидание - нужно выглядеть опрятно. Шанса на второе "первое впечатление" не будет.
В человеке должно быть всё прекрасно: и лицо, и одежда, и душа, и мысли. (А.П. Чехов)Логично, что кроме внешней красоты должна быть и внутренняя. Наши знания и опыт, приобретенные естественным путём, а не полученные из статьи "100 популярных вопросов на собеседовании". Читать такие статьи - полезно, но они не должны быть единственным источником Ваших знаний. Всё равно что выучить самые популярные подкаты и не знать о чём говорить после знакомства.
Место для непрошенных советов По поводу составления "правильного" резюме можно услышать всякое. "Это должна быть интересная история, которая читается на одном дыхании" или "нужно успеть накрутить побольше звезд на своем гитхабе". Я поступил так: нашел хорошее резюме и сделал своё по аналогии. Точнее, я слушал Moscow python podcast (это не реклама) и гость одного из выпусков сам советовал брать свое резюме за основу. Короче, я не крал, а мне подарили.
Кроме чтения статей, я попробовал найти умные мысли в различных IT подкастах, посмотрел открытые онлайн собеседования и узнал много полезного. Заниматься этим я начал за пару месяцев до поисков работы, понемногу готовясь к будущим переменам.
> В одном из подкастов была озвучена следующая мысль: искать работу нужно только через связи, знакомых в Facebook или LinkedIn.
>
>
С одной стороны, всё правильно - мы обходим очередь из людей, откликнувшихся на вакансию через HeadHunter. Но с другой стороны, возникает впечатление, что без связей невозможно устроиться на работу. Посещай митапы, знакомься с людьми, заводи связи - иначе никак. Попадаем в грустный цикл:
```
while my_skill not in ('курсы', 'митапы', 'социальные связи'):
print('Работу мне не найти')
```
Очень хорошо, если у Вас есть человек, который может ~~Вас женить~~ помочь с трудоустройством. При условии, что Вы действительно хороший кандидат на должность. Для тех, у кого нет связей, предлагаю не зацикливаться, а проверять себя на условие:
```
if my_skill in ('знания', 'опыт', 'желание развиваться'):
print('Я могу попробовать найти работу')
```
Про Tinder говорят практически то же самое: там нельзя найти серьезных отношений, а искать вторую половинку нужно через знакомых. Это не так, но желаемый результат - совокупность удачи и Ваших собственных усилий. А их, возможно, придётся приложить немало.
Ищем ту самую ...
-----------------
Соискатель изучает вакансии в газете "Из рук в руки" (архивное фото)... подходящую вакансию, конечно же. А их может быть много и все они будут казаться подходящими. На этом этапе мы пытаемся понять, каким хотим видеть будущего ~~партнера~~ работодателя, будет ли нам интересно вместе, подходим ли мы друг другу. Процесс выбора достаточно непростой, приходится ориентироваться только на описание (в Tinder описание вообще может отсутствовать - только фото).
В вакансии может быть написано, что компании нужен middle или senior ~~помидор~~ разработчик, а на самом деле - набирают и джунов. Или другой вариант: указаны технологии с которыми Вы не работали, например, фреймворк Django. Но зато, Вы хорошо знаете Flask или FastAPI, возможно этого будет достаточно. Во всяком случае, никто не запрещает откликнуться на вакансию и написать о том, что вы чего-то не знаете в сопроводительном письме.
> Это не означает, что нужно "ломиться" в тимлиды, закончив курсы junior python разработчика. Всегда нужно знать меру и трезво оценивать свои силы.
>
>
Tinder (как и HeadHunter) - особенное место. На просторах сервиса знакомств можно встретить разное. Например, можно не пройти проверку условия и вызовется исключение:
```
if your_salary < 100000:
raise NotEnoughMoneyError
```
Людей фильтруют по интересам, физическим параметрам, финансовой успешности. Каждый ищет что-то своё, а Tinder в данном случае - всего лишь инструмент для поиска. Только вот, фильтруя вакансии в HeadHunter, в отличие от Tinder, не чувствуешь, что [пластмассовый мир победил.](https://vc.ru/services/118899-mehaniki-tinder-psihologiya-igry-lyubov-dengi)
Работает ли Tinder?Если кратко - да. Об этом говорит мой личный опыт и опыт моих друзей. Найти себе пару в онлайне - реально. На мой взгляд, это ничем не отличается от знакомств в реальной жизни. В том смысле, что и в интернете, и в офлайне Вы можете встретить как хорошего человека, так и не очень. Повторюсь, успех - это Ваши усилия плюс удача.
Делаем свайп и пишем первыми
----------------------------
Когда не хочется делать резюме видимым для всехИ вот, настает тот момент, когда мы решаемся сделать первый шаг. Если для общения в Tinder, у Вас с потенциальным партнером должен быть match (вы оба лайкнули фотографии друг друга), то с HeadHunter дело обстоит иначе. Вы сразу откликаетесь на понравившуюся вакансию и даже можете написать сопроводительное письмо. Впрочем, это неплохая практика в том же Tinder: рассказать немного о себе, сделать комплимент. Уж точно лучше, чем просто поставить лайк.
Ободряющие слова для интровертовНе знаю как другие, но я, откликаясь на первую вакансию, заметно нервничал. Это был первый раз, когда я почувствовал атмосферу сайта знакомств. Может, это особенность восприятия или простая нервозность. В любом случае, мне пришлось сделать над собой усилие и побороть нерешительность. Чем больше усилий Вы совершаете, тем проще становится. Если у Вас есть цель и готовность следовать ей.
К слову о комплиментах, почему бы при отклике на вакансию не написать, что именно Вас в ней заинтересовало. При условии, что Вы прочитали дальше названия вакансии и будущей зарплаты. В идеале, стоит откликаться только на те вакансии, которые вызывают у Вас искренний интерес.
> Искренность - залог здоровых отношений не только с партнером, но и с работодателем.
>
>
И тут появляется сваха ...
--------------------------
HR рассматривают Вашу кандидатуру на имеющуюся вакансиюДа, сваха это HR рекрутер. Без обид, это просто аналогия и у HR более важная роль, чем свести потенциального работника и компанию. Работники - это люди, а люди бывают разные. Если точнее - ~~вменяемые~~ подходящие и не очень. Соответственно, HR выступает первым фильтром, который отсеивает людей, не соответствующих вакансии.
> Роль свахи заключается в том, чтобы свести подходящих друг другу людей. HR занимаются тем же самым, только сводят человека с компанией.
>
>
В идеальном мире рекрутеры находят работникам идеально подходящие вакансии. Но мы живём в мире реальном, где нам присылают вакансию java разработчика, хотя мы пишем на python. Прямо как в брачном агентстве - быстрее бы женить (выдать замуж) и взяться за следующего кандидата.
На самом деле я люблю HRНекоторые считают HR лишним звеном в цепочке трудоустройства, утверждая, что нужно сразу общаться с потенциальным руководителем. Я с этим не согласен. Если бы HR не прислала мне вакансию компании, в которую меня потом взяли на работу, то сам бы я на неё не откликнулся.
Тем не менее, решение об отклике на вакансию принимает не рекрутер, а Вы. Только Вы сами можете реально оценить уровень собственной компетенции и насколько он соответствует выбранной вакансии.
Назначаем свидание
------------------
Го в zoom, я создалТочнее договариваемся, когда нам было бы удобно пообщаться. В Tinder c этим сложнее: музей или кино, погулять в парке или просто поговорить за чашечкой кофе. Договариваясь о собеседовании (забавно, когда его называют "интервью", *чувствуешь себя "звездой"*), Вы просто выбираете сервис видеоконференций, обычно Skype или Zoom. Последний, кстати, в бесплатной версии имеет ограничение по времени в 40 минут, после чего конференция завершается. Прямо посреди собеседования.
> Если бы свидания выглядели как собеседования через Zoom, то каждые 40 минут Вас бы выгоняли из кафе или просили пересесть за другой столик.
>
>
Выбор, правда, предоставляют не всегда - чаще просто дают ссылку на конференцию. Всё равно, что позвать в кино и не дать выбрать кинотеатр. В результате, за день может быть 4-5 собеседований и все в разных сервисах.
Что делать, если Вас все хотятТакого успеха у женщин я не имел никогда. Да и у мужчин тоже. Правда, им всем нужно было от меня только одно - чтобы я откликнулся на вакансию. Сделав своё резюме видимым, я получил много предложений и откликнулся на большую часть из них. Договариваться о времени для собеседования, ведя переписку одновременно с несколькими HR было проблематично. Поэтому я использовал [планировщик](https://youcanbook.me) и кидал всем ссылку на своё расписание со свободными таймслотами.
Производим впечатление
----------------------
Джун пишет код на бумажке (фрагмент собеседования)Стараемся, во всяком случае, произвести хорошее впечатление о себе, но там *уж как получится*. Желательно быть дружелюбным ~~соседом человеком-пауком~~ собеседником и не "огрызаться", если Вам не нравится вопрос или методика проведения собеседования.
Ваша основная задача - показать свои сильные стороны. Слабые - нужно не скрывать, но уметь правильно их преподнести. Удержаться от того, чтобы приукрасить себя любимого и свои достижения - довольно непросто. Может быть и наоборот: неуверенность в себе мешает объективно оценить свои знания и рассказать о них. С первого раза, вряд ли получится отлично презентовать себя, если у Вас такого опыта не было.
> Как и настоящее свидание, собеседование это не односторонний процесс. Вы составляете мнение о компании так же, как компания - о Вас. Необходимо использовать эту возможность по максимуму и узнать о компании всё, что Вас интересует.
>
>
Спрашивать нужно о том, чем придется заниматься, о своих будущих обязанностях и условиях труда. Иногда, то что написано в вакансии, может не соответствовать действительности. Удаленная работа может оказаться гибридным графиком, а фраза "ты не боишься кода на python 2.x" - бессрочной поддержкой legacy.
Как мы делали ЭТОЗа время прохождения собеседований, я пообщался с большим количеством людей. Одни были настроены дружелюбно, другие - нейтрально, а третьи ~~издевались~~ весело иронизировали над моими пробелами в знаниях (таких людей было мало).
Спрашивают, в основном, по делу, на общение уходит около часа. У одной из компаний собеседование было ограничено 30 минутами, меня толком не поспрашивали, я не успел задать вопросы, которые хотел. Не очень понятно, как они в итоге выбирают кандидатов, возможно - по скорости произношения слов.
В Tinder не стоит врать, что Вы бодибилдер, это глупо и обман будет раскрыт при первой же встрече. Так и в резюме не стоит писать лишнего. Например, если Вы практически не работали с базами данных, то не нужно указывать отличный уровень знания PostgreSQL. Спросят и будет стыдно.
Учимся принимать отказы и работаем над ошибками
-----------------------------------------------
"Вы нам понравились, но ..."Если не получилось произвести правильное впечатление или Вы не подошли по каким-то критериям, то результат будет один - отказ. Хорошо, если компания оставит Вам фидбек по итогам собеседования (через какое-то время или [сразу](https://habr.com/ru/company/dododev/blog/506378/)), чтобы проработать ошибки и заполнить пробелы в своих знаниях. Можно сделать это и самостоятельно, зафиксировав вопросы, на которые Вы не смогли дать правильные ответы.
> Отказ - всегда удар по самооценке. Привыкнуть к этому невозможно, остается только изменить отношение к своим неудачам. Если отказов слишком много, возможно, следует сделать перерыв и вернуться позже, с новыми силами.
>
>
В Tinder оставлять фидбек не принято. Если что-то не так - собеседник просто начнёт Вас игнорировать или добавит в чёрный список. Это нормально, ведь на одного адекватного человека в сервисах знакомств приходится несколько неадекватных. Да и интернет развязывает руки, а точнее языки, позволяя написать вещи, которые в лицо не каждый скажет.
А может быть такая ситуация, что Вас просто не хотят обидеть и своим молчанием дают понять, что продолжения общения не будет. Почему так делают HR подробно описано [тут](https://habr.com/ru/post/547868/).
В любом случае (неважно, Tinder это или HeadHunter), нужно работать над ошибками. Гораздо проще это делать, если Вы осознаёте свои недостатки и понимаете, что все проблемы решаемы.
Идём на второе свидание
-----------------------
Интервьюер подсказывает решение задачиА точнее - на лайвкодинг (написание кода на собеседовании). Не у всех компаний это принято, многие на техническом собеседовании дают небольшие задачки и просят написать решение в чат. Бывает, что вместо второго этапа дают тестовое задание, но сейчас эта практика встречается всё реже.
Почему не даютПосле первого десятка собеседований я получил всего одно тестовое задание. Первая мысль была, что я просто не прохожу на второй этап, но во время общения с очередным HR рекрутером, я задал вопрос про тестовые задания и получил следующий ответ: "За последние пару лет рынок IT изменился. Сейчас большой спрос на специалистов и компании, обычно, берут человека без проверки тестовым заданием, чтобы он быстрее приступил к работе. Плюс, пока он будет делать задание, кто-то другой уже может предложить ему оффер"
Это плохо для компаний и, внезапно, для соискателя тоже. Если вы разволновались и не смогли поразить интервьюера рассказом о своих навыках и трудовой деятельности, то у Вас не будет второго шанса доказать свою профпригодность. Как и на свидании, если Вы не могли и двух слов связать, вряд ли с Вами захотят увидеться второй раз.
> Как и второе свидание, следующий этап собеседования - это успех. Значит, Вы друг другу понравились и можно продолжать диалог.
>
>
Многим людям не нравится то, что нужно писать код на собеседовании. А там просто [хотят проверить знание каких-то базовых вещей](https://habr.com/ru/post/550088/). Это можно понять, Вам с компанией ~~ещё детей растить~~ предстоит решать определенные задачи и она хочет знать справитесь ли Вы с ними. Другой вопрос, насколько методы проверки знаний объективны и показывают Ваш настоящий уровень.
Вступаем в отношения
--------------------
Приходит время признаться в своих чувствахВ случае с парой из Tinder всё понятно - Вам либо нравится человек, либо нет. С выбором работы сложнее: выбирать из нескольких компаний, про которые Вы ничего не знаете или, наоборот, все говорят и говорят разное. Вот, когда социальные связи реально нужны: узнать о работе в компании от работника - бесценно.
Не хочу теряться в само-само-сомнениях, выбирать один из ста вариантовВсе вакансии прекрасны без исключения, но только на первый взгляд. Как и у людей, недостатки есть и у компаний. Из тех, что после собеседования предложили мне оффер, выбрать было сложно. В итоге, я выбрал наиболее интересный стек технологий, с которым хотел поработать. Интервьюеры компании оставили хорошее впечатление, хотя собеседование простым не было. Но я понимаю, что истинное лицо (компания, сотрудники, условия работы) мне покажут только после ~~свадьбы~~ трудоустройства.
Да, вступив в обычные отношения, Вы тоже не знаете как они будут развиваться. Но, в отличие от работы, Вы не будете зависеть от отношений финансово (кроме тех случаев, когда один партнер содержит другого). Можно в любой момент расстаться, сделать паузу, какое-то время не вступать в отношения. С работой так не получится - нужно на что-то жить.
Компания тоже рискует, когда берёт Вас на работу. Ей нужно присмотреться к Вам и для этого назначается испытательный срок. Может случиться, что вы повстречаетесь несколько месяцев и расстанетесь. А может - это будет любовь на долгие годы.
И жили они долго и счастливо
----------------------------
И уволились в один деньМысль, которую я хочу донести, довольно проста. Вдумчивый поиск работы - как поиск второй половинки. Поэтому HeadHunter это Tinder. Если относиться к работе, как к партнеру на одну ночь, то ничего хорошего в результате не будет. Здоровые отношения - основа, фундамент нашей жизни, без них всё развалится.
Делать шаг навстречу неизвестности - всегда страшно. Бояться можно, даже нужно, но нельзя трусить, прятаться за выдуманными отговорками и откладывать важное решение на неопределенный срок. Ведь гораздо страшнее просидеть всю жизнь в "башне из слоновой кости" и, выйдя из неё понять, что ты больше никому не нужен.
> Смерть стоит того, чтобы жить, а любовь стоит того, чтобы ждать
>
> (Виктор Цой. "Легенда")
>
>
И любовь, и работа мечты пришли в мою жизнь, когда я уже был готов сдаться. Когда я уже сам в себя не верил, но всё равно продолжал следовать своей цели. Всё могло пройти мимо, но не прошло. Можно назвать это ошибкой выжившего, можно приплести эзотерику и трансерфинг реальности, можно пропагандировать упёртость и наглость. Всё это неважно - "дорога возникает под шагами идущего". А тот, кто стоит на месте, там и останется.
А вдруг не получится?Вот уже два года я живу с замечательной девушкой, которую очень сильно люблю. Мы познакомились в Tinder, том самом сервисе, где "невозможно" найти серьёзные отношения. Помните, что возможно всё. Верьте в себя и творите. Спасибо. | https://habr.com/ru/post/583820/ | null | ru | null |
# Yet Another Производственный Календарь на MS SQL. ПО->ША->ГО->ВО
Написать свое решение меня подтолкнул **[пост](https://habr.com/ru/post/507430/)** на Хабре на аналогичную тему, в котором эта задача была решена «в лоб» — простым перечислением дней и флагом рабочий/выходной за весь диапазон жизнедеятельности системы, в которой этот календарь используется. В аналогичной ситуации я решил поступить немного хитрее, что в итоге оказывается и гораздо проще в поддержке. Если интересно, как это было сделано — welcome под кат:
У метода «в лоб», кроме простоты, есть два достоинства — 1) логарифмическая скорость поиска/выборки, т.к. сама дата является натуральным ПК, и выбрать признак выходного дня по набору дат — операция на поле (кластерного) индекса, и 2) всего лишь незначительное снижение производительности при проверке рандомного набора (в диапазоне хранения, конечно) относительно непрерывного поддиапазона дат.
В итоге, если а) проверка даты может быть в широком диапазоне (хоть до Великой Октябрьской), б) в предикате проверки размах проверяемых дат не измеряется десятилетием, и в) не хочется возиться с тысячами записей в таблице, которые в 99% случаев не несут полезной информации, то можно сделать по-другому, а именно…
… вообще не хранить все возможные даты (чтобы не было и объекта, к которому применять index seek ;), синтезировать ось дат прямо на лету, по заданному диапазону, получать признак рабочий/выходной по номеру дня недели (Пн… Пт: рабочий, Сб… Вс: выходной), а исключения из этого правила хранить в компактной таблице.
Ну-с, приступим:
Создаем генератор оси дат в заданном диапазоне (пусть это будет inline table-valued function, для возможности переиспользования в разных применениях):
```
CREATE FUNCTION [dbo].[TF_Sys_DateGen](@MinDate DATE, @MaxDate DATE)
RETURNS TABLE AS
RETURN (
WITH DR AS (
SELECT @MinDate AS DateSeq
UNION ALL
SELECT DATEADD(DY, 1, R.DateSeq)
FROM DR R
WHERE DATEADD(DY, 1, R.DateSeq) <= @MaxDate
)
SELECT
DR.DateSeq
FROM DR
)
```
Проверяем:
```
SELECT * FROM dbo.TF_Sys_DateGen('2020-06-20', '2020-07-01')
```
Закономерно получаем:
Теперь приклеиваем к выводу признак выходного дня по умолчанию:
```
ALTER FUNCTION [dbo].[TF_Sys_DateGen](@MinDate DATE, @MaxDate DATE)
RETURNS TABLE AS
RETURN (
WITH DR AS (
SELECT @MinDate AS DateSeq
UNION ALL
SELECT DATEADD(DY, 1, R.DateSeq)
FROM DR R
WHERE DATEADD(DY, 1, R.DateSeq) <= @MaxDate
)
SELECT
DR.DateSeq,
CONVERT(BIT, CASE WHEN DATEPART(WEEKDAY, DR.DateSeq) IN (7, 1) THEN 1 ELSE 0 END) AS IsHoliday
FROM DR
)
```
Уже теплее:
Однако, есть маленькая закавыка: номер дня, возвращаемый встроенной функцией DATEPART, зависит от значения параметра DATEFIRST, а его дефолтное значение — в свою очередь от региональных настроек сервера. Поэтому надеться, что у нас американская система, и неделя начинается с воскресенья, в общем случае ~~непатриотично~~ ненадежно.
Что можно сделать, чтобы это обойти? Например, считать текущее значение DATEFIRST через переменную @@DATEFIRST (которая возвращает номер первого дня относительно дефолтного представления для США, в котором день с номером 1 — воскресенье (!)) и далее вывести исходя из текущего значения @@DATEFIRST номера дней в текущей нотации, соотвествующие субботе и воскресенью. Засеките минуту и попробуйте сделать это в уме.
Получилось? У меня тоже нет. Я решил не брать еще минуту помощи клуба, и сделал по-другому — получил дни недели в текущей нотации от дат, для которых я априори знаю, что это суббота и воскресенье — например, 1 и 2 января 2000 года. И дальше просто сравнил номера выдаваемых дней с этими, априори известными в текущем контексте:
```
ALTER FUNCTION [dbo].[TF_Sys_DateGen](@MinDate DATE, @MaxDate DATE)
RETURNS TABLE AS
RETURN (
WITH DR AS (
SELECT @MinDate AS DateSeq
UNION ALL
SELECT DATEADD(DY, 1, R.DateSeq)
FROM DR R
WHERE DATEADD(DY, 1, R.DateSeq) <= @MaxDate
)
SELECT
DR.DateSeq,
CONVERT(BIT, CASE WHEN DATEPART(WEEKDAY, DR.DateSeq) IN (Q.DOW_Sat, Q.DOW_Sun) THEN 1 ELSE 0 END) AS IsHoliday
FROM DR
CROSS JOIN (
SELECT TOP (1)
DATEPART(WEEKDAY, '1/1/2000') AS DOW_Sat, -- достоверная суббота
DATEPART(WEEKDAY, '1/2/2000') AS DOW_Sun -- достоверное воскресенье
) Q
)
```
Можно спросить, для чего все это вот CROSS JOIN / SELECT TOP (1)… подмешано в запрос? А вот для чего: поскольку моя TVF — inline, и тело функции — по сути один SELECT, — то никаких переменных вводить нельзя — все, на что мы можем опираться в основном SELECT, можно либо хардкодить (а этого мы как раз и хотим избежать), либо выводить в subquery.
Поэтому применяем CROSS JOIN (можно INNER… ON 1 = 1, кому как больше нравится).
TOP (1) здесь нужно больше SQL-движку, чем нам самим (ведь мы-то понимаем, что в subquery — всегда одна строка!), но *говорят*, что для подобных конструкций TOP (1) подсказывает компилятору запроса, что subquery нужно выполнить один раз перед основным, а не выполнять подобно CROSS APPLY для каждой строки основного SELECT'а. Я в этом не уверен на 100%, особенно если тело subquery non-deterministic (как нибудь это проверю), но пусть пока будет так.
Проверяем:
```
SET DATEFIRST 5 -- пусть в Солнечном городе у Незнайки неделя начинается с четверга
SELECT * FROM dbo.TF_Sys_DateGen('2020-06-20', '2020-07-01')
```
Бинго! Даже в Солнечном городе выходные — суббота и воскресенье!
Теперь осталась тривиальщина — наваять таблицу для хранения исключений и правильно ее сджойнить. Сделаем все в предположении, что мы автоматизируем глобальный бизнес, и праздничный день для одной страны может быть вполне себе серым рабочим буднем в другой:
```
CREATE TABLE CountryCalendarOverride (
CountryID INT NOT NULL,
CalendarDate DATE NOT NULL,
IsHoliday BIT NOT NULL,
CONSTRAINT PK_CountryCalendarOverride PRIMARY KEY CLUSTERED
(
CountryID,
CalendarDate
)
)
```
А что если мы хотим оставить лейбл к праздничном дню, чтобы не забывать, что мы празднуем? Или даже не переопределять признак рабочий/выходной, а просто оставить напротив какой-нибудь даты комментарий? Очень просто:
```
ALTER TABLE CountryCalendarOverride ALTER COLUMN IsHoliday BIT NULL
GO
ALTER TABLE CountryCalendarOverride ADD DateComment NVARCHAR(256) NULL
```
Зачем нам теперь nullable IsHoliday? Затем, что мы однажды можем захотеть дать комментарий просто для определенной даты, не зная/не задумываясь о том, выходной она день или рабочий, и не собираясь переопределять именно этот флаг — а просто сказать, что эта дата требует внимания.
Теперь все готово для финального спурта:
```
SET DATEFIRST 5 -- пусть в Солнечном городе у Незнайки неделя начинается с четверга
SELECT
DX.DateSeq,
ISNULL(CCO.IsHoliday, DX.IsHoliday) AS IsHoliday,
CCO.DateComment
FROM dbo.TF_Sys_DateGen('2020-06-20', '2020-07-01') DX
LEFT JOIN CountryCalendarOverride CCO ON DX.DateSeq = CCO.CalendarDate
AND CCO.CountryID = 1 -- Страна, в которой находится Солнечный город
ORDER BY DX.DateSeq
OPTION (MAXRECURSION 0)
```
Данные в таблице за июнь:
Вуаля (результат):
На закуску вопрос. Что будет, если
```
. . .
AND CCO.CountryID = 1 -- Страна, в которой находится Солнечный город
```
заменить на
```
. . .
WHERE CCO.CountryID = 1 -- Страна, в которой находится Солнечный город
```
?
Есть еще один нюанс, связанный с CTE и MAXRECURSION — из-за него во имя принципа ненарушения инкапсуляции приходится подобные TVF делать multi-statement вместо inline — но об этом в следующий раз. | https://habr.com/ru/post/507728/ | null | ru | null |
# Tips & tricks в разработке букмарклетов
Так получилось, что в течение нескольких месяцев я занимался разработкой букмарклетов, сделав их около десятка. Использовал как jQuery, так и native JavaScript. О том, с какими подводными камнями я столкнулся, что нового узнал и нашел — об этом пойдет речь под катом.
#### 1. Подключение
Те, кто уже занимался разработкой букмарклетов, этот пункт могут пропустить, для остальных — простой пример.
> `<a href="javascript: (function(){var a=document.createElement('script');a.type='text/javascript';a.src='http://example.com/bookm.js?'+(new Date).getTime()/1E5;document.getElementsByTagName('head')[0].appendChild(a)})();" onclick="alert('Drag this button to your browser\'s bookmarks toolbar or right-click it and choose Bookmark This Link.');return false;" title="Bookmarklet Title"><img src="http://example.com/img/bookmarklet.gif" align="absmiddle" alt="Bookmarklet Title" border="0" />
>
> a>`
«href» в более читаемом виде:
> `javascript: (function () {
>
> var a = document.createElement('script');
>
> a.type = 'text/javascript';
>
> a.src = 'http://example.com/bookm.js?' + (new Date).getTime() / 1E5;
>
> document.getElementsByTagName('head')[0].appendChild(a)
>
> })();`
Здесь мы создаем элемент , в качестве src используем наш букмарклет, и добавляем его к странице в . Запись
> `(new Date).getTime() / 1E5`
Позволяет всегда подключать актуальную версию букмарклета, избежав его кеширования. Если вы не собираетесь часто менять его содержимое, можете её убрать.
Такой букмарклет можно перетащить Drag-and-Drop'ом в тулбары в Chrome, Safari и FireFox. Для IE нужно будет в контекстном меню выбрать добавление на панель закладок.
#### 2. Структура
Итак, рассмотрим содержимое нашего bookm.js. Вообще, можно привести два стиля написания букмарклетов:
##### 2.1 Функциональный подход
> `(function () {
>
> try {
>
> // код букмарклета здесь
>
> } catch (e) {
>
> console.log(e.name + ": " + e.message);
>
> }
>
> }())`
Основной плюс этого подхода — глобальная область видимости переменных остается абсолютно чистой, мы не засоряем её своими переменными. Но такой подход работает только для небольших, простых скриптов.
##### 2.2 Объектно-ориентированный подход
> `function ourSuperBookmarklet() {
>
> // свойства класса, например this.a = '10';
>
> }
>
>
>
> ourSuperBookmarklet.prototype.someOtherFunction = function(abc) {
>
> this.a += abc;
>
> }
>
>
>
> ourSuperBookmarklet.prototype.start = function() {
>
> // код букмарклета здесь
>
> this.someOtherFunction(abc);
>
> }
>
>
>
> try {
>
> var \_\_osb = new ourSuperBookmarklet();
>
> \_\_osb.start();
>
> } catch (e) {
>
> console.log(e.name + ": " + e.message);
>
> }`
Получилось немного больше.
Итак, здесь мы описываем класс, его свойства и методы. Затем в try-catch конструкции создаем экземпляр этого класса и запускаем метод-загрузчик.
В этом случае в глобальную область видимости попадает ourSuperBookmarklet и \_\_osb, однако нам это на самом деле и надо (об этом дальше).
Нужно никогда не забывать, что наш код инжектируется непосредственно в сайт, на который пользователь зашел, и наши ошибки могут сломать всю страницу. try-catch нам в этом немного поможет. Главное — не забудьте убрать все console.log'и из production версии.
#### 3. Работа с экземпляром класса
Рассмотрим такой пример.
> `ourSuperBookmarklet.prototype.start = function() {
>
> var si = setInterval(function () {
>
> if(something) {
>
> clearInterval(si);
>
> this.a++;
>
> }
>
> }, 500);
>
> }`
this.a — в данном случае мы хотим обратиться к свойству нашего класса. В такой записи ничего не выйдет, ведь this будет указателем на функцию интервала. Вы можете сделать так:
> `ourSuperBookmarklet.prototype.start = function() {
>
> var th = this;
>
> var si = setInterval(function () {
>
> if(something) {
>
> clearInterval(si);
>
> th.a++;
>
> }
>
> }, 500);
>
> }`
И это будет работать. Однако создавать в каждом методе специальную переменную, так чтобы она была везде одинакова — больше похоже на костыль.
Более элегантное решение (имхо!) это обратиться к экземпляру класса, вот так:
> `ourSuperBookmarklet.prototype.start = function() {
>
> var si = setInterval(function () {
>
> if(something) {
>
> clearInterval(si);
>
> \_\_osb.a++;
>
> }
>
> }, 500);
>
> }`
И в этом огромный плюс объектно-ориентированного подхода. Возможно этот пример не очень убедителен, но посмотрите вот сюда:
> `ourSuperBookmarklet.prototype.someOtherFunction = function(text, obj) {
>
> obj.innerHTML = text;
>
> }
>
>
>
> ourSuperBookmarklet.prototype.start = function() {
>
> var a = document.createElement('div');
>
> a.innerHTML = 'qwerty';
>
> a.setAttribute('ommouseover', '\_\_osb.someOtherFunction(\'asdf\', this);')
>
> document.body.appendChild(a);
>
> }`
Таким образом мы можем обращаться к методам и свойствам нашего класса из других скриптов/событий и т.д. Что есть хорошо.
#### 4. AJAX
Вот здесь спешу вас огорчить. Ваши любимые $.post и $.get здесь работать не будут.
Дело в том, что на уровне браузера компоненту xmlHttpRequest запрещено обращаться к другому домену (это относится не ко всем браузерам, и где-то такое будет работать, есть желание — проверьте), подробнее [en.wikipedia.org/wiki/Same\_origin\_policy](http://en.wikipedia.org/wiki/Same_origin_policy). А так как наш код становится частью сайта, на который пользователь зашел, то обращение к нашему сайту и есть обращение к другому домену.
Все же, не xmlHttpRequest'ом единым. В свое время я сам пришел к нижеописанному способу, однако потом нашел, что этот метод достаточно популярен.
> `ourSuperBookmarklet.prototype.request = function(str) {
>
> var script = document.createElement('script');
>
> script.setAttribute('type', 'text/javascript');
>
> script.setAttribute('src', str);
>
> document.getElementsByTagName('head')[0].appendChild(script);
>
> }`
Все просто, и очень похоже на то, как мы подключали букмарклет (см. начало). Просто, если нам нужно просто передать данные. А если мы хотим получить callback? Здесь я использую 2 способа, и они оба связаны с JSON.
##### 4.1 JSONP
Возьму пример из википедии. У нас есть объект
> `{"Name": "Cheeso", "Rank": 7}`
И мы передаем его с помощью script'а (в нашем случае он создается динамически).
> `<script type="text/javascript" src="http://server2.example.com/getjson?jsonp=parseResponse">script>`
В итоге нам нужно передать
> `parseResponse({"Name": "Cheeso", "Rank": 7})`
Где parseResponse — это функция callback'а в букмарклете, который будет обрабатывать переданный объект. В нашем случае это было бы что-то вроде
> `\_\_osb.parseResponse({"Name": "Cheeso", "Rank": 7})`
##### 4.2 JSONP, но без P
Все хорошо, но как узнать, если мы не смогли запросить нужный ответ? Например, наш сайт лег. В таком случае я использую конструкцию:
> `var c = 0;
>
> var ci = setInterval(function() {
>
> if(\_\_osb.getInfo) {
>
> clearInterval(ci);
>
> // обработка объекта
>
> }
>
>
>
> if(c > \_\_osb.timeout) {
>
> clearInterval(ci);
>
> // выводим сообщение об ошибке
>
> }
>
> c++;
>
> }, 1000);`
Здесь \_\_osb.timeout — количество секунд, в течение которых мы будем ждать ответ от сервера. Вопрос — что такое \_\_osb.getInfo?
Изначально (в конструкторе класса) мы проинициализировали getInfo как null. А ответ от сервера будет таким:
> `\_\_osb.getInfo = {"Name": "Cheeso", "Rank": 7}`
Поэтому, как только \_\_osb.getInfo станет не null, мы закончим его ждать и начнем обработку ответа, иначе выведем сообщение об ошибке.
#### 5. JSON
Раз уж зашла речь о JSON'е, хочется немного отойти от темы и сообщить приятную новость. В последних версиях популярных браузеров появился нативный объект window.JSON, который умеет кодировать/декодировать объекты/строки.
Для кодирования объекта в строку используется JSON.stringify, для обратного преобразования — JSON.parse. Нативный объект JSON быстрее выполняет эти преобразования, нежели наши решения, написанные вручную. Поэтому рекомндую проверять наличие объекта window.JSON, и только в случае его отсутствия пользоваться своими решениями для конвертирования.
#### Вместо заключения
В примерах я использовал только нативный JavaScript, однако вы можете подключить любимый фреймворк перед поключением самого букмарклета. Причины, по которым я обычно не пользуюсь фреймворками:
* Скорость выполнения. Если у нас много объектов, по которым часто проходиться пробегать, то вопросы процессорного времени и памяти становятся на первое место. Чистый JavaScript всегда будет работать быстрее фреймворков. Хоть они и удобнее.
* Надежность. Используя нативные функции для работы с DOM я гарантирую, что скрипт будет работать так, как хочу я. Вы можете возразить, что мне приходится писать много лишнего кода для поддержания кроссбраузерности. Очнитесь, люди! За все время написания букмарклетов помню одно серьезное отличие IE от остальных браузеров (работа с выделенным текстом) и пару мелких.
* Независимость от CDN'ов. Для работы нужен только браузер пользователя и все. Если вы не используете CDN, то это серьезный аргумент, если используете — я немного побуду параноиком и скажу, что теоретически их тоже могут уронить/сломать и прочее…
* Желание выучить нативный JavaScript и DOM. Для меня было важной причиной ;-) | https://habr.com/ru/post/111070/ | null | ru | null |
# Релиз Node.js 16: обзор лучшего
20 апреля состоялся релиз новой 16 версии Node.js. Среди основных изменений обновление движка JavaScript V8 до версии 9.0, встроенные бинарники (двоичные файлы) для Apple Silicon и несколько API, но обо всем по порядку.
С полным списком изменений можно ознакомиться [здесь](https://nodejs.org/en/blog/release/v16.0.0/).
Node.js 16 заменит Node.js 15 в качестве «текущего» (current) релиза. Этот статус будет сохраняться за ним на протяжении следующих 6 месяцев. Затем, в октябре 2021 года, Node.js 16 перейдет в статус «долгосрочной поддержки» (long-term support, LTS). После перехода в статус LTS он получит кодовое имя 'Gallium'.
Подробности о релизах можно найти в репозитории [«Node.js Release Working Group»](https://github.com/nodejs/release). А пока давайте пройдемся по лучшим новостям.
### Обновление V8 до версии 9.0
Обновление движка JavaScript V8 — это улучшение производительности, а также обеспечение поддержки Node.js последних возможностей JavaScript. К слову, в Node.js 15 использовался V8 версии 8.6.
Из основных изменений движка можно назвать поддержку индексов соответствия в регулярных выражениях (regexp match indices), а также улучшение (повышение скорости) доступа к свойству «super».
С полным списком изменений можно ознакомиться [здесь](https://v8.dev/blog/v8-release-90).
##### Индексы соответствия
Индексы соответствия позволяют разработчикам получать массив подмассивов, содержащих начальные и конечные позиции (индексы) групп захвата (capture groups) в регулярном выражении при наличии совпадения (или нескольких совпадений). Данный массив доступен через свойство «indices» объекта с совпадениями. Обратите внимание, что регулярное выражение, используемое для поиска совпадений, должно иметь флаг «/d».
```
const re = /(a)(b)/d // Регулярное выражение. Обратите внимание на наличие флага /d
const m = re.exec('ab') // Объект с совпадениями
console.log(m.indices[0]) // Первый подмассив — это полное совпадение
// [0, 2]
console.log(m.indices[1]) // Второй подмассив — первая группа захвата
// [0, 1]
console.log(m.indices[2]) // Третий подмассив — вторая группа захвата
// [1, 2]
```
##### Доступ к свойству «super»
Доступ к свойству «super» был улучшен за счет использования системы встроенного кэша и оптимизации генерации кода в «TurboFan» (TurboFan — это компилятор, за интепретацию кода в V8 отвечает Ignition). Как утверждают разработчики V8, скорость доступа к super стала почти такой же, как скорость доступа к обычному свойству.
Ось «Y» — количество операций. Ось «X» — доступ к обычному свойству, доступ к свойству «super» (до обновления), доступ к свойству «super» (после обновления).
### Стабильный Timers Promises API
[Timers Promises API](https://nodejs.org/api/timers.html#timers_timers_promises_api) предоставляет альтернативный набор таймеров, возвращающих объект «Promise», что избавляет от необходимости использования [util.promisify()](https://nodejs.org/dist/latest-v8.x/docs/api/util.html#util_util_promisify_original).
```
import { setTimeout } from 'timers/promises'
async function run() {
const greet = await setTimeout(3000, 'Hi!')
console.log(greet) // Hi!
}
run()
```
Timers Promises API был представлен в Node.js 15 в качестве экспериментальной возможности. Теперь он приобрел статус стабильного интерфейса.
### Другие новые возможности
Природа процесса релизов такова, что новые возможности появляются в «текущем» релизе примерно каждые 2 недели. По этой причине многие возможности были доступны в Node.js 15, но все же являются относительно новыми для среды выполнения.
Среди таких возможностей можно назвать следующее:
* Экспериментальная реализация стандарта [Web Crypto API](https://www.w3.org/TR/WebCryptoAPI/)
* npm 7 (v7.10.0)
* Node-API версии 8
* Стабильная реализация AbortController, основанная на [AbortController Web API](https://developer.mozilla.org/ru/docs/Web/API/AbortController)
* Стабильная реализация [Source Maps v3](https://sourcemaps.info/spec.html) (NODE\_OPTIONS=--enable-source-maps в терминале или { «enable-source-maps»: true } в .mocharc.json)
* Реализации atob (buffer.atob(data)) и btoa (buffer.btoa(data)), обеспечивающие совместимость с устаревшими API (кодирование/декодирование данных в формат «Base64»)
### Новые минимальные наборы компилятора и платформы
Node.js предоставляет встроенные бинарники для нескольких различных платформ. Для каждого мажорного релиза минимальный набор инструментов оценивается и по-возможности расширяется.
Node.js 16 будет первым релизом с встроенными двоичными файлами для [Apple Silicon](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D1%85%D0%BE%D0%B4_Mac_%D0%BD%D0%B0_Apple_Silicon#%D0%9F%D0%B5%D1%80%D0%B5%D1%85%D0%BE%D0%B4_%D0%BD%D0%B0_Apple_Silicon). В то время как для архитектур Intel (darwin-x64) и ARM (darwin-arm64) предоставляются отдельные архивы (tarball), «установщик» (.pkg) для macOS представляет собой мультиархитектурный бинарник.
Для платформ, основанных на Linux, минимальный уровень [GCC](https://developers.google.com/closure/compiler) для генерации Node.js 16 составляет GCC 8.3.
Подробности о поддерживаемых инструментах и компиляторах можно найти [здесь](https://github.com/nodejs/node/blob/v12.x/BUILDING.md#platform-list).
### Прекращение поддержки
Разработчики Node.js стараются минимизировать количество изменений, которые могут привести к нарушениям в экосистеме (имеется ввиду работа Node.js-библиотек). Для обнаружения таких изменений используется [СITGM (Canary in the Gold Mine)](https://github.com/nodejs/citgm).
Тем не менее, некоторые возможности были признаны устаревшими. Среди наиболее существенных можно назвать доступ к process.bindings() для некоторых модулей ядра, таких как process.binding('http\_parser') или process.binding('url').
Следует отметить, что новый мажорный релиз — это результат усилий большого количества людей, заинтересованных в улучшении и дальнейшем развитии Node.js (контрибьюторов и коллабораторов). Также с целью подготовки нового релиза к продакшну большую работу проделывает [Node.js Build Working Group](https://github.com/nodejs/build).
---
Наши [серверы](https://macloud.ru/?partner=4189mjxpzx) можно использовать для разработки на node.js.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
[](https://macloud.ru/?partner=4189mjxpzx&utm_source=habr&utm_medium=original&utm_campaign=agapov) | https://habr.com/ru/post/554098/ | null | ru | null |
# Аутентификация на сетевом оборудовании через SSH с помощью публичных ключей
По умолчанию инженеры подключаются к сетевому оборудованию с помощью имени пользователя и пароля. По протоколу Telnet учетные данные пользователя передаются в открытом виде, а по протоколу SSH в зашифрованном. Чтобы не передавать секретную часть по сети, используется аутентификация по публичным ключам. При такой аутентификации публичный ключ пользователя заранее прописывается пользователю на оборудовании. Секретный ключ по сети не передается.
Это руководство поможет вам быстро начать использовать публичные ключи для аутентификации при подключении к сетевому оборудованию по протоколу SSH. Руководство применимо как для Windows, так и для Mac OS X. Я постарался сделать его максимально простым и информативным. Оно не перегружено, но отвечает на основные вопросы:
* [Откуда взять публичный ключ и как его использовать?](#CreatePublicKey)
* [Как установить публичный ключ на оборудование привязать его к пользователю?](#ConfigureKeyAtHardware)
* [Как использовать секретный ключ на своем компьютере для подключения к конечному оборудованию?](#ConfigureSoftwareToUsePublicKey)
Содержание
----------
* [Введение](#Introduction)
* [Создание публичного RSA-ключа](#CreatePublicKey)
+ [Генерирование RSA-пары в SecureCRT](#CreatePublicKeySecureCRT)
+ [Генерирование RSA-пары в PuTTYgen](#CreatePublicKeyPuttygen)
+ [Конвертирование RSA-ключа из формата Putty Private Key (PuTTY) в формат OpenSSH (SecureCRT)](#ConvertPPKtoOpenSSH)
+ [Конвертирование RSA-ключа из формата VanDyke Private Key (SecureCRT) в формат Putty Private Key (PuTTY)](#ConvertVanDykePrivateKeyToPPK)
+ [Генерирование публичных ключей на MAC OS X средствами операционной системы](#CreatePublicKeyMacOSX)
* [Применение публичного ключа на оборудовании](#ConfigureKeyAtHardware)
+ [Cisco IOS XE, Catalyst (с версии 15.1 и выше), IOS](#ConfigureKeyAtHardwareCiscoIOS)
+ [Cisco ASA](#ConfigureKeyAtHardwareCiscoASA)
+ [Маршрутизаторы и коммутаторы Huawei](#ConfigureKeyAtHardwareHuaweiRouter)
+ [Huawei USG (6000)](#ConfigureKeyAtHardwareHuaweiUSG)
+ [Cisco Nexus 9.3](#ConfigureKeyAtHardwareCiscoNexus)
* [Использование секретного ключа для подключения по SSH](#ConfigureSoftwareToUsePublicKey)
+ [SecureCRT](#ConfigureSoftwareToUsePublicKeySecureCRT)
+ [PuTTY](#ConfigureSoftwareToUsePublicKeyPutty)
+ [MAC OS X](#ConfigureSoftwareToUsePublicKeyMacOSX)
+ [Как упростить работу с SSH на MAC OS X:](#MacOSXUseSSH)
* [Заключение](#finale)
* [Список источников](#ListOfSources)
Также я рассмотрел «больные» темы:
* Конвертация ключа между OpenSSH <==> SecureCRT <==> PuTTY.
* Использование разных пар публичных ключей для разного оборудования. Один ключ — это хорошо, но в реальности неприменимо. Для разных заказчиков или оборудования необходимы разные пары публичных ключей (одни с паролем, другие без).
* Использованию нативной (native) MAC OS X для работы с публичными ключами.
* Руководство также должно помочь в использовании Ansible с сетевым оборудованием, поскольку Ansible по умолчанию использует OpenSSH с аутентификацией по публичным ключам.
90 % изложенного материала проверено на реальном оборудовании.
Введение
--------
Кроме стандартной аутентификации по паролю (password/keyboard) в протоколе SSH существует также аутентификация по публичному ключу (RSA).
**Для справки**RSA (<https://ru.wikipedia.org/wiki/RSA>) — криптографический алгоритм с открытым ключом. Существует публичный открытый ключ (public key) и частный секретный ключ (private key). Обычно они используются для шифрования или цифровой подписи: сообщение зашифровывается с помощью открытого ключа и расшифровывается с помощью секретного ключа. То есть прочитать сообщение может только владелец частного ключа. Сообщение можно подписать контрольной суммой с использованием частного ключа, а любой обладатель открытого ключа сможет убедиться, что сообщение было зашифровано с помощью секретного ключа.
Аутентификация с помощью RSA-ключей состоит из нескольких этапов:
* [Создание пары RSA-ключей.](#CreatePublicKey)
* [Установка открытого ключа на оборудование.](#ConfigureKeyAtHardware)
* [Подключение к оборудованию и аутентификация с помощью RSA-ключа.](#ConfigureSoftwareToUsePublicKey)
Почему только RSA? Почему не DSA? К сожалению, ответа на этот вопрос я не нашел (и не особо искал). Но официально на оборудовании Cisco поддерживается только RSA.
Документ Secure Shell Configuration Guide, Cisco IOS Release 15E:
> Secure Shell Configuration Guide, Cisco IOS Release 15E
>
> Restrictions for Secure Shell Version 2 Support
>
> Rivest, Shamir, and Adleman (RSA) key generation is an SSH server-side requirement. Devices that act as SSH clients need not generate RSA keys.
>
>
Попытка ввести данные DSA-ключа:
```
CSR-1(conf-ssh-pubkey-data)#exit
%SSH: Only ssh-rsa type is supported
CSR-1(conf-ssh-pubkey-user)#
```
Создание публичного RSA-ключа
-----------------------------
Пару RSA-ключей можно создать с помощью различных утилит: SecureCRT, PuTTYgen или любым другим ПО. При создании ключа можно задать Passphrase (защита ключа с помощью пароля).
### Генерирование RSA-пары в SecureCRT
SecureCRT → Tools → Create Public Key…:
Чуть-чуть теории → кнопка “Next >”:
Тип сертификата RSA/DSA → Выбираем RSA → кнопка “Next >”:
Пароль шифрования для секретного ключа (необязательно, можно оставить пустым и не шифровать) + Комментарий → кнопка “Next >”:
Выбираем длину ключа (в версии SecureCRT 6.1.0 максимальная длина ключа равна 2048 бит, в версии 8.5.4 — 16 384 бит):
Генерирование ключа → кнопка “Next >”:
Для генерирования случайных чисел нужно просит поводить мышкой в рамках окна.
Сохранение пары ключей → Выбор места хранения → Выбор формата сохраняемого ключа (VanDuke Private format, OpenSSH legacy, OpenSSH new) → кнопка “Finish”:
SecureCRT спрашивает, делать ли данный ключ ключом по умолчанию для SecureCRT:
### Генерирование RSA-пары в PuTTYgen
Скачать PuTTYgen можно здесь: <https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html>.
Запускаем PuTTYgen:
Выбираем параметры (тип пары: RSA; битная размерность ключа: 2048; по желанию задаём Passphrase (защита ключа с помощью пароля)) → Generate:
Для гарантирования случайных чисел просит поводить мышкой в рамках окна. Это защита от псевдослучайных чисел.
Сохраняем RSA-ключи → Кнопка «Save private key»:
Обратите внимание: RSA-ключи, сохраненные в частном формате в одном ПО, нельзя использовать в ПО другого производителя. То есть пара RSA-ключей, созданных в PuTTYgen и сохраненных в формате Putty Private Key, не подходит для использования в SecureCRT, и наоборот. PuTTY поддерживает только формат Putty Private Key. Универсальным решением для распространения ключей является конвертирование ключей в формат OpenSSH (Смотри ссылку 2: “Conversion from Putty to SecureCRT with auth. keys”). Т. к. SecureCRT свободно работает с форматом OpenSSH. А ПО PuTTYgen преобразует формат OpenSSH в формат Putty Private Key.
### Конвертирование RSA-ключа из формата Putty Private Key (PuTTY) в формат OpenSSH (SecureCRT)
Чтобы использовать в SecureCRT RSA-ключи, которые сгенерированы в PuTTYgen и сохранены в формате Putty Private Key (\*.ppk), экспортируем их с помощью PuTTYgen в формат OpenSSH:
1. Запускаем PuTTYgen.
2. Загружаем существующий RSA-ключ в формате Putty Private Key (\*.ppk) → Кнопка “Load”.
3. Сохраняем файл публичного ключа → “Save public key”.
4. Экспортируем секретный ключ в формат OpenSSH: меню PuTTYgen → “Conversions” → “Export OpenSSH key”.
5. Используем в SecureCRT файлы в формате OpenSSH. Файл с публичным ключом имеет расширение .pub, файл с секретным ключом не имеет расширения.
### Конвертирование RSA-ключа из формата VanDyke Private Key (SecureCRT) в формат Putty Private Key (PuTTY)
Чтобы использовать в PuTTY RSA-ключи, которые сгенерированы в SecureCRT и сохранены в формате VanDyke Private Key (файл публичного ключа — \*.pub, файл секретного ключа \*. (без расширения)), экспортируем их с помощью SecureCRT в формат OpenSSH, а затем с помощью PuTTYgen экспортируем в формат Putty Private Key (\*.ppk):
1. Запускаем SecureCRT.
2. Меню “Tools” → “Convert Private Key to OpenSSH format...”
3. Выбираем исходный файл с ключами VanDyke Private Key.
4. Сохраняем OpenSSH-ключи с новым именем.
5. Запускаем PuTTYgen.
6. Загружаем существующий RSA-ключ в формате OpenSSH (\*.): PuTTYgen Menu → “Conversions” → “Import key”.
7. Сохраняем файл в формате Putty: “Save private key”.
### Генерирование публичных ключей на MAC OS X средствами операционной системы
Будем использовать встроенную утилиту ssh-keygen (man ssh-keygen).
Генерируем RSA-ключ с длиной 2048 бит с указанием имени ключа, путем к папке с местом хранения ключа:
```
ssh-keygen -b 2048 -t rsa -c "Lab router R4" -f /Users/ArtemiySP/Documents/python/r4
```
Во время выполнения программа спросит пароль для защиты RSA-ключа:
```
artemiy-2:Downloads ArtemiySP$ ssh-keygen -b 2048 -t rsa -C "Lab router R4" -f /Users/ArtemiySP/Documents/python/r4
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /Users/ArtemiySP/Documents/python/r4.
Your public key has been saved in /Users/ArtemiySP/Documents/python/r4.pub.
The key fingerprint is:
SHA256:WdT47SFvgGI7danxX94p8/cO3uyU12SB3ipkc7nHxzA Lab router R4
The key's randomart image is:
+---[RSA 2048]----+
| .o |
| .. . . |
| .o + . |
| oo+ B = .|
| .S+ O OEoo|
| o + + B*+|
| . . =.*O|
| .+o**|
| =+O|
+----[SHA256]-----+
artemiy-2:Downloads ArtemiySP$
```
Генерируем RSA-ключ с длиной 4096 бит в с указанием имени ключа, путем к папке с местом хранения ключа, пароль задаем в явном виде в параметрах генерации ключа (-N «cisco»):
```
artemiy-2:Downloads ArtemiySP$ ssh-keygen -b 4096 -t rsa -C "Lab router R5" -N "cisco" -f /Users/ArtemiySP/Documents/python/r5
Generating public/private rsa key pair.
Your identification has been saved in /Users/ArtemiySP/Documents/python/r5.
Your public key has been saved in /Users/ArtemiySP/Documents/python/r5.pub.
The key fingerprint is:
SHA256:NraLRMqB4qmA8qNjKdpBBt1JBw8Osf/3GfuB2k1R+zY Lab router R5
The key's randomart image is:
+---[RSA 4096]----+
| o.+.. |
| . * = |
|. o + . . |
| . o . . |
|. + o . S . . |
|o+.. = o o . . . |
|+oo o o o o o Eo|
|*=.. . o = * . ..|
|Boo. . o =.o |
+----[SHA256]-----+
artemiy-2:Downloads ArtemiySP$
```
Не рекомендуемые параметры генерации ключей: ненадёжный ключ длиной 1024 бита, с указанием имени ключа, путем к папке с местом хранения ключа, пароль задаем в явном виде в параметрах генерации ключа (-N "" – без пароля):
```
artemiy-2:Downloads ArtemiySP$ ssh-keygen -b 1024 -t rsa -C "Lab router R6" -N "" -f /Users/ArtemiySP/Documents/python/r6
Generating public/private rsa key pair.
Your identification has been saved in /Users/ArtemiySP/Documents/python/r6.
Your public key has been saved in /Users/ArtemiySP/Documents/python/r6.pub.
The key fingerprint is:
SHA256:LEcfgN+58TYMDv4MpBA2FGCWc2aFiY+SxWBf7pRViWs Lab router R6
The key's randomart image is:
+---[RSA 1024]----+
|.++=o*.o+.. |
|.oB % +. o |
| o X * .o... |
|o . = E+.=. |
| . oo+So.* |
| .oo o = |
| + . . |
| o |
| |
+----[SHA256]-----+
artemiy-2:Downloads ArtemiySP$
```
Итак, мы создали три ключа в с указанием имен ключей и указанием места хранения ключей (по умолчанию все ключи сохраняются в /Users/[Username]/.ssh).
По умолчанию, при подключении по SSH с аутентификацией по публичному ключу, происходит последовательный перебор всех публичных ключей, которые хранятся в папке /Users/[Username]/.ssh.
Ключ R6: переименуем ключ в “id\_rsa” (по умолчанию имя файла генерируемого ключа “id\_rsa”) и перенесем в папку с SSH-ключами (~/.ssh/) (Т. е. выполним все действия, чтобы ключ R6 использовался как основной ключ для подключений по SSH по умолчанию):
Преобразуем публичный OpenSSH-ключ в формат RFC4716 (экспорт в Cisco IOS):
```
https://serverfault.com/questions/706336/how-to-get-a-pem-file-from-ssh-key-pair
ssh-keygen -f ~/Documents/python/r4.pub -e -m RFC4716
ssh-keygen -f ~/Documents/python/r5.pub -e -m RFC4716
ssh-keygen -f ~/.ssh/id_rsa.pub -e -m RFC4716
```
Применение публичного ключа на оборудовании
-------------------------------------------
Как на различном оборудовании привязать открытый ключ к пользователю?
Процесс привязки публичного ключа к пользователю не стандартный и меняется от оборудования к оборудованию, поэтому приведены примеры для каждого типа оборудования, которое чаще всего применяется в сети.
### Cisco IOS XE, Catalyst (с версии 15.1 и выше), IOS
1. На устройстве уже есть пользователь.
2. В настройках SSH (ip ssh pubkey-chain) для пользователя (username cisco) указываем публичный ключ (key-string):
```
CSR-1#conf t
Enter configuration commands, one per line. End with CNTL/Z.
CSR-1(config)#ip ssh pubkey-chain
CSR-1(conf-ssh-pubkey)#username ssh-putty
CSR-1(conf-ssh-pubkey-user)#key-string
CSR-1(conf-ssh-pubkey-data)#$QAAAQEAnPbynT1+2rjlyqP4viSPdTVDFLSHzWjJnAwy
CSR-1(conf-ssh-pubkey-data)#$NCfaqvMTPruCgG5096q8lO0ntURmNgmfMEQPOgb8weF
CSR-1(conf-ssh-pubkey-data)#$AtMQYk7WFM+5iBnOQ32UAHNavCUA7YFEpAdOQO4W/qB
CSR-1(conf-ssh-pubkey-data)#$SlOLy+PQ47jDUINBnuUeHd8ZXyzXxWglzSvqtwMEXBW
CSR-1(conf-ssh-pubkey-data)#$VoUTBYbJ45DmFa93P50qf494ujaAsTbYyJ/GBzJUTK/
CSR-1(conf-ssh-pubkey-data)#$UADAkNGxQARfOfHZWiIYb3rif6h6hfwwVUZS/Tw==
CSR-1(conf-ssh-pubkey-data)#exit
CSR-1(conf-ssh-pubkey-user)#exit
CSR-1(conf-ssh-pubkey)#exit
CSR-1(config)#exit
CSR-1#exit
CSR-1#show running-config | inc ssh
username ssh-public-key secret 5 $1$ebjc$EYgwMFQXPPiywFVn6rl7t.
username ssh-putty privilege 15 secret 5 $1$vIhh$nM8iCeBKmLyVK4hA6./h4.
ip ssh pubkey-chain
key-hash ssh-rsa D4E9AD62F7F6265EAAB3FB8778477612
username ssh-public-key
key-hash ssh-rsa C331DEE821A84681A4A7B1862C100D16
username ssh-putty
key-hash ssh-rsa F32BEB60290EA75D151447C0D42D2A99
key-hash ssh-rsa 5432C275B363B646E02D3BA7E8D865B7
CSR-1#
```
### Cisco ASA
```
LAB-ASA5516-X-01/pri/act# conf t
LAB-ASA5516-X-01/pri/act(config)# username artemiy password artemiy privilege $
LAB-ASA5516-X-01/pri/act(config)# username artemiy attributes
LAB-ASA5516-X-01/pri/act(config-username)# ssh authentication publickey ?
username mode commands/options:
WORD Raw SSH-RSA public key
LAB-ASA5516-X-01/pri/act(config-username)# ssh authentication publickey AAAAB3$
```
Весь ключ вставляем в одну строчку (OpenSSH формат).
### Маршрутизаторы и коммутаторы Huawei
```
[R1]rsa peer-public-key test-key1 encoding-type pem
Enter "RSA public key" view, return system view with "peer-public-key end".
NOTE: The number of the bits of public key must be between 769 and 2048.
[R1-rsa-public-key]public-key-code begin
Enter "RSA key code" view, return last view with "public-key-code end".
[R1-rsa-key-code]---- BEGIN SSH2 PUBLIC KEY ----
[R1-rsa-key-code]Subject: Subject
[R1-rsa-key-code]Comment: " [email protected]"
[R1-rsa-key-code]ModBitSize: 2048
[R1-rsa-key-code]AAAAB3NzaC1yc2EAAAADAQABAAABAQC4YLFhPqfsz4a6PUpZOtvm6zGn5TWOVMnx
[R1-rsa-key-code]lTH5hr/u+aYnoM2XnDTu4Ul1iB8MMPLVKXzV4LgYhaFcU1rz2/yYhTKIwbiQTHof
[R1-rsa-key-code]63fJjyWwkvyBuVZTSKh4b2pfoF2mXgdJzzRmUaiRrZZUVJWsX+CbgtKQuktG7sTK
[R1-rsa-key-code]2eguHwdfhilbOAsUaL0/q39Y0aTAMnLMtn0m5r6MD/UopQPI3Fxm1L9azJ7zYIZa
[R1-rsa-key-code]yI43Solg0AOupPl8FHFI9Cxq81/uZRACx5lAyuObaQ4/t1Rdh3CAJj1qwfZjZFTP
[R1-rsa-key-code]VdJxwTDxwfkpOzMD193M0ThOSrgfWe336Q9F3jbSWrEYUQDX8ew7
[R1-rsa-key-code]---- END SSH2 PUBLIC KEY ----
[R1-rsa-key-code]public-key-code end
[R1-rsa-public-key]peer-public-key end
[R1]display rsa peer-public-key
=====================================
Key name: test-key1
=====================================
Key Code:
---- BEGIN SSH2 PUBLIC KEY ----
AAAAB3NzaC1yc2EAAAADAQABAAABAQC4YLFhPqfsz4a6PUpZOtvm6zGn5TWOVMnx
lTH5hr/u+aYnoM2XnDTu4Ul1iB8MMPLVKXzV4LgYhaFcU1rz2/yYhTKIwbiQTHof
63fJjyWwkvyBuVZTSKh4b2pfoF2mXgdJzzRmUaiRrZZUVJWsX+CbgtKQuktG7sTK
2eguHwdfhilbOAsUaL0/q39Y0aTAMnLMtn0m5r6MD/UopQPI3Fxm1L9azJ7zYIZa
yI43Solg0AOupPl8FHFI9Cxq81/uZRACx5lAyuObaQ4/t1Rdh3CAJj1qwfZjZFTP
VdJxwTDxwfkpOzMD193M0ThOSrgfWe336Q9F3jbSWrEYUQDX8ew7
---- END SSH2 PUBLIC KEY ----
aaa
local-user jet privilege level 15
local-user jet service-type telnet terminal ssh http
ssh user jet assign rsa-key test-key1
```
Типы форматов ключей, импортируемых на Huawei:
“The SecureCRT and PuTTY generate RSA keys in PEM format.”
```
rsa peer-public-key test-key1 encoding-type pem
```
“The OpenSSH generates RSA keys in OpenSSH format.”
```
rsa peer-public-key test-key1 encoding-type openssh
```
“The OpenSSL generates RSA keys in DER format.”
```
rsa peer-public-key test-key1 encoding-type der
```
По умолчанию — в шестнадцатеричном виде:
```
rsa peer-public-key test-key1
```
Примечание: оборудование Huawei поддерживает не только ключи в формате RSA, но и другие форматы:
```
ssh user user-name assign { rsa-key | dsa-key | ecc-key } key-name
```
Можно жестко задать тип аутентификации для пользователя по SSH:
```
[R1]ssh user jet authentication-type ?
all All authentication, password,RSA or ECC
ecc ECC authentication
password Password authentication
password-ecc Both password and ECC
password-rsa Both password and RSA
rsa RSA authentication
[R1]
```
То есть мы разрешаем доступ с помощью либо пароля, либо публичных и приватных ключей, либо и того, и другого.
### Huawei USG (6000)
Конфигурация полностью аналогична настройкам на маршрутизаторе, но имеет некоторые особенности.
По умолчанию уровень привилегий после журналирования с использованием сертификатов равен 0 и повышению не поддается. Поэтому уровень приоритета задается с помощью
```
user-interface vty 0 4
user privilege level 15
user-interface vty 16 20:
user privilege level 15
```
Пример:
```
[USG-a]rsa peer-public-key test-key1 encoding-type pem
Enter "RSA public key" view, return system view with "peer-public-key end".
[USG-a-rsa-public-key]public-key-code begin
Enter "RSA key code" view, return last view with "public-key-code end".
[USG-a-rsa-key-code]---- BEGIN SSH2 PUBLIC KEY ----
[USG-a-rsa-key-code]Subject: subject
[USG-a-rsa-key-code]Comment: " [email protected]"
[USG-a-rsa-key-code]ModBitSize: 2048
[USG-a-rsa-key-code]AAAAB3NzaC1yc2EAAAADAQABAAABAQC4YLFhPqfsz4a6PUpZOtvm6zGn5TWOVMnx
[USG-a-rsa-key-code]lTH5hr/u+aYnoM2XnDTu4Ul1iB8MMPLVKXzV4LgYhaFcU1rz2/yYhTKIwbiQTHof
[USG-a-rsa-key-code]63fJjyWwkvyBuVZTSKh4b2pfoF2mXgdJzzRmUaiRrZZUVJWsX+CbgtKQuktG7sTK
[USG-a-rsa-key-code]2eguHwdfhilbOAsUaL0/q39Y0aTAMnLMtn0m5r6MD/UopQPI3Fxm1L9azJ7zYIZa
[USG-a-rsa-key-code]yI43Solg0AOupPl8FHFI9Cxq81/uZRACx5lAyuObaQ4/t1Rdh3CAJj1qwfZjZFTP
[USG-a-rsa-key-code]VdJxwTDxwfkpOzMD193M0ThOSrgfWe336Q9F3jbSWrEYUQDX8ew7
[USG-a-rsa-key-code]---- END SSH2 PUBLIC KEY ----
[USG-a-rsa-key-code]public-key-code end
[USG-a-rsa-public-key]peer-public-key end
[USG-a]
[USG-a]ssh user admin assign rsa-key test-key1
! Out-of-band management interface:
[USG-a-GigabitEthernet0/0/0]service-manage ssh permit
! Grant user level 15 privillege:
[USG-a]user-interface vty 0 4
[USG-a-ui-vty0-4]user privilege level 15
```
### Cisco Nexus 9.3
Вариант 1: предустанавливаем файл публичного ключа на устройство и привязываем файл публичного ключа к пользователю.
* Копируем файл публичного ключа на устройство.
* Указываем пользователю использовать файл публичного ключа.
```
switch# copy tftp://10.10.1.1/secsh_file.pub bootflash:secsh_file.pub
username User1 sshkey file bootflash:secsh_file.pub
```
Вариант 2: копируем публичный ключ пользователю:
```
username User1 sshkey
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC4YLFhPqfsz4a6PUpZOtvm6zGn5TWOVMnxlTH5hr/u+aYnoM2XnDTu4Ul1iB8MMPLVKXzV4LgYhaFcU1rz2/yYhTKIwbiQTHof63fJjyWwkvyBuVZTSKh4b2pfoF2mXgdJzzRmUaiRrZZUVJWsX+CbgtKQuktG7sTK2eguHwdfhilbOAsUaL0/q39Y0aTAMnLMtn0m5r6MD/UopQPI3Fxm1L9azJ7zYIZayI43Solg0AOupPl8FHFI9Cxq81/uZRACx5lAyuObaQ4/t1Rdh3CAJj1qwfZjZFTPVdJxwTDxwfkpOzMD193M0ThOSrgfWe336Q9F3jbSWrEYUQDX8ew7
```
Использование секретного ключа для подключения по SSH
-----------------------------------------------------
Этот раздел посвящен настройке SSH-клиентов для аутентификации по RSA-ключам на сетевом оборудовании (или другом оборудовании, при условии, что оборудование и ПО поддерживает аутентификацию по публичным ключам).
Мы рассмотрим настройку использования публичного ключа в самых популярных программах: SecureCRT и PuTTY.
### SecureCRT
В окне настроек SSH есть список Authentication. В нём необходимо увеличить приоритет PublicKey до самого высокого — сделать верхним в списке.
Затем перейдите в параметры PublicKey и выберите файл приватного ключа. Самый верхний переключатель позволяет использовать глобальные настройки секретного ключа или сеансовые настройки — другой секретный ключ (ключ не по умолчанию) — только для этого подключения.
Настраиваем глобальный публичный ключ: в меню Options → Global options → Категория SSH2.
### PuTTY
В настройках SSH (Connection → SSH → Auth) в поле “Private key file for authentication” укажите файл Putty Private Key (\*.ppk):
### MAC OS X
Настройка стандартного клиента для использования публичных ключей:
* Подключение с нестандартным ключом (non-default key), указанным вручную:
```
artemiy-2:~ ArtemiySP$ ssh [email protected] -i ~/Documents/python/r4
The authenticity of host '10.31.73.29 (10.31.73.29)' can't be established.
RSA key fingerprint is SHA256:fxOLFKU6YGyIqisrIh2P0O52Rr6Wx/wsSAcHsTz8fo0.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '10.31.73.29' (RSA) to the list of known hosts.
CSR-4#
```
* Подключение с нестандартным ключом (non-default key), указанным вручную:
```
artemiy-2:~ ArtemiySP$ ssh [email protected] -i ~/Documents/python/r5
The authenticity of host '10.31.73.30 (10.31.73.30)' can't be established.
RSA key fingerprint is SHA256:4l67C4Il4pTaqYT4vrtWr0aY7rPmNWKsjRv2zlYtQIU.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '10.31.73.30' (RSA) to the list of known hosts.
MGTU#exit
Connection to 10.31.73.30 closed.
```
**Ошибка примера**Я не смог сделать снимок с запросом пароля — пароль записался в открытую сессию пользователя. Для запроса пароля в MAC OS X — необходимо разлогиниться и залогиниться снова.
* Подключение с ключом по умолчанию (default key – система сама найдет и использует Default public key):
```
artemiy-2:~ ArtemiySP$ ssh [email protected]
The authenticity of host '10.31.73.31 (10.31.73.31)' can't be established.
RSA key fingerprint is SHA256:2/ysACJQw48Q8S45ody4wna+6nJspcsEU558HiUN43Q.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '10.31.73.31' (RSA) to the list of known hosts.
PR#exit
Connection to 10.31.73.31 closed.
artemiy-2:~ ArtemiySP$
```
### Как упростить работу с SSH на MAC OS X:
* Создаём SSH Aliases.
* В SSH Aliases сразу задаём пользователей.
* Сразу прописываем местонахождение ключей.
Местонахождение Aliases и преднастроенная конфигурация SSH указаны в файле ~/.ssh/config (/Users/[Username]/.ssh/config).
Заполняется таким образом:
```
host r4
Hostname 10.31.73.29
Port 22
User r4
IdentityFile ~/Documents/python/r4
host r5
Hostname 10.31.73.30
Port 22
User r5
IdentityFile ~/Documents/python/r5
host r6
Hostname 10.31.73.31
Port 22
User r6
```
Примечание: у меня некорректно настроено подключение по умолчанию (как правильно, я не знаю), потому что подключение к хосту R6 (10.31.73.31) выполняется очень долго. Рекомендуется указать сразу указать путь к ключу по умолчанию.
Пример подключения по ssh используя публичные ключи и файл config:
```
artemiy-2:Documents ArtemiySP$ ssh r5
MGTU#exit
Connection to 10.31.73.30 closed by remote host.
Connection to 10.31.73.30 closed.
artemiy-2:Documents ArtemiySP$ ssh r4
CSR-4#exit
Connection to 10.31.73.29 closed by remote host.
Connection to 10.31.73.29 closed.
artemiy-2:Documents ArtemiySP$ ssh r6
PR#exit
Connection to 10.31.73.31 closed.
artemiy-2:Documents ArtemiySP$ ssh r6
PR#
```
Заключение
----------
RSA-ключи могут использоваться для замены аутентификации по паролю, но не во всех случаях:
* Невозможна аутентификация по публичным ключам, если настроена доменная аутентификация (потому что для аутентификации проксируются LDAP-запросы (kerberos) на сервер).
* Невозможна аутентификация по публичным ключам на старом сетевом оборудовании (пример: не получилось настроить на Cisco Catalyst 2960 с прошивкой 12.2).
Незащищенные паролем публичные ключи удобно применять в стендовом оборудовании. Недостаток: приходится рассылать коллегам и партнерам связку приватных и публичных ключей.
На некотором оборудовании одному пользователю может соответствовать несколько пар публичных ключей, на другом оборудовании одному пользователю соответствует только один публичный ключ.
Также разнятся форматы, в которых хранится пара из публичного и секретного ключа. Но это руководство поможет вам экспортировать ключи в разные форматы.
Сегодня оптимально использовать ключи длиной 2048 бит, но для некоторого оборудования это максимально возможная длина ключа (быть может, в новых прошивках это исправят). Например:
```
[R1]rsa peer-public-key test-key2 encoding-type pem
Enter "RSA public key" view, return system view with "peer-public-key end".
NOTE: The number of the bits of public key must be between 769 and 2048.
[R1-rsa-public-key]
```
Рекомендуется использовать публичные ключи для замены паролей, если пароли вводятся с помощью скриптов (пример: autologon в SecureCRT).
Рекомендуется использовать публичные ключи для защиты от передачи пароля по сети.
Некоторое ПО по умолчанию использует публичные ключи для аутентификации по SSH вместо пароля (пример: Ansible).
Список источников:
------------------
1. [Википедия RSA](https://ru.wikipedia.org/wiki/RSA)
2. [Conversion from Putty to SecureCRT with auth. keys, SecureCRT Forum](https://forums.vandyke.com/showthread.php?t=2773)
3. [Secure Shell Configuration Guide, Cisco IOS Release 15E](https://www.cisco.com/c/en/us/td/docs/ios-xml/ios/sec_usr_ssh/configuration/15-e/sec-usr-ssh-15-e-book/sec-secure-shell-v2.html)
4. [Скачивание PuTTYgen](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html)
5. Huawei, [официальная документация](https://support.huawei.com/hedex/pages/EDOC1000163877DEG0814J/10/EDOC1000163877DEG0814J/10/resources/dc/rsa_peer-public-key.html) — описание различных форматов ключей для импортирования на маршрутизатор Huawei
6. Huawei USG 6000, [настройка аутентификации по публичным ключам](https://support.huawei.com/hedex/hdx.do?lib=EDOC1100068394AEI0226D&docid=EDOC1100068394&lang=en&v=03&tocLib=EDOC1100068394AEI0226D&tocV=03&id=user_privilege&tocURL=resources%252fcli%252fuser%255fprivilege%252ehtml&p=t&fe=1&ui=3&keyword=user%25252Bprivilege%25252Blevel) (CLI: Example for Logging In to the CLI Using STelnet (RSA Authentication))
7. [Nexus 9000 Configuration guide SSH public key](https://www.cisco.com/c/en/us/td/docs/switches/datacenter/nexus9000/sw/93x/security/configuration/guide/b-cisco-nexus-9000-nx-os-security-configuration-guide-93x/b-cisco-nexus-9000-nx-os-security-configuration-guide-93x_chapter_0111.html#con_1064777)
8. man ssh-keygen — всё про генерацию ключей на mac os x.
9. [SSH config file на MAC OS X](https://osxdaily.com/2011/04/05/setup-ssh-config-fie/)
10. [Как указывать другой публичный ключ в параметрах SSH](https://www.mrtechnique.com/how-to-set-up-ssh-keys-on-a-mac/#log-in-ssh-different-name)
11. [Как указывать сторонний публичный ключ в параметрах SSH config](https://stackoverflow.com/questions/47455300/ssh-config-bad-configuration-option-usekeychain-on-mac-os-sierra-10-12-6)
12. [Как преобразовать openssh public key в формат RFC4716](https://serverfault.com/questions/706336/how-to-get-a-pem-file-from-ssh-key-pair) | https://habr.com/ru/post/490726/ | null | ru | null |
# Обновления Скалакси: изменение размера дисков, новая ОС и другие улучшения
Раз в две недели, а иногда и чаще, мы выпускаем обновления системы управления облаком. За две недели, обычно, мы успеваем определить, какой именно функционал нужно запустить или улучшить, реализовать его, протестировать и, наконец, выкатить.
Некоторое время назад появилась ajax-консоль для управления серверами, затем и возможность переустановить операционную систему. Но сегодняшнее обновление мне хочется выделить и рассказать о нем отдельно потому, какие изменения в него вошли. Просьбы реализовать их я слышал много раз как на хабре от просто интересующихся, так и от клиентов.
**UPD**: Те, кто зарегистрирован у нас на сайте, могут написать свои идеи и feature requests [вот тут](https://oversun.zendesk.com/forums/149794), в специальном разделе нашего сайта поддержки пользователей. Там же можно проголосовать за идеи других пользователей. Если вам действительно нужна та или иная фукнция, freebsd, например — пишите идеи и голосуйте :) Заранее спасибо вам за участие и поддержку проекта.
Итак, в обновление вошли:
* Возможность изменять размер дисков. Теперь можно зайти в панель и увеличить или уменьшить размер диска не перезагружая сервер. Эти операции доступны также и в API;
* Доступна новая ОС: OpenSuSE 11.3. Теперь можно использовать: Debian 5.0.6, Ubuntu 10.04, CentOS 5.5 и OpenSuSE 11.3.
Есть ряд ограничений на изменение размера дисков:
* Размер корневого раздела можно изменить только для выключенного сервера;
* Перед изменением размера диска **необходимо** отмонтировать соответствующий раздел;
* После изменения размера диска нужно самостоятельно изменить размер файловой системы командой `resize2fs /dev/%partition%`.
Спасибо всем тем, кто уже пользуется нашими сервисами, и добро пожаловать тем, кому только хочется их протестировать. Напомню, что после [регистрации на сайте](http://scalaxy.ru/signup) можно некоторое время тестировать наши сервисы бесплатно.
А для тех, кто следит за обновлениями и подписан на [наш twitter](http://twitter.com/scalaxy), у нас специальный сюрприз :)
Кстати, а какой операционной системы не хватает вам? Windows Server? FreeBSD? Будем рады услышать ваши отзывы! | https://habr.com/ru/post/109095/ | null | ru | null |
# Подсчёт времени выполнения метода через аннотацию
Во многих проектах требуется посчитать время, которое затратил тот или иной метод. Для этого можно вручную сохранять значение System.currentTimeMillis() и после метода вычислять затраченное время. Когда методов много это становится не очень удобным.
Поэтому я решил написать простенькую аннотацию, которая бы считала время выполнения метода. Попытавшись найти информацию в интернете, понял, что её по данной теме очень мало. Придётся как-то выкручиваться, собирая информацию по крупицам.
Наша аннотация будет помечать методы, для которых мы хотим посчитать время выполнения в миллисекундах или наносекундах и выводить результат через System.out.println.
Для начала создадим саму аннотацию:
> `package annotations.time;
>
>
>
> import java.lang.annotation.ElementType;
>
> import java.lang.annotation.Retention;
>
> import java.lang.annotation.RetentionPolicy;
>
> import java.lang.annotation.Target;
>
>
>
> @Target({ElementType.METHOD})
>
> @Retention(RetentionPolicy.SOURCE)
>
> public @interface Time {
>
> public enum TimeInterval { MILLISECOND, NANOSECOND };
>
> annotations.time.Time.TimeInterval interval() default annotations.time.Time.TimeInterval.MILLISECOND;
>
> String format() default "Elapsed %s";
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Поле interval служит для указания интервала времени (миллисекунды или наносекунды), поле format задаёт формат вывода результата.
Теперь, чтобы данная аннотация сработала как надо, нужно создать класс-обработчик расширяющий AbstractProcessor. В данном классе добавляется сохранение времени перед кодом метода, сам код метода копируется в блок try-finally, а блоке finally вычисляется затраченное методом время и выводится в консоль:
> `package annotations.time;
>
>
>
> import com.sun.tools.javac.code.Flags;
>
> import com.sun.tools.javac.code.TypeTags;
>
> import com.sun.tools.javac.model.JavacElements;
>
> import com.sun.tools.javac.processing.JavacProcessingEnvironment;
>
> import com.sun.tools.javac.tree.JCTree;
>
> import com.sun.tools.javac.tree.JCTree.JCBlock;
>
> import com.sun.tools.javac.tree.JCTree.JCCatch;
>
> import com.sun.tools.javac.tree.JCTree.JCExpression;
>
> import com.sun.tools.javac.tree.JCTree.JCExpressionStatement;
>
> import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
>
> import com.sun.tools.javac.tree.JCTree.JCStatement;
>
> import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
>
> import com.sun.tools.javac.tree.TreeMaker;
>
> import com.sun.tools.javac.util.List;
>
> import java.util.Set;
>
> import javax.annotation.processing.AbstractProcessor;
>
> import javax.annotation.processing.ProcessingEnvironment;
>
> import javax.annotation.processing.RoundEnvironment;
>
> import javax.annotation.processing.SupportedAnnotationTypes;
>
> import javax.annotation.processing.SupportedSourceVersion;
>
> import javax.lang.model.SourceVersion;
>
> import javax.lang.model.element.Element;
>
> import javax.lang.model.element.TypeElement;
>
> import javax.lang.model.util.Elements;
>
>
>
> @SupportedAnnotationTypes(value = {TimeAnnotationProcessor.ANNOTATION\_TYPE})
>
> @SupportedSourceVersion(SourceVersion.RELEASE\_6)
>
> public class TimeAnnotationProcessor extends AbstractProcessor {
>
>
>
> public static final String ANNOTATION\_TYPE = "annotations.time.Time";
>
> private JavacProcessingEnvironment javacProcessingEnv;
>
> private TreeMaker maker;
>
>
>
> @Override
>
> public void init(ProcessingEnvironment procEnv) {
>
> super.init(procEnv);
>
> this.javacProcessingEnv = (JavacProcessingEnvironment) procEnv;
>
> this.maker = TreeMaker.instance(javacProcessingEnv.getContext());
>
> }
>
>
>
> @Override
>
> public boolean process(Set extends TypeElement annotations, RoundEnvironment roundEnv) {
>
> if (annotations == null || annotations.isEmpty()) {
>
> return false;
>
> }
>
>
>
> final Elements elements = javacProcessingEnv.getElementUtils();
>
>
>
> final TypeElement annotation = elements.getTypeElement(ANNOTATION\_TYPE);
>
>
>
> if (annotation != null) {
>
> // Выбираем все элементы, у которых стоит наша аннотация
>
> final Set extends Element methods = roundEnv.getElementsAnnotatedWith(annotation);
>
>
>
> JavacElements utils = javacProcessingEnv.getElementUtils();
>
> for (final Element m : methods) {
>
> Time time = m.getAnnotation(Time.class);
>
> if (time != null) {
>
> JCTree blockNode = utils.getTree(m);
>
> // Нам нужны только описания методов
>
> if (blockNode instanceof JCMethodDecl) {
>
> // Получаем содержимое метода
>
> final List statements = ((JCMethodDecl) blockNode).body.stats;
>
>
>
> // Новое тело метода
>
> List newStatements = List.nil();
>
> // Добавляем в начало метода сохранение текущего времени
>
> JCVariableDecl var = makeTimeStartVar(maker, utils, time);
>
> newStatements = newStatements.append(var);
>
>
>
> // Создаём тело блока try, копируем в него оригинальное содержимое метода
>
> List tryBlock = List.nil();
>
> for (JCStatement statement : statements) {
>
> tryBlock = tryBlock.append(statement);
>
> }
>
>
>
> // Создаём тело блока finally, добавляем в него вывод затраченного времени
>
> JCBlock finalizer = makePrintBlock(maker, utils, time, var);
>
> JCStatement stat = maker.Try(maker.Block(0, tryBlock), List.nil(), finalizer);
>
> newStatements = newStatements.append(stat);
>
>
>
> // Заменяем старый код метода на новый
>
> ((JCMethodDecl) blockNode).body.stats = newStatements;
>
> }
>
> }
>
> }
>
>
>
> return true;
>
> }
>
>
>
> return false;
>
> }
>
>
>
> private JCExpression makeCurrentTime(TreeMaker maker, JavacElements utils, Time time) {
>
> // Создаём вызов System.nanoTime или System.currentTimeMillis
>
> JCExpression exp = maker.Ident(utils.getName("System"));
>
> String methodName;
>
> switch (time.interval()) {
>
> case NANOSECOND:
>
> methodName = "nanoTime";
>
> break;
>
> default:
>
> methodName = "currentTimeMillis";
>
> break;
>
> }
>
> exp = maker.Select(exp, utils.getName(methodName));
>
> return maker.Apply(List.nil(), exp, List.nil());
>
> }
>
>
>
> protected JCVariableDecl makeTimeStartVar(TreeMaker maker, JavacElements utils, Time time) {
>
> // Создаём финальную переменную для хранения времени старта. Имя переменной в виде time\_start\_{random}
>
> JCExpression currentTime = makeCurrentTime(maker, utils, time);
>
> String fieldName = fieldName = "time\_start\_" + (int) (Math.random() \* 10000);
>
> return maker.VarDef(maker.Modifiers(Flags.FINAL), utils.getName(fieldName), maker.TypeIdent(TypeTags.LONG), currentTime);
>
> }
>
>
>
> protected JCBlock makePrintBlock(TreeMaker maker, JavacElements utils, Time time, JCVariableDecl var) {
>
> // Создаём вызов System.out.println
>
> JCExpression printlnExpression = maker.Ident(utils.getName("System"));
>
> printlnExpression = maker.Select(printlnExpression, utils.getName("out"));
>
> printlnExpression = maker.Select(printlnExpression, utils.getName("println"));
>
>
>
> // Создаём блок вычисления затраченного времени (currentTime - startTime)
>
> JCExpression currentTime = makeCurrentTime(maker, utils, time);
>
> JCExpression elapsedTime = maker.Binary(JCTree.MINUS, currentTime, maker.Ident(var.name));
>
>
>
> // Форматируем результат
>
> JCExpression formatExpression = maker.Ident(utils.getName("String"));
>
> formatExpression = maker.Select(formatExpression, utils.getName("format"));
>
>
>
> // Собираем все кусочки вместе
>
> List formatArgs = List.nil();
>
> formatArgs.append(maker.Literal(time.format()));
>
> formatArgs.append(elapsedTime);
>
>
>
> JCExpression format = maker.Apply(List.nil(), formatExpression, formatArgs);
>
>
>
> List printlnArgs = List.nil();
>
> printlnArgs.append(format);
>
>
>
> JCExpression print = maker.Apply(List.nil(), printlnExpression, printlnArgs);
>
> JCExpressionStatement stmt = maker.Exec(print);
>
>
>
> List stmts = List.nil();
>
> stmts.append(stmt);
>
>
>
> return maker.Block(0, stmts);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для того чтобы компилятор java использовал наш управляющий класс, нужно создать файл META-INF/javax.annotation.processing.Processor, в котором должна быть прописана следующая строка:
annotations.time.TimeAnnotationProcessor
После этого собираем все наши файлы в annotations.jar и добавляем его в classpath к любому проекту.
Теперь, чтобы посчитать время выполнения метода, достаточно добавить к этому методу аннотацию [Time](https://habrahabr.ru/users/time/) и после его выполнения в консоль будет выведено затраченное методом время:
> `@Time(format="method time: %s ms")
>
> public void start() {
>
> Thread.sleep(1000);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В результате в консоли увидим:
method time: 1000 ms
UPD: добавил немного комментариев в код
UPD2: Так же можно переработать пример, чтобы он выводил время затраченное методом в System.err только если оно больше заданного в параметрах аннотации. Это могло бы быть полезно для production серверов, где пользоваться профайлером не всегда удобно. | https://habr.com/ru/post/88908/ | null | ru | null |
# Ещё один модуль рисования графиков
Лет пятнадцать назад потребовалось мне в программе для диплома отобразить график. Была бы программа на Builder или Delphi, всё было бы ничего, но только писал я для Windows на MFC, а там с классами графиков как-то не очень. И написал я тогда собственный модуль построения графиков. Три пятилетки прошло, а модуль остался, был переработан и я его иногда использую в своих поделках в QNX, Linux и Windows. Быть может, он пригодится чем-либо и вам.
Представляемый модуль рисования графиков позволяет отображать произвольное количество цветных графиков с легендой. Количество точек в графиках может составлять десятки миллионов и больше (лишь бы памяти хватало) без особого снижения быстродействия на перерисовку, так как при каждом изменении масштаба производится построение набора точек, отображаемого на экране с учётом масштаба. Таким образом, количество точек влияет только на время пересчёта этих отображаемых точек при изменении масштаба.
Функции растеризации вынесены в подключаемые классы. Всего возможно на текущий момент три варианта: рисование штатными функциями Windows-GUI из MFC (класс CVideo\_Windows), рисование штатными функциями Qt (класс CVideo\_Qt) и программная растеризация (класс CVideo\_Software — с доработкой этот модуль можно использовать на микроконтроллерах). Перекодировку символов в требуемый для классов растеризации формат осуществляет класс CTranslator.
В отдельные классы вынесены типы линий (если тип поддерживается классом растеризации), цвета, точки, прямоугольники.
Зажав левую кнопку мышки можно перемещаться по полю графиков. Правой кнопкой можно задать выделенную область, сделав щелчок на которой правой кнопкой мышки вы вернётесь в заданный изначальный масштаб, а после щелчка левой кнопкой выполнится операция увеличения.
Выглядят нарисованные графики вот так:
Создание класса графика, например, для Windows в MFC выполняется следующим образом:
```
CWnd_Graphics cWnd_Graphics;//класс графиков
CGrData *cGrData_SinPtr;//указатель на данные графика синуса
CGrData *cGrData_CosPtr;//указатель на данные графика косинуса
//создаём график
CRect cRect_Client;
((CStatic*)GetDlgItem(IDC_STATIC_MAIN_MAP))->GetClientRect(&cRect_Client);
cWnd_Graphics.Create(WS_VISIBLE,cRect_Client,(CStatic*)GetDlgItem(IDC_STATIC_MAIN_MAP));
//настраиваем график
cWnd_Graphics.GetIGraphicsPtr()->SetBackGroundColor(CGrColor(192,192,192));
cWnd_Graphics.GetIGraphicsPtr()->SetLegendBackGroundColor(CGrColor(230,230,230));
cWnd_Graphics.GetIGraphicsPtr()->SetAxisColor(CGrColor(0,0,0),CGrColor(0,0,0));
cWnd_Graphics.GetIGraphicsPtr()->SetTextValueColor(CGrColor(0,0,0),CGrColor(0,0,0),CGrColor(0,0,0));
cWnd_Graphics.GetIGraphicsPtr()->SetSelectRectangleColor(CGrColor(0,0,255));
cWnd_Graphics.GetIGraphicsPtr()->SetName("Графики функций");
//создаём графики
cGrData_SinPtr=cWnd_Graphics.GetIGraphicsPtr()->AddNewGraphic();
cGrData_SinPtr->SetEnable(true);
cGrData_SinPtr->SetGrColor(CGrColor(255,0,0));
cGrData_SinPtr->SetGrLineStyle(CGrLineStyle(IVideo::LINE_TYPE_SOLID,1,false,false));
cGrData_SinPtr->SetName("График синуса");
for(size_t n=0;n<1024;n++)
{
double x=n;
double y=sin(x*0.01);
cGrData_SinPtr->AddPoint(x,y);
}
cGrData_CosPtr=cWnd_Graphics.GetIGraphicsPtr()->AddNewGraphic();
cGrData_CosPtr->SetEnable(true);
cGrData_CosPtr->SetGrColor(CGrColor(0,0,255));
cGrData_CosPtr->SetGrLineStyle(CGrLineStyle(IVideo::LINE_TYPE_SOLID,3,false,false));
cGrData_CosPtr->SetName("График косинуса");
for(size_t n=0;n<1024;n++)
{
double x=n;
double y=cos(x*0.01);
cGrData_CosPtr->AddPoint(x,y);
}
//приводим масштаб, чтобы отображались все графики
CGrRect cGrRect;
cWnd_Graphics.GetIGraphicsPtr()->FindViewRectangle(cGrRect);
cWnd_Graphics.GetIGraphicsPtr()->SetRectangle(cGrRect);
cWnd_Graphics.GetIGraphicsPtr()->OnMagnify();
cWnd_Graphics.GetIGraphicsPtr()->GetRectangle(cGrRect);
cWnd_Graphics.GetIGraphicsPtr()->SetOriginalScale(cGrRect);
```
Здесь класс cWnd\_Graphics обеспечивает связку класса графиков CGraphics с Windows, перенаправляя в класс CGraphics события, возникающие в Windows и обеспечивая отображение графика в событии перерисовки ON\_WM\_PAINT. Для других ОС эту связку потребуется переписать, с учётом используемой ОС. В данном примере через cWnd\_Graphics.GetIGraphicsPtr() можно непосредственно обратиться к классу графиков CGraphics и настроить параметры отображения графиков, а так же попросить класс графиков создать новый график и вернуть на него указатель AddNewGraphic (будет получен указатель на класс CGrData). Удалять этот указатель самостоятельно нельзя – график можно удалить только через функцию DeleteGraphic. В дальнейшем работа с графиком выполняется через полученный указатель.
Всего доступны следующие функции управления графиками:
```
CGrData* AddNewGraphic(void);//добавить график и получить указатель на созданный график
void DeleteAllGraphics(void);//удалить все графики из памяти
void DeleteGraphic(CGrData *cGrDataPtr);//удалить график из памяти
void FindRectangle(CGrRect &cGrRect) const;//найти описывающий прямоугольник всех активных графиков
void FindRectangleOfEndPoints(CGrRect &cGrRect,size_t points) const;//найти описывающий прямоугольник всех активных графиков за последние points точек
void FindRectangleOfEndTime(CGrRect &cGrRect,long double time) const;//найти описывающий прямоугольник всех активных графиков за последние time время
void FindViewRectangle(CGrRect &cGrRect) const;//найти описывающий прямоугольник всех активных графиков с запасом по высоте
void FindViewRectangleOfEndPoints(CGrRect &cGrRect,size_t points) const;//найти описывающий прямоугольник всех активных графиков с запасом по высоте за последние points точек
void FindViewRectangleOfEndTime(CGrRect &cGrRect,long double time) const;//найти описывающий прямоугольник всех активных графиков с запасом по высоте за последнее time время
void SetTimeDivider(double value);//установить временной делитель
double GetTimeDivider(void) const;//получить временной делитель
//функции отображения
void CancelSelect(void);//убрать выделение
void Redraw(void);//перерисовать изображение
void RedrawAll(void);//перерисовать всё
void OnOriginalScale(void);//перейти в режим оригинального масштаба
//функции цветовых настроек
void SetBackGroundColor(const CGrColor &cGrColor);//задать цвет фона
void SetLegendBackGroundColor(const CGrColor &cGrColor);//задать цвет фона легенды
void SetAxisColor(const CGrColor &cGrColor_AxisX,const CGrColor &cGrColor_AxisY);//задать цвет осей
void SetGridColor(const CGrColor &cGrColor_GridX,const CGrColor &cGrColor_GridY);//задать цвет сетки
void SetSelectRectangleColor(const CGrColor &cGrColor);//задать цвет прямоугольника выделения
void SetTextValueColor(const CGrColor &cGrColor_TextX,const CGrColor &cGrColor_TextY,const CGrColor &cGrColor_TextLegend);//задать цвет текста
//функции настройки стиля линий
void SetAxisLineStyle(const CGrLineStyle &cGrLineStyle_AxisX,const CGrLineStyle &cGrLineStyle_AxisY);//задать стиль осей
void SetGridLineStyle(const CGrLineStyle &cGrLineStyle_GridX,const CGrLineStyle &cGrLineStyle_GridY);//задать стиль сетки
//функции настройки системы координат
void SetRectangle(const CGrRect &cGrRect);//задать прямоугольник системы координат
void SetGridStep(long double step_x,long double step_y);//задать шаг сетки
void GetRectangle(CGrRect &cGrRect) const;//получить прямоугольник системы координат
void GetGridSize(long double &step_x,long double &step_y) const;//получить оптимальный шаг сетки
//функции дополнительных настроек
void SetEnableMagnify(bool enable);//разрешить увеличение
void SetEnableValue(bool x_value,bool y_value);//разрешить отображение значений
void SetOriginalScale(const CGrRect &cGrRect);//задать оригинальный масштаб
void SetMoveMode(bool inversion);//задать режим инверсии мышки
bool GetSelectedRectangle(CGrRect &cGrRect) const;//вернуть прямоугольник выделения
void GetClientRectangle(CGrRect &cGrRect) const;//вернуть прямоугольник графика
void SetName(const std::string &name);//установить название графика
bool GetUserMode(void) const;//получить режим управления пользователем
void SetUserMode(bool state);//установить режим управления пользователем
```
В принципе, настроить отображение можно достаточно гибко.
Режим управления пользователем, указанный в последних двух функциях, используется при выводе данных с обновлением (скажем, прибор добавляет точки с некоторой частотой). В этом случае при попытке перемещения/увеличения графика включается режим управления пользователем, а при возврате в исходный масштаб этот режим отключается. Это позволяет остановить изменение масштаба во время добавления данных (если режим включён, то просто не надо вызывать пересчёт масштаба, как в примере выше).
[Пример программы, использующей этот модуль (там и исходники модуля).](https://github.com/da-nie/DrawGraphics)
От проекта там 4 файла — main.cpp, cdialog\_main.h, cdialog\_main.cpp и stdafx.h. В этих четырёх файлах и находится пример подключения модуля построения графиков. Все остальные файлы исходников и есть части модуля рисования графиков.
Ну вот, собственно, и всё, что можно сказать об этой примитивной поделке.
P.S. Мне тут подсказали, что я неудачно назвал функции (Graph -график, а Graphic — графика). Извиняюсь, я немецкий язык учил и счёл, что по-английски будет вот так. :) | https://habr.com/ru/post/559236/ | null | ru | null |
# Состоялся стабильный выпуск Midnight Commander 4.7.5
Midnight Commander (MC) — это визуальный консольный файловый менеджер, который позволяет копировать, перемещать и удалять файлы и целые деревья каталогов, искать файлы и запускать команды в своей оболочке. Также включены встроенный просмотрщик и редактор.
На прошлой неделе MC был обновлен. Изменения, начиная с версии 4.7.4 :
* Повтор предыдущего быстрого поиски по Cs Cs (без ввода текста)
* Регистрозависимый порядок сортировки файлов не смешивается с файлами других пользователей, начинающимися с точки.
* Добавлены новые цвета для диалогов и строки состояния
* Добавлено новое действие PanelSmartGotoParentDir
* Встроенный редактор закладок теперь является постоянным и изменения не теряются после выхода из редактора
* Масштабная реорганизация дерева исходного кода и полная расстановка отступов в соответствии с политикой MC
* Новые переводы: баскский, эстонский, грузинский, индонезийский
* Сокрытие панелей перед подключением к файловой системе FISH
* Копирование текста в буфер не сбрасывает текущее выделение текста
* Запоминать текущую позицию поиска после того, как файл был открыт в просмотрщике и переоткрыт в mcedit'оре
* Ускорение движения курсора вниз/вверх
* Добавлен новый темный скин
Полный список изменений находится [на этой странице](http://www.midnight-commander.org/wiki/NEWS-4.7.5).
Для желающих перейти на новую версию, можно использовать WebUpd8 PPA:
`sudo add-apt-repository ppa:nilarimogard/webupd8
sudo apt-get update
sudo apt-get install mc`
Или же [обойтись и без него](http://www.midnight-commander.org/downloads). | https://habr.com/ru/post/111117/ | null | ru | null |
# «Как баран на новые ворота» или пользовательские «псевдо-3D» объекты в NanoCAD с помощью MultiCAD.NET API
На мой взгляд, один из лучших способов научится чему-то это поделится знаниями с другими людьми.
В этот раз мне понадобилось понять, как создаются пользовательские объекты в NanoCAD с помощью MultiCAD.NET API. В блоге компании Нанософт есть статья от 2013 года, в которой объясняются базовые вопросы [создания пользовательских примитивов](https://habrahabr.ru/company/nanosoft/blog/184482/). Но согласитесь было бы не интересно, просто воспроизвести эту статью, поэтому мы ее немного дополним.
В нашем случае мы **создадим псевдотрехмерную дверь**, которая к тому же будет уметь открываться и закрываться. А чтобы нашей маленькой дверке не было одиноко, мы создадим ей подружку — такую же стенку.
Под понятием «псевдо-3D» в данном случае я имею ввиду, что наши объекты не будут обладать свойствами модели твёрдого тела, то есть это будет просто набор связанных геометрических примитивов в трёхмерной системе координат. Может это не совсем корректный термин, но я пока лучше ничего не подобрал.
К сожалению, программистом при всем желании меня сейчас назвать нельзя, поэтому данная статья будет в стиле от новичка-новичкам и наверняка весь код, и приемы, которые вы в ней встретите можно будет улучшить.
Так или иначе если вы интересуетесь: проектированием, САПР, NanoCAD, разработкой под .NET и в частности на C#, а также овцами и **Улицей Сезам**, то возможно эта статья как раз для вас.
Вам тоже интересно причем тут овцы и Улица Сезам? Тогда милости прошу под кат.
[](https://www.youtube.com/watch?v=HWiZj4I8DUY)
Не буду нагнетать драматическую паузу, овцы – это некоторая метафора поясняющая бессмысленность, того чем мы сегодня займемся (картинка чуть позже).
Ну, а Улица Сезам, здесь просто потому, что я недавно про нее вспомнил и меня разбила жуткая ностальгия по куклам «Маппетам», так что они помогут нам выдержать единую стилистику повествования.
Наверное, глупо было так быстро раскрыть всю интригу? Но я надеюсь, что вы все же продолжите читать статью.
Содержание:
[Часть I: С новым CADом! (Введение).](#I)
[Часть II: Пишем код под NanoCAD 8.5](#II)
[Часть III: Пробуем адаптировать код под бесплатный NanoCAD 5.1.](#III)
[Часть IV: МультиКукиш (Заключение)](#IV)
### 1. С новым CADом! (Введение).
Начать хотелось бы с того, что на портале [для разработчиков NanoCAD](http://developer.nanocad.ru/) стала доступна стабильная версия свежего NanoCAD 8.5 SDK и в этот раз мы будем ориентироваться именно на нее.
В своей прошлой статье ориентированной на NanoCAD 8.1, я поделился своим мнением относительно платформы, мы разобрали процесс подготовки проекта к сборке и написали простенькую команду, поэтому если Вы её пропустили и совсем незнакомы с NanoCAD и разработкой с помощью MultiCAD .NET API, то можно начать со статьи [«Лицо без шрама» или первые шаги в Multicad.NET API 7 (для Nanocad 8.1)](https://habrahabr.ru/post/342186/)
В этот раз я планирую поменьше «лить воды» и побольше уделить внимания технической стороне.
Единственное перед тем как перейти к разработке наших объектов скажу, что до начала подготовки этой статьи, я по сути пользовался только бесплатной версий NanoCAD (NC 5.1), которая была выпущена аж в 2013 году.
Причиной этому были две: она полностью бесплатна для любых целей, а вторая причина — у меня весьма слабенький комп, поэтому AutoCAD на нем подтормаживает и чертовски долго грузится.
Но поскольку перед тем как писать эту статью, мне надо был потренироваться «ручками» чертить объект, а также разобратся как работает трехмерный просмотр объекта, ну и самое главное 10000 раз перезапустить CAD в процессе отладки, то я успел чуть-чуть рассмотреть и NanoCAD 8.5.
Так вот на первый взгляд могу сказать следующее, чертить приятней чем в старой бесплатной версии, а грузится также быстро как старый NanoCAD 5.1, то есть NC 8.5 стартует в несколько раз быстрее чем его сверстник — AutoCAD 2017 (если кому любопытно пишите в комментарии, сделаю замер с секундомером). Остается только надеется, что однажды компания обновит бесплатную версию, перенеся в нее новые API и новые фишки в части функций «электронного кульмана».
Ну и последнее, как я понимаю в версиях NanoCAD доступных для разработчиков, включен модуль трехмерного твердотельного моделирования, но я не смог так сходу разобраться с API к нему, особенно для объектов, создаваемых пользователем. Может быть в другой раз мы его изучим. А пока мы будем довольствоваться «псевдо-3D» объектами.
В этом даже есть свое преимущество, наша с вами библиотека после небольшой адаптации запустится и в бесплатном NanoCAD 5.1, где твердотельного моделирования нет и в помине. Но об этом чуть позже.
### 2. Пишем код под NanoCAD 8.5
[](https://www.youtube.com/watch?v=Tka-miw3tvc)
Да, да, граф фон Знак всё верно сосчитал! Забегая вперед именно столько овец, стен и дверей мы получим в конце. Теперь у графа Знака будет новое задание — считать просмотры и голоса за статью. *Я уже прям слышу это: «один, один просмотр, два – два просмотра, три…»*
Как обычно, полный код классов и пример dwg фалов вы найдете на [GitHub](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/2.ForNanoCAD/1.Pseudo_3D_for_NanoCAD).
А сейчас мы начнем разбирать его по частям. Я не стал прилагать готовые сборки, думаю вы сможете собрать проект самостоятельно, [в прошлой статье](https://habrahabr.ru/post/342186/#IV) , я подробно с картинками рассказывал, как создать и настроить проект под MS Visual Studio 2015, для NanoCAD 8.1, так вот с того момента ничего сильно не поменялось.
Поэтому в этот раз я лишь кратко упомяну порядок действий для сборки под Nanocad 8.5:
1. Создать новый проект выбрать платформу .NET Framework 4, в качестве шаблона выбрать библиотеку классов C#.
2. Для версии Нанокада x64 (а у меня такая) из папки SDK\include-x64\ добавить в проект ссылки на: mapibasetypes.dll, mapimgd.dll, imapimgd.dll. Не забудьте для всех трех библиотек свойство копировать локально установить в False.
3. Также добавим ссылки на сборки от Микрософт: System.Windows.Forms.dll, System.Drawing.dll.
4. В свойствах проекта, на вкладке «Отладка», в качестве действия при запуске выберем «открывать во внешней программе» и укажем путь к исполняемому файлу NC 8.5 (у меня — C:\Program Files\Nanosoft\nanoCAD x64 Plus 8.5\nCad.exe)
5. Создадим два класса DoorPseudo3D.cs и WalllPseudo3D.cs для двери и стены соответственно.
6. Перейдем по адресу C:\ProgramData\Nanosoft\nanoCAD x64 Plus 8.5\DataRW (у вас может отличаться) и найдем или создадим файл load.config следующего содержания
```
```
У вас естественно название проекта и путь к нему могут отличаться.
Ну вот и все мы готовы к разработке, теперь у нас по нажатию F5 автоматически запускается NC 8.5 и сразу подгружается наша сборка, останется только вводить разработанные команды.
Еще раз оговорюсь, я не программист, поэтому скорей всего в коде будет куча огрехов: сбои при сохранении, перемещении или копировании объектов, да и просто неоптимальные решения. Если кто-то, не сильно усложняя код сможет эго довести до ума – «земной поклон».
Но так или иначе, на базе этого кода мы с вами сможем немного разобраться в том, как создавать свои объекты, а значит свою главную цель он выполняет.
Ну и безусловно надо сказать большое спасибо Александру Полховскому с форума разработчиков NanoCAD, он мне очень помог с переопределением функционала, связанного с перемещением и поворотом объекта (пригодилось для открытия/закрытия двери). Да и всем другим участникам форума тоже спасибо, напомню это на данный момент один из самых доступных источников информации по MultiCAD.NET API.
Начнем мы с вами со стенки, потому, что она попроще в исполнении.
Для начала добавим пространства имен.
```
using System;
using System.Collections.Generic;
using System.ComponentModel;
using Multicad.Runtime;
using Multicad.DatabaseServices;
using Multicad.Geometry;
using Multicad.CustomObjectBase;
using Multicad;
```
Затем создадим класс пользовательского объекта.
```
namespace nanowall2
{
//change "8b0986c0-4163-42a4-b005-187111b499d7" for your Guid from Assembly.
// Be careful GUID for door and wall classes must be different!
// Otherwise there will be problems with saving and moving
[CustomEntity(typeof(WalllPseudo3D), "8b0986c0-4163-42a4-b005-187111b499d7", "WalllPseudo3D", "WalllPseudo3D Sample Entity")]
[Serializable]
public class WalllPseudo3D : McCustomBase
{
```
Название класса возьмите какое хотите (можно оставить и мое), главное чтобы он наследовал от McCustomBase.
Все атрибуты класса – обязательны, я если честно параметры атрибута CustomEntity не до конца понимаю, поэтому тупо переделал по аналогии.
«8b0986c0-4163-42a4-b005-187111b499d7» — в моем примере это GUID, я видимо «прощелкал» тот момент, где в документации по .NET объяснялось как с ним работать. Могу сказать только одно, я для простоты брал его из файла настроек сборки, заменяя последнюю цифру для обеспечения уникальности. Если GUID у классов двери и стены будет полностью одинаковым, то начнутся чудеса: стены при копировании будут превращаться в двери, а двери после сохранения файла терять свой функционал, у себя я это вроде исправил надеюсь и у вас проблем не будет.
Определим поля класса.
```
private Point3d _pnt1 = new Point3d(100, 100, 0);
private Point3d _pnt2 = new Point3d(500, 100, 0);
private double _h = 2085;
```
Поля \_pnt1 и \_pnt12, это базовые точки по которым будет строится геометрия нашей стены (длина стены по сути), \_h это высота стены по умолчанию (после создания объекта можно будет поправить).
Дальше создадим команду по вызову, которой будет обрисовываться наша дверь.
DrawWall в атрибуте CommandMethod, это имя команды, которое вы будете вводить в командную строку, чтобы вызвать объект, вы можете его сократить например на DWall, без потери функциональности.
```
[CommandMethod("DrawWall", CommandFlags.NoCheck | CommandFlags.NoPrefix)]
public void DrawWall() {
WalllPseudo3D wall = new WalllPseudo3D();
wall.PlaceObject();
}
```
Мы в классе реализующем нашу команду создаем новый экземпляр класса стена (если этого не сделать, то у меня все стенки начинают восприниматься как одна «убер» стенка). А метод PlaceObject мы определим чуть позже.
Определим процедуру отрисовки объекта.
```
public override void OnDraw(GeometryBuilder dc)
{
dc.Clear();
```
Я не полностью понимаю этот кусок, но так или иначе в API есть класс GeometryBuilder, на основании, которого мы и будем дальше ваять нашу стенку.
Dc.Clear, по всей видимости очищает каждый раз всю ранее построенную для экземпляра класса геометрию.
Дальше проще.
```
Point3d pnt1 = _pnt1;
Point3d pnt2 = new Point3d(_pnt2.X, pnt1.Y, 0);
Point3d pnt3 = new Point3d(pnt2.X, pnt1.Y+150, 0);
Point3d pnt4 = new Point3d(pnt1.X , pnt3.Y, 0);
// Set the color to ByObject value
dc.Color = McDbEntity.ByObject;
Vector3d hvec = new Vector3d(0, 0, _h);
```
Мы определяем четыре базовые точки на основании которых будет строится основание и верхушка стены, причем первая и вторая точка увязываются с полями класса, а значит именно ими мы потом и будем манипулировать. Наша стенка в длину будет строиться по расстоянию между точками \_pnt1 и pnt2, а вот ширина стенки задана жестко её поправить нельзя (так сделано для простоты), но вы легко можете переопределить логику работы по аналогии.
dc.Color – похоже задает свойство «цвет по блоку» для объекта.
Вектор hvec это высота нашей стенки, которую мы будем прибавлять к основанию, чтобы построить верхушку.
Дальше чертим нижнюю и верхнюю стороны стенки.
```
dc.DrawPolyline(new Point3d[] { pnt1, pnt2, pnt3, pnt4, _pnt1 });
dc.DrawPolyline(new Point3d[] { _pnt1.Add(hvec),
pnt2.Add(hvec), pnt3.Add(hvec), pnt4.Add(hvec), pnt1.Add(hvec)});
```
Соединяем низ и верх ребрами.
```
dc.DrawLine(pnt1, pnt1.Add(hvec));
dc.DrawLine(pnt2, pnt2.Add(hvec));
dc.DrawLine(pnt3, pnt3.Add(hvec));
dc.DrawLine(pnt4, pnt4.Add(hvec));
```
Создаем контур из поллиний для штриховки и затем заливаем его штриховкой кирпич (названия штриховок можно посмотреть в самой программе). Причем у меня не получилось заштриховать через список полилиний пришлось повторять процедуру два раза. Думаю, я что-то не учел.
Мы с вами штрихуем только 2 поверхности стенки — самые длинные, если захотите можете самостоятельно заштриховать остальное.
```
// Create contours for the front and rear sides and hatch them
// In this demo, we hatch only two sides, you can tailor the others yourself
List c1 = new List();
c1.Add(new Polyline3d(
new List() { pnt1, pnt1.Add(hvec), pnt2.Add(hvec), pnt2, pnt1, }));
dc.DrawGeometry(new Hatch(c1, "BRICK", 0, 20, false, HatchStyle.Normal, PatternType.PreDefined, 30), 1);
List c2 = new List();
c2.Add(new Polyline3d(
new List() { pnt4, pnt4.Add(hvec), pnt3.Add(hvec), pnt3, pnt4, }));
dc.DrawGeometry(new Hatch(c2, "BRICK", 0, 20, false, HatchStyle.Normal, PatternType.PreDefined, 30), 1);
}
```
Определим пользовательское свойство для объекта, поскольку на мой взгляд чертить удобней в двухмерном виде, то высоту стенки в момент черчения выставлять не удобно, можно было сделать установку высоты стенки как часть процедуры ее отрисовки, но мы пойдем более простым путем, просто добавим свойство, с помощью которого будем менять высоту уже после того как её начертим.
```
//Define the custom properties of the object
[DisplayName("Height")]
[Description("Height of wall")]
[Category("Wall options")]
public double HWall
{
get
{
return _h;
}
set
{
//Save Undo state and set the object status to "Changed"
if (!TryModify())
return;
_h = value;
}
}
```
По атрибутам [DisplayName(«Height»)] – имя которое будет в окне свойств, [Description(«Height of wall»)], это описание, но я не понял, где оно отображается, [Category(«Wall options»)] – категория полей, как вы позже увидите на примере дверей, наши поля модно сгруппировать для удобства.
Ну а дальше идет обычно свойство, если вы когда-нибудь делали публичные свойства в Unity 3D, то механизм похож, можем иметь доступ к полям класса прямо из редактора (в нашем случае из САПР).
TryModify() – это обязательный метод, его надо вызывать перед каждым изменением свойств объекта, как я понял. Мы с ним еще пару раз встретимся.
Дальше переопределяем метод отвечающий за размещение объекта на чертеже (помните мы его раньше командой вызывали).
```
public override hresult PlaceObject(PlaceFlags lInsertType)
{
InputJig jig = new InputJig();
// Get the first box point from the jig
InputResult res = jig.GetPoint("Select first point:");
if (res.Result != InputResult.ResultCode.Normal)
return hresult.e_Fail;
_pnt1 = res.Point;
// Add the object to the database
this.DbEntity.AddToCurrentDocument();
//Exclude the object from snap points
jig.ExcludeObject(ID);
// Monitoring mouse moving and interactive entity redrawing
jig.MouseMove = (s, a) => { TryModify(); _pnt2 = a.Point; this.DbEntity.Update(); };
// Get the second box point from the jig
res = jig.GetPoint("Select second point:");
if (res.Result != InputResult.ResultCode.Normal)
{
this.DbEntity.Erase();
return hresult.e_Fail;
}
_pnt2 = res.Point;
return hresult.s_Ok;
}
```
Этот код почти полностью позаимствован из примера от Нанософт о котором я упоминал в первой главе, я его не на 100% понимаю, но если вкратце мы вызываем команду для ввода первой точки стены (jig.GetPoint), затем помещаем её в чертеж (DbEntity.AddToCurrentDocument()), после чего исключаем объект из привязок, чтобы он нам не мешал вводить вторую точку (\_pnt2).
Если все нормально, то объект размещается в чертеже, если нет (например не завершён ввод), то объект удаляется.
И последнее делаем ручки для изменения размера стенки.
```
// Create a grip for the base point of the object
public override bool GetGripPoints(GripPointsInfo info)
{
info.AppendGrip(new McSmartGrip(\_pnt1, (obj, g, offset) => { obj.TryModify(); obj.\_pnt1 += offset; }));
info.AppendGrip(new McSmartGrip(\_pnt2, (obj, g, offset) => { obj.TryModify(); obj.\_pnt2 += offset; }));
return true;
}
}
// TODO: There are many shortcomings in this code.
// Including failures when working with copying, moving objects and saving files, you can improve it if you want.
}
```
Как я понимаю, код из примера который я упоминал выше, в части ручек устарел (для NC 8.X) и лучше ориентироваться на код [из этого примера](https://habrahabr.ru/company/nanosoft/blog/234181/).
Ну и естественно я предупреждаю, вас что мой код далек от идеала поэтому адекватным, вменяемым правкам буду рад.
Теперь рассмотрим дверь. Начало — аналогичное.
```
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows.Forms;
using Multicad.Runtime;
using Multicad.DatabaseServices;
using Multicad.Geometry;
using Multicad.CustomObjectBase;
using Multicad;
namespace nanodoor2
{
//change "8b0986c0-4163-42a4-b005-187111b499d7" for your Guid from Assembly.
// Be careful GUID for door and wall classes must be different!
// Otherwise there will be problems with saving and moving
[CustomEntity(typeof(DoorPseudo3D), "8b0986c0-4163-42a4-b005-187111b499d9", "DoorPseudo3D", "DoorPseudo3D Sample Entity")]
[Serializable]
public class DoorPseudo3D : McCustomBase
{
// First and second vertices of the box
private Point3d _pnt1 = new Point3d(0, 0, 0);
private double _h = 2085;
private Vector3d _vecStraightDirection = new Vector3d(1, 0, 0);
private Vector3d _vecDirectionClosed = new Vector3d(1, 0, 0);
public enum status { closed , middle, open };
private status _dStatus = status.closed;
[CommandMethod("DrawDoor", CommandFlags.NoCheck | CommandFlags.NoPrefix)]
public void DrawDoor() {
DoorPseudo3D door = new DoorPseudo3D();
door.PlaceObject();
}
```
Разве что добавилось поле, которое будет отвечать за то открыта или закрыта наша дверь, а также появлюсь два вектора \_vecStraightDirection — отвечает за текущий поворот двери, \_vecDirectionClosed — хранит данные о повороте двери в закрытом состоянии. Это нам все пригодится позже.
А вот непосредственно в геометрии двери, как и следовало ожидать есть маленькие изменения.
```
public override void OnDraw(GeometryBuilder dc)
{
dc.Clear();
// Define the basic points for drawing
Point3d pnt1 = new Point3d(0, 0, 0);
Point3d pnt2 = new Point3d(pnt1.X + 984, pnt1.Y, 0);
Point3d pnt3 = new Point3d(pnt2.X + 0, pnt1.Y+50, 0);
Point3d pnt4 = new Point3d(pnt1.X , pnt3.Y, 0);
// Set the color to ByObject value
dc.Color = McDbEntity.ByObject;
Vector3d hvec = new Vector3d(0, 0, _h);
// Draw the upper and lower sides
dc.DrawPolyline(new Point3d[] { pnt1, pnt2, pnt3, pnt4, pnt1 });
dc.DrawPolyline(new Point3d[] { pnt1.Add(hvec),
pnt2.Add(hvec), pnt3.Add(hvec), pnt4.Add(hvec), pnt1.Add(hvec)});
// Draw the edges
dc.DrawLine(pnt1, pnt1.Add(hvec));
dc.DrawLine(pnt2, pnt2.Add(hvec));
dc.DrawLine(pnt3, pnt3.Add(hvec));
dc.DrawLine(pnt4, pnt4.Add(hvec));
// Drawing a Door Handle
dc.DrawLine(pnt2.Add(new Vector3d( - 190, -0, _h*0.45)),
pnt2.Add(new Vector3d(-100, 0, _h * 0.45)));
dc.DrawLine(pnt3.Add(new Vector3d(-190, 0, _h * 0.45)),
pnt3.Add(new Vector3d(-100, 0, _h * 0.45)));
// Create contours for the front and rear sides and hatch them
// In this demo, we hatch only two sides, you can tailor the others yourself
List c1 = new List();
c1.Add(new Polyline3d(
new List() { pnt1, pnt1.Add(hvec), pnt2.Add(hvec), pnt2, pnt1, }));
List c2 = new List();
c2.Add(new Polyline3d(
new List() { pnt4, pnt4.Add(hvec), pnt3.Add(hvec), pnt3, pnt4, }));
dc.DrawGeometry(new Hatch(c1, "JIS\_WOOD", 0, 170, false, HatchStyle.Normal, PatternType.PreDefined, 500), 1);
dc.DrawGeometry(new Hatch(c2, "JIS\_WOOD", 0, 170, false, HatchStyle.Normal, PatternType.PreDefined, 500), 1);
}
```
Во-первых, обратите внимание, что мы строим дверь по одной точке, то есть размер двери по ширине и высоте у нас жестко закреплен (ну чтобы она от стены отличалась). Также добавилась секция «// Drawing a Door Handle», там 2 линии которые обозначают условную ручку, ну и еще тип штриховки мы заменили на JIS\_WOOD
А вот метод PlaceObject у нас упростился, за счет того, что не нужна вторая ручка.
```
public override hresult PlaceObject(PlaceFlags lInsertType)
{
InputJig jig = new InputJig();
// Get the first box point from the jig
InputResult res = jig.GetPoint("Select first point:");
if (res.Result != InputResult.ResultCode.Normal)
return hresult.e_Fail;
_pnt1 = res.Point;
// Add the object to the database
DbEntity.AddToCurrentDocument();
return hresult.s_Ok;
}
```
Дальше идет полная новинка по отношению к классу стенки. За которую я в начале статьи поблагодарил Александра.
Ниже мы переопределим метод, который каким-то мистическим образом отвечает за создании матрицы трансформации (перемещения и поворота) нашей двери.
```
///
/// Method for changing the object's SC (the graph is built at the origin of coordinates).
///
/// The matrix for changing the position of the object.
/// True - if the matrix is passed, False - if not.
public override bool GetECS(out Matrix3d tfm)
{
// Create a matrix that transforms the object.
// The object is drawn in coordinates(0.0), then it is transformed with the help of this matrix.
tfm = Matrix3d.Displacement(this._pnt1.GetAsVector()) * Matrix3d.Rotation
(-this._vecStraightDirection.GetAngleTo(Vector3d.XAxis, Vector3d.ZAxis), Vector3d.ZAxis, Point3d.Origin);
return true;
}
```
Я не полностью понимаю работу этого метода, но похоже при каждом перемещении он преобразует нашу дверь в зависимости от базовой точки и вектора поворота, это в конечном счете позволяет нам открывать или закрывать дверь на чертеже.
Дальше мы переопределяем событие которое похоже наступает при трансформации объекта.
```
public override void OnTransform(Matrix3d tfm)
{
// To be able to cancel(Undo)
McUndoPoint undo = new McUndoPoint();
undo.Start();
// Get the coordinates of the base point and the rotation vector
this.TryModify();
this._pnt1 = this._pnt1.TransformBy(tfm);
this.TryModify();
this._vecStraightDirection = this._vecStraightDirection.TransformBy(tfm);
// We move the door only when it is closed if not - undo
if (_dStatus == status.closed) _vecDirectionClosed = _vecStraightDirection;
else
{
MessageBox.Show("Please transform only closed door");
undo.Undo();
}
undo.Stop();
}
```
Для начала скажу, что чтобы не застревать с разработкой, некоторые моменты я упрощал, особенно те решения, которые мне давались с трудом. Одно из таких упрощений — это ограничение на манипуляции с дверью.
Двигать, поворочать, копировать и как-либо еще изменять дверь можно только в закрытом состоянии (оно установлено по умолчанию).
Для того, чтобы оно так и работало мы создаем объект undo и отмечаем точку старта для фиксации изменений.
После чего если все нормально передаем точке \_pnt1 и вектору .\_vecStraightDirection их состояние после трансформации.
Затем идет проверка условия, если дверь была закрыта, то изменения применяются и дополнительно заносятся в вектор который хранит данные о положении закрытой двери.
Если дверь была открыта (или приоткрыта) мы выдаем сообщение об ошибке и отменяем все изменения.
Поле высоты двери – аналогично стене.
```
//Define the custom properties of the object
[DisplayName("Height")]
[Description("Height of door")]
[Category("Door options")]
public double HDoor
{
get
{
return _h;
}
set
{
//Save Undo state and set the object status to "Changed"
if (!TryModify())
return;
_h = value;
}
}
```
А вот следующее поле – новенькое
```
[DisplayName("Door status")]
[Description("Door may be: closed, middle, open")]
[Category("Door options")]
public status Stat
{
get
{
return _dStatus;
}
set
{
//Save Undo state and set the object status to "Changed"
if (!TryModify())
return;
// Change the rotation vector for each of the door states
switch (value)
{
case status.closed:
_vecStraightDirection = _vecDirectionClosed;
break;
case status.middle:
_vecStraightDirection = _vecDirectionClosed.Add(_vecDirectionClosed.GetPerpendicularVector().Negate() * 0.575) ;
break;
case status.open:
_vecStraightDirection = _vecDirectionClosed.GetPerpendicularVector()*-1;
break;
default:
_vecStraightDirection = _vecDirectionClosed;
break;
}
_dStatus = value;
}
}
```
Именно оно у нас и отвечает за состояние двери, в окне свойств появляется выпадающий список со значениями: closed, middle, open (один в один, как определение перечисления вначале класса).
При выборе каждого из значений изменяется в конечном счете вектор отвечающий за поворот двери.
При закрытой он выставляется в заранее сохранённое состояние \_vecDirectionClosed;
При полуоткрытом состоянии получается результирующий вектор, который поворачивает нашу дверь на угол примерно 30 градусов, чтобы было похоже на обозначение по ГОСТ.
При открытом состоянии мы просто берем перпендикуляр к нашему вектору закрытого состояния с отрицательным значением (чтобы дверь открывалась по умолчанию вниз).
Дефолтный случай думаю не нужен вовсе, но я оставил.
Ну и последнее это ручка для манипулирования.
```
// Create a grip for the base point of the object
public override bool GetGripPoints(GripPointsInfo info)
{
info.AppendGrip(new McSmartGrip(\_pnt1, (obj, g, offset) => { obj.TryModify(); obj.\_pnt1 += offset; }));
return true;
}
// TODO: There are many shortcomings in this code.
// Including failures when working with copying, moving objects and saving files, you can improve it if you want.
}
```
За нее можно перетаскивать и все. Ручки у меня время от времени у обоих объектов скачут, куда попало, но отлаживать это у меня уже нет сил (я думал, что закончу статью быстрее, а убил уже три полных дня).
Итак, жмем F5 и с помощью команд DRAWWALL и DRAWDOOR вставляем наши двери и стены.
В результате получим то что на рисунке. На нём я демонстрирую вам работу библиотеки с 4-х разных ракурсов. Овцы к сожалению плоские, да и чертил я их от руки. Ну и двери со стенками чуть-чуть отличаются от тех, что в последней версии .dwg файла на GitHub, просто внес пару правок, а переснимать снимки экрана было лень.
*Если будете загружать вашу библиотеку вручную командой NETLOAD помните, что она должна быть загружена до открытия файла с нашими объектами, или они распознаются как proxy объекты.*
Для тех, кто новичок в работе с Нанокад, напомню, что получить трехмерный вид на ваши объекты удобно сделав так: вид-> орбита-> зависимая орбита, а вернуть двухмерный вид назад, можно так: вид-> виды и проекции-> вид в плане-> текущая ПСК.
### 3. Пробуем адаптировать код под бесплатный NanoCAD 5.1.
В прошлой статье, у меня почему-то не заработала команда рисующая лицо, а вот в этот раз удалось адаптировать код и наш объект с небольшими ограничениями запускается и в бесплатной версии NanoCAD 5.1.
Для начала кратко расскажу, как настроить среду, отличий почти никаких.
Поэтому я опять лишь кратко упомяну порядок действий для сборки под Nanocad 5.1:
1. Создать новый проект выбрать платформу .NET Framework 3.5, в качестве шаблона выбрать библиотеку классов C#.
2. Для версии Нанокада x32 (а 5.1 только такая) из папки SDK\include\ добавить в проект ссылку на: mapimgd. Не забудьте свойство копировать локально установить в False.
3. Также добавим ссылки на сборки от Микрософт: System.Windows.Forms.dll, System.Drawing.dll.
4. В свойствах проекта, на вкладке «Отладка», в качестве действия при запуске выберем «открывать во внешней программе» и укажем путь к исполняемому файлу NC 5.1 (у меня — C:\Program Files (x86)\Nanosoft\nanoCAD 5.1\nCad.exe)
5. Я еще до кучи в разделе «Сборка» установил конечную платформу – x86.
6. Создадим два класса DoorPseudo3D\_nc51.cs и WalllPseudo3D\_nc51.cs для двери и стены соответственно.
7. Перейдем по C:\ProgramData\Nanosoft\nanoCAD 5.1\DataRW (у вас может отличаться) и найдем или создадим файл load.config следующего содержания
```
```
У вас пути к файлам будут свои.
Код кардинально различаться не будет поэтому я спрячу под спойлер оба класса и поясню, только различия.
Итак, стена:
**Полный код для стены**
```
//Use Microsoft .NET Framework 3.5 and old version of MultiCad.NET (for NC 5.1)
//Class for demonstrating the capabilities of MultiCad.NET
//Assembly for the Nanocad 5.1
//Link mapimgd from Nanocad SDK
//Link System.Windows.Forms and System.Drawing
//The commands: draws a pseudo 3D wall.
//This code in the part of non-infringing rights Nanosoft can be used and distributed in any accessible ways.
//For the consequences of the code application, the developer is not responsible.
//More detailed - https://habrahabr.ru/post/342680/
using System;
using System.ComponentModel;
using Multicad.Runtime;
using Multicad.DatabaseServices;
using Multicad.Geometry;
using Multicad.CustomObjectBase;
using Multicad;
namespace nanowall2
{
//change "8b0986c0-4163-42a4-b005-187111b499d7" for your Guid from Assembly.
// Be careful GUID for door and wall classes must be different!
// Otherwise there will be problems with saving and moving
[CustomEntity(typeof(WalllPseudo3D_nc51), "b4edac1f-7978-483f-91b1-10503d20735a", "WalllPseudo3D_nc51", "WalllPseudo3D_nc51 Sample Entity")]
[Serializable]
public class WalllPseudo3D_nc51 : McCustomBase
{
// First and second vertices of the box
private Point3d _pnt1 = new Point3d(100, 100, 0);
private Point3d _pnt2 = new Point3d(500, 100, 0);
private double _h = 2085;
private double _scale = 1000;
[CommandMethod("DrawWall", CommandFlags.NoCheck | CommandFlags.NoPrefix)]
public void DrawWall() {
WalllPseudo3D_nc51 wall = new WalllPseudo3D_nc51();
wall.PlaceObject();
}
public override void OnDraw(GeometryBuilder dc)
{
dc.Clear();
// Define the basic points for drawing
Point3d pnt1 = _pnt1;
Point3d pnt2 = new Point3d(_pnt2.X, pnt1.Y, 0);
Point3d pnt3 = new Point3d(pnt2.X, pnt1.Y+(150 * _scale), 0);
Point3d pnt4 = new Point3d(pnt1.X , pnt3.Y, 0);
// Set the color to ByObject value
dc.Color = McDbEntity.ByObject;
Vector3d hvec = new Vector3d(0, 0, _h * _scale);
// Draw the upper and lower sidestes
dc.DrawPolyline(new Point3d[] { pnt1, pnt2, pnt3, pnt4, pnt1 });
dc.DrawPolyline(new Point3d[] { _pnt1.Add(hvec),
pnt2.Add(hvec), pnt3.Add(hvec), pnt4.Add(hvec), pnt1.Add(hvec)});
// Draw the edges
dc.DrawLine(pnt1, pnt1.Add(hvec));
dc.DrawLine(pnt2, pnt2.Add(hvec));
dc.DrawLine(pnt3, pnt3.Add(hvec));
dc.DrawLine(pnt4, pnt4.Add(hvec));
}
//Define the custom properties of the object
[DisplayName("WScale")]
[Description("Wall Scale")]
[Category("Wall options")]
public double WScale
{
get
{
return _scale;
}
set
{
if (!TryModify())
return;
_scale = value;
}
}
[DisplayName("Height")]
[Description("Height of wall")]
[Category("Wall options")]
public double HWall
{
get
{
return _h;
}
set
{
//Save Undo state and set the object status to "Changed"
if (!TryModify())
return;
_h = value;
}
}
public override hresult PlaceObject(PlaceFlags lInsertType)
{
InputJig jig = new InputJig();
// Get the first box point from the jig
InputResult res = jig.GetPoint("Select first point:");
if (res.Result != InputResult.ResultCode.Normal)
return hresult.e_Fail;
_pnt1 = res.Point;
// Add the object to the database
this.DbEntity.AddToCurrentDocument();
//Exclude the object from snap points
jig.ExcludeObject(ID);
// Monitoring mouse moving and interactive entity redrawing
jig.MouseMove = (s, a) => { TryModify(); _pnt2 = a.Point; this.DbEntity.Update(); };
// Get the second box point from the jig
res = jig.GetPoint("Select second point:");
if (res.Result != InputResult.ResultCode.Normal)
{
this.DbEntity.Erase();
return hresult.e_Fail;
}
_pnt2 = res.Point;
return hresult.s_Ok;
}
// Create a grip for the base point of the object
public override bool GetGripPoints(GripPointsInfo info)
{
info.AppendGrip(new McSmartGrip(\_pnt1, (obj, g, offset) => { obj.TryModify(); obj.\_pnt1 += offset; }));
info.AppendGrip(new McSmartGrip(\_pnt2, (obj, g, offset) => { obj.TryModify(); obj.\_pnt2 += offset; }));
return true;
}
}
// TODO: There are many shortcomings in this code.
// Including failures when working with copying, moving objects and saving files, you can improve it if you want.
}
```
В чем разница, во-первых, когда я пытался вставлять объекты в пустой чертеж, то Нанокад мне его так масштабировал, что было не видно ни стенку ни дверь и я добавил поле с масштабом.
Для стены оно изменяет толщину стены, а для двери — толщину и длину.
Соответственно нужные координаты теперь домножаются на масштаб, для которого есть открытое свойство.
И второе отличие в старой версии MultiCAD.NET API — нет класса для работы со штриховкой, могу предположить, что её можно реализовать через API для обычного .NET, но я не стал.
Теперь дверь:
**Полный код для двери**
```
//Use Microsoft .NET Framework 3.5 and old version of MultiCad.NET (for NC 5.1)
//Class for demonstrating the capabilities of MultiCad.NET
//Assembly for the Nanocad 5.1
//Link mapimgd from Nanocad SDK
//Link System.Windows.Forms and System.Drawing
//The commands: draws a pseudo 3D door.
//This code in the part of non-infringing rights Nanosoft can be used and distributed in any accessible ways.
//For the consequences of the code application, the developer is not responsible.
//More detailed - https://habrahabr.ru/post/342680/
// P.S. A big thanks to Alexander Vologodsky for help in developing a method for pivoting object.
using System;
using System.ComponentModel;
using System.Windows.Forms;
using Multicad.Runtime;
using Multicad.DatabaseServices;
using Multicad.Geometry;
using Multicad.CustomObjectBase;
using Multicad;
namespace nanodoor2
{
//change "8b0986c0-4163-42a4-b005-187111b499d7" for your Guid from Assembly.
// Be careful GUID for door and wall classes must be different!
// Otherwise there will be problems with saving and moving
[CustomEntity(typeof(DoorPseudo3D_nc51), "b4edac1f-7978-483f-91b1-10503d20735b", "DoorPseudo3D_nc51", "DoorPseudo3D_nc51 Sample Entity")]
[Serializable]
public class DoorPseudo3D_nc51 : McCustomBase
{
// First and second vertices of the box
private Point3d _pnt1 = new Point3d(0, 0, 0);
private double _scale = 1000;
private double _h = 2085;
private Vector3d _vecStraightDirection = new Vector3d(1, 0, 0);
private Vector3d _vecDirectionClosed = new Vector3d(1, 0, 0);
public enum status { closed , middle, open };
private status _dStatus = status.closed;
[CommandMethod("DrawDoor", CommandFlags.NoCheck | CommandFlags.NoPrefix)]
public void DrawDoor() {
DoorPseudo3D_nc51 door = new DoorPseudo3D_nc51();
door.PlaceObject();
}
public override void OnDraw(GeometryBuilder dc)
{
dc.Clear();
// Define the basic points for drawing
Point3d pnt1 = new Point3d(0, 0, 0);
Point3d pnt2 = new Point3d(pnt1.X + (984 * _scale), pnt1.Y, 0);
Point3d pnt3 = new Point3d(pnt2.X + 0, pnt1.Y+(50 * _scale), 0);
Point3d pnt4 = new Point3d(pnt1.X , pnt3.Y, 0) ;
// Set the color to ByObject value
dc.Color = McDbEntity.ByObject;
Vector3d hvec = new Vector3d(0, 0, _h * _scale) ;
// Draw the upper and lower sides
dc.DrawPolyline(new Point3d[] { pnt1, pnt2, pnt3, pnt4, pnt1 });
dc.DrawPolyline(new Point3d[] { pnt1.Add(hvec),
pnt2.Add(hvec), pnt3.Add(hvec), pnt4.Add(hvec), pnt1.Add(hvec)});
// Draw the edges
dc.DrawLine(pnt1, pnt1.Add(hvec));
dc.DrawLine(pnt2, pnt2.Add(hvec));
dc.DrawLine(pnt3, pnt3.Add(hvec));
dc.DrawLine(pnt4, pnt4.Add(hvec));
// Drawing a Door Handle
dc.DrawLine(pnt2.Add(new Vector3d( -190 * _scale, -0, _h*0.45 * _scale)),
pnt2.Add(new Vector3d(-100 * _scale, 0, _h * 0.45 * _scale)));
dc.DrawLine(pnt3.Add(new Vector3d(-190 * _scale, 0, _h * 0.45 * _scale)),
pnt3.Add(new Vector3d(-100 * _scale, 0, _h * 0.45 * _scale)));
}
public override hresult PlaceObject(PlaceFlags lInsertType)
{
InputJig jig = new InputJig();
// Get the first box point from the jig
InputResult res = jig.GetPoint("Select first point:");
if (res.Result != InputResult.ResultCode.Normal)
return hresult.e_Fail;
_pnt1 = res.Point;
// Add the object to the database
DbEntity.AddToCurrentDocument();
return hresult.s_Ok;
}
///
/// Method for changing the object's SC (the graph is built at the origin of coordinates).
///
/// The matrix for changing the position of the object.
/// True - if the matrix is passed, False - if not.
public override bool GetECS(out Matrix3d tfm)
{
// Create a matrix that transforms the object.
// The object is drawn in coordinates(0.0), then it is transformed with the help of this matrix.
tfm = Matrix3d.Displacement(this._pnt1.GetAsVector()) * Matrix3d.Rotation
(-this._vecStraightDirection.GetAngleTo(Vector3d.XAxis, Vector3d.ZAxis), Vector3d.ZAxis, Point3d.Origin);
return true;
}
public override void OnTransform(Matrix3d tfm)
{
// To be able to cancel(Undo)
McUndoPoint undo = new McUndoPoint();
undo.Start();
// Get the coordinates of the base point and the rotation vector
this.TryModify();
this._pnt1 = this._pnt1.TransformBy(tfm);
this.TryModify();
this._vecStraightDirection = this._vecStraightDirection.TransformBy(tfm);
// We move the door only when it is closed if not - undo
if (_dStatus == status.closed) _vecDirectionClosed = _vecStraightDirection;
else
{
MessageBox.Show("Please transform only closed door (when its status = 0)");
undo.Undo();
}
undo.Stop();
}
//Define the custom properties of the object
[DisplayName("Height")]
[Description("Height of door")]
[Category("Door options")]
public double HDoor
{
get
{
return _h;
}
set
{
//Save Undo state and set the object status to "Changed"
if (!TryModify())
return;
_h = value;
}
}
[DisplayName("DScale")]
[Description("Door Scale")]
[Category("Door options")]
public double DScale
{
get
{
return _scale;
}
set
{
if (!TryModify())
return;
_scale = value;
}
}
[DisplayName("Door status")]
[Description("0-closed, 1-midle, 2-open")]
[Category("Door options")]
public status Stat
{
get
{
return _dStatus;
}
set
{
//Save Undo state and set the object status to "Changed"
if (!TryModify())
return;
// Change the rotation vector for each of the door states
switch (value)
{
case status.closed:
_vecStraightDirection = _vecDirectionClosed;
break;
case status.middle:
_vecStraightDirection = _vecDirectionClosed.Add(_vecDirectionClosed.GetPerpendicularVector().Negate() * 0.575) ;
break;
case status.open:
_vecStraightDirection = _vecDirectionClosed.GetPerpendicularVector()*-1;
break;
default:
break;
}
_dStatus = value;
}
}
// Create a grip for the base point of the object
public override bool GetGripPoints(GripPointsInfo info)
{
info.AppendGrip(new McSmartGrip(\_pnt1, (obj, g, offset) => { obj.TryModify(); obj.\_pnt1 += offset; }));
return true;
}
}
// TODO: There are many shortcomings in this code.
// Including failures when working with copying, moving objects and saving files, you can improve it if you want.
}
```
Опять почти все тоже самое, единственное, в версии 5.1 похоже поле по-другому обрабатывает перечисления и в окошке свойств объекта вместо слов closed/open, мы увидим значения перечисления: 0, 1, 2 это не очень наглядно, поэтому мы немножко изменили предупреждение об ошибке. Также у двери нет штриховки и есть лишнее свойство для масштаба (его кстати при желании можно реализовать и в классах для NC 8.5).
Получится примерно так:
### 4. МультиКукиш (Заключение)
[](https://www.youtube.com/watch?v=ei1DvIgW_PU)
Как вы помните из прошлой статьи, я и Нанософт никак не связаны, а значит могу себе позволить небольшой элемент критики. Разработчики заявляют о поддержке MultiCAD.NET API в AutoCAD и ZWCAD через определенную прослойку, есть даже [статья про это](https://habrahabr.ru/company/nanosoft/blog/242497/).
Но похоже, это неприоритетное направление разработки. В [прошлой статье я писал](https://habrahabr.ru/post/342186/#V), что не смог протестировать эту функцию потому, что у меня на компьютере установлен AutoCAD 2017, а последняя размещенная на сайте разработчиков прослойка — «MultiCAD\_AC\_ZC\_Enabler\_2209\_RU.zip» (которой уже 1.5 года), не поддерживает ничего старше AutoCAD 2016. Ставить ради такого удовольствия еще одну версию Автокада мне не захотелось.
В этот раз я решил попробовать другой вариант, скачал пробную версию ZWCAD+ 2015, опять-таки последнюю версию, которую поддерживает данная прослойка. Не знаю, может быть я «рукожоп», но ни эта библиотека, ни библиотека из прошлой статьи у меня так и не «взлетела» в ZWCAD. Поэтому если у кого-то получится запустить, и он поделится скриншотом буду признателен.
Ну а в остальном, надо сказать, что чем больше возишься с этим API тем больше втягиваешься и даже начинает понемногу нравится, заметно что API улучшается, часть членов классов API уже имеет вменяемое описание на русском, да и само по себе API становится более самодостаточным.
Думаю, что когда выйдет NanoCAD 9 (или как его там назовут) с поддержкой DWG 2018, то станет еще лучше (особенно если как обещали на форуме разработчики, за ним следом выйдет новый бесплатный [Нанокад](http://forum.nanocad.ru/index.php?showtopic=7837)).
Так что хочется сказать всем участникам форума разработчиков Нанокад — спасибо за помощь, разработчикам — спасибо за то, что выложили NC 8.5, а всем читателям — спасибо за то, что осилили статью до конца.
**P.S.** Изначально у статьи в заголовке должна была быть другая картинка, но я решил, что она «не айс» и в итоге заменил её на политкорректных Кермита и Гровера (кстати часть картинок ведут на те видео, что я смог найти). А вот исходную картинку я решил спрятать в конце статьи под…
**...спойлером** | https://habr.com/ru/post/342680/ | null | ru | null |
# AI пати в Siliconовой Долине: мэр, миллиардер, президенты, гении, разработчики процессоров и девушка с яркими волосами
В прошлом году в российской и украинской прессе прошла волна статей о вечеринках в Кремниевой долине, с какой-то голливудской атмосферностью, но без указания конкретных имен, фотографий и без описания связанных с этими именами технологий разработки аппаратного и написания программного обеспечения. Эта статья — другая! В ней тоже будут миллиардеры, гении и девушки, но с фотографиями, слайдами, схемами и фрагментами программного кода. Итак:
На днях мэр города Кэмпбелл, c русской фамилией Paul Resnikoff, разрезал ленточку при открытии нового офиса стартапа Wave Computing, который вместе с компанией Broadcom разрабатывает 7-нанометровый чип для ускорения вычислений нейросетей. Офис находится в здании исторической фруктово-консервной фабрики конца 19-начала 20 века, когда Кремниевая Долина представляла собой самый большой фруктовый сад в мире. Уже тогда в офисе занимались инновациями, вводили первые в абрикосово-сливовой индустрии электромоторы для конвейеров, за которыми трудились около 200 работников, в основном женщин.
На последующей за разрезанием ленточки парти засветилось много известных в индустрии людей, в частности соратник Кернигана-Ричи и автор самого популярного C компилятора конца 70-х — начала 80-х годов Стивен Джонсон, один из авторов стандарта чисел с плавающей точкой Джероми Кунен, изобретатель концепции локальной шины и разработчик чипсетов первых PC AT Диосдадо Банатао, бывшие разработчики процессоров Sun, DEC, Cyrix, Intel, AMD и Silicon Graphics, чипов Qualcomm, Xilinx и Cypress, индустриальные аналитики, девушка с красными волосами и другие обитатели калифорнийских компаний такого типа.
В конце поста мы поговорим, какие книжки нужно почитать и упражнения поделать, чтобы примкнуть к данному сообществу.
Начнем с Джероми Кунена, инноватора арифметики с плавающей точкой и менеджера Apple времен первого Макинтоша.
Не так часто встречаются кандидатские диссертации, которые затрагивают вычисления на миллиардах устройств. Именно таким стал дисер Джероми Кунена (слева) «Contributions to a Proposed Standard for Binary Floating Point Arithmetic», результаты которого вошли в IEEE Standard 754 чисел с плавающей точкой. После окончания аспирантуры Беркли в 1982 году Джероми пошел работать в Apple, где внедрил библиотеки вычислений с плавающей точкой в первый Макинтош.
После 10 лет менеджерства в Apple, Кунен консультировал Hewlett-Packard и Microsoft, а в 2000 году оптимизировал 128-битную арифметику для только появившейся 64-битной версии x86 от AMD. В последнее время Джероми обратил свое внимание на исследования по стандартам плавающей точки для нейросетей, в частности споры про Unum и Posit. Unum — это новый предлагаемый стандарт, продвижением которого занимается ученый из Калтеха John Gustafson, автор шумящей сейчас книги The End of Error, «Конец Ошибки». Posit — это версия Unum-а, которую можно более эффективно (\*), чем Unum, реализовать в аппаратуре.
(\*) Более эффективно по комбинации параметров: тактовой частоте, количеству циклов на операцию, пропускной способности конвейера, относительной площади на кристалле и относительному энергопотреблению.
Картинки из статей (не от Джероми) [Making floating point math highly efficient for AI hardware](https://code.fb.com/ai-research/floating-point-math/) и
[Beating Floating Point at its Own Game: Posit Arithmetic by John L. Gustafson and Isaac Yonemoto](http://superfri.org/superfri/article/view/137/232):
А вот на парти Стефен/Стив Джонсон — человек, на компиляторе которого язык программирования Си стал популярным. Первый компилятор Си написал Денис Ритчи, но компилятор Ричи был жестко привязан к архитектуре PDP-11. Стив Джонсон, основываясь на работах Алана Снайдера, написал в середине 1970-х годов компилятор Portable C Compiler (PCC), который было легко переделать для генерации кода для разных архитектур. При этом компилятор Джонсона работал быстро и был оптимизирующим. Как он этого достиг?
На входе PCC Стив Джонсон использовал LALR(1) парсер, сгенерированный программой YACC (Yet Another Compiler Compiler), автором которого был тоже Стив Джонсон. После этого задача компиляции сводилась к манипуляции с деревьями в рекурсивных фукциях и генерации кода по таблице шаблонов. Часть этих рекурсивных функций была машинно-независима, другая часть переписывалась людьми, которые переносили PCC на другую машину. Таблица шаблонов состояла из записей правил типа «если свободен регистр типа A и два регистра типа B, перестроить дерево в узел типа C и сгенерировать код с строкой D». Таблица была машинно-зависимой.
Из-за комбинации элегантности, гибкости и эффективности, компилятор PCC перенесли на более чем 200 архитектур — от PDP, VAX, IBM/370, x86 до советских БЭСМ-6 и Орбита 20-700 (бортового компьютера в ранних версиях МиГ-29). Согласно Денису Ритчи, практически каждый С компилятор начала 1980-х годов базировался на PCC. Из мира BSD Unix PCC был вытеснен как стандартно поставляемый компилятор только GNU GCC в 1994 году.
Кроме PCC и Yacc, Стив Джонсон также является автором исходной программы проверки программ Lint (см. напр. [статью 1978 года](http://www.silicon-russia.com/wp-content/uploads/2019/02/lint_1978_stephen_johnson.pdf)). Названия программ Yacc и Lint с тех пор стали нарицательными. В 2000-е Стив переписал фронт-энд MATLAB и написал MLint. Сейчас Стив Джонсон занят задачей распараллеливания алгоритмов вычислений нейросетей на устройствах типа CGRA (Coarse-Grained Reconfigurable Architecture), с десятками тысяч процессорообразных элементов, которые перекидываются между собой тензорами через сеть из тоже десятков тысяч свитчей внутри массивного чипа с миллиардами транзисторов:
А вот с бокалом вина миллиардер Диосдадо Банатао, основатель Chips & Technologies, S3 Graphics и инвестор в Marvell. Если вы программировали IBM PC в 1985-1988 годах, когда они только появились в СССР, то вы можете знать, что внутри большинства AT-шек с графикой EGA и VGA стояли чипсеты от Chips & Technologies, которые выходили одновременно с IBM-овскими. Ранние чипсеты C&T дизайнил Банатао, который выучился на электронщика в Стенфорде, а до Стенфорда работал инженером в Боинге. В 1987 году компанию Chips & Technologies купил Интел.
Слева на снимке ниже — Джон Буржуин (John Bourgoin), президент MIPS Technologies времен максимального расцвета этой компании в 2000-х, когда чипы с ядрами MIPS стояли внутри большинства DVD-плейеров, цифровых фотокамер и телевизоров, с чипсетами от Zoran, Sigma Design, Realtek, Broadcom и других компаний. До этого Джон был с 1996 года президентом отделения MIPS Silicon Graphics, когда процессоры MIPS стояли внутри рабочих станций Silicon Graphics, которые использовались в Голливуде для съемки первых реалистичных 3D фильмов «Парк Юрского Периода». До Silicon Graphics Джон был одним из вице-президентов AMD, еще с 1976 года.
Арт Свифт, справа, был вице-президентом маркетинга MIPS в 2000-е, а до этого в 1980-е работал инженером в Fairchild Semiconductor (да, том самом), потом вице-президентом по маркетингу в Sun, DEC, Cirrus Logic, и президентом компании Трансмета. В последнее время Арт был вице-председателем комитета по маркетингу RISC-V и знаком на этой позиции с российскими компаниями Syntacore и CloudBear. А сейчас стал президентом направления MIPS IP компании Wave:
Слайды из [презентации по истории MIPS](http://panchul.com/dropbox/2012_10_27/mips_russia_2012_1_background.pptx), относящиеся к периоду, когда MIPS-ом управлял Джон Буржуин (John Bourgoin), на снимке выше слева:
Компания Трансмета, президентом которой был некоторое время Арт Свифт, на снимке выше справа, в конце 1990-х выпустила процессор Крузо (Crusoe), который мог выполнять инструкции x86 и дошел до рынка в суб-ноутбуках Toshiba Libretto L, ноутах от NEC и Sharp, тонком клиенте от Compaq. Их конкурентным преимуществом перед Интелом и AMD ставилось контролируемо низкое энергопотребление.
Прямая реализация и верификация полного набора x86 — это очень дорогое мероприятие, поэтому Трансмета пошла другим путем, который напоминает путь российской компании МЦСТ с процессором Эльбрус (линии, которая началась с Эльбруса 2000 и сейчас представлена в виде Эльбрус 8С). Трансмета и Эльбрус в качестве основы ставили структурно простой процессор с микроархитекторой VLIW, а поверх него работал уровень эмуляции x86 с помощью технологии, которая у Трансметы называлась code morphing.
Идея VLIW (Very Long Instruction Word — Очень Длинное Слово Инструкции) довольно проста — несколько инструкций процессора в явном виде объявляются одной суперинструкцией и выполняются параллельно. В отличие от суперскалярных процессоров, в частности интелов начиная с PentiumPro (1996), в которых процессор делает выборку нескольких инструкций из памяти, и потом сам решает, что выполнять паралельно, а что последовательно, на основе автоматического анализа зависимостей между инструкциями.
Суперскалярный процессор гораздо сложнее VLIW, потому что суперскаляру приходится тратить логику на поддерживание иллюзии у программиста, что все выбранные инструкции выполняются одна за другой, хотя реально их может находится внутри процессора десятки, на разных стадиях выполнения. В случае VLIW бремя поддержания такой иллюзии ложится на компилятор с языка высокого уровня. В конечном итоге схема VLIW ломается, когда процессору приходится работать с многоуровневой кэш-памятью, у которой непредсказуемые задержки, которые приводят к тому, что компилятору становится трудно планировать инструкции по тактам. Но для математических вычислений (например поставить Эльбрус на радар и вычислять движение цели) это самое то, особенно в условиях дефицита квалифицированных инженерных кадров (для верификации суперскаляра нужно больше людей).
Иллюстрация идеи VLIW, процессор Крузо и суб-ноут Toshiba Libretto L1:
А вот в центре на фото ниже Дерек Мейер, Derek Meyer, нынешний CEO Wave Computing. До Wave Дерек был CEO компании ARC, разработчика процессорных ядер ARC, которые используются в чипах для аудио. Эти ядра в свое время [лицензировала в том числе и российская компания НИИМА Прогресс](https://www.businesswire.com/news/home/20100901005664/en/Russian-SoC-Leader-MRI-Progress-Licenses-Virage), которая потом лицензировала ядра MIPS и [показывала чипы на их основе на выставке в Казанском Иннополисе](https://habr.com/en/post/395357/). Дерек Мейер неоднократно ездил в Россию, в Санкт-Петербург, где находилась группа разработчиков компании Virage Logic. В 2009 году компания ARC купила компанию Virage Logic, а в 2010 году ARC поглотила компания Synopsys, главный производитель средств проектирования микросхем в мире.
Справа на фото — [Сергей Вакуленко](https://vak.dreamwidth.org/), который на заре карьеры стоял у истоков рунета, работал в кооперативе Демос и институте Курчатова, которые принесли интернет в СССР. Сейчас Сергей пишет cycle-accurate модель процессорного элемента Wave для вычислений нейросетей, а раньше написал instruction-accurate модели ядер MIPS, которые использовались для верификации процессорных ядер MIPS I6400 Samurai, I7200 Shaolin и других.
Вот Вадим Антонов и Сергей Вакуленко в 1990 году, с первым компьютером в СССР, подключенным к интернету:
А вот справа Larry Hudepohl (по русски пишется Хьюдепол?). Ларри начинал свою карьеру в Digital Equipment Corporation (DEC) как дизайнер процессоров для MicroVAX. Потом Ларри работал в небольшой компании Cyrix, которая в конце 1980-х бросила вызов Интелу и сделала FPU сопроцессор, который был совместим Intel 80387 и при этом был его на 50% быстрее. Потом Ларри проектировал чипы MIPS в Silicon Graphics. Когда MIPS Technologies отделилась от Silicon Graphics, Ларри вдвоем с Райаном Кинтером начали первый продукт независимого MIPS — MIPS 4K, который стал основой линейки, доминирующей в домашней электронике 2000-х (DVD-плееры, фотокамеры, цифровые телевизоры). Затем MIPS 5K полетел в космос — его использовало японское космическое агентство JAXA. Потом Ларри на должности VP Hardware Engineering руководил разработкой следующих линеек, а сейчас работает над новыми архитектурами Wave акселератора.
Японский космический корабль с гордым названием Хаябуса-2 («Сапсан-2»), который [в прошлом году приземлился на поверхности астероида Рюгу](https://www.bbc.com/russian/news-45669705), управляется процессором HR5000 на основе довольно давно лицензированного у MIPS Technologies процессорного ядра MIPS 5Kf.
Вот простой последовательный конвейер 64-битного процессорного ядра MIPS 5Kf из его [даташита](https://www.digchip.com/datasheets/parts/datasheet/303/MIPS645KF-pdf.php):
Справа на фото — Даррен Джонс, Darren Jones. Он был директором хардверного инжиниринга в MIPS заведовал разработкой сложных ядер, с аппаратной многопоточностью, и суперскаляров с внеочередным выполнением инструкций. Потом Даррен ушел в Xilinx, где занимался Xilinx Zynq — чипами, на которых стоит комбинация из ПЛИС и процессоров ARM. Сейчас Даррен стал вице-президентом инжиниринга в Wave.
В MIPS Даррен был лидером группы, члены которой потом пошли работать в Apple и Samsung. Дизайнерша Моника, которая ушла в Самсунг, однажды сказала мне фразу, которую я хорошо запомнил: «RTL design: a few simple principles and the rest is cheating» (разработка аппаратуры на уровне регистровых передач: несколько простых принципов, все остальное — мухлеж"). Канонический пример мухлежа это кэш (программа записала данные и прочитала, но в памяти это окажется только когда-нибудь потом), но это только очень частный случай того, что умела делать Моника.
Аппаратная многопоточность и внеочередной суперскаляр — это два разных подхода к повышению производительности процессора. Аппаратная многопоточность позволяет повысить пропускную способность без особого повышения энергопотребления, но с нетривиальным программированием. Суперскаляр позволяет выполнять однопоточные программы грубо говоря вдвое быстрее, но и тратит вдвое больше ватт. Но без ухищрений в программировании.
Аппаратную многопоточность наконец-то хорошо разъяснили в русской википедии, вот ее [временная многопоточность](https://ru.wikipedia.org/wiki/Temporal_multithreading) (она реализована в MIPS interAptiv и MIPS I7200 Shaolin), а вот [одновременная многопоточность](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE%D0%BF%D0%BE%D1%82%D0%BE%D1%87%D0%BD%D0%BE%D1%81%D1%82%D1%8C) (ее в 1990-е сделали в процессорах DEC Alpha, потом в SPARC, а потом в MIPS I6400 Samurai / I6500 Daimyo).
Временная многопоточность эксплуатирует тот факт, что процессор с обычным последовательным конвейером половину времени выполнения простаивает / ждет. Чего он ждет? Данные, которые через кэши идут из памяти. Причем ждет долго — за время ожидания одного промаха кэша процессор мог бы выполнить десятки или даже сотню-другую простых арифметических инструкций типа сложения.
Так было не всегда — в 1960-е годы арифметические устройства были гораздо медленнее, чем память. А вот с примерно 1980-го года скорость процессорных ядер росла гораздо быстрее, чем скорость памяти, и даже появление у процессоров многоуровневых кэшей решило проблему только частично.
Процессоры с временной многопоточностью поддерживают несколько наборов регистров, по одному для каждого потока, и когда текущий поток ждет данные из памяти во время промаха кэша, то процессор переключается на другой поток. Это происходит мгновенно, за цикл, без прерываний и тысячи циклов обработчика прерываний, который включается при программной (не аппаратной) многопоточности.
Вот идея многопоточности [на слайдах с семинаров Чарльза Данчека](http://silicon-russia.com/public_materials/2016_11_04_one_day_mipsfpga_connected_mcu_materials_public_for_the_website/04_present_nanometer_asic_seminar/dna.rus.2016.MIPS.pdf), преподавателя из University of California Santa Cruz, Silicon Valley Extension. Почему на русском? Потому что Чарльз Данчек проводил лекции в московском МИСиС-е, после чего в питерском ИТМО и в киевском КПИ:
Интересно, что аппаратно-многопоточно можно программировать просто на Си. Вот как это выглядит:
```
#include "mips/m32c0.h"
#include "mips/mt.h"
#include "mips/mips34k.h"
// Это макро на Си использует GNUшные штучки,
// которые позволяют вставлять параметры прямо в ассемблируемый код.
// С помощью этого параметра поток (thread) будет знать свой ID.
// Обратите внимание на инструкцию FORK. Да, это одна 32-битная инструкция!
#define mips_mt_fork_and_pass_param(thread_function, param) \
__extension__ \
({ \
void * __thread_function = (thread_function); \
unsigned __param = (param); \
\
__asm__ __volatile \
( \
".set push; .set mt; fork $4,%0,%z1; .set pop" \
: : "d" (__thread_function), "dJ" (__param) \
); \
})
void thread (unsigned tc)
{
// Тут можно делать что-нибудь параллельное.
// Потоки могут обмениваться информацией
// через аппаратно-реализованные FIFO и общую память,
// а также синхронизироваться аппаратными семафорами.
}
int main ()
{
// Макросы чтобы поставить аппаратную многопоточность
for (tc = 0; tc < NUM_TCS; tc++)
{
mips32_setvpecontrol (VPECONTROL_TE | tc);
u = mips32_mt_gettcstatus ();
mips32_mt_settcstatus (u | TCSTATUS_DA);
mips32_mt_settchalt (0);
}
mips_mt_emt ();
// Запускаем восемь параллельных потоков выполнения, остаемся в девятом
for (int tc = 1; tc < NUM_TCS; tc ++)
mips_mt_fork_and_pass_param (thread, tc);
thread (0);
}
```
Вот сбоку на парти стоит устройство Wave для датацентров. Оно пока не вполне работает, хотя чипы доступны некоторым клиентам в рамках бета-программы:
Что это устройство делает? Вы умеете программировать на Питоне? Вот на Питоне можно построить с помощью вызовов библиотеки TensorFlow так называемый Data Flow Graph (DFG). Нейросети — это по-сути специализированные вот такие графы, с операциями над матрицами. В софтверной группе Wave, частью которой руководит Стив Джонсон, есть компилятор с подмножества представления гугловсого TensorFlow в конфигурационные файлы для чипов этого устройства. После конфигурации оно может делать вычисления таких графов очень быстро. Устройство предназначено для датацентров, но тот же принцип можно применить и к небольшим чипам, даже внутри мобильных устройств, например для распознавания лиц:
Chijioke Anyanwu (слева) — много лет является хранителем всей системы тестирования процессорных ядер MIPS. Baldwyn Chieh (в центре) — дизайнер нового поколения процессорообразных элементов в Wave. Раньше Балдвин был старшим дизайнером в Qualcomm. Вот [слайды про устройство Wave с конференции HotChips](https://www.hotchips.org/wp-content/uploads/hc_archives/hc29/HC29.22-Tuesday-Pub/HC29.22.60-NeuralNet1-Pub/HC29.22.610-Dataflow-Deep-Nicol-Wave-07012017.pdf):
В каждой нанометровой цифровой инновационной AI компании Кремниевой Долины должна быть своя девушка с яркими волосами. Вот такая девушка в Wave. Ее зовут Афина, она социолог по образованию, и занимается в офисе офисом:
А вот как выглядит офис снаружи, и его более чем вековая история со времен, когда он был инновационной консервной фабрикой:
А теперь вопрос: как разобраться в архитектуре, микроархитектуре, цифровой схемотехнике, принципах дизайна AI чипов и участвовать в таких парти? Самый простой способ — это проштудировать учебник «Цифровая схемотехника и архитектура компьютера» Дэвида Харриса и Сары Харрис, и пойти в Wave Computing на лето интерном (планируется нанять 15 практикантов на лето). Надеюсь, что это же можно делать и в российских микроэлектронных компаниях, которые заняты подобными разработками — ЭЛВИС, Миландр, Байкал Электроникс, IVA Technologies и ряда других. В Киеве это теоретически можно делать в сотрудничающей с КПИ компанией Melexis.
На днях вышла новая, окончательно исправленная версия учебника Харрис & Харрис, которая должна бесплатно лежать вот здесь [www.mips.com/downloads/digital-design-and-computer-architecture-russian-edition-second-edition-ver3](https://www.mips.com/downloads/digital-design-and-computer-architecture-russian-edition-second-edition-ver3), но по-моему эта ссылка не работает, а когда заработает, я напишу про это отдельный пост. С вопросами, которые задают на интервью в Apple, Intel, AMD, и на каких страницах этого учебника (и других источников) можно посмотреть ответы. | https://habr.com/ru/post/438928/ | null | ru | null |
# Как мы разрабатывали темы для Почты
*Летом 2011 года мы внедрили новый дизайн Почты Mail.Ru. Интерфейс изменился не только визуально, но и был полностью переделан в техническом плане, что в разы ускорило его быстродействие и удобство. Но еще это было необходимо для реализации очень желанной для пользователей фичи — тем оформления интерфейса. О том, как мы внедряли темы в Почте, хочу рассказать в этом посте.*
Буквально за неделю до этого мы закончили перевод основных страниц на БЭМ (<http://bem.github.com/bem-method/pages/beginning/beginning.ru.html>). Решено было делать тематическую кастомизацию почты только на CSS. Но чистого CSS мало, нужен инструмент генерации CSS – и мы выбрали SASS (<http://sass-lang.com/>).
Как я писал выше, к тому моменту как мы начали делать темы на Почте, основные страницы у нас уже были переведены на независимые блоки.
```
/css
/blocks
/messages
...
/pages
main.css
```
Плюс, который мы получили сразу, – отсутствие каскадируемости. Если перекрашиваешь блок, ты перекрашиваешь только этот блок, ничего и нигде не стреляет и не взрывается.
Тема – это картинки на фоне, а также цвета (шрифт, фон, бордер...). Мы брали блок за блоком и выносили всю цветовую часть отдельно.
```
/css
/blocks
/messages // геометрия блоков
/themes
/default
/messages // файлы с переменными оформления
default.scss // сборка всех блоков с переменными
default.vars.scss // значения переменных по умолчанию
/theme
theme.scss // файл с нужными инклудами
theme.vars.scss // “окрас” конкретной темы
/pages
…
```
Естественно, нам понадобилась система сборки. SASS подошел. Он позволяет собирать scss в один большой css-файл плюс дает возможность использовать переменные.
Стилевое оформление одного из блоков строится так:
```
/css/blocks/messages/messages.scss
.messages{
padding:20px;
}
/css/pages/mail.scss
@import url(../messages/messages.scss);
/css/themes/default/messages/messages.scss
.messages{
background:$messages-background;
}
/css/blocks/default/default.scss
@import url(messages/messages.scss);
```
В этих стилевых файлах все значения css-свойств – переменные, которые определяются в конкретной теме.
```
/css/themes/theme/theme.vars.scss
$messages-background: #FFF;
/css/themes/theme/theme.scss
@import url(theme.vars.scss);
@import url(../default/default.scss);
```
После работы SASS мы получаем файл с геометрией всех блоков:
```
/css/pages/mail.css
```
и файлы с цветовым оформлением, разбитые по темам:
```
/css/themes/theme/theme.css;
```
Пользователю загружаются два файла – геометрия и стили выбранной темы.
**Переключение темы**
Т.к. оформление отделено от геометрии, нет необходимости перезагружать страницу для изменения оформления. Все, что нужно – загрузить асинхронно стили новой темы, после чего удалить старые.
Для работы с темами создан JS-класс, основными интересующими нас методами которого являются setTheme и switchThemeCss.
Система обратных вызовов для асинхронной работы с темами построена с помощью deferred.
Метод setTheme – “точка входа” для установки темы. Принимает id темы и возвращает deferred, который ожидает выполнения двух методов: switchThemeCss (смена стилей темы оформления) и AJAX-запрос на сохранение выбранной темы. Оба эти метода тоже работают с deferred.
```
return $.when(AJAX.post(...), switchThemeCss(themeId));
```
Самое интересное происходит внутри switchThemeCss. Основываясь на переданном themeId, функция строит путь до файла стилей и пытается его загрузить.
В проекте к этому моменту уже использовался плагин для загрузки стилей jquery.getCSS, и мы решили им воспользоваться. Но, к сожалению, он не позволяет определить, действительно ли загрузились стили, или запрос “отвалился” по таймауту из-за отсутствия подключения к сети, что очень важно для нас, т.к. удалять стили старой темы нужно только после успешного применения стилей новой.
Эту проблему мы решили с помощью многим, вероятно, известного, но успешно забытого метода, заключающегося в следующем.
На страницу добавляется скрытый блок, на который “навешиваются” стили, уникальные для каждой темы. После загрузки файла стилей проверяем, изменились ли стили скрытого блока, и если изменились – значит, тема успешно загружена.
В нашем случае 100% уникальность имеет id темы. Но этот id не имеет ничего общего с возможными значениями CSS-свойств, а значит, в общем случае стили применены не будут.
Нужно было некоторое свойство, значением которого может быть произвольная строка. Для этого подходят свойства content и font-family, но с некоторыми оговорками.
Одни браузеры не применяют свойство content к не псевдо-элементам, для которых оно предназначено. А другие не применяют свойство font-family, если такого семейства в реальности не существует, но при этом применяют свойство content. Мы решили использовать оба свойства, и в браузерах, которые возвращают пустое значение свойства content, смотреть в свойство font-family.
В итоге получился примерно следующий код (схематично):
```
function getApplyedThemeId(){
var ff = hiddenElement.css('font-family'),
content = hiddenElement.css('content');
return content || ff;
},
function switchThemeCss (themeId){
var url = getThemeCssUrl(themeId)
, deferred = newDeferred();
var oldThemeId = getApplyedThemeId(); // Получаем текущий themeId
$.getCSS(
url,
function(link){
var newThemeId =getApplyedThemeId(); // Получаем новый themeId
// Если id не совпадают – тема загрузилась
if (newThemeId !== oldThemeId){
$ThemeCSS.remove(); // Удаляем старые стили
$ThemeCSS = $(link); // Запоминаем новые
deferred.resolve(); // Возвращаем ОК
} else { // Тема по какой-то причине не загрузилась
$(link).remove(); // Удаляем link на неудачные стили
deferred.reject(); // Возвращаем “все плохо”
}
}
);
}
```
В итоге мы получили темы, которые легко поддерживать. Кроме того, их загрузкой легко управлять, а код загрузки можно использовать с любым интерфейсным решением для выбора тем на любой странице.
На техническую реализацию, создание 12 тем, отладку и выпуск на продакшн ушло 2 месяца работы одного человека.
**Напоследок — забавная статистика о самых популярных темах:**
Зомби устанавливают в основном мальчики 12-25. А еще это любимая темы команды Почты Mail.ru:)
Игра в снежки удерживает лидерство в сегменте тем про зиму, на данный момент ее установили уже более 300 000 человек, 2/3 из которых представительницы прекрасного пола 25-34
Самая девчачья тема Анимэ (девочки 12-17 лет)
Самая гиковская тема — Blackboard. Включить ее из интерфейса вообще нельзя! Зато можно включить вот по такой читерской ссылке <http://e.mail.ru/cgi-bin/msglist?folder=0&setTheme=t1026>
Саймонс Кэт — темы для молодых женщин 25-34
P.S: Приоткрывая завесу тайны — в ближайшее время выйдут первые две темы для фанатов игр Аллоды и Легенда.
Андрей Сумин,
руководитель разработки клиентской части | https://habr.com/ru/post/137552/ | null | ru | null |
# Меняем цвет выделения текста с помощью CSS.
Одна из интересных функций CSS3, которую мы и рассмотрим сегодня, носит имя "::selection", при помощи которой можно заменить стандартный цвет выделения текста в браузере. **Следует заметить что, на момент написания статьи, эту функцию поддерживают только лишь Safari и Firefox, причем отображают совершенно по разному.** Однако, на мой взгляд, стоит быть в курсе всех новинок дабы не отставать от этих, так сказать, «вперед-идущих» техник.
Начнем:
`::selection {
background: #ffb7b7; /* Safari */
}
::-moz-selection {
background: #ffb7b7; /* Firefox */
}`
Цвет выделения текста будет, как можно догадаться, красным. Можно добавить несколько параграфов и определить для них разные цвета выделения.
**[[ПРИМЕР](http://css-tricks.com/examples/DifferentSelectionColors/)]**
`p.red::selection {
background: #ffb7b7;
}
p.red::-moz-selection {
background: #ffb7b7;
}
p.blue::selection {
background: #a8d1ff;
}
p.blue::-moz-selection {
background: #a8d1ff;
}
p.yellow::selection {
background: #fff2a8;
}
p.yellow::-moz-selection {
background: #fff2a8;
}` | https://habr.com/ru/post/19712/ | null | ru | null |
# 1С + MS SQL против Матрицы виртуализации
*"Логика Черного лебедя делает то, чего вы не знаете, гораздо более важным, чем то, что вы знаете. Ведь если вдуматься, то многие Черные лебеди явились в мир и потрясли его именно потому, что их никто не ожидал."*
*Нассим Талеб*
«Время всегда против нас».
--------------------------
Весна 2020 года была очень активной на фондовых рынках, количество сделок в некоторые дни вырастало в 2 раза от нормы, закрытие дня в финансовом учете было близко к предельным срокам. Клиенты боролись с Черным Лебедем Covid-19 по всем фронтам. К этому моменту конфигурация уже 7 лет работала на одном и том же оборудовании, которое было заложено с запасом под горизонтальное маштабирование. Даже то горизонтальное маштабирование, которое можно сделать в 1С (см статью <https://habr.com/ru/post/674282/> ) позволяет решать проблемы роста объемов оборудованием, и вот настал тот момент когда уже пора расширять оборудование.
Случайное совпадение - наши системные администраторы предложили попробовать новый виртуальный кластер, который недавно развернули в компании. Кластер на основе VMWare. Перспективы были заманчивые, вместо покупки новых серверов, отдельных дисковых хранилищ, обоснований бюджета – создаются виртуальные машины с нужными параметрами, а в бюджет аллоцируются расходы из общего пула. Будущее рисует нам картины, когда системный администратор скоро не сможет потрогать сервер рукой, и будет видеть только операционную систему и прайс лист за использование J от провайдера. Однако виртуальная реальность оказалась не такой радужной.
Мне выделили контур с примерно таким же числом ядер, памяти как на рабочем. Версии программ и операционной системы поставили идентичные, настройки тоже. Параметры оборудования по виртуализацию были лучше, но не сильно ведь гонка тактовых частот заканчивается по физическим ограничениям. Запустил перерасчет за месяц с распараллеливанием… и ушел спать.
«Что есть реальность?» В виртуальной среде
------------------------------------------
Утром первым делом посмотрел на результаты, они были странные – замедление 60% на виртуальном кластере. Даже ФИФО который параллелится только по бумагам и не создает большой нагрузке посчитался медленней на 30%
**Кликайте на картинки для большего разрешения!**
Хорошо, что мне есть с чем сравнивать, и я могу просто сказать «А вот на железном кластере с той же конфигурацией гораздо быстрее» или сравнить счетчики MS SQL на быстром и медленном кластере. *Но допустим, кому-то дали облако под проект с якобы заявленными параметрами, как ему понять что кластер (1С MSSQL Hardware) работает на полную мощность?*
Тут можно обратится к принципу непротиворечивости логичной системы аксиом. В [логике предикатов это изложено детально](http://mathhelpplanet.com/static.php?p=svoystva-aksiomaticheskikh-teoriy), но по простому можно сказать: Вы можете построить любую систему аксиом для своей алгебры, геометрии, теории множеств – важно чтобы она была непротиворечивой при выводе теорем и утверждений. Там, где есть противоречие 2 варианта либо система аксиом плоха, либо вы что-то не знаете и не учитываете и именно там истина. Математика, физические постоянные существуют в мире не просто так любые противоречия разрушили бы вселенную. Напр путешествие во времени назад вызывает кучу противоречий, значит оно невозможно, а вот в будущее без возврата в прошлое вполне возможно.
Значит решено - снимаем показатели и ищем противоречия. ИТ технологии сложны, но это гораздо проще тензорного исчисления J. Производительность какого-то компонента кластера снижается по одной из трех причин.
* Ресурс перегружен, это сразу видно на счетчиках производительности.
* Ресурс частично свободен, но ждет снятия какой-то блокировки (Это может быть блокировка строк в СУБД, ресурсов памяти Latch, и т.д.).
* Ресурс частично свободен, но у него скопилась очередь (Это может быть очередь к дисковой системе, минимально необходимые задержки на передачу пакета по сети).
Комбинация этих причин приводит к тому что все утыкается в бутылочное горлышко и остальные ресурсы просто не нагружаются.
Настроил счетчики, я не будут описывать нужные - так как в разных ситуациях нужно искать разные. Принцип простой – из всех счетчиков ищите счетчики очередей, ожиданий, миллисекунд на трансфер. Счетчики на % загрузки как правило не дают сделать выводы напр. Передача по сети множества мелких пакетов не создает 100% траффика, но за счет задержек сети упирается в потолок производительности ([см. мою старую статью на эту тему](http://selis76.narod.ru/matnetw1.html#bookmark1))
Для оборудования настроил Perfomance Monitor с записью, то что называется Data collection set. Странно, но оно работало только после перезагрузки сервера.
Для SQL Server сбросил счетчики статистики и кэши:
`DBCC SQLPERF("sys.dm_os_wait_stats",CLEAR);`
`DBCC FREEPROCCACHE ;`
`DBCC DROPCLEANBUFFERS;`
Анализ перегруженности ресурсов не показал ничего критичного.
На кластере 1С за счет горизонтального маштабирования, загрузка плотная больше 50% (что считается с точки зрения Microsoft значительной нагрузкой).
Небольшая странность, бывают очереди на процессор (Processor queue length).
На сервере базы данных нагрузка небольшая, значит можно увеличить еще, но видны противоречия:
Видны всплески очередей на диск (Current disk queue length больше 100), когда активность превышает 10 тыс IOPS . Причем видно что очередь держится по несколько секунд. Это странно, ведь SSD должен переваривать такой траффик легко.
Попросил администраторов проверить со стороны гипервизора, получил ответ.
*«В данной конфигурации Ваш виртуальный сервер может спокойно потреблять до 50k iops при минимальном latency. Разумеется, если от него этого требуют.*
*На Ваших графиках видно, что нагрузка почти нулевая с периодическими кратковременными скачками. Я посмотрел - в эти пиковые моменты сервер потреблял всего до 20k iops. Latency в эти моменты достигала 15-20 мс, что безусловно не мало, но и не катастрофично, учитывая, что эти всплески длятся доли секунды.*
*Latency растет, т.к. Вы периодически упираетесь в одно единственно ограничение - одновременное количество потоков данных от виртуального сервера к дисковой системе (максимум 64) в текущей конфигурации.*
*Параметр queue lentgh и все его производные имеет смысл рассматривать только на однодисковых десктопах. На серверах и в виртуализации он не показывает абсолютно ничего. »*
Вот первый звоночек оказывается VMWare ограничивает одновременное количество потоков данных от сервера к дисковой подсистеме, неужели придется еще VWWare изучать J чтобы знать ее узкие места. Про очереди не согласен, если они возникают значит что-то не так. А так «Все хорошо прекрасная маркиза, все хорошо, все хорошо».
«Если бы ты не мог проснуться, как бы ты узнал, что сон, а что действительность?»
---------------------------------------------------------------------------------
Очень просто – надо так пошалить в системе, что бы агент Смит мигом прибежал успокаивать прозревающего Нео и попытаться уложить его в кроватку. В ИТ это называется стресс тест, у водопроводчиков опрессовка. Если хотите проверить качество работы сантехника, пригласите опрессовщика, он создаст избыточное давление и все недоработки потоком польются вам на пол.
Горизонтальное маштабирование позволяет легко увеличить количество параллельных процессов обработки и тем самым увеличить нагрузку. Поэтому свой тест я запускал увеличив количество параллельных процессов обработки с 40 до 60, если % загрузки не дают внятного ответа, смотрим анализ ожиданий.
Результат интересные, ожидание на логгирование Transaction log вылезло в топ, [да еще Memory waits появились](https://www.sqlskills.com/help/waits/resource_semaphore/).
Еще сетевые [задержки между кластером 1С и СУБД великоваты](https://www.sqlskills.com/help/waits/async_network_io/) они действительно отличались от продуктивного контура, если применить анализ задержек через hrping. Это исправили, результат улучшился, но не существенно для текущей проблемы.
На продуктивном сервере топ ожиданий совсем другой, скажем так логичный – больше ждешь записи\чтения в базу нежели transaction log и памяти.
Далее смотрим детально ожидания на Transaction log он находится на отдельном SSD диске, но там нет проблем с производительностью дисковой системы.
Администраторы мне это подтвердили.
*«На графике ниже 3 параметра: lock wait, log write wait, disk latency.*
*Хорошо видно, что несмотря на высокий уровень Log write waits, запись данных на диск происходит с приемлемой latency. Следовательно, проблема тут не в дисках.*
Решение проблем с задержками сети улучшило результат до **1233** мин против **1492**, но это не 937 мин на рабочем.
Анонс. Анализ сетевых задержек это отдельная тема. В устаревшем варианте есть [моя статья](http://selis76.narod.ru/matnetw1.html#bookmark1), но ее можно уже обновить учитывая новые кейсы.
«Часть меня чувствует, будто я всю жизнь ждала тебя.» Ожидания наше все.
------------------------------------------------------------------------
Если отбросить диск, то анализ задержек на уровне процессор память наиболее сложная тема, поскольку это уже нужно лезть в анализ процессов операционной системы и с пониманием использовать [ProcessExplorer](https://docs.microsoft.com/en-us/sysinternals/downloads/process-explorer). Многоядерность, Numa nodes усложняют задачу.
Я уже подошел к моменту, когда анализ счетчиков увеличивает глубину НЕ знания, поскольку даже внутри кластера видно, что для tempdb при сопоставимых объемах записи, таких проблем нет, а для базы СУБД есть. Интуитивно было понятно что, что-то не так с виртуальными ядрами, Numa nodes, а не с реальным железом.
*Если есть теория значит нужно искать ей подтверждение! Ок Google?*
Не помню какой правильно был сформулированный вопрос, который содержит половину ответа, но я нашел [эту статью про spinlock в MS SQL](https://chrisadkin.io/2015/09/09/tuning-the-logcache_access-spinlock-on-a-big-box/).
Тема сложная поскольку это уже системная архитектура СУБД, до которой не каждый SQL администратор доберется, а Эксперт по технологическим вопросам 1С вообще не должен столкнутся с подобным, учитывая проблемы 1С горизонтальным маштабированием [см тут](https://infostart.ru/1c/articles/1683197/) . Приведу лишь несколько цитат для понимания.
*«Spinlocks are lightweight synchronization primitives which are used to protect access to data structures. Spinlocks are not unique to SQL Server. They are generally used when it is expected that access to a given data structure will need to be held for a very short period of time. When a thread attempting to acquire a spinlock is unable to obtain access it executes in a loop periodically checking to determine if the resource is available instead of immediately yielding. After some period of time a thread waiting on a spinlock will yield before it is able to acquire the resource in order to allow other threads running on the same CPU to execute. This is known as a backoff and will be discussed in more depth later in this paper.*
*SQL Server utilizes spinlocks to protect access to some of its internal data structures. These are used within the engine to serialize access to certain data structures in a similar fashion to latches. The main difference between a latch and a spinlock is the fact that spinlocks will spin (execute a loop) for a period of time checking for availability of a data structure while a thread attempting to acquire access to a structure protected by a latch will immediately yield if the resource is not available. Yielding requires context switching of a thread off the CPU so that another thread can execute. This is a relatively expensive operation and for resources that are held for a very short duration it is more efficient overall to allow a thread to execute in a loop periodically checking for availability of the resource.»*
Проще говоря это блокировки для структур памяти, которые работают по принципу циклического ожидания.
*«Ты всю жизнь ощущал, что мир не в порядке. Странная мысль, но её не отогнать. Она — как заноза в мозгу. Она сводит с ума, не даёт покоя. Это и привело тебя ко мне...» Морфеус*
Предположил, что проблема в физическом распределении по Numa Node потоков MS SQL, которое влечет задержки при доступе к памяти (ведь spinlock это структуры памяти) , видимо на физическом уровне WriteLog висит на тех же ядрах что и другие потоки MS SQL и Numa Nodes фактически не работают. С приходом многоядерности требуется внимательно смотреть на загрузку отдельных ядер, ведь там может висеть процесс или поток, который становится узким местом для всей системы.
Классический пример из 1С – rmanager со всеми сервисами висит на одном ядре, если он управляет 40 рабочими процессами, загрузка этого ядра на 100% уже влияет на всю систему самым отрицательным образом. Поэтому в 8.3 есть флажок «Менеджер под каждый сервис», а в 8.2 нужно сделать несколько менеджеров кластера и распределить по ним сервисы.
Ложки не существует. Что не так с ядрами виртуальной машины?
-------------------------------------------------------------
> — Не пытайся согнуть ложку. Это невозможно. Для начала нужно понять главное.
>
> — Что главное?
>
> — Ложки не существует.
>
> — Не существует?
>
> — Знаешь, это не ложка гнётся. Всё — обман. Дело в тебе.
>
>
С какими ядрами работает SQL Server - можно увидеть в Affinity mask логе SQL Server
Вот что было на виртуальном кластере:
А это на рабочем:
Почувствовали разницу? SQL сервер по другому видит и Numa node и количество ядер. Хотя там все одинаково с точки зрения количества
Что такое Numa node хорошо [объяснено тут](https://docs.microsoft.com/en-us/previous-versions/sql/sql-server-2008-r2/ms178144(v=sql.105)).
*«Each group of processors has its own memory and possibly its own I/O channels. However, each CPU can access memory associated with the other groups in a coherent way. Each group is called a NUMA node. The number of CPUs within a NUMA node depends on the hardware vendor. It is faster to access local memory than the memory associated with other NUMA nodes»*
Дальше все становится понятным - SQL Server не будет есть виртуальную … . Любая виртуальная … приведет к самым экзотическим эффектам в производительности. Выход один – выровнять виртуальную машину с физической. В VMWare такое возможно, с другой стороны, а зачем она нам вообще тогда нужна J . Все варианты например: дадим половину реальной машины или 2 реальных машины объединенных в одну приведут к непредсказуемым эффектам в производительности.
Проверка через CoreInfo показала такое распределение ядер на виртуальном сервере:
Logical to Physical Processor Map:
\*----------------------- Physical Processor 0
-\*---------------------- Physical Processor 1
--\*--------------------- Physical Processor 2
---\*-------------------- Physical Processor 3
----\*------------------- Physical Processor 4
-----\*------------------ Physical Processor 5
------\*----------------- Physical Processor 6
-------\*---------------- Physical Processor 7
--------\*--------------- Physical Processor 8
---------\*-------------- Physical Processor 9
----------\*------------- Physical Processor 10
-----------\*------------ Physical Processor 11
------------\*----------- Physical Processor 12
-------------\*---------- Physical Processor 13
--------------\*--------- Physical Processor 14
---------------\*-------- Physical Processor 15
----------------\*------- Physical Processor 16
-----------------\*------ Physical Processor 17
------------------\*----- Physical Processor 18
-------------------\*---- Physical Processor 19
--------------------\*--- Physical Processor 20
---------------------\*-- Physical Processor 21
----------------------\*- Physical Processor 22
-----------------------\* Physical Processor 23
Logical Processor to Socket Map:
\*----------------------- Socket 0
-\*---------------------- Socket 1
--\*--------------------- Socket 2
---\*-------------------- Socket 3
----\*------------------- Socket 4
-----\*------------------ Socket 5
------\*----------------- Socket 6
-------\*---------------- Socket 7
--------\*--------------- Socket 8
---------\*-------------- Socket 9
----------\*------------- Socket 10
-----------\*------------ Socket 11
------------\*----------- Socket 12
-------------\*---------- Socket 13
--------------\*--------- Socket 14
---------------\*-------- Socket 15
----------------\*------- Socket 16
-----------------\*------ Socket 17
------------------\*----- Socket 18
-------------------\*---- Socket 19
--------------------\*--- Socket 20
---------------------\*-- Socket 21
----------------------\*- Socket 22
-----------------------\* Socket 23
Logical Processor to NUMA Node Map:
\*\*\*\*\*\*\*\*\*\*\*\*------------ NUMA Node 0
------------\*\*\*\*\*\*\*\*\*\*\*\* NUMA Node 1
Approximate Cross-NUMA Node Access Cost (relative to fastest):
00 01
00: 1.0 1.2
01: 1.2 1.1
На рабочем сервере:
Logical to Physical Processor Map:
\*\*------------------------------ Physical Processor 0 (Hyperthreaded)
--\*\*---------------------------- Physical Processor 1 (Hyperthreaded)
----\*\*-------------------------- Physical Processor 2 (Hyperthreaded)
------\*\*------------------------ Physical Processor 3 (Hyperthreaded)
--------\*\*---------------------- Physical Processor 4 (Hyperthreaded)
----------\*\*-------------------- Physical Processor 5 (Hyperthreaded)
------------\*\*------------------ Physical Processor 6 (Hyperthreaded)
--------------\*\*---------------- Physical Processor 7 (Hyperthreaded)
----------------\*\*-------------- Physical Processor 8 (Hyperthreaded)
------------------\*\*------------ Physical Processor 9 (Hyperthreaded)
--------------------\*\*---------- Physical Processor 10 (Hyperthreaded)
----------------------\*\*-------- Physical Processor 11 (Hyperthreaded)
------------------------\*\*------ Physical Processor 12 (Hyperthreaded)
--------------------------\*\*---- Physical Processor 13 (Hyperthreaded)
----------------------------\*\*-- Physical Processor 14 (Hyperthreaded)
------------------------------\*\* Physical Processor 15 (Hyperthreaded)
Logical Processor to Socket Map:
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*---------------- Socket 0
----------------\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* Socket 1
Logical Processor to NUMA Node Map:
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*---------------- NUMA Node 0
----------------\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* NUMA Node 1
Approximate Cross-NUMA Node Access Cost (relative to fastest):
00 01
00: 1.0 1.3
01: 1.5 1.0
Разница понятна. На виртуальном якобы физические сокеты 24 шт, а на рабочем сервере 2 сокета и 32 ядра Hyperthread.
Прошу администраторов выровнять виртуальные машины по физическим на SQL сервере и кластере 1С, запускаю тест повторно. Урааа 1162 минуты против 937 это еще не победа, вообще результат должен быть лучше все-таки оборудование более новое. Но направление борьбы с Матрицей понятно – нужно везде разоблачать виртуальные ресурсы и отображать их на реальные физические один к одному.
*Зачем нам тогда Матрица?* Для белых воротничков, которые сидят в браузере и Word, для малого бизнеса которому лишние железки только лишняя нагрузка, а в браузере он выглядит даже средним бизнесом, менеджерам для экономии - кому угодно только не тем кому нужна реальная производительность.
*Кто-то скажет: Вы не умеете готовить виртуальную среду?*
Я отвечу: Я что - шеф повару должен объяснять как ему готовить? Да ну такой ресторан, лучше сделать свой.
Уже по идеологии виртуализации видно, что вопросы производительности там на последнем месте и все заточено на «эффективное использование ресурсов», никогда не знаешь где и когда тебе подрежут ресурсы. Самое плохое, что никто из специалистов 1С не станет изучать гипервизор и VMWare, а системные администраторы не будут глубоко лезть в архитектуру SQL сервера. В итоге любые проблемы придется решать мозговым штурмом Эксперта по тех вопросам 1С, Администратора SQL , Системного администратора и еще других занятых сотрудников только ради того чтобы убрать ограничения виртуальной среды.
Забегая вперед могу сказать, что равной производительности (и даже большей) на виртуальном кластере мы достигли, в следующей серии Матрицы.
Как изменились счетчики после выравнивания виртуальной машины можно посмотреть ниже.
Скрипты для запросов с источниками происхождения я прилагаю.
На тестовом кластере зафиксировано до оптимизации:
После выравнивания виртуальных машин с физическими сокетами и ядрами картина резко улучшилась.
Задержка по Writelog сократилась в два раза.
Как работает spinlock описано выше, но нам сейчас важно понимать, что при коллизии доступа к logbuffer значение spin увеличивается циклически пока другой поток не отпустит ресурс. Т.е чем выше значение spins\_per\_collision тем хуже работает связка процессор
У нас – они уменьшились на logflushq, но увеличились на logcashe\_access – последнее считается признаком более интенсивной работой writelog . Замечу что на рабочем кластере статистика еще лучше, но там повышенную нагрузку не давали при измерениях. О том, что еще влияло на производительность виртуального кластера – в следующей статье. Первыми статьи появляются на нашем канале **t.me/Chat1CUnlimited** + дополнительная информация.
*«Я не сказал, что будет легко. Я лишь обещал открыть правду.» Морфеус* | https://habr.com/ru/post/675398/ | null | ru | null |
# Автосбор данных о файлах баз данных и логических дисках операционной системы в MS SQL Server
### Предисловие
Администратору баз данных важно знать, когда закончится место на диске. И чтобы этого не делать вручную на каждом сервере, лучше этот процесс автоматизировать.
В данной статье приведу реализацию автоматического ежедневного сбора информации о логических дисках и о файлах баз данных.
### Решение
Алгоритм:
1) создать таблицы для хранения информации:
1.1) для файлов баз данных:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [srv].[DBFile](
[DBFile_GUID] [uniqueidentifier] ROWGUIDCOL NOT NULL,
[Server] [nvarchar](255) NOT NULL,
[Name] [nvarchar](255) NOT NULL,
[Drive] [nvarchar](10) NOT NULL,
[Physical_Name] [nvarchar](255) NOT NULL,
[Ext] [nvarchar](255) NOT NULL,
[Growth] [int] NOT NULL,
[IsPercentGrowth] [int] NOT NULL,
[DB_ID] [int] NOT NULL,
[DB_Name] [nvarchar](255) NOT NULL,
[SizeMb] [float] NOT NULL,
[DiffSizeMb] [float] NOT NULL,
[InsertUTCDate] [datetime] NOT NULL,
[UpdateUTCdate] [datetime] NOT NULL,
[File_ID] [int] NOT NULL,
CONSTRAINT [PK_DBFile] PRIMARY KEY CLUSTERED
(
[DBFile_GUID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
ALTER TABLE [srv].[DBFile] ADD CONSTRAINT [DF_DBFile_DBFile_GUID] DEFAULT (newid()) FOR [DBFile_GUID]
GO
ALTER TABLE [srv].[DBFile] ADD CONSTRAINT [DF_DBFile_InsertUTCDate] DEFAULT (getutcdate()) FOR [InsertUTCDate]
GO
ALTER TABLE [srv].[DBFile] ADD CONSTRAINT [DF_DBFile_UpdateUTCdate] DEFAULT (getutcdate()) FOR [UpdateUTCdate]
GO
```
1.2) для логических дисков:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [srv].[Drivers](
[Driver_GUID] [uniqueidentifier] ROWGUIDCOL NOT NULL,
[Server] [nvarchar](255) NOT NULL,
[Name] [nvarchar](8) NOT NULL,
[TotalSpace] [float] NOT NULL,
[FreeSpace] [float] NOT NULL,
[DiffFreeSpace] [float] NOT NULL,
[InsertUTCDate] [datetime] NOT NULL,
[UpdateUTCdate] [datetime] NOT NULL,
CONSTRAINT [PK_Drivers] PRIMARY KEY CLUSTERED
(
[Driver_GUID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
ALTER TABLE [srv].[Drivers] ADD CONSTRAINT [DF_Drivers_Driver_GUID] DEFAULT (newid()) FOR [Driver_GUID]
GO
ALTER TABLE [srv].[Drivers] ADD CONSTRAINT [DF_Drivers_Server] DEFAULT (@@servername) FOR [Server]
GO
ALTER TABLE [srv].[Drivers] ADD CONSTRAINT [DF_Drivers_TotalSpace] DEFAULT ((0)) FOR [TotalSpace]
GO
ALTER TABLE [srv].[Drivers] ADD CONSTRAINT [DF_Drivers_FreeSpace] DEFAULT ((0)) FOR [FreeSpace]
GO
ALTER TABLE [srv].[Drivers] ADD CONSTRAINT [DF_Drivers_DiffFreeSpace] DEFAULT ((0)) FOR [DiffFreeSpace]
GO
ALTER TABLE [srv].[Drivers] ADD CONSTRAINT [DF_Drivers_InsertUTCDate] DEFAULT (getutcdate()) FOR [InsertUTCDate]
GO
ALTER TABLE [srv].[Drivers] ADD CONSTRAINT [DF_Drivers_UpdateUTCdate] DEFAULT (getutcdate()) FOR [UpdateUTCdate]
GO
```
Таблицу с логическими дисками нужно заполнить заранее следующим образом:
название сервера — метка тома (MyServer — C:).
2) создать необходимое представление для сбора информации о файлах баз данных:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE view [inf].[ServerDBFileInfo] as
SELECT @@Servername AS Server ,
File_id ,--Идентификатор файла в базе данных. Основное значение file_id всегда равно 1
Type_desc ,--Описание типа файла
Name as [FileName] ,--Логическое имя файла в базе данных
LEFT(Physical_Name, 1) AS Drive ,--Метка тома, где располагается файл БД
Physical_Name ,--Полное имя файла в операционной системе
RIGHT(physical_name, 3) AS Ext ,--Расширение файла
Size as CountPage, --Текущий размер файла в страницах по 8 КБ
round((cast(Size*8 as float))/1024,3) as SizeMb, --Размер файла в МБ
Growth, --Прирост
is_percent_growth, --Признак процентного приращения
database_id,
DB_Name(database_id) as [DB_Name]
FROM sys.master_files--database_files
GO
```
Здесь используется системное представление [sys.master\_files](https://technet.microsoft.com/ru-ru/library/ms186782(v=sql.110).aspx)
3) создать хранимую процедуру, которая возвращает информацию по логическому диску:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
create procedure [srv].[sp_DriveSpace]
@DrivePath varchar(1024) --устройство (можно передать метку тома 'C:')
, @TotalSpace float output --всего емкость в байтах
, @FreeSpace float output --свободного пространства в байтах
as
begin
DECLARE @fso int
, @Drive int
, @DriveName varchar(255)
, @Folder int
, @Drives int
, @source varchar(255)
, @desc varchar(255)
, @ret int
, @Object int
-- Создаем обект файловой системы
exec @ret = sp_OACreate 'Scripting.FileSystemObject', @fso output
set @Object = @fso
if @ret != 0
goto ErrorInfo
-- Получаем папку по заданному пути
exec @ret = sp_OAmethod @fso, 'GetFolder', @Folder output, @DrivePath
set @Object = @fso
if @ret != 0
goto ErrorInfo
-- Получаем устройство
exec @ret = sp_OAmethod @Folder, 'Drive', @Drive output
set @Object = @Folder
if @ret != 0
goto ErrorInfo
-- Определяем полный размер устройства
exec @ret = sp_OAGetProperty @Drive, 'TotalSize', @TotalSpace output
set @Object = @Drive
if @ret != 0
goto ErrorInfo
-- Определяем свободное место не устройстве
exec @ret = sp_OAGetProperty @Drive, 'AvailableSpace', @FreeSpace output
set @Object = @Drive
if @ret != 0
goto ErrorInfo
DestroyObjects:
if @Folder is not null
exec sp_OADestroy @Folder
if @Drive is not null
exec sp_OADestroy @Drive
if @fso is not null
exec sp_OADestroy @fso
return (@ret)
ErrorInfo:
exec sp_OAGetErrorInfo @Object, @source output, @desc output
print 'Source error: ' + isnull( @source, 'n/a' ) + char(13) + 'Description: ' + isnull( @desc, 'n/a' )
goto DestroyObjects;
end
GO
```
Данная хранимая процедура была взята из следующей статьи [Объём дисков на T-SQL](http://www.t-sql.ru/post/disk_size.aspx)
4) создать хранимую процедуру для сбора информации:
4.1) для файлов баз данных:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [srv].[MergeDBFileInfo]
AS
BEGIN
SET NOCOUNT ON;
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
;merge [srv].[DBFile] as f
using [inf].[ServerDBFileInfo] as ff
on f.File_ID=ff.File_ID and f.DB_ID=ff.[database_id] and f.[Server]=ff.[Server]
when matched then
update set UpdateUTcDate = getUTCDate()
,[Name] = ff.[FileName]
,[Drive] = ff.[Drive]
,[Physical_Name] = ff.[Physical_Name]
,[Ext] = ff.[Ext]
,[Growth] = ff.[Growth]
,[IsPercentGrowth] = ff.[is_percent_growth]
,[SizeMb] = ff.[SizeMb]
,[DiffSizeMb] = round(ff.[SizeMb]-f.[SizeMb],3)
when not matched by target then
insert (
[Server]
,[Name]
,[Drive]
,[Physical_Name]
,[Ext]
,[Growth]
,[IsPercentGrowth]
,[DB_ID]
,[DB_Name]
,[SizeMb]
,[File_ID]
,[DiffSizeMb]
)
values (
ff.[Server]
,ff.[FileName]
,ff.[Drive]
,ff.[Physical_Name]
,ff.[Ext]
,ff.[Growth]
,ff.[is_percent_growth]
,ff.[database_id]
,ff.[DB_Name]
,ff.[SizeMb]
,ff.[File_id]
,0
)
when not matched by source and f.[Server]=@@SERVERNAME then delete;
END
GO
```
4.2) для логических дисков:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [srv].[MergeDriverInfo]
AS
BEGIN
SET NOCOUNT ON;
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
declare @Drivers table (
[Server] nvarchar(255),
Name nvarchar(8),
TotalSpace float,
FreeSpace float,
DiffFreeSpace float NULL
);
insert into @Drivers (
[Server],
Name,
TotalSpace,
FreeSpace
)
select [Server],
Name,
TotalSpace,
FreeSpace
from srv.Drivers
where [Server]=@@SERVERNAME;
declare @TotalSpace float;
declare @FreeSpace float;
declare @DrivePath nvarchar(8);
while(exists(select top(1) 1 from @Drivers where DiffFreeSpace is null))
begin
select top(1)
@DrivePath=Name
from @Drivers
where DiffFreeSpace is null;
exec srv.sp_DriveSpace @DrivePath = @DrivePath
, @TotalSpace = @TotalSpace out
, @FreeSpace = @FreeSpace out;
update @Drivers
set TotalSpace=@TotalSpace
,FreeSpace=@FreeSpace
,DiffFreeSpace=case when FreeSpace>0 then round(FreeSpace-@FreeSpace,3) else 0 end
where Name=@DrivePath;
end
;merge [srv].[Drivers] as d
using @Drivers as dd
on d.Name=dd.Name and d.[Server]=dd.[Server]
when matched then
update set UpdateUTcDate = getUTCDate()
,[TotalSpace] = dd.[TotalSpace]
,[FreeSpace] = dd.[FreeSpace]
,[DiffFreeSpace]= dd.[DiffFreeSpace];
END
GO
```
5) создать представления для вывода информации:
5.1) для файлов баз данных:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
create view [srv].[vDBFiles] as
SELECT [DBFile_GUID]
,[Server]
,[Name]
,[Drive]
,[Physical_Name]
,[Ext]
,[Growth]
,[IsPercentGrowth]
,[DB_ID]
,[File_ID]
,[DB_Name]
,[SizeMb]
,[DiffSizeMb]
,round([SizeMb]/1024,3) as [SizeGb]
,round([DiffSizeMb]/1024,3) as [DiffSizeGb]
,round([SizeMb]/1024/1024,3) as [SizeTb]
,round([DiffSizeMb]/1024/1024,3) as [DiffSizeTb]
,round([DiffSizeMb]/([SizeMb]/100), 3) as [DiffSizePercent]
,[InsertUTCDate]
,[UpdateUTCdate]
FROM [srv].[DBFile];
GO
```
5.2) для логических дисков:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
create view [srv].[vDrivers] as
select
[Driver_GUID]
,[Server]
,[Name]
,[TotalSpace] as [TotalSpaceByte]
,[FreeSpace] as [FreeSpaceByte]
,[DiffFreeSpace] as [DiffFreeSpaceByte]
,round([TotalSpace]/1024, 3) as [TotalSpaceKb]
,round([FreeSpace]/1024, 3) as [FreeSpaceKb]
,round([DiffFreeSpace]/1024, 3) as [DiffFreeSpaceKb]
,round([TotalSpace]/1024/1024, 3) as [TotalSpaceMb]
,round([FreeSpace]/1024/1024, 3) as [FreeSpaceMb]
,round([DiffFreeSpace]/1024/1024, 3) as [DiffFreeSpaceMb]
,round([TotalSpace]/1024/1024/1024, 3) as [TotalSpaceGb]
,round([FreeSpace]/1024/1024/1024, 3) as [FreeSpaceGb]
,round([DiffFreeSpace]/1024/1024/1024, 3) as [DiffFreeSpaceGb]
,round([TotalSpace]/1024/1024/1024/1024, 3) as [TotalSpaceTb]
,round([FreeSpace]/1024/1024/1024/1024, 3) as [FreeSpaceTb]
,round([DiffFreeSpace]/1024/1024/1024/1024, 3) as [DiffFreeSpaceTb]
,round([FreeSpace]/([TotalSpace]/100), 3) as [FreeSpacePercent]
,round([DiffFreeSpace]/([TotalSpace]/100), 3) as [DiffFreeSpacePercent]
,[InsertUTCDate]
,[UpdateUTCdate]
FROM [srv].[Drivers]
GO
```
6) создать задание в Агенте и запускать раз в сутки:
```
USE [ИМЯ_БАЗЫ_ДАННЫХ];
GO
exec srv.MergeDBFileInfo;
exec srv.MergeDriverInfo;
```
7) собрать всю полученную информацию с серверов (также можно через задание агента или другим иным способом)
8) создать хранимую процедуру для формирования отчета и отправки администраторам. Реализовать можно по разному. Поэтому приведу лишь пример:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [srv].[GetHTMLTableShortInfoDrivers]
@body nvarchar(max) OUTPUT
AS
BEGIN
SET NOCOUNT ON;
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
declare @tbl table (
Driver_GUID uniqueidentifier
,[Name] nvarchar(255)
,[TotalSpaceGb] float
,[FreeSpaceGb] float
,[DiffFreeSpaceMb] float
,[FreeSpacePercent] float
,[DiffFreeSpacePercent] float
,UpdateUTCDate datetime
,[Server] nvarchar(255)
,ID int identity(1,1)
);
declare
@Driver_GUID uniqueidentifier
,@Name nvarchar(255)
,@TotalSpaceGb float
,@FreeSpaceGb float
,@DiffFreeSpaceMb float
,@FreeSpacePercent float
,@DiffFreeSpacePercent float
,@UpdateUTCDate datetime
,@Server nvarchar(255)
,@ID int;
insert into @tbl(
Driver_GUID
,[Name]
,[TotalSpaceGb]
,[FreeSpaceGb]
,[DiffFreeSpaceMb]
,[FreeSpacePercent]
,[DiffFreeSpacePercent]
,UpdateUTCDate
,[Server]
)
select Driver_GUID
,[Name]
,[TotalSpaceGb]
,[FreeSpaceGb]
,[DiffFreeSpaceMb]
,[FreeSpacePercent]
,[DiffFreeSpacePercent]
,UpdateUTCDate
,[Server]
from srv.vDrivers
where [DiffFreeSpacePercent]<=-5
or [FreeSpacePercent]<=15
order by [Server] asc, [Name] asc;
if(exists(select top(1) 1 from @tbl))
begin
set @body='В ходе анализа были выявлены следующие носители иформации, у которых либо свободного объема осталось меньше 15%, либо свободное место уменьшается свыше 5% за день:
'+'
';
set @body=@body+'|';
set @body=@body+' ';
set @body=@body+'№ п/п';
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+'ГУИД';
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+'СЕРВЕР';
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+'ТОМ';
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+'ЕМКОСТЬ, ГБ.';
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+'СВОБОДНО, ГБ.';
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+'ИЗМЕНЕНИЕ СВОБОДНОГО МЕСТА, МБ.';
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+'СВОБОДНО, %';
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+'ИЗМЕНЕНИЕ СВОБОДНОГО МЕСТА, %';
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+'UTC ВРЕМЯ ОБНАРУЖЕНИЯ';
set @body=@body+' |';
set @body=@body+'
';
while((select top 1 1 from @tbl)>0)
begin
set @body=@body+'|';
select top 1
@Driver\_GUID = Driver\_GUID
,@Name = Name
,@TotalSpaceGb = TotalSpaceGb
,@FreeSpaceGb = FreeSpaceGb
,@DiffFreeSpaceMb = DiffFreeSpaceMb
,@FreeSpacePercent = FreeSpacePercent
,@DiffFreeSpacePercent = DiffFreeSpacePercent
,@UpdateUTCDate = UpdateUTCDate
,@Server = [Server]
,@ID = [ID]
from @tbl;
set @body=@body+' ';
set @body=@body+cast(@ID as nvarchar(max));
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+cast(@Driver\_GUID as nvarchar(255));
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+coalesce(@Server,'');
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+coalesce(@Name,'');
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+cast(@TotalSpaceGb as nvarchar(255));
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+cast(@FreeSpaceGb as nvarchar(255));
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+cast(@DiffFreeSpaceMb as nvarchar(255));
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+cast(@FreeSpacePercent as nvarchar(255));
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+cast(@DiffFreeSpacePercent as nvarchar(255));
set @body=@body+' |';
set @body=@body+' ';
set @body=@body+rep.GetDateFormat(@UpdateUTCDate, default)+' '+rep.GetTimeFormat(@UpdateUTCDate, default);
set @body=@body+' |';
delete from @tbl
where ID=@ID;
set @body=@body+'
';
end
set @body=@body+'
';
set @body=@body+'
Для более детальной информации обратитесь к представлению SRV.srv.vDrivers
Для просмотра информации по файлам баз данных обратитесь к представлению ИМЯ_БАЗЫ_ДАННЫХ.srv.vDBFiles';
end
END
GO
``` | https://habr.com/ru/post/314522/ | null | ru | null |
# Понимая, как используется дисковое пространство в Linux
***Прим перев.**: Автор оригинальной статьи — испанский Open Source-энтузиаст [nachoparker](https://github.com/nachoparker), развивающий проект [NextCloudPlus](https://ownyourbits.com/nextcloudplus/) (ранее известен как NextCloudPi), — делится своими знаниями об устройстве дисковой подсистемы в Linux, делая важные уточнения в ответах на простые, казалось бы, вопросы…*
Сколько пространства занимает этот файл на жёстком диске? Сколько свободного места у меня есть? Сколько ещё файлов я смогу вместить в оставшееся пространство?
Ответы на эти вопросы кажутся очевидными. У всех нас есть инстинктивное понимание работы файловых систем и зачастую мы представляем хранение файлов на диске аналогично заполнению корзины яблоками.
Однако в современных Linux-системах такая интуиция может вводить в заблуждение. Давайте разберёмся, почему.
Размер файла
------------
Что такое размер файла? Ответ вроде бы прост: совокупность всех байтов его содержимого, от начала до конца файла.
Зачастую всё содержимое файла представляется как расположенное байт за байтом:
Так же мы воспринимаем и понятие *размер файла*. Чтобы его узнать, выполняем `ls -l file.c` или команду [`stat`](https://linux.die.net/man/1/stat) (т.е. `stat file.c`), которая делает системный вызов [`stat()`](https://en.wikipedia.org/wiki/Stat_(system_call)).
В ядре Linux структурой памяти, представляющей файл, является *inode*. И метаданные, к которым мы обращаемся с помощью команды `stat`, находятся именно в inode.
Фрагмент `include/linux/fs.h`:
```
struct inode {
/* excluded content */
loff_t i_size; /* file size */
struct timespec i_atime; /* access time */
struct timespec i_mtime; /* modification time */
struct timespec i_ctime; /* change time */
unsigned short i_bytes; /* bytes used (for quota) */
unsigned int i_blkbits; /* block size = 1 << i_blkbits */
blkcnt_t i_blocks; /* number of blocks used */
/* excluded content */
}
```
Здесь можно увидеть знакомые атрибуты, такие как время доступа и модификации, а также `i_size` — это и есть *размер файла*, как он был определён выше.
Размышлять в терминах *размера файла* интуитивно понятно, но больше нас интересует, как *в действительности* используется пространство.
Блоки и размер блока
--------------------
Для внутреннего хранения файла файловая система разбивает хранилище на *блоки*. Традиционным размером блока были 512 байт, но более актуальное значение — 4 килобайта. Вообще же при выборе этого значения руководствуются поддерживаемым размером страницы на типовом оборудовании MMU *(memory management unit, «[устройство управления памятью](https://ru.wikipedia.org/wiki/%D0%91%D0%BB%D0%BE%D0%BA_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C%D1%8E)» — **прим. перев.**)*.
Файловая система вставляет порезанный на части *(chunks)* файл в эти блоки и следит за ними в метаданных. В идеале всё выглядит так:
… но в действительности файлы постоянно создаются, изменяются в размере, удаляются, поэтому реальная картина такова:
Это называется *внешней фрагментацией* *([external fragmentation](https://en.wikipedia.org/wiki/Fragmentation_(computing)#External_fragmentation))* и обычно приводит к падению производительности. Причина — вращающейся головке жёсткого диска приходится переходить с места на место, чтобы собрать все фрагменты, а это медленная операция. Решением данной проблемы занимаются классические инструменты дефрагментации.
Что происходит с файлами меньше 4 КБ? Что происходит с содержимым последнего блока после того, как файл был порезан на части? Естественным образом будет возникать неиспользуемое пространство — это называется *внутренней фрагментацией ([internal fragmentation](https://en.wikipedia.org/wiki/Fragmentation_(computing)#Internal_fragmentation))*. Очевидно, этот побочный эффект нежелателен и может привести к тому, что многое свободное пространство не будет использоваться, особенно если у нас большое количество очень маленьких файлов.
Итак, *реальное использование диска* файлом можно увидеть с помощью `stat`, `ls -ls file.c` или `du file.c`. Например, содержимое 1-байтового файла всё равно занимает 4 КБ дискового пространства:
```
$ echo "" > file.c
$ ls -l file.c
-rw-r--r-- 1 nacho nacho 1 Apr 30 20:42 file.c
$ ls -ls file.c
4 -rw-r--r-- 1 nacho nacho 1 Apr 30 20:42 file.c
$ du file.c
4 file.c
$ dutree file.c
[ file.c 1 B ]
$ dutree -u file.c
[ file.c 4.00 KiB ]
$ stat file.c
File: file.c
Size: 1 Blocks: 8 IO Block: 4096 regular file
Device: 2fh/47d Inode: 2185244 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 1000/ nacho) Gid: ( 1000/ nacho)
Access: 2018-04-30 20:41:58.002124411 +0200
Modify: 2018-04-30 20:42:24.835458383 +0200
Change: 2018-04-30 20:42:24.835458383 +0200
Birth: -
```
Таким образом, мы смотрим на две величины: размер файла и использованные блоки. Мы привыкли думать в терминах первого, однако должны — в терминах последнего.
Специфичные для файловой системы возможности
--------------------------------------------
Помимо актуального содержимого файла ядру также необходимо хранить все виды метаданных. Метаданные inode'а мы уже видели, но есть и другие данные, с которыми знаком каждый пользователь UNIX: *права доступа*, [владелец](https://ru.wikipedia.org/wiki/%D0%98%D0%B4%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80_%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8F), *uid*, *gid*, флаги, [ACL](https://ru.wikipedia.org/wiki/ACL).
```
struct inode {
/* excluded content */
struct fown_struct f_owner;
umode_t i_mode;
unsigned short i_opflags;
kuid_t i_uid;
kgid_t i_gid;
unsigned int i_flags;
/* excluded content */
}
```
Наконец, существуют ещё и другие структуры — вроде *суперблока (superblock)* с представлением самой файловой системы, *[vfsmount](https://github.com/torvalds/linux/blob/cdface5209349930ae1b51338763c8e029971b97/include/linux/mount.h#L67)* с представлением точки монтирования, а также информация об избыточности, именные пространства и т.п. Как мы увидим далее, некоторые из этих метаданных также могут занимать значительное место.
### Метаданные размещения блоков
Эти данные сильно зависят от используемой файловой системы — в каждой из них по-своему реализовано сопоставление блоков с файлами. Традиционный подход ext2 — таблица `i_block` с прямыми и непрямыми блоками *([direct/indirect blocks](https://en.wikipedia.org/wiki/Inode_pointer_structure))*.
Эту же таблицу можно увидеть в структуре памяти (фрагмент из `fs/ext2/ext2.h`):
```
/*
* Structure of an inode on the disk
*/
struct ext2_inode {
__le16 i_mode; /* File mode */
__le16 i_uid; /* Low 16 bits of Owner Uid */
__le32 i_size; /* Size in bytes */
__le32 i_atime; /* Access time */
__le32 i_ctime; /* Creation time */
__le32 i_mtime; /* Modification time */
__le32 i_dtime; /* Deletion Time */
__le16 i_gid; /* Low 16 bits of Group Id */
__le16 i_links_count; /* Links count */
__le32 i_blocks; /* Blocks count */
__le32 i_flags; /* File flags */
/* excluded content */
__le32 i_block[EXT2_N_BLOCKS];/* Pointers to blocks */
/* excluded content */
}
```
Для больших файлов такая схема приводит к большим накладным расходам, поскольку единственный (большой) файл требует сопоставления тысяч блоков. Кроме того, есть ограничение на размер файла: используя такой метод, 32-битная файловая система ext3 поддерживает файлы не более 8 ТБ. Разработчики ext3 [спасали ситуацию](http://lkml.iu.edu/hypermail/linux/kernel/0606.1/0268.html) поддержкой 48 бит и добавлением *[extents](https://en.wikipedia.org/wiki/Extent_(file_systems))*:
```
struct ext3_extent {
__le32 ee_block; /* first logical block extent covers */
__le16 ee_len; /* number of blocks covered by extent */
__le16 ee_start_hi; /* high 16 bits of physical block */
__le32 ee_start; /* low 32 bits of physical block */
};
```
Идея по-настоящему проста: занимать соседние блоки на диске и просто объявлять, где extent начинается и каков его размер. Таким образом мы можем выделять файлу большие группы блоков, минимизируя количество метаданных и заодно используя более быстрый последовательный доступ.
Примечание для любопытных: у ext4 предусмотрена обратная совместимость, то есть в ней поддерживаются оба метода: *непрямой (indirect)* и *extents*. Увидеть, как распределено пространство, можно на примере операции записи. Запись не идёт напрямую в хранилище — из соображений производительности данные сначала попадают в файловый кэш. После этого в определённый момент кэш записывает информацию на постоянное хранилище.
Кэш файловой системы представлен структурой [`address_space`](https://github.com/torvalds/linux/blob/cdface5209349930ae1b51338763c8e029971b97/include/linux/fs.h#L392), в которой вызывается операция [*writepages*](https://github.com/torvalds/linux/blob/cdface5209349930ae1b51338763c8e029971b97/include/linux/fs.h#L337). Вся последовательность выглядит так:
```
(cache writeback) ext4_aops-> ext4_writepages() -> ... -> ext4_map_blocks()
```
… где `ext4_map_blocks()` вызовет функцию `ext4_ext_map_blocks()` или `ext4_ind_map_blocks()` в зависимости от того, используются ли extents. Если взглянуть на первую в `[extents.c](https://github.com/torvalds/linux/blob/cdface5209349930ae1b51338763c8e029971b97/fs/ext4/extents.c?L=4261#L4261)`, можно увидеть упоминания *дыр (holes)*, о которых будет рассказано ниже.
### Контрольные суммы
Файловые системы последнего поколения хранят также контрольные суммы *(checksums)* для блоков данных во избежание [незаметного повреждения данных](https://en.wikipedia.org/wiki/Data_corruption#Silent). Эта возможность позволяет [обнаруживать и корректировать](https://en.wikipedia.org/wiki/Error_detection_and_correction) случайные ошибки и, конечно, ведёт к дополнительным накладным расходам в использовании диска пропорционально размеру файлов.
Более современные системы вроде BTRFS и ZFS поддерживают контрольные суммы для данных, а у более старых, таких как ext4, реализованы контрольные суммы для метаданных.
### Журналирование
Возможности [журналирования](https://en.wikipedia.org/wiki/Journaling_file_system) для ext2 появились в ext3. Журнал — циклический лог, записывающий обрабатываемые транзакции с целью улучшить устойчивость к сбоям питания. По умолчанию он применяется [только к метаданным](https://ext4.wiki.kernel.org/index.php/Ext4_Disk_Layout#Journal_.28jbd2.29), однако можно его активировать и для данных с помощью опции `data=journal`, что повлияет на производительность.
Это специальный скрытый файл, обычно с номером inode 8 и размером 128 МБ, объяснение про который можно найти в официальной документации:
> Журнал, представленный в файловой системе ext3, используется в ext4 для защиты ФС от повреждений в случае системных сбоев. Небольшой последовательный фрагмент диска (по умолчанию это 128 МБ) зарезервирован внутри ФС как место для сбрасывания «важных» операций записи на диск настолько быстро, насколько это возможно. Когда транзакция с важными данными полностью записана на диск и сброшена с кэша *(disk write cache)*, запись о данных также записывается в журнал. Позже код журнала запишет транзакции в их конечные позиции на диске (операция может приводить к продолжительному поиску или большому числу операций чтения-удаления-стирания) перед тем, как запись об этих данных будет стёрта. В случае системного сбоя во время второй медленной операции записи журнал позволяет воспроизвести все операции вплоть до последней записи, гарантируя атомарность всего, что пишется на диск через журнал. Результатом является гарантия, что файловая система не застрянет на полпути обновления метаданных.
### «Упаковка хвостов»
Возможность tail packing, ещё называемая [блочным перераспределением](https://ru.wikipedia.org/wiki/%D0%91%D0%BB%D0%BE%D1%87%D0%BD%D0%BE%D0%B5_%D0%BF%D0%B5%D1%80%D0%B5%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5) *(block suballocation)*, позволяет файловым системам использовать пустое пространство в конце последнего блока («хвосты») и распределять его среди различных файлов, эффективно упаковывая «хвосты» в единый блок.
Замечательно иметь такую возможность, что позволяет сохранить много пространства, особенно если у вас большое количество маленьких файлов… Однако она приводит к тому, что существующие инструменты неточно сообщают об используемом пространстве. Потому что с ней мы не можем просто добавить все занятые блоки всех файлов для получения реальных данных по использованию диска. Эту фичу поддерживают файловые системы BTRFS и ReiserFS.
### Разрежённые файлы
Большинство современных файловых систем поддерживают [разрежённые файлы](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 files)*. У таких файлов могут быть *дыры*, которые в действительности не записаны на диск (не занимают дисковое пространство). На этот раз реальный *размер файла* будет больше, чем используемые блоки.
Такая особенность может оказаться очень полезной, например, для быстрой генерации больших файлов или для предоставления свободного пространства виртуальному жёсткому диску виртуальной машины по запросу.
Чтобы медленно создать 10-гигабайтный файл, который занимает около 10 ГБ дискового пространства, можно выполнить:
```
$ dd if=/dev/zero of=file bs=2M count=5120
```
Чтобы создать такой же большой файл мгновенно, достаточно лишь записать последний байт… или даже сделать:
```
$ dd of=file-sparse bs=2M seek=5120 count=0
```
Или же воспользоваться командой `truncate`:
```
$ truncate -s 10G
```
Дисковое пространство, выделенное файлу, можно изменить командой `[fallocate](http://man7.org/linux/man-pages/man1/fallocate.1.html)`, которая делает системный вызов `[fallocate()](http://man7.org/linux/man-pages/man2/fallocate.2.html)`. С этим вызовом доступны и более продвинутые операции — например:
* Предварительно выделить пространство для файла вставкой нулей. Такая операция увеличивает и использование дискового пространства, и размер файла.
* Освободить пространство. Операция создаст дыру в файле, делая его разрежённым и уменьшая использование пространства без влияния на размер файла.
* Оптимизировать пространство, уменьшив размер файла и использование диска.
* Увеличить пространство файла, вставив дыру в его конец. Размер файла увеличивается, а использование диска не меняется.
* Обнулить дыры. Дыры станут не записанными на диск extents, которые будут читаться как нули, не влияя на дисковое пространство и его использование.
Например, создать дыры в файле, превратив его в разрежённый, можно так:
```
$ fallocate -d file
```
Команда `cp` поддерживает работу с разрежёнными файлами. С помощью простой эвристики она пытается определить, является ли исходный файл разрежённым: если это так, то результирующий файл тоже будет разрежённым. Скопировать же неразрежённый файл в разрежённый можно так:
```
$ cp --sparse=always file file_sparse
```
… а обратное действие (сделать «плотную» копию разрежённого файла) выглядит так:
```
$ cp --sparse=never file_sparse file
```
Таким образом, если вам нравится работать с разрежёнными файлами, можете добавить следующий алиас в окружение своего терминала (`~/.zshrc` или `~/.bashrc`):
```
alias cp='cp --sparse=always'
```
Когда процессы читают байты в секциях *дыр* файловая система предоставляет им страницы с нулями. Например, можно посмотреть, что происходит, когда файловый кэш читает из файловой системы в области дыр в ext4. В этом случае последовательность в `[readpage.c](https://github.com/torvalds/linux/blob/cdface5209349930ae1b51338763c8e029971b97/fs/ext4/readpage.c)` будет выглядеть примерно так:
`(cache read miss) ext4_aops-> ext4_readpages() -> ... -> zero_user_segment()`
После этого сегмент памяти, к которому процесс пытается обратиться с помощью системного вызова `read()`, получит нули напрямую из быстрой памяти.
### Файловые системы COW (copy-on-write)
Следующее (после семейства ext) поколение файловых систем принесло очень интересные возможности. Пожалуй, наибольшего внимания среди фич файловых систем вроде ZFS и BTRFS заслуживает их COW (copy-on-write, «[копирование при записи](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BF%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%B8_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D0%B8)»).
Когда мы выполняем операцию *copy-on-write* или *клонирования*, или *копии reflink*, или *поверхностной (shallow) копии*, на самом деле никакого дублирования extent'ов не происходит. Просто создаётся аннотация в метаданных для нового файла, которая отсылает к тем же самым extents оригинального файла, а сам extent помечается как *разделяемый (shared)*. При этом в пользовательском пространстве создаётся иллюзия, что существуют два отдельных файла, которые можно отдельно модифицировать. Когда какой-то процесс захочет написать в разделяемый extent, ядро сначала создаст его копию и аннотацию, что этот extent принадлежит единственному файлу (по крайней мере, на данный момент). После этого у двух файлов появляется больше отличий, однако они все ещё могут разделять многие extents. Другими словами, extents в файловых системах с поддержкой COW можно делить между файлами, а ФС обеспечит создание новых extents только в случае необходимости.
Как видно, клонирование — очень быстрая операция, не требующая удваивания пространства, которое используется в случае обычной копии. Именно эта технология и стоит за возможностью создания мгновенных снапшотов в BTRFS и ZFS. Вы можете буквально клонировать (или [сделать снапшот](https://ownyourbits.com/2017/12/27/schedule-btrfs-snapshots-with-btrfs-snp/)) всей корневой файловой системы меньше чем за секунду. Очень полезно, например, перед обновлением пакетов на случай, если что-то сломается.
BTRFS поддерживает два метода создания shallow-копий. Первый относится к *подтомам (subvolumes)* и использует команду `btrfs subvolume snapshot`. Второй — к отдельным файлам и использует `cp --reflink`. Такой алиас (опять же, для `~/.zshrc` или `~/.bashrc`) может пригодиться, если вы хотите по умолчанию делать быстрые shallow-копии:
`cp='cp --reflink=auto --sparse=always'`
Следующий шаг — если есть не-shallow-копии или файл, или даже файлы, с дублирующимися extents, можно [*дедуплицировать*](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%B4%D1%83%D0%BF%D0%BB%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D1%8F) их, чтобы они использовали (через reflink) общие extents и освободили пространство. Один из инструментов для этого — [duperemove](https://github.com/markfasheh/duperemove), однако учтите, что это естественным образом приводит к более высокой фрагментации файлов.
Если мы попытаемся теперь разобраться, как дисковое пространство используется файлами, всё будет не так просто. Утилиты вроде `du` или [dutree](https://ownyourbits.com/2018/03/25/analize-disk-usage-with-dutree/) всего лишь считают используемые блоки, не учитывая, что некоторые из них могут быть разделяемыми, поэтому они покажут больше занятого места, чем на самом деле используется.
Аналогичным образом, в случае BTRFS стоит избегать команды `df`, поскольку пространство, занятое файловой системой BTRFS, она покажет как свободное. Лучше пользоваться `btrfs filesystem usage`:
```
$ sudo btrfs filesystem usage /media/disk1
Overall:
Device size: 2.64TiB
Device allocated: 1.34TiB
Device unallocated: 1.29TiB
Device missing: 0.00B
Used: 1.27TiB
Free (estimated): 1.36TiB (min: 731.10GiB)
Data ratio: 1.00
Metadata ratio: 2.00
Global reserve: 512.00MiB (used: 0.00B)
Data,single: Size:1.33TiB, Used:1.26TiB
/dev/sdb2 1.33TiB
Metadata,DUP: Size:6.00GiB, Used:3.48GiB
/dev/sdb2 12.00GiB
System,DUP: Size:8.00MiB, Used:192.00KiB
/dev/sdb2 16.00MiB
Unallocated:
/dev/sdb2 1.29TiB
$ sudo btrfs filesystem usage /media/disk1
Overall:
Device size: 2.64TiB
Device allocated: 1.34TiB
Device unallocated: 1.29TiB
Device missing: 0.00B
Used: 1.27TiB
Free (estimated): 1.36TiB (min: 731.10GiB)
Data ratio: 1.00
Metadata ratio: 2.00
Global reserve: 512.00MiB (used: 0.00B)
Data,single: Size:1.33TiB, Used:1.26TiB
/dev/sdb2 1.33TiB
Metadata,DUP: Size:6.00GiB, Used:3.48GiB
/dev/sdb2 12.00GiB
System,DUP: Size:8.00MiB, Used:192.00KiB
/dev/sdb2 16.00MiB
Unallocated:
/dev/sdb2 1.29TiB
```
К сожалению, я не знаю простых способов отслеживания занятого пространства отдельными файлами в файловых системах с COW. На уровне подтома с помощью утилит вроде [btrfs-du](https://ownyourbits.com/2017/12/06/check-disk-space-of-your-btrfs-snapshots-with-btrfs-du/) мы можем получить приблизительное представление о количестве данных, которые уникальны для снапшота и которые разделяются между снапшотами.
Ссылки
------
* [Comparison oа file systems, Wikipedia](https://en.wikipedia.org/wiki/Comparison_of_file_systems);
* [Ext3 for large filesystems, LWN](https://lwn.net/Articles/187321/);
* [Ext4 (and Ext2/Ext3) Wiki](https://ext4.wiki.kernel.org/index.php/Main_Page).
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[В защиту swap'а [в Linux]: распространенные заблуждения](https://habr.com/company/flant/blog/348324/)»;
* «[Rook — «самообслуживаемое» хранилище данных для Kubernetes](https://habr.com/company/flant/blog/348044/)»;
* «[Создаём постоянное хранилище с provisioning в Kubernetes на базе Ceph](https://habr.com/company/flant/blog/329666/)». | https://habr.com/ru/post/354802/ | null | ru | null |
# Терминология OneGet, NuGet, Chocolatey, PowerShellGet — разложим по полочкам
В этой статье я хочу помочь разобраться в структуре пакетных менеджеров под Windows. Статья нацелена больше на тех, кто, как и я, пришли из мира Linux, где принято заходить в понимание процессов ниже уровня абстракций.
Уверен, что абстракции вы уже прочитали и без меня:
> chocolatey для установки приложений, nuget — для установки зависимостей разработчиком.
Но это мало того грубо, так еще и неправда.
Итак, какие типы пакетов мы знаем из мира Linux? Внимание: не пакетные менеджеры, а именно сами пакеты. Самые распространенные условно делятся на две группы: ОС-зависимые (deb, rpm) или языко-зависимые (как правило, tar-болы). В принципе можно сказать, что первая группа — это приложения (утилиты), а вторые — зависимости (библиотеки). Но иногда это не так: среди пакетов ОС есть библиотеки, а среди языковых пакетов есть пакеты, устанавливающие еще и утилиты (например stdeb в pip или elastalert в npm) — если их устанавливать глобально, то получится как пакет ОС.
Возвращаемся к Windows.
Изначально здесь придумали тоже формат пакета. Сделан он был на замену старому формату msi/msu потому, что старый формат имел достаточно высокий входной порог для понимания, как его автоматизировать [вполне вероятно, что я сейчас брежу]. В общем и целом новый формат очень похож на rpm. У него даже есть spec-файл. Имя ему — NuGet, но расширение .nupkg. Внутри этого пакета есть директории, файлы и инсталляционные скрипты — все нам, линуксойдам, привычно и знакомо.
Теперь давайте вспомним, какие пакетные менеджеры мы знаем. Для ОС это apt, yum,… Для языковых: pip, gem, npm, cpan, cpm,…
Что для Windows? Тут мы знакомимся с новым NuGet. Есть NuGet-пакет, а есть одноименный nuget.exe — утилита, которая умеет эти пакеты скачивать и разархивировать. Вообще, она умеет много другое, но это за пределами обсуждаемого вопроса.
Какой расклад мы получаем:
Debian: apt(deb) + pip + npm + gem +…
RHEL: yum(rpm) + pip + npm + gem +…
Windows: nuget(nupkg) + pip + npm + gem +…
Обратите внимание, для msi пакетного менеджера так и не создали (это не совсем так, но пока для простоты).
И вот здесь начинается отличие от Linux. В мире Windows появился какой-то талантливый парень, который решил, что он хочет устанавливать все одной командой. И начал писать open-source'ный проект OneGet (его проприетарное название: PackageManager, который является одним из модулей PowerShell версии >=5.0).
OneGet — это абстрактный интерфейс, который умеет разговаривать с каждым пакетным менеджером на его языке. OneGet публикует для нас набор унифицированных команд. Например, команду Install-Package, которая является wrapper'ом каждый раз для разных команд.
Что получается: мы подключаем к OneGet несколько пакетных менеджеров. Например: NuGet, PIP, NPM.
Далее, если мы хотим поставить какой-то питоний пакет, то мы пишем:
```
Install-Package <имя pip-пакета>
```
OneGet преобразует это в:
```
pip install <имя pip-пакета>
```
А теперь мы хотим поставить пакет NuGet и запускаем:
```
Install-Package <имя nupkg-пакета>
```
В этот раз команда вызвала:
```
nuget install <имя nupkg-пакета>
```
Я соврал. На самом деле Install-Package не вызывает эти команды в бэкграунде — пакетные менеджеры более не используются. Выпали из пищевой цепочки. Вместо них установлены специализированные пакетные провайдеры (считайте плагины PowerShell) для управления инородными пакетами. И эти провайдеры занимаются задачей установки вместо привычных нам пакетных менеджеров. А OneGet над ними начальник. За зависимостями следят сами провайдеры.
И тут мы знакомимся с третьим NuGet — NuGet-пакетный провайдер. Я с самого начала статьи мечтал взорвать ваш мозг: NuGet — это пакетный провайдер, который пришел на смену пакетному менеджеру NuGet(nuget.exe), чтобы управлять пакетами NuGet(.nupkg).
Здесь очень важный момент. Старые пакетные менеджеры имели каждый свой список репозиториев (Source в терминологии Windows):
```
PS C:\> nuget source list
Registered Sources:
1. nuget.org [Enabled]
https://api.nuget.org/v3/index.json
2. ABC [Enabled]
http://<тут_я_спрятал_IP>/artifactory/api/nuget/<имя_репо>
```
Или:
```
PS C:\> gem sources
*** CURRENT SOURCES ***
https://rubygems.org
```
OneGet опирается не на них, а на заменивших их провайдеров. А список репозиториев один для всех, но с указанием, кому какой репозиторий принадлежит — по аналогии с внешними ключами БД.
Смотрим сначала список пакетных провайдеров:
```
PS C:\> Get-PackageProvider
Name Version DynamicOptions
---- ------- --------------
Chocolatey 2.8.5.130 SkipDependencies, ContinueOnFailure, ExcludeVers
ChocolateyGet 1.0.0.1 AdditionalArguments
msi 3.0.0.0 AdditionalArguments
msu 3.0.0.0
NuGet 2.8.5.208 Destination, ExcludeVersion, Scope, SkipDependen
PowerShellGet 1.0.0.1 PackageManagementProvider, Type, Scope, AllowClo
Programs 3.0.0.0 IncludeWindowsInstaller, IncludeSystemComponent
```
А теперь смотрим кому какой репозиторий принадлежит:
```
PS C:\> Get-PackageSource
Name ProviderName IsTrusted Location
---- ------------ --------- --------
nuget.org NuGet False https://api.nuget.org/v3/index.json
PSGallery PowerShellGet False https://www.powershellgallery....
chocolatey Chocolatey False http://chocolatey.org/api/v2/
```
Теперь я сделаю паузу и отвлекусь на один из странных пакетных провайдеров — PowerShellGet. Этот провайдер призван устанавливать модули самого PowerShell. Появился он в PowerShell 2 — еще до прихода PackageManager(aka OneGet). Но они друг другу не ровня. PowerShellGet — это один из рядовых пакетных провайдеров, умеющих делать только свой тип пакетов, а не управленец пакетными провайдерами, как OneGet.
Его тип пакетов — .nupkg, содержимое которых — модули PowerShell. Поэтому не удивляйтесь, что его репозиторий PSGallery имеет формат NuGet:
```
PS C:\> Get-PSRepository -Name "PSGallery" | Format-List * -Force
Name : PSGallery
SourceLocation : https://www.powershellgallery.com/api/v2/
Trusted : False
Registered : True
InstallationPolicy : Untrusted
PackageManagementProvider : NuGet
PublishLocation : https://www.powershellgallery.com/api/v2/package/
ScriptSourceLocation : https://www.powershellgallery.com/api/v2/items/psscript/
ScriptPublishLocation : https://www.powershellgallery.com/api/v2/package/
ProviderOptions : {}
```
И сейчас вы могли заметить следующую тонкость: список репозиториев в PackageManager выполняется командой Get-PackageSource, а не Get-PSRepository.
Дело в том, что работа этого модуля, как я сказал выше, устанавливать модули PowerShell. В комплект установки входит и регистрация новых командлетов, что он и сделал. Этот командлет дает дополнительные поля при регистрации репозитория (например PublishLocation). Этого не видно, если использовать стандартный командлет:
```
PS C:\> Get-PackageSource -Name "PSGallery" | Format-List * -Force
Name : PSGallery
Location : https://www.powershellgallery.com/api/v2/
Source : PSGallery
ProviderName : PowerShellGet
Provider : Microsoft.PackageManagement.Implementation.PackageProvider
IsTrusted : False
IsRegistered : True
IsValidated : False
Details : {[ScriptPublishLocation, https://www.powershellgallery.com/api/v2/package/], [InstallationPolicy, Untrusted], [PackageManagementProvider, NuGet],
[ScriptSourceLocation, https://www.powershellgallery.com/api/v2/items/psscript/]...}
```
Последнее: Chocolatey.
Вот все говорят, что Chocolatey — надстройка над NuGet. Оно как бы так, но не совсем. Chocolatey использует те же spec'и, но не полностью. Вместо полноценного пакета он зачастую использует скачивание .msi или чего угодно другого и последующую silent-установку. То есть в то время, как пакетный провайдер NuGet или пакетный менеджер nuget.exe устанавливает только нативные NuGet-пакеты, Chocolatey устанавливает их же + все то, что что другие устанавливать не умеют. Поэтому база пакетов Chocolatey такая внушительная по сравнению с базой NuGet. И поэтому в пакетах Chocolatey столько скриптов много.
Возможно вы заметили, что есть два провайдера Chocolatey и ChocolateyGet. Первый — самодельная времянка. Второй — официальный провайдер, который недавно только вышел. Ну вы видите по версиям. | https://habr.com/ru/post/331124/ | null | ru | null |
# Обзор новых возможностей С++14: Часть 2
На этот раз нововведений гораздо меньше, чем в первой части. Все-таки С++14 считается незначительным релизом, нацеленным скорее на устранение недочетов С++11, чем привнесение новых возможностей.
Краткий перечень:
* Освобождение памяти определенного размера
* Одинарная кавычка, как цифровой разделитель
* Аттрибут `[[deprecated]]`
* Пользовательские литералы для `std::complex`
* Filesystem API
* Преобразование сетевого порядка байт
[Обзор новых возможностей С++14: Часть 1](http://habrahabr.ru/post/184606/)
[Текущий черновик стандарта](http://isocpp.org/files/papers/N3797.pdf)
### Изменения в самом языке
#### Освобождение памяти определенного размера
В C++11 программисты могут определить статический метод класса `operator delete`, который бы принимал параметром размер удалямого объекта. Теперь же в стандарт был добавлен соответствующий глобальный оператор `delete`. Это изменение призвано повысить производительность современных распределителей памяти.
Добавленные операторы имеют следующие сигнатуры:
```
void operator delete(void* ptr, std::size_t size) noexcept;
void operator delete(void* ptr, std::size_t size, const std::nothrow_t&) noexcept;
void operator delete[](void* ptr, std::size_t size) noexcept;
void operator delete[](void* ptr, std::size_t size, const std::nothrow_t&) noexcept;
```
Основной возникшей здесь проблемой совместимости является случай, когда используются новая системная и старая пользовательская библиотеки распределения памяти. В новых программах, вызовы к оператору, не принимающему размер, будут направляться в пользовательскую библиотеку, а вызовы с размером — в системную библиотеку. На данный момент, стандартное поведение операторов с размером — это вызов соответствующих операторов без размера, поэтому проблем пока не будет, а пользователям, желающим получить прирост приозводительности, необходимо будет добавить соответствующие версии операторов самим. Однако в будущих версиях стандарта планируется изменить это поведение. Таким образом, комитет дает программистам время адаптировать их распределители памяти, во избежание неожиданно возникших проблем.
#### Одинарная кавычка, как цифровой разделитель
Теперь можно будет использовать одинарные кавычки для обособления порядков чисел. Например, числа `1048576`, `1'048'576`, `1'0'4'8'5'7'6`, `0X100000`, `0x10'0000`, и `0'004'000'000` имеют одно и тоже значение.
Однако это изменение приводит к следующим проблемам:
Во-первых, изменяется поведение расширения макросов. Например:
```
#define M(x, ...) __VA_ARGS__
int x[2] = { M(1'2,3'4) };
// C++11: int x[2] = {};
// Now: int x[2] = { 3'4 };
```
А во-вторых, множество редакторов и других утилит, предназначенных для подсветки синтаксиса, будут теперь неправильно парсить код. Даже Хабрахабр не устоял, сравните:
```
int testing_habrahabr_syntax_highlighter = 1000;
```
```
int testing_habrahabr_syntax_highlighter = 1'000;
```
```
int testing_habrahabr_syntax_highlighter = 1'000'000;
```
```
int testing_habrahabr_syntax_highlighter = 1'0'0'0'0'0'0;
```
#### Аттрибут `[[deprecated]]`
В C++11 был стандартизирован синтаксис объявления аттрибутов, ранее известных как \_\_attribute\_\_ для gcc/clang и \_\_declspec для VC++. В C++14 был добавлен аттрибут, позволяющий пометить любой из следующих токенов: класс, переменную, нестатический член класса, функцию, перечисление, специализацию шаблона или typedef — как устаревший, если по каким-либо причинам дальнейшее их использование нежелательно. В результате, при использовании программистом помеченных таким аттрибутом токенов, компилятор будет выдавать предупреждение. Опциональный параметр аттрибута позволяет указать свое дополнительное сообщение (например, предложение о подходящей замене), которое будет выведено вместе с предупреждением компилятора.
```
void foo();
[[deprecated("use 'foo' instead")]] void bar();
```
Допускается переобъявление токенов с этим аттрибутом, если Вы, например, хотите запретить своей команде разработчиков использовать некоторые функции из сторонних библиотек, однако снять действие этого аттрибута переобъявлением нельзя.
```
#include
[[deprecated("use 'glDrawArrays' instead")]] void glBegin(GLenum);
```
На усмотрение разработчиков STL, все подходящие токены, указанные в дополнении D к стандарту C++ (Compatibility features), могут быть помечены этим аттрибутом.
### Изменения в стандартной библиотеке
#### Пользовательские литералы для `std::complex`
Добавлены следующие литералы для быстрого создания комплексных чисел, состоящих только из мнимой части:
```
namespace std {
inline namespace literals {
inline namespace complex_literals {
constexpr complex operator""il(long double);
constexpr complex operator""il(unsigned long long);
constexpr complex operator""i(long double);
constexpr complex operator""i(unsigned long long);
constexpr complex operator""if(long double);
constexpr complex operator""if(unsigned long long);
}}}
```
В результате можно легко и просто создавать комплексные числа привычными арифметическими операциями:
```
using namespace std;
complex a = 1.5 + 0.3i;
auto b = 2.3 - 0.2i;
```
### Технические спецификации
Как показано на изображении, до 2011 комитет использовал «монолитную» модель, где все новые возможности попадали в единственный черновик стандарта.
Начиная с 2012 комитет перешел на более «распределенную» модель, где основные направления разработки стандарта ведутся независимо от самого стандарта со своей скоростью и могут быть выпущены как только будут готовы, не дожидаясь выхода основного стандарта, в виде технических спецификаций (ТС), с последующим слиянием вместе с ним через некоторое время. Такая модель позволяет комитету представлять работу публике небольшими частями более быстрым и предсказуемым способом. Это также должно ускорить выпуск новых версий самого стандарта.
На данный момент уже одобрен [черновик](http://isocpp.org/files/papers/n3790.html) технической спецификации API для работы с файловой системой, основанный на Boost.Filesystem v3, включая итерацию по файлам и директориям.
Активно ведется доработка следующих спецификаций:
1. Networking TS. На данный момент содержит в себе:
* Функции для преобразования порядка байт между сетевым (big-endian) и используемым на локальной машине, основанные на функциях `htonl(), htons(), ntohl(), ntohs()` стандарта POSIX. Уже одобрено комитетом.
* [API](http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3792.html) для работы с URI. Еще ожидает одобрения комитета.
2. Library Fundamentals TS: Представляет из себя набор расширений основной части стандартной библиотеки. Сюда были вынесены `optional<>` и другие фундаментальные утилиты для доработки.
3. Array Extensions TS: Расширения языка и библиотеки связанные с массивами. Сюда были вынесены `runtime-sized arrays` и `dynarray<>` для доработки.
4. Concurrency TS: Изначально включает в себя поддержку [исполнителей (executors) и планировщиков (schedulers)](http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3731.pdf) и поддержку [неблокирующих операций для `std::future`](http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3721.pdf), таких как `.then()` и `.when_*()`. Позже сюда могут быть добавлены расширения языка, типа [`await`](http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3722.pdf), и расширения библиотеки, типа [параллельных хэш-контейнеров](http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3732.pdf).
5. Расширения для параллелизма: Изначально включает в себя параллельную STL библиотеку с поддержкой параллельных алгоритмов, использующих несколько ядер процессора, и векторизуемых (vectorizable) алгоритмов, использующих всю мощь наборов инструкций процессоров.
Все технические спецификации используют пространтсво имен `std::experimental`.
Также недавно начала свою работу группа, занимающаяся графикой, с целью стандартизировать «2D Lite» API для рисования. Небольшое обсуждение графики и C++ можно посмотреть в презентации Герба Саттера с GoingNative2013, начиная с 42:30 [здесь](http://channel9.msdn.com/Events/GoingNative/2013/Keynote-Herb-Sutter-One-Cpp).
### Заключение
Следующая встреча комитета запланирована на февраль 2014 года. После чего мы получим некоторое подобие релиз кандидата следующего — С++14 стандарта, также известного, как С++1y.
По последним данным, Clang вместе с libc++ в SVN уже полностью реализуют текущий черновик стандарта, GCC несколько отстает. Убедиться в этом можно здесь: [Clang](http://clang.llvm.org/cxx_status.html), [libc++](http://libcxx.llvm.org/cxx1y_status.html), [GCC](http://gcc.gnu.org/projects/cxx1y.html).
[Обзор новых возможностей С++14: Часть 1](http://habrahabr.ru/post/184606/)
[Текущий черновик стандарта](http://isocpp.org/files/papers/N3797.pdf)
### P.S. `swap` оператор
Среди всех прочих предложений для стандартизации, прошлой весной появилось предложение внести в С++ специальный оператор обмена :=:, чтобы заменить функцию стандартной библиотеки `std::swap`. Тогда некоторые восприняли это как первоапрельскую шутку, но в конце августа предложение обновилось до версии 2. Мне пока не известно мнение комитета о данном операторе, но его еще пока не одобрили для стандартизации. Подробнее прочитать о нем можно [здесь](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3746.pdf). | https://habr.com/ru/post/198238/ | null | ru | null |
# Выпущен Emacs 24.1
Сегодня была выпущена новая версия рабочей среды (и хорошего редактора) **Emacs** 24.1.
Среди новых возможностей:
* Новая система пакетов (M-x list-packages), упрощающая загрузку и установку расширений. Стандартный репозиторий располагается на сервере GNU и поддерживается разработчиками Emacs.
* Поддержка языков с письмом справа-налево (например, арабского или иврита).
* Поддержка лексической области видимости (lexical scoping) в Emacs Lisp. В ближайшем будущем это позволит добавить в Emacs многопоточность.
* Улучшена система тем (M-x customize-themes) — настройка шрифтов, цветов, и т.п. должна упроститься.
* Улучшенная и универсальная система дополнения кода для множества пакетов и режимов.
* Поддержка библиотек GnuTLS (для встроенного TLS/SSL-шифрования), GTK+ 3, ImageMagick, SELinux и Libxml2.
Полный список улучшений доступен в файле `etc/NEWS`.
Новую версию уже можно скачать на [FTP проекта GNU](ftp://ftp.gnu.org/gnu/emacs/) или на [одном из его зеркал](http://www.gnu.org/order/ftp.html).
**UPD.** Уже доступна [версия для Windows](http://ftp.gnu.org/gnu/emacs/windows/). | https://habr.com/ru/post/145610/ | null | ru | null |
# Новые коды состояния HTTP
На рассмотрение в IETF поданы [спецификации](https://tools.ietf.org/html/draft-nottingham-http-new-status-02) новых кодов состояния HTTP, которые более точно описывают некоторые типичные ситуации.
```
428 Precondition Required
429 Too Many Requests
431 Request Header Fields Too Large
511 Network Authentication Required
```
**Код состояния 428 (precondition required)** означает, что серверу требуются условия выполнения запроса. Это типичная ситуация, когда клиент получает данные по GET, модифицирует их и отправляет назад на сервер через PUT, но к тому времени они уже были модифицированы другим клиентом, из-за чего возникает конфликт. Требуя обусловленного запроса, сервер защищается от возникновения конфликта. При этом обязательно должны быть указаны условия для корректной отправки данных на сервер.
```
HTTP/1.1 428 Precondition Required
Content-Type: text/html
Precondition Required
Precondition Required
=====================
This request is required to be conditional;
try using "If-Match".
```
**Код состояния 429 (too many requests)** означает, что пользователь отправил слишком много запросов в заданный период времени. Ответ должен содержать объяснение нарушенного условия и может содержать заголовок *Retry-After* с указанием времени, которое нужно подождать перед повтором.
```
HTTP/1.1 429 Too Many Requests
Content-Type: text/html
Retry-After: 3600
Too Many Requests
Too many Requests
=================
I only allow 50 requests per hour to this Web site per
logged in user. Try again soon.
```
**Код состояния 431 (request header fields too large)** используется тогда, когда сервер отказывает в обработке запроса из-за того, что один или несколько заголовков в сумме превышают норму. Во втором случае в ответе должно содержаться указание, какой именно заголовок вызвал проблему.
```
HTTP/1.1 431 Request Header Fields Too Large
Content-Type: text/html
Request Header Fields Too Large
Request Header Fields Too Large
===============================
The "Example" header was too large.
```
**Код состояния 511 (network authentication required)** означает, что нужно выполнить аутентификацию, при этом в ответе должна содержаться инструкция о том, как это сделать, например, с помощью HTML-формы по указанному адресу. Ошибку 511 возвращает не целевой сервер, а прокси, который не пускает пользователя в сеть (например, маршрутизатор в зоне платного Wi-Fi при неавторизованном доступе).
Например, пользователь отправляет HTTP-запрос по TCP на порт 80.
```
GET /index.htm HTTP/1.1
Host: www.example.com
```
Логин-сервер возвращает такой ответ.
```
HTTP/1.1 511 Network Authentication Required
Refresh: 0; url=https://login.example.net/
Content-Type: text/html
Network Authentication Required
You need to [authenticate with the local network](https://login.example.net/) in order to get
access.
``` | https://habr.com/ru/post/130902/ | null | ru | null |
# Собирать Docker-образы в werf теперь можно и по обычному Dockerfile
*Лучше поздно, чем никогда. Или как мы чуть не допустили серьёзную ошибку, не имея поддержки обычных Dockerfiles для сборки образов приложения.*
Речь пойдёт про [werf](https://github.com/flant/werf) — GitOps-утилиту, которая интегрируется с любой CI/CD-системой и обеспечивает управление всем жизненным циклом приложения, позволяя:
* собирать и публиковать образы,
* разворачивать приложения в Kubernetes,
* удалять неиспользуемые образы с помощью специальных политик.
Философия проекта — собрать низкоуровневые инструменты в единую унифицированную систему, дающую DevOps-инженерам контроль над приложениями. По возможности должны быть задействованы уже существующие утилиты (вроде Helm и Docker). Если же решения какой-то задачи нет — мы можем создать и поддерживать всё необходимое для этого.
Предыстория: свой сборщик образов
---------------------------------
Так и случилось со сборщиком образов в werf: привычного Dockerfile нам не хватало. Если бегло окунуться в историю проекта, то эта проблема проявилась уже в первых версиях werf (тогда еще [известного как dapp](https://habr.com/ru/company/flant/blog/333682/)).
Создавая инструмент для сборки приложений в Docker-образы, мы быстро поняли, что Dockerfile нам не подходит для некоторых вполне конкретных задач:
1. Необходимость собирать типичные небольшие веб-приложения по следующей стандартной схеме:
* установить общесистемные зависимости приложения,
* установить bundle библиотек зависимостей приложения,
* собрать ассеты,
* и самое важное — обновлять код в образе быстро и эффективно.
2. При изменениях в файлах проекта сборщик должен быстро создавать новый слой путем наложения патча на измененные файлы.
3. Если поменялись определенные файлы, то необходимо пересобирать соответствующую зависимую стадию.
На сегодняшний день в нашем сборщике есть и многие другие возможности, но изначальные желания и позывы были таковы.
В общем, недолго думая, мы вооружились используемым языком программирования *(см. ниже)* и отправились в путь — реализовывать **собственный DSL**! Соответствуя поставленным задачам, он был предназначен для описания процесса сборки по стадиям и определения зависимостей этих стадий от файлов. А дополнял его **собственный сборщик**, который превращал DSL в конечную цель — собранный образ. Сначала DSL был на Ruby, а по мере [перехода на Golang](https://habr.com/ru/company/flant/blog/437044/) — конфиг нашего сборщика стал описываться в YAML-файле.
*Старый конфиг для dapp на Ruby*
*Актуальный конфиг для werf на YAML*
Механизм работы сборщика тоже менялся со временем. Сначала мы просто генерировали на лету некий временный Dockerfile из нашей конфигурации, а потом стали запускать сборочные инструкции во временных контейнерах и делать commit.
***NB**: На данный момент наш сборщик, который работает со своим конфигом (в YAML) и называется Stapel-сборщиком, уже развился в достаточно мощный инструмент. Его развернутое описание заслуживает отдельных статей, а основные подробности можно узнать из [документации](https://werf.io/documentation/reference/build_process.html#stapel-image-and-artifact).*
Осознание проблемы
------------------
Но мы поняли, причем не сразу, что совершили одну ошибку: не добавили возможность **собирать образы через стандартный Dockerfile** и интегрировать их в ту же инфраструктуру комплексного управления приложением (т.е. собирать образы, деплоить и чистить их). Как можно было сделать инструмент для деплоя в Kubernetes и не реализовать поддержку Dockerfile, т.е. стандартного способа описания образов для большинства проектов?..
Вместо ответа на такой вопрос мы предлагаем его решение. Что делать, если у вас уже имеется Dockerfile (или набор Dockerfile’ов) и вы хотите использовать werf?
***NB**: К слову, с чего бы вам вообще захотеть использовать werf? Основные фичи сводятся к следующим:*
* *полный цикл управления приложением включая очистку образов;*
* *возможность управлять сборкой сразу нескольких образов из единого конфига;*
* *улучшенный процесс деплоя чартов, совместимых с Helm.*
*С более полным их списком можно ознакомиться на [странице проекта](https://github.com/flant/werf#complete-features-list).*
Итак, если раньше мы бы предложили переписать Dockerfile на наш конфиг, то теперь с радостью скажем: «Позвольте werf собрать ваши Dockerfile’ы!»
Как использовать?
-----------------
Полная реализация этой возможности появилась в релизе [werf v1.0.3-beta.1](https://github.com/flant/werf/releases/tag/v1.0.3-beta.1). Общий принцип прост: пользователь указывает путь до существующего Dockerfile в конфиге werf, после чего запускает команду `werf build`… и всё — werf соберёт образ. Рассмотрим на абстрактном примере.
Объявим следующий `Dockerfile` в корне проекта:
```
FROM ubuntu:18.04
RUN echo Building ...
```
И объявим `werf.yaml`, который использует этот `Dockerfile`:
```
configVersion: 1
project: dockerfile-example
---
image: ~
dockerfile: ./Dockerfile
```
Всё! Осталось **запустить `werf build`**:
Кроме того, можно объявить следующий `werf.yaml` для сборки сразу нескольких образов из разных Dockerfile’ов:
```
configVersion: 1
project: dockerfile-example
---
image: backend
dockerfile: ./dockerfiles/Dockerfile-backend
---
image: frontend
dockerfile: ./dockerfiles/Dockerfile-frontend
```
Наконец, поддерживается и передача дополнительных параметров сборки — таких как `--build-arg` и `--add-host` — через конфиг werf. Полное описание конфигурации Dockerfile image доступно на [странице документации](https://werf.io/documentation/configuration/dockerfile_image.html).
Как это работает?
-----------------
В процессе сборки функционирует стандартный кэш локальных слоёв в Docker. Однако, что важно, werf также **интегрирует конфигурацию Dockerfile в свою инфраструктуру**. Что это означает?
1. Каждый образ, собранный из Dockerfile, состоит из одного stage под названием `dockerfile` (подробнее про то, что такое stages в werf, можно почитать [здесь](https://werf.io/documentation/reference/stages_and_images.html#stages)).
2. Для stage’а `dockerfile` werf рассчитывает сигнатуру, которая зависит от содержимого конфигурации Dockerfile. При изменении конфигурации Dockerfile происходит смена сигнатуры стадии `dockerfile` и werf инициирует пересборку этой стадии с новым конфигом Dockerfile. Если же сигнатура не меняется, то werf берет образ из кэша *(подробнее об использовании сигнатур в werf рассказывалось в [этом докладе](https://habr.com/ru/company/flant/blog/460351/))*.
3. Далее собранные образы можно опубликовать командой `werf publish` (или `werf build-and-publish`) и использовать для деплоя в Kubernetes. Опубликованные образы в Docker Registry будут чиститься стандартными средствами очистки werf, т.е. произойдет автоматическая очистка старых образов (старше N дней), образов, связанных с несуществующими Git-ветками, и по другим политикам.
Подробнее об описанных здесь моментах можно узнать из документации:
* [Процесс публикации](https://werf.io/documentation/reference/publish_process.html);
* [Интеграция с процессом деплоя в Kubernetes](https://werf.io/documentation/reference/deploy_process/deploy_into_kubernetes.html#integration-with-built-images);
* [Процесс очистки](https://werf.io/documentation/reference/cleaning_process.html).
Примечания и предосторожности
-----------------------------
### 1. Внешний URL в ADD не поддерживается
На данный момент не поддерживается использование внешнего URL в директиве `ADD`. Werf не будет инициировать пересборку при изменении ресурса по указанному URL. В скором времени планируется добавление данной возможности.
### 2. Нельзя добавлять .git в образ
Вообще говоря, добавление директории `.git` в образ — ~~порочная~~ плохая практика и вот почему:
1. Если `.git` остается в финальном образе, это нарушает принципы [12 factor app](https://12factor.net/build-release-run): поскольку итоговый образ должен быть связан с одним коммитом, не должно быть возможности сделать `git checkout` произвольного коммита.
2. `.git` увеличивает размер образа (репозиторий может быть большим из-за того, что в него когда-то добавили большие файлы, а потом удалили). Размер же work-tree, связанного только с определенным коммитом, не будет зависеть от истории операций в Git. При этом добавление и последующее удаление `.git` из финального образа не сработает: образ все равно приобретет лишний слой — так работает Docker.
3. Docker может инициировать лишнюю пересборку, даже если идет сборка одного и того же коммита, но из разных work-tree. Например, GitLab создает отдельные склонированные директории в `/home/gitlab-runner/builds/HASH/[0-N]/yourproject` при включенной параллельной сборке. Лишняя пересборка будет связана с тем, что директория `.git` отличается в разных склонированных версиях одного и того же репозитория, даже если собирается один и тот же коммит.
Последний пункт имеет последствие и при использовании werf. Werf требует, чтобы собранный кэш присутствовал при запуске некоторых команд (например, `werf deploy`). Во время работы таких команд werf рассчитывает сигнатуры стадий для образов, указанных в `werf.yaml`, и они должны быть в сборочном кэше — иначе команда не сможет продолжить работу. Если же сигнатура стадий будет зависеть от содержимого `.git`, то мы получаем неустойчивый к изменениям в нерелевантных файлах кэш, и werf не сможет простить такую оплошность (подробнее см. в [документации](https://werf.io/documentation/reference/stages_and_images.html)).
В целом **добавление только определенных необходимых файлов** через инструкцию `ADD` в любом случае повышает эффективность и надежность написанного `Dockerfile`, а также улучшает устойчивость кэша, собранного по данному `Dockerfile`, к нерелевантным изменениям в Git.
Итог
----
Наш изначальный путь с написанием своего сборщика для определенных потребностей был тяжелым, честным и прямолинейным: вместо использования костылей поверх стандартного Dockerfile мы написали своё решение с кастомным синтаксисом. И это дало свои плюсы: Stapel-сборщик отлично справляется со своей задачей.
Однако в процессе написания собственного сборщика мы упустили из виду поддержку уже существующих Dockerfile’ов. Сейчас этот недостаток исправлен, а в дальнейшем мы планируем развивать поддержку Dockerfile наряду с нашим кастомным сборщиком Stapel для распределенной сборки и для сборки с использованием Kubernetes (т.е. сборки на runner’ах внутри Kubernetes, как это сделано в kaniko).
Так что, если у вас вдруг завалялось пара Dockerfile’ов… **попробуйте [werf](https://github.com/flant/werf)**!
P.S. Список документации по теме
--------------------------------
* [Гайды для быстрого старта](https://werf.io/documentation/guides/getting_started.html);
* [Конфигурации dockerfile builder](https://werf.io/documentation/configuration/dockerfile_image.html);
* [Устройство stages в werf](https://werf.io/documentation/reference/stages_and_images.html#stages);
* [Процесс публикации образов](https://werf.io/documentation/reference/publish_process.html);
* [Интеграция с процессом деплоя в Kubernetes](https://werf.io/documentation/reference/deploy_process/deploy_into_kubernetes.html#integration-with-built-images);
* [Процесс очистки](https://werf.io/documentation/reference/cleaning_process.html);
* [Stapel-сборщик как альтернатива Dockerfile](https://werf.io/documentation/reference/build_process.html#stapel-image-and-artifact).
Читайте также в нашем блоге: «[werf — наш инструмент для CI/CD в Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/460351/)». | https://habr.com/ru/post/463613/ | null | ru | null |
# Как мы делали БелАЗ. Часть 3 – Пусконаладка на разрезе
Это третья статья из цикла о самосвале ([первая](https://habr.com/post/416945/), [вторая](https://habr.com/post/416963/)). Теперь мы едем на карьер, устанавливать электрооборудование на машину и выезжать в первый рейс! Но, конечно же, так просто, с наскоку, ничего не ездит, и я расскажу про множество проблем с которыми мы столкнулись во время командировки. Хоть мы и испытали в прошлой статье все оборудование на лабораторном стенде, реальность бьет совсем с другой стороны. В этой статье будет много видео и фотографий!
Сборка машины
-------------
Самосвал, на который ставилось наше оборудование, эксплуатируется на карьере в Кемеровской области. Добывают там уголь, поэтому правильнее называть это место разрез (угольные карьеры принято называть разрезами). Панорама в разрезе самая обычная для таких мест:
Но, конечно, машина собиралась не посреди дороги. При эксплуатации такой техники должно быть место, где её обслуживать. Таким местом в нашем случае являлся большой ангар, своеобразный «гараж» для самосвалов. Там им меняют резину, чинят и всячески ухаживают. Собственно, там и проходила работа по замене одной электротрансмиссии, старой, на нашу новую на одном из самосвалов.
Погода по приезду была что надо (смотреть показания термометра на светодиодной панели):
В самом цехе было теплее, но так как двери все время открывались/закрывались для прохода машин, без теплой куртки работать там было нельзя.
Вот здесь с машины краном демонтируют старый шкаф управления:
Далее снимают тяговые двигатели:
Двигатели вставляются в своеобразную «бочку» заднего моста. У движка вал выходит с двух сторон – на одной стороне, внутри бочки, на нем располагается механический тормоз, а с другой стороны привинчивается колесный редуктор. Поверх редуктора на болты крепится диск с шиной.
Вот на этом фото рабочие монтируют на наш тяговый двигатель тормозные суппорта.
Механический тормоз на таких машинах используется в качестве аварийного и стояночного. В движении им штатно не тормозят, так как тогда внутри бочки все раскалится и загорится – механическую энергию торможения там отводить некуда. Также на фото видно, как в эту же сторону выходят все провода, которые затем подключаются к клеммнику внутри бочки.
Далее на палубу (да, у БелАЗа есть палуба) устанавливается шкаф управления.
Заметьте, что новый шкаф значительно ниже, чем предыдущий (сравните с фото выше, где кран поднимал старый шкаф). Это дает водителю больший обзор в правое окно.
А помните анекдот: «В аптечке БелАЗа на амбулаторном лечении могут находиться до шести человек»? Так вот, на самом деле кабина очень маленькая, узкая и места там ровно два. Дизайн внутри не назвать изысканным, но функционально всё что нужно есть, даже кондиционер. На фото передняя панель немного подразобрана, идет монтаж:
При этом панель управления с приборами – вполне современная, с большим цветным дисплеем и красивая (почти как у Теслы). Стоит она под рулем:
Эта панель отображает всю информацию по автомобилю, и для каждой подсистемы там есть своя страница. Своя страница про гидравлику, про ДВС, про трансмиссию и т.п. Но панель в основном информационная и ничем жизненно-важным не управляет – т.е. на функционирование трансмиссии её отсутствие не влияет. К сожалению, заранее цифровой протокол обмена с этой панелью никто не согласовал, под нас страницу с нашим приводом не сделал. Поэтому мы сначала решили, что наш привод будет «без окон, без дверей» – две лампочки для индикации аварий и хватит.
Однако местным наладчиком (за что ему отдельное спасибо) был предоставлен протокол обмена с панелью в виде таблички CAN посылок, полученный им прямо на месте методом пристального анализа логов (или по-народному сниффингом). Недолго думая, мы подстроились под этот протокол и стали отправлять своим контроллером нужные посылки, после чего телеметрия от нашего привода на панели ожила и стала отображаться на схожих полях от другой электротрансмиссии:
Не сказать, что там сильно много всего, но, по крайне мере, токи, напряжения и температуры водитель посмотреть может. Также отображаются статусы включенности круиз-контроля, ошибки на преобразователях, состояние селектора направления движения и т.п. Вся остальная диагностика выполняется с ноутбука наладчика сервисной программой от производителя трансмиссии (то есть помимо самого электропривода нужно было разрабатывать сервисный софт).
Первое включение
----------------
После проверки подачи приборного питания, проверки наличия всех узлов в сети CAN и прозвонки силовых кабелей настает время первого включения. Задние колеса самосвала вывешены, ДВС работает на холостых оборотах. Все уставки защит снижаются до «бреющего полета». Т.е. если хоть что-то куда-то прыгнет, хоть ток, хоть напряжение – любая телеметрия, то сразу все отключается.
В ручном режиме с ноутбука задаем небольшой ток возбуждения генератора и нажимаем заветную кнопку «Пуск». Напряжение на шине постоянного тока неспешно поднимается до 100В. Ничего не бахнуло? Защиты не чиркнуло? Контроль изоляции силовых шин не сработал? Ничем не пахнет? Никто не кричит «вырубай»? В логах всё гладко? Хорошо. Можно поднять чуть выше, до 400. Вот так это выглядит в нашей «рисовалке логов» телеметрии (в онлайн режиме графики выползают справа в реальном времени):
Теперь проверяем каждый тяговый двигатель. Задаем небольшую частоту вращения, опять же в ручном режиме, также снижаем все защиты в самый низ, нажимаем «Пуск». Вот так это выглядит снаружи:
Видео вращающегося колеса
Вот так это выглядит в логах:
На момент разгона колеса чуть приспустилось напряжение на звене постоянного тока всех устройств (белым), подрос ток статора всех триад первого двигателя (фиолетовым), ток возбуждения (оранжевым), генератор показал ток по шине постоянного тока (красным), небольшую мощность в 43кВт (голубым), и частота вращения (желтая) поднялась до задания, 200 об/мин, после чего всё остальное упало в ноль. На вращение на холостом ходе энергии почти не тратится, на уровне погрешности измерений.
Повторяем все со вторым двигателем – работает. Потом проверяем все тоже самое от органов управления – от педали газа, тормоза. Разгоняем и тормозим двигатели уже быстрее, поднимаем выше уставки срабатывания защиты.
**В логах это выглядит примерно так**
На самом деле наша программа просмотра логов рассчитана на интерактивную работу, а в статике, в виде скриншота, абсолютно неинформативна. При пользовании ей предполагается, что пользователь водит мышкой, ставя курсоры трассировки на интересующие места графика, и значения всех линий, попавших в вертикальное перекрестие курсора (стрелочки), отображаются в легенде. Если бы мы вывели значения всех тысяч графиков телеметрии сразу одной простыней, там никогда было бы не найти нужного. Поэтому не пытайтесь особо понять, что тут происходит – просто много красивых разноцветных линий, по которым ездит самосвал!
К сожалению, в цехе слабая вытяжка, а дизель сильно коптит – за время пробных включений он уже закоптил всё так, что в цехе появилась явно видимая дымка и начала болеть голова. Срочно глушим и открываем все двери – перекур. Впрочем, всё основное проверено и можно ставить самосвал на колеса, авось доедет до улицы уже сам, и продолжать пусконаладку можно будет там, на свежем воздухе. В случае чего, закатить обратно самосвал всегда есть чем – у эксплуатирующей организации всегда в наличии вот такие машинки, которые могут довезти домой до ремонта:
«Покатушки» и первые проблемы
-----------------------------
Итак, самосвал на колесах, и вот он, долгожданный первый выезд из цеха своим ходом:
Но с первой же попыткой нажать на газ посильнее сработала защита по превышению тока на шине постоянного тока генератора. Ток превысил защиту 1500А (номинальный ток для полной мощности – 1100А). При этом машина даже не ехала, водитель только резко нажал на газ и всё выключилось. Что видно в логах? А ничего:
Напряжение было, потом небольшой «тычок» в токах двигателей и генератора (всего 30А по логу), и потом все по нулям. А где же 1500А? Дело в том, что штатно посылки логов в CAN сети идут с периодом порядка 50-100мс, а выводимые в них данные – усредненные, со временем усреднения примерно те же 50мс. Поэтому да, там что-то произошло, в очень короткий промежуток времени, но что – по этим логам не видно. Для выяснения такой проблемы нужно снимать осциллограмму средствами самого преобразователя. Заряжаем в программный осциллограф контроллера генератора напряжение и ток на шине, ток возбуждения генератора. Повторяем опыт… и опа:
Здесь красный – это выпрямленный ток генератора, и он достиг 2000А, предела измерения контроллера, и, судя по форме кривой, где-то там явно был выше этой полки! Два с лишним килоампера, Карл! А напряжение на шине проседает в это время с 250В почти до нуля! И всё это происходит за 5мс и затем всё восстанавливается. При этом еще и ток возбуждения выстреливает вверх… Хотя контроллер должен его ограничивать на 30А максимум, а тут 60А. Что происходит?!
Давайте посмотрим другие величины, на этот раз задание тока возбуждения и частоту вращения генератора. Может быть, задание тока возбуждения из-за глюка улетает вверх или частота вращения как-то прыгает? Но нет, все стабильно:
Задание тока возбуждения, красным, едва равно 17А, и обнуляется, как только срабатывает защита в 1500А. Также себя ведет и частота вращения (синим), она стабильна как полка до момента аварии, и затем её измерение при отключении преобразователя прекращается. Однако токи все равно растут сами по себе, контроллер ничего не может сделать! Ладно. Давайте посмотрим, что делают тем временем тяговые двигатели. Может быть, это какое-то замыкание в блоке генератора, а на двигателях все в порядке? Ага, вот оно что:
В момент резкого трогания двигатели пытаются скачком отработать задание 300А фазного тока (фиолетовым). Синий ток статора (усредненный по всем триадам машины) честно выстреливает вверх на задание за 4мс, и это же сопровождается синхронной просадкой напряжения в звене постоянного тока (бирюзовым). Ну, теперь все понятно.
Двигатели резко потребляют много энергии за короткое время со звена постоянного тока. Эта энергия, несмотря на то, что двигатель не крутится, уходит на «накачку» током индуктивностей статора двигателя. Т.е. энергия из конденсатора шины постоянного тока уходит в индуктивность двигателя – из одного накопителя электроэнергии в другой.
Пиковая мощность, как показывают расчеты на салфетке, составляет при этом порядка 400кВт! Так как напряжение на звене постоянного тока при трогании маленькое, энергия в нем тоже маленькая (). Этой энергии не хватает, чтобы «зарядить» индуктивности обмоток двигателя (), поэтому напряжение с ростом тока начинает резко падать. Из-за этого энергия начинает потребляться с генератора, а у него всё просто – чем ниже напряжение на шине, тем больший он дает ток через выпрямитель. Только вот ток в силу инерционности синхронной машины он дает с задержкой, он не может так быстро начать выдавать мощность 400кВт, как это нужно двигателям. Ему нужно большее время, чтобы ток нарос в его индуктивностях. А тяговые двигатели быстро съедают напряжение в шине почти до нуля, и в ответ на это негодяйство через пару миллисекунд генератор отвечает килоамперными токами!
Что делать? Всё просто, никому не нужно за 4мс реагировать на нажатие педали газа. Нужно в ПО контроллера преобразователей двигателей ввести задатчик интенсивности, т.е. плавно наращивать задание тока, в течение, скажем, 50мс. На отзывчивости машины это никак не скажется, зато исключит резкий наброс мощности на генератор, чтобы он успевал вовремя поддать тока. Сделали, прошили, работает!
Поехали! Но уехали недалеко. При повышении динамики разгона снова стала срабатывать защита. Теперь уже не при трогании, а на 15 км/ч. Теперь осциллограмма токов и напряжений на генераторе выглядела вот так:
Явная колебательная раскачка! Ток и напряжение шины постоянного тока начинают раскачиваться в противофазе, увеличивая и увеличивая амплитуду. Синусы частотой 70Гц в шине постоянного тока, резонанс, однако! Только чего с чем?
Я бы с удовольствием рассказал, что было на этот раз и прошивкой чего и где мы устранили эту раскачку, но статья не про это. Вернее, не только лишь про это, а ещё и про много что другое. Приведены лишь типичные примеры проблем, потому что они вылезали и вылезали, и мы правили и правили софт, коэффициенты и логику работы оборудования, пока в итоге всё не поехало как надо – всего не описать! Такая пусконаладка с игрушечными режимами работы самосвала шла днями, выявляя такие проблемы, которые априори, до реального объекта, ни помыслить, ни промоделировать было нельзя.
Всё это время, пока программистами велась ожесточенная охота на неведомые колебания и прочую чертовщину, внешне машина уныло ездила кругами перед воротами цеха, как-то вот так:
We need to go deeper
--------------------
Когда все проблемы первого бастиона более-менее отладили, и защиты перестали сыпаться через каждые 100 метров, пришло время первой ходки в разрез. Это тоже отдельная процедура, надо выписывать заявки на выезд машины, еще зачем-то обязательно ехать надо с легковой машиной сопровождения, согласовать время и т.п. Но, тем не менее, мы в карьере. То есть в разрезе. Ждем загрузки в очереди на экскаватор:
Сначала мы попросили нагрузить нас не до верху, а половину, на пробу. Просили половину, но нам навалили по ощущениям явно больше! Ну что делать, поехали, первый раз с полезным грузом! Видео изнутри (осторожно, эмоциональные выражения, смотреть в наушниках!):
В логе езда выглядит еще более интересно (конечно, для тех, кто умеет видеть матрицу):
На картинке как раз то место с преодолением горки из видео. Сначала видны колебания, это машина прыгает на своих шинах по неровной дороге, нога водителя задает такой же «прыгающий» газ, трансмиссия его отрабатывает. Потом начинается горка. Желтый график частоты вращения тяговых двигателей проседает до 600 об/мин, что соответствует 10 км/ч. При этом, судя по фиолетовому графику тока, в фазах протекает лишь половина от максимума, т.е. у двигателей есть еще двоекратный запас по моменту. Быстрее машина не едет просто потому, что на большее не хватает мощности дизеля – голубой график на второй оси вышел на «полку» 770кВт и держится постоянным (вместе с оборотами дизеля) независимо от изменяющейся скорости машины. Т.е. здесь электротрансмиссия целиком трансформирует полную мощность дизеля (за вычетом КПД) в подъем массы вверх по уклону, не упираясь ни в какие свои ограничения. Работает как будто всегда правильно подобранная и всегда оптимальная механическая передача.
Но, мы отвлеклись. Мы же едем! И вот уже пора высыпать полезный груз. Вот так выглядит отвал, и опять ждем в очереди:
Таким способом формируют карьер, вываливая в нужные места пустую породу.
Потом мы опять спустились вниз, теперь нас нагрузили полностью, съездили еще, и еще, и еще… Машина начала постепенно втягиваться в работу. По пути, конечно же, происходили срабатывания защит, приходилось опять охотиться с осциллограммами на причины, но с течением времени защиты срабатывали всё реже, а машина без отключений проезжала все больше. Потом мы стали отдавать машину на ночную смену (без программиста в кабине). По утру скачивали логи с промышленной SD-карты в контроллере верхнего уровня, изучая интересные места и опрашивая жалобы водителей.
Хотелки
-------
А дальше… Дальше начались всякие внеплановые улучшения софта, скажем так. То, что не влияет на основной функционал, то, чего не было в ТЗ, но, как оказалось, что «у всех других самосвалов есть и это очень удобно». Например, выяснилось, что у всех новых машин реализована противооткатная система. Примерно как на легковушках, но с некоторыми «карьерными» нюансами. В общем, надо было сделать так, что если селектор направления стоит вперед, то машина могла катиться только вперед, а назад ехать упиралась что есть силы. Т.е. чтобы можно было при подъеме на уклон полностью отпустить газ, машина плавно бы остановилась и не покатилась назад. А если надо поехать вперед, водитель жал бы газ и машина без отката назад и рывков шла вверх. И все тоже самое при селекторе назад – вперед катиться нельзя. А в нейтрали противооткат должен отключаться.
Но никто же заранее не говорил, что это надо делать! Да, своими глазами на карьере становится видно, что без этого режима реально неудобно эксплуатировать машины. Но вот в чем проблема – с механическим тормозом так сделать просто, в легковушках при нулевой скорости он зажимается клапанами блока АБС (или чем там?) и всё. И не надо ни энергии тратить, ни эквилибристикой заниматься. На БелАЗе же все системы разделены, и там есть три педали – газ, тормоз механический и тормоз электрический (там, где обычно сцепление). Так вот: механические тормоза управляется только напрямую от своей педали без всякой электроники. Поэтому если делать противооткат на этой конструкции самосвалов, то только средствами торможения тяговым двигателем.
А держать в одном положении электродвигатель с нагрузкой в виде самосвала, стоящего на уклоне – не так-то просто! Как бы это объяснить… это как держать обычную машину с механической коробкой передач на уклоне, играя газом и сцеплением. В зависимости от положения машины нужно поддавать тягу или её сбрасывать. Датчиком положения машины у нас в этом случае служит датчик положения ротора двигателя. Но датчик этот у нас очень грубый, с малым числом меток на оборот. Т.е. если сделать по-простому, «чем быстрее едем назад, тем сильнее поддавай момент вперед», то машина или предательски ползла с уклона понемногу, или раскачивалась вперед-назад. Представляете себе, встали вы на светофоре, а машина елозит вперед-назад на два метра, поддавая то газ, то тормоз, и кивая подвеской туда-сюда… Задача сводится в итоге к задаче сервопривода, который держит положение (как я показывал в [статье про сервопривод](https://habr.com/company/npf_vektor/blog/392837/)), но только в размерах БелАЗа и на датчике положения с очень низким разрешением.
В общем, наигрались мы тогда вдоволь с алгоритмами противоотката, пришлось применить самые хитрые ПИД-регуляторы с фильтрами, что только мы сумели придумать. А ведь характер поведения самосвала еще меняется разительно с грузом/без груза! Но настроить «как у всех» вроде бы получилось, водители остались довольны. Вот одно из видео, как мы отлаживали противооткат с грузом:
Тоже самое, но изнутри:
Еще одной интересной системой является круиз-контроль. Местные его называют стабилизация скорости. И если на легковушках он нужен при поездках «на дальняк», чтобы нога не устала газ держать, то здесь – совсем по другой причине. Даже летом на карьерах обычно достаточно скользко, дороги земляные, после дождя их размывает, получается жижа. Ну а зимой в гололед и подавно. И все эти многотонные самосвалы на этих дорогах вполне успешно буксуют (у нас видео нет, но на ютубе полно примеров: [раз](https://www.youtube.com/watch?v=hNwC1w2_Wnc), [два](https://www.youtube.com/watch?v=DiPr7XpyurE) ).
По отзывам водителей самый безопасный способ езды – чтобы колеса вращались с заданной фиксированной скоростью, хоть там спуск, хоть подъем. Это как раз и обеспечивает функция стабилизации скорости. Её задача – очень жестко держать задание, не реагируя на локальные перепады высот. При этом держать скорость она должна играя сразу и газом, и тормозом, смотря куда и как машина едет.
На словах звучит круто, но по факту там обычный ПИД регулятор скорости машины и всё. Хотя поотлаживать и понастраивать тоже пришлось. Да, и еще одно отличие от обычных машин – если нажать на газ или на тормоз, то режим круиз-контроля здесь не отключается, а просто повышает или снижает задание скорости. Т.е. водитель может ехать в таком режиме постоянно, но педали меняют роль и вместо уровня тяги теперь регулируют задание скорости.
Кроме стабилизации скорости машины целиком, еще нужно выравнивание частот вращения по колесам (по задним, конечно, от передних информации нет). Но здесь уже выравнивание не жесткое, так как колеса могут (и должны) крутиться с разной скоростью в повороте. Поэтому до определенной дельты частот вращения привод ничего не предпринимает, а при большей разнице начинает перераспределять момент на колесах так, чтобы подкручивать отстающее и приостанавливать убегающее. Но, в общем, тут тоже никакой рокет-саенс нету, и справляется пропорциональный регулятор с мертвой зоной. При этом сразу одним регулятором можно убить двух зайцев: в зависимости от того, тянем мы или толкаем, получается как бы и противобуксовочная и антиблокировочная система сразу. Не совсем честные системы, конечно, потому что сразу два задних колеса могут и буксовать, и заблокироваться вместе, но по отдельности каждое – нет. Хотя на будущих машинах нам обещали поставить датчики скоростей передних колес, тогда можно с ними будет сделать по-настоящему, без блокировки.
Наша команда
------------
Сколько народу всё это делало? А сколько пусконалаживало? А как строилось взаимодействие? Это тоже интересные вопросы. Если посчитать по пальцам, то конструированием силового шкафа занималось человека три, написанием софта еще три, пара разводила контроллеры, электрические машины еще конструировали в среднем трое и один суперкомпьютер. Еще нужно посчитать нескольких работников, которые занимались комплектацией, документацией и организационными вещами. И это только непосредственно вовлеченные в проект люди, которые занимались только этим и больше ничем. А еще есть рабочие на заводах, которые это оборудование точили, резали, наматывали, собирали, проверяли, перевозили и так далее. В общем, кооперация была большая, многих фирм и заводов в разных частях страны.
На пусконаладке на объекте было сначала пятеро, когда производилась активная сборка и монтаж оборудования, прокладка кабелей и т.п., но потом на покатушки и отладку осталось двое: один конструктор силового шкафа и один программист. Ну это без учета местных – водителей, наладчиков и рабочих, которые помогали в случае чего.
Однако, хоть там и было два человека, виртуально с ними была вся команда. У нас такая практика – под каждый проект создается отдельный чат (в неком опальном мессенджере), и там освещается всё, что происходит. За день там публикуются десятки осциллограмм, фотографий отвалившихся проводов, файлов логов и воззваний к помощи. Все всегда на связи и решают возникающие вопросы. Под это дело мы даже купили и отправили «туда» GSM антенну с модемом, чтобы связь была даже на самом дне ямы (разреза).
Также часто практикуется удаленное подключение (удаленный рабочий стол), когда конкретному программисту нужно что-то поосцать (термин у нас такой для сессии снятия осциллограмм) или пошить контроллеры в своей части ответственности. А еще бывает, что в машине сильно трясет, тогда тот, кто подключается по удаленке ведет саму работу, а тот кто сидит в кабине просто визуально контролирует обстановку, следит за связью и командует куда ехать.
Также есть миссия ответственного просмотрщика логов. Скажем, машина сделала очередную ходку с грузом, визуально всё было хорошо, в чатик сваливается CAN лог поездки. Его обязательно нужно открыть и просмотреть, и обычно в нем находится много очень интересных нюансов, хотя на ходу никто ничего не заметил. Тут же в офисе идет правка софта, пушится, на той стороне интернета пуллится и шьется в машину.
Вы, может быть, удивитесь, но автор этой статьи – ни разу не видел вживую БелАЗа. Да, в этом проекте я тот самый оператор матрицы и удаленный смотритель логов. И эта статья написана без единой консультации с теми, кто «был там». Просто потому, что мы все, кто в чате, обо всём уже знаем. Вот такая плотность передачи информации у нас при работе с проектом.
Более того, все испытания электродвигателей на заводе (прошлая статья) шли вообще без присутствия программистов. Но велись ими. По удаленке. Из командированных на месте на испытаниях сидел только несчастный конструктор силовых шкафов (не считая работников завода), которому нужно было снимать осциллограммы физическим осциллографом, контролировать температуры и подключать провода. Такая наглость со стороны программистов стала возможной только благодаря многолетним инвестициям в свой отладочный софт и методологию, которая была подробно [рассмотрена здесь](https://habr.com/company/npf_vektor/blog/389123/).
К слову, по этой причине еще на стадии обсуждения нового проекта с заказчиком мы сразу выясняем, есть ли на объекте в месте установки оборудования интернет, мобильная связь и возможно ли их обеспечить в случае отсутвия. Если выясняется, что ничего нет, говорим, что тогда пусконаладка будет идти в три раза дольше. Обычно это очень хорошо стимулирует на поиск и подключение нам завалявшейся вайфай точки доступа или организации разрешения на пронос «запрещенного для обычных смертных» 3G-модема на объект на время пусконаладки. Но, безусловно, бывают и такие места, где не то что интернет, а и розетку бытовую найти сложно. Кстати, о розетках — на время пусконаладки в самосвал мы ставили инвертор 24-220В (из обычного автомагазина) для зарядки ноутбуков и телефонов, чтобы спокойно бесперерывно работать.
Заключение
----------
Хоть сейчас машинка уже стала взрослая и ходит в разрез самостоятельно, мы про нее не забываем – местным наладчикам оставили GSM антенну, и, если что – подключаемся удаленно и диагностируем, что не так. На место выезжать нужно только если сломается что-то непоправимое. Поломки типа отвалившегося провода или отказавшего насоса чинятся местным персоналом, а наше дело подключиться и сказать, в каком именно месте проблема и где это увидеть.
Предположительно, это финальная статья по этому проекту. Если в комментариях будут предложения о чем рассказать ещё, что не уложится в формат ответного комментария, то подумаем о написании продолжения.
Серия статей получилась, конечно, однобокая – эдакий взгляд на проект со стороны программистов. Я уверен, что всем другим участниками проекта, конструкторам машин и шкафов, монтажникам и рабочим тоже было бы много чего рассказать со своей точки зрения. Может быть, когда-то они напишут что-то похожее.
Также в статье даже близко не рассмотрены все алгоритмы управления самим самосвалом, потому что для этого не статью надо писать, а диссертацию. Как обеспечивается баланс мощности между всеми устройствами, по какому закону управляется генератор, как задается частота вращения дизеля, как обрабатываются педали оператора и преобразуются в задание момента, и многое, многое другое. То есть алгоритмы, конечно, гораздо сложнее, чем
```
if (газ>0)
задание_момента = газ;
if (тормоз>0)
задание_момента = -тормоз;
```
И в них, конечно же, тоже куча разных инженерных решений: какие-то решения элегантные, какие-то топорные, какие-то неочевидные, какие-то самые тривиальные. Но до всех этих алгоритмов со временем и опытом дошел бы так или иначе каждый инженер, когда нужно выполнить поставленную задачу. Поэтому я решил не погружаться в занудные технические детали реализации, а показать, как шел этот проект эпизодически, с картинками, ютубами и лирическими отступлениями. Надеюсь, было интересно.
Как обычно, реклама родного института
-------------------------------------
Этот проект выполнялся по большей части выпускниками НИУ МЭИ. Если Вы стоите перед вопросом «где дальше учиться» и Вам интересно крутить электродвигатели, пусконалаживать БелАЗы, а также хочется научиться программировать векторную систему управления, то добро пожаловать под
**спойлер**
Кафедра Автоматизированного электропривода (АЭП) НИУ МЭИ продолжает набор в **магистратуру** по направлению 13.04.02 «Электроэнергетика и электротехника», программа подготовки – «Электропривод и автоматика».
В магистратуру по данной специальности можно поступать на конкурсной основе на бюджетную форму обучения или на платной основе. Срок окончания приема документов в магистратуру на бюджетную форму обучения – 17 августа 2018г.
Вступительные экзамены будут проводиться 11 августа и 20 августа (консультации 10 и 17 августа, соответственно). Подробности на сайте [приёмной комиссии](https://www.pkmpei.ru/info/magistracy.html). Примеры экзаменационных заданий можно так же найти в [специальном разделе сайта приёмной комиссии](https://www.pkmpei.ru/info/example_mag.html). Поступающим, нуждающимся в общежитии, предоставляет общежитие в пределах выделенного числа мест при поступлении на места в рамках контрольных цифр приёма очной формы обучения и на договорные места очной формы обучения.
Также приглашаем выпускников школ поступать в **бакалавриат** по направлению 13.03.02 «Электроэнергетика и электротехника» факультета ИЭТ МЭИ. Срок окончания приема документов в бакалавриат на бюджетную форму обучения – 26 июля 2018г.
Документы подаются по адресу г. Москва, ул. Красноказарменная, д.17.
Кафедра автоматизированного электропривода НИУ «МЭИ» является ведущей кафедрой по данной специальности в России, имеет более 20 млн. руб. ежегодного объема научно-исследовательских работ, публикует более 20 статей в год в изданиях, индексируемых наукометрическими базами данных Web of Science и Scopus, на кафедре преподают сотрудники ООО «НПФ «ВЕКТОР» и ООО «НПП «ЦИКЛ+» — ведущих предприятий в области разработки электроприводов и электрических трансмиссий в России.
А вот напоследок загадка:
Найдите на этом фото GSM-антенну и фары.
**Отгадка**
Ну, антенну-то все нашли, ромбик над кабиной, а вот то что многие могли принять за большие круглые фары – на самом деле воздушные фильтры. А фары на самом деле под ними, маленькие квадратики. | https://habr.com/ru/post/416967/ | null | ru | null |
# Распространенные ошибки при работе с промисами в JavaScript, о которых должен знать каждый
Доброго времени суток, друзья!
Хотел бы я знать об этих ошибках, когда изучал JavaScript и промисы.
Всякий раз, когда ко мне обращается какой-нибудь разработчик и жалуется на то, что его код не работает или медленно выполняется, я прежде всего обращаю внимание на эти ошибки. Когда я начал программировать 4 года назад, я не знал о них и привык их игнорировать. Однако после назначения в проект, который обрабатывает около миллиона запросов в течение нескольких минут, у меня не было другого выбора, кроме как оптимизировать свой код (поскольку мы достигли уровня, когда дальнейшее вертикальное масштабирование стало невозможным).
Поэтому в данной статье я бы хотел поговорить о самых распространенных ошибках при работе с промисами в JS, на которые многие не обращают внимания.
### Ошибка № 1. Использование блока try/catch внутри промиса
Использовать блок try/catch внутри промиса нецелесообразно, поскольку если Ваш код выдаст ошибку (внутри промиса), она будет перехвачена обработчиком ошибок самого промиса.
Речь идет вот о чем:
```
new Promise((resolve, reject) => {
try {
const data = someFunction()
// ваш код
resolve()
} catch(e) {
reject(e)
}
})
.then(data => console.log(data))
.catch(error => console.log(error))
```
Вместо этого позвольте коду обработать ошибку вне промиса:
```
new Promise((resolve, reject) => {
const data = someFunction()
// ваш код
resolve(data)
})
.then(data => console.log(data))
.catch(error => console.log(error))
```
Это будет работать всегда, за исключением случая, описанного ниже.
### Ошибка № 2. Использование асинхронной функции внутри промиса
При использовании асинхронной функции внутри промиса возникают некоторые неприятные побочные эффекты.
Допустим, Вы решили выполнить некоторую асинхронную задачу, добавили в промис ключевое слово «async», и Ваш код выдает ошибку. Однако теперь Вы не можете обработать эту ошибку ни с помощью .catch(), ни с помощью await:
```
// этот код не сможет перехватить ошибку
new Promise(async() => {
throw new Error('message')
}).catch(e => console.log(e.message))
// этот код также не сможет перехватить ошибку
(async() => {
try {
await new Promise(async() => {
throw new Error('message')
})
} catch(e) {
console.log(e.message)
}
})();
```
Каждый раз, когда я встречаю асинхронную функцию внутри промиса, я пытаюсь их разделить. И у меня это получается в 9 из 10 случаев. Тем не менее, это не всегда возможно. В таком случае у Вас нет другого выбора, кроме как использовать блок try/catch внутри промиса (да, это противоречит первой ошибке, но это единственный выход):
```
new Promise(async(resolve, reject) => {
try {
throw new Error('message')
} catch(error) {
reject(error)
}
}).catch(e => console.log(e.message))
// или используя async/await
(async() => {
try {
await new Promise(async(resolve, reject) => {
try {
throw new Error('message')
} catch(error) {
reject(error)
}
})
} catch(e) {
console.log(e.message)
}
})();
```
### Ошибка № 3. Забывать про .catch()
Эта одна из тех ошибок, о существовании которой даже не подозреваешь, пока не начнется тестирование. Либо, если Вы какой-нибудь атеист, который не верит в тесты, Ваш код обязательно рухнет в [продакшне](https://dic.academic.ru/dic.nsf/ruwiki/1328397). Потому что продакшн строго следует [закону Мерфи](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BA%D0%BE%D0%BD_%D0%9C%D0%B5%D1%80%D1%84%D0%B8), который гласит: «Anything that can go wrong will go wrong» (можно перевести так: «Если что-то может пойти не так, это обязательно произойдет»; аналогией в русском языке является «закон подлости» — прим. пер.).
Для того, чтобы сделать код элегантнее, можно обернуть промис в try/catch вместо использования .then().catch().
### Ошибка № 4. Не использовать Promise.all()
Promise.all() — твой друг.
Если Вы профессиональный разработчик, Вы наверняка понимаете, что я хочу сказать. Если у Вас есть несколько не зависящих друг от друга промисов, Вы можете выполнить их одновременно. По умолчанию, промисы выполняются параллельно, однако если Вам необходимо выполнить их последовательно (с помощью await), это займет много времени. Promise.all() позволяет сильно сократить время ожидания:
```
const {promisify} = require('util')
const sleep = promisify(setTimeout)
async function f1() {
await sleep(1000)
}
async function f2() {
await sleep(2000)
}
async function f3() {
await sleep(3000)
}
// выполняем последовательно
(async() => {
console.time('sequential')
await f1()
await f2()
await f3()
console.timeEnd('sequential') // около 6 секунд
})();
```
Теперь с Promise.all():
```
(async() => {
console.time('concurrent')
await Promise.all([f1(), f2(), f3()])
console.timeEnd('concurrent') // около 3 секунд
})();
```
### Ошибка № 5. Неправильное использование Promise.race()
Promise.race() не всегда делает Ваш код быстрее.
Это может показаться странным, но это действительно так. Я не утверждаю, что Promise.race() — бесполезный метод, но Вы должны четко понимать, зачем его используете.
Вы, например, можете использовать Promise.race() для запуска кода после разрешения любого из промисов. Но это не означает, что выполнение кода, следующего за промисами, начнется сразу же после разрешения одного из них. Promise.race() будет ждать разрешения всех промисов и только после этого освободит поток:
```
const {promisify} = require('util')
const sleep = promisify(setTimeout)
async function f1() {
await sleep(1000)
}
async function f2() {
await sleep(2000)
}
async function f3() {
await sleep(3000)
}
(async() => {
console.time('race')
await Promise.race([f1(), f2(), f3()])
})();
process.on('exit', () => {
console.timeEnd('race') // около 3 секунд, код не стал быстрее!
})
```
### Ошибка № 6. Злоупотребление промисами
Промисы делают код медленнее, так что не злоупотребляйте ими.
Часто приходится видеть разработчиков, использующих длинную цепочку .then(), чтобы их код выглядел лучше. Вы и глазом не успеете моргнуть, как эта цепочка станет слишком длинной. Для того, чтобы наглядно убедиться в негативных последствиях такой ситуации, необходимо (далее я немного отступлю от оригинального текста для того, чтобы описать процесс подробнее, нежели в статье — прим. пер.):
1) создать файл script.js следующего содержания (с лишними промисами):
```
new Promise((resolve) => {
// некий код, возвращающий данные пользователя
const user = {
name: 'John Doe',
age: 50,
}
resolve(user)
}).then(userObj => {
const {age} = userObj
return age
}).then(age => {
if(age > 25) {
return true
}
throw new Error('Age is less than 25')
}).then(() => {
console.log('Age is greater than 25')
}).catch(e => {
console.log(e.message)
})
```
2) открыть командную строку (для пользователей Windows: чтобы открыть командную строку в папке с нужным файлом, зажимаем Shift, кликаем правой кнопкой мыши, выбираем «Открыть окно команд»), запустить script.js с помощью следующей команды (должен быть установлен Node.js):
```
node --trace-events-enabled script.js
```
3) Node.js создает файл журнала (в моем случае node\_trace.1.txt) в папке со скриптом;
4) открываем Chrome (потому что это работает только в нем), вводим в адресной строке «chrome://tracing»;
5) нажимаем Load, загружаем файл журнала, созданного Node.js;
6) открываем вкладку Promise.
Видим примерно следующее:
Зеленые блоки — промисы, выполнение каждого из которых занимает несколько миллисекунд. Следовательно, чем больше будет промисов, тем дольше они будут выполняться.
Перепишем script.js:
```
new Promise((resolve, reject) => {
const user = {
name: 'John Doe',
age: 50,
}
if(user.age > 25) {
resolve()
} else {
reject('Age is less than 25')
}
}).then(() => {
console.log('Age is greater than 25')
}).catch(e => {
console.log(e.message)
})
```
Повторим «трассировку».
Видим следующее:
Зеленых блоков (промисов) стало меньше, а значит время выполнения кода сократилось.
Таким образом, использовать несколько промисов следует только в том случае, если Вам необходимо выполнить некоторый асинхронный код.
Благодарю за внимание. | https://habr.com/ru/post/484466/ | null | ru | null |
# Настройка авторизации с помощью ключа в мобильной putty
Наверное, все, знающие программу [Putty](http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html), слышали про ее [версию для смартфонов](http://s2putty.sourceforge.net/) с ОС Symbian. Если вам интересно — велком под кат.
Сегодня, после нескольких попыток набора пароля на свайп-клавиатуре в переполненном автобусе, я наконец решил настроить авторизаию без ключа. В теории, для этого достаточно публичный ключ с устройства-клиента скормить устройству-серверу. Но на практике все оказалось несколько сложнее. И первая «сложность» — это отсутствие способа создать ключ на самом смартфоне. Здесь мне помог случайно оказавшийся под рукой образ с Windows XP (в wine puttygen почему то не смогла отрисовать интерфейс). При создании ключа важно пояснить, что мобильная версия putty корректно работает только с ключем типа SSH2-RSA длиной 1024 бит. Созданный приватный ключ перемещаем в укромное место памяти смартфона (а то мало ли что). Запускаем мобильную putty, в настройках соединения указываем местоположение ключа и имя пользователя для входа. Выдохнули.
Теперь переходим к настройке устройства-сервера. Я использую ОС Ubuntu, но в других ОС семейства Linux процедура не должна сильно отличаться. Сначала проверяем, установлен ли ssh сервер:
> `sudo apt-get install openssh-server`
>
>
После выполнения этой команды начнется установка или же появится сообщение о том, что пакет уже установлен.
Далее необходимо отредактировать настройки ssh сервера. Для этого в любимом редакторе открываем файл /etc/ssh/sshd\_config
> `sudo gedit /etc/ssh/sshd_config`
>
>
Среди прочих настроек присутствуют следующие:
> `PubkeyAuthentication yes
>
> AuthorizedKeysFile %h/.ssh/authorized_keys`
>
>
Первая отвечает за возможность авторизации с ключем, вторая указывает путь к файлу с паблик-ключами устройств-клиентов. %h заменяется именем домашней папки текущего пользователя. По умолчанию вторая строчка закомментирована, необходимо удалить знак # перед ней. Теперь можно переходить к добавлению паблик-ключей.
Для этого необходимо создать и отредактировать файл, находящийся по указанному ранее пути в системе:
> `touch ~/.ssh/authorized_keys
>
> gedit ~/.ssh/authorized_keys`
>
>
Теперь — магия! Паблик-ключ, созданный puttygen, не сработает в его текущем виде, поэтому открываем его в том же любимом текстовом редакторе, копируем ключ (выделен на скриншоте) внутрь файла authorized\_keys, дописываем в начало тип ключа (ssh-rsa) и, при желании, в конец — комментарий.
До:
После:
А теперь нужно обязательно перезагрузить ssh сервер, иначе ничего не получится.
> `sudo service ssh restart`
>
>
На этом настройка авторизации без пароля завершена, но остался последний шаг — тестирование. Запускаем мобильную putty, выбираем соединение, в котором мы указали ключ, ждем подключения. | https://habr.com/ru/post/127796/ | null | ru | null |
# Скрипт статического коллтрекинга
Описание работы скрипта для подмены на сайте номеров любых операторов. Конструктор для визуальной настройки скрипта. Подмена заголовков, для разных источников трафика.
Для чего нужен скрипт
---------------------
Скрипт для подмены номеров телефона на сайте помогает настроить условия, когда должен появится тот или иной номер. Номера могут быть любых операторов, важно лишь, чтобы вы могли получить статистику звонков на эти номера.
Скрипт также запоминает откуда пришел посетитель. Если в первый раз он пришел из Яндекс, а затем, повторно из закладок, ему показывается номер телефона, связанный с Яндекс.
Предположим, нужно определить сколько звонков от пользоватлей, пришедших из рекламы Яндекс Директ и статей на сайтах. Для отслеживания двух источников трафика потребуется 3 номера. Один номер будет подсчитывать звонки со всех остальных источников.
Для этого на сайте нужно установить скрипт, который определяет откуда пришел посетитель и показывает ему нужный номер телефона.
Как установить и настроить скрипт
---------------------------------
[Скачайте скрипт](https://raw.githubusercontent.com/sipuni/static-calltracking/master/src/sipuni-calltracking.js) и подключите на сайте.
Добавьте CSS класс ct\_phone в элементах, где будет происходить подмена номеров. Если номер есть в шапке и в подвале сайта, то для всех номеров нужно добавить класс.
```
+7 888 888-88-88
```
Вставьте код подмены. Его можно вставить в любом месте страницы, главное, чтобы он был после элементов, в которых происходит подмена.
```
sipuniCalltracking({
sources: {
'yadirect':{'utm\_source': 'direct.yandex.ru'},
'articles':{'ref': /(habrahabr|oborot.ru)/ig}
},
phones: [
{'src':'yadirect', 'phone':['+74951111114']},
{'src':'articles', 'phone':['+74952222224']}
],
pattern:'+# (###) ###-##-##'
}, window);
```
Если подмена требуется только в шапке сайта, то код можно вставить прямо под номерами. В этом случае подмена номеров почти незаметна.
Без особой причины не рекомендую выполнять код в событии готовности DOM модели или в Google Tag Manager, потому что подмена номеров становится заметнее.
Настройка с помощью конструктора
--------------------------------
Для упрощения настройки мы создали [конструктор](https://sipuni.com/ru_RU/tools/calltracking). Для работы с конструктором советую прочитать всю статью, чтобы понимать значения параметров.
В первой секции нужно создать источники трафика и условия как их определить. Ниже, вы задаете соответсвие источников трафика и номеров телефона. Готовый скрипт внизу страницы.
В конструкторе есть примеры определения источников трафика. Их можно использовать как основу, и расширить если требуется.
Когда все настроили готовый код можно скопировать внизу страницы.
Настройка источников трафика
----------------------------
В массиве sources задаются источники трафика.
```
'articles':{'ref': /(habrahabr|oborot.ru)/ig}
```
В этом примере, articles это название источника. Это название используется в массиве phones. Ключ ref означает искать в адресе источника, а значение — регулярное выражение, с помощью которого выполянть поиск.
Поддерживаются следующие места поиска:
* ref — адрес, с которого посетитель перешел на ваш сайт.
* dst — адрес страницы, на которую пришел посетитель.
* utm *— только параметр начинающийся с utm*.
В этом примере, в utm\_medium будет искаться подстрока email.
```
'email': {'utm_medium': 'email'}
```
Заменив подстроку на регулярное выражение можно использовать более сложные правила поиска.
```
'email': {'utm_medium': /(email|eml)/ig }
```
Если поиска подстроки или регулярного выражения недостаточно, есть возможность задать функцию. В параметр функции подается значение места поиска, а вернуть функция должна true или false.
```
'ydirect_openstat': {'dst': function(subject){
var o = query.getRawParam(subject, '_openstat');
return (o && a2b(o).indexOf('direct.yandex.ru')>-1);
}
}
```
В этой функции распаковывается параметр \_openstat из адреса страницы и проверяется, что он от Яндекс Директ.
Соответствие источников трафика и номеров телефона
--------------------------------------------------
После настройки источников трафика, нужно задать соответсвие номеров и источников.
```
phones: [
{'src':'yadirect', 'phone':['+74951111114']},
{'src':'articles', 'phone':['+74952222224']}
],
```
Если на сайте одновременно отображаются несколько номеров, их нужно перечислить в массиве phone.
```
targets: ['.phone1', '.phone2'],
phones: [
{'src':'yadirect', 'phone':['+74951111114', '+78121111114']},
{'src':'articles', 'phone':['+74952222224', '+78122222224']}
],
```
Параметр targets задает селекторы для элементов, в которых заменять номера. Количество в targets должно соответсвовать количеству телефонов в параметре phone
HTML будет выглядеть так:
```
+7 495 888-88-88
+7 812 888-88-88
```
По умолчанию в targets задан один селектор — .ct\_phone
Отображение номеров
-------------------
Номера отображаются в соответствтии с параметром pattern. По умолчанию он равен
```
+# (###) ###-##-##
```
Вместо символов # будут подставлены цифры из номера.
Шаблон нужно задавать под конкретные номера. Шаблон по умолчанию позволяет отображать 11-ти значные российские номера, но не сможет правильно показать белорусский номер, потому что в нем 12 цифр.
В шаблоне можно использовать HTML тэги. Например, если нужно отделить номер от кода города.
```
+# (###) **###-##-##**
```
Если параметр pattern сделать пустым, номер будет выводится как он записан в секции phones.
Если шаблона недостаточно, отображение номера можно сделать при помощи callback функции. В параметр функции подается массив из списка phones.
```
function substCallback(p){
if(p){
document.getElementById('top_phone').innerText=someComplexModification(p.phone[0]);
}
}
sipuniCalltracking({
callback: substCallback,
sources: {
...
},
phones: [
{'src':'yadirect', 'phone':['+74951111114']},
{'src':'articles', 'phone':['+74952222224']}
],
}, window);
```
Подмена заголовков страницы для разных источников трафика
---------------------------------------------------------
Скрипт можно использовать для подмены любого содержимого страницы в зависимости от источников трафика.
### Подмена заголовков для разных ключевых слов
Простой вариант подмены, когда вместо номеров телефона указывается заголовок.
```
sipuniCalltracking({
pattern: '',
sources: {
'yadirect_ustanovka':{'utm_keyword': 'установка'},
'yadirect_rassrochka':{'utm_keyword': 'рассрочку'}
},
phones: [
{'src':'yadirect_ustanovka', 'phone':['Газовые котлы с установкой']},
{'src':'yadirect_rassrochka', 'phone':['Газовые котлы в рассрочку']}
]
}, window);
```
Теперь нужно добавить CSS класс в тэге заголовка.
```
Газовые котлы
=============
```
Если посетитель пришел по объявлению о газовых котлах с установкой, ему покажется заголовок “Газовые котлы с установкой”. Поскольку скрипт запоминает, откуда пришел посетитель в первый раз, то при повторном заходе на сайт он все равно увидит “Газовые котлы с установкой”.
В параметр pattern подаем пустую строку, чтобы шаблон не применялся к строкам при выводе.
Можно менять заголовок и подзаголовок, и сделать CSS классы понятнее при помощи настройки targets.
```
pattern:'',
targets: ['.title', '.subtitle'],
phones: [
{'src':'yadirect_ustanovka', 'phone':[
'Газовые котлы с установкой',
'Доставим и установим газовый котел в вашем доме']},
{'src':'yadirect_rassrochka', 'phone':[
'Газовые котлы в рассрочку',
'Безпроцентная рассрочка до 6 месяцев']}
],
```
Размечаем CSS классами title и subtitle элементы, в которых будем менять содержимое.
```
Газовые котлы
=============
Доставка и установка газовых котлов
```
### Подмена содержимого при помощи callback функции.
Для более сложного варианта подмены, можно использовать функцию. Такой вариант подойтет, если нужно заменить изображение. В функцию передается словарь из списка phones или null если источник не найден.
```
function substCallback(p){
if(p){
document.getElementById('header_img').src=p.phone[1];
}else{
document.getElementById('header_img').src = '/default.png';
}
}
sipuniCalltracking({
pattern:'',
targets:['.title'],
callback: substCallback,
sources:{
...
},
phones:[
{src:'yadirect_dostavka', phone:['Котлы с доставкой', '/kotel_dostavka.png']},
{src:'yadirect_ras', phone:['Котлы в рассрочку', '/kotel_ras.png']}
]
}, window);
```
Проверка и отладка кода подмены
-------------------------------
Проверить работу скрипта можно в jsFiddle. Для того чтобы подключить файл скрипта используйте эту [ссылку](https://rawgit.com/sipuni/static-calltracking/master/src/sipuni-calltracking.js). Напрямую jsFiddle не позволяет подключить файлы из GitHub поэтому ссылка преобразована при помощи сервиса [rawgit.com](https://rawgit.com)
### Страница приземления и реферрер
В обычном режиме вторым параметром скрипта подается объект window. Для отладки вместо него используйте словарь, в котором укажите referrer и посадочную страницу.
```
var wnd = {
document:{referrer:'http://yandex.ru'},
location:{href:'http://mysite.com/?utm_keyword=dostavka'}
};
sipuniCalltracking({
…
}, wnd);
```
### Отключение запоминания источника посетителя
При отладке важно отключить механизм сохранения в куках источника посетителя. Для этого добавьте два параметра:
```
cookie_ttl_days: 0,
cookie_key: 'test1',
```
### Пример
Пример jsFiddle для проверки работы скрипта: [<https://jsfiddle.net/xndmnydj/1/>](https://jsfiddle.net/xndmnydj/1/)
### Не забыть
После отладки не забудьте убрать cookie\_ttl\_days и cookie\_key и заменить параметр wnd на window.
Заключение
----------
У статического коллтрекинга есть ряд преимуществ по сравнению с динамическим: не возникает нехватки номеров при увеличении трафика, не возникает коллизий, когда номер показан другому человеку, а по нему звонит предыдущий посетитель.
Статический коллтрекинг подходит для оценки работы каналов рекламы, например, органика, социальные сети, контекстная реклама. В этом поможет скрипт, описанный в статье.
Скрипт мы создавали для наших клиентов, но поскольку он работает с номерами любых операторов, решили, сделать его открытым, лицензия — MIT.
В планах добавить установку через менеджер пакетов, например Browserify или Webpack.
→ [Репозиторий GitHub](https://github.com/sipuni/static-calltracking) | https://habr.com/ru/post/331540/ | null | ru | null |
# Компиляция C в WebAssembly без Emscripten
Компилятор — часть [Emscripten](https://emscripten.org/). А что, если удалить все свистелки и оставить только его?
Emscripten необходим для компиляции C/C++ в [WebAssembly](https://webassembly.org/). Но это гораздо больше, чем просто компилятор. Цель Emscripten в том, чтобы полностью заменить ваш компилятор C/C++ и запустить в вебе код, который изначально **не предназначен** для Сети. Для этого Emscripten эмулирует всю операционную систему POSIX. Если программа использует [fopen()](http://man7.org/linux/man-pages/man3/fopen.3.html), то Emscripten предоставит эмуляцию файловой системы. Если используется OpenGL, то Emscripten предоставит С-совместимый контекст GL, поддерживаемый [WebGL](https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API). Это немалая работа, и немало кода, который придётся внедрить в итоговый пакет. Но можно ли просто… удалить его?
Собственно *компилятором* в наборе инструментов Emscripten является LLVM. Именно он переводит код C в байт-код WebAssembly. Это современный модульный фреймворк для анализа, трансформации и оптимизации программ. LLVM модульный в том смысле, что он никогда не компилирует прямо в машинный код. Вместо этого встроенный *фронтенд-компилятор* генерирует *промежуточное представление* (IR). Это промежуточное представление, собственно, и называется LLVM, аббревиатура от Low-Level Virtual Machine, отсюда и название проекта.
Затем *бэкенд-компилятор* выполняет перевод IR в машинный код хоста. Преимущество такого строгого разделения заключается в том, что новые архитектуры поддерживаются «простым» добавлением нового компилятора. В этом смысле WebAssembly — лишь одна из многих целей компиляции, которые поддерживает LLVM, и в течение некоторого времени он активировался специальным флагом. Начиная с LLVM 8 цель компиляции WebAssembly доступна по умолчанию.
На MacOS вы можете установить LLVM с помощью [homebrew](https://brew.sh/):
```
$ brew install llvm
$ brew link --force llvm
```
Проверяем поддержку WebAssembly:
```
$ llc --version
LLVM (http://llvm.org/):
LLVM version 8.0.0
Optimized build.
Default target: x86_64-apple-darwin18.5.0
Host CPU: skylake
Registered Targets:
# …Господи, сколько архитектур…
systemz - SystemZ
thumb - Thumb
thumbeb - Thumb (big endian)
wasm32 - WebAssembly 32-bit # Ура! Ура! Ура!
wasm64 - WebAssembly 64-bit
x86 - 32-bit X86: Pentium-Pro and above
x86-64 - 64-bit X86: EM64T and AMD64
xcore - XCore
```
Кажется, мы готовы!
Компиляция C трудным путём
==========================
> **Примечание:** здесь рассмотрим некоторые низкоуровневые форматы RAW WebAssembly. Если вам их трудно понять, это нормально. **Хорошее использование WebAssembly не требует обязательного понимания всего текста в этой статье. Если ищете код для копипаста, см. вызов компилятора в разделе «Оптимизация»**. Но если вам интересно, продолжайте читать! Ранее я написал введение в [чистый Webassembly](https://dassur.ma/things/raw-wasm) и WAT: это основы, необходимые для понимания этого поста.
Предупреждение: я немного отклонюсь от стандарта и на каждом шаге постараюсь использовать удобочитаемые форматы (насколько это возможно). Наша программа здесь будет очень простой, чтобы избежать пограничных ситуаций и не отвлекаться:
```
// Filename: add.c
int add(int a, int b) {
return a*a + b;
}
```
Какой умопомрачительный инженерный подвиг! Особенно потому что программа называется *add*, а на самом деле она ничего не *add* (не добавляет). Что более важно: программа не использует стандартную библиотеку, а из типов здесь только 'int'.
### Превращаем C во внутреннее представление LLVM
Первый шаг — превратить нашу программу C в LLVM IR. Это задача фронтенд-компилятора `clang`, который установился с LLVM:
```
clang \
--target=wasm32 \ # Target WebAssembly
-emit-llvm \ # Emit LLVM IR (instead of host machine code)
-c \ # Only compile, no linking just yet
-S \ # Emit human-readable assembly rather than binary
add.c
```
И в результате мы получаем `add.ll` с внутренним представлением LLVM IR. **Я показываю его только ради полноты картины**. При работе с WebAssembly или даже clang вы как разработчик на C *никогда* не вступаете в контакт с LLVM IR.
```
; ModuleID = 'add.c'
source_filename = "add.c"
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32"
; Function Attrs: norecurse nounwind readnone
define hidden i32 @add(i32, i32) local_unnamed_addr #0 {
%3 = mul nsw i32 %0, %0
%4 = add nsw i32 %3, %1
ret i32 %4
}
attributes #0 = { norecurse nounwind readnone "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" }
!llvm.module.flags = !{!0}
!llvm.ident = !{!1}
!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{!"clang version 8.0.0 (tags/RELEASE_800/final)"}
```
*LLVM IR полна дополнительных метаданных и аннотаций, что позволяет компилятору принимать более обоснованные решения при генерации машинного кода.*
### Превращаем LLVM IR в объектные файлы
Следующий шаг — вызов бэкенд-компилятора `llc`, чтобы сделать из внутреннего представления объектный файл.
Выходной файл `add.o` — это уже валидный модуль WebAssembly, который содержит весь скомпилированный код нашего файла C. Но обычно вы не сможете запустить объектные файлы, поскольку в них отсутствуют существенные части.
Если бы в команде мы опустили `-filetype=obj`, то получили бы ассемблер LLVM для WebAssembly, человекочитаемый формат, который в чём-то похож на WAT. Однако инструмент `llvm-mc` для работы с такими файлами ещё не полностью поддерживает формат и часто не может обработать файлы. Поэтому дизассемблируем объектные файлы постфактум. Для проверки этих объектных файлов нужен специфический инструмент. В случае WebAssembly это `wasm-objdump`, часть [WebAssembly Binary Toolkit](https://github.com/WebAssembly/wabt) или wabt для краткости.
```
$ brew install wabt # in case you haven’t
$ wasm-objdump -x add.o
add.o: file format wasm 0x1
Section Details:
Type[1]:
- type[0] (i32, i32) -> i32
Import[3]:
- memory[0] pages: initial=0 <- env.__linear_memory
- table[0] elem_type=funcref init=0 max=0 <- env.__indirect_function_table
- global[0] i32 mutable=1 <- env.__stack_pointer
Function[1]:
- func[0] sig=0
Code[1]:
- func[0] size=75
Custom:
- name: "linking"
- symbol table [count=2]
- 0: F func=0 binding=global vis=hidden
- 1: G global=0 undefined binding=global vis=default
Custom:
- name: "reloc.CODE"
- relocations for section: 3 (Code) [1]
R\_WASM\_GLOBAL\_INDEX\_LEB offset=0x000006(file=0x000080) symbol=1
```
Выдача показывает, что наша функция add() находится в этом модуле, но она также содержит разделы *custom* с метаданными и, что удивительно, несколько импортов. На следующем этапе *компоновки* разделы custom будут проанализированы и удалены, а с импортом разберётся компоновщик (линкер).
### Компоновка
Традиционно задачей компоновщика является сборка нескольких объектных файлов в исполняемый файл. Компоновщик LLVM называется `lld`, и он вызывается с указанием целевой символической ссылки. Для WebAssembly это `wasm-ld`.
```
wasm-ld \
--no-entry \ # We don’t have an entry function
--export-all \ # Export everything (for now)
-o add.wasm \
add.o
```
В результате получается модуль WebAssembly размером 262 байта.
### Запуск
Конечно, самое главное — увидеть, что всё *действительно* работает. Как и в [прошлой статье](https://dassur.ma/things/raw-wasm), можно использовать пару строк встроенного JavaScript для загрузки и запуска этого модуля WebAssembly.
```
async function init() {
const { instance } = await WebAssembly.instantiateStreaming(
fetch("./add.wasm")
);
console.log(instance.exports.add(4, 1));
}
init();
```
Если всё нормально, вы увидите в консоли DevTool число 17. **Мы только что успешно скомпилировали C в WebAssembly, не трогая Emscripten.** Также стоит отметить, что здесь нет никакого связующего кода для настройки и загрузки модуля WebAssembly.
Компиляция C немного попроще
============================
Для компиляции C в WebAssembly мы сделали немало шагов. Как я уже сказал, в образовательных целях мы рассмотрели подробно все этапы. Давайте пропустим человекочитаемые промежуточные форматы и сразу применим компилятор C как швейцарский армейский нож, как он и был разработан:
```
clang \
--target=wasm32 \
-nostdlib \ # Don’t try and link against a standard library
-Wl,--no-entry \ # Flags passed to the linker
-Wl,--export-all \
-o add.wasm \
add.c
```
Здесь мы получаем такой же файл `.wasm`, но одной командой.
Оптимизация
===========
Посмотрим на WAT нашего модуля WebAssembly, запустив `wasm2wat`:
```
(module
(type (;0;) (func))
(type (;1;) (func (param i32 i32) (result i32)))
(func $__wasm_call_ctors (type 0))
(func $add (type 1) (param i32 i32) (result i32)
(local i32 i32 i32 i32 i32 i32 i32 i32)
global.get 0
local.set 2
i32.const 16
local.set 3
local.get 2
local.get 3
i32.sub
local.set 4
local.get 4
local.get 0
i32.store offset=12
local.get 4
local.get 1
i32.store offset=8
local.get 4
i32.load offset=12
local.set 5
local.get 4
i32.load offset=12
local.set 6
local.get 5
local.get 6
i32.mul
local.set 7
local.get 4
i32.load offset=8
local.set 8
local.get 7
local.get 8
i32.add
local.set 9
local.get 9
return)
(table (;0;) 1 1 anyfunc)
(memory (;0;) 2)
(global (;0;) (mut i32) (i32.const 66560))
(global (;1;) i32 (i32.const 66560))
(global (;2;) i32 (i32.const 1024))
(global (;3;) i32 (i32.const 1024))
(export "memory" (memory 0))
(export "__wasm_call_ctors" (func $__wasm_call_ctors))
(export "__heap_base" (global 1))
(export "__data_end" (global 2))
(export "__dso_handle" (global 3))
(export "add" (func $add)))
```
Ничего себе, какой большой код. К моему удивлению, модуль использует память (что видно по операциям `i32.load` и `i32.store`), восемь локальных и несколько глобальных переменных. Вероятно, вручную можно написать более лаконичную версию. Эта программа такая большая, потому что мы не применили никаких оптимизаций. Давай сделаем это:
```
clang \
--target=wasm32 \
+ -O3 \ # Agressive optimizations
+ -flto \ # Add metadata for link-time optimizations
-nostdlib \
-Wl,--no-entry \
-Wl,--export-all \
+ -Wl,--lto-O3 \ # Aggressive link-time optimizations
-o add.wasm \
add.c
```
> **Примечание:** технически, оптимизация при компоновке (LTO) не даёт никаких преимуществ, поскольку мы компонуем только один файл. В больших проектах LTO поможет заметно уменьшить размер файла.
После выполнения этих команд файл `.wasm` уменьшился с 262 до 197 байт, а WAT тоже стал намного проще:
```
(module
(type (;0;) (func))
(type (;1;) (func (param i32 i32) (result i32)))
(func $__wasm_call_ctors (type 0))
(func $add (type 1) (param i32 i32) (result i32)
local.get 0
local.get 0
i32.mul
local.get 1
i32.add)
(table (;0;) 1 1 anyfunc)
(memory (;0;) 2)
(global (;0;) (mut i32) (i32.const 66560))
(global (;1;) i32 (i32.const 66560))
(global (;2;) i32 (i32.const 1024))
(global (;3;) i32 (i32.const 1024))
(export "memory" (memory 0))
(export "__wasm_call_ctors" (func $__wasm_call_ctors))
(export "__heap_base" (global 1))
(export "__data_end" (global 2))
(export "__dso_handle" (global 3))
(export "add" (func $add)))
```
Вызов стандартной библиотеки
============================
Использование C без стандартной библиотеки libc кажется довольно грубым. Логично добавить её, но буду честен: это *не* будет легко. **На самом деле мы напрямую не вызываем в статье никаких библиотек libc**. Есть несколько подходящих, особенно [glibc](https://www.gnu.org/software/libc/), [musl](https://www.musl-libc.org/) и [dietlibc](https://www.fefe.de/dietlibc/). Однако большинство этих библиотек предполагается запускать в операционной системе POSIX, которая реализует определённый набор системных вызовов. Поскольку у нас в JavaScript нет интерфейса ядра, нам придётся самостоятельно реализовать эти системные вызовы POSIX, вероятно, через JavaScript. Это сложная задача и я не собираюсь этим тут заниматься. Хорошая новость в том, что **именно этим для вас занимается Emscripten**.
Конечно, не все функции libc полагаются на системные вызовы. Такие функции, как `strlen()`, `sin()` или даже `memset()`, реализованы в простом C. Это означает, что вы можете использовать эти функции или даже просто скопировать/вставить их реализацию из какой-нибудь упомянутой библиотеки.
Динамическая память
===================
Без libc нам недоступны фундаментальные интерфейсы C, такие как `malloc()` и `free()`. В неоптимизированном WAT мы видели, что компилятор в случае необходимости использует память. Это означает, что мы не можем просто использовать память, как нам нравится, не рискуя её повредить. Нужно понять, как она используется.
### Модели памяти LLVM
Способ сегментации памяти WebAssembly немного удивит опытных программистов. Во-первых, в WebAssembly технически допустим нулевой адрес, но часто он всё равно обрабатывается как ошибка. Во-вторых, стек приходит первым и увеличивается вниз (к более низким адресам), а куча появляется потом и растёт вверх. Причина в том, что память WebAssembly может увеличиться во время выполнения. Это означает, что нет фиксированного конца для размещения стека или кучи.
Вот макет `wasm-ld`:
*Стек растёт вниз, а куча — вверх. Стек начинается с `__data_end`, а куча — с `__heap_base`. Потому что стек размещается первым, он ограничен максимальным размером, установленным при компиляции, то есть `__heap_base` минус `__data_end`*
Если вернуться и посмотреть на раздел globals в нашем WAT, мы найдём эти значения: `__heap_base` установлен в 66560, а `__data_end` — в 1024. Это означает, что стек может вырасти максимум до 64 КиБ, что не много. К счастью, `wasm-ld` позволяет изменить это значение:
```
clang \
--target=wasm32 \
-O3 \
-flto \
-nostdlib \
-Wl,--no-entry \
-Wl,--export-all \
-Wl,--lto-O3 \
+ -Wl,-z,stack-size=$[8 * 1024 * 1024] \ # Set maximum stack size to 8MiB
-o add.wasm \
add.c
```
### Сборка аллокатора
Известно, что область кучи начинается с `__heap_base`. Поскольку функция `malloc()` отсутствует, мы знаем, что следующую область памяти можно спокойно использовать. Мы можем разместить там данные как угодно, и не нужно бояться повреждения памяти, поскольку стек растёт в другую сторону. Однако свободная для всех куча может быстро засориться, поэтому обычно требуется какое-то динамическое управление памятью. Один из вариантов — взять полноценную реализацию malloc(), такую как [реализация malloc от Дага Ли](http://g.oswego.edu/dl/html/malloc.html), которая используется в Emscripten. Есть ещё несколько небольших реализаций с различными компромиссами.
Но почему бы не написать собственный `malloc()`? Мы так глубоко увязли, что это уже без разницы. Один из простейших — bump-аллокатор: он супербыстрый, чрезвычайно маленький и простой в реализации. Но есть и недостаток: вы не можете освободить память. Хотя на первый взгляд такой аллокатор кажется невероятно бесполезным, но при разработке [Squoosh](https://squoosh.app/) я столкнулся с прецедентами, где он стал бы отличным выбором. Концепция бамп-аллокатора заключается в том, что мы храним начальный адрес неиспользуемой памяти как глобальный. Если программа запрашивает `n` байт памяти, мы передвигаем маркер на `n` и возвращаем предыдущее значение:
```
extern unsigned char __heap_base;
unsigned int bump_pointer = &__heap_base;
void* malloc(int n) {
unsigned int r = bump_pointer;
bump_pointer += n;
return (void *)r;
}
void free(void* p) {
// lol
}
```
Глобальные переменные из WAT фактически определяются `wasm-ld`, так что мы можем получить к ним доступ из нашего кода C как к обычным переменным, если объявим их `extern`. Итак, **мы только что написали собственный `malloc()`… в пяти строчках C**.
> **Примечание:** наш бамп-аллокатор не полностью совместим с `malloc()` из C. Например, мы не даём никаких гарантий выравнивания. Но он достаточно хорошо и работает, так что...
### Использование динамической памяти
Для проверки давайте сделаем функцию C, которая принимает массив чисел произвольного размера и вычисляет сумму. Не очень интересно, но это заставляет использовать динамическую память, так как мы не знаем размер массива во время сборки:
```
int sum(int a[], int len) {
int sum = 0;
for(int i = 0; i < len; i++) {
sum += a[i];
}
return sum;
}
```
Функция sum(), надеюсь, довольно понятна. Более интересный вопрос заключается в том, как передать массив из JavaScript в WebAssembly — в конце концов, WebAssembly понимает только числа. Общая идея состоит в том, чтобы использовать `malloc()` *из JavaScript*, чтобы выделить кусок памяти, скопировать туда значения и передать адрес (число!) *где* находится массив:
```
async function init() {
const { instance } = await WebAssembly.instantiateStreaming(
fetch("./add.wasm")
);
const jsArray = [1, 2, 3, 4, 5];
// Allocate memory for 5 32-bit integers
// and return get starting address.
const cArrayPointer = instance.exports.malloc(jsArray.length \* 4);
// Turn that sequence of 32-bit integers
// into a Uint32Array, starting at that address.
const cArray = new Uint32Array(
instance.exports.memory.buffer,
cArrayPointer,
jsArray.length
);
// Copy the values from JS to C.
cArray.set(jsArray);
// Run the function, passing the starting address and length.
console.log(instance.exports.sum(cArrayPointer, cArray.length));
}
init();
```
После запуска вы должны увидеть в консоли DevTools ответ 15, что действительно является суммой всех чисел от 1 до 5.
Заключение
==========
Итак, вы дочитали до конца. Поздравляю! Опять же, если чувствуете себя немного перегруженным, всё в порядке. **Не обязательно читать все детали. Их понимание совершенно необязательно для хорошего веб-разработчика и даже не требуется для отличного использования WebAssembly**. Но я хотел поделиться этой информацией, потому что она позволяет действительно оценить всю работу, которую делает для вас такой проект, как [Emscripten](https://emscripten.org/). В то же время это даёт понимание, насколько маленькими могут быть чисто вычислительные модули WebAssembly. Модуль Wasm для суммирования массива вместился всего в 230 байт, *включая аллокатор динамической памяти*. Компиляция того же кода с помощью Emscripten даст 100 байт кода WebAssembly и 11K связующего кода JavaScript. Нужно постараться ради такого результата, но бывают ситуации, когда оно того стоит. | https://habr.com/ru/post/454868/ | null | ru | null |
# Официальный мануал по Dart и обновлённый Dart Editor
Команда инженеров Google, ответственная за разработку «замены JavaScript» языка программирования Dart, на днях представила его первый официальный [обзор](http://www.dartlang.org/language-tour/), опубликовав перед этим около месяца назад его полную [спецификацию](http://www.dartlang.org/docs/spec/latest/dart-language-specification.html). Обзор предназначен, прежде всего, для быстрого знакомства с языком или получения по нему быстрой справки. Рассмотрены такие базовые темы для любого мануала как «Hello, world», переменные, типы данных, функции, управление выполнением, исключения, ООП, библиотеки и пространства имён.
Так, к примеру, выглядит итерация по списку:
```
var gifts = {
"first" : "partridge",
"second": "turtledoves",
"fifth" : "golden rings"};
gifts.forEach((k,v) => print('$k : $v'));
```
Также команда Dart обновила редактор Dart Editor, основанный на Eclipse. Список усовершенствований трудно назвать принципиальным — они касаются преимущественно надёжности и стабильности работы. Скорее, наличие редактора устраняет одну существенных проблем для перехода на новый язык разработчиков — наличие IDE. Сейчас Dart Editor и Dart SDK можно загрузить для Windows, Linux и MacOS; также для быстрого старта существует [туториал](http://www.dartlang.org/docs/getting-started/editor/#code) по быстрому созданию приложения.
[[Обзор Dart](http://www.dartlang.org/language-tour/), [Спецификация](http://www.dartlang.org/docs/spec/), Скачать [Dart Editor](http://www.dartlang.org/docs/getting-started/editor/)] | https://habr.com/ru/post/142751/ | null | ru | null |
# Атаки китайской APT-группировки HAFNIUM c использованием 0-day в Microsoft Exchange Server: как это было в России
Важная [новость](https://www.microsoft.com/security/blog/2021/03/02/Hafnium-targeting-exchange-servers) в мире информационной безопасности появилась на прошлой неделе от компании Microsoft о том, что китайская группировка HAFNIUM атакует американские компании и организации с использованием 0-day уязвимости в Microsoft Exchange Server. Новость стала настолько резонансной, что ее транслировали даже [федеральные каналы](https://www.bbc.com/russian/news-56309038?ocid=wsrussian.social.in-app-messaging.telegram..russiantelegram_.edit), а ведущие ИБ-компании незамедлительно публиковали подробности атак, которые они наблюдали ([Volexity](https://www.volexity.com/blog/2021/03/02/active-exploitation-of-microsoft-exchange-zero-day-vulnerabilities/), [Fireeye](https://www.fireeye.com/blog/threat-research/2021/03/detection-response-to-exploitation-of-microsoft-exchange-zero-day-vulnerabilities.html), [Cisco Talos Intelligence Group](https://blog.talosintelligence.com/2021/03/threat-advisory-hafnium-and-microsoft.html)).
Вопрос, который всю предыдущую неделю задавал себе, наверное, каждый специалист по ИБ в России: а как же мы? Нас тоже атаковали с использованием 0-day уязвимости? Спойлер – да. Технические подробности под катом.
В целом сценарий работы группировки HAFNIUM при атаках на российские компании схож с тем, что наблюдалось при атаках на американские организации. При этом мы немного дополним свои наблюдения интересными техническими деталями.
На момент получения образов жестких дисков часть логов и журналов безопасности, к сожалению, ротировалась, а восстановить их нам не удалось. Поэтому, например, следов эксплуатации CVE-2021-26857 в журнале безопасности Application, мы не обнаружили. Зато
CVE-2021-27065 и CVE-2021-26855 видно достаточно ярко.
*Cледы CVE-2021-27065 в C:\Program Files\Microsoft\Exchange Server\V15\Logging\ECP\Server*
*Cледы CVE-2021-26855 в C:\Program Files\Microsoft\Exchange Server\V15\Logging\HttpProxy*
В результате эксплуатации злоумышленники загружали на сервер два Web Shell-а: один для загрузки на сервер произвольных файлов, второй для запуска команд через cmd.exe /c:
*Web Shell для загрузки произвольных файлов*
*Web Shell для запуска команд через cmd.exe /c*
Имена Web Shell-ов были различные, но расположение и User-agent во всех случаях были схожими:
Web Shells
```
owa\auth\current\themes\resources\Expiredtoken.aspx
owa\auth\current\themes\resources\owafont_ki.aspx
owa\auth\current\themes\resources\owafont.aspx
owa\auth\expire.aspx
owa\auth\owafont_ki.aspx
owa\auth\Expiredtoken.aspx
owa\auth\one.aspx
owa\auth\RedirSuites.aspx
```
User-Agents
```
python-requests/2.25.1
Mozilla/5.0+(Windows+NT+6.1;+Win64;+x64;+rv:86.0)+Gecko/20100101+Firefox/86.0
```
Работу злоумышленника через Web Shell всегда хорошо видно в логах IIS, кроме того,
в данном случае там еще и частично видна активность по эксплуатации уязвимостей:
*Следы обращений в логах IIS*
После загрузки на сервер Web Shell-ов, злоумышленники собирали различную информацию о хосте, учетных записях, выгружали архивы электронной почты, интересовавших их людей (именно так, точечно) и забирали всю эту информацию, предварительно архивируя. Cтоит отметить, что с точки зрения стандартного хостового мониторинга сделано это было достаточно шумно, хотя после этого злоумышленники удаляли за собой эксфильтруемые файлы и дополнительные инструменты:
```
cmd.exe /c wmic process list full|findstr /i commandline
```
```
c:\windows\system32\cmd.exe /c schtasks /create /tn ddd /tr "cmd /c reg save HKLM\SAM
```
```
c:\windows\cluster\samBkup.hiv && reg save HKLM\SYSTEM c:\windows\cluster\systemBkup.hiv" /sc onstart /ru system /F
```
```
c:\windows\system32\cmd.exe" /c c:\programdata\as.log a -pqweasd123#@!MB
```
```
c:\programdata\hiv.png c:\windows\cluster\*.hiv
```
```
cmd.exe /c reg query
HKEY_LOCAL_MACHINE\system\currentcontrolset\control\securityproviders\wdigest && hostname
```
```
cmd.exe /c reg add
HKEY_LOCAL_MACHINE\system\currentcontrolset\control\securityproviders\wdigest /v uselogoncredential /t reg_dword /d 1 /f
```
```
rundll32.exe C:\Windows\System32\comsvcs.dll, MiniDump 848 c:\programdata\dm.bin full
cmd.exe /c powershell -execu bypass -f c:\programdata\n.ps1
cmd.exe /c powershell -exec bypass -w 1 -file c:\programdata\exinfo.ps1
```
Скрипт n.ps1 был использован для выгрузки электронной почты и сбора статистики через скрипт excshell.psc1 (стандартный механизм).
*Скрипт n.ps1*
Результат работы данного скрипта хорошо виден при настроенном аудите логов Exchange
*Логи Exchange после выгрузки электронной почты скриптом n.ps1*
Скрипт exinfo.ps1 необходим для сбора достаточно большой информации о хосте (часть кода заимствована из [проекта Nishang](https://github.com/samratashok/nishang/blob/0090ba2e51b7503c3245081894c0fc87b696f941/Gather/Get-Information.ps1)) и запуска кастомной сборки Mimikatz
*Основная функция exeinfo.ps1*
Перечислять каждую функцию по сбору информации нет смысла, поэтому мы покажем только первую и вторую, а дальше остановимся на своеобразной сборке Mimikatz, используемой злоумышленниками при данных атаках.
*Функции t1 и t2 (сбор информации) из exeinfo.ps1*
Mimikatz запускается через запуск исполняемого файла, содержащего в себе две динамические библиотеки, и загрузку одной из них в память процесса lsass.exe через вызов функции NdrClientCall3
*Функция t6 (запуск mimikatz) из exeinfo.ps1*
**C:\windows\Cluster\ accace.exe (SHA256: 0D648339C975CF04F6C8DC99CD09EA508F16C553A47847B522341CE5857424A2).**
Данный файл содержит в себе две библиотеки:
* twindump.dll (находится в ресурсах accace.exe в открытом виде)
* lsadll.dll (закодирована в base64 и зашифрована с помощью AES CBC)
Запускается следующим образом: cmd.exe" /c r <ключ> <вектор инициализации> .
Ключ и вектор инициализации необходимы, чтобы расшифровать lsadll.dll. Если ввести их неправильно, файл не отработает. Параметр path задает путь, по которому создается библиотека twindump.dll. По умолчанию – C:\ProgramData\twindump.dll.
*accace.exe.exe использует библиотеку CryptoPP*
**lsadll.dll (SHA256: EE91A2ADF1581CEEAEB690125A60A3CCD94B98ECE545679D1E95E609AB9666F9)**
Библиотека имеет одну экспортную функцию «DO», задача которой, используя API AddSecurityPackage (через RPC), заставить процесс lsass.exe загрузить библиотеку twindump.dll.
При этом данную технику можно детектировать путем отслеживания загрузки неподписанных библиотек в процесс lsass.exe.
*Вызов AddSecurityPackage*
**twindump.dll (SHA256: 94512C434290405BEFD159FC3C4ED01F18722F966D53DAC45760DD36C4D9B918)**
Содержит в себе зашифрованную библиотеку mimikatz.dll.
*DllEntryPoint twindump.dll*
*Экспортируемая функция «Do» библиотеки mimikatz.dll*
### Вместо заключения
Как мы показали, китайская группировка HAFNIUM действовала схожим образом при атаках как на американские, так и на российские организации, и, если честно, это немного удивляет. Ведь обычно APT-группировки, имея в запасе эксплойт для 0-day уязвимости, стараются его использовать редко, в исключительных случаях. Но, как мы видим, в этих историях кратковременный результат оказался важнее.
Хочется напомнить, что, сетевые индикаторы в данном случае малоэффективны, ведь это даже не CnC, которые живут некоторые время, а обычные хостинги, VPS-серверы и proxy-цепочки, цель которых единожды запустить код на вашем непропатченном Exchange-сервере. А если вы хотите провести ретроспективную проверку, то куда более эффективно будет проверить ваши Exchange-логи на наличие определённых признаков (все это описано в статье Microsoft).
Напоследок мы в очередной раз призываем всех обновляться. И если вдруг по каким-то причинам вы не можете это сделать, то скорее настраивайте аудит и организуйте мониторинг событий информационной безопасности – ведь даже несмотря на то, что это были 0-day уязвимости, активность злоумышленника возможно было своевременно обнаружить с помощью описанных ниже правил детекта.
 | https://habr.com/ru/post/545164/ | null | ru | null |
# Визуализация характеристической функции
Многие в общих чертах представляют, как работает обратная лучевая трассировка: через каждый пиксель окна вывода алгоритм пропускает луч и вычисляет, с какими объектами сцены он пересекается и как в результате данный пиксель должен быть освещён. Алгоритм по сути требует, чтобы у нас была функция, которая для каждой позиции возвращает цвет точки. Разумеется, тот же подход можно применять не только для трёхмерной графики: любое изображение можно растеризовать таким образом, если у нас есть подходящая функция. Рассмотрим для примера, как с помощью такого подхода решить задачу визуализации [диаграмм разложения на простые множители](http://habrahabr.ru/post/154073/), о которой написал [helarqjsc](http://habrahabr.ru/users/helarqjsc/).
Моя реализация [здесь](http://amaembo.github.io/primes/primes.html). На картинке изображено 10! = 3628800, хотя всех деталей, разумеется, не видно.
В данной задаче, как и во многих других, цвет бинаризованный: или чёрный, или белый. Соответственно, нам нужна функция вида function check(x,y), которая возвращает логическое значение, говорящее нам, следует ли закрасить данную точку. Математики бы сказали, что check(x,y) — характеристическая функция множества точек на плоскости (в математике такая функция обычно возвращает 1 или 0). Если эта функция задана, алгоритм рисования на HTML5 Canvas будет достаточно прост:
```
function trace(canvas) {
var ctx = canvas.getContext("2d");
var w = canvas.width;
var h = canvas.height;
var img = ctx.createImageData(w, h);
for(var x=0; x
```
Здесь мы пользуемся тем, что createImageData создаёт чёрный прозрачный холст. Мы меняем только байт, отвечающий за прозрачность.
Пусть мы хотим изобразить, к примеру, круг с центром (50, 50) и радиусом 50. Функция check(x,y) будет выглядеть так:
```
function check(x,y) {
return (x-50)*(x-50)+(y-50)*(y-50)<50*50;
}
```
Сумма квадратов расстояний от центра меньше квадрата радиуса. Получим такую картинку:
Разумеется, для круга проще и дешевле воспользоваться библиотечной функцией. Кроме того, наш круг получился угловатым. Чтобы с этим немного побороться, воспользуемся субпиксельным рендерингом: разделим пиксель на n×n более маленьких, прогоним check для каждого из них и установим прозрачность пропорционально количеству успешных проверок:
```
function trace(canvas) {
var ctx = canvas.getContext("2d");
var w = canvas.width;
var h = canvas.height;
var img = ctx.createImageData(w, h);
var n = 2;
for(var x=0; x
```
Результат получается такой:
Уже вполне красиво. Кому мало, можно увеличить значение n (разумеется, считать будет медленнее).
Вернёмся к исходной задаче. По сути дела нам нужно написать характеристическую функцию для диаграммы разложения числа на простые множители. Я немного поменяю прототип функции, чтобы передать все нужные параметры задачи и воспользоваться рекурсией. Функция check будет принимать аргументы (factors, n, x, y, r), где x и y координаты точки относительно центра окружности, r — радиус окружности, factors — массив простых множителей, где двойки уже объединены в четвёрки, как это делал [helarqjsc](http://habrahabr.ru/users/helarqjsc/), а n — элемент массива, с которого нам нужно начинать рассмотрение. Тогда функция check будет выглядеть примерно так:
— Если расстояние от центра до текущей точки больше радиуса, точка точно не подходит — вернём false;
— Если n указывает на конец массива, значит мы добрались до конца и надо просто рисовать закрашенный кружок — вернём true;
— Иначе вычислим радиус окружности следующего порядка (r1);
— Если расстояние от центра до текущей точки меньше радиуса за вычетом диаметра новой окружности (2\*r1), то точка попадает внутрь кольца — вернём false;
— Вычислим сектор, в который попадает точка (серым цветом на картинке);
— Вызовем саму себя с тем же factors, на единицу большим n, новым радиусом r1 и значениями x и y, откорректированными в соответствии с центром новой окружности.
Вот, собственно, и всё. Готовое приложение на JS вы можете видеть [здесь](http://biorainbow.com/~lan/primes.html) (требуется поддержка canvas в браузере, никаких fallback для IE 6-8 нету). Я использовал функции [helarqjsc](http://habrahabr.ru/users/helarqjsc/) для разложения на простые множители, а рендеринг полностью мой. Картинки у меня немного другие, потому что радиусы окружностей и расположение секторов я вычислял по-другому. Можно заметить, что скорость отрисовки практически не зависит от вводимого числа. Хотя реализация [helarqjsc](http://habrahabr.ru/users/helarqjsc/) быстрее для первой сотни, но дальше моя начинает выигрывать (для честности я тоже не кэшировал значения синусов и косинусов). Использованный мной подход позволяет упростить и ускорить визуализацию многих нетривиальных вещей. Особенно он полезен при рендеринге фракталов. Заметьте также, что при моём подходе очень легко добавить неограниченный зум в любой области рисунка. | https://habr.com/ru/post/154343/ | null | ru | null |
# Чего вам не говорили про сокеты
Чтобы эффективно писать приложения, общающиеся через сокеты, мне пришлось понять кое-что, чего мне не сообщал никто и что не написано ни в какой документации.
Если у вас есть опыт написания приложения с использованием сокетов, то вся эта информация должна быть для вас очевидной. Она неочевидна для меня как абсолютного новичка, поэтому я попытаюсь как можно подробнее объяснить это, чтобы ускорить процесс освоения сокетов для других новичков.
Надёжность TCP и надёжность приложений
======================================
TCP гарантирует надёжность с точки зрения потока; он не гарантирует, что каждый `send()` будет принят (`recv()`) соединением. Это отличие очень важно. Чтобы понять это, мне понадобилось время.
Фундаментальная задача, которую я пытался решить, — это чистая обработка [нарушения связности сети](https://en.wikipedia.org/wiki/Network_partition), то есть когда машина А и машина Б оказываются полностью разъединены. Разумеется, TCP не может гарантировать, что сообщения будут доставлены, если машина выключена или отсоединена от сети. TCP какое-то время будет хранить данные в своём буфере отправки, но в конечном итоге сбросит данные по таймауту. Я уверен, что там происходит ещё и что-то ещё, но с точки зрения приложения это всё, что мне нужно знать.
Здесь важно то, что если я отправлю при помощи `send()` сообщение, нет никаких гарантий, что другая машина получит его при помощи `recv()`, если внезапно отключится от сети. Это опять-таки может быть очевидно для опытного сетевого программиста, но для абсолютного новичка это было непривычно. Когда я прочитал, что TCP гарантирует надёжную доставку, то ошибочно посчитал, что, например, `send()` блокируется и возвращает успешное выполнение только после успешного получения сообщения на стороне `recv()`.
Такую `send()` можно написать, и она будет гарантировать на уровне приложения, что сообщения точно попадут к получающему приложению, и что они считаются получающим приложением. Однако скорость взаимодействия приложения существенно упадёт, потому что каждый вызов `send()` будет заставлять приложение ожидать подтверждения того, что другое приложение получило сообщение.
Вместо этого мы будем надеяться, что другое приложение по-прежнему подключено и будем отправлять один или несколько вызовов `send()` в буфер, который за нас обрабатывает TCP. Затем TCP сделает всё возможное, чтобы передать данные другому приложению, но в случае разъединения мы, по сути, потеряем их полностью.
Надёжность приложений
---------------------
Разработчики приложений должны решить, как их приложение реагирует на неожиданные разъединения. Нужно решить, насколько сильно вы будете пытаться узнать, действительно ли получающее приложение получило каждый бит передаваемых данных.
Противоречит интуитивному пониманию здесь то, что для этого нужно будет реализовать подтверждающие сообщения, разметку сообщений идентификаторами, создание буфера и системы для повторной отправки сообщений и/или, возможно, даже таймауты, связанные с каждым сообщением. По описанию очень похоже на TCP, не так ли? Разница в том, что вы не имеете дело с ненадёжностью UDP, которую приходится обрабатывать TCP. Вы имеете дело с ненадёжностью машин в сети, в общем случае включенных и находящихся онлайн.
Возможно, вам покажется сложной реализация всех этих вещей, однако они позволят вашему приложению иметь интересные способности:
* Можно хранить пакеты данных на жёстком диске, тогда если возникнет сбой приложения или машины, то вы всё равно можете попытаться отправить эти данные, когда всё придёт в норму.
* Можно допустить разъединения во время длительных операций; когда две машины наконец восстановят связь, можно будет передать результаты операции.
* Можно определять насколько важно подтверждать доставку в каждом конкретном случае. Например, можно прикладывать большие усилия к тому, чтобы подтвердить завершение длительной операции, но смириться с утерей данных, сообщающих о степени выполнения операции. Из-за первого пользователь может подумать, что ему придётся перезапустить потециально требовательную операцию, а из-за второго всего лишь будет немного дёргаться полоса прогресса.
Возможно, вам не требуется надёжность на уровне приложения. Многие приложения просто завершают работу, если происходит отключение в неожиданный момент. Мне же нужно было, чтобы мои приложения спокойно продолжали работу, пытаясь восстановить подключение. Это означало, что мне требуется отдельный цикл переподключения, который будет какое-то время спать, а затем пытаться переподключиться и если это удастся, продолжить обычную работу.
Я пока не реализовал надёжность уровня приложения в своём приложении, потому что меня не особо волнует, что какие-то данные не будут получены. Однако это решение следует принимать в каждом конкретном случае. Например, если я выполняю сборку, которая занимает два часа, но сообщение «сборка выполнена» будет утеряло из-за отключения, мне может потребоваться ещё два часа на ненужное повторное выполнение сборки. Если бы у меня была надёжность на уровне приложения, то я знал бы, что сборка успешно завершена. Однако за это пришлось бы заплатить увеличением времени разработки и сложности системы, но, вероятно, в каких-то ситуациях оно того стоит.
recv() и SIGPIPE
================
Поначалу меня очень сбивало с толку то, что мне нужно было пробовать безуспешно выполнить `recv()` из сокета только для того, чтобы понять, что соединение больше неактивно. Я ожидал, что можно будет вызывать, например, `isconnected()` для сокетов после того, как `accept()` сообщит, что с ним что-то произошло. Теперь мне кажется логичным то, что лучше безуспешно выполнить `recv()`, чтобы получить информацию о разъединении. В противном случае я мог бы ошибочно предположить, что если я вызову `isconnected()`, то гарантированно буду иметь хороший `recv()`. Благодаря тому, что разъединение связано с безуспешным `recv()`, я знаю, что мне нужно обрабатывать потенциальные разъединения при любом вызове `recv()`. То же самое относится и к `send()`.
В Linux мне также нужно отключить оповещения при `recv()`, чтобы я мог обрабатывать ошибку подключения линейно, а не регистрировать для этого обработчик сигналов. Я решил добавить к `send()` и `recv()` `MSG_NOSIGNAL`, и обрабатывать потенциальные ошибки разъединения при каждом вызове. Возможно, это не так характерно для Linux, где обработчик сигнала может быть более общим, однако это даёт мне гораздо больше контроля при разработке приложений. Также это лучше работает при портировании в Windows, которая не использует сигналы для сообщений об разъединениях.
Не используйте с сокетами API Linux, где «всё — это файл»
=========================================================
Linux позволяет работать с сокетами так, как будто это дескрипторы файлов. Это удобно, потому что можно реализовать в приложение поддержку потоковой передачи в/из файла и сокета при помощи одного кода.
Однако Windows не работает с сокетами так же, как с файлами. Если вы хотите использовать нативные Windows API, то нужно применять специализированные функции сокетов: `send()`, `recv()`, `closesocket()` и так далее.
Я считаю, что абстракцию Linux не стоит использовать с точки зрения надёжности. Обработка уже несуществующего файла и разъединения сокета, скорее всего, будет очень разной. Я уверен, что у кого-то найдутся возражения, и что кому-то нужно писать приложения так, чтобы они обрабатывались одинаково. Мне важна качественная поддержка Windows, поэтому даже если я и ошибаюсь, мои руки всё равно связаны.
Разумеется, вы можете написать для них собственный уровень абстракции, но повторюсь, факторы надёжности и производительности файлов и сокетов сильно отличаются. Мне кажется, что если можно работать с ними по-разному, то это и нужно делать, хотя бы для понимания и контроля. Можно ещё задать вопрос: как часто в пишете приложения, которым нужно принимать и файлы, и сокеты? По моему опыту подобные вещи случаются в подавляющем меньшинстве случаев. Обычно я знаю, куда передаются мои данные, и *хочу* это знать, чтобы принимать более осознанные решения о производительности.
Главный цикл `select()` приложения
==================================
Приложение знает, когда ему нужно выполнить запись в сокет. Но оно не всегда знает, когда ему нужно выполнить чтение из сокета. Это значит, что я должен добавлять сокеты в список записи `select()` только тогда, когда у меня есть готовое к отправке сообщение. Следует всегда добавлять все сокеты в список чтения `select()`, если я хочу, чтобы приложение было достаточно гибким для получения сообщений в любой момент.
Если для одной операции есть множество передач туда и обратно, то я всё равно могу это закодировать, однако код становится менее гибким. Проще попытаться обойтись одной отправкой, а затем обрабатывать получение в главном цикле `select`. Для этого может потребоваться хранение состояния в метаданных, связанных с каждым соединением, или добавления в сообщения идентификаторов, чтобы связывать их с другим состоянием.
Если `select()` будет только выполнять отправку или получения в каждом сокете, то это улучшит работу с несколькими соединениями. Например, можно отправить команду начать длительную операцию на другой машине, затем получить сообщения от других соединений, пока эта длительная операция выполняется. В противном случае придётся выносить код отправки и получения этой длительной операции в другой поток или что-то иное, чтобы можно было обрабатывать другие подключения.
Это вызывает меньше проблем, если вы, например, получаете запрос, а затем можете быстро составить и отправить ответ. В таких случаях можно просто получать и отправлять ту же итерацию `select()` по этому соединению, чтобы ничего не усложнять. Если код получающего приложения имеет схожую структуру, то оно тоже может решать, нужно ли выполнять получение сразу после отправки или вернуться в свой цикл `select()`.
Сокеты — это всё равно круто
============================
Мне понадобилось довольно много времени, чтобы понять, что необходимо для написания приложений, эффективно использующих сокеты. Заплатив эту цену, я чувствую, как будто обрёл новую сверхспособность.
Похожие ощущения у меня были, когда я узнал, как выполнять подпроцессы, и когда я научился загружать код динамически1. Подобные вещи ломают преграды и открывают двери к новым восхитительным возможностям.
И хотя я потратил гораздо больше времени, чем ожидалось, на создание проекта, для которого мне пришлось изучать сокеты, я рад, что это сделал.
---
1. Если вы не изучили их, то это определённо стоит сделать. Вот функции, которые можно поискать:
Для запуска подпроцессов (sub-process):
| Платформа | Функция |
| --- | --- |
| Windows | `CreateProcess` |
| Linux | `fork`, `exec` |
Для динамической загрузки:
| Платформа | Функция |
| --- | --- |
| Windows | `LoadLibrary`, `GetProcAddress` |
| Linux | `dlopen`, `dlsym` |
Если вы хотите загружать код без использования динамического связывания, то вам стоит изучить *виртуальную память* и `mmap()` (Linux) или `VirtualAlloc()` (Windows).
Благодаря использованию выполнения подпроцессов и динамической загрузки вы можете сделать, например, так, чтобы приложения вызывали компилятор для сборки динамической библиотеки, а затем сразу же загружали эту библиотеку в то же приложение. Это единственный способ, при помощи которого пользователи смогут изменять и расширять приложение в процессе его работы. | https://habr.com/ru/post/686134/ | null | ru | null |
# Получаем атрибуты S.M.A.R.T
 S.M.A.R.T это технология оценки состояния жесткого диска, помогающая оценить текущее состояние и предсказать возможные проблемы и выход устройства из строя. Атрибуты S.M.A.R.T условно можно разделить на две группы: параметры, отражающие процесс изнашивания (старения) диска и текущие параметры (например, параметры производительности).
Каждый атрибут имеет идентификатор, тип (критический, показатель производительности, счетчик ошибок, счетчик событий), текущее значение, пороговое значение (если текущее меньше порогового — начинайте искать новый диск), самое низкое, зафиксированное, значение атрибута. Описание каждого атрибута можно посмотреть [здесь](http://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F_SMART).
На этом теоретическая часть заканчивается, перейдем к практике. Напишем программу, которая будет считывать и отображать атрибуты S.M.A.R.T. Скачать готовую программу с исходниками можно [здесь](http://intelloware.com/Download/smart.zip).
Для начала определим структуры, в которые мы будем получать интересующую нас информацию:
> `// Заголовок атрибутов
>
> typedef struct \_DRIVEATTRIBUTEHDR
>
> {
>
> // Номер версии
>
> WORD wRevision;
>
> // Данные
>
> BYTE bData[1];
>
> }
>
> DRIVEATTRIBUTEHDR, \*PDRIVEATTRIBUTEHDR, \*LPDRIVEATTRIBUTEHDR;
>
>
>
> // атрибут S.M.A.R.T
>
> typedef struct \_DRIVEATTRIBUTE
>
> {
>
> // Идентификатор атрибута
>
> BYTE bAttrID;
>
> // Тип атрибута (критический, счетчик ошибок и т.д.)
>
> WORD wStatusFlags;
>
> // Значение атрибута
>
> BYTE bAttrValue;
>
> // Худшее, зафиксированное, значение
>
> BYTE bWorstValue;
>
> // Значение атрибута, ненормализованное
>
> BYTE bRawValue[6];
>
> BYTE bReserved;
>
> }
>
> DRIVEATTRIBUTE, \*PDRIVEATTRIBUTE, \*LPDRIVEATTRIBUTE;
>
>
>
> // Пареметр Threshold (пороговое значение) атрибута S.M.A.R.T
>
> typedef struct \_ATTRTHRESHOLD
>
> {
>
> // Идентификатор атрибута
>
> BYTE bAttrID;
>
> // Значение
>
> BYTE bWarrantyThreshold;
>
> BYTE bReserved[10];
>
> }
>
> ATTRTHRESHOLD, \*PATTRTHRESHOLD, \*LPATTRTHRESHOLD;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все начинается с получения дескриптора диска:
> `HANDLE hDrive = CreateFile("\\\\.\\PHYSICALDRIVE0", GENERIC\_READ, FILE\_SHARE\_DELETE | FILE\_SHARE\_READ | FILE\_SHARE\_WRITE, NULL, OPEN\_EXISTING, FILE\_ATTRIBUTE\_NORMAL, NULL);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь 0 в *"\\\\.\\PHYSICALDRIVE0"* означает номер физического диска в системе.
После получения дескриптора необходимо заполнить структуру *SENDCMDINPARAMS*
> `SENDCMDINPARAMS cmdIn = {0};
>
> // Размер буфера для получения атрибутов
>
> cmdIn.cBufferSize = READ\_ATTRIBUTE\_BUFFER\_SIZE;
>
> // Комманда IDE
>
> cmdIn.irDriveRegs.bCommandReg = SMART\_CMD;
>
> // Запрос на чтение атрибутов
>
> cmdIn.irDriveRegs.bFeaturesReg = READ\_ATTRIBUTES;
>
> // Младший разряд, указывающий на номер цилиндра
>
> cmdIn.irDriveRegs.bCylLowReg = SMART\_CYL\_LOW;
>
> // Старший разряд, указывающий на номер цилиндра
>
> cmdIn.irDriveRegs.bCylHighReg = SMART\_CYL\_HI;
>
> // Регистр количества секторов
>
> cmdIn.irDriveRegs.bSectorCountReg = 1;
>
> // Регистр номера сектора
>
> cmdIn.irDriveRegs.bSectorNumberReg = 1;
>
> // Регистр диска\головки IDE
>
> cmdIn.irDriveRegs.bDriveHeadReg = 0xA0 | (((BYTE)nDrive & 1) << 4);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Запрашиваем атрибуты:
> `BYTE bOutAttributes[sizeof(SENDCMDOUTPARAMS) + READ\_ATTRIBUTE\_BUFFER\_SIZE - 1] = {0};
>
> DeviceIoControl(hDrive, SMART\_RCV\_DRIVE\_DATA, &cmdIn, sizeof(cmdIn), bOutAttributes, sizeof(bOutAttributes), &dwReturn, NULL);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
При успешном выполнении атрибуты будут записаны в буффер *bOutAttributes*. Преобразуем указатель, чтобы с ним можно было работать как с массивом структур
> `// Заголовок
>
> LPDRIVEATTRIBUTEHDR lpAttrHdr = (LPDRIVEATTRIBUTEHDR)(((LPSENDCMDOUTPARAMS)bOutAttributes)->bBuffer);
>
> // Указатель на атрибуты
>
> LPDRIVEATTRIBUTE lpAttr = (LPDRIVEATTRIBUTE)(lpAttrHdr->bData);
>
>
>
> // Что-то делаем с полученными атрибутами
>
> // NUM\_ATTRIBUTE\_STRUCTS - максимально возможное количество атрибутов S.M.A.R.T
>
> // в настоящий момент равняется 30-ти
>
> for(int iAttr = 0; iAttr < NUM\_ATTRIBUTE\_STRUCTS; iAttr++)
>
> {
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Получим пороговые значения (*Threshold*), делается это почти так же, как и в случае чтение атрибутов. Заполняется структура *SENDCMDINPARAMS*, меняются два параметра
> `cmdIn.cBufferSize = READ\_THRESHOLD\_BUFFER\_SIZE;
>
> cmdIn.irDriveRegs.bFeaturesReg = READ\_THRESHOLDS;
>
>
>
> // Получаем значения
>
> BYTE bOutThresholds[sizeof(SENDCMDOUTPARAMS) + READ\_THRESHOLD\_BUFFER\_SIZE - 1] = {0};
>
> bResult = DeviceIoControl(drive, SMART\_RCV\_DRIVE\_DATA, &cmdIn, sizeof(cmdIn), bOutThresholds, sizeof(bOutThresholds), &dwReturn, NULL);
>
>
>
> // Получем указатели
>
> LPDRIVEATTRIBUTEHDR lpThrHdr = (LPDRIVEATTRIBUTEHDR)(((LPSENDCMDOUTPARAMS)bOutThresholds)->bBuffer);
>
> LPATTRTHRESHOLD lpThresholds = (LPATTRTHRESHOLD)(lpThrHdr->bData);
>
>
>
> // Что-то делаем с полученными значениями
>
> for(int iAttr = 0; iAttr < NUM\_ATTRIBUTE\_STRUCTS; iAttr++)
>
> {
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для простоты работы я обернул получение информации в класс *CSMARTInfo*
> `// Структура-обертка для S.M.A.R.T атрибута
>
> typedef struct SMARTAttribute
>
> {
>
> int nId;
>
>
>
> BYTE bValue;
>
> BYTE bWorst;
>
> BYTE bThreshold;
>
>
>
> WORD wStatusFlags;
>
>
>
> \_\_int64 nRaw;
>
> }
>
> SMARTAttribute;
>
>
>
> // Класс для работы со S.M.A.R.T
>
> class CSMARTInfo
>
> {
>
> public:
>
> CSMARTInfo();
>
> ~CSMARTInfo();
>
>
>
> public:
>
> // Вспомогательная функция, возвращающая
>
> // название модели жесткого диска
>
> BOOL GetDriveModel(int nDrive, wstring &strModel);
>
>
>
> // Поддерживается ли S.M.A.R.T на указанном диске
>
> BOOL IsSmartSupported(int nDrive);
>
> // Включить S.M.A.R.T на указанном диске
>
> BOOL EnableSmart(int nDrive);
>
>
>
> // Получить информацию о диске
>
> BOOL GetInfo(int nDrive, GETVERSIONINPARAMS &info);
>
> // Получить S.M.A.R.T атрибуты
>
> BOOL GetAttributes(int nDrive, vector &attributes);
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Пока я разбирался со S.M.A.R.T сделал интересное наблюдение. Стандарт-стандартом, а вот значение и предназначение атрибутов, так же как и их трактовка у различных производителей своя. Например мой Seagate показывает жуткое, постоянно увеличивающееся, значение атрибутов *Raw Read Error Rate* (ID = 0x1) и *Seek Error Rate* (ID = 0x7). Я попытался найти информацию об этих параметрах применительно к Seagate, но так ничего и не нашел, не считая сообщений пользователей на данную тему на форуме Seagate и заверетильные ответы тех. поддержки, что все нормально, так должно и быть.
Использовать S.M.A.R.T можно не только для диагностики и предсказания проблем, но и, например, для проверки — а не б\у ли мы купили, атрибут *Power-On Hours* (ID=0х9, число часов, проведенных во включенном состоянии) или *Device Power Cycle Count* (ID=0x0C, количество полных циклов включения-выключения диска). А не падал ли этот диск в процессе работы (в смысле физически, на пол) — атрибут *G-sense error rate* (0хBF, количество ошибок, возникающих в результате ударных нагрузок) | https://habr.com/ru/post/78652/ | null | ru | null |
# Почему вы не отвечаете на мой вопрос?
На различных Q&A-сайтах и форумах, связанных с разработкой, я провёл времени больше, чем хотелось бы признавать. Там я ответил на тысячи вопросов. Как правило, вопросы остаются в границах таких форумов. Но после того, как вопросы начали сыпаться на мой личный почтовый ящик, я подумал, что надо написать об этом.
Эти электронные письма и сообщения обычно поступают от людей, с которыми я никогда раньше не общался — все они просто знают, что я «отвечаю на вопросы или решаю проблемы». Всё обычно выглядит примерно так:
* Я написал вопрос по ссылке {здесь}. Могли бы вы исправить ошибку?
* Привет, пожалуйста, помогите здесь {ссылка}.
* У меня есть серьёзное домашнее задание со сроком сдачи сегодня в 5 вечера, и мне с ним не справиться. Могли бы вы скачать его здесь {ссылка} и сделать так, чтобы к тому времени оно работало?
Это полные тексты реальных электронных писем, которые я нередко получаю.
Не имею ничего против людей, которые просят о помощи, поэтому я и участвую в сообществах вопросов и ответов. Дело в том, что есть много неправильных способов обратиться за помощью, в частности — плохие вопросы.
Здесь я укажу несколько причин, по которым такие прямые запросы остаются без ответа, напишу, как действовать, чтобы получить ответ на вопрос, и представлю несколько шагов, которые вы должны сделать до отправки вопроса, чтобы он не оказался плохим.
Как получать ответы
-------------------
На разных форумах и сайтах, таких как Stack Overflow, есть *много* вопросов, оставшихся без ответа. Основная причина: большинство этих вопросов — просто плохие.
Если вы желаете задать вопрос, попробуйте пройтись по списку ниже, чтобы ваш вопрос не ушёл в безответное небытие:
* **Вы погуглили ваш вопрос?** Серьёзно. Просто скопируйте точное сообщение о вашей ошибке и потратьте несколько минут на чтение результатов выдачи. Это решит 90%+ всех проблем, с которыми вы сталкиваетесь.
* **Хорошо, Google не помог. Что дальше?** Я вам не верю. Поищите ещё, попробуйте изменить некоторые условия поиска и удалить всё специфическое для конкретного *вашего* случая (например, название проекта и т.д.).
* **Может быть, спросить коллегу?** Если вы работаете в команде, то попросите помочь. Две головы часто лучше, чем одна, и обычно найти ответ, сидя рядом с кем-то, легче, чем через Интернет.
* **Нет коллеги? Как насчёт утёнка?** Я знаю, что это может показаться глупым, но нередко [метод утёнка](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D1%83%D1%82%D1%91%D0%BD%D0%BA%D0%B0) помогает взглянуть на проблемы со стороны или даже решить их. Просто попробуйте озвучить точно вашу проблему кому-нибудь (или чему-нибудь) и посмотреть, щёлкнет ли что-нибудь в вас. Я знаю, это звучит глупо, но вы удивитесь, насколько эффективным может быть результат.
* **Рассмотрите возможность проверки в «нишевых» точках.** Если применимо, то рассмотрите возможность проверки репозитория GitHub для конкретной проблемы или вопроса. Или используйте функцию поиска на некоторых «нишевых» форумах или сайтах (например, «отправка электронной почты в MVC» на форумах ASP.NET). Кстати, эти сайты могут не индексироваться, поэтому их труднее найти в выдаче поисковой системы.
* **Всё-таки ничего. Что делать?** Если вам всё-таки не повезло, тогда, вероятно, пора задать вопрос где-нибудь. Опять же — скорее всего, похожую проблему решали до вас, но вы обнаружите это лишь позже.
Как задать (правильный) вопрос
------------------------------
Итак, вы просмотрели всю Сеть. Вы выполнили бесчисленные поиски по каждой комбинации поисковых терминов и синонимов, которые только можно себе представить, и всё равно — ничего.
Наверное, настало время задать вопрос. Давайте рассмотрим несколько вещей, которые вы должны помнить в этом процессе:
* **Заголовок — это всё!** Описательный и содержательный заголовок вашего вопроса имеет исключительное значение. Заголовок должен передавать основную проблему (например, «Null Reference Exception в ASP.NET Telerik GridView при разбиении на страницы» вместо «Помогите! GridView не работает»). Если ваш заголовок достаточно описательный, то его прочитают, а чем больше людей прочитает его, тем больше шансов получить ответ.
* **Не забрасывайте сеть слишком широко.** Не нужно описывать всё ваше приложение и его общее назначение. Будьте проще и сосредоточьтесь только на одной проблеме или на одном варианте использования. Чем выше фокус, тем выше вероятность того, что вы получите результаты.
* **Конкретнее.** Будьте настолько конкретными, насколько сможете. Не заявляйте просто, «что-то не работает». Укажите точно, что вы пытаетесь выполнить, что вы пробовали и какой результат вы ожидаете получить.
* **…Но не слишком.** Хотя важно включать детали, не переусердствуйте. Не надо вставлять огромные куски HTML, CSS, Javascript, SQL и другого кода, прокручивая через которые можно заработать кистевой туннельный синдром — такое отпугивает. Опять же — кратко и только нужные детали.
* **Не гадайте с ошибками.** Если ваш вопрос связан с ошибками, попробуйте включить *точное* сообщение об ошибке из системы, а не использовать: «Кажется, случилось или вывело то-то». Специфика имеет значение; иногда ошибка при компиляции и ошибка при выполнении — вещи совершенно разные, поэтому пусть ваши возможные читатели знают, что и когда происходит.
* **Это воспроизводится? Тогда воспроизведите проблему.** Если вашу проблему можно легко воспроизвести и, что важно, расшарить её, то постарайтесь это сделать. Либо кратко объясните шаги, необходимые для проявления проблемы, либо рассмотрите возможность использования онлайн-инструмента для обмена кодом. Например, попробуйте [JSBin](http://www.jsbin.com/) или сниппеты Stack Overflow, чтобы создать пример, похожий на ваш.
* **Прочитайте ваш вопрос — дважды.** Прежде чем нажимать кнопку отправки, скорее всего, зелёного цвета, прочитайте вопрос. Затем прочитайте его ещё раз. Если что-то выглядит не так или неправильно, попробуйте переделать. В основном, сосредоточьтесь на определении того, понятен ли ваш вопрос, и помните, что он должен быть понятным для совершенно незнакомого вам человека.
* **Всё шаги позади, а проблема там же?** Тогда задавайте свой вопрос и надейтесь на лучшее. По мере обсуждения вашей проблемы вы быстро обнаружите, что именно вы объяснили хорошо, что недостаточно; просто следите за ответами и редактируйте по необходимости.
Провели несколько часов, постоянно обновляя экран, и всё же ничего? Если у вас есть быстро приближающийся дедлайн, то вы можете прийти к осознанию того, что находится в центре внимания следующего раздела: ваша проблема — не их проблема.
Ваша проблема — не моя проблема
-------------------------------
Я знаю, это может звучать грубо, но так оно и есть.
Слишком часто вопросы и просьбы изобилуют срочностью: дедлайн через несколько часов, проект нужно сдать в ближайшее время и т.п. Как бы я ни хотел помочь вам, но в сутках просто слишком мало часов. У меня есть свои собственные сроки и проекты. А ещё есть у меня есть жизнь за пределами разработки, которую я ценю больше всего на свете.
> *Избегайте любых выражений, связанных со срочностью в ваших вопросах, таких как «ПОМОГИТЕ!», «СРОЧНО» или любых других фраз, которые соответствуют этому регулярному выражению: `[A-ZА-Я!]+`.*
Вероятно, образовательная система научила вас, что откладывание «на потом» бывает делом ужасным. То же верно в программировании. Вот почему своевременное начало работы может дать достаточно времени для решения любых серьёзных проблем, с которыми вы столкнётесь (самостоятельно или со сторонней помощью).
Этот урок должен усвоить в какой-то момент каждый: спешка, как правило, не ускоряет решение проблемы. Задавайте внятный вопрос за адекватный объём времени и поместите его в надлежащий раздел, чтобы читатель успел ознакомиться с вопросом и ответить на него.
Будьте профессионалом (а не тупицей)
------------------------------------
Дедлайн и срочность могут вызывать серьёзный стресс. Любой, кто профессионально разрабатывал программное обеспечение, знает, что утверждение выше — большое преуменьшение.
Однако стресс — не оправдание для того, чтобы действовать, как тупица. Я видел немеряно вопрошающих, просто уничтожающих того, кто попытался помочь. Крик «это не сработало» заглавными буквами или «это глупый ответ» не принесёт вам никаких плюсов и, конечно же, не выманит никого на поле боя ради помощи незнакомцу.
> *Помните, что помогающие вам люди делают это полностью добровольно. Они тратят своё время и силы, чтобы помочь вам преодолеть трудную ситуацию. Не забывайте об этом, когда собираетесь переключиться в верхний регистр клавиатуры в ответе.*
Люди тратят своё время, чтобы ответить на ваш вопрос, получая лишь несколько сомнительных интернет-баллов, поэтому просто учитывайте это во время всего процесса.
Особенно плохо получается, когда вопрошающий находит чей-то адрес электронной почты и решает штурмовать людей напрямую вместо того, чтобы спрашивать на форумах.
(Слишком) личное общение
------------------------
Скажу для начала: я не против писем на мою почту, когда кому-то нужна помощь. Я охотно оторвусь от своих дел и напишу вам, если вы обратитесь — но вежливо.
Чаще всего мне присылают ссылки на уже опубликованные вопросы на форумах или Stack Overflow. Обычно, когда я перехожу по ссылке, решение уже есть. Если нет, то я уделю немного времени и постараюсь помочь, если смогу.
Есть другое семейство писем, на которые отвечать не так приятно и которые редко заслуживают ответа. Это потому, что они не следуют ни одному из правил, которые я сформулировал выше.
Ситуация немного иная, когда вы обращаетесь к кому-то напрямую. Некоторые подходы остаются теми же, но здесь есть свои собственные ключевые моменты:
* **Ещё раз — что вы делали?** Если я не вижу от вас никаких намёков на попытки решить свою проблему, то я тоже не вижу причин её решать (см. выше «Ваша проблема — не моя проблема»).
* **Это тот человек?** Убедитесь, что тот, с кем вы связываетесь, в состоянии вам помочь.
* **Не сердитесь.** Столкновение с проблемой может быть обескураживающим, поверьте мне, я это понимаю. Трудность возникает, когда вы решаете дать себе выход, отправив мне электронное письмо, как будто я та персона, которая создала проблему. Так очень легко не получить ответа.
* **Будьте терпеливыми.** Как и в случае с форумом, если вы пришлёте мне вопрос, то я не остановлю все свои дела, чтобы ответить на него. Когда я получу возможность взглянуть на него, я сделаю это — но, пожалуйста, не засыпайте мою почту обновлениями каждые пять минут.
Я не хочу кого-то отговаривать от обращения за помощью напрямую. Но, пожалуйста, убедитесь, что сначала вы в достаточной мере исчерпали другие ресурсы. Мне абсолютно не хочется читать очередное письмо «почему jQuery не работает».
Итоги
-----
Надеюсь, этот пост не выглядит как ворчание о ваших вопросах. Также не хочу, чтобы кому-то показалось, что речь идёт конкретно о нём. Этот пост — лишь о некоторых действиях, которые помогут не задавать плохие вопросы, что, в свою очередь, приведёт к плохим ответам или их отсутствию.
Находчивость — это одна из самых важных способностей разработчика. Если разработчик может находить ответы и решать проблемы самостоятельно, то, скорее всего, у него больше времени уйдёт на выполнение задач, а не раздумья, почему они не получаются.
Если вы сталкиваетесь с проблемой, которая снова и снова не находится в поисковике, а решение продолжает ускользать от вас, то вот тогда следует задать вопрос. Просто убедитесь, что вы его достаточно обдумали и действительно постарались, чтобы сделать ваш вопрос достойным ответа.
И лучше, чтобы вопрос не был «почему jQuery не работает». | https://habr.com/ru/post/328530/ | null | ru | null |
# Асинхронность в питоне — это хайп, не стоит отказываться от блокирующего кода
Здравствуйте, читатели хабра! В этой статье я постараюсь убедить вас в том, что блокирующий ввод-вывод и использование тредов - жизнеспособная и самодостаточная модель - как для работы с реляционными базами, так и для написания веб-сервисов вообще.
Вы, возможно, скажете - идея не нова, в период популярности Django и Rails - чего только не перепробовали для нормальной реализации реалтайма: и long-polling, и микросервисный подход а-ля django channels 1, и django channels 2 - всегда получается что-то не то. Это, конечно, так, но - всё равно, не стоит доверять коллективному разуму чересчур.
Кстати, предлагаю решение для реалтайма: отлично можно слать сообщения по вебсокету и в обычном WSGI-хэндлере. Если, конечно, предположить, что у нас есть сторонний асинхронный сервер, который принимает вместо нас ws-коннекты - выполняя роль прокси, таким образом. Будем использовать этот сервер как прокси и дальше: подключимся к нему по вебсокету с нашего WSGI-сервера - и будем слать через него ws-сообщения нашим клиентам: "прокси"-сервер получает сообщение, видит конечного получателя - и шлёт ему такое же. Внутри WSGI-хэндлера будет обычный блокирующий вызов:
```
def view(request):
...
send(client_id=11, message="All done.")
```
Подчеркну, что последний вызов блокирующий: мы ждём успешной отправки. При существующем подключении, сообщения отправляются быстро. Я не предлагаю использовать этот подход на практике: на практике можно сделать ещё проще.
Но начнём по-порядку. Современные веб-приложения, как правило - всего лишь, фронтенд к базе данных - поэтому интересно, как можно сравнить между собой блокирующий и асинхронный подходы в смысле запросов к базе. Моё мнение - подходы эквивалентны. Работа с одновременным доступом к базе строится вокруг подключений, причём их оптимальное количество невелико. В результате, вполне подходит модель 1 поток = 1 подключение.
У меня получилось сделать некоторые бенчмарки: я сравнивал asyncpg и psycopg2. Результаты - asyncpg стабильно чуть быстрее, но ненамного - от 10 до 20%. При этом, asyncpg и psycopg2 ведут себя одинаково при увеличении числа подключений - то есть, при параллельном доступе. Я тестировал на сравнительно несложных [селектах](https://gist.github.com/pwtail/5f056752fed2760bc78d3fea64b6f854) и [инсертах](https://gist.github.com/pwtail/e39fb4a6ff6afbb66f082dd053f811bd) - вы можете потестировать на чём-нибудь ещё.
У asyncpg есть свои фирменные [бенчмарки](https://github.com/MagicStack/pgbench), я их запускал - в них она ведёт себя очень хорошо - всё равно, не так хорошо, как на их графиках. Всего в 2 раза лучше, чем psycopg2 - на простых селектах. Причём, если убрать [этот](https://github.com/MagicStack/pgbench/blob/1b361556b4221659b3e032caa4d34061ca2c5b71/_python/pgbench_python.py#L50) бессмысленный параметр cursor\_factory, преимущество снижается до 1.5 раз. Чем ещё обусловлена разница между их бенчмарками и моими - не знаю. Я смотрел их код - он, вроде, адекватный.
Я не исключаю, что у asyncpg есть некоторые преимущества перед psycopg2 (вроде, используются prepared statements, где это возможно), но к асинхронности они не имеют отношения. В общем - не бойтесь использовать синхронные драйверы: они такие же быстрые.
Теперь - о веб-приложениях: я считаю, что старомодный WSGI так же хорош и годится для тех же юзкейсов, что и новомодные.
Скажу об одном обстоятельстве: после появления псевдо-стандарта ASGI, стали появляться и различные сервера с его поддержкой, в том числе, не питоновские - как, например, [nginx unit](https://github.com/nginx/unit). В связи с этим, реальность такова: асинхронный веб-сервер, с реализацией тех же вебсокетов - обычно он уже есть, его можно считать как данность. Причём, Вы не знаете, как он устроен: в том же ASGI приложении Вам не дают доступ к физическому подключению по вебсокету, потому что это особенность реализации. Учитывая это обстоятельство, давайте сравним блокирующую и асинхронную модель - Вы увидите, что у последней нет каких-то особых преимуществ.
Во-первых, отправлять сообщения по вебсокету блокирующим образом - это возможно (используя имеющийся у нас асинхронный сервер). Поток будет ждать, пока сообщение отправится. Здесь можно вспомнить пример, который я приводил вначале: принцип тот же самый, только подключаться по вебсокету к "прокси"-серверу нет необходимости, можно напрямую использовать его API. Стандарт ASGI, правда, для этого не подойдёт: он сделан для asyncio исключительно. Но небольшая его модификация позволит это сделать.
Теперь, по поводу ASGI: стандарт этот - недоразумение. И появился он при странных обстоятельствах - и сам получился странным. Нет, хорошо, конечно, что он вообще есть, но он мог быть и лучше.
Например, в нём есть понятие scope - это соответствует подключению (это для вебсокетов больше имеет смысл). Есть также асинхронные функции read и write - чтобы читать и писать, в рамках этого подключения. Само ASGI приложение - это одна асинхронная функция:
```
async def your_app(scope, receive, send):
...
```
В итоге, каждому подключению по вебсокету соответствует корутина - вроде, всё логично. На самом деле - нет. Главная деталь в том, что ASGI - это спецификация для приложения "внутри" асинхронного сервера, а не для самого этого сервера. Сам сервер уже есть, работа с вебсокетами в нём уже реализована, задача приложения - пользоваться им - а не копировать его в миниатюре или что-то ещё.
Что мне не нравится в ASGI? Первое: функции send и receive могут быть как блокирующими, так и асинхронными - нужна спецификация, основанная на колбэках, потому что колбэки - это универсальный интерфейс.
Второе: вместо функций send и receive для текущего подключения было бы гораздо полезнее иметь айдишники подключений и возможность отослать (или принять) сообщение по любому айдишнику. Ведь у сервера есть физические объекты подключений - он нам может сообщать какие-то айдишники для них - по которым сам потом сможет их идентифицировать. Но этого нет - в результате, нам нужно хранить в памяти интерпретатора все функции send - чтобы иметь возможность отправить сообщение произвольному клиенту. И это работает, пока наше приложение запущено в 1 процесс, а не несколько. Одним словом, ASGI - довольно странный протокол, на мой взгляд.
Если говорить о том, что можно добавить в WSGI - ничего, он работоспособен, как есть. Нужен только ещё API для работы с вебсокетами - аналог ASGI, но для блокирующего ввода-вывода. Формат сообщений можно оставить, как в ASGI.
И последнее, о чём обещал рассказать - своём [проекте](https://github.com/Bi-Coloured-Python-Rock-Snake/pgbackend) по добавлению в джанго асинхронного бэкенда. Он есть, он работает (делает это при помощи махинаций с гринлетами - тех самых, которые использует sqlalchemy), но я решил его не развивать.
Дело в том, что достоинства всей этой пляски с гринлетами - это совместимость с синхронным (блокирующим) кодом - которой у asyncio нет. И - как следствие - поддержка уже имеющихся библиотек (django). Ни то, ни другое не является самоцелью. Библиотек в питоне достаточно - использующая asyncio нативно, без гринлетов, подойдёт, наверно, лучше. Мне кажется - совершенно нормально, если django будет поддерживать только блокирующий ввод-вывод, а какие-то другие библиотеки - наоборот, только asyncio. Разделение труда.
В целом, я считаю - то, что всем вдруг понадобилась асинхронность, не имеет под собой объективных причин. Лично я скорее бы использовал обычные потоки. И, конечно, всё вышесказанное не относится к случаям с по-настоящему интенсивным вводом-выводом. Но, во-первых, кто станет использовать питон для этого? Тот факт, что современные библиотеки вроде io\_uring не нужны пока асинхронному питону - лишнее тому подтверждение.
Опрос делать в этот раз не буду, но очень жду комментов, велкам! | https://habr.com/ru/post/703422/ | null | ru | null |
# Монада Maybe на стероидах
Про монады на Хабре было [уже](http://habrahabr.ru/post/127556/) [столько](http://habrahabr.ru/post/209510/) [много](http://habrahabr.ru/post/231801/) [публикаций](http://habrahabr.ru/post/238171/), [что](http://habrahabr.ru/post/184722/), [мне](http://habrahabr.ru/post/212955/) [кажется](http://habrahabr.ru/company/cit/blog/262055/), [не](http://habrahabr.ru/post/247997/) [хватает](http://habrahabr.ru/post/112464/) [еще](http://habrahabr.ru/post/147363/) одной.
Я не буду расписывать, что такое монада, я просто покажу одну забавную реализацию монады Maybe (мы же в хабе «Ненормальное программирование»?).
Давайте объявим вот такой простой делегат:
```
public delegate T IMaybe();
```
Сейчас я покажу, что такого простого определения будет достаточно, чтобы создать полноценный опциональный тип (Optional type).
Монада должна иметь два метода — Return и Bind. Первый «заворачивает» немонадическое значение в монаду, второй — позволяет связывать два монадических вычисления.
Для удобства создадим статический класс и все нужные функции сделаем функциями-расширениями (extension methods) от нашего типа и все методы будем складывать в него:
```
public static class Maybe
{
}
```
Первая функция — Return — достаточно простая. Из значения мы должны сделать делегат, который его возвращает:
```
public static IMaybe Return(T x)
{
return () => x;
}
```
У Maybe также должно быть объявлено нечто, отвечающие за отсутствие значения. В нашем случае это будет делегат, который бросает исключение:
```
public static IMaybe Nothing()
{
return () => { throw new InvalidOperationException("Нельзя получить значение"); };
}
```
Второй метод у монады — Bind — должен связывать два вычисления. Его сигнатура:
```
public static IMaybe Bind(this IMaybe maybe, Func> func)
```
Давайте с ним разберемся поближе.
Первый аргумент — собственно, первое монадическое значение. Второй аргумент — функция, которая из значения внутри монады создает новое монадическое значение. Реализация метода Bind должна уметь получать значение из монады. В нашем случае, чтобы получить значение, достаточно просто вызвать наш делегат.
```
public static IMaybe Bind(this IMaybe maybe, Func> func)
{
return () => {
var value = maybe();
var newMaybe = func(value);
return newMaybe();
};
}
```
Здесь есть некоторая хитрость. Метод Bind вполне мог иметь и такую реализацию:
```
public static IMaybe Bind(this IMaybe maybe, Func> func)
{
// неправильная реализация!
return func(maybe());
}
```
Однако тут есть подвох. Если первым аргументом мы передаем Nothing, то метод Bind выбросит исключение сразу после вызова. Но мы-то хотим, чтобы Bind *связывал* два вычисления, а не *производил* их. Поэтому Bind должен отложить получение результата из первой монады и собственно вычисление над значением из монады до тех пор, пока значение не понадобится потребителю нашей Maybe.
Добавим еще несколько методов для нашего Maybe: Select, Where, SelectMany
Метод Select производит некоторую трансформацию над объектом внутри Maybe. Он может быть реализован с помощью Bind и Return:
```
public static IMaybe Select(this IMaybe maybe, Func func)
{
return maybe.Bind(value => Return(func(value)));
}
```
Where фильтрует значение внутри Maybe и возвращает Nothing, если значение не удовлетворяет предикату:
```
public static IMaybe Where(this IMaybe maybe, Func predicate)
{
return maybe.Bind(x => predicate(x) ? Return(x) : Nothing());
}
```
SelectMany — это аналог Bind, который позволит писать нам выражения, используя Linq синтаксис. От простого Bind отличается наличием финальной проекции от значений обоих монад:
```
public static IMaybe SelectMany(this IMaybe ma, Func> maybeSelector, Func resultSelector)
{
return ma.Bind(a => maybeSelector(a).Select(b => resultSelector(a, b)));
}
```
Примечательно, что методы Select, Where и SelectMany ничего не знают о внутреннем устройстве нашего Maybe — они используют только Bind, Return и пустое значение (Nothing для Maybe). Мы могли бы подставить другую реализацию Maybe — и эти методы остались бы неизменны. Более того, мы могли бы подставить другую монаду, например List:
```
public static IEnumerable Return(T x)
{
return new[] { x };
}
public static IEnumerable Nothing()
{
yield break;
}
public static IEnumerable Bind(this IEnumerable m, Func> func)
{
foreach (var arg in m)
{
foreach (var result in func(arg))
{
yield return result;
}
}
}
```
… и снова эти методы остались бы такими же. Если бы у нас были тайп-классы (type class), мы бы объявили эти методы над тайп-классом Monad (как это делается\* в Хаскелле) (\*на самом деле нет).
Последнее, что осталось — это, собственно, использование нашего Maybe:
```
var one = Maybe.Return(1);
var nothing = Maybe.Nothing();
var nothing2 =
from ax in one
from ay in nothing
select ax + ay;
var two = one.Where(z => z > 0).Select(z => z + 1);
Console.WriteLine(one());
Console.WriteLine(two());
Console.WriteLine(nothing2());
```
У нас нет другого способа получить значение из монады, кроме как вызвать делегат, что и происходит в последних трех строчках. Последняя строчка ожидаемо падает с исключением «Нельзя получить значение».
Все вместе можно увидеть [здесь](https://dotnetfiddle.net/jaWnj8). | https://habr.com/ru/post/269717/ | null | ru | null |
# Как релизить библиотеку с открытым кодом в 2020 году
Выпуск библиотеки — это непростая задача, но с нужными инструментами это проходит намного легче. На конференции [**HolyJS**](https://holyjs.ru/?utm_source=habr&utm_medium=527436) Ундже Ли (Eunjae Lee) показал, как можно автоматизировать процесс релиза, как сделать его асинхронным и коллаборативным.
Ниже — видео и перевод этого доклада.
**Далее повествование — от лица спикера.**
Я работаю на компанию Algolia. Это сервис удаленно размещенного поиска, который дает разработчикам полный набор инструментов для создания поиска в их продуктах. В Algolia есть инфраструктура, движок, база данных и много других вещей на бэкенде. Помимо этого, есть различные REST API, которые используются для индексирования и поиска записей и прочего. Кроме REST API у нас есть API-клиенты. Мы предоставляем API-клиенты для большого количества разных языков, таких как PHP, Ruby, JavaScript, Python, Kotlin, .NET, Java, Golang, Scala, iOS, Android.
В общем, мы делаем многое для API-клиентов. И, помимо API-клиента на JavaScript, мы делаем нечто под названием Instant Search (мгновенный поиск). Это что-то наподобие компонента JavaScript. Вместо вызова поисковых методов API мы предоставляем компоненты, которые вы можете подключить. Например, строки поиска, клики, фильтры, пагинаторы.
В Instant Search мы поддерживаем InstantSearch.js для Vanilla JavaScript, у нас есть React InstantSearch, Vue InstantSearch, Angular InstantSearch и другие библиотеки. Моя команда управляет большим количеством библиотек с открытым кодом, и нам необходимо их релизить.
Скорее всего, большая часть из вас любит кодить. Кто-то из вас кодит после работы в стороннем проекте. Есть люди, которые не являются разработчиками, но кодят просто потому что любят это. И, думаю, много людей любят тестировать. Вы знаете TDD — Test Driven Development (разработка на основе тестов). Некоторые люди любят дебаггинг, потому что мы постоянно сталкиваемся с багами, и иногда очень сложно выяснить причину. Когда у нас получается и мы исправляем их, то радуемся. Но люди едва ли любят релизить, особенно библиотеки. Я ни разу не слышал, как кто-то говорит: «Я люблю релизить, пойду после работы выпущу что-нибудь».
Существует много CI/CD-сервисов, таких как Netlify, Vercel, Bamboo, Jenkins. Так что автоматическая сборка приложений достаточно хорошо автоматизирована, хоть и не без шероховатостей. В общем, со сборкой приложений дела обстоят более или менее неплохо.
Проблемы при релизе библиотек
-----------------------------
Но мы не особенно любим релизить библиотеки. Существует много причин, расскажу о некоторых из них. Например, мы беспокоимся о багах, ведь есть шанс, что они будут. Как предотвратить это? Здесь я не скажу вам ничего нового: нужно написать хороший код и не дать им возникать с самого начала и хорошие тесты, чтобы найти баги еще до релиза.
Также мы постоянно боимся ошибиться. При выпуске библиотек есть шансы, что мы можем допустить ошибку.
Например, если использовать неверную версию Node.js, то это может привести к неожиданным эффектам при сборке. Или иногда я могу забыть выполнить git pull и опубликовать что-нибудь устаревшее. Да, это очень пугает. Однажды я запустил npm publish, но забыл поставить --tag beta. То есть должен был выпустить пакет как бету, а выпустил как стабильную версию. Ну и node\_modules — источник головной боли. Переключение веток иногда приводит их в некорректное состояние, заметить которое очень тяжело.
Другая причина — вы заблокированы. Например, мне нужно запустить lint, unit test или e2e test и дождаться завершения. Вот скриншот моей библиотеки из CircleCI.
Полное тестирование занимает всего лишь 4 минуты 30 секунд, не так много. Но может быть и намного дольше, если проект большой и вы пишете много тестов.
Также мы заблокированы, потому что релизим из основной ветви. Когда я запускаю тесты или сборку, мне нужно дождаться их окончания. Я не могу работать в других ветках.
Семантическое версионирование и общепринятые коммиты
----------------------------------------------------
Я рассказал, почему мы не любим выпускать библиотеки, а сейчас расскажу, на что стоит обратить внимание при выпуске библиотек.
Если вы не слышали о semver, это означает «семантическое версионирование». Обычно версии выглядят так: v1.2.3.
* 1 — мажорная версия
* 2 — минорная версия
* 3 — патч-версия
При выпуске новой версии нужно обновить правильный номер, чтобы не сломать приложения пользователей. Также многие авторы библиотек используют общепринятые коммиты ([conventional commits](https://www.conventionalcommits.org/ru/v1.0.0-beta.4/)), и вам нужно писать комментарии к коммитам особым образом. Вот пример комментария к коммитам.
`fix: should use fallback for scoped slots with...`
Еще один пример ниже.
`fix(compiler): remove the warning for valid....`
В этом случае compiler называется скоупом (область видимости).
Может быть feat.
`feat(ssr): inheritAttrs support in SSR`
Здесь ssr тоже является скоупом.
Если в комментарии к коммиту есть строка BREAKING CHANGE, это значит, что будет критическое изменение и мы должны поднять мажорную версию.
Итого:
* Если комментарий к коммиту начинается с fix, chore, docs, refactor, test и прочего, то это патч-обновление.
* Если комментарий к коммиту начинается с feat, то это минорное обновление.
* Если в комментарии к коммиту содержится breaking change, это мажорное обновление.
Общепринятые коммиты используются во многих библиотеках и приложениях с открытым кодом: Vue.js, webpack, Angular, Nuxt.js, Gatsby, jest и других.
Когда вы написали сообщения к коммитам таким способом, то можете использовать conventional-changelog — инструмент для генерации ченджлогов. Ченджлог из примера ниже, скорее всего, был сделан с помощью conventional-changelog.
Рассмотрим еще один пример с комментариями к коммитам. Давайте скажем, что chore: release v0.15.0 — это последняя версия, и мы собираемся выпускать после нее.
Когда мы генерируем ченджлоги, chore и docs не так важны. Мы не вносим эти коммиты в ченджлог, поэтому пропускаем их и просто используем эти три комментария к коммитам для генерации ченджлога. Он будет выглядеть так.
Вы видите error, эта область видимости выделена жирным шрифтом. И, так как здесь есть коммит feat, то это минорное обновление. Версия изменилась с 0.15.0 до 0.16.0.
Когда мы выпускаем библиотеки, то, скорее всего, должны поставить --tag при выпуске alpha, beta, dev, canary, rc-версий. Вы иногда выпускаете что-то не как стабильную версию, а как alpha или beta, чтобы проверить что-нибудь на ограниченной группе.
Процесс выпуска и инструменты
-----------------------------
Давайте вернемся к Instant Search. В Instant Search у нас есть файл scr/scripts/publish.js. Он занимается релизом Instant Search. Делает он следующее:
* Проверяет, что в гите нет незакомиченных изменений. Если нет, то выбрасывает ошибку и выходит
* Обновляет версию в package.json, используя общепринятый ченджлог
* Обновляет ченджлог
* Коммитит изменение
* Запускает тесты
* Выполняет задачи по сборке и подготовке проекта к релизу
* Публикует его в репозиторий npm, иногда c --tag beta
* После выпуска создается git tag
* Пушит новый коммит и tag обратно в git-репозиторий
У нас был этот файл в репозитории Instant Search, значит, у нас есть такой же файл в React Instant Search, Vue Instant Search, Angular Instant Search. Проблема в том, что они немного разные. Мы вносили модификации в каждый из них вручную, и поддерживать это было сложно. И даже с этим скриптом я все еще делал ошибки. Например, в версии Node.js, папке node\_modules, версиях Yarn.
np
--
Я начал искать другие варианты, чтобы еще немного автоматизировать процесс. Например, существует np от Sindre Sorhus. Описание гласит, что это «улучшенный npm publish», и это действительно так. Он проверяет незакоммиченные изменения, устанавливает зависимости, запускает тесты, ставит новую версию, публикует пакет и пушит теги.
Но когда я запускаю его, он спрашивает у меня новую версию. И я опять вынужден ждать, так что это тоже не выход. То есть np — это действительно лучше, чем просто npm publish, но его функционала недостаточно, чтобы покрыть наш скрипт.
semantic-release
----------------
Другой вариант — это semantic-release. Это полностью автоматизированный менеджер версий и издатель пакетов. В его документации показаны этапы:
* проверка условий
* получение последнего релиза
* анализ коммитов
* тестирование релиза
* генерация ченджлога
* создание git tag
* подготовка к релизу
* публикация
* оповещения
Да, он действительно автоматизирует много всего. Но если вы взглянете в описание, там сказано: «полностью автоматизированный». Это значит, что у меня нет возможности вмешаться в процесс релиза. Например, я написал неправильный комментарий к коммиту, и набрал fix вместо feat. Тогда версия будет неправильной, и у меня не будет шанса это исправить, потому что процесс полностью автоматизирован.
Три части процесса выпуска
--------------------------
Нужен был баланс между чем-то полностью ручным и чем-то полностью автоматизированным. И я придумал совершенно иной процесс, он состоит из трех частей.
* подготовка
* проверка
* запуск
Часть первая — подготовка. В этой части мы вычисляем следующую версию.
* Мы можем выяснить, какая версия следующая, потому что использовали общепринятые коммиты.
* Потом можем переключиться на промежуточную ветку, например, git checkout -b releases/v1.2.3.
* В ней мы можем обновить версию в package.json и других файлах.
* Можем обновить ченджлог
* Коммитим изменение
* Можем создать pull-запрос из этой ветки к основной.
Часть 2 — проверка. Мы можем изучить pull-запрос и результаты тестов.
Я использую CircleCI, вы можете запускать тесты на GitHub. Можно сделать дополнительные тесты, например, используя CodeSandbox CI или Pika CI.
Что такое CodeSandbox CI? Это сервис который можно интегрировать в вашу сборку, он умеет создавать отдельную песочницу на CodeSandbox, в который установлена свежесобранная версия библиотеки из текущего PR.
Ее можно использовать, чтобы вручную проверить новый или старый функционал, или отправить клиенту, чтобы посмотреть, работает ли она для их кейсов.
Помимо этого можно добавить больше коммитов к этому pull-запросу: например, вручную поменять ченджлог. Общепринятый ченджлог обновляется вместе с комментариями к коммитам, но иногда хочется поменять комментарии, добавить что-нибудь или изменить тип. Можно добавить больше коммитов, если хотите.
Затем можно сделать squash and merge. На GitHub есть кнопка Squash and merge. Добавится новый коммит, например, chore: release v1.2.3.
Часть 3 — релиз. CI прошел, тесты прошли, можно запускать скрипт релиза. Скрипт может быть наподобие npm run build, npm publish или npm publish --tag beta или alpha. После этого можно создать git tag и сделать пуш тега назад в ремоут.
Итого:
Первая часть: происходит на вашем компьютере.
* Обновили версию
* Обновили ченджлог
* Выполнили коммит изменений
Вторая часть: происходит на GitHub.
* Npm run test
Третья часть: происходит на CI/CD.
* Npm run build
* Npm publish
* создали git tag и выполнили его пуш в ремоут.
В трех частях только первая происходит на моей машине, вторая — на GitHub, третья — на CI/CD. Я делаю меньше ошибок, так как я запускаю только первую часть, вторая и третья части — не моя или не ваша ответственность.
ship.js
-------
А теперь я хочу представить наш собственный инструмент: ship.js. С помощью него можно автоматизировать части 1 и 3.
* **Часть 1**. Вы просто запускаете команду shipjs prepare. Будут выполнены все задачи из первой части, также будет создан pull-запрос. Это делаете вы, но сама команда автоматизирована.
* **Часть 2**. Можете просмотреть pull-запрос на GitHub самостоятельно или с вашими коллегами.
* **Часть 3**. Когда коммит добавлен, CI/CD запустит команду shipjs trigger и сделает все остальное.
Выпуск ship.js с использованием ship.js
---------------------------------------
Я выпускаю ship.js, используя ship.js (да, это забавно). Вот как я это делаю. Недавно была версия 0.20.0-beta.3, которую я хочу выпустить как стабильную версию 0.20.0.
Здесь есть скрипт release, вызывающий shipjs prepare.
Я запущу yarn run release. Он вызывается из ремоута, принимает теги, пушит назад в ремоут и показывает текущую версию — 0.20.0-beta.3 и следующую версию — 0.20.0-beta.4.
Когда выпускаете бета-версии или альфа-версии, обычно увеличивается только последнее число, поэтому он предположил, что следующая версия будет beta.4. Но я хочу выпустить стабильную версию, поэтому просто введу No. Потом ввожу следующую версию.
Cоздается промежуточная ветка, обновляется ченджлог, происходит коммит, пуш и создание pull-запроса. Теперь мы видим pull-запрос. Он открывается автоматически, здесь у нас есть некоторая информация о нем и запущены тесты.
Для краткости я проигнорирую это и просто сделаю мердж. Но не делайте это в своем продакшене.
Это добавит новый коммит в основную ветку, которая называется main. В данном случае: chore: release v0.20.0. И запускается shipjs\_trigger.
Вернемся к коду и проверим конфигурацию CircleCI. Видим resease\_if\_needed, который вызывает shipjs\_trigger только на главной ветке.
Он делает очень простые вещи: чекаут и некоторую работу с yarn и yarn shipjs trigger.
Также он запускает ship.js для релиза. Он устанавливает зависимости, и теперь вызван shipjs\_trigger, который создает и публикует в репозиторий npm, создает git tag и отправляет тег в ремоут. Всё прошло успешно.
Откроем страницу пакета на npmjs.com и видим, что выпущена новая версия.
На вкладке релизов видим, что новые релизы на месте.
Интеграция ship.js в вашу библиотеку и ее релиз
-----------------------------------------------
Теперь покажу, как интегрировать ship.js в вашу библиотеку. Я создал библиотеку-болванку, которая называется eunjae-math-library. Сейчас ее версия — 0.1.0. Я только что создал эту библиотеку, но еще не выпустил ее на репозиторий npm. Файл версии гласит version: 0.1.0, но этой библиотеки на npm пока нет. И я хочу выпустить ее как 0.1.0.
В библиотеке есть простая функция.
Ее версия 0.1.0. Мы сохраним ее и выпустим как 0.1.0. Откроем документацию ship.js, секцию Getting Started. У нас есть команда npx shipjs setup, она помогает добавить ship.js в ваш проект. Она спросит вас о вашей основной ветке и конфигурации CI.
Выбираю CircleCI. Можете выбрать GitHub Actions или просто «Ничего».
Появится вопрос: «Запланировать выпуск через CircleCI?» Отвечаю «Нет».
Когда процесс закончится, ship.js установится как devDependency. Видим, что ship.js добавился.
Появляется новый скрипт release, который вызывает shipjs prepare.
Нам не нужно самому писать всю конфигурацию CI, джобы для сборки были созданы за нас. В ней один воркфлоу, он вызывает джоб shipjs\_trigger, причем только на основной ветке. Он выполняет чекаут, установку yarn, управление его кэшем и запуск yarn shipjs trigger.
Коммитим это изменение и пушим. Идем в CircleCI и настраиваем проект.
Добавляем конфигурацию вручную и нажимаем Start Building.
Исполняется джоб shipjs\_trigger. Он устанавливает некоторые зависимости. В редакторе вы увидите, что необходимо указать GitHub-токен как переменную среды. Дело в том, что я забыл сделать последний шаг. Откроем терминал, здесь сказано: «Необходимо закончить настройку на CircleCI».
И ниже есть ссылка на документацию. Здесь показано, как настроить CircleCI, что уже сделано командой установки ship.js. Нам нужно настроить два токена: npm-токен и GitHub-токен. Давайте начнем с npm-токена.
Заходим на сайт npm, идем в Auth Tokens, создаем токен для чтения и публикации.
Кстати, я аннулировал токен, так что не пытайтесь прочитать и использовать его. Возвращаемся в CircleCI, идем в Project Settings, Environment Variables. Вводим имя NPM\_AUTH\_TOKEN, вставляем значение.
Также необходимо добавить токен GitHub. Заходим на GitHub. Можем назвать release eunjae-math-library. Выбираем скоуп repo и генерируем токен.
Этого токена тоже уже нет.
В CircleCI добавляем GITHUB\_TOKEN и вставляем его.
Теперь мы закончили с CircleCI. Можем добавить токен GitHub на нашу машину, чтобы поработать с ship.js. Добавляем GITHUB\_TOKEN= и вставляем его. Нам нужно, чтобы этот файл был внутри gitignore, потому что мы не хотим коммитить этот токен в репозиторий. Мы обновляем этот файл gitignore.
Теперь yarn run release. Выпустим эту библиотеку первый раз.
Здесь сказано, что git tag 0.1.0 не существует.
Я только создал этот репозиторий, и эта версия была автоматически написана изначальной командой. Я еще не выпустил ее, у меня нет тега.
В вопросе «Из какого коммита вы хотите выпустить?» (From which commit do you want to release?) это мой первый релиз, поэтому я выберу последний вариант. Я выпущу ее как версию 0.1.0, то есть как текущую версию, так что выбираю initial commit.
«Эта следующая версия корректна?»
Нет, здесь сказано, что следующая версия будет 0.1.1. Но в данном случае мы выпускаем ее, как ту же версию, поэтому отвечаем «Нет» и указываем 0.1.0 вручную.
Есть ряд вещей, которые необходимо сделать, когда используете ship.js в первый раз, чтобы все настроить. Но после этого первого релиза во второй раз все будет намного проще.
Обновляется ченджлог, пушит в промежуточную ветку, создается pull-запрос.
Здесь мы видим некоторую основную информацию в описании этого pull-запроса.
При слиянии pull-запроса необходимо выбрать Squash and merge, и убедиться, что тайтл начинается c chore: release v0.1.0. Если нажмете See details, то увидите больше подробностей. Изначально здесь Create a merge commit.
Но нам это делать не нужно. Вместо того чтобы выбирать Squash and merge каждый раз, я могу настроить это для всего репозитория. Откроем настройки, прокрутим вниз и деактивируем два других варианта, чтобы в репозитории была активна была только кнопка Squash and merge.
Видим, что кнопка изменена и нельзя выбрать другие варианты.
Конечно, вы вольны выбирать, но я предпочитаю использовать Squash and merge для библиотек, это позволяет иметь чистую историю коммитов и удобные сообщения и ченджлоги.
Сейчас в ченджлоге немного всего, потому что мы еще ничего не сделали.
Обновим ченджлог. Добавим Initial Release и docs: update CHANGELOG.md.
Отправим, обновим — видим следующее изменение.
Необходимо сделать коммит — chore: release v0.1.0.
Видим в CircleCI, что новый коммит добавлен к основной ветке и выполняется shipjs\_trigger. В нем запускается ship.js для релиза. Он публикует в репозиторий npm, создает git tag и отправляет тег в ремоут. Обновим GitHub и видим этот новый тег.
Если наберем в поиске eunjae-math-library на npm, то увидим, что новая версия была выпущена минуту назад, так что все работает хорошо.
Добавим новую функцию — вычитание. Это очень простая функция, которая производит вычитание двух чисел. Оставим к коммиту комментарий feat: add subtract function.
Я могу просто запустить yarn run release. Мы добавили новую фичу, это минорное обновление, так что следующая версия верна.
Обновление отсылается в ремоут и создает pull-запрос. В нем также видим, что версия изменилась верно. Еще в PR написана команда, которая будет вызвана для публикации в npm.
Теперь у нас есть ченджлог, потому что мы использовали общепринятые коммиты.
Версия обновлена. Перейдем по ссылке ниже.
Можно сравнить изменения с предыдущей версией.
Слияние этого pull-запроса запустит очередной релиз. Снова выполняется shipjs\_trigger, устанавливаются зависимости, создается сборка, публикуется на npm, выполняется git tag. Обновим снова и увидим новый тег на GitHub и новую версию на npm.
Наконец, сделаем последнее изменение в этой библиотеке — chore: add log.
Создадим файл конфигурации ship.js (ship.config.js). В документации есть ряд типовых конфигураций. В данном случае я собираюсь сделать немного дополнительной работы в обновлении версии. Я скопирую и вставлю это из документации, оставлю только важные части.
Когда версия обновляется, создается или обновляется файл src/version.ts. Файл экспортирует версию как строку.
Вводим chore: update version file on release и выпускаем эту версию. Следующая версия 0.2.1 верна, а в новом pull-запросе изменена версия. Можно посмотреть изменения и увидеть, что создан новый файл.
Все работает верно. Теперь можно просто мерджить pull-запрос, и новая версия будет выпущена.
Также существует команда shipjs setup. Она помогает установить ship.js в библиотеку и дает выбор, использовать ли GitHub Actions. Я сфокусировался на CircleCI, потому что использую именно его. Но можно использовать GitHub Actions.
Также у нас есть референс для всех конфигураций. А если вы используете комментарии к коммитам, основанные на эмоджи, вместо общепринятых коммитов, я могу добавить новую конфигурацию к ship.js, чтобы вы могли использовать любую конвенцию, какую хотите. Так что это настраиваемый инструмент.
Заключение
----------
Ship.js — не о инструменте, а о процессе. Вы можете внести вклад в ship.js. Или же «украдите» эту идею и сделайте подобное для других языков, ведь это всего лишь инструмент для улучшения процесса. Если сделаете — дайте мне знать.
Надеюсь, вы наслаждаетесь своим релизом даже по четвергам и пятницам.
Вы можете связаться со мной в твиттере: [@eunjae\_lee](https://twitter.com/eunjae_lee). Также у нас есть аккаунт для [@ship\_js](https://twitter.com/ship_js), так что можете подписаться на ship.js.
> Это доклад с июньской конференции, а теперь уже на носу [следующая HolyJS](https://holyjs-moscow.ru/?utm_source=habr&utm_medium=527436): там будут Дэн Абрамов, бывший председатель TC39 Дэниэл Эренберг, основатель Smashing Magazine Виталий Фридман и другие интереснейшие спикеры. О том, какие доклады там будут, мы уже подробно [писали](https://habr.com/ru/company/jugru/blog/526548/) на Хабре, а вся остальная информация и билеты есть [на сайте](https://holyjs-moscow.ru/?utm_source=habr&utm_medium=527436). | https://habr.com/ru/post/527436/ | null | ru | null |
# Подробная инструкция по установке SSL-сертификата Let’s Encrypt на сервер с CMS Bitrix и Nginx
Да, на Хабре уже много текстов про сертификаты Let’s Encrypt, но полной пошаговой инструкции я, к сожалению, не нашёл. Хотел восполнить пробел. К тому же, с мая 2016 года в процессе установки произошли незначительные изменения, которые могут сбить с толку новичка. Поэтому я решил написать эту инструкцию. Так сказать себе на память и другим в помощь.
Эта инструкция, в первую очередь, должна быть интересна новичкам.
Если у вас все настройки установлены по умолчанию, можно смотреть те пути, которые я привёл. То есть, если вы используете систему, установленную с помощью скрипта Bitrix environment на операционной системе CentOS 6.X. Если же нет, вы и сами знаете где что лежит.
### Установка
Первое, что необходимо сделать — установить **git**:
```
# yum install git
```
Далее переходим в директорию **/tmp**:
```
# cd /tmp
```
С помощью git скачиваем файлы Let’s Encrypt. Сам скрипт теперь называется **certbot**:
```
# git clone https://github.com/certbot/certbot
```
Переходим в скачанную директорию:
```
# cd certbot
```
На всякий случай, даем права на выполнение для файла скрипта:
```
# chmod a+x ./certbot-auto
```
### Получение сертификата
Далее следует команда непосредственно получения сертификата:
```
# ./certbot-auto certonly --webroot --agree-tos --email [email protected] -w /home/bitrix/www/ -d my-domain.ru -d www.my-domain.ru
```
**--webroot** — так как автоматическая установка для nginx пока не надежна, используем этот ключ;
**--agree-tos** — соглашаемся с лицензионным соглашением;
**--email [email protected]** — указываем свой e-mail. В дальнейшем он может пригодиться для восстановления своего аккаунта;
**-w /home/bitrix/www** — указываем корневую директорию сайта;
**-d my-domain.ru** — наш домен. так же можно указывать и поддомены, например **-d site.my-domain.ru**.
После этого скрипт начнет работу и предложит установить недостающие пакеты. Соглашаемся и ждём.
Если всё завершится успешно, вы увидите сообщение:
`IMPORTANT NOTES:
- Congratulations! Your certificate and chain have been saved at
/etc/letsencrypt/live/my-domain.ru/fullchain.pem. Your
cert will expire on 2016-08-21. To obtain a new version of the
certificate in the future, simply run Certbot again.
- If you lose your account credentials, you can recover through
e-mails sent to [email protected].
- Your account credentials have been saved in your Certbot
configuration directory at /etc/letsencrypt. You should make a
secure backup of this folder now. This configuration directory will
also contain certificates and private keys obtained by Certbot so
making regular backups of this folder is ideal.
- If you like Certbot, please consider supporting our work by:
Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate
Donating to EFF: https://eff.org/donate-le`
Сертификаты установлены, осталось только указать nginx'у, где они лежат.
### Настройка
Открываем конфигурационный файл **ssl.conf**:
```
# vim /etc/nginx/bx/conf/ssl.conf
```
Если у вас уже были установлены сертификаты, удаляем или комментируем строки с ними и вставляем новые:
`ssl_certificate /etc/letsencrypt/live/my-domain.ru/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/my-domain.ru/privkey.pem;`
Не забываем включить ssl, если этого не было сделано ранее:
`ssl on;
keepalive_timeout 70;
keepalive_requests 150;
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 10m;`
После этого перезапускаем nginx:
```
# service nginx reload
```
Если он не выдал никаких ошибок, значит всё в порядке. Можно зайти на сайт и посмотреть что получилось.
### Обновление
Сертификат выдается на **90 дней**, так что после этого срока нужно будет его обновить. Делается это командой:
```
# certbot-auto renew
```
Её так же можно поставить в **cron**.
На этом всё. Для составления инструкции я использовал статью [Yet another инструкция по получению ssl-сертификата Let's Encrypt](https://habrahabr.ru/post/279695/) и [официальный гайд](https://certbot.eff.org/docs/using.html). | https://habr.com/ru/post/301558/ | null | ru | null |
# Plugoo — удобная обратная связь на вашем сайте.
Нашел новый сервис, который позволяет встраивать на ваш сайт форму обратной связь. При создании формы вы можете польностью настроить ее внешний вид: цвет, размер и прочее. Но, что самое интересное — вы можете выбрать способ общения с посетителем вашего сайта: ICQ, Gtalk, Yahoo, Jabber, MSN, AIM.
После того, как посетитель оставил вам сообщение — создается сессия вашего разговора и вы можете свободно пообщаться, при этом ваши контактные данные остаются неизвестны собеседнику.
~~Есть один минус — в сообщениях не поддерживается кириллица. Разработчикам я уже пожаловался :)~~
Решение найдено. Саппорт ответил:
> Please try to remove `/>` from your HTML Plugoo code and let us know should you be able to use cirillic characters.
Сайт: [www.plugoo.com](http://www.plugoo.com/)
Посмотреть, как выглядит: [orestov.com/vegas/contact](http://orestov.com/vegas/contact) | https://habr.com/ru/post/16454/ | null | ru | null |
# Как я мониторил Avito по SMS
Как известно, на «Авито» периодически появляются товары очень хорошего качества и при этом очень дешевые. Но появляются они редко, висят там мало и исчезают быстро.
Поэтому возникла у меня идея: а не поискать ли сервис, который раз в несколько минут проверяет объявления, и если появилось что-то интересное для меня — оповещает об этом? При этом оповещать лучше всего по смс, а то почту я не всегда проверяю оперативно.
Гуглинг выдал несколько таких сервисов, «всего» от 3 руб за смс или от 4 руб в сутки.
В итоге, я решил написать такой сервис самостоятельно, но об этом дальше…
Для интереса я зарегистрировался на одном из сервисов. Вчера он проверял ссылки каждые 15 минут, и если что изменилось, слал уведомления на почту. Про смс же у них на сайте было вскользь упомянуто, что почта mail.ru умеет отправлять смски. По факту оказалось, что mail.ru умеет отправлять только на мегафон, а у меня совсем даже не он… А если надо билайн-мтс, то пожалуйста, сервис с удовольствием поможет, за отдельную денежку.
Замечу также, что я давно являюсь пользователем очень удобного и бесплатного сервиса, [о котором давным-давно писали тут же на хабре](http://habrahabr.ru/post/147583/), и который позволяет отправить письмо с определенной темой на определенный ящик, и содержание письма придет мне в виде смс. Хотел указать свой\_ящик@sms.ru для писем сервиса, но не понял как поменять тему письма, без чего смс не получишь.
Кроме того, сегодня демо-период глисы закончился, и периодичность проверки стала 720 минут.
В общем, подумав что платить за, прошу прощения, «сервис» такого уровня это все равно что платить за ~~винду~~ воздух, я решил что проще всего потратить часа 3 своего ценного времени и соорудить подобный сервис самому, благо парсинг страницы «Авито» тривиальный и, как следует ниже, занял у меня ровно 1 строчку кода.
Я для этого скрипта использовал VPS-хостинг. Подойдет также WEB-хостинг, при условии наличия на нем перла, доступа «наружу» и планировщика. В крайнем случае, подойдет любой включенный в инет комп. Думаю, у многих есть что-то подобное.
### На чем написан скрипт
Писать его я решил на перле, и хотя знаю я перл довольно посредственно, для скриптов такого плана он подходит лучше всего. Там, где разбираться с перлом было лень, я не особо напрягаясь, вызывал команды шелла через system. Тем не менее, получилось, на мой взгляд, довольно прилично и даже не постесняюсь показать свое творение общественности.
### Логика работы, кратко
— Запускаем скрипт каждые xxx минут;
— Скачиваем страничку с помощью wget;
— Храним скачанную в прошлый раз страничку, сравнивая ее с вновь скачанной, если какие-то объявления изменились/появились новые — отправляем смс об этом.
Вытаскиваемая из объявлений инфа — это:
1. URL объявления (который я использую как уникальный идентификатор объявления);
2. Название;
3. Цена.
При этом предусмотрено: если вдруг произойдет сбой при одном из скачиваний страницы, то старый список останется, а страница просто скачается в следующий раз, тогда же и придет смс об изменениях, если они произошли.
### Детальнее
Перед использованием проверить пути и имена для mailer и wget, убедиться что они у вас есть и работают. В частности, у меня в centos мейлер называется mutt, чаще встречается mail или sendmail с тем же синтаксисом. Может быть, вам надо заменить wget на /usr/local/bin/wget и т.п.
Также следует задать свой ящик и телефон, на который хотите получать уведомления.
Запускать скрипт командой: ./avito.pl урл\_страницы\_с\_объявлениями.
Замечу, что URL страницы должен быть в виде «списком с фото». Иначе говоря, в урле не должно быть никаких &view=list или &view=gallery.
Пример урла: [www.avito.ru/moskva?q=%D1%80%D0%B5%D0%B7%D0%B8%D0%BD%D0%BE%D0%B2%D1%8B%D0%B9+%D1%81%D0%BB%D0%BE%D0%BD](https://www.avito.ru/moskva?q=%D1%80%D0%B5%D0%B7%D0%B8%D0%BD%D0%BE%D0%B2%D1%8B%D0%B9+%D1%81%D0%BB%D0%BE%D0%BD)
Страница скачивается в файл с именем полученным из урла, с заменой всех левых символов на подчеркивания, наподобие такого:
https\_\_\_www.avito.ru\_moskva\_q\_\_D1\_80\_D0\_B5\_D0\_B7\_D0\_B8\_D0\_BD\_D0\_BE\_D0\_B2\_D1\_8B\_D0\_B9\_\_D1\_81\_D0\_BB\_D0\_BE\_D0\_BD
Оно должно быть уникальным, поддерживаться и в линуксе, и в винде и при этом быть достаточно читаемым.
Если такой файл уже есть, скрипт пытается вытащить из него объявления. Если объявлений в файле не найдено, скрипт вызывает wget, при этом перезаписывая файл. Если объявления найдены, файл сохраняется с суффиксом -1:
https\_\_\_www.avito.ru\_moskva\_q\_\_D1\_80\_D0\_B5\_D0\_B7\_D0\_B8\_D0\_BD\_D0\_BE\_D0\_B2\_D1\_8B\_D0\_B9\_\_D1\_81\_D0\_BB\_D0\_BE\_D0\_BD-1
Далее страница скачивается заново, в ней проверяются следующие ситуации:
1. Если объявления в новой скачанной странице не найдены, скрипт просто завершается — старая страница остается с суффиксом -1. Это на тот случай, если вдруг сеть пропала или подвисла — прошлый список объявлений не потеряется.
2. Если скрипт запущен в первый раз (не найдена ранее скачанная страница), то инфа придет просто о количестве имеющихся объявлений:
> Found 25 items, page [www.avito.ru/moskva?q=%D1%80%D0%B5%D0%B7%D0%B8%D0%BD%D0%BE%D0%B2%D1%8B%D0%B9+%D1%81%D0%BB%D0%BE%D0%BD](https://www.avito.ru/moskva?q=%D1%80%D0%B5%D0%B7%D0%B8%D0%BD%D0%BE%D0%B2%D1%8B%D0%B9+%D1%81%D0%BB%D0%BE%D0%BD) monitoring started
Если это сообщение пришло, значит система запустилась, это главным образом проверка того, что все заработало.
Поскольку смс должно быть чем короче, тем лучше, то все сообщения очень лаконичны.
3. Если появилось новое объявление, то инфа об этом добавится в текст будущей смс. Потом по всем объявлениям инфа придет в виде одной смс.
4. Если изменилась цена или наименование товара, то инфа придет в виде: старая\_цена -> новая\_цена наименование ссылка. Или новое\_название ссылка.
Не знаю, может ли измениться название, но лишнюю проверку сделать было не жалко.
5. В консоль выводится отдельным текстом список того, что нашлось. Это сделано больше для отладки, потому как сегодня парсер работает, а завтра, когда они поменяют разметку, перестанет. Придется менять парсинг.
### О парсинге и нюансах
Собственно, весь парсинг — в этой строчке:
```
while($text=~/ ### [\n(.\*?)\n.\*?\n\s\*(\S\*)/gs)](\"(.*?)\".*?)
```
Хотя, еще цена содержит пробел в виде nbsp, который я вырезаю другим regexp-ом:
```
$price=~s/ //g
```
Так что парсинг, формально говоря, все же не в одной, а в двух строчках.
g — модификатор глобального поиска, который позволяет засунуть поиск внутрь условия while, выдавая каждый раз следующее объявление;
s — позволяет внутри одного регекспа проводить поиск в нескольких строчках (на «Авито» URL, наименование и цена располагаются на 4 строках, но это сейчас, пока они верстку не поменяли).
Также замечу, что для многострочного чтения файла в начале скрипта присваивается:
```
undef $/;
```
Это чтобы my $text=; прочитал в себя весь файл целиком.
Еще нюанс: я во все смски вставляю кликабельные урлы. У меня нормальный смартфон, который позволяет ткнуть в урл внутри смс и попасть на нужную страницу, очень удобно. Так вот, почему-то sms.ru портит такой невинный символ, как подчеркивание. Заменяя его на %C2%A7. Повлиять я на это не могу, зато могу заменить его на код подчеркивания, который доходит нормально, при этом урл становится кликабельным для sms.ru, оставаясь таким и для обычной почты: $text=~s/\_/%5F/g;
### Добавляем задание в планировщик
```
#crontab -e
*/20 * * * * cd /scripts/avito && ./avito.pl 'https://www.avito.ru/moskva?q=%D1%80%D0%B5%D0%B7%D0%B8%D0%BD%D0%BE%D0%B2%D1%8B%D0%B9+%D1%81%D0%BB%D0%BE%D0%BD'
```
Каждые 20 минут вызывать скрипт, проверяя страницу. Не забыть экранировать URL одинарными кавычками.
Таких заданий можно задать сколько угодно, они все будут работать независимо друг от друга.
### Что я еще не сделал для промышленного варианта и что было бы легко доделать
1. Веб-морду для добавления/удаления юзеров и заданий. Хранение урлов, периодичности, ящика и телефона юзеров на sms.ru в базе mysql. Скрипт бы вызывался каждую минуту, проверял, по какому урлу выполняться и слал бы смс не на мой жестко забитый номер, а на тот, который задан пользователем.
Тогда можно было бы сдирать с юзеров по 8 рублей в день или что-то типа того. Может, заняться? Есть желающие за такую штуку денег заплатить?
2. Фильтр цен. Игнорировать цену выше или ниже заданной. Делается элементарно, еще одним `if: next if($page_new{"price"}{$uri}>$max_price or $page_new{"price"}{$uri}<$min_price)`. Просто не нужно было.
3. По аналогии с «Авито», добавить авто.ру, irr и т.п. сайты.
Тоже элементарно, просто за тем `while(...){...}` дописать еще несколько `while` — каждому сайту по одному. Главное, чтобы внутри них заполнялись `$page{"name"}{$uri} и $page{"price"}{$uri}`.
По каждому сайту будет срабатывать свой `while`, остальные просто возвращать пустой результат.
### Ну и собственно код скрипта
```
#!/usr/bin/perl
use strict;
undef $/;
my $url=$ARGV[0];
my $mailer="mutt";
my $wget="wget";
if($url eq ""){
print "Usage: avito.pl ";
exit;
}
my $filename=$url;
$filename=~s#[^A-Za-z0-9\.]#\_#g;
$url=~m#(^.\*?://.\*?)/#;
my $site=$1;
print "site:".$site."\n";
sub sendsms {
my $text=shift;
$text=~s/\_/%5F/g;
$text=~s/&/%26/g;
system("echo '$text' | $mailer -s 79xxxxxxxxx xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\@sms.ru");
}
sub parse\_page {
open(MYFILE,"<".shift);
my $text=;
close(MYFILE);
my %page;
while($text=~/ ### [\n(.\*?)\n.\*?\n\s\*(\S\*)/gs)
{
my $uri=$1;
my $name=$2;
my $price=$3;
$uri=~s/^\s+|\s+$//g;
$name=~s/^\s+|\s+$//g;
$price=~s/^\s+|\s+$//g;
$price=~s/ //g;
$page{"name"}{$uri}=$name;
$page{"price"}{$uri}=$price;
}
return %page;
}
my %page\_old=parse\_page($filename);
if(scalar keys %{$page\_old{"name"}}>0){
system("cp $filename ${filename}-1");
}
else{
%page\_old=parse\_page("${filename}-1");
}
system("$wget '$url' -O $filename");
my %page\_new=parse\_page($filename);
if(scalar keys %{$page\_old{"name"}}>0){ # already have previous successful search
if(scalar keys %{$page\_new{"name"}}>0){ # both searches have been successful
my $smstext="";
foreach my $uri(keys %{$page\_new{"name"}})
{
if(!defined($page\_old{"price"}{$uri})){
$smstext.="New: ".$page\_new{"price"}{$uri}." ".$page\_new{"name"}{$uri}." $site$uri\n ";
}
elsif($page\_new{"price"}{$uri} ne $page\_old{"price"}{$uri}){
$smstext.="Price ".$page\_old{"price"}{$uri}." -> ".$page\_new{"price"}{$uri}." ".$page\_new{"name"}{$uri}." $site$uri\n";
}
if(!defined($page\_old{"name"}{$uri})){
# already done for price
}
elsif($page\_new{"name"}{$uri} ne $page\_old{"name"}{$uri}){
$smstext.="Name changed from ".$page\_old{"name"}{$uri}." to ".$page\_new{"name"}{$uri}." for $site$uri\n";
}
}
if($smstext ne ""){
sendsms($smstext);
}
}
else{ # previous search is successful, but current one is failed
# do nothing, probably a temporary problem
}
}
else{ # is new search
if(scalar keys %{$page\_new{"name"}}<=0){ # both this and previous have been failed
sendsms("Error, nothing found for page '$url'");
}
else{ # successful search and items found
sendsms("Found ".(scalar keys %{$page\_new{"name"}})." items, page '$url' monitoring started");
}
}
foreach my $uri(keys %{$page\_new{"name"}})
{
print "uri: $uri, name: ".$page\_new{"name"}{$uri}.", price: ".$page\_new{"price"}{$uri}."\n";
if($page\_new{"price"}{$uri} eq $page\_old{"price"}{$uri}){print "old price the same\n";}
else{print "old price = ".$page\_old{"price"}{$uri}."\n";}
if($page\_new{"name"}{$uri} eq $page\_old{"name"}{$uri}){print "old name the same\n";}
else{print "old name = ".$page\_old{"name"}{$uri}."\n";}
}](\"(.*?)\".*?)
``` | https://habr.com/ru/post/268857/ | null | ru | null |
# Неконтролируемые компоненты в React
Продолжение серии переводов раздела "Продвинутые руководства" (Advanced Guides) официальной документации библиотеки React.js.
Неконтролируемые компоненты в React
-----------------------------------
В большинстве случаев, мы рекомендуем использовать [контролируемые компоненты](https://facebook.github.io/react/docs/forms.html) для реализации форм. В контролируемом компоненте, данные формы обрабатываются компонентом React. Есть альтернативный вариант — это неконтролируемые компоненты, в которых данные формы обрабатываются самим DOM.
При написании неконтролируемого компонента, вместо того, чтобы писать обработчик событий для каждого обновления состояния, вы можете [использовать ref](https://habrahabr.ru/post/319510/) для получения значений формы из DOM.
Например, следующий код принимает значение Имени из формы в неконтролируемом компоненте:
```
class NameForm extends React.Component {
constructor(props) {
super(props);
this.handleSubmit = this.handleSubmit.bind(this);
}
handleSubmit(event) {
alert('A name was submitted: ' + this.input.value);
event.preventDefault();
}
render() {
return (
Name:
this.input = input} />
);
}
}
```
Поскольку в неконтролируемом компоненте хранение актуальных данных происходит в DOM — использование таких компонентов иногда позволяет проще интегрировать (соединять) React и не-React код. Если вас интересует меньший объем кода (и следственно скорость его написания) в ущерб чистоты кода — это вариант. В противном случае, лучше использовать контролируемые компоненты.
### Значения по умолчанию
В жизненном цикле отображения (рендеринга) React, атрибут `value` в элементах формы будет переопределять значение в DOM. В неконтролируемых компонентах, у вас часто будет возникать необходимость в задании начальных значений, при этом оставляя последующие обновления неконтролируемыми. В этом случае, вы можете задать атрибут `defaultValue` вместо `value`.
```
render() {
return (
Name:
this.input = input} />
);
}
```
Кроме того, и поддерживают атрибут `defaultChecked`, а поддерживает `defaultValue`.
Следующая часть:
* [Оптимизация производительности в React.](https://habrahabr.ru/post/319536/)
Предыдущие части:
* [Ref-атрибуты и DOM в React.](https://habrahabr.ru/post/319510/)
* [PropTypes — проверка типов в React.](https://habrahabr.ru/post/319358/)
* [JSX — подробности.](https://habrahabr.ru/post/319270/)
Первоисточник: [React — Advanced Guides — Uncontrolled Components](https://facebook.github.io/react/docs/uncontrolled-components.html) | https://habr.com/ru/post/319520/ | null | ru | null |
# Обсуждение: стандартные UNIX-утилиты, которые мало кто использовал и использует сейчас
Неделю назад Дуглас Макилрой (Douglas McIlroy), разработчик конвейера UNIX и автор понятия «компонентно-ориентированное программирование», [рассказал](https://minnie.tuhs.org/pipermail/tuhs/2020-March/020664.html) об интересных и необычных UNIX-программах, не нашедших широкого применения. Публикация запустила активное обсуждение на Hacker News. Мы собрали самое интересное и будем рады, если вы присоединитесь к дискуссии.
[](https://habr.com/ru/company/1cloud/blog/493718/)
*Фото — [Virginia Johnson](https://unsplash.com/photos/QmNnZj_Ok-M) — Unsplash*
Работа с текстом
----------------
В UNIX-подобных операционных системах есть стандартный набор инструментов для форматирования текста. Утилита ***typo*** позволяла просматривать документ на наличие опечаток и [гапаксов](https://ru.wikipedia.org/wiki/%D0%93%D0%B0%D0%BF%D0%B0%D0%BA%D1%81) — слов, встречающихся в материале только один раз. Что интересно, для поиска опечаток программа [не использует](http://man.cat-v.org/unix-6th/1/typo) словари. Она опирается только на информацию в файле и проводит частотный анализ по триграммам (последовательность из трех символов). При этом все необходимые счетчики [хранятся](https://minnie.tuhs.org/pipermail/tuhs/2020-March/020664.html) в массиве 26x26x26. По словам Дугласа Макилроя, такого объема памяти едва хватало для нескольких однобайтных счётчиков. Поэтому в целях экономии их писали в логарифмическом виде.
Сегодня typo заменили более современные и точные программы проверки правописания на основе словарей. Однако про инструмент все еще помнят — несколько лет назад энтузиаст [представил](https://github.com/robpike/typo) реализацию typo на Go. Репозиторий обновляется до сих пор.
Еще один инструмент для работы с документами из 80-х — пакет ***Writer's Workbench*** от Лоринды Черри (Lorinda Cherry) и Нины Макдональд (Nina McDonald) из Bell Labs. В его состав [входили](https://en.wikipedia.org/wiki/Writer%27s_Workbench#Package_contents) инструменты для определения частей речи и стиля документа, поиска тавтологий и излишне сложных предложений. Утилиты разрабатывали в качестве подспорья для студентов, и одно время их [использовали](https://bit.ly/2U9mSjT) учащиеся Государственного университета Колорадо в США. Но к началу девяностых о Writer's Workbench позабыли, потому что его не включили в Version 7 Unix. Однако этот инструмент продолжил дорогу подражателям — например, [Grammatik](https://en.wikipedia.org/wiki/Grammatik) для IBM PC.
В UNIX также имеются стандартные средства, упрощающие работу с формулами. Есть препроцессор языка для оформления математических выражений ***eqn***. Он примечателен тем, что для отображения формулы разработчику достаточно описать её простыми словами и символами. Ключевые слова позволяют смещать математические знаки по вертикали и горизонтали, менять их размеры и другие параметры. Если передать утилите строку:
```
sum from { k = 1 } to N { k sup 2 }
```
На выходе будет сгенерирована следующая формула:
В 1980–1990-х eqn [помогал](https://news.ycombinator.com/item?id=22582548) ИТ-специалистам писать мануалы к программному обеспечению. Но позже его заменила система LaTeX, которую [использует](https://habr.com/ru/docs/help/posts/#allowed_tags_formulae) даже Habr. Но eqn — это первый инструмент подобного класса, остающийся частью UNIX-подобных ОС.
Работа с файлами
----------------
В тематическом треде резиденты Hacker News отметили несколько редко используемых утилит для работы с файлами. Одной из них [была](https://news.ycombinator.com/item?id=22583046) ***comm*** для их сравнения. Это — упрощенный аналог [diff](https://ru.wikipedia.org/wiki/Diff), заточенный под работу в скриптах. Его [написал](https://linux.die.net/man/1/comm) сам Ричард Столлман (Richard Stallman) вместе с Дэвидом Маккензи (David MacKenzie).
Вывод программы состоит из трех столбцов. В первую колонку попадают значения, уникальные для первого файла, во второй — уникальные для второго файла. Третий столбец включает общие значения. Для корректной работы comm сравниваемые документы должны быть лексически отсортированы. Поэтому один из резидентов площадки [предложил](https://news.ycombinator.com/item?id=22583686) работать с утилитой в следующем виде:
```
comm <(sort fileA.txt) <(sort fileB.txt)
```
Comm удобно использовать для проверки написания слов. Достаточно сравнивать их с эталонным документом-словарем. Учитывая тонкости, связанные с необходимостью сортировки файлов, есть [мнение](https://web.archive.org/web/20090402013730/http:/apicom.org.ua/blog/2009/02/16/komanda-comm/), что Столлман и Маккензи написали свою утилиту исключительно для этого юзкейса.
*Фото — [Marnix Hogendoorn](https://unsplash.com/photos/VB1XqDcp6sc) — Unsplash*
Также участник обсуждения на HN [отметил](https://news.ycombinator.com/item?id=22583803) возможности оператора ***paste***, которые были для него неочевидны. Он позволяет чередовать потоки данных или разделить один поток на две колонки при выводе:
```
$ paste <( echo -e 'foo\nbar' ) <( echo -e 'baz\nqux' )
foo baz
bar qux
$ echo -e 'foo\nbar\nbaz\nqux' | paste - -
foo bar
baz qux
```
Один из пользователей [заметил](https://news.ycombinator.com/item?id=22585103), что часто для выполнения этих простых операций применяют не самые оптимальные решения: начиная с [fmt](https://ru.wikipedia.org/wiki/Fmt), [ex](https://ru.wikipedia.org/wiki/Ex_(Unix)) и заканчивая [mlr](https://github.com/johnkerl/miller) с [jot](http://www.nsc.ru/cgi-bin/www/unix_help/unix-man?jot) и [rs](https://www.freebsd.org/cgi/man.cgi?query=rs&sektion=1&apropos=0&manpath=freebsd).
*Какие стандартные возможности UNIX-подобных операционных систем стали открытием для вас?*
> **О чем мы пишем в нашем корпоративном блоге:**
>
>
>
>  [Как развивалась система доменных имен: эра ARPANET](https://1cloud.ru/blog/era-arpanet?utm_source=habrahabr&utm_medium=cpm&utm_campaign=unixtools&utm_content=blog)
>
>  [История системы доменных имен: первые DNS-серверы](https://1cloud.ru/blog/pervie-dns-serveri?utm_source=habrahabr&utm_medium=cpm&utm_campaign=unixtools&utm_content=blog)
>
>  [История DNS: когда доменные имена стали платными](https://1cloud.ru/blog/platnie-dns-imena?utm_source=habrahabr&utm_medium=cpm&utm_campaign=unixtools&utm_content=blog)
>
>  [История системы доменных имен: «войны» протоколов](https://1cloud.ru/blog/voini-protokolov-dns?utm_source=habrahabr&utm_medium=cpm&utm_campaign=unixtools&utm_content=blog) | https://habr.com/ru/post/493718/ | null | ru | null |
# Автоматизируем обработку изображений с помощью Jupyter и Python
Вряд ли вам захочется разбираться с обработкой изображений в графических редакторах, если вы знаете, как сделать это с помощью открытых библиотек для Python.
Недавно мой ребёнок захотел сделать раскраску для персонажа из любимого мультфильма. Очевидным решением было использовать какой-нибудь графический редактор для Linux (потому что я линуксоид), но потом я вспомнил, что я ленивый человек.
К счастью, я знаком с Python и JupyterLab. Посмотрим, насколько Jupyter облегчит задачу.
В первую очередь, нам, конечно, понадобится современная версия Python (если вы пользователь macOS, вы можете следовать этому [руководству](https://opensource.com/article/19/5/python-3-default-mac)). Затем нужно установить и открыть [JupyterLab](https://opensource.com/article/19/5/jupyterlab-python-developers-magic) и [Pillow](https://pillow.readthedocs.io/en/stable/installation.html) — форк библиотеки Python Imaging Library (PIL):
```
$ python -V
Python 3.8.5
$ pip install jupyterlab pillow
……………………..
$ jupyter lab
```
В данном случае мы хотим сделать раскраску с изображением оленя. Для начала загрузим изображение и сохраним его локально. Лучше всего использовать картинки с [Creative Commons](https://creativecommons.org/) или другой открытой лицензией, чтобы не заморачиваться с авторскими правами. В этом примере я использовал изображение с открытой лицензией от [Unsplash](https://unsplash.com/photos/Xu1xO3mpr1I) и назвал его deer.jpg.
Начнём с импорта:
```
from PIL import Image
```
Откроем изображение и проверим его размер:
```
pic = Image.open("deer.jpg")
pic.size
(3561, 5342)
```
Это, пожалуй, многовато для нашей задачи. Такие изображения с высоким разрешением хорошо использовать в книгах, а не в раскрасках. Уменьшим размер изображения:
```
x, y = pic.size
x //= 10
y //= 10
smaller = pic.resize((x, y))
```
Размер стал в 10 раз меньше.
```
smaller
```
Прекрасно. Двигаемся дальше.
Этот олень должен быть лёгкой добычей для алгоритма обнаружения границ. Нужно очистить изображение, чтобы раскрашивание было лёгким. И, к счастью, для этого тоже есть готовый алгоритм:
```
from PIL import ImageFilter
edges = smaller.filter(ImageFilter.FIND_EDGES)
edges
```
Это, наверное, самый важный шаг. Мы уберём все посторонние детали и оставим чёткие линии. Цвет немного странный, но решить эту проблему несложно. Разделим изображение на цветовые полосы и выберем ту, где линии наиболее чёткие:
```
bands = edges.split()
bands[0]
```
Теперь линии чёткие, но сама палитра пока не подходит для печати, потому что в вашем принтере закончатся чернила, да и вашему ребёнку не понравится раскрашивать картинку на чёрном фоне. Так что инвертируем цвета. Установим для x пороги max-black и max-white, чтобы сделать линии еще более чёткими:
```
outline = bands[0].point(lambda x: 255 if x<100 else 0)
outline
```
Теперь обратим внимание, что на картинке осталось много пустого места, поэтому обрежем её:
```
outline.crop((10, 200, 300, 400))
```
Ну и всё. Сохраним картинку в формате PDF (для печати):
```
outline.save("deer.pdf")
```
Вот так можно легко самостоятельно сделать раскраски для ваших детей: минимум рутины, максимум программирования!
---
#### На правах рекламы
**Эпичные серверы** — это [VPS на Linux](https://vdsina.ru/cloud-servers?partner=habr67) или Windows с мощными процессорами семейства AMD EPYC и очень быстрыми NVMe дисками Intel. Расходятся, как горячие пирожки!
[](https://vdsina.ru/cloud-servers?partner=habr67) | https://habr.com/ru/post/515440/ | null | ru | null |
# Создание беспарольной аутентификации в Laravel, используя только email
Недавно я работал над проектом, где одной из болевых точек был пароль пользователя. Администратор добавлял пользователей в приложение, поэтому они не имеют пароля, а заставлять их придумывать пароль при первом после регистрации входе было крайне неудобно.
Итак, мы решили попробовать метод беспарольного входа. Если Вы никогда не имели возможности работать с этим, мы расскажем как это работает:
На странице входа в систему пользователь вводит свой email-адрес, на который получит ссылку на вход. Переход по ссылке подтверждает личность пользователя без необходимости ввода пароля, так как ссылка для каждого входа пользователя уникальная.
Начнем творить!
Новое приложение и make:auth
----------------------------
Вначале мы создадим наше приложение, подключив аутентификацию:
```
laravel new medium-login
cd medium-login
php artisan make:auth
```
Теперь у нас есть все необходимые для авторизации файлы, в том числе вьюхи. Давайте начнем с них.
Изменение страницы входа и регистрации
--------------------------------------
Конечно, сочетание логина с паролем довольно хорошая идея, но нам нужно отказаться от поля ввода пароля на обеих формах.
Откройте файл `resources/views/auth/login.blade.php` и удалите группу, отвечающую за ввод пароля (label, input и обертка ). Сохраняем, закрываем.
Теперь открываем файл `resources/views/auth/register.blade.php` и удаляем группы, отвечающие за ввод пароля (`password`) и подтверждения пароля (`password-reset`). Сохраняем, закрываем.
Позже Вы можете добавить инструкцию о методе входа на странице аутентификации, а также разместите ссылки на сброс пароля, но это позже.
Изменение регистрационных роутов
--------------------------------
Итак, нам нужно изменить роут, указывающий на точки входа и регистрации. Взглянем на контроллер ` AuthController`.
Во-первых, мы заметим метод `validator`, возвращающий валидацию поля пароля. Так как он отвечает за процесс регистрации учетной записи, нам нужно избавиться от его привязки к паролю.
В конечном итоге, функция должна выглядеть так:
```
// app/http/Controllers/Auth/AuthController.php
protected function validator(array $data)
{
return Validator::make($data, [
'name' => 'required|max:255',
'email' => 'required|email|max:255|unique:users',
]);
}
```
То же самое мы сделаем для метода `Create`, приведя его к виду:
```
// app/http/Controllers/Auth/AuthController.php
protected function create(array $data)
{
return User::create([
'name' => $data['name'],
'email' => $data['email'],
]);
}
```
Перекрытие роута `login`
------------------------
Как Вы можете видеть, здесь нет методов для регистрации пользователей. Они скрыты в трейте `AuthenticatesAndRegistersUsers`, который использует трейты аутентификации `AuthenticatesUsers` и регистрации `RegistersUsers`. Вы можете перейти к трейту `AuthenticatesUsers` и в конце файла найти метод аутентификации пользователей под именем `login`.
Все, что там происходит, основывается на защищенных паролях, хотя этот метод можно и заменить…
Целью нашего нового метода является отправка на email пользователя ссылки для входа в систему. Давайте вернемся к контроллеру `AuthController` и добавим метод входа в систему, перекрывающий `login` в `AuthenticatesUsers`:
```
// app/http/Controllers/Auth/AuthController.php
public function login(Request $request)
{
// validate that this is a real email address
// send off a login email
// show the users a view saying "check your email"
}
```
Подтверждение реальности email-адреса
-------------------------------------
Подтвердить реальность email адреса для зарегистрированного пользователя очень просто:
```
$this->validate($request, ['email' => 'required|email|exists:users']);
```
Отправка email-сообщения
------------------------
Далее, нам необходимо отправить пользователю ссылку на вход. Это займет немного больше времени.
### Создание структуры для формирования и проверки токенов email
Если Вы знакомы с формой структуры базы данных `password\_reset`, то Вам будет проще, т.к. мы будем создавать нечто похожее. Каждый раз, когда кто-то пытается войти в систему, нам нужно добавлять запись в таблицу, которая будет фиксировать адрес электронной почты и уникальный токен, отправляемые в электронном письме в качестве URL, а также дату создания и срок жизни записи.
В конечном итоге мы будем использовать URL-адрес для создания (и проверки), например: `myapp.com/auth/email-authenticate/09ajfpoib23li4ub123p984h1234`. Так как срок жизни токена ограничен, мы должны связать этот URL с конкретным пользователем, отслеживая email, токен и дату создания для каждой записи таблицы.
Итак, создадим для него миграцию:
```
php artisan make:migration create_email_logins_table --create=email_logins
```
И добавим в нее несколько полей:
```
Schema::create('email_logins', function (Blueprint $table) {
$table->string('email')->index();
$table->string('token')->index();
$table->timestamps();
});
```
> Примечание: при желании можно использовать значение колонки `id` вместо токена, но есть несколько причин более лучших вариантов. Во всяком случае, решать Вам.
Теперь, давайте создадим модель.
```
php artisan make:model EmailLogin
```
Отредактировать файл (`app/EmailLogin.php`) и сделать его простым для нас, создав экземпляр с нужными свойствами:
```
class EmailLogin extends Model
{
public $fillable = ['email', 'token'];
}
```
И когда хотим найти пользователя, мы должны использовать электронную почту, а не идентификатор, вручную связав столбец email:
```
class EmailLogin extends Model
{
public $fillable = ['email', 'token'];
public function user()
{
return $this->hasOne(\App\User::class, 'email', 'email');
}
}
```
### Создание токена
Теперь мы готовы к созданию email-сообщения. Мы будем использовать URL-адрес, содержащий уникальный токен, сгенерированный заранее.
Нужно понять, как мы будем создавать и хранить токен. Для этого, нам нужно создать экземпляр `EmailLogin`, так что приступим:
```
public function login()
{
$this->validate($request, ['email' => 'required|email|exists:users']);
$emailLogin = EmailLogin::createForEmail($request->input('email'));
}
```
Давайте добавим этот метод в `EmailLogin`:
```
class EmailLogin extends Model
{
...
public static function createForEmail($email)
{
return self::create([
'email' => $email,
'token' => str_random(20)
]);
}
}
```
Мы генерируем рандомный токен и создаем экземпляр класса `EmailToken`, получая его обратно.
### Формирование URL для отправки по email
Итак, нам нужно использовать `EmailToken` для формирования URL перед отправкой сообщения пользователю.
```
public function login()
{
$this->validate($request, ['email' => 'required|email|exists:users']);
$emailLogin = EmailLogin::createForEmail($request->input('email'));
$url = route('auth.email-authenticate', [
'token' => $emailLogin->token
]);
}
```
Давайте создадим для него роут:
```
// app/Http/routes.php
Route::get('auth/email-authenticate/{token}', [
'as' => 'auth.email-authenticate',
'uses' => 'Auth\AuthController@authenticateEmail'
]);
```
… и добавим метод в контроллер для работы этого маршрута:
```
class AuthController
{
...
public function authenticateEmail($token)
{
$emailLogin = EmailLogin::validFromToken($token);
Auth::login($emailLogin->user);
return redirect('home');
}
}
```
… и еще добавим метод `validFromToken` для проверки токена:
```
class EmailLogin
{
...
public static function validFromToken($token)
{
return self::where('token', $token)
->where('created_at', '>', Carbon::parse('-15 minutes'))
->firstOrFail();
}
```
Теперь у нас есть входящий роут, учитывающий актуальность каждого токена. Если токен актуален — пользователь будет перенаправлен по адресу `mysite.ru/home`.
Что ж, давайте отправим письмо.
### Отправка письма
Добавим вызов `call email` в наш контроллер:
```
public function login()
{
...
Mail::send('auth.emails.email-login', ['url' => $url], function ($m) use ($request) {
$m->from('[email protected]', 'MyApp');
$m->to($request->input('email'))->subject('MyApp Login');
});
```
… и создадим шаблон:
```
Log in to MyApp here: <{{ $url }}>
```
### Возвращение шаблона
Вы можете оформить шаблон любым удобным способом, но мы просто используем текст: «Эй, мы отправили мыло, чтобы его проверить. Это все.»
```
return 'Login email sent. Go check your email.';
```
Совместный вход
---------------
Взглянем на нашу систему. У нас есть новый метод `login` в контроллере `AuthController`:
```
public function login(Request $request)
{
$this->validate($request, ['email' => 'required|exists:users']);
$emailLogin = EmailLogin::createForEmail($request->input('email'));
$url = route('auth.email-authenticate', [
'token' => $emailLogin->token
]);
Mail::send('auth.emails.email-login', ['url' => $url], function ($m) use ($request) {
$m->from('[email protected]', 'MyApp');
$m->to($request->input('email'))->subject('MyApp login');
});
return 'Login email sent. Go check your email.';
}
```
Мы создали несколько вьюх, обновив существующие (убрали в них записи о пароле). Также создали новый роут в `/auth/email-authenticate`. И также создали миграцию `EmailLogin` с классом всех его потребностей.
Это все!
--------
И… профит! Поместите все примеры в Ваш код и получите полностью функциональную систему беспарольного входа.
Для регистрации пользователя нужно будет узнать всего-лишь их email-адрес. И при авторизации кроме их email-адреса больше ничего не нужно будет запоминать и вводить. Больше нет забытых паролей. Бум!
### От переводчика
При переводе статьи была произведена адаптация информации для лучшей читаемости русскоговорящих пользователей. | https://habr.com/ru/post/279173/ | null | ru | null |
# Последовательное выполнение задач в Gulp JS
[Gulp JS](http://gulpjs.com) — это сборщик проектов и таск-менеджер для фронтенд и веб-разработки, который является достойной альтернативой для популярного [Grunt JS](http://gruntjs.com). Одной из нескольких вещей, которыми Gulp отличается от Grunt является то, что по умолчанию все задачи запускаются асинхронно. В целом, можно сказать, что все задачи выполняются одновременно.
Недавно, изучая Gulp, я столкнулся с необходимостью синхронного запуска нескольких задач… синхронного. В документации к Gulp упоминается данная проблема, но мне пришлось немного повозиться перед тем, как я с этим разобрался.
Итак, у нас есть 3 способа сделать выполнение задач синхронным, но чтобы это заработало, нужно явно указать зависимости задач. Про зависимости чуть позже, для начала разберем эти 3 способа:
1. Используя обратный вызов, callback
```
gulp.task('sync', function (cb) {
// setTimeout может быть асинхронной задачей
setTimeout(function () {
cb();
}, 1000);
});
```
2. Через возвращение потока
```
gulp.task('sync', function () {
return gulp.src('js/*.js')
.pipe(concat('script.min.js')
.pipe(uglify())
.pipe(gulp.dest('../dist/js');
});
```
3. Воспользоваться [Promise](https://github.com/kriskowal/q)
```
gulp.task('sync', function () {
var deferred = Q.defer();
// setTimeout может быть асинхронной задачей
setTimeout(function () {
deferred.resolve();
}, 1000);
return deferred.promise;
});
```
Теперь предположим, что мы имеем еще одну задачу `secondTask`, которая зависит от результатов выполнения задачи `sync` (которую мы создали одним из способов описанных выше). Поэтому мы объявляем нашу задачу `sync` как зависимость для задачи `secondTask`:
```
gulp.task('secondTask', ['sync'], function () {
// эта задача не буде запущена пока
// задача 'sync' не закончит работу!
});
```
Главная ошибка, которую я допустил, была в предположении, что если я объявляю в качестве зависимости список задач, то задачи будут выполнены в указанной последовательности, когда выполнение следующей задачи в списке, будет выполняться только после окончания предшествующей задачи. Но это совсем не так:
```
gulp.task('thirdTask', function () {
// эта задача не зависит от других
});
// Я надеялся, что этот код сначала запустит
// задачу 'sync', затем будет запущена
// задача 'thridTask' и только потом будет
// выполнена задача 'default'. Но это не так.
// Перед выполнении задачи 'default', задачи
// 'sync' и 'thridTask будут запущены
// ОДНОВРЕМЕННО
gulp.task('default', ['sync', 'thirdTask'], function () {
// что-то делаем
});
```
Для того, чтобы задача `default` была выполнена в той последовательности как я хотел, задачу `thirdTask` необходимо сделать зависимой от задачи `sync`.
```
gulp.task('thirdTask', ['sync'] function () {
// теперь эта задача зависит от 'sync'. Если здесь
// будет возвращен поток, то задача 'default' не будет
// запущена, пока 'thirdTask' не будет закончена
});
gulp.task('default', ['sync', 'thirdTask'], function () {
// что-то делаем
});
```
Обратите внимание на то, что каждый раз, когда вы запускаете `thirdTask`, будет также запускаться `sync`. Это может быть нежелательным поведением, если у вас есть некоторая задача `watch`, которая запускает задачу `thirdTask`.
Надеюсь, что эта статья кому-то поможет понять, как с помощью Gulp реализовать выполнение своих задач в строго определенном порядке. Но стоит отметить, что именно асинхронный запуск и асинхронное выполнение задач делают Gulp таким быстрым и мощным, поэтому используйте возможность синхронного выполнения только там, где это действительно необходимо. | https://habr.com/ru/post/240485/ | null | ru | null |
# Ещё более современный C++
“C++11 feels like a new language.” – Bjarne Stroustrup
Не так давно [Герб Саттер](http://ru.wikipedia.org/wiki/Герб_Саттер) открыл на своём сайте новую страничку — [Elements of Modern C++ Style](http://herbsutter.com/elements-of-modern-c-style/), где он описывает преимущества нового стандарта и то, как они повлияют на код.
Стандарт C++11 вносит множество новых фич. Далее мы рассмотрим те из них, благодаря которым C++11 можно считать новым языком по сравнению с C++98, т.е.:
* Они меняют стиль Вашего кода, привнося новые идиомы. Они повлияют на архитектуру С++ библиотек. Например: умные указатели получат большее распространение (и как аргументы функций, и как их возвращаемые значения), как и функции, возвращающие большие объекты по значению.
* Они будут использоваться столь часто и интенсивно, что Вы, вероятно, будете встречать их в каждом втором примере кода. Например: вряд ли какой-нибудь пример из пяти или более строчек кода обойдётся без упоминания ключевого слова auto.
Не стесняйтесь использовать и другие возможности C++11. Но в первую очередь обратите внимание на те, что перечислены ниже, так как именно благодаря им, на C++11 возможно писать чистый, безопасный и быстрый код — такой же чистый и безопасный, как и в случае других современных языков. Ну и традиционная производительность C++, как всегда, на высоте.
#### auto
Используйте ключевое слово auto везде, где это возможно.
Во-первых, не стоит повторять имя типа, о котором и мы, и компилятор уже знаем:
```
// C++98
map::iterator i = m.begin();
// C++11
auto i = begin(m);
```
Во-вторых, так гораздо удобнее в случае, если тип имеет неизвестное или большое и неказистое имя, которое Вы даже произнести не в состоянии.
```
// C++98
binder2nd< greater > x = bind2nd( greater(), 42 );
// C++11
auto x = [](int i) { return i > 42; };
```
Отметим, что использование auto не меняет смысла Вашего кода. Он по-прежнему статически типизирован, и каждое выражение по-прежнему обладает чётким и ясным типом. Просто язык больше не заставляет Вас повторяться, заново указывая тип.
Кто-то боится использования auto, потому как не указывая тип, мы можем получить совсем не то, что ожидаем. Если Вы хотите принудительно приводить типы, то хорошо — указывайте нужный тип. Но в большинстве случаев следует использовать auto: вряд ли Вы получите экземпляр другого типа по ошибке, и даже в этом случае поможет строгая типизация (компилятор будет ругаться, если Вы, например, попробуете вызвать несуществующий метод).
#### Умные указатели: delete не нужен
Всегда используйте стандартные умные указатели и невладеющие сырые указатели. Никогда не используйте владеющие сырые указатели и delete (кроме крайних случаев, вроде реализации низкоуровневых структур).
В общем случае указатель — это shared\_ptr, выражающий общее владение.
```
// C++98
widget* pw = new widget();
:::
delete pw;
// C++11
auto pw = make_shared();
```
Чтобы избежать циклических связей или выразить опциональность (например, при реализации кеша объектов), используйте weak\_ptr.
```
// C++11
class gadget;
class widget {
private:
shared_ptr g;
};
class gadget {
private:
weak\_ptr w;
};
```
В случае, если у указателя должен быть единственный владелец, используйте unique\_ptr, предназначенный специально для этого случая. Любое выражение вида “new T” должно немедленно инициализировать другой объект, владеющий им. И обычно это unique\_ptr.
```
// C++11 Pimpl Idiom
class widget {
:::
private:
class impl;
unique_ptr pimpl;
};
// в .cpp файле
class impl {
:::
};
widget::widget()
: pimpl( new impl() )
{
}
```
Если Вам нужно работать с объектом, который может пережить Вас, используйте сырой указатель.
```
// C++11
class node {
vector< unique_ptr > children;
node\* parent;
public:
:::
};
```
#### nullptr
Всегда используйте для нулевого значения nullptr и никогда 0 или макрос NULL, поскольку они неоднозначны и могут быть как числом, так и указателем.
```
// C++98
int* p = 0;
// C++11
int* p = nullptr;
```
#### for и range
С новым for'ом, умеющим работать с range, перебирать элементы контейнеров стало ещё проще и удобнее.
```
// C++98
for( vector::iterator i = v.begin(); i != v.end(); ++i ) {
total += \*i;
}
// C++11
for( auto d : v ) {
total += d;
}
```
#### begin и end
Всегда используйте begin и end как нечлены, потому что такой подход легко расширяем и позволяет работать со всеми типами контейнеров, а не только теми, которые следуют стилю STL и предоставляют методы .begin() и .end().
Если Вы используйте не-STL коллекцию, которую можно проитерировать, но не реализующую методы .begin() и .end(), Вы можете самостоятельно перегрузить begin и end для неё так, чтобы итерировать эту коллекцию так же, как и контейнеры STL. Такая перегрузка, например, уже реализована для массивов в стиле C.
```
vector v;
int a[100];
// C++98
sort( v.begin(), v.end() );
sort( &a[0], &a[0] + sizeof(a)/sizeof(a[0]) );
// C++11
sort( begin(v), end(v) );
sort( begin(a), end(a) );
```
#### Лямбда функции
Благодаря лямбдам Ваш код станет элегантнее и быстрее. С их появлением использовать существующие алгоритмы STL стало проще раз в 100. Новые библиотеки всё чаще полагаются на поддержку лямбда-функций ([PPL](http://en.wikipedia.org/wiki/Parallel_Patterns_Library)), а некоторые и вовсе требуют их наличия ([C++ AMP](http://habrahabr.ru/company/microsoft/blog/121937/)).
Небольшой пример: найти первый элемент в v, который больше x и меньше y.
```
// C++98: пишем обычный цикл (использовать std::find_if сложно и непрактично)
vector::iterator i = v.begin(); // i нам ещё пригодится
for( ; i != v.end(); ++i ) {
if( \*i > x && \*i < y ) break;
}
// C++11: используем std::find\_if
auto i = find\_if( begin(v), end(v), [=](int i) { return i > x && i < y; } );
Нужен специальный цикл или что-то похожее, чего нет в языке? Нет проблем — просто реализуйте его шаблонной функцией и, благодаря лямбдам, Вы можете использовать его практически так же, как если бы это было частью языка, но с ещё большей гибкостью, т.к. этот функционал не является частью языка.
// C#
lock( mut\_x ) {
... use x ...
}
```
```
// C++11 without lambdas: already nice, and more flexible (e.g., can use timeouts, other options)
{
lock_guard hold { mut\_x };
... use x ...
}
// C++11 with lambdas, and a helper algorithm: C# syntax in C++
// Algorithm: template void lock( T& t, F f ) { lock\_guard hold(t); f(); }
lock( mut\_x, [&]{
... use x ...
});
```
Обязательно ознакомьтесь с лямбдами. Они уже широко распространены во многих популярных языках. Для начала можно послушать мой доклад [Lambdas, Lambdas Everywhere](http://herbsutter.com/2010/10/30/pdc-languages-panel-andshortened-lambdas-talk/) на PDC 2010.
#### Move / &&
Семантика переноса сильно изменит дизайн наших API. Гораздо чаще функции и методы будут возвращать по значению.
```
// C++98: как избежать копирования
vector\* make\_big\_vector(); // вариант 1: возвращаем указатель: копирования нет, но не забудьте про delete
:::
vector\* result = make\_big\_vector();
void make\_big\_vector( vector& out ); // вариант 2: выдача по ссылке: копирования нет, но вызывающему нужен именованный объект
:::
vector result;
make\_big\_vector( result );
// C++11: перенос
vector make\_big\_vector();
:::
vector result = make\_big\_vector();
```
Если Вы можете сделать что-то более эффективное, чем простое копирование, используйте перемещение.
#### Единообразная инициализация и списки инициализации
Что не изменилось: при инициализации локальной переменной типа, отличного от POD и auto, продолжайте использовать обычный синтаксис присваивания без дополнительных { } скобок.
```
// C++98 or C++11
int a = 42; // как всегда, ок
// C++ 11
auto x = begin(v); // хуже не станет
```
В других случаях, особенно когда Вы использовали круглые ( ) скобки для конструирования объекта, предпочитайте использовать фигурные. Использование скобок позволяет избежать нескольких потенциальных проблем: Вы не сможете случайно сузить тип (вроде приведения float к int), не сможете случайно забыть инициализировать POD члены или массивы. Также Вы сможете избежать классической ошибки C++98: код компилируется, но из-за неоднозначности грамматики на самом деле объявляет функцию вместо переменной
```
// C++98
rectangle w( origin(), extents() ); // oops, declares a function, if origin and extents are types
complex c( 2.71828, 3.14159 );
int a[] = { 1, 2, 3, 4 };
vector v;
for( int i = 1; i <= 4; ++i ) v.push\_back(i);
// C++11
rectangle w = { origin(), extent() }; // = is optional but I personally prefer it
complex c = { 2.71828, 3.14159 }; // = is optional but I personally prefer it
int a[] = { 1, 2, 3, 4 };
vector v = { 1, 2, 3, 4 };
```
Новый синтаксис { } работает практически везде:
```
// C++98
X::X( /*...*/ ) : mem1(init1), mem2(init2, init3) { /*...*/ }
// C++11
X::X( /*...*/ ) : mem1{init1}, mem2{init2, init3} { /*...*/ }
```
Наконец, иногда удобнее передавать функции аргументы без указания обёртки:
void draw\_rect( rectangle );
```
// C++98
draw_rect( rectangle( myobj.origin, selection.extents ) );
// C++11
draw_rect( { myobj.origin, selection.extents } );
```
#### И ещё
В современном C++ ещё много хороших вещей. Очень много. И в ближайшем будущем я напишу о них подробнее.
Но на текущий момент, всё вышенаписанное — это must-know. Эти фичи лежат в основе современного C++, определяя его стиль. И совсем скоро Вы сможете встретить их практически в каждом кусочке свеженаписанного C++ кода. Именно они делают современный C++ чистым, безопасным и быстрым — таким, на который индустрия будет полагаться долгие годы. | https://habr.com/ru/post/131478/ | null | ru | null |
# Мифический PCM Capture Extraction Tool: извлекаем звук без обращения в TAC
*Недоступный простым смертным мифический ресурс pcet.cisco.com*
Читатель, сталкивавшийся с необходимостью заниматься захватом данных PCM на маршрутизаторах Cisco ISR, легко находит исчерпывающее пошаговое руководство по данной теме, но непременно спотыкается о пункт «полученный файл следует отправить в TAC для дальнейшего извлечения звука». Можно ли обойтись без этого?
### Предыстория
Телефонную станцию заказчика требовалось подключить как к одному известному SIP-оператору (публичный IP-адрес), так и к SIP-серверу провайдера, предоставлявшего местную связь (частный IP-адрес). К сожалению, станции этой модели не могут одновременно подключаться к SIP-серверам за NAT'ом и к таковым в частной сети, поскольку обход NAT подменой адресов в них включается для всех SIP-транков без исключения. В качестве маршрутизатора клиент использовал Cisco 2811. Поскольку у заказчика в АТС имелась свободная плата потока ISDN PRI, задачу решили приобретением в указанный маршрутизатор платы потока E1 и голосового процессора. Были выполнены соответствующие настройки (везде использовался кодек G.711 A-law) — и все заработало.
### Проблема
Ситуация стандартная — все работало замечательно, но в один прекрасный день перестало. Сотрудники заказчика начали обращаться с жалобами на некий сигнал во время разговора, «как будто кто-то кнопку на телефоне нажал». Данный сигнал был довольно быстро идентифицирован как DTMF-тон, который мог прозвучать в начале, середине или конце разговора, а то и несколько раз в продолжение такового. Оставалось выяснить, кто в этом виноват (или что виновато) и как ситуацию исправить.
Следует сказать, что состав используемого оборудования предоставляет впечатляющий набор инструментов для тестирования и отладки. Кроме всего спектра отладочных возможностей Cisco есть весьма полезный инструмент трассировки ISDN в реальном времени, входящий в состав консоли управления используемой АТС. К сожалению, в этом случае ничего не помогало, «поймать» данный сигнал, то есть сопоставить его с отладочной информацией, никак не получалось в силу крайней нерегулярности его появления. Изучение всей информации по данному вопросу привело к ряду документов по захвату PCM на оборудовании Cisco.
Сообщается, что маршрутизаторы серий 2900, 3900, 3900e и шлюзы VG350 позволяют это делать [легко и просто](http://www.cisco.com/c/en/us/support/docs/voice-unified-communications/unified-communications-system/115749-analyze-pcm-data.html), причем в результате получается файл, содержащий голосовые данные, пригодные для непосредственного импорта в аудиоредакторы.
К огромному сожалению, маршрутизатор заказчика серии 2800 не имел чести принадлежать к перечисленным благородным семействам и таковыми возможностями не обладал. В IOS с версиями ниже 15.2(2)T1 (для маршрутизатора заказчика такая версия ПО никогда не будет выпущена, ибо End of Support) для захвата PCM требовалось выполнить ряд команд. Если событие ожидаемое, то можно дождаться его и произвести запись:
```
voice hpi capture buffer 51200000
voice hpi capture destination flash:pcm.dat
test voice port x/x/x pcm-dump caplog fff duration xxx
```
Или же можно записывать вообще все подряд до тех пор, пока не произойдет интересующее событие (осторожно, возможно переполнение памяти flash!):
```
dial-peer voice x voip/pots
pcm-dump caplog fff duration xxx
```
При этом создается файл с голосовой и отладочной информацией, который может быть извлечен из памяти flash и скопирован на TFTP-сервер.
### Еще одна проблема, в каком-то смысле похуже первой
Вот тут началось самое интересное. Многочисленные граждане, озадачившиеся захватом PCM, изливали на форумах технической поддержки свое негодование — мол, я сделал дамп, импортировал его в аудиоредактор и так и эдак, все равно получается какая-то фигня! Что я делаю неправильно? На это другие граждане им отвечали, что ситуация совершенно нормальная, извлечь из оного файла вожделенный звук могут только могущественные специалисты TAC при помощи мифического инструмента PCM Capture Extraction Tool, доступного по ссылке pcet.cisco.com. Думаю, не я один, посмотрев замечательный [обучающий видеоролик на Youtube](https://youtu.be/B_8CIKamSsc), пытался перейти по данной ссылке и был жестоко унижен, ибо это невозможно для простых смертных. Якобы необходимость вовлечения TAC связана не с техническими, а с правовыми аспектами (интересно, чем в правовом аспекте ISR G2 отличается от ISR?) — дескать, такое декодирование с какой-то точки зрения можно считать незаконным прослушиванием, и вообще декодер меняется слишком часто, версию используемого DSP определить трудно, etc. Удалось найти и мнение, высказанное предположительно от лица нерусскоязычного инженера TAC — мол, мы о механизме не задумываемся, а файл просто загружаем в систему через форму на страничке. Есть ряд ограничений на имя и размер, но в результате получаем .WAV-Файлы, а также некоторую отладочную информацию. В виде распространяемого дистрибутива данный инструмент не существует, и вообще основная трудность — заполучить сами .DAT-Файлы, так что вы, уважаемые заказчики, сии файлы заполучите и перешлите нам, а уж мы извлечем из них все, что надо и не надо.
Однако вовлечь в решение вопроса инженеров TAC в данном случае не получилось — помните, что оборудование в статусе End of Support? Соответственно, никаких сервисных контрактов и никакой поддержки. Правда, инженеры TAC порадовали меня, сообщив, что мое желание самостоятельно решить данную задачу, то есть разобраться в структуре файла и извлечь хранимую там информацию, нарушением чего бы то ни было не является и в случае успеха меня за это ничего пожизненно не лишат. И на том, как говорится, спасибо.
Начал с того, что загрузил один из полученных файлов в шестнадцатеричный редактор. Увиденное не слишком порадовало, хотя там и были знакомые слова («C2800NM-ADVENTERPRISEK9-M, 15.1(4)M10, IP|SLA|IPv6|IS-IS|FIREWALL|VOICE|PLUS|QoS|HA|NAT|MPLS|VPN|LE» и «28.3.14», последнее представляет собой значение DSPWARE VERSION из вывода команды show voice dsp detail). Кроме того, была заметна, так сказать, структура и периодичность. На этом этапе я решил вернуться к рассмотрению команды test voice port:
```
C2811#test voice port 0/3/0:15.1 pcm-dump ?
caplog Print to caplog, please enable banjo logger
console Print to console, possible flood console
disable Disable the message dump
```
Во всех найденных описаниях внимание уделяется исключительно параметру caplog. Почему же заслуженную консоль так незаслуженно обошли вниманием? Это следует исправить:
```
C2811#test voice port 0/3/0:15.1 pcm-dump console ?
<1-7> PCM stream index. Bit0:R_in=0x01 Bit1:S_in=0x02 Bit2:S_out=0x04
```
Тут все более или менее понятно. Следующий параметр кодирует номера потоков PCM, которые требуется захватить. Поток R\_in содержит аудиоданные, передающиеся из VoIP в PSTN. Поток S\_in содержит аудиоданные, передающиеся из PSTN в VoIP ДО обработки DSP. Поток S\_out содержит аудиоданные, передающиеся из PSTN в VoIP ПОСЛЕ обработки DSP. Номера потоков можно складывать, получая любые желаемые комбинации — можно захватывать любой один, любые два или же сразу все три потока одновременно. Впрочем, не вижу причин, по которым имеет смысл захватывать не все три потока данных сразу – разве что с целью разобраться в структуре поступающей в консоль информации. При этом можно запустить бессрочный захват (не забываем о том, что на карте flash должно быть достаточно свободного места) с последующей ручной остановкой:
```
test voice port 0/3/0:15.1 pcm-dump console 1
```
[разговор]
```
test voice port 0/3/0:15.1 pcm-dump disable
```
Можно сразу указать требуемую продолжительность в секундах:
```
C2811#test voice port 0/3/0:15.1 pcm-dump console 1 duration ?
<0-255> capturing time in sec
```
Захват трех каналов в консоли выглядит примерно так:
```
047581: Jan 19 11:52:15.491: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
047582: Jan 19 11:52:15.495: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 00 00 07 00 09 00 0E 00 0E 00 0D 00 0D 00 03 FF FC 00 00 00 04 00 02 00 00 FF F9 00 03 00 0B 00 04 00 0B 00 0C 00 01 00 00 00 01 FF FE 00 06 00 02 00 03 00 07 00 06 00 00 00 05 FF FD 00 02 00 07 00 03 00 04 00 08 FF FF 00 02 00 04 FF FF FF F8 FF F5 FF F3 FF FA FF F8 FF F1 FF F1 FF F2 FF F4 FF EF FF EF FF EE FF F0 FF F8 FF FB FF F4 FF F3 FF FA FF F4 FF F2 FF F8 FF FF 00 04 FF FB FF F5 FF F1 FF FC FF FD FF FE FF F6 FF F3 FF F2 FF ED FF EA FF EB FF F7 FF F5 FF F2 FF F2 FF F6 FF FC
047583: Jan 19 11:52:15.499: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 01 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08
```
[и еще очень много похожих сообщений]
Захват одного канала:
```
027761: Jan 15 00:59:53.549: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00
```
[и еще очень много похожих сообщений]
Выполним следующие команды:
```
test voice port 0/3/0:15.1 pcm-dump con 1 duration 10
test voice port 0/3/0:15.1 pcm-dump dis
test voice port 0/3/0:15.1 pcm-dump con 2 duration 10
test voice port 0/3/0:15.1 pcm-dump dis
test voice port 0/3/0:15.1 pcm-dump con 4 duration 10
test voice port 0/3/0:15.1 pcm-dump dis
test voice port 0/3/0:15.1 pcm-dump con 7 duration 10
test voice port 0/3/0:15.1 pcm-dump dis
```
Вернемся к рассмотрению структуры полученных текстовых сообщений. Файл для R\_in:
```
047648: Jan 19 12:10:48.525: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 00 00 18 00 28 00 28 00 18 00 28 00 28 00 18 00 28 00 18 00 18 00 18 00 18 00 08 00 18 00 18 00 08 00 18 00 08 FF F8 00 08 FF F8 FF E8 FF E8 FF E8 FF E8 FF E8 FF E8 FF E8 FF E8 FF D8 FF D8 FF E8 FF E8 FF E8 FF E8 FF D8 FF E8 FF E8 FF E8 FF E8 FF E8 FF F8 00 08 00 08 FF F8 FF F8 FF F8 FF F8 FF F8 FF F8 FF F8 FF F8 00 08 00 08 FF F8 00 08 00 08 00 08 00 08 00 18 00 08 00 18 00 18 00 18 00 18 00 18 00 18 00 08 00 18 00 18 00 18 00 18 00 08 00 08 00 08 00 08 00 18 00 18 FF F8 00 08
```
[...]
```
048647: Jan 19 12:10:58.517: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 00 00 08 00 08 FF E8 FF F8 FF E8 FF F8 FF F8 FF E8 FF E8 FF E8 FF E8 FF F8 FF E8 00 08 FF F8 FF F8 FF F8 FF F8 00 18 FF F8 00 08 00 08 FF F8 FF F8 FF E8 FF F8 FF E8 FF F8 FF E8 FF F8 FF F8 FF F8 FF F8 FF E8 FF D8 FF F8 FF E8 FF E8 FF E8 FF E8 FF F8 FF F8 FF D8 FF E8 FF E8 FF F8 FF E8 FF F8 FF F8 FF E8 FF F8 FF F8 FF E8 FF E8 FF F8 FF E8 FF E8 00 08 FF F8 FF F8 FF F8 FF F8 FF F8 FF E8 FF E8 FF F8 FF E8 00 08 FF F8 00 18 00 08 00 08 FF E8 00 08 00 08 00 08 00 08 00 18 00 08 00 08
```
Шестизначное число перед датой представляет собой уникальный идентификатор, всего у нас присутствует ровно одна тысяча сообщений с номерами от 047648 до 048647 включительно.
Файл для S\_in:
```
050234: Jan 19 12:12:58.636: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 01 FF E8 FD 90 FE F8 FF B8 02 B0 01 C8 FF 48 03 D0 FE 98 08 40 FD F0 FD 70 FF D8 FD D0 00 C8 FC D0 04 E0 FA E0 02 10 04 A0 F9 E0 02 90 FD F0 FE A8 00 B8 02 50 02 70 FE E8 02 90 FD 90 00 F8 04 60 FA 60 00 A8 FC D0 02 30 01 E8 FD D0 03 50 FA 20 FF D8 01 78 FF 28 03 90 01 08 FB E0 01 78 FF 98 FE C8 FF A8 FF 38 06 A0 FA A0 00 A8 04 A0 FD 10 00 E8 FE 08 00 B8 FE D8 FD B0 01 98 01 78 01 D8 00 38 FF C8 FF 08 00 28 01 58 FE B8 01 D8 FE E8 FE 08 01 C8 FF 68 FF A8 00 08 00 38 FF 28 FE 48
```
[...]
```
051233: Jan 19 12:13:08.624: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 01 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 08 00 18 00 08 00 08 00 08 00 18 00 18 00 18 00 18 00 18 00 18 00 08 00 08 FF F8 FF F8 FF F8 FF E8 FF E8 FF E8 FF D8 FF E8 FF D8 FF D8 FF D8 FF E8 FF E8 FF E8 FF F8 FF F8 00 08 00 18 00 08 00 08 00 18 00 18 00 18 00 18 00 18 00 08 00 08 00 08 00 08 00 08 FF F8 00 08 FF F8 00 08 00 08 00 08 FF F8 FF F8 FF F8 FF F8 00 08 00 08 00 08 00 08 FF F8 00 08 00 08 00 08 00 18 00 08 00 18 00 18 FF F8 FF F8 FF F8 FF F8 FF F8 FF E8 FF E8
```
Тоже одна тысяча сообщений ровно.
Файл для S\_out:
```
051234: Jan 19 12:14:00.396: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 02 00 06 FF F6 00 76 00 F6 00 36 FF C6 00 68 FF F8 FF 88 00 78 FF A8 FE B8 00 18 00 98 FF 98 FF C8 01 38 FF 98 FF 18 01 58 00 58 FE F6 FF A8 01 A8 00 E8 00 38 00 18 FF 08 FE 56 FF 06 00 A6 00 86 00 E6 FF 86 FF 58 FF D8 00 18 00 86 00 26 00 66 FF F6 FF E6 FF 56 00 56 00 76 FE F6 FF E6 00 16 FF C6 FF B6 FF C6 00 86 FF B6 FF 76 FF F6 00 A6 00 36 FF E6 00 88 00 08 00 38 FF E8 FF F6 00 18 00 3A 00 8A 00 2A FF BA FF 5A FF D8 00 18 00 58 00 5A FF 7A FF AA FF E8 00 18 00 18 FF C8 FF F8
```
[...]
```
052233: Jan 19 12:14:10.388: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 02 00 C0 01 8C FD 52 01 00 01 C2 FE E8 FE BE 01 3E 01 60 FF 4E FE 56 FE 44 02 0E 02 14 FF E8 FF 46 FF B4 FE F6 01 64 00 C2 FC D2 03 84 00 84 FC BC FD E8 01 5E 04 66 FD B6 FE 62 00 60 FF C6 01 6E 00 50 FE AA FE AC 01 3C 02 2C FC E8 00 16 01 3E 00 38 00 EC FF 26 FF 40 00 26 01 30 00 22 00 20 FF 74 FE 9C 01 A8 01 16 FF A8 FD EE FF 84 01 E0 FE 9C 00 64 FF A4 00 7A 01 96 FE BC FF 44 00 86 FF E0 FE F8 01 8A FF 22 FF 00 02 12 00 5A FE 70 00 18 00 B0 FE D6 01 B6 FE 1A FF E6 02 6E FE 22
```
Одна тысяча сообщений ровно.
Файл для всех потоков:
```
052234: Jan 19 12:15:02.576: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 00 00 08 00 38 00 78 00 B8 00 18 00 18 FF F8 FF C8 FF F8 FF E8 FF B8 FF 58 00 08 FF 98 FF A8 00 58 00 48 00 08 FF 88 FF C8 00 28 00 48 00 68 00 98 00 68 00 A8 00 B8 00 18 FF 98 FF 68 FF C8 FF A8 FF 88 FF 78 FF 58 00 38 FF C8 FF 78 00 48 00 48 00 38 00 88 01 78 00 78 FF D8 00 38 FF A8 FF 78 FF E8 00 28 FF A8 FF 98 00 88 00 A8 00 18 FF 88 FF E8 00 78 FF E8 FF B8 00 58 00 58 FF 48 FF C8 00 48 00 08 FF C8 00 38 00 78 FF D8 00 28 00 68 00 18 FF B8 FF 78 FF C8 00 68 00 38 FF D8 FF A8
```
[...]
```
055211: Jan 19 12:15:12.516: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 01 FF A8 01 28 FE 28 00 18 FF 78 FE E8 01 A8 00 08 02 10 00 48 FE C8 00 28 00 98 00 38 FF 68 FF 18 FE C8 00 A8 FF 68 01 98 00 08 FF C8 01 18 00 B8 FF E8 FF 08 FF F8 FE 18 00 28 FF 68 FE F8 00 E8 00 78 00 F8 00 78 FE E8 00 78 FE D8 00 48 01 A8 00 E8 00 B8 FF F8 FF C8 FF 58 FF 08 00 C8 FF B8 FF 58 01 D8 FE 78 00 08 FF 38 FE 28 FF E8 00 C8 FF 88 01 48 00 D8 00 68 00 08 FF 68 FF D8 00 68 FF B8 FF 58 00 78 00 08 00 68 FF A8 01 18 FE 58 00 18 00 28 FF E8 00 F8 00 28 01 08 00 B8 FE E8
055212: Jan 19 12:15:12.520: len=172, ch_id=1, pak_id=143, proc_id=0, <== Payload: 00 07 00 02 FF AC 01
055234: Jan 19 12:15:32.851: %ISDN-6-DISCONNECT: Interface Serial0/3/0:0 disconnected from 2606699 , call lasted 372 seconds
```
Тут картина несколько отличается. Очевидно, что для трех потоков сообщений будет в три раза больше, чем для одного. Однако во взятом для примера логе полных сообщений всего-навсего 2978 штук, плюс одно обрезанное в самом конце. Некоторые источники указывают на то, что в случаях, когда диагностические сообщения поступают в буфер быстрее, чем маршрутизатор может выводить их в лог, некоторые сообщения могу теряться целиком или частично.
Можно обратить внимание, что в каждом сообщении данные начинаются одной и той же последовательностью байтов (R\_in: 00 07 00 00, S\_in: 00 07 00 01, S\_out: 00 07 00 02; файл для всех потоков содержит сообщения со всеми указанными последовательностями).
Очевидно, эти четыре байта представляют собой некий служебный заголовок, который при рассмотрении можно смело не принимать в расчет, поскольку он просто указывает на поток, которому принадлежит сообщение. Данное предположение неплохо согласуется с тем, что для десятисекундного интервала в лог попадает тысяча сообщений со 160 байтами полезной информации каждое, то есть 160000 байтов полезной информации. При частоте дискретизации 8000 Герц, временном интервале 10 секунд и при глубине дискретизации 16 бит для одного звукового канала (моно) получается именно такой объем данных.
### Первая грубая обработка
При помощи текстового редактора, поддерживающего регулярные выржения, и регулярного выражения (......:).\*(<== Payload: 00 07 00 01 ) удаляю строки (050234: Jan 19 12:12:58.636: len=172, ch\_id=1, pak\_id=143, proc\_id=0, <== Payload: 00 07 00 01 ) из соответствующего файла. Происходит ровно 1000 замен. После преобразования ASCII данных в двоичные в шестнадцатеричном редакторе (вставка в файл буфера ASCII-HEX) получаем файл размером ровно 160000 байтов.
Необходимо отметить, что при этом происходит следующее. В лог маршрутизатора данные попадают в том же порядке, в котором они хранятся в его памяти (порядок big-endian). То есть, например, значение 0x1234 хранится в двух последовательных ячейках: 12 34. В таком виде мы и копируем текст в буфер, в том же порядке байты попадают в двоичный файл.
Посмею напомнить читателю, что в памяти персональных компьютеров с x86-процессорами принят порядок записи от младшего байта к старшему (англ. little-endian, дословно: «остроконечный»), в связи с чем иногда его называют интеловский порядок (по названию фирмы-создателя архитектуры x86).
В то же время стандартным для протоколов TCP/IP является байтовый порядок от старшего к младшему (англ. big-endian, дословно: «тупоконечный»). Он используется в заголовках пакетов данных и во многих протоколах более высокого уровня, разработанных для использования поверх TCP/IP. Поэтому порядок байтов от старшего к младшему часто называют сетевым порядком байтов (англ. network byte order). Этот порядок байтов используется не только процессорами IBM 360/370/390, Motorola 68000, SPARC (отсюда третье название — порядок байтов Motorola, Motorola byte order), но и процессорами некоторых маршрутизаторов Cisco.
Далее производится импорт полученного RAW-файл в аудиоредактор. В итоге удается получить корректный звуковой файл при указании следующих параметров: Signed 16 bit, Big-endian, 1 канал (моно), частота 8000 Гц.
Все слышно!
Это, безусловно, первый маленький успех. Его следует развить — попробовать разобраться со структурой .DAT файла, после чего всяк желающий сможет написать на своем любимом языке программирования собственную программу, которая будет извлекать из данного файла звук.
При ближайшем рассмотрении файла обнаружил, что в файле также чередуются последовательности 00 07 00 0X, смещенные на F4 байтов друг относительно друга. Двухбайтовое слово со значением 00 F4 (big-endian, не забываем это) присутствует во всех случаях со смещением -0x0E относительно последовательности 00 07 00 0X. Можно предположить, что оно относится к заголовку пакета данных и указывает размер текущего пакета (смещение заголовка следующего пакета по отношению к заголовку текущего пакета).
Рассмотрев последний голосовой пакет в файле, можно заметить, что за F4 байтов от конца файла присутствует последовательность 00 00 00 00. Предположим, что она обозначает начало пакета. Таким образом, слово со значением 00 F4 находится по смещению 0x42 от начала голосового пакета. В то же время для каждого голосового пакета в файле между последовательностями 00 07 00 0X и 00 00 00 00 помещается ровно 0xA0, то есть 160 байтов информации, что неплохо согласуется с зависимостями, установленными в ходе анализа текстового лога. Можно предположить, что это 160 байт полезной нагрузки — голосовых данных. На иллюстрациях я выделяю данные байты пурпурным цветом, дабы указать на их важность.
Проанализируем заголовки:
Голубым выделено предполагаемое положение идентификаторов len, ch\_id, pak\_id, proc\_id (Вспомним текстовый лог: 792308: Jan 22 16:30:42.458: len=172, ch\_id=1, pak\_id=143, proc\_id=0, <== Payload:), оранжевое значение в проанализированных пакетах совпадает с ch\_id.
Значение 172=0xAC, расположенное по смещению 0x48, соответствует размеру порции данных начиная от этого смещения и до конца пакета.
Однако у нас остается не идентифицированный массив байтов, содержащих служебную информацию, в самом начале файла. Необходимо выявить закономерности, иначе решение нельзя считать приемлемым.
Обнаруживаются две завершающиеся нулем строки, содержащие текстовую информацию о маршрутизаторе (на рисунке выделены желто-зеленым цветом):
1) текст 28.3.14 (соответствует DSPWARE VERSION из вывода команды show voice dsp detail) находится со смещением 0x5С от начала файла;
2) текст C2800NM-ADVENTERPRISEK9-M, 15.1(4)M10, IP|SLA|IPv6|IS-IS|FIREWALL|VOICE|PLUS |QoS|HA|NAT|MPLS|VPN|LE) находится со смещением 0xC0 от начала файла.
Можно также попытаться отыскать в данном файле какие-то частные значения, относящиеся к конкретному маршрутизатору (типа MAC'ов и серийных номеров) или пакету (CRC). Пока же не следует углубляться в изыскания, поскольку эти данные для нас особого интереса не представляют.
По смещению 0x42 в файле содержится слово 01 24, а по смещению 0x0124 начинается первый голосовой пакет. Это могло бы быть совпадением, однако проверка на ряде файлов позволяет сделать вывод, что закономерность подтверждается для всех файлов и пакетов в них. Это соблюдается и для неизвестного назначения и содержания пакетов, явно не содержащих голос.
Итак, структура голосового пакета:
```
packet_sign [0x00] 0x04 байта всегда 00 00 00 00
UNKNOWN [0x04] 0x3E байтов
packet_size [0x42] 0x02 байта
UNKNOWN [0x44] 0x04 байта всегда 00 00 00 00
len [0x48] 0x02 байта
ch_id [0x4A] 0x02 байта
pak_id [0x4C] 0x02 байта
proc_id [0x4E] 0x02 байта
UNKNOWN [0x50] 0x02 байта всегда 00 07
stream_id [0x52] 0x02 байта R_in 00 00
S_in 00 01
S_out 00 02
raw_data [0x54] 0xA0 байтов
```
Вооружившись изложенным, всяк желающий может самостоятельно на своем любимом языке программирования написать программу, формирующую из DAT-файла файлы, содержащие голос — хоть RAW для последующего импорта в аудиоредактор и обработки, хоть сразу WAV.
### Итог
Разумеется, это лишь частное решение, не претендующее на полноту. Например, при использовании кодеков, отличных от G.711, идентифицировать и распаковать звуковые данные будет существенно сложнее. Наверняка проявятся и другие побочные эффекты. По этим причинам я не публикую код, при помощи которого достигалась автоматизация обработки входных данных.
Данные предположения позволили без проблем разделить по каналам файл с данными PCM, полученный на диалпире и содержащий несколько одновременных разговоров с различными ch\_id. Благодаря этому удалось отследить и идентифицировать проблемный DTMF, который был всему причиной.
К тому же маршрутизатору, как выяснилось, был подключен по SIP китайский GSM-шлюз. Абоненты АТС слышали тоны только при звонках через данный шлюз. Удалось выявить, что шлюз, на котором включен RFC2833, передает странные (не вполне понятно, откуда они берутся — то ли генерируются самим шлюзом, то ли приходят из сети оператора, но точно не от удаленного абонента) пакеты, которые маршрутизатор (на котором, в свою очередь, тоже включен RFC2833) воспринимает как RTP NTE, после чего отправляет в поток полноценный тон, который слышат абоненты АТС и для обнаружения которого были проделаны все те манипуляции, которые легли в основу данного материала.
Поскольку шлюз в силу своей предельной дешевизны не позволяет выполнять сбор отладочной информации и установить степень его вины не представлялось возможным, было на всякий случай произведено обновление прошивки шлюза до актуальной версии. Это не помогло, сигнал продолжал появляться. Далее было произведено переключение шлюза в режим SIP INFO (на маршрутизаторах Cisco ISR данный режим всегда включен). Пока жалобы отсутствуют. | https://habr.com/ru/post/322856/ | null | ru | null |
# PHP-Дайджест № 145 (26 ноября – 10 декабря 2018)
[](https://habr.com/post/432600/)
Свежая подборка со ссылками на новости и материалы. В выпуске: PHP 7.3.0, Symfony 4.2, Composer 1.8.0 и другие релизы, конец поддержки PHP 5.6 и PHP 7.0, свежие предложения из PHP Internals, порция полезных инструментов, видеозаписи докладов и многое другое.
Приятного чтения!
> Короткая аудиоверсия дайджеста в подкасте [Пятиминутка PHP Выпуск №44](https://5minphp.ru/episode44/)
### Новости и релизы
* [PHP 7.3.0](http://php.net/releases/7_3_0.php) — Долгожданный мажорный релиз PHP доставлен строго по расписанию. Спасибо всем контрибьюторам и релиз-менеджерам за проделанную работу! В свежей версии интерпретатора ряд улучшений:
• Улучшения Heredoc и Nowdoc синтаксиса [RFC](https://wiki.php.net/rfc/flexible_heredoc_nowdoc_syntaxes)
• Функции `json_encode()` и `json_decode()` будут бросать исключение в случае ошибки и наличия соответствующего флага [RFC](https://wiki.php.net/rfc/json_throw_on_error)
• Возможность использовать запятую после последнего аргумента функции [RFC](https://wiki.php.net/rfc/trailing-comma-function-calls)
• Добавлены функции `array_key_first()` и `array_key_last()` [RFC](https://wiki.php.net/rfc/array_key_first_last)
• Новая функция hrtime(), которая возвращает время высокой точности и не зависит от системного времени [PR](https://github.com/php/php-src/pull/2976)
• Добавлена функция `is_countable()` для проверки на перечислимость [RFC](https://wiki.php.net/rfc/is-countable)
• Использование ссылок в `list()` [RFC](https://wiki.php.net/rfc/list_reference_assignment)
• Значительное улучшение сборщика мусора улучшает работу с больши́м количеством объектов [PR](https://github.com/php/php-src/pull/3165)
• Движок регулярных выражений обновлен до PCRE2 [RFC](https://wiki.php.net/rfc/pcre2-migration)
Полный список изменений в документе [UPGRADING](https://github.com/php/php-src/blob/php-7.3.0/UPGRADING).
Очень рекомендую посмотреть руководство по [миграции с PHP 7.2.x на PHP 7.3.x](http://docs.php.net/manual/ru/migration73.php), спасибо [lex111](https://habr.com/users/lex111/) за перевод.
* Свет также увидели обновления [PHP 5.6.39](http://php.net/archive/2018.php#id2018-12-06-2), [PHP 7.0.33](http://php.net/archive/2018.php#id2018-12-06-5), [PHP 7.1.25](http://php.net/archive/2018.php#id2018-12-06-4) и [PHP 7.2.13](http://php.net/archive/2018.php#id2018-12-06-3). И это **последние релизы веток 5.6 и 7.0**, а **PHP 7.1 переходит в режим поддержки безопасности**. Таким образом, на данный момент актуальными остаются только ветки PHP 7.2 и PHP 7.3.
* [PHP на AWS Lambda](https://aws.amazon.com/blogs/aws/new-for-aws-lambda-use-any-programming-language-and-share-common-components/) — На конференции AWS re:Invent 2018, кроме всего прочего, анонсирована поддержка кастомных рантаймов для AWS Lambda. PHP из коробки поддерживается через [stackery/php-lambda-layer](https://github.com/stackery/php-lambda-layer), но можно сделать и свою реализацию. Это значит, что вместо [костылей](https://medium.com/@stephenheron/serverless-php-9da3f00df5de) в виде запуска через Nodejs или Go, теперь можно писать полноценные лямбды на чистом PHP.
* [Composer 1.8.0](https://github.com/composer/composer/releases/tag/1.8.0)
* [CakePHP 3.7.0](https://bakery.cakephp.org/2018/12/08/cakephp_370_released.html)
* [PHPUnit 7.5.0](https://github.com/sebastianbergmann/phpunit/blob/7.5.0/ChangeLog-7.5.md#750---2018-12-07)
### PHP Internals
* [[RFC] FFI — Foreign Function Interface](https://wiki.php.net/rfc/ffi) — [Концепт](https://github.com/dstogov/php-ffi) от Дмитрия Стогова теперь оформлен в виде полноценного предложения. Реализация даст возможность использовать функции и структуры данных из C-модулей напрямую. В качестве примера можно посмотреть на [PHP-биндинг для TensorFlow](https://github.com/dstogov/php-tensorflow). Большие возможности, правда, открывают и широкий простор для потенциальных проблем и уязвимостей, поэтому предлагается по умолчанию разрешить FFI только в CLI-скриптах и предзагруженных файлах.
* [[RFC] Covariant Returns and Contravariant Parameters](https://wiki.php.net/rfc/covariant-returns-and-contravariant-parameters) — Предлагается сделать более консистентным типы, в частности, разрешить «сужать» тип возвращаемого значения в наследниках, и «расширять» тип параметров. **Скрытый текст**
```
interface X {
function m(Y $z): X;
}
interface Y extends X {
// Тут можно будет сужать тип
function m(X $z): Y;
}
interface Concatable {
function concat(Iterator $input);
}
class Collection implements Concatable {
// А тут можно будет расширять тип
function concat(iterable $input) {/* . . . */}
}
```
### Инструменты
* [spatie/period](https://github.com/spatie/period) — Библиотека позволяет делать сложные сравнения дат, например, найти пересечения периодов, разницу, пробелы, крайние границы и прочее.
* [scrivo/highlight.php](https://github.com/scrivo/highlight.php) — Порт [highlight.js](https://highlightjs.org/), который позволяет подсвечивать синтаксис на сервере. Интеграция с markdown через [spatie/commonmark-highlighter](https://github.com/spatie/commonmark-highlighter).
* [3v4l.org/live](https://3v4l.org/live) — Интерактивный онлайн PHP шелл (REPL).
* [j6s/phparch](https://github.com/j6s/phparch) — Библиотека для архитектурного тестирования PHP-проектов, вдохновленная archlint (C#) и archunit (Java). Разработка в процессе.
* [halaxa/json-machine](https://github.com/halaxa/json-machine) — Потоковое чтение (декодирование) JSON. Для потокового кодирования подойдет [violet-php/streaming-json-encoder](https://github.com/violet-php/streaming-json-encoder).
* [DivineOmega/password\_exposed](https://github.com/DivineOmega/password_exposed) — Проверяет с помощью [haveibeenpwned.com](https://haveibeenpwned.com) API был пароль скомпрометирован.
* [skollro/alexa-php-sdk](https://github.com/skollro/alexa-php-sdk) — SDK для разработки скилов для Amazon Alexa на PHP.
* [pyrech/composer-changelogs](https://github.com/pyrech/composer-changelogs) — В удобном виде выводит информацию об обновленных пакетах после выполнения `composer update`.
* [RubixML/RubixML](https://github.com/RubixML/RubixML) — Библиотека для применения машинного обучения на PHP. Альтернатива [php-ai/php-ml](https://github.com/php-ai/php-ml).
### Материалы для обучения
* ##### Symfony
+ [Symfony 4.2.0](https://symfony.com/blog/symfony-4-2-0-released) — Список наиболее интересных изменений [тут](https://symfony.com/blog/symfony-4-2-curated-new-features).
+ [Неделя Symfony #623 (3-9 декабря 2018)](https://symfony.com/blog/a-week-of-symfony-623-3-9-december-2018)
+ [Неделя Symfony #622 (26 ноября — 2 декабря 2018)](https://symfony.com/blog/a-week-of-symfony-622-26-november-2-december-2018)
+ [EasyCorp/EasyAdminBundle 2.0.0](https://github.com/EasyCorp/EasyAdminBundle/releases/tag/v2.0.0)
+ [Лучшие плагины PhpStorm для разработки на Symfony](https://blog.martinhujer.cz/best-phpstorm-plugins-for-symfony-development/)
+ [Как управлять конфигурацией в Symfony](https://www.tomasvotruba.cz/blog/2018/11/29/how-to-manage-configuration-in-symfony-without-bundle-extension-and-configuraiton/) не используя классы Bundle, Extension и Configuration.
+  [Пятиминутка PHP Выпуск №43](https://5minphp.ru/episode43/) — Репортаж с SymfonyCon: Using Symfony Forms with Rich Domain Models.
* ##### Yii
+ [cebe/yii2-openapi](https://github.com/cebe/yii2-openapi) — Генератор REST API для Yii2 на основе спецификации OpenAPI 3.0.
* ##### Laravel
+ [beyondcode/laravel-websockets](https://github.com/beyondcode/laravel-websockets) — WebSocket сервер для Laravel на базе [Ratchet](https://github.com/ratchetphp/Ratchet). Позволяет реализовать всякого рода приложения реального времени, без необходимости использовать Pusher. Есть [демоприложение](https://github.com/beyondcode/laravel-websockets-demo). Подробнее в [анонсе инструмента](https://murze.be/introducing-laravel-websockets-an-easy-to-use-websocket-server-implemented-in-php), [документации](https://docs.beyondco.de/laravel-websockets/) или коротко в [видеообзоре](https://www.youtube.com/watch?time_continue=3&v=GtphrhnFwZQ).
+ [qcod/laravel-gamify](https://github.com/qcod/laravel-gamify) — Пакет для добавления элементов игрофикации в виде очков и бейджей в Laravel-приложение. Также есть автономный движок игрофикации на базе Symfony [sveneisenschmidt/yay](https://github.com/sveneisenschmidt/yay).
+ [spatie/laravel-collection-macros](https://github.com/spatie/laravel-collection-macros) — Набор полезных макросов для коллекций Laravel.
+ [Делаем резервные копии базы данных Laravel на Google Drive](https://medium.com/@dennissmink/laravel-backup-database-to-your-google-drive-f4728a2b74bd)
+  [Быстрые подсказки по производительности в Laravel](https://www.youtube.com/playlist?list=PL1TrjkMQ8UbWRZ4tv4GW_KwbyavOxt6bc)
* ##### Async PHP
+ [friends-of-reactphp/mysql](https://github.com/friends-of-reactphp/mysql) — Асинхронный клиент для MySQL на ReactPHP. Пост в поддержку релиза о добавленных [ленивых соединениях](https://www.lueck.tv/2018/introducing-reactphp-mysql-lazy-connections).
+ [walkor/shadowsocks-php](https://github.com/walkor/shadowsocks-php) — Еще один SOCKS5 прокси, клон популярного [shadowsocks](https://github.com/shadowsocks/shadowsocks) на базе асинхронного движка [Workerman](https://github.com/walkor/Workerman).
+ [Корутины в PHP на Swoole 4.x vs корутины Golang](https://www.swoole.co.uk/article/coroutine-swoole-vs-golang)
* ##### CMS
+ [WordPress 5.0 “Bebo”](https://wordpress.org/news/2018/12/bebo/) — В релизе новый редактор [Guttenberg](https://wordpress.org/gutenberg/) и новая тема Twenty Nineteen. Старый редактор доступен в плагине [Сlassic Editor](https://wordpress.org/plugins/classic-editor/) и будет поддерживаться до конца 2021.
+ WordPress наконец-то обновит PHP! В апреле минимальная версия [будет повышена](https://twitter.com/miss_jwo/status/1071540985702825991) до 5.6, а к концу [2019 года](https://twitter.com/miss_jwo/status/1071556243406376960) – до PHP 7 (вероятно 7.2).
+ [Magento Tech Digest #38: Nov 26 – Dec 03, 2018](https://www.maxpronko.com/magento-tech-digest-38-nov-26-dec-03-2018/)
+  [Релиз платформы Magento 2.3.0 GA](https://habr.com/post/431480/)
+  [Magento Meetup Kharkiv №4 — видео докладов](https://habr.com/post/432090/)
+  [Система управления складом с использованием CQRS и Event Sourcing (Magento)](https://habr.com/post/431924/)
* ##### Security
+ [ajinabraham/CMSScan](https://github.com/ajinabraham/CMSScan) — Сканер уязвимостей в популярных CMS Wordpress, Drupal, Joomla, vBulletin. Обертка над [wpscan](https://github.com/wpscanteam/wpscan), [droopescan](https://github.com/droope/droopescan), [vbscan](https://github.com/rezasp/vbscan), [joomscan](https://github.com/rezasp/joomscan).
+ [PHP Security Advent Calendar 2018](https://www.ripstech.com/php-security-calendar-2018/) — В течение всего декабря каждый день публикуется интересная информация об уязвимостях в плагинах WordPress.
+  [Уязвимости в PHP и PHPMailer](http://www.opennet.ru/opennews/art.shtml?num=49746)
+ [Slice Of PIE #01](https://paragonie.com/blog/2018/11/slice-pie-01) — Ответы на вопросы по безопасности от ParagonIE.
+ Пара уязвимостей в Symfony: [CVE-2018-19789](https://symfony.com/blog/cve-2018-19789-disclosure-of-uploaded-files-full-path) (раскрытие пути загруженных файлов), [CVE-2018-19790](https://symfony.com/blog/cve-2018-19790-open-redirect-vulnerability-when-using-security-http) (уязвимость редиректа в Security\Http)
+ [Ад зависимостей NPM: сравнение с Symfony, Laravel и API Platform](https://dunglas.fr/2018/11/about-the-dependencies-of-symfony/) — Анализ мейнтейнеров зависимостей популярных PHP фреймворков после того, как в популярной JS-библиотеке [event-stream](https://github.com/dominictarr/event-stream) был [обнаружен вредоносный код](https://github.com/dominictarr/event-stream/issues/116).
* [Конфигурируем генерацию кода в PhpStorm](https://murze.be/configuring-phpstorms-code-generation)
* [14 вредных советов](https://www.tomasvotruba.cz/blog/2018/11/26/14-tips-to-write-php-code-that-is-hard-to-maintain-and-upgrade/) о том, как писать плохо читаемый и неподдерживаемый код на PHP
* [Мигрируем на password\_verify](https://akrabat.com/migrating-to-password_verify/) и обновляем хеши паролей в существующей БД.
* [создания исключений на лету](https://mwop.net/blog/2018-12-05-on-the-fly-exceptions.html) — Использование анонимных классов для
*  [Как выруливать с legacy code, когда проект нужно было на вчера](https://habr.com/post/431562/)
*  [На-click-ать известность, или как взбудоражить робота и … остальных](https://habr.com/post/432038/)
### Аудио и видеоматериалы
*  [Пятиминутка PHP Выпуск №44](https://5minphp.ru/episode44/) — Аудиоверсия этого выпуска PHP-Дайджеста.
*  [Пятиминутка PHP Выпуск №42](https://5minphp.ru/episode42/) — MySQL 8 и caching\_sha2\_password
* [Подкаст PHP Roundtable #81](https://www.phproundtable.com/episode/php-fig-3-0) — О PHP-FIG 3.0, PSR-18 и другом.
### Занимательное
* [MagicalTux/goro](https://github.com/MagicalTux/goro) — Попытка реализовать PHP на Go.
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:[email protected]) или в [твиттер](https://twitter.com/pronskiy).
Больше новостей и комментариев в телеграм-канале **[PHP Digest](https://t.me/phpdigest)**.
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 144](https://habr.com/post/431042/) | https://habr.com/ru/post/432600/ | null | ru | null |
# Тренировка кислотного аккумулятора кое-как и своими руками
Печаль. Сдох аккумулятор, незаслуженно забытый зимой в гараже. Я его вынул из мотоцикла, то ли сигнализация сожрала всё, то ли не зарядился в прошлые покатушки. Напряжометр показывал 9В, что есть криминал.
Я принёс батарею домой, отогрел, подключил к заряднику. Зарядник через полчаса показал ОК. Врал. Ничего там не ок. Лампочка ближнего света горела примерно 10 минут и потом быстро перешла в состояние «слабо грею воздух». Аккумулятор 6Ач, лампочка 55Вт.
Не покупать же новый аккумулятор? Зима, время есть. Есть ардуина даже и коробка всяких чипсов из Китая. Зря пылятся там что ли?
В далёкой советской армии 30 лет назад я проходил курс ухода за аккумуляторами. Основное отличие его от инструкций 21 века было таким: батарея должна проходить серию циклов заряда и разряда. Без этого, сколько её в заряднике не держи, какой бы он ни был умный, она сдохнет.
Теория процесса нагугливается легко. Практически же надо разрядить небольшим током в несколько ампер до 10.8В, а потом зарядить до упора. И так несколько раз. Смотреть на лампочку быстро наскучило и я нарисовал схему прибора.
Так как я не профессиональный реаниматор батареек, я собрал всё кое-как. Ну, как положено любителю ардуины.
Так как я оказался в этой ситуации не один, я оформил [проект на гитхабе](https://github.com/nw-wind/BatteryTrainer), чтобы другие тоже могли пользоваться, и даже положил туда красивую схему, нарисовав её в [easyeda.com](http://easyeda.com)
Аналоговые ноги считывали напряжение и ток, потенциометр делил напряжение аккумулятора примерно на три. При падении напряжения ниже 10.8В включался заряд, при превышении 14.5В разряд. И так три раза. Потом батарея заряжалась и разряд уже не включался.
```
#define POWERPIN 0
#define AMPERPIN 1
#define LIMIT 10.8f
#define UPLIMIT 14.5f
```
Запускался процесс кнопкой или автоматически после полного заряда. Самый дохлый из аккумуляторов заряжаться не хотел до упора и только зря грелся. Я его пинал кнопкой несколько раз, потом процесс пошёл.
Был в коробке амперметр, я применил его для подсчёта ёмкости батарейки при разряде. В процессе цикла в терминале было видно:
* Текущий заряд в Ач.
* Текущий разряд в Ач.
* Ток в А.
* Напряжение в В.
При переключении режима, соответственно было видно конечная величина Ач для предыдущего процесса. Так же выводилось время, затраченное на цикл.
**Собственно программуля копипастом из гитхаба**
```
/*
** Реле на пин 2
** Кнопка на пин 3
** Меряем напряжение на аналоговом пине 0
** Амперметр на аралоговый порт 1
** Переключаем на заряд при напряжении 10.8В
** Не хотим работать при напряжении меньше 5В
**
** При включении работает зарядка.
** Кнопка переключает режим заряд/разряд.
** Разряд завершается при достижении 10.8B и начинается заряд.
*/
/*
Todo:
Считать время заряда и разряда.
Если лампа перегорает -- на зарядку.
*/
#define RELAYPIN 2
#define BUTTONPIN 3
#define POWERPIN 0
#define AMPERPIN 1
#define LIMIT 10.8f
#define UPLIMIT 14.5f
#define BADPOWER 5.0f
#define CIRCLES 3
#define SWITCH_LAMP 0
#define SWITCH_CHARGER 1
// Секунд на вывод инфы
#define TICKS (60*5)
void setup() {
pinMode(RELAYPIN, OUTPUT);
pinMode(BUTTONPIN, INPUT_PULLUP);
digitalWrite(RELAYPIN, HIGH);
Serial.begin(9600);
Serial.println("Start...");
}
int mode = SWITCH_CHARGER;
int pressed = 0;
int tick = 0;
unsigned long start = 0;
int circle = 1;
float chargeAh = 0.0;
unsigned long chargeMs = 0;
float dischargeAh = 0.0;
unsigned long dischargeMs = 0;
void loop() {
// Закончили
if (circle > CIRCLES) return;
// Проверяем напряжение.
float v = analogRead(POWERPIN) / 1023.0f * 3.0f * 5.0f;
// Измеряем ток
float a = ((analogRead(AMPERPIN) * (5.0 / 1024.0)) - 2.5) / 0.1;
// Заряжаем, если что-то не так с зарядкой.
if (v > BADPOWER) {
// Идёт зарядка, ожидаем кнопку.
if (mode == SWITCH_CHARGER) {
chargeAh += a * (millis() - chargeMs) / 3600000.0;
chargeMs = millis();
if (digitalRead(BUTTONPIN) == LOW || v > UPLIMIT && circle <= CIRCLES) {
mode = SWITCH_LAMP;
digitalWrite(RELAYPIN, LOW); // Переключаем на лампочку.
dischargeMs = millis();
Serial.print("Try "); Serial.println(circle);
Serial.print("Charge was "); Serial.print(chargeAh); Serial.println("Ah");
dischargeAh = 0.0;
Serial.println("LETS LIGHT!");
delay(100);
pressed = 1;
circle++;
if (circle > CIRCLES) Serial.println("Thats enough!");
}
}
// Идёт разряд, ожидаем падение напряжения.
if (mode == SWITCH_LAMP) {
dischargeAh += a * (millis() - dischargeMs) / 3600000.0;
dischargeMs = millis();
// Достигли дна по напряжению.
if (v < LIMIT) {
mode = SWITCH_CHARGER;
digitalWrite(RELAYPIN, HIGH); // Переключаем на зарядник.
start = millis();
Serial.println("TIME TO SUCK ELECTRICITY!");
unsigned long msec = millis() - start;
Serial.print("Discharge time ");
Serial.print(msec / 3600000); Serial.print("h ");
Serial.print((msec % 3600000) / 60000); Serial.print("m ");
Serial.print((msec % 60000) / 1000); Serial.print("s ");
Serial.println();
Serial.print("Appoximate capacity "); Serial.print(55 / 12);
Serial.println("Ah");
Serial.print("Disharge was "); Serial.print(dischargeAh); Serial.println("Ah");
chargeAh = 0.0;
}
// Переключить на зарядку принудительно.
if (pressed == 0 && digitalRead(BUTTONPIN) == LOW) {
mode = SWITCH_CHARGER;
digitalWrite(RELAYPIN, HIGH); // Переключаем на зарядник.
chargeMs = millis();
Serial.println("SUCK THE ELECTRICITY!");
Serial.print("Disharge was "); Serial.print(-dischargeAh); Serial.println("Ah");
chargeAh = 0.0;
if (circle > CIRCLES) Serial.println("LAST CHARGING!");
delay(100);
}
}
} else {
Serial.println("BAD POWER!");
}
if (tick == 0) {
Serial.print(" Disharge = "); Serial.print(-dischargeAh);
Serial.print(" Charge = "); Serial.print(chargeAh);
Serial.print(" Current = "); Serial.print(a);
Serial.print(" Voltage = "); Serial.println(v);
}
pressed = 0;
tick = ++tick % TICKS;
delay(1000); // Не спешим
}
```
Всякие дисплеи я не прикручивал, наблюдал за процессом с терминала через usb/serial.
В итоге, оба аккумулятора ожили и показали приличные амперчасы примерно соответствующие своим номиналам, что было даже удивительно для их возраста. | https://habr.com/ru/post/319414/ | null | ru | null |
# Использование распараллеливания при обработке данных в C#
Всем добрый день! Я технический специалист, работающий в системе внутреннего аудита, в мои обязанности входит создание инструментов ETL на языке программирования C#.
Периодически источниками данных становятся жестко структурированные файлы формата xml, csv, json или любого другого формата. Иногда их количество становится достаточно большим и постоянно увеличивающимся. Например, в одной из моих задач количество файлов увеличивалось со средней скоростью обновления примерно 150 000 файлов в сутки. Если при этом обработка одного файла (считывание массива байт с жесткого диска в память, трансформация загруженных данных и запись их в базу данных) занимает секунду, то становится понятно, что обработка всех файлов займет более 40 часов. В этом случае мы не сможем обработать эти файлы до конца, так как скорость увеличения количества файлов будет явно выше скорости их обработки.
Одно из решений данной проблемы – разработать приложение, в котором создать пул независимых друг от друга потоков. В потоках будут обрабатываться файлы, выбираемые из общей очереди. Однако в этом случае возникают сложности с синхронизацией работающих потоков и совместного использования ресурсов, так как очень вероятно появление взаимных блокировок.
Что бы избежать этих сложностей компания Microsoft добавила в фреймоворк .Net библиотеку TPL (начиная с версии 4.0). Я расскажу, как используя возможности этой библиотеки решить данную проблему.
Итак, изначально алгоритм работы выглядит следующим образом:
Сканируется каталог хранения файлов и возвращается список (например, List), содержащий данные о всех файлах;
Запускается цикл (for или foreach) в котором данные из очередного файла считываются в память, при необходимости трансформируются и записываются в БД.
Очевидно, что самые затратные по времени операции – это считывание данных с жесткого диска в память и запись данных из памяти в БД.
Попробуем оптимизировать наш алгоритм при помощи библиотеки TPL:
Пункт 1.
Изменим список, возвращаемый функцией сканирования каталога хранения файлов с List на ConcurrentQueue.
Для чего мы это делаем? Дело в том, что класс ConcurrentQueue является потокобезопасным, то есть если одновременно два потока попытаются извлечь данные из этого списка или записать в него данные, то у нас не возникнет исключений (Exception).
Пункт 1 нашего алгоритма будет выглядеть так: сканируется каталог хранения файлов и возвращается список ConcurrentQueue, содержащий данные о всех файлах.
Пункт 2:
Изменим конструкцию формирующую цикл обработки данных из файла. Заменим for на Parallel.For или Parallel.ForEach.
В чем отличие новой конструкции от for? Тут всё просто и в принципе понятно из названия языковой конструкции. Все итерации цикла выполняются в параллельных потоках. В качестве примера я покажу организацию цикла конструкцией Parallel.ForEach:
```
Parallel.ForEach(listFiles, (currentFile) =>
{
var dataFile = getDataFile(currentFile.FullName);
TransformData(dataFile);
WriteToDB(dataFile);
});
```
где:
listFiles – это коллекция типа ConcurrentQueue содержащая спи-сок файлов в каталоге;
currentFile – элемент коллекции listFiles, который возвращается конструк-цией ForEach;
dataFile – условная некоторая структура данных в памяти, получаемая счи-тыванием содержимого файла в память;
getDataFile – условная функция возвращающая содержимое файла в виде некоторой структуры данных;
TransformData – условная процедура трансформации полученных данных;
WriteToDB – условная процедура записи данных в БД.
В данном примере, с помощью конструкции Parallel.ForEach, мы организуем цикл. В этом цикле, в параллельных потоках, производится считывание данных с жесткого диска, их трансформация и запись в БД. При этом, проблемы организации работы параллельных потоков отсутствуют. Количество параллельных потоков зависит от числа ядер процессора и их загруженности.
Используя предложенный алгоритм, мы ускорим обработку файлов, как минимум в 2 раза. Хотя, конечно, эта цифра будет меняться в зависимости от количества ядер и памяти машины, на которой будет запускаться программа.
Так же для ускорения работы программы нужно вынести запись в БД в отдельный поток, работающий независимо от основного. Сделать это можно при помощи коллекции ConcurrentQueue, чтобы избежать конфликтов при добавлении данных в оче-редь.
Перепишем вышеприведенный пример с учетом оптимизации записи в БД.
Предположим, что процедура чтения файлов возвращает нам данные в DataTable):
```
Parallel.ForEach(listFiles, (currentFile) =>
{
DataTable dataFile = getDataFile(currentFile.FullName);
TransformData(dataFile);
threadWriteToDB.ListData.Enqueue(dataFile);
});
```
Как видно, вместо строки с вызовом процедуры записи в БД, мы просто добавляем в коллекцию ConcurrentQueue ListData описанную и инициализированную в отдельном потоке, экземпляр которого threadWriteToDB используется в нашем цикле.
Запись в БД происходит уже в отдельном потоке. Запись в БД можно организовать аналогично работе с файлами, с помощью конструкций Parallel.For и/или Paral-lel.Foreach.
В моей задаче, где потребовалась обработка сопоставимого количества файлов, сейчас может обрабатываться в среднем от 200 000 до 400 000 файлов в сутки, при чем скорость ограничивается загрузкой БД и шириной канала данных. | https://habr.com/ru/post/502868/ | null | ru | null |
# Неочевидные факты о коллекциях в Magento 2
Привет! Меня зовут Павел и я занимаюсь бэкенд разработкой. Сегодня мы рассмотрим коллекции в Magento 2 (далее — M2). Несмотря на кажущуюся простоту реализации и интуитивно понятное назначение, эта сущность таит в себе несколько неочевидных подводных камней, которые влияют на производительность, а иногда и на саму возможность работы кода.
Сегодня рассмотрим принципы работы коллекций, полезные фишки и лайфхаки их использования, а также оценим влияние разных нюансов на производительность.
Погнали!
### Как работают коллекции в M2
По общему определению, справедливому для большинства фреймворков, коллекции в М2 — это набор объектов-моделей, объединенных какими либо общими признаками, а также инструменты для работы с ними: фильтрация, сортировка, пагинация и пр.
При объявлении коллекции указывается модель и ресурс-модель объектов, с набором которых работает коллекция:
```
php
declare(strict_types=1);
namespace RSHB\WhiteRabbit\Model\ResourceModel\WhiteRabbit;
use Magento\Framework\Model\ResourceModel\Db\Collection\AbstractCollection;
use RSHB\WhiteRabbit\Model\ResourceModel\WhiteRabbit as WhiteRabbitResource;
use RSHB\WhiteRabbit\Model\WhiteRabbit as WhiteRabbitModel;
/**
* Class Collection
* @package RSHB\WhiteRabbit\Model\ResourceModel\WhiteRabbit
*/
class Collection extends AbstractCollection
{
/**
* {@inheritDoc}
*/
protected function _construct()
{
$this-_init(
WhiteRabbitModel::class,
WhiteRabbitResource::class
);
}
}
```
Как мы можем увидеть, в базовом варианте достаточно указать модель и ресурс-модель, т. е. коллекция теперь знает, что брать и откуда.
Давайте создадим новую коллекцию, воспользовавшись фабрикой:
```
$collection = $this->whiteRabbitCollectionFactory->create();
```
и укажем произвольный фильтр для нашей коллекции:
```
$collection->addFieldToFilter('name', $name);
```
Затем поставим точку остановки после задания фильтров и посмотрим на объект коллекции в xdebug. Мы видим, что поле `_items` в коллекции пустое, однако в базе явно присутствуют элементы, отвечающие нашим фильтрам. Почему?
Незагруженная коллекция в xdebugЗдесь я хотел бы заострить внимание на первом аспекте коллекций, которые являются не очевидными для начинающих M2-разработчиков. Сразу после создания и задания фильтров коллекция является хранилищем sql запроса. Фактически, фильтры, которые мы задавали, — это надстройка над ORM, которая формирует элементы запроса. Давайте посмотрим, какой запрос сейчас содержится в нашей коллекции, для чего достанем из коллекции наш запрос и воспользуемся магическим методом для извлечения из него текста запроса:
```
$collection->getSelect()->__toString()
```
И посмотрим на сам запрос:
```
SELECT main_table. FROM rshb_white_rabbit AS main_table WHERE (name = 'White Rabbit')
```
Как мы видим, наш фильтр сформировал запрос в части `WHERE`. А вот основная часть запроса `SELECT` была сформирована при инстанцировании объекта коллекции при помощи метода `_initSelect()` (о нем более подробно ниже).
Таким образом, в настоящий момент коллекция не содержит никаких реальных данных из базы, но при этом имеет сформированный запрос, чтобы эти данные достать.
Вывод: коллекция имеет два состояния: загруженная и незагруженная. До загрузки данных коллекция служит хранилищем SQL запроса, который формируется и модифицируется инструментами коллекции.
### Загрузка коллекции
Итак, самый очевидный способ загрузить данные в коллекцию из БД — вызвать метод `load()`. Вызовем данный метод от нашей коллекции, после чего посмотрим на нее через xdebug:
Загруженная коллекция при помощи метода load()Теперь сделаем кое что интересное. Уберем метод `load()`, а вместо этого добавим нашу коллекцию в цикл `foreach` (мы можем делать это без дополнительных манипулций, поскольку коллекция реализует интерфейс `ArrayAccess`):
```
$collection = $this->whiteRabbitCollectionFactory->create();
$name = 'White Rabbit';
$collection->addFieldToFilter('name', $name);
foreach ($this->collection as $rabbit) {
//stop point
}
```
Остановимся внутри цикла на первой итерации и посмотрим в объект. Данные загружены!
Загруженная коллекция при обращении к элементам коллекцииКак так получилось, ведь мы не вызывали метод `load()`? Дело в том, что загрузка происходит автоматически при попытке обращения к элементам коллекции. Таким образом, мы можем не вызывать явным образом метод `load()` и начинать работать с коллекцией так, будто данные уже загружены.
Из всего сказанного выше следует один важный момент: после загрузки модификация фильтров и прочих элементов запроса коллекции не будет оказывать влияния на уже загруженные данные.
Проиллюстрируем простым примером. Немного модифицируем наш код и коллекцию,
После чего загрузим ее:
```
$collection = $this->whiteRabbitCollectionFactory->create();
$name = '%Rabbit';
$collection->addFieldToFilter('name', [‘like’ => $name]);
$collection->load();
//stop point 1
```
```
SELECT main_table.* FROM rshb_white_rabbit AS main_table WHERE (name LIKE '%Rabbit')
```
Загруженная коллекция с первым фильтромдобавим в нее новый фильтр и поставим точку остановки до второй загрузки:
```
$ids = [1, 2];
$collection->addFieldToFilter('id', [‘in’ => $ids]);
//stop point 2
$collection->clear();
$collection->load();
```
Удостоверимся, что хранящийся в коллекции запрос изменился:
```
SELECT `main_table`.* FROM `rshb_white_rabbit` AS `main_table` WHERE (`name` LIKE '%Rabbit') AND (`id` IN (1, 2))
```
После чего посмотрим, какие элементы сейчас фактически загружены:
Загруженная коллекция не измениласьКак мы видим, фактически загруженные элементы не изменились, наш фильтр на них не подействовал. Теперь вызовем у коллекции метод `clear()`, что инициирует очистку коллекции и ее возврат в незагруженное состояние, а затем метод `load()` и посмотрим еще раз:
Коллекция перезагружена с новым фильтромИ здесь есть тонкость. Метод `load()` принудительно инициирует загрузку данных в незагруженной коллекции, но при обращении к элементам уже загруженной коллекции этого не произойдет, повторная загрузка произведена не будет. Уберем методы `clear()` и `load()` и вызовем коллекцию в цикле `foreach`:
При обращении к элементам загруженная коллекция не измениласьПовторная загрузка данных с использованием нового запроса не произошла. Однако, если коллекцию очистить при помощи `clear()` и затем обратиться к ее элементам, загрузка будет осуществлена в соответствии с измененным нами запросом.
### Считаем элементы коллекции
Регулярно встречаю в коде посторонних модулей такие конструкции:
```
if (count($collection)) {
//do something…
}
```
И, на первый взгляд, здесь нет ошибки, count вернет нам количество элементов коллекции (помним про интерфейсы `ArrayAccess` и `Countable`, которые реализует коллекция). Но только на первый взгляд.
Самые внимательные уже догадались, в чем подвох. При выполнении `count` произойдет автоматическая загрузка коллекции, т.е. Загрузятся все данные в соответствии с запросом. Если нам нужно просто проверить, что в базе есть какое-то количество элементов, соответствующих нашему запросу, вместо `count` нужно использовать `$collection->getSize()`. Данный метод использует тот же запрос с одним отличием:
```
SELECT COUNT(*) FROM `rshb_white_rabbit` AS `main_table` WHERE (`name` LIKE '%Rabbit') AND (`id` IN (1, 2))
```
Что экономнее и быстрее при том же эффекте.
Таким образом, при операциях с коллекцией следует избегать действий, которые будут инициировать ненужную загрузку всей коллекции.
Вместе с тем, если в вашем случае не имеет значения, есть ли в базе нужные элементы или нет, то подобную проверку вообще стоит опустить, тем самым исключив один `COUNT` запрос:
```
If ($collection->getSize()) {
foreach ($collection as $item) {
//Do something
}
}
```
```
foreach ($collection as $item) {
//do nothing if collection is empty
}
```
### Запрос одного элемента при помощи коллекции
Что ж, теперь давайте рассмотрим ситуацию, когда коллекции используются для получения одного элемента. Нецелевое, на первый взгляд, использование может быть оправдано, если репозиторий не содержит нужных методов для нестандартных запросов, к примеру, запроса по какому-то произвольному полю.
Рассмотрим следующий код:
```
$collection = $this->collectionFactory->create();
$name = '%Rabbit';
$collection->addFieldToFilter('name', [‘like’ => $name]);
$item = $collection->getFirstItem();
```
Данная конструкция применяется обычно в двух случаях:
* Запрос гарантированно вернет один элемент;
* Нам нужен первый элемент коллекции (это бывает полезно, когда коллекция отсортирована по какому либо полю).
Во втором случае произойдет не совсем то, что мы ожидали: загрузятся все элементы которые удовлетворяют условиям, и лишь потом из загруженных элементов будет извлечен первый, о чем свидетельствует запрос, содержащийся в коллекции:
```
SELECT main_table.* FROM rshb_white_rabbit AS main_table WHERE (name LIKE '%Rabbit')
```
Если нам нужен только один элемент, мы можем заметно ускорить выборку, задав ограничение на количество элементов:
```
$collection = $this->collectionFactory->create();
$name = '%Rabbit';
$collection->addFieldToFilter('name', [‘like’ => $name]);
$collection->addOrder(‘name’, ASC);
$collection->setPageSize(1);
$item = $collection->getFirstItem();
```
```
SELECT `main_table`.* FROM `rshb_white_rabbit` AS `main_table` WHERE (`name` LIKE '%Rabbit') ORDER BY name ASC LIMIT 1
```
### AND и OR condition
Создадим коллекцию и добавим в нее несколько фильтров:
```
$collection = $this->whiteRabbitCollectionFactory->create();
$name = '%Rabbit';
$collection->addFieldToFilter('name', [‘like’ => $name]);
$ids = [1, 2];
$collection->addFieldToFilter('id', [‘in’ $ids]);
```
Посмотрим SQL-запрос:
```
SELECT `main_table`.* FROM `rshb_white_rabbit` AS `main_table` WHERE (`name` LIKE '%Rabbit') AND (`id` IN (1, 2))
```
Видим, что фильтры объединяются при помощи оператора `AND`.
Чтобы добавить фильтры с оператором `OR`, нужно применять несколько иную конструкцию:
```
$collection = $this->whiteRabbitCollectionFactory->create();
$name = '%Rabbit';
$ids = [1, 2];
$collection->addFieldToFilter(
['name', 'id'],
[
['like' => $name],
['in' => $ids]
]
);
```
SQL-запрос:
```
SELECT `main_table`.* FROM `rshb_white_rabbit` AS `main_table` WHERE ((`name` LIKE '%Rabbit') OR (`id` IN (1, 2)))
```
Мы можем комбинировать оба подхода, располагая фильтры в нужном порядке.
### Работа с очень большими коллекциями
В некоторых случаях, когда коллекция содержит десятки миллионов элементов, мы можем столкнуться с проблемой нехватки памяти при попытке итеративного прохода по всей коллекции:
```
PHP Fatal error: Allowed memory size of XXXX bytes exhausted (tried to allocate XXXX bytes) in vendor/magento/zendframework1/library/Zend/Db/Statement/Pdo.php on line 228
```
Есть несколько подходов для решения данной проблемы.
* Загрузка элементов порциями, пока не будет обработан весь объем:
```
$collection = $this->collectionFactory->create();
$name = '%Rabbit';
$lastId = 500;
$collection->addFieldToFilter('name', [‘like’ => $name]);
$collection->addFieldToFilter('id', [‘gt’ => $lastId]);
$collection->addOrder(‘id’);
$collection->setPageSize(500);
```
В этом случае необходимо реализовать логику хранения последнего обработанного элемента.
* Использование метода `walk()` итератора `Magento\Framework\Model\ResourceModel\Iterator`:
```
public function doAnything()
{
...
$this->iterator->walk(
$collection->getSelect(),
[[$this, 'callback']]
);
}
public function callback($args)
{
//do something
}
```
Стоит применять данные подходы, когда существует угроза нехватки памяти (также полезно применять при работе с любыми потенциально большими коллекциями).
### Кастомизация коллекции
Как я уже упоминал ранее, базовый запрос формируется сразу при инстанцировании коллекции при помощи метода `_initSelect()`. Мы можем использовать этот метод для модификации базового запроса под наши нужды. Наиболее часто такая кастомизация используется для join`а другой таблицы:
```
php
declare(strict_types=1);
namespace RSHB\WhiteRabbit\Model\ResourceModel\WhiteRabbit;
use Magento\Framework\Model\ResourceModel\Db\Collection\AbstractCollection;
use RSHB\WhiteRabbit\Model\ResourceModel\WhiteRabbit as WhiteRabbitResource;
use RSHB\WhiteRabbit\Model\WhiteRabbit as WhiteRabbitModel;
/**
* Class Collection
* @package RSHB\WhiteRabbit\Model\ResourceModel\WhiteRabbit
*/
class Collection extends AbstractCollection
{
/**
* {@inheritDoc}
*/
protected function _construct()
{
$this-_init(
WhiteRabbitModel::class,
WhiteRabbitResource::class
);
}
/**
* @return Collection|void
*/
protected function _initSelect()
{
parent::_initSelect();
$this->getSelect()->join(
['another_white_rabbit' => 'rshb_another_white_rabbit'],
'main_table.id = another_white_rabbit.white_rabbit_id',
['another_name' => 'another_white_rabbit.name']
);
return $this;
}
}
```
Вы также можете использовать данный подход в любых других случаях, когда нужно изменить базовый запрос коллекции под ваши нужды.
### Вопросы производительности
Кратко обозначим моменты, влияющие на производительность коллекций.
* Используйте `getSize()` вместо `count()` (или не используйте вообще, если можно без этого обойтись).
* Используйте ограничение на количество элементов (`setPageSize()`) в случаях, когда это необходимо.
* Если вам не нужны все поля элементов, загружайте только нужные:
```
//Плохая идея:
$collection->addFieldToSelect('*');
//Указываем нужные нам поля:
$collection->addFieldToSelect(['first', 'second', 'third']);
//или, если нужно получить значения только одного поля:
$collection->getFieldValues('somefield');
```
* Старайтесь не инициировать загрузку элементов, которые вам не нужны.
* В некоторых случаях в целях повышения производительности бывает полезно сформировать запрос вручную, особенно это актуально при работе с большими объемами данных или формировании очень сложных запросов. В этом случае стоит воспользоваться `Connection`:
```
/** @var \Magento\Framework\App\ResourceConnection $connection **/
$connection = $this->connection->getConnection();
$tableName = $this->connection->getTableName('rshbwhite_rabbit’);
$sql = "SELECT * FROM $tableName";
$result = $connection->fetchAll($sql);
```
Однако злоупотреблять данным подходом не стоит, применение коллекций — наиболее правильный путь в подавляющем большинстве случаев.
### Заключение
Мы рассмотрели ряд интересных особенностей коллекций в М2. Я уверен, что читатели могут дополнить данную статью своими наблюдениями, в связи с чем предлагаю делиться знаниями в комментариях.
На этом все. Пишите код с удовольствием. До встречи! | https://habr.com/ru/post/540862/ | null | ru | null |
# FritzFrog — новое поколение ботнетов
### Краткое содержание
* Guardicore обнаружили сложный ботнет пиринговой (P2P) сети **FritzFrog**, который еще с января 2020 года активно взламывал SSH серверы.
* **Вредоносное ПО на Golang**: FritzFrog исполняет модульный, мультипоточный и безфайловый вредоносный код на Golang, который не оставляет следов на жестком диске зараженного устройства.
* **Активное таргетирование государственных, образовательных, финансовых и прочих ресурсов**: FritzFrog пытался брутфорсить и распространяться на десятках миллионов IP адресов правительственных офисов, образовательных учреждений, медицинских центров, банков и множества телекоммуникационных компаний. Среди них успешно подвержены атаке оказались более чем 500 серверов, включая известные университеты США и Европы, и одну железнодорожную компанию.
* **Сложность**: FritzFrog полностью проприетарен, его имплементация P2P написана с нуля, что говорит о высоком уровне профессионализма его создателей в области разработки ПО.
* **Перехват**: Guardcore Labs разработали клиентскую программу на Golang, способную перехватывать P2P соединения FritzFrog и подключаться к сети как пир.
* **Принадлежность**: мы не смогли определить конкретную группу, ответственную за создание FritzFrog, однако текущий ботнет частично похож на ранее известный ботнет Rakos.
Введение
--------
FritzFrog это очень изощренный пиринговый ботнет, который активно взламывает SSH серверы по всему миру. Благодаря своей децентрализованной структуре он распределяет контроль по всем своим узлам. В этой сети нет единой точки отказа, и пиры постоянно общаются друг с другом, чтобы поддерживать ее в устойчивом, обновляемом и постоянно активном состоянии. P2P соединение проводится через зашифрованный канал с использованием AES для симметричного шифрования и протокола Диффи-Хеллмана для обмена ключами.
В отличие от других P2P ботнетов, FritzFrog уникален набором своих свойств: он безфайловый, поскольку собирает и исполняет пакеты прямо в памяти; несмотря на эффективное равномерное распределение целей в своей сети, он очень агрессивно их брутфорсит; его проприетарные P2P протоколы не основаны ни на одной из ныне известных реализаций.
Написанный на Golang вредоносный код очень переменчив и не оставляет следов на жестком диске. Он создает бэкдор в виде публичного SSH ключа и тем самым открывает злоумышленникам постоянный доступ к устройству жертвы. С самого начала его активности мы выявили 20 различных версий исполняемого вредоносного ПО.
В этом посте мы расскажем, каким образом была раскрыта деятельность FritzFrog, а так же каковы природа его P2P сети и внутреннее устройство вредоносного кода — включая процесс заражения, шифрование команд и изменчивое поведение.
Guardicore Labs предоставили доступ к [Github репозиторию](https://github.com/guardicore/labs_campaigns/tree/master/FritzFrog) со скриптом для обнаружения этого вредоносного ПО и списком индикаторов компрометации (IoC) его деятельности.
*Географическое распределение зараженных узлов. Наиболее подверженными атакам странами оказались США, Китай и Южная Корея.*
Исследование FritzFrog
----------------------
Впервые Guardcore Labs обратили внимание на деятельность FritzFrog в ходе исследования [Botnet Encyclopedia](https://www.guardicore.com/botnet-encyclopedia/). 9 января были обнаружены новые атаки с исполнением вредоносных процессов `ifconfig` и `nginx`. Мы начали отслеживать стабильный и значимый рост вредоносной деятельности, которая вскоре достигла 13 тысяч атак на Guardcore Global Sensors Network (GGSN). За все время мы отследили 20 различных версий бинарников FritzFrog.
*График демонстрирует количество атак FritzFrog на GGSN.*
Удивительным оказалось то, что вредоносный код на первый взгляд не связывался с каким-либо сервером командования и контроля (CNC). Только когда мы начали серьезно исследовать ботнет, мы поняли что никакого сервера не было и в помине.
Для перехвата сети ботнета Guardcore Labs разработали на Golang клиент, способный обмениваться ключами с вредоносным ПО, а так же отправлять команды и получать ответы. Эта программа, которую мы затем назвали «фроггер», позволила нам исследовать природу и задачи сети, и благодаря фроггеру мы «добавили» в сеть наши собственные узлы, сумев подсоединиться к ботнету, и поучаствовали в передаче данных активного P2P трафика.
FritzFrog брутфорсил миллионы IP адресов, среди которых оказались правительственные офисы, образовательные учреждения, медицинские центры, банки и множество телекоммуникационных компаний. Из них успешно подвержены атаке оказались более чем 500 серверов, включая известные университеты США и Европы, и одну железнодорожную компанию.
Новое поколение P2P
-------------------
> ### Почему «Новое поколение»?
>
>
>
> У FritzFrog есть уникальный набор свойств, который сильно выделяет его на фоне прочих сетевых угроз:
>
>
>
> * **Безфайловость**: FritzFrog работает без рабочей директории, а обмен файлами происходит прямо в памяти через массивы двоичных данных (BLOB).
> * **Постоянные обновления**: базы данных целей и пораженных устройств обновляются плавно и органично.
> * **Агрессивность**: брутфорс ведется с использованием обширного словаря. Для примера, недавно обнаруженный P2P ботнет DDG в поле логина использовал только «root».
> * **Эффективность**: Цели равномерно распределены между узлами.
> * **Проприетарность**: P2P протокол ботнета полностью проприетарен и не основывается на каком-либо из известных P2P протоколов, например μTP.
>
Как только жертва оказывается успешно взломана, на ней запускается UPX-запакованный вредоносный код, который затем тут же сам себя удаляет. Для минимизации подозрений вредоносные процессы исполняются под наименованиями ifconfig и nginx. В самом начале своей работы вредоносный код прослушивает порт 1234 в ожидании команд. Первые полученные команды синхронизируют жертву с базой данных пиров сети и целей брутфорса.
*Кластер узлов сети FritzFrog. Каждый узел это зараженный SSH сервер. Размер узлов демонстрирует их связность с остальной сетью.*
Трафик на нестандартном порте, например 1234, легко заметить и заблокировать файерволом либо любой другой системой защиты. Поэтому разработчики FritzFrog подошли к проблеме творчески и вместо прямой передачи команд через порт 1234 злоумышленник подключается к жертве через SSH и запускает на устройстве netcat клиент, который в свою очередь соединяется с сервером ботнета. Таким образом, любая команда будет передана через SSH как ввод netcat и без труда достигнет вредоносного кода.
*FritzFrog туннелирует свои P2P команды через классический SSH порт, для чего пользуется локальным netcat клиентом зараженного устройства.*
Злоумышленники FritzFrog внедрили зашифрованный командный канал с более чем 30 различными командами. Параметры команд и отклики передаются в указанных структурах данных и выпускаются («мобилизуются») в формате JSON. Перед отправлением данные зашифровываются симметричным шифрованием AES и кодируются в Base64. Для обмена ключами участвующие в передаче данных узлы используют протокол Диффи-Хеллмана.
Узлы в сети FritzFrog поддерживают тесный контакт, постоянно пингуя друг друга для проверки соединения, обмена пирами и целями и взаимной синхронизации. Узлы также участвуют в искусном избирательном процессе, который влияет на распределение целей брутфорса в сети. Наблюдения Guardcore Labs подтверждают, что цели в сети распределены равномерно и никакие два узла не будут пытаться взломать одну и ту же цель.
Погружение во вредоносный код
-----------------------------
Бинарник FritzFrog это продвинутый вредоносный код на Golang. Он полностью работает в памяти, каждый узел с вредоносным кодом хранит в памяти всю базу данных целей и пиров. Вредоносный код создает несколько потоков для одновременной обработки различных задач в соответствии с приведенной ниже таблицей.
FritzFrog определяет состояния управления жертвой и целевым устройством следующим образом:
1. **Target (цель)**: устройство из запроса цели будет затем передано модулю Cracker, который в свою очередь постарается просканировать и взломать его.
2. **Deploy (развертывание)**: успешно взломанное устройство встает в очередь на заражение вредоносным кодом через модуль DeployMgmt.
3. **Owned (владение)**: успешно зараженное устройство будет добавлено в P2P сеть модулем Owned.
У каждого узла с вредоносным кодом есть рабочий поток, который отвечает за получение команд, их разбор и передачу соответствующим функциям в коде.
*Рабочая функция в дизассемблере. Каждая ветка соответствует поддерживаемому P2P функционалу.*
Вредоносный код несет временный характер: пусть он и пытается пережить системные перезагрузки, для будущего доступа к взломанной цели сохраняется бэкдор, чьи логин и пароль хранятся у пиров сети. Вредоносный код добавляет публичный SSH-RSA ключ в файл `authorized_keys`. Столь простой бэкдор позволяет злоумышленнику – с секретным частым ключом – аутентифицироваться без пароля, на случай если изначальный пароль оказался изменен. Единственный используемый FritzFrog публичный ключ приведен ниже.
```
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDJYZIsncBTFc+iCRHXkeGfFA67j+kUVf7h/IL+sh0RXJn7yDN0vEXz7ig73hC//2/71sND+x+Wu0zytQhZxrCPzimSyC8FJCRtcqDATSjvWsIoI4j/AJyKk5k3fCzjPex3moc48TEYiSbAgXYVQ62uNhx7ylug50nTcUH1BNKDiknXjnZfueiqAO1vcgNLH4qfqIj7WWXu8YgFJ9qwYmwbMm+S7jYYgCtD107bpSR7/WoXSr1/SJLGX6Hg1sTet2USiNevGbfqNzciNxOp08hHQIYp2W9sMuo02pXj9nEoiximR4gSKrNoVesqNZMcVA0Kku01uOuOBAOReN7KJQBt
```
Вредоносный файл прогоняет всевозможные команды оболочки на локальном устройстве, некоторые по несколько раз, для отслеживания состояния системы. Например, он прогоняет `free –m` для проверки доступной оперативной памяти, `uptime`, `journalctl –s @0 –u sshd` для отслеживания SSH логинов, и прочие команды для вывода статистики нагрузки процессора. Эта статистика оказывается доступна другим узлам в сети, и используется для принятия различных решений, например запускать ли криптомайнер на устройстве или нет. Если решение принято, вредоносный код запускает отдельный процесс, `libexec`, для майнинга Monero. Этот майнер основан на популярном майнере XMRig и связывается с публичным пулом `web.xmrpool.eu` через порт 5555.
Злобная торрентоподобная сеть
-----------------------------
FritzFrog полагается на способность делиться файлами по всей сети, как для заражения новых устройств, так и для запуска вредоносных элементов, например криптомайнера Monero.
Для обмена файлами между узлами FritzFrog использует скрытный безфайловый подход: файлы делятся на хранящиеся в памяти массивы двоичных данных, и вредоносный код отслеживает доступные массивы через хранение их в карте вместе со значением хэша каждого массива.
Когда узел А хочет получить файл от своего пира, узла B, он моет выслать узлу В запрос `getblobstats` чтобы узнать какими массивами он владеет. Затем узел А может получить конкретный массив через его хэш, как с помощью P2P команды `getbin`, так и с помощью HTTP по адресу `http://1234/`. Как только узел А получает все массивы, он собирает файл через модуль Assemble и запускает его.
*Результат команды `getblolbstats`. Каждый узел в сети сообщает, каким он обладает массивом в соответствии с поддерживаемым списком файлов.*
Присвоение
----------
Отслеживание операций P2P ботнета — задача трудная. В связи с распределенной природой сети, команды в ней можно передавать с любого узла на любой узел. Тем не менее, мы попробовали сравнить этот P2P ботнет с предыдущими аналогичными угрозами.
Даже при сравнении с другими P2P ботнетами FritzFrog остается уникальным: он не использует IRC как это делает [IRCflu](https://securityboulevard.com/2020/06/ssh-targeting-golang-bots-becoming-the-new-norm/), в отличие от DDG он работает прямо в памяти, и он запускается на Unix-устройствах в противовес ботнету InterPlanetary Storm. Если он на кого и похож, особенно в плане наименования функций и нумерации версий, так это на [Rakos](https://www.welivesecurity.com/2016/12/20/new-linuxrakos-threat-devices-servers-ssh-scan/), P2P ботнет на Golang, проанализированный ESET еще в 2016 году.
Отслеживание действий И смягчение последствий
---------------------------------------------
Guardcore Labs предоставили [скрипт по отслеживанию FritzFrog](https://github.com/guardicore/labs_campaigns/blob/master/FritzFrog/detect_fritzfrog.sh) для запуска на SSH серверах. Он ищет следующие индикаторы ботнета:
* Запуск процессов `nginx`, `ifconfig` или `libexec`, чей исполняемый файл более в системе не существует (как можно видеть ниже).
* Прослушивание порта 1234.
В дополнение к этому, TCP трафик через порт 5555 может указывать на сетевой трафик к пулу Monero.
```
ubuntu@ip-111-11-11-11:~$ ./detect_fritzfrog.sh
FritzFrog Detection Script by Guardicore Labs
=============================================
[*] Fileless process nginx is running on the server.
[*] Listening on port 1234
[*] There is evidence of FritzFrog's malicious activity on this machine.
```
FritzFrog эксплуатирует особенность большинства систем сетевой защиты по принуждению трафика только через порт и протокол. Исключить подобные угрозы можно основанными на процессах правилами сегментации.
Слабые пароли оказываются ключевой уязвимостью для атак FritzFrog. Мы рекомендуем использовать сильные пароли и публичные ключи авторизации, что намного безопаснее. Кроме того, критически важно исключить публичный ключ FritzFrog из файла `authorization_keys` чтобы не дать злоумышленникам доступ к устройству. Роутеры и IoT устройства обычно раскрывают свой SSH и потому становятся уязвимы для атак FritzFrog; мы рекомендуем сменить таким устройствам SSH порт или, если функционал не используется, полностью отключить SSH. | https://habr.com/ru/post/516396/ | null | ru | null |
# Реализация классификации текста свёрточной сетью на keras
Речь, как ни странно, пойдёт о использующем свёрточную сеть классификаторе текстов (векторизация отдельных слов — это уже другой вопрос). [Код, тестовые данные и примеры их применения](https://bitbucket.org/alex43210/pynlc) — на bitbucket (уперся в ограничения размера от github и предложение применить Git Large File Storage (LFS), пока не осилил предлагаемое решение).
Наборы данных
-------------
Использованы конвертированные наборы: [reuters — 22000 записей](http://www.daviddlewis.com/resources/testcollections/reuters21578/), [watson-й — 530 записей](https://github.com/watson-developer-cloud/car-dashboard/blob/master/training/car_workspace.json), [и ещё 1 watson-й — 50 записей](https://github.com/watson-developer-cloud/natural-language-classifier-nodejs/blob/master/training/weather_data_train.csv). *Кстати, не отказался бы от подкинутого в комменты/ЛС (но лучше таки в комменты) набора текстов на русском.*
Устройство сети
---------------
За основу взята одна реализация [описанной тут сети](https://arxiv.org/abs/1408.5882). [Код использованной реализации на github](https://github.com/alexander-rakhlin/CNN-for-Sentence-Classification-in-Keras).
В моём случае — на входе сети находятся векторы слов (использована gensim-я реализация word2vec). Структура сети изображена ниже:
Вкратце:
* Текст представляется как матрица вида word\_count x word\_vector\_size. Векторы отдельных слов — от word2vec, о котором можно почитать, например, [в этом посте](https://habrahabr.ru/post/253227/). Так как заранее мне неизвестно, какой текст подсунет пользователь — беру длину 2 \* N, где N — число векторов в длиннейшем тексте обучающей выборки. Да, ткнул пальцев в небо.
* Матрица обрабатывается свёрточными участками сети (на выходе получаем преобразованные признаки слова)
* Выделенные признаки обрабатываются полносвязным участком сети
Стоп слова отфильтровываю предварительно (на reuter-м dataset-е это не сказывалось, но в меньших по объему наборах — оказало влияние). Об этом ниже.
Установка необходимого ПО (keras/theano, cuda) в Windows
--------------------------------------------------------
Установка для linux была ощутимо проще. Требовались:
* python3.5
* заголовочные файлы python (python-dev в debian)
* gcc
* cuda
* python-е библиотеки — те же, что и в списке ниже
В моём случае с win10 x64 примерная последовательность была следующей:
* [Anaconda с python3.5](https://www.continuum.io/downloads).
* [Cuda 8.0](https://developer.nvidia.com/cuda-downloads). Можно запускать и на CPU (тогда достаточно gcc и следующие 4 шага не нужны), но на относительно крупных датасетах падение скорости должно быть существенным (не проверял).
* Путь к nvcc добавлен в PATH (в противном случае — theano его не обнаружит).
* Visual Studio 2015 с C++, включая windows 10 kit (потребуется corecrt.h).
* Путь к cl.exe добавлен в PATH.
* Путь к corecrt.h в INCLUDE (в моём случае — C:\Program Files (x86)\Windows Kits\10\Include\10.0.10240.0\ucrt).
* `conda install mingw libpython` — gcc и libpython потребуется при компиляции сетки.
* ну и `pip install keras theano python-levenshtein gensim nltk` (возможно заведется и с заменой keras-го бэкенда с theano на tensorflow, но мной не проверялось).
* в .theanorc указан следующий флаг для gcc:
```
[gcc]
cxxflags = -D_hypot=hypot
```
* Запустить python и выполнить
```
import nltk
nltk.download()
```
### Обработка текста
На этой стадии происходит удаление стопслов, не вошедших в комбинации из «белого списка» (о нём далее) и векторизация оставшихся. Входные данные для применяемого алгоритма:
* язык — требуется nltk для токенизации и возвращения списка стопслов
* «белый список» комбинаций слов, в которых используются стопслова. Например — «on» отнесено к стопсловам, но [«turn», «on»] — уже другое дело
* векторы word2vec
Ну и алгоритм (вижу как минимум 2 возможных улучшения, но не осилил):
* Разбиваю входной текст на токены ntlk.tokenize-м (условно — «Hello, world!» преобразуется в [«hello», ",", «world», "!"]).
* Отбрасываю токены, которых нет в word2vec-м словаре.
На самом деле — которых там нет и выделить схожий по расстоянию не вышло. Пока только расстояние Левенштейна, есть идея отфильтровывать токены с наименьшим расстоянием Левенштейна по расстоянию от их векторов до векторов, входящих в обучающую выборку.
* Выбрать токены:
+ которых нет в списке стопслов (снизило ошибку на погодном датасете, но без следующего шага — очень испортило результат на «car\_intents»-м).
+ если токен в списке стопслов — проверить вхождение в текст последовательностей из белого списка, в которых он есть (условно — по нахождении «on» проверить наличие последовательностей из списка [[«turn», «on»]]). Если такая найдётся — всё же добавить его. Есть что улучшить — сейчас я проверяю (в нашем примере) наличие «turn», но оно же может и не относиться к данному «on».
* Заменить выбранные токены их векторами.
Кода нам, кода
--------------
**Собственно, код которым я и оценивал влияние изменений**
```
import itertools
import json
import numpy
from gensim.models import Word2Vec
from pynlc.test_data import reuters_classes, word2vec, car_classes, weather_classes
from pynlc.text_classifier import TextClassifier
from pynlc.text_processor import TextProcessor
from sklearn.metrics import mean_squared_error
def classification_demo(data_path, train_before, test_before, train_epochs, test_labels_path, instantiated_test_labels_path, trained_path):
with open(data_path, 'r', encoding='utf-8') as data_source:
data = json.load(data_source)
texts = [item["text"] for item in data]
class_names = [item["classes"] for item in data]
train_texts = texts[:train_before]
train_classes = class_names[:train_before]
test_texts = texts[train_before:test_before]
test_classes = class_names[train_before:test_before]
text_processor = TextProcessor("english", [["turn", "on"], ["turn", "off"]], Word2Vec.load_word2vec_format(word2vec))
classifier = TextClassifier(text_processor)
classifier.train(train_texts, train_classes, train_epochs, True)
prediction = classifier.predict(test_texts)
with open(test_labels_path, "w", encoding="utf-8") as test_labels_output:
test_labels_output_lst = []
for i in range(0, len(prediction)):
test_labels_output_lst.append({
"real": test_classes[i],
"classified": prediction[i]
})
json.dump(test_labels_output_lst, test_labels_output)
instantiated_classifier = TextClassifier(text_processor, **classifier.config)
instantiated_prediction = instantiated_classifier.predict(test_texts)
with open(instantiated_test_labels_path, "w", encoding="utf-8") as instantiated_test_labels_output:
instantiated_test_labels_output_lst = []
for i in range(0, len(instantiated_prediction)):
instantiated_test_labels_output_lst.append({
"real": test_classes[i],
"classified": instantiated_prediction[i]
})
json.dump(instantiated_test_labels_output_lst, instantiated_test_labels_output)
with open(trained_path, "w", encoding="utf-8") as trained_output:
json.dump(classifier.config, trained_output, ensure_ascii=True)
def classification_error(files):
for name in files:
with open(name, "r", encoding="utf-8") as src:
data = json.load(src)
classes = []
real = []
for row in data:
classes.append(row["real"])
classified = row["classified"]
row_classes = list(classified.keys())
row_classes.sort()
real.append([classified[class_name] for class_name in row_classes])
labels = []
class_names = list(set(itertools.chain(*classes)))
class_names.sort()
for item_classes in classes:
labels.append([int(class_name in item_classes) for class_name in class_names])
real_np = numpy.array(real)
mse = mean_squared_error(numpy.array(labels), real_np)
print(name, mse)
if __name__ == '__main__':
print("Reuters:\n")
classification_demo(reuters_classes, 10000, 15000, 10,
"reuters_test_labels.json", "reuters_car_test_labels.json",
"reuters_trained.json")
classification_error(["reuters_test_labels.json", "reuters_car_test_labels.json"])
print("Car intents:\n")
classification_demo(car_classes, 400, 500, 20,
"car_test_labels.json", "instantiated_car_test_labels.json",
"car_trained.json")
classification_error(["cars_test_labels.json", "instantiated_cars_test_labels.json"])
print("Weather:\n")
classification_demo(weather_classes, 40, 50, 30,
"weather_test_labels.json", "instantiated_weather_test_labels.json",
"weather_trained.json")
classification_error(["weather_test_labels.json", "instantiated_weather_test_labels.json"])
```
Здесь вы видите:
* Подготовку данных:
```
with open(data_path, 'r', encoding='utf-8') as data_source:
data = json.load(data_source)
texts = [item["text"] for item in data]
class_names = [item["classes"] for item in data]
train_texts = texts[:train_before]
train_classes = class_names[:train_before]
test_texts = texts[train_before:test_before]
test_classes = class_names[train_before:test_before]
```
* Создание нового классификатора:
```
text_processor = TextProcessor("english", [["turn", "on"], ["turn", "off"]], Word2Vec.load_word2vec_format(word2vec))
classifier = TextClassifier(text_processor)
```
* Его обучение:
```
classifier.train(train_texts, train_classes, train_epochs, True)
```
* Предсказание классов для тестовой выборки и сохранение пар «настоящие классы»-«предсказанные вероятности классов»:
```
prediction = classifier.predict(test_texts)
with open(test_labels_path, "w", encoding="utf-8") as test_labels_output:
test_labels_output_lst = []
for i in range(0, len(prediction)):
test_labels_output_lst.append({
"real": test_classes[i],
"classified": prediction[i]
})
json.dump(test_labels_output_lst, test_labels_output)
```
* Создание нового экземпляра классификатора по конфигурации (dict, может быть сериализована в/десериализована из, например json):
```
instantiated_classifier = TextClassifier(text_processor, **classifier.config)
```
Выхлоп примерно таков:
```
C:\Users\user\pynlc-env\lib\site-packages\gensim\utils.py:840: UserWarning: detected Windows; aliasing chunkize to chunkize_serial
warnings.warn("detected Windows; aliasing chunkize to chunkize_serial")
C:\Users\user\pynlc-env\lib\site-packages\gensim\utils.py:1015: UserWarning: Pattern library is not installed, lemmatization won't be available.
warnings.warn("Pattern library is not installed, lemmatization won't be available.")
Using Theano backend.
Using gpu device 0: GeForce GT 730 (CNMeM is disabled, cuDNN not available)
Reuters:
Train on 3000 samples, validate on 7000 samples
Epoch 1/10
20/3000 [..............................] - ETA: 307s - loss: 0.6968 - acc: 0.5376
....
3000/3000 [==============================] - 640s - loss: 0.0018 - acc: 0.9996 - val_loss: 0.0019 - val_acc: 0.9996
Epoch 8/10
20/3000 [..............................] - ETA: 323s - loss: 0.0012 - acc: 0.9994
...
3000/3000 [==============================] - 635s - loss: 0.0012 - acc: 0.9997 - val_loss: 9.2200e-04 - val_acc: 0.9998
Epoch 9/10
20/3000 [..............................] - ETA: 315s - loss: 3.4387e-05 - acc: 1.0000
...
3000/3000 [==============================] - 879s - loss: 0.0012 - acc: 0.9997 - val_loss: 0.0016 - val_acc: 0.9995
Epoch 10/10
20/3000 [..............................] - ETA: 327s - loss: 8.0144e-04 - acc: 0.9997
...
3000/3000 [==============================] - 655s - loss: 0.0012 - acc: 0.9997 - val_loss: 7.4761e-04 - val_acc: 0.9998
reuters_test_labels.json 0.000151774189194
reuters_car_test_labels.json 0.000151774189194
Car intents:
Train on 280 samples, validate on 120 samples
Epoch 1/20
20/280 [=>............................] - ETA: 0s - loss: 0.6729 - acc: 0.5250
...
280/280 [==============================] - 0s - loss: 0.2914 - acc: 0.8980 - val_loss: 0.2282 - val_acc: 0.9375
...
Epoch 19/20
20/280 [=>............................] - ETA: 0s - loss: 0.0552 - acc: 0.9857
...
280/280 [==============================] - 0s - loss: 0.0464 - acc: 0.9842 - val_loss: 0.1647 - val_acc: 0.9494
Epoch 20/20
20/280 [=>............................] - ETA: 0s - loss: 0.0636 - acc: 0.9714
...
280/280 [==============================] - 0s - loss: 0.0447 - acc: 0.9849 - val_loss: 0.1583 - val_acc: 0.9530
cars_test_labels.json 0.0520754688092
instantiated_cars_test_labels.json 0.0520754688092
Weather:
Train on 28 samples, validate on 12 samples
Epoch 1/30
20/28 [====================>.........] - ETA: 0s - loss: 0.6457 - acc: 0.6000
...
Epoch 29/30
20/28 [====================>.........] - ETA: 0s - loss: 0.0021 - acc: 1.0000
...
28/28 [==============================] - 0s - loss: 0.0019 - acc: 1.0000 - val_loss: 0.1487 - val_acc: 0.9167
Epoch 30/30
...
28/28 [==============================] - 0s - loss: 0.0018 - acc: 1.0000 - val_loss: 0.1517 - val_acc: 0.9167
weather_test_labels.json 0.0136964029149
instantiated_weather_test_labels.json 0.0136964029149
```
По ходу экспериментов с стопсловами:
* ошибка в reuter-м наборе оставалась сравнима вне зависимости от удаление/сохранения стопслов.
* ошибка в weather-м — упала с 8% при удалении стопслов. Усложнение алгоритма не повлияло (т.к. комбинаций, при которых стопслово таки нужно сохранить тут нет).
* ошибка в car\_intent-м — возросла примерно до 15% при удалении стопслов (например, условное «turn on» урезалось до «turn»). При добавлении обработки «белого списка» — вернулась на прежний уровень.
### Пример с запуском заранее обученного классификатора
Собственно, свойство TextClassifier.config — словарь, который можно отрендерить, например, в json и после восстановления из json-а — передать его элементы в конструктор TextClassifier-а. Например:
```
import json
from gensim.models import Word2Vec
from pynlc.test_data import word2vec
from pynlc import TextProcessor, TextClassifier
if __name__ == '__main__':
text_processor = TextProcessor("english", [["turn", "on"], ["turn", "off"]],
Word2Vec.load_word2vec_format(word2vec))
with open("weather_trained.json", "r", encoding="utf-8") as classifier_data_source:
classifier_data = json.load(classifier_data_source)
classifier = TextClassifier(text_processor, **classifier_data)
texts = [
"Will it be windy or rainy at evening?",
"How cold it'll be today?"
]
predictions = classifier.predict(texts)
for i in range(0, len(texts)):
print(texts[i])
print(predictions[i])
```
И его выхлоп:
```
C:\Users\user\pynlc-env\lib\site-packages\gensim\utils.py:840: UserWarning: detected Windows; aliasing chunkize to chunkize_serial
warnings.warn("detected Windows; aliasing chunkize to chunkize_serial")
C:\Users\user\pynlc-env\lib\site-packages\gensim\utils.py:1015: UserWarning: Pattern library is not installed, lemmatization won't be available.
warnings.warn("Pattern library is not installed, lemmatization won't be available.")
Using Theano backend.
Will it be windy or rainy at evening?
{'temperature': 0.039208538830280304, 'conditions': 0.9617446660995483}
How cold it'll be today?
{'temperature': 0.9986168146133423, 'conditions': 0.0016815820708870888}
```
И да, конфиг сети обученной на датасете от reuters — [тут](https://drive.google.com/file/d/0B7cY3wBgM-aBWGh3NmFjSGVHVzA/view?usp=sharing). Гигабайт сетки для 19Мб датасета, да :-) | https://habr.com/ru/post/315118/ | null | ru | null |
# Релиз стабильной версии Dart 2.0 и Dart Web Platform
*Примечание: присоединяйтесь к русскоязычному сообществу Dart в [Telegram](https://t.me/rudart), [Slack](http://dart-ru.herokuapp.com/) и [Google+](http://bit.ly/dart_ru_group). А в конце статьи вас ждёт небольшой анонс.*
---
Возрождение Dart как популярного языка программирования для мобильной и веб-разработки
--------------------------------------------------------------------------------------
Сегодня мы объявляем о релизе стабильной версии языка программирования Dart — 2.0, а также веб-платформы Dart, которая предлагает уникальное сочетание продуктивности, производительности и масштабируемости.
Разработчики Flutter пользуются многими возможностями Dart 2, так как Flutter уже несколько месяцев использует предварительные версии Dart 2 SDK. Тем не менее, выпуск стабильной версии Dart 2 является еще одним важным этапом на пути к релизу Flutter из-за жесткой связи между фреймворком и языком. Если вы еще не установили Flutter, вы можете [попробовать его прямо сейчас](https://flutter.io/get-started/install/).
С релизом Dart 2 теперь и веб-разработчики также могут использовать эту версию языка, все библиотеки и инструменты получат ряд улучшений, специфичных для Web. Всю необходимую информацию по установке и созданию первого приложения можно найти [здесь](https://webdev.dartlang.org/guides/get-started).
Dart: рост популярности
-----------------------
Dart 2 является важной вехой на пути возрождения Дарта как популярного языка программирования, ориентированного на быструю и удобную разработку мобильных и веб-приложений. Мы хотим, чтобы разработчики, создающие клиентские приложения, были продуктивными: с языком, фреймворком и компонентами, которые уменьшают шаблонный код и позволяют им сосредоточиться на бизнес-логике, а также инструментами, которые на ранних этапах идентифицируют ошибки, помогают в отладке и генерируют компактный и быстрый код.
Мы наблюдаем резкий рост популярности Dart за последний год. Наша собственная аналитика показывает десятикратный рост внешнего использования. В последнем квартале Dart был [одним из самых быстрорастущих](https://madnight.github.io/githut/#/pull_requests/2018/2) языков в GitHub, измеренным по pull request; [рост вопросов на StackOverflow](http://sotagtrends.com/?tags=%5Bdart,perl,haskell,rust%5D&relative=false) также демонстрирует положительный тренд в популярности Dart:
Для Google Dart является одним из немногих языков, которые мы используем для разработки веб-приложений с миллионами строк кода из множества различных проектов, включая Google Ads, Google Shopping и наших собственных проектов для внутренней инфраструктуры.
Фактически, вы уже могли использовать Dart, не осознавая этого: популярный [препроцессор стилей Sass](https://sass-lang.com/) был недавно [переписан на Dart](http://sass.logdown.com/posts/7045860-dart-sass-100-is-released), чтобы сделать его более быстрым, более портативным и более простым для разработки. Sass теперь распространяется как автономный исполняемый файл на Homebrew и Chocolatey и скомпилирован для JavaScript на npm. Dart упрощает установку приложений в любом месте без внешних зависимостей, а также для развертывания рабочих процессов как у пользователей, пишущих на Dart, так и у пользователей, которые этого не делают.
Dart 2 фокусируется на трёх аспектах: усиление и ужесточение языка, развитие нашей поддержки веб-и мобильных платформ и создание инструментов и компонентов, которые поддерживают использование Google Dart для внешнего мира. В остальной части этой статьи будут рассмотрены эти три темы.
Dart 2: язык, оптимизированный для клиентской разработки
--------------------------------------------------------
Как мы [рассказывали в Феврале](https://medium.com/dartlang/announcing-dart-2-80ba01f43b6) (*[русскоязычная версия](https://habr.com/company/wrike/blog/349790/)*) [система типов Dart](https://www.dartlang.org/guides/language/sound-dart) является *явной*. Это означает, что перед тем, как пользователи запустят ваше приложение, оно пройдёт стадию анализа и компиляции, во время которых зачастую и обнаруживается большой класс проблем. Когда мы масштабировали Dart до чрезвычайно больших приложений в Google, система типов обнаружила много ошибок ещё на раннем этапе разработки, что привело к созданию более качественного кода.
С Dart 2 вы не можете попасть в состояние, в котором выражение выполняется со значением, не соответствующим статическому типу этого выражения. Это означает, что вы можете масштабировать свою кодовую базу до миллионов строк, рефакторить крупные проекты и развертывать свой код на продакшен, будучи уверенными в нём.
Не беспокойтесь: *явность* не означает горы ненужного кода. Система типов включает в себя расширенный вывод — даже для аргументов *generic* типа.
```
final _field = [3.14, 6.28];
void main() {
// Типы не указаны, но тип будет выведен
print([1, 2, 3].runtimeType); // List
// Если типы не указаны, будет использован их общий базовый тип
// int (1) и double (3.14) оба являются типом `num`
print([1, 3.14].runtimeType); // List
// Вывод типов работает не только на переменных
print(\_field.runtimeType); // List
}
```
Узнать больше о системе типов Dart 2 можно на [этой](https://www.dartlang.org/guides/language/sound-dart) странице.
Как упоминалось в предыдущих постах в блоге, Dart 2 также уменьшает языковой шум в нескольких ключевых областях: например, ключевое слово *new* теперь является необязательным, а ключевое слово *const* необязательно в соответствующем контексте.
Наконец, мы проделали много закулисной работы, чтобы унифицировать различные вспомогательные инструменты, которые теперь объединены *общим фронтендом*, который поддерживает наши компиляторы и среды исполнения. Это обеспечивает консистентность для наших пользователей и обещает улучшить скорость и качество новых функций, поскольку Dart продолжает развиваться.
Dart 2 в Web: богатый, мощный фреймворк
---------------------------------------
Веб-приложения с самого начала занимали центральное место в миссии Дарта. Фактически, большинство разработок Dart в Google предназначено для веб-приложений. Одной из самых больших является Google Ads, которая обеспечивает миллиарды долларов интернет-экономики. В процессе переноса кода на Dart они уменьшили размер кодовой базы UI на 40%, одновременно повышая производительность и качество приложений.
В то время как основной Dart SDK предоставляет библиотеки для доступа к современным API-интерфейсам браузера, мы также поддерживаем надежный, основанный на Angular, фреймворк для построения сложных веб-приложений. [AngularDart 5](https://webdev.dartlang.org/angular), поставляемый как часть Dart 2, использует преимущества явной системы типов Dart и [новую систему сборки](https://github.com/dart-lang/build) (описанную ниже), чтобы пользователь мог использовать быстрые инкрементальные сборки во время разработки и более компактный скомпилированный JavaScript.
Одним из основных направлений в этой версии стало уменьшение количества кода, который обрабатывается при загрузке страницы, что значительно сокращает «время до интерактивности» для веб-страниц. Во многих приложениях размер кода уменьшился более чем наполовину по сравнению с AngularDart 4.
Чтобы продемонстрировать улучшения в веб-платформе Дарта, мы создали [клиентскую реализацию на основе Dart для сайта HackerNews](https://hnpwa.dartlang.org/) в качестве прогрессивного веб-приложения; он публикуется вместе с другими примерами на популярном сайте [HNPWA](https://hnpwa.com/). Используя лучшие практики для создания веб-приложений на Dart, мы смогли создать полнофункциональное приложение, которое полностью интерактивно за одну секунду на современных устройствах и до пяти секунд на скромном мобильном устройстве в медленной сети 3G. Это конкурентоспособно даже при сравнении с облегченными веб-фреймворками, оптимизированными для небольших приложений.
<https://hnpwa.dartlang.org/>
Наши инвестиции в инфраструктуру также распространяются и на нашу [библиотеку компонентов](https://pub.dartlang.org/packages/angular_components), которую мы также обновили. Теперь у вас есть доступ к 100 новым классам, включая различные [Material компоненты](https://material.io/). Вы можете изучить все наши компоненты в [галерее компонентов](https://dart-lang.github.io/angular_components_example/).
Material Date Picker — один из компонентов, доступных для вашего веб-приложения
Инструментарий для Dart 2
-------------------------
Вместе с Dart 2, Dart становится первоклассным компилируемым-в-JavaScript языком, с циклом разработки, который ожидают веб-разработчики, и отличными характеристиками производительности во время исполнения. Это достигается благодаря преимуществам, которые большинство языков, ориентированных на JS, не обеспечивают: явную систему типов и отличную поддержку для нативных мобильных приложений.
С Dart 2 наши веб-инструменты охватывают 100% -ную модель разработки JavaScript с двумя дополнительными компиляторами JavaScript. Компилятор разработки, [dartdevc](https://webdev.dartlang.org/tools/dartdevc), обеспечивает быструю инкрементальную компиляцию при генерации JavaScript, который легко читается и отлаживается. Это позволяет нашему компилятору [dart2js](https://webdev.dartlang.org/tools/dart2js) сосредоточиться на создании высоко оптимизированного JavaScript для прогрессивных веб-приложений для мобильных и сложных корпоративных приложений для рабочего стола. Оба компилятора используют явную систему типов Dart для оптимизации их вывода.
Наши веб-инструменты основаны на [новой системе сборки](https://github.com/dart-lang/build), созданной для того, чтобы быть быстрой, отлаживаемой и расширяемой. Теперь такие задачи, как генерация кода для сериализации, компиляция Sass в CSS и компиляция Dart в JavaScript, происходят в одной инструментальной цепочке, которая поддерживает быстрые, инкрементальные обновления по мере изменения частей вашего приложения. Система сборки также предназначена для поддержки использования за пределами Web. Пример: она используется разработчиками Flutter для генерации кода для [сериализации в JSON](https://flutter.io/json/#serializing-json-using-code-generation-libraries).
Вместе с Dart 2 у нас появился расширенный набор инструментов для разработчиков. Помимо поддержки [Android Studio](https://developer.android.com/studio/) и инструментов JetBrains, включая [IntelliJ IDEA](https://www.jetbrains.com/idea/) и [WebStorm](https://www.jetbrains.com/webstorm/), мы также поддерживаем [Visual Studio Code](https://code.visualstudio.com/) с расширением [Dart Code](https://dartcode.org/). И у нас также есть площадка для экспериментов: [DartPad](https://dartpad.dartlang.org/), которая была полностью обновлена для Dart 2.
Наконец, Dart SDK поставляется с набором других полезных инструментов: диспетчер пакетов, который работает с нашим [сайтом](https://pub.dartlang.org/), [статический анализатор](https://www.dartlang.org/tools/analyzer), linter, который вы можете использовать из командной строки или в виде пакета, а также инструментарий для [веб-документации](https://pub.dartlang.org/packages/dartdoc) и [форматирования](https://pub.dartlang.org/packages/dart_style), соответствующего [стандартам языка Dart](https://www.dartlang.org/guides/language/effective-dart/style).
Узнать больше
-------------
Ознакомьтесь с инструкциями по началу работы с [Flutter](https://flutter.io/get-started/install/) и набором [инструментов Web Dart](https://webdev.dartlang.org/guides/get-started).
В [примечаниях](https://groups.google.com/a/dartlang.org/forum/#!topic/announce/IUWWXwL7QB4) к релизу содержится подробная техническая информация о многих других небольших улучшениях, сделанных после Dart 1, некоторые из которых являются критичными. Если вы столкнулись с проблемами, которые не может решить поиск Google, рекомендуем начать с [StackOverflow](https://stackoverflow.com/questions/tagged/dart). Подпишитесь на рассылку [Dart Announcements](https://groups.google.com/a/dartlang.org/forum/#!forum/announce) и следите за нами в [Twitter](https://twitter.com/dart_lang), чтобы получать обновления. Мы также хотели бы видеть вас в наших сообществах, например, в [Gitter](https://gitter.im/dart-lang/home) и реддите [r/dartlang](https://www.reddit.com/r/dartlang/).
Спасибо
-------
Дарт стал языком общего назначения, который оптимизирован для разработки в Web и на мобильных устройствах. Мы работаем над Dart 2 уже в течение нескольких лет, за это время он затрагивал все аспекты нашей экосистемы и требовал миграции миллионов строк кода и сотен пакетов.
Мы благодарны сообществам [Dart](https://www.dartlang.org/) и [Flutter](https://flutter.io/), а также сотням инженеров Google, которые помогли нам в этом путешествии. Мы не смогли бы сделать это без вас!
---
#### От сообщества
Хотелось бы поздравить команду разработчиков Dart с таким важным событием, это действительно крупная веха для развития языка. Конечно, многие слова из этой статьи могут показаться вам весьма *дискусионными*, обсудить их можно как в комментариях, так и в наших чатах [Telegram](https://t.me/rudart), [Slack](http://dart-ru.herokuapp.com/) и [Google+](http://bit.ly/dart_ru_group).
И обещанный анонс: помимо небольших митапов мы проводим ежегодные большие события, посвященные языку, инструментам, Flutter, AngularDart и всему, что с ними связано. В прошлом году у нас были в гостях инженеры из Google, мы сварили специальное [пиво](https://twitter.com/bunopus/status/936253898100224000), и вообще было весело. В этом году мы постараемся сделать ещё лучше! Поэтому бронируйте конец ноября — начало декабря, и следите за анонсами. | https://habr.com/ru/post/419635/ | null | ru | null |
# Билдеры или конструкторы? Рассуждаем вслух
Всем привет! Хочу порассуждать над целесообразностью использования билдеров для несложных объектов.
Для упрощения буду использовать аннотации lombok'a:
[@Value](https://projectlombok.org/features/Value)
[@Builder](https://projectlombok.org/features/Builder)
Недолго погуглив, получаем, что **builder** — *[Отделяет конструирование сложного объекта от его представления так, что в результате одного и того же процесса конструирования могут получаться разные представления.](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D1%80%D0%BE%D0%B8%D1%82%D0%B5%D0%BB%D1%8C_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)#%D0%A6%D0%B5%D0%BB%D1%8C)* Только ли для сложных объектов?
Рассмотрим на простом примере:
```
@Value
public class Info {
@Nullable String uuid;
@Nullable String email;
@Nullable String phone;
}
```
Довольно-таки простой класс. На деле получаем иммутабельный объект, который инициализируется через конструктор.
Но, как мы видим, все поля nullable, и создание такие объектов будет выглядеть не очень красиво:
```
final Info info1 = new Info(null, "[email protected]", "79998888888");
final Info info2 = new Info("3d107928-d225-11ea-87d0-0242ac130003", null, null);
final Info info3 = new Info("3d107928-d225-11ea-87d0-0242ac130003 ", "[email protected]", null);
...
```
Безусловно, есть варианты:
1. Объекты, где немного полей разных типов, можно завезти несколько конструкторов. Но это не решает проблему класса выше.
2. Использовать setter'ы — субьективно, нагромождает код.
А что с билдером?
```
@Value
@Builder
public class Info {
@Nullable String uuid;
@Nullable String email;
@Nullable String phone;
}
```
Мы получаем весьма элегантное построение *несложного* объекта:
```
final Info info1 = Info.builder()
.uuid("3d107928-d225-11ea-87d0-0242ac130003")
.phone("79998888888")
.build();
final Info2 info2 = Info.builder()
.email("[email protected]")
.phone("79998888888")
.build();
...
}
```
Однако, для использования в проекте [jackson'а](https://github.com/FasterXML/jackson) необходимо дополнить наш класс, чтобы он успешно десериализовывался:
```
@Value
@Builder(builderClassName = "InfoBuilder")
@JsonDeserialize(builder = Info.InfoBuilder.class)
public class Info {
@Nullable String uuid;
@Nullable String email;
@Nullable String phone;
@JsonPOJOBuilder(withPrefix = "")
public static class InfoBuilder {
}
}
```
Получаем свои плюсы и минусы за оба подхода:
***builder:***
**+**
1. Код становится лаконичнее.
3. null в параметрах конструктора не бросается в глаза.
2. Меньше шанс перепутать параметры одного типа.
**-**
1. Создаем лишний объект, который GC в целом благополучно уберет, но забывать об этом не стоит.
2. При необходимости использовать jackson — нагромоздим класс.
***конструктор:***
**+**
1. Минимально нагромождает наш класс, никакой воды.
2. Нет создания лишних объектов.
**-**
1. Весьма часто в конструктор такого объекта будет прилетать null.
2. Есть вероятность ошибится, когда кто-то будет вносить изменения в код.
#### Итог
Опираясь на свой опыт — склоняюсь к использованию билдеров. Плата за это не высока, а на выходе имеем код, который приятно читать.
И конечно же, **пишите тесты**, чтобы избежать 2-го отрицательного пункта использования конструкторов.
P.S. Это моя первая статья, буду благодарен конструктивной критике и комментариям. | https://habr.com/ru/post/515358/ | null | ru | null |
# Особенности использования GD-lib на хостинге PHP c ограничеными ресурсами
Данной проблемой пришлось занятся после случая на хостинге «Х», на котором достаточно небольшие изобржаения невозможно было преобразовать, используя эту библиотеку. Но самое противное заключалось в том что скрипт просто умирал, оставляя информацию только в логах. Поэтому пришлось выяснить
Из достоверных источников (логов) было известно, что не хватает памяти для копирования изображения в оную. Т.е. нужно было предварительно проверить её достаточное наличие перед использованием библиотеки (вариант манипуляция с memory\_limit не рассматривается), предугадав при этом сколько же она собирается этой памяти прихватить.
Итак, библиотека GD может создавать изображения с палитрой 2^8 цветов и 2^24. Т.ж. теоритически максимальный размер изображения 2^16 x 2^16. Итого на пиксел приходится 5 или 7 байт.
Проверим на практике — создадам квадратные изображения функциями createImage и createImageTrueColor. И сведем практику и теорию в одном графике:
Видно что результаты расходятся, но при этом практически совпадают теория для 8 бит и практика для 24 бит.
Попробуем получит эмпирические значения «средних затрат памяти» на 1 пиксел в двух палитрах. Строим графики.
Видно что при больших значених они асимптотически стремятся к 2-м и 5-ти байтам соответствено.
Но при малых размерах картинки (примерно 100 пкс на сторону) могут достигать 3-х и 6-ти байт на пиксел. Не будем заморачиваться на апроксимирующую функцию (хотя стоило бы) и просто возьмем среднее 2,5 и 5,5 байт на пиксел соответственно.
Как результат получаем следующую функцию проверки возможности использования библиотеки GD в текущей опреативной обстановке:
> `Copy Source | Copy HTML1. function returnBytes($v) {
> 2. $v = trim($v);
> 3. switch(strtolower($v[strlen($v)-1])) {
> 4. case 'g':
> 5. $v \*= 1024;
> 6. case 'm':
> 7. $v \*= 1024;
> 8. case 'k':
> 9. $v \*= 1024;
> 10. }
> 11. return $v;
> 12. }
> 13.
> 14.
> 15. function checkMemoryForGDUsage($w, $h, $trueColor = false){
> 16. return (((returnBytes(ini\_get("memory\_limit"))-memory\_get\_usage())) > ($w \* $h \* (2.5 + (((int)$trueColor) \* 3))))?true:false;
> 17. }`
Собственно все, теперь вызов функции checkMemoryForGDUsage c планируемыми значениями ширины, высоты и палитры, перед созданием изображения, может уберечь (при удачном стечении обстоятельств) от fatal error. | https://habr.com/ru/post/102122/ | null | ru | null |
# Автоматическое дифференцирование
В программировании один из заветов — не дублировать функциональность. Иначе мы получаем код, в котором одни участки нетривиально зависят от других. При реализации части задач этому принципу легко следовать, но в других возникают проблемы: рассмотрим софт, который использует не очень хитрые математические алгоритмы, требующие работы с функциями и их производными.
> `f(a : double) : double
>
> {
>
> a\*a + 3 \* a
>
> }
>
>
>
> df(a : double) : double
>
> {
>
> 2\*a + 3
>
> }`
Очевидно, что, как минимум, код f и df функционально зависим, а, возможно, мы наблюдаем дублирование функциональности. Ситуацию можно исправить, если вспомнить определение производной и, соответственно, исправить код df:
> `df(a : double) : double
>
> {
>
> def delta = 0.1;
>
> (f(a+delta)-f(a))/delta
>
> }`
В данном случае, мы избавились от дублирования функциональности, но расплатились точностью работы программы, так как оптимального значения параметра delta не существует.
Серьезные инженеры могут решать эту проблему, программируя, например, в matlab и дальнейшей кодогенерацией в любимый язык программирования. Но есть мнение, что кодогенерация — зло, поэтому я расскажу о другом методе.
Мнимая единица i полагается решением уравнения x2+1 = 0. По-аналогии введем другую мнимую единицу d, которая будет решать уравнение x2=0 и при этом не равняться нулю. Затем вспомним разложение функции в ряд Тейлора:
Если в качестве h подставить нашу мнимую единицу и воспользоваться тем, что d2=0, то получим:
Таким образом, что бы узнать значение производной функции f в точке x достаточно взять коэффициент при мнимой части числа f(x+d). В современных языках не проблема определить класс, для работы с комплексными числами, так же легко можно определить класс для работы с этими расширенными числами. Ниже переведен пример на Nemerle:
> `public class Dual
>
> {
>
> public this(real : double, imaginary : double)
>
> {
>
> this.real = real;
>
> this.imaginary = imaginary;
>
> }
>
>
>
> real : double;
>
> imaginary : double;
>
>
>
> public Real : double { get { real } }
>
> public Imaginary : double { get { imaginary } }
>
>
>
> public static @+(a : Dual, b : Dual) : Dual
>
> {
>
> Dual(a.real + b.real, a.imaginary + b.imaginary)
>
> }
>
>
>
> public static @-(a : Dual, b : Dual) : Dual
>
> {
>
> Dual(a.real - b.real, a.imaginary - b.imaginary)
>
> }
>
>
>
> public static @\*(a : Dual, b : Dual) : Dual
>
> {
>
> Dual(a.real \* b.real, a.real \* b.imaginary + a.imaginary \* b.real)
>
> }
>
>
>
> public static @/(a : Dual, b : Dual) : Dual
>
> {
>
> a\*Dual(1/b.real, - b.imaginary / (b.real\*b.real))
>
> }
>
>
>
> public static @:(k : double) : Dual
>
> {
>
> Dual(k,0)
>
> }
>
> }`
Теперь можно переписать пример из начала статьи:
> `f(a : Dual) : Dual
>
> {
>
> a\*a + 3.0 \* a
>
> }
>
>
>
> f(a : double) : double
>
> {
>
> f(Dual(a,0)).Real
>
> }
>
>
>
> df(a : double) : double
>
> {
>
> f(Dual(a,1)).Imaginary
>
> }`
Очевидно, что код для производной мы получаем бесплатно. Минусом данного подхода является то, что необходимо переопределить элементарные функции для работы с dual-числами, но благодаря полученной формуле это не сложно, ниже приведена перегрузка синуса:
> `public Sin(a : Dual) : Dual
>
> {
>
> Dual(Math.Sin(a.Real), Math.Cos(a.Real)\*a.Imaginary)
>
> }`
Хочу еще:
| | |
| --- | --- |
| image | [Automatic differentiation](http://en.wikipedia.org/wiki/Automatic_differentiation) |
| image | [Dual numbers](http://en.wikipedia.org/wiki/Dual_numbers) |
| image | [Automatic Differentiation](http://blog.sigfpe.com/2005/07/automatic-differentiation.html) |
| image | [Automatic Differentiation, C++ Templates and
Photogrammetry](http://homepage.mac.com/sigfpe/paper.pdf) |
| image | [Nemerle](http://nemerle.org/Main_Page) |
Хотел создать блог Computer Science и поместить этот пост туда, но на хабре, надеюсь, что временно, нельзя создавать новые блоги, поэтому помещаю в блог «Ненормальное программирование». Блог Computer Science планировался быть местом, куда можно писать пересказы, переводы, аннотации к статям попадающим под определение Computer Science, ссылками на pdf и так далее. Всем, кто хотел бы писать статьи в этот блог советую не дожидаться его открытия, а писать в «Ненормальное программирование» с тегом «to computer science». | https://habr.com/ru/post/63055/ | null | ru | null |
# Реверс-инжиниринг протокола парктроника. Танец маленьких бит
Привет, хабр!
В попытках свести все ~~жизненные~~ рабочие показатели своего автомобиля на один экран головного устройства дошла очередь и до подключения парктроника. Многие возразят — ведь даже у дешевых парктроников есть свой экранчик, зачем выводить данные куда-то ещё? Да просто лишний экранчик в салоне ставить не хочется, и покопаться в железе повод есть…
В статье постараюсь описать приёмы и инструменты для реверс-инжиниринга недокументированного протокола обмена двух железок между собой.
Из содержания [некоторых публикаций](http://www.mp3car.com/hardware-development/121995-custom-usb-parking-sensor-interface-formally-pdc-usb.html), создаётся впечатление, что, во-первых, стоит выбирать парктроник с радиоканалом между основным блоком и экраном, и во-вторых, ничего сложного в протоколах обмена не ожидается. Хм… ну да. Правдой это оказалось наполовину.
Наличие радиоканала между основным блоком и «блоком индикации» позволяет предположить, что протокол обмена между ними будет простым и последовательным с передачей измеренных расстояний в явном виде. Если бы экран цеплялся напрямую, то, скорее всего, вся логика была бы реализована в одном чипе и на экран шли бы уже команды типа «зажги вот этот пиксель/сегмент и погаси вон тот», без возможности получить непосредственно измеренные расстояния. Окей. Воодушевлённые, идём в «крупнейший кибермаркет» и покупаем там самый дешевый комплект парктроника с самолётами в логотипе. Купили, и тут началось…
#### Шаг первый. Вскрытие и считывание посылаемых данных
Для начала определимся со способом передачи данных по радиоканалу. Вскрыв основной блок, находим там кругленький чип [R433A](http://www.adsean.com/dl/saw5035.pdf) с совершенно стандартной обвязкой. Приёмника в основном блоке нет, следовательно, канал передачи данных односторонний, с единственно возможной для R433 [OOK-модуляцией](http://en.wikipedia.org/wiki/On-off_keying). Т.е. при наличии высокого уровня цифрового сигнала (логической «единицы») передатчик передаёт в эфир несущую на частоте 433,92 МГц. При отсутствии высокого уровня — передатчик молчит. Со стороны приёмника в блоке индикации аналогичным образом происходит декодирование: если приёмник видит несущую, выдаёт высокий уровень, если не видит — выдаёт низкий. Да, все помехи ~~от парктроника соседа~~ приёмник так же прекрасно ловит, поэтому его чувствительность сильно занижается. И к передаваемым данным, как правило, добавляется контрольная сумма (этот факт нам ещё пригодится ниже).
Нам понадобится цифровой осциллограф-самописец (удобны простые USB-осциллографы, типа DiSco). Находим дорожку, которая идёт от главного микроконтроллера «мозгов» к передатчику в основном блоке или от приёмника к микроконтроллеру в блоке индикации, находим любую «минусовую» дорожку, подпаиваем к ним проводочки, подключаем осциллограф, смотрим:
Вот такую повторяющуюся посылку шлёт основной блок сразу при подаче питания. При внимательном её рассмотрении можно сделать ~~крайне неочевидный~~ вывод о том, что посылка состоит из трёх частей:
* Первая часть — очевидно, некая синхронизация, чтобы «разбудить» приёмник и чип в блоке индикации. Состоит из пяти импульсов по 0.4 мс с паузами по 0.4 мс и следом одного импульса длительностью 1 мс с паузой 2 мс. Запомним информацию о длительности, она пригодится для реализации собственного декодера.
* Вторая и третьи части — это непосредственно данные, закодированные в 16 импульсах разной ширины в каждой части (плюс ещё один 0.4 мс импульс в самом конце).
Выясним, каким образом во второй и третьей части закодированы биты. Чередование широких и узких импульсов похоже на [Манчестерский код](https://ru.wikipedia.org/wiki/Физическое_кодирование#.D0.9C.D0.B0.D0.BD.D1.87.D0.B5.D1.81.D1.82.D0.B5.D1.80.D1.81.D0.BA.D0.BE.D0.B5_.D0.BA.D0.BE.D0.B4.D0.B8.D1.80.D0.BE.D0.B2.D0.B0.D0.BD.D0.B8.D0.B5.C2.A0.28.D0.B0.D0.BD.D0.B3.D0.BB..29.D1.80.D1.83.D1.81.D1.81.D0.BA.), который применяется, в частности, в сетях Ethernet. Но у манчестера два широких импульса не могут разделяться узким. Поэтому, заметив, что после широкого импульса всегда следует узкая «пауза» и наоборот (при общей длительности импульс+пауза = 1 мс), предположим более простое — ширина импульса непосредственно кодирует логическую единицу (узкий импульс) или ноль (широкий импульс).
#### Шаг второй. Декодирование ручками
Итак, у нас есть 32 бита данных и 4 датчика. Логично предположить, что на каждый датчик отводится «чуть менее» 8 бит, плюс, вероятно, контрольная сумма (мы ещё помним про контрольную сумму!). И нам нужно понять, каким образом в этих битах кодируются расстояния до препятствий и всё такое. Для начала отключим все датчики и вручную с показаний осциллографа запишем полученную последовательность бит:
10011100 10011100 10011101 01000100
хм… понятно, что ничего не понятно. В отсутствие датчиков логично бы получать все единицы или все нули. Здесь ничего похожего. Подключим датчик A, направив его в пустоту (показания — «бесконечность»):
10011100 10011100 10010011 01001100
изменились последние два байта. В 4-м байте поменялся 1 бит. Видимо, именно он показывает «наличие датчика A»? А в 3-м байте поменялось 3 бита. Причём, если рассматривать их как отдельное 3-битное число, записанное от младшего к старшему биту, можно заметить, что оно увеличилось на единицу: 011+1=100. А единица эта — добавилась к 4-му байту. Отсюда два предварительных вывода:
* в 3-м байте есть биты, относящиеся к контрольной сумме,
* контрольная сумма — это простая арифметическая сумма чего-то с чем-то, никаких там CRC и прочих сложностей,
* данные в целом кодируются не байтами, а 4-битными «нибблами».
Попробуем отключить датчик A и подключить датчик B:
10011100 10011110 01011101 01000100
изменились 2-й и 3-й байты. Шестой бит второго байта (считая от нуля), похоже, «наличие датчика B». Младшие 4 бита третьего байта — тоже контрольная сумма, тоже увеличилась на единицу, появившуюся во втором байте. Но появилась она там не в нулевом и не в четвёртом, а в шестом бите! Уже становится интересно. Пробуем одновременно датчики A и B в «бесконечность»:
10011100 10011110 01010011 01001100
да, кое-что прояснилось. Имеем второй байт, как в посылке «только датчик B» и четвёртый байт из посылки «только датчик A». А вот в третьем байте две 4-битных части из двух предыдущих посылок. Предположение про 4-битные контрольные суммы начинает подтверждаться? Непривычно только то, что контрольная сумма засунута в середину посылки.
Попробуем теперь выставить перед датчиком A (отключив B) препятствие на расстоянии, скажем, 90 см:
10011100 10011100 10011111 01000110
о как, бит «наличие датчика A» больше не показывает нам наличие датчика A. Но в последних 4 битах появился бит в другом месте. И разительно поменялась контрольная сумма. Хотя если сравнить с исходной посылкой без датчиков: 1111-1011 = 100, а последние 4 бита: 0110-0010 = 100. Ура! Совпало!
Тем не менее, дальше становится понятно, что вручную с показаний осциллографа срисовывать эти биты тяжело и велика вероятность ошибиться. Поэтому…
#### Шаг третий. Декодирование ~~ножками~~ в микроконтроллере
У нас есть микроконтроллер. Ардуино или просто AVR на макетке, неважно. Он у нас есть, кому как не ему собирать все данные для головного устройства. Поэтому самое время написать программку для декодирования посылки от парктроника и передачи этой посылки через терминалку в компьютер для упрощения дальнейшего процесса реверсинга.
Поскольку уровень сигналов от парктроника составляет стандартные 5 вольт, то подключение к AVRке для отладки очень простое — проводом на любую неспециализированную ножку (хмм… может я зря зачеркнул в заголовке?).
Исходник программы доступен на [гитхабе](https://github.com/doncreat0r/KMENevoBT/blob/master/KME_BT.c). Декодированием занимается функция-обработчик прерывания PCINT3\_vect в строке 119 и далее. Остальная часть программы делает много других интересных штук, может быть когда-нибудь я и про это напишу статью. А пока опишу вкратце алгоритм декодирования посылки от парктроника.
У нынешних AVRок почти на каждую ногу можно повесить прерывание, которое будет срабатывать каждый раз при изменении уровня на входе. Т.е. каждый раз при переходе от 0 до 5 вольт и каждый раз при переходе обратно от 5 до 0. Таким образом, достаточно при помощи таймера засекать время между срабатываниями прерывания и фиксировать внутреннее состояние. Состояний может быть несколько: ожидание первых 5 импульсов, ожидание широкого импульса, ожидание паузы, ожидание первых 16 бит (с последующим декодированием в зависимости от длительности импульса), ожидание паузы, ожидание вторых 16 бит, ожидание финального импульса, переход в начальное состояние. Причём всё это реализовано в обработчике прерывания, отнимает каждый раз буквально считанные такты и совсем не занимает главный цикл (правда, занимает отдельный таймер, но это исправимо).
Получившееся устройство по UART выдаёт в терминалку компьютера декодированные значения непосредственно в виде 4х байт. Для упрощения последующего анализа открываем Excel и пишем макрос:
**Хабр умеет подсвечивать бейсик?**
```
Dim lst As Worksheet
Dim s As String
Dim v, i, j As Long
Set lst = ActiveWorkbook.ActiveSheet
For k = 2 To 365
For i = 1 To 8
If i Mod 2 = 0 Then ii = i - 1 Else ii = i + 1
s = "&H0" + Mid(lst.Cells(k, 2).Value, ii, 1)
v = CDec(s)
For j = 0 To 3
If (v And (2 ^ j)) > 0 Then
lst.Cells(k, 3 + (i - 1) * 4 + j) = "1"
Else
lst.Cells(k, 3 + (i - 1) * 4 + j) = "0"
End If
Next j
Next i
Next k
```
генерирующий из 4 шестнадцатеричных байт вот такое (разноцветие и подписи, конечно, я уже добавил сам):
очень наглядно стало видно, что биты «наличие датчика» действительно имеются по всем 4-м датчикам и влияют на контрольные суммы соответственно. А пропадание бита датчика A при некоторых показаниях обусловлено чем-то ещё.
Обладая всем вышеописанным инструментарием, опытным путём получаем таблицу по датчику A:
ну всё очень неплохо вырисовывается:
* Последние 4 бита — десятки сантиметров датчика A. Причём если промоделировать расстояния вплоть до нуля, получится, что нулю десятков сантиметров соответствует 1111 и далее по убывающей, 10+ см = 1110, 20+ см = 1101, 30+ см = 1100 и т.д. вплоть до 0011, соответствующего 130+ см.
* Отмеченные бледно-розовым два столбца по 2 бита соответствуют единицам сантиметров (заметьте, что для 105, 95 и 85 см биты одинаковы). Причём в первом столбце более старшие биты 4-битного значения. Принцип кодирования тот же: 0 см = 1111, 1 см = 1110 и т.д. вплоть до 9 см = 0110
* Первая контрольная сумма остаётся неизменной, а вот вторая меняется хитро. Столбец десятков сантиметров влияет на сумму непосредственно, а вот оба столбца единиц сантиметров — влияют только на старшие два бита контрольной суммы.
Соберем аналогичную таблицу по датчику B:
здесь интереснее получается:
* Два столбца по два бита, кодирующие единицы сантиметров, остаются на своих местах (отмечены светлозеленым). Получается, что, скорее всего, единицы сантиметров выводятся каждый раз для ближайшего к препятствию датчика, а десятки сантиметров — отдельно по каждому датчику. Таким образом, на штатном экранчике выводится расстояние до ближайшего к препятствию датчика с точностью до сантиметра и, грубо, расстояние до остальных датчиков в виде полосочек перед бампером.
* Десятки сантиметров для датчика B получаются также разбитыми на два столбца по два бита (отмечены «среднезеленым»).
* Обратившись к инструкции к парктронику, выясняем, что заявленное максимальное фиксируемое расстояние до препятствия — 2.5 метра. А в 4 битах можно закодировать только 1.6 метра. Значит где-то есть пятый бит? И действительно, промоделировав расстояния 1.7 метра и дальше, выясняем, что это второй бит первого байта (отмечен тёмнозеленым). Таким образом, десятки сантиметров датчика B кодируются битами в следующем порядке (от старшего к младшему): 2,1,0,16,15.
* Меняются значения обоих 4-битных контрольных сумм. Следовательно, биты, связанные с показаниями датчика B, влияют на обе суммы.
* Первая контрольная сумма чётко изменяется на единицу вместе с изменениями на единицу значения десятков сантиметров. Видимо остальные столбцы, которые тоже включены в эту сумму — среди неизменяющихся по датчику B.
Очередь датчика C:
я уже начинаю мыслить, как китаец:
* ~~гоньфень джи рёнран суньза~~ ой, то есть единицы сантиметров по-прежнему на своих местах.
* Десятки сантиметров для датчика C закодированы в пяти битах, которые на этот раз вместе, хоть и принадлежат разным байтам (сиреневый и тёмносиреневый). Принцип кодирования аналогичен предыдущим датчикам.
* Первая контрольная сумма (первые 4 бита) чётко изменяется на единицу вместе с изменениями на единицу значения десятков сантиметров. Аналогично датчику B. Следовательно, предварительный вывод: в первую контрольную сумму входят значение десятков сантиметров датчика B и датчика C (вероятно, без пятого бита) и что-то ещё. Интуиция подсказывает, что это младшие 4 бита последнего байта. Проверим ниже.
По датчику D собирать подробную таблицу стало лениво, поэтому так:
что ж, все гипотезы подтвердились. Первые 4 бита последнего байта кодируют десятки сантиметров датчика D.
Для проверки промоделируем несколько сочетаний датчиков A и B:
да, всё совпадает.
На данном этапе мы можем полностью декодировать расстояния по каждому датчику, включая единицы сантиметров. И наличие/отсутствие датчиков. Может быть, этого достаточно? Хм. Кажется что-то ещё недораскопано…
#### Шаг четвёртый. Расчёт CRC (Chinese Redundancy Check)
Итак, что мы уже знаем про местные контрольные суммы:
* Их две, по 4 бита, находятся почему-то не в последнем, а в третьем байте.
* Каждая из них является простой арифметической суммой данных из других столбцов.
* Предположительно известна принадлежность некоторых бит к конкретным контрольным суммам.
Отметим известную на данный момент принадлежность на выборке каких-нибудь произвольных показаний:
попробуем просуммировать по первой строке, возьмём столбцы десятков сантиметров датчиков B, C и D:
1110 + 0111 + 0011 = 11000
хм, а контрольная сумма в третьем байте 0111. А что если минус один?
1110 + 0111 + 0011 — 1 = 10111
совпадает, если отбросить лишний бит. Проверим по другим строкам:
1110 + 0111 + 0011 — 1 = 10111 (ой, тут всё повторилось)
0101 + 0111 + 0011 — 1 = 0111 (тут без отбрасывания)
1111 + 1100 + 1100 — 1 = 100110 (тут аж два бита переполнилось)
0001 + 0101 + 0011 — 1 = 1000 (без отбрасывания)
ура, всё совпало!
У нас остались не отмеченные столбцы. Вероятно, они относятся ко второй контрольной сумме, поэтому попробуем просуммировать:
1010 + 1011 + 0011 = 11000
1110 + 0111 + 0101 = 11010
1110 + 0011 + 1000 = 11001
1111 + 1111 + 0111 = 100101
1111 + 1011 + 0111 = 100001
мда, маловато общего с второй контрольной суммой. Посмотрим, сколько нужно вычесть, чтобы совпало:
1010 + 1011 + 0011 — 10 = 10110
1110 + 0111 + 0101 — 10 = 11000
1110 + 0011 + 1000 — 11 = 10110
1111 + 1111 + 0111 — 01 = 100100
1111 + 1011 + 0111 — 11 = 11110
где-то я это уже видел… а, ну да, у первой контрольной суммы! Зависимость простая — от второй КС нужно отнять то, что мы отбросили как переполнение при расчёте первой КС, только xor'енное с 11. Т.е. отбрасывая 00 (ничего) от первой КС, от второй отнимаем 11 и т.д.
Уфф, вроде всё. Осталось два незадействованных бита, но они, похоже, всегда единицы.
#### Шаг пятый. Чистка радиоэфира
А вообще я не сторонник применения радиоканалов где попало. Эфир и так прилично загажен, так что работать это всё будет местами (географическими) довольно нестабильно. Поэтому займёмся тем, что выкинем из парктроника приёмник и передатчик, соединив базовый блок, блок индикации и наш микроконтроллер по проводам. Почему я упоминаю блок индикации, хотя не собирался его ставить? А из-за пищалки. Всё-таки передача от базового блока парктроника в наш микроконтроллер, там декодирование, затем пересылка в головное устройство, там снова декодирование и отрисовка внесёт некритичный, но заметный лаг в отображение расстояний. Поэтому блок индикации останется в недрах приборки и будет пищать заведомо быстрее (хотя в будущем, может быть, заставлю пищать свой микроконтроллер).
Можно было бы не париться и соединить все блоки проводочками прямо как в отладочном режиме, напрямую. Однако прокидывать через всю машину жалкие 5 вольт TTL, поверьте мне, не лучшая идея. Поэтому впаяем во все три устройства микросхемы MAX485, реализующие передачу по куда более надёжному интерфейсу [RS-485](http://ru.wikipedia.org/wiki/RS-485). В общем как-то так (простите за неотмытый флюс). Базовый блок:
на месте белого кружка в правом верхнему углу платы стоял чип R433A, из его обвязки также удалён транзистор Q11 и резистор, вместо которого припаян проводок. А в свободном месте удалось расположить микросхемку так, что ножки попали на минусовой контакт и несколько других подходящих контактов. Поскольку базовый блок всегда является передатчиком, ножки DE и RE можно постоянно замкнуть на +5 вольт. Линии A и B интерфейса RS485 выведены на дополнительную клемму.
Блок индикации:
ну здесь вообще красота, MAX485 впаялась практически как родная вместо стоявшей микросхемы приёмника [RF83C](http://www.hoperf.com/upload/rf/RF83.pdf). Совпали ножки выхода данных DO и минусовая GND, ножки DE и RE, поскольку эта часть всегда приёмник, посажены на землю. Остальное потребовало всего одной перемычки.
Работает, как и прежде:
фотку собственного микроконтроллера, пожалуй, опубликую в статье про остальную часть функционала KMENevoBT с гитхаба.
Напоследок, код полного декодирования посылки от парктроника из отладочной программки на Delphi:
**Ну не бейте, это всего-лишь отладочный код на коленке**
```
procedure TfrmKMEmul.UpdatePT(a, b, c, d: Byte);
var
cm, la, lb, lc, ld, crc1, crc2: integer;
begin
cm := $F - ( (a shr 2) and $C + (b shr 4) and $3 );
la := (d shr 4) and $F;
lb := ((a and 7) shl 2) + ((b shr 6) and $3);
lc := ((a shr 6) and $3) + ((b and $7) shl 2);
ld := (d) and $F;
crc1 := ((lc and $F + lb and $F + ld) - 1);
crc2 := ((a shr 2) and $F) + ((b shr 2) and $F) + ((d shr 4) and $F);
crc2 := crc2 - ((crc1 shr 4) xor $3);
la := $F - la;
lb := $1F - lb;
lc := $1F - lc;
ld := $F - ld;
lbCM.Caption := IntToStr(cm);
lbA.Caption := Format('%.1f', [la/10]);
lbB.Caption := Format('%.1f', [lb/10]);
lbC.Caption := Format('%.1f', [lc/10]);
lbD.Caption := Format('%.1f', [ld/10]);
if la = $F - $2 then lbA.Font.Color := clRed else lbA.Font.Color := clGreen;
if lb = $1F - $4 then lbB.Font.Color := clRed else lbB.Font.Color := clGreen;
if lc = $1F - $4 then lbC.Font.Color := clRed else lbC.Font.Color := clGreen;
if ld = $F - $2 then lbD.Font.Color := clRed else lbD.Font.Color := clGreen;
if crc1 and $F = c and $F then lbCRC.Caption := 'OK' else lbCRC.Caption := 'BAD';
if (crc2 and $F = (c shr 4) and $F) then lbCRC2.Caption := 'OK' else lbCRC2.Caption := 'BAD';
end;
```
#### Шаг шестой. Выводы
Возможно, в какой-то момент стоило отказаться от дальнейших раскопок и заказать с Ebay тот же парктроник, который расковырял итальянец с форума по первой ссылке, но мне понравился сам парктроник. Он весьма быстро и точно работает. Пришлось добить, уже из принципа.
Что курили китайцы, разрабатывая такой вот протокол, непонятно.
**Лирическое отступление**Довелось мне несколько лет назад раскопать протокол диагностики автомобилей Форд с мозгами EEC-IV. Это такие мозги на основе интеловского набора 8096, кажется. В общем, древность на уровне чуть-ли не 8086. Ставилось это на форды с середины 80х и по начало 2000х, где-то с начала 90х там был реализован протокол диагностики Data Communication Link (DCL). Так вот, скорее всего из-за ограничений производительности невозможно было сделать протокол обмена с асинхронным обменом данными, как COM-порт компьютера. Поэтому протокол был синхронный. Это означало, что при активации диагностики мозги начинали слать по линии данных «фреймы», состоящие из строго синхронизированных по времени ~~байт~~слов. Для общения с мозгами необходимо было с точностью в десятки микросекунд засылать свои слова в указанные промежутки между принимаемыми словами. Никакой компьютер с COM-портом не обеспечивал требуемой точности отправки байт. Пришлось делать на микроконтроллере…
Хм, так о чём я… А, вот. В том случае такой интересный протокол обмена был оправдан ограничениями чипа. В случае с этим парктроником я не вижу никакой логики именно такого «танца» бит. Что мешало расположить, к примеру, 4х4 бит десятков сантиметров, затем 4 бита единиц сантиметров, ещё 4 бита на расширение до 5 бит датчиков B и C и всякие служебные и в конце контрольная сумма всех бит (просто сумма, без извращений, в крайнем случае стандартная CRC8).
Кстати, зная протокол обмена, можно применить этот парктроник не только на автомобиле, а, к примеру, на самодельном роботе. Да, для роботов есть отдельные ультразвуковые датчики, но тут их сразу четыре и читаются они одной ножкой ардуины, хоть и с задержкой в несколько миллисекунд.
Всем дочитавшим всего наилучшего!
P.S. Хотел опрос добавить насчёт писать ли про раскопки протокола мозгов для газового впрыска KME Nevo Pro. Там несколько другие приёмы использовались… Но думаю, скорее надо спрашивать насчёт «а нужны ли на хабре такие околоавтомобильные изыскания?». | https://habr.com/ru/post/249409/ | null | ru | null |
# C++: Коварство и Любовь, или Да что вообще может пойти не так?
> “C позволяет легко выстрелить себе в ногу. На C++ это сделать сложнее, но ногу оторвёт целиком” — Бьёрн Страуструп, создатель C++.
В этой статье мы покажем, как писать стабильный, безопасный и надежный код и насколько легко на самом деле его совершенно непреднамеренно поломать. Для этого мы постарались собрать максимально полезный и увлекательный материал.
Мы в SimbirSoft тесно сотрудничаем с проектом [Secure Code Warrior](https://securecodewarrior.com/), обучая других разработчиков создавать безопасные решения, и хотим поделиться примером.
Итак, к коду!
-------------
Здесь представлен небольшой фрагмент абстрактного кода на C++. Этот код был специально написан с целью демонстрации всевозможных проблем и уязвимостей, которые потенциально можно встретить на вполне реальных проектах. Как вы можете заметить, это код из **Windows DLL** (это важный момент). Предположим, что кто-то собирается использовать этот код в некоем (безопасном, разумеется) решении.
Приглядитесь к коду. Что, на ваш взгляд, в нём может пойти не так?
**Код**
```
class Finalizer
{
struct Data
{
int i = 0;
char* c = nullptr;
union U
{
long double d;
int i[sizeof(d) / sizeof(int)];
char c [sizeof(i)];
} u = {};
time_t time;
};
struct DataNew;
DataNew* data2 = nullptr;
typedef DataNew* (*SpawnDataNewFunc)();
SpawnDataNewFunc spawnDataNewFunc = nullptr;
typedef Data* (*Func)();
Func func = nullptr;
Finalizer()
{
func = GetProcAddress(OTHER_LIB, "func")
auto data = func();
auto str = data->c;
memset(str, 0, sizeof(str));
data->u.d = 123456.789;
const int i0 = data->u.i[sizeof(long double) - 1U];
spawnDataNewFunc = GetProcAddress(OTHER_LIB, "SpawnDataNewFunc")
data2 = spawnDataNewFunc();
}
~Finalizer()
{
auto data = func();
delete[] data2;
}
};
Finalizer FINALIZER;
HMODULE OTHER_LIB;
std::vector\* INTEGERS;
DWORD WINAPI Init(LPVOID lpParam)
{
OleInitialize(nullptr);
ExitThread(0U);
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
static std::vector THREADS;
switch (fdwReason)
{
case DLL\_PROCESS\_ATTACH:
CoInitializeEx(nullptr, COINIT\_MULTITHREADED);
srand(time(nullptr));
OTHER\_LIB = LoadLibrary("B.dll");
if (OTHER\_LIB = nullptr)
return FALSE;
CreateThread(nullptr, 0U, &Init, nullptr, 0U, nullptr);
break;
case DLL\_PROCESS\_DETACH:
CoUninitialize();
OleUninitialize();
{
free(INTEGERS);
const BOOL result = FreeLibrary(OTHER\_LIB);
if (!result)
throw new std::runtime\_error("Required module was not loaded");
return result;
}
break;
case DLL\_THREAD\_ATTACH:
THREADS.push\_back(std::this\_thread::get\_id());
break;
case DLL\_THREAD\_DETACH:
THREADS.pop\_back();
break;
}
return TRUE;
}
\_\_declspec(dllexport) int Initialize(std::vector integers, int& c) throw()
{
for (int i : integers)
i \*= c;
INTEGERS = new std::vector(integers);
}
int Random()
{
return rand() + rand();
}
\_\_declspec(dllexport) long long int \_\_cdecl \_GetInt(int a)
{
return 100 / a <= 0 ? a : a + 1 + Random();
}
```
Возможно, вы сочли этот код простым, очевидным и достаточно безопасным? Или, может быть, вы нашли в нем некоторые проблемы? А может быть, даже дюжину или две?
Что ж, на самом деле в этом фрагменте **более 43 потенциальных угроз** различной степени значимости!
### На что стоит всё же обратить внимание
1) sizeof(d) (где d — это long double) не обязательно кратен sizeof(int)
```
int i[sizeof(d) / sizeof(int)];
```
Такая ситуация не проверяется и не обрабатывается здесь. Например, размер long double может быть 10 байт на некоторых платформах (что неверно для **компилятора MS VS**, но верно для **RAD Studio**, в прошлом известного как **C++ Builder**).
[int также может быть разных размеров в зависимости от платформы](https://www.viva64.com/en/t/0012) (приведенный выше код предназначен для **Windows**, поэтому применительно именно к этой текущей ситуации проблема несколько надуманная, но для переносимого кода такая проблема весьма актуальна).
Все это может стать проблемой, если мы хотим использовать так называемый [каламбур типизации](https://en.wikipedia.org/wiki/Type_punning). К слову, он [вызывает неопределенное поведение](https://adriann.github.io/undefined_behavior.html) согласно стандарту языка C++. Впрочем, использование каламбура типизации является [обычной практикой](https://www.cocoawithlove.com/2008/04/using-pointers-to-recast-in-c-is-bad.html), поскольку [современные компиляторы обычно определяют правильное, ожидаемое поведение для данного случая](https://blog.regehr.org/archives/959) (как, например, это делает [**GCC**](https://www.ibm.com/support/knowledgecenter/en/SSB23S_1.1.0.14/common/m1rhpun.html)).
[*Источник: Medium.com*](https://medium.com/@CPP_Coder/about-size-t-and-ptrdiff-t-a1654234d842)
Между прочим, в отличие от C++, [в современном C каламбур типизации полностью допустим](https://stackoverflow.com/questions/11639947/is-type-punning-through-a-union-unspecified-in-c99-and-has-it-become-specified) (вы же понимаете, что *[C++ и C – разные языки](https://hackr.io/blog/c-vs-cpp)*, и вы **не** должны ожидать, что будете знать C, если вы знаете C++, и наоборот, не так ли?)
**Решение:** используйте [static\_assert](https://en.cppreference.com/w/cpp/keyword/static_assert) для контроля всех подобных предположений во время компиляции. Он предупредит вас, если вдруг что-то с размерами типов пойдет не так:
```
static_assert(0U == (sizeof(d) % sizeof(int)), “Houston, we have a problem”);
```
2) time\_t — это макрос, в Visual Studio он может ссылаться на 32-битный (старый) или 64-битный (новый) целочисленный тип
```
time_t time;
```
Доступ к переменной этого типа из разных исполняемых модулей (например, исполняемого файла и библиотеки DLL, которую он загружает) может привести к чтению/записи за границами объекта, в случае если эти два двоичных модуля скомпилированы с разным физическим представлением этого типа. Что, в свою очередь, приведёт к повреждению памяти или считыванию мусора.
**Решение:** убедитесь, что для обмена данными между всеми модулями используются одинаковые типы строго определенного размера:
```
int64_t time;
```
3) **B.dll** (хэндл которой хранит переменная **OTHER\_LIB**) еще **не** загружена в момент, когда мы обращаемся к указанной выше переменной, поэтому мы не сможем получить адреса функций данной библиотеки
4) проблема с порядком инициализации статических объектов ([SIOF](https://isocpp.org/wiki/faq/ctors#static-init-order)): (объект **OTHER\_LIB** в коде используется раньше, чем он был инициализирован)
```
func = GetProcAddress(OTHER_LIB, "func");
```
**FINALIZER** — это [статический](https://en.cppreference.com/w/cpp/keyword/static) объект, который создается перед вызовом функции **DllMain**. В его конструкторе мы пытаемся использовать библиотеку, которая еще не загружена. Проблема усугубляется тем, что статический объект **OTHER\_LIB**, который используется статическим объектом **FINALIZER**, размещается в единице трансляции ниже по коду. Это означает, что инициализирован (обнулен) он также будет позже. Т. е. на момент, когда к нему будут обращаться, он будет содержать некоторый [псевдослучайный](https://en.wikipedia.org/wiki/Pseudorandomness) мусор. **WinAPI** в целом должен нормально отреагировать на это, потому что с высокой степенью вероятности загруженного модуля с таким дескриптором просто не будет вовсе. И даже если произойдет совершенно невероятное совпадение и он всё таки будет — вряд ли в нём будет присутствовать функция по имени *«Func»*.
**Решение:** общий совет — избегать использования глобальных объектов, особенно сложных, особенно если они зависят друг от друга, особенно в **DLL**. Однако, если они все же нужны вам по какой-либо причине, будьте предельно внимательны и осторожны с порядком их инициализации. Чтобы [контролировать этот порядок](https://isocpp.org/wiki/faq/ctors#static-init-order-on-first-use), поместите **все** экземпляры (определения) глобальных объектов в **одну** [единицу трансляции](https://en.wikipedia.org/wiki/Translation_unit_(programming)) в нужном порядке, чтобы обеспечить их корректную инициализацию.
5) возвращенный ранее результат не проверяется перед использованием
```
auto data = func();
```
func — это [указатель на функцию](https://en.wikipedia.org/wiki/Function_pointer). И указывать он должен на функцию из **B.dll**. Однако, поскольку мы полностью провалили все действия на предыдущем шаге, это будет **nullptr**. Таким образом, пытаясь разыменовать его, вместо ожидаемого вызова функции мы получим ошибку нарушения прав доступа (access violation) или ошибку защиты памяти (general protection fault) или что-то в этом духе.
**Решение:** при работе с внешним кодом (в нашем случае с **WinAPI**) **всегда** проверяйте результат возврата вызываемых функций. Для надежных и отказоустойчивых систем это правило распространяется даже на функции, для которых существует строгий договор [о том, что и в каком случае они должны возвращать].
6) считывание/запись мусора при обмене данными между модулями, скомпилированными с разными alignment/padding настройками
```
auto str = data->c;
```
Если структура Data (которая используется для обмена информацией между взаимодействующими модулями) имеет в этих самых модулях различное физическое представление, все выльется в ранее упомянутое [нарушение прав доступа](https://www.viva64.com/en/t/0063), [ошибку защиты памяти](https://en.wikipedia.org/wiki/General_protection_fault), [ошибку сегментации](https://en.wikipedia.org/wiki/Segmentation_fault), [повреждение кучи](http://www.qnx.com/developers/docs/qnxcar2/index.jsp?topic=%2Fcom.qnx.doc.neutrino.prog%2Ftopic%2Fhat_ProblemsWithHeapCorruption.html) и т.д. Или же мы просто будем считывать мусор. Точный результат будет зависеть от реального сценария использования этой памяти. Все это может произойти из-за того, что для самой структуры отсутствуют явные настройки [выравнивания/заполнения](https://en.wikipedia.org/wiki/Data_structure_alignment). Поэтому в случае, если эти глобальные настройки в момент компиляции были разными для взаимодействующих модулей, у нас появятся проблемы.
**Решение:** убедиться, что все совместно используемые структуры данных имеют строгое, явно определенное и очевидное физическое представление (используют типы с фиксированным размером, явно указанное выравнивание и т.д.) и/или двоичные модули, взаимодействующие между собой, были скомпилированы с одинаковыми глобальными настройками выравнивания/заполнения.
**Смотрите также**
[Alignment (C++ Declarations)](https://docs.microsoft.com/en-us/cpp/cpp/alignment-cpp-declarations?view=vs-2019)
[Data structure alignment](https://en.wikipedia.org/wiki/Data_structure_alignment)
[Struct padding in C++](https://stackoverflow.com/questions/5397447/struct-padding-in-c)
7) использование размера указателя на массив вместо размера самого массива
```
memset(str, 0, sizeof(str));
```
Обычно такое является результатом банальной опечатки. Но также эта проблема потенциально может возникнуть, когда приходится иметь дело со [статическим полиморфизмом](https://en.wikipedia.org/wiki/Template_metaprogramming#Static_polymorphism) или при бездумном использовании ключевого слова auto ([особенно когда им явно злоупотребляют](https://www.acodersjourney.com/c-11-auto)). Очень хочется надеяться, впрочем, что современные компиляторы достаточно умны, чтобы обнаруживать такие проблемы на этапе компиляции, используя возможности [внутреннего статического анализатора](https://en.wikipedia.org/wiki/Static_program_analysis).
**Решение:**
* никогда не путайте sizeof (*<полный тип объекта>*) и sizeof (*<тип указателя на объект>* );
* [не игнорируйте предупреждения компилятора](https://wiki.sei.cmu.edu/confluence/display/c/MSC00-C.+Compile+cleanly+at+high+warning+levels);
* вы также можете использовать немного шаблонной магии С++, комбинируя typeid, constexpr и [static\_assert](https://en.cppreference.com/w/cpp/language/static_assert), чтобы гарантировать правильность типов на этапе компиляции (здесь ещё могут быть полезны [type traits](https://en.cppreference.com/w/cpp/types#Type_traits_.28since_C.2B.2B11.29), в частности, [std::is\_pointer](https://en.cppreference.com/w/cpp/types/is_pointer)).
8) неопределенное поведение при попытке читать иное поле объединения, нежели то, что ранее использовалось для установки значения
9) возможна попытка чтения за пределами допустимой области памяти, если размер long double различается между двоичными модулями
```
const int i0 = data->u.i[sizeof(long double) - 1U];
```
Это уже было упомянуто ранее, поэтому здесь мы просто получили еще одну точку присутствия ранее упомянутой проблемы.
**Решение:** не обращаться к другому полю, кроме того, которое было установлено ранее, если вы не уверены, что ваш компилятор обрабатывает это правильно. Убедитесь, что размеры типов общих объектов одинаковы во всех взаимодействующих модулях.
**Смотрите также**
[Type-punning and strict-aliasing](https://blog.qt.io/blog/2011/06/10/type-punning-and-strict-aliasing/)
[What is the Strict Aliasing Rule and Why do we care?](https://gist.github.com/shafik/848ae25ee209f698763cffee272a58f8)
10) даже если B.dll была правильно загружена и функция «func» правильно экспортирована и импортирована, B.dll все равно уже выгружена из памяти к данному моменту (т. к. ранее была вызвана системная функции FreeLibrary в секции DLL\_PROCESS\_DETACH функции обратного вызова DllMain)
```
auto data = func();
```
Вызов виртуальной функции у уже разрушенного ранее объекта полиморфного типа, равно как и вызов функции уже выгруженной динамической библиотеки, вероятно, приведет к [ошибке чисто виртуального вызова](https://support.microsoft.com/en-us/help/125749/description-of-the-r6025-run-time-error-in-visual-c).
**Решение:** внедрить в приложение корректную процедуру финализации, гарантирующую, что все динамические библиотеки завершат свою работу/будут выгружены в правильном порядке. Избегайте использования статических объектов со сложной логикой в **DL**L. Избегайте выполнения каких-либо операций внутри библиотеки после вызова DllMain/DLL\_PROCESS\_DETACH (когда библиотека перейдёт к своему последнему этапу жизненного цикла — фазе разрушения своих статических объектов).
#### Необходимо понимать что из себя представляет жизненный цикл DLL:
**А) Сторонний модуль вызывает LoadLibrary с целью загрузить библиотеку**
* происходит инициализация статических объектов библиотеки (этот этап должен содержать только очень простую логику, вызывается автоматически)
* происходит вызов DllMain -> DLL\_PROCESS\_ATTACH (секция должна содержать только очень простую логику, вызывается автоматически)
* теперь другие потоки приложения могут начать [параллельно] вызывать DllMain -> DLL\_THREAD\_ATTACH / DLL\_THREAD\_DETACH (вызывается автоматически, но см. далее примечания в пункте 30).
* эти секции, возможно, могут содержать некоторую сложную логику (например, индивидуальную инициализацию генератора псевдослучайных чисел для каждого потока), но будьте аккуратны
* происходит вызов экспортируемой разработчиком библиотеки функции инициализации библиотеки (содержит в себе всю сложную/тяжелую работу по инициализации, вызывается вручную тем, кто загружает библиотеку)
* непосредственно работа приложения с библиотекой, для чего она (библиотека) и создавалась
* происходит вызов экспортируемой разработчиком библиотеки функции ДЕинициализации библиотеки (содержит в себе всю сложную/тяжелую работу по ДЕинициализации, вызывается вручную тем, кто выгружает библиотеку)
* После этой точки избегайте каких-либо действий в библиотеке: все ранее запущенные потоки библиотеки должны быть завершены, прежде чем произойдет возврат из этой функции
**В) Другой модуль вызывает FreeLibrary**
* происходит вызов DllMain -> DLL\_PROCESS\_DETACH (секция должна содержать только очень простую логику, вызывается автоматически)
* происходит уничтожение статических объектов библиотеки (должен содержать только очень простую логику, вызываемую автоматически)
11) [удаление непрозрачного указателя](https://en.wikipedia.org/wiki/Opaque_pointer) ([компилятор должен знать полный тип](https://manu343726.github.io/2016-03-07-c++11-opaque-pointer-idiom), чтобы вызвать деструктор, поэтому удаление объекта с помощью opaque pointer может привести к утечке памяти и другим проблемам)
12) если деструктор DataNew является виртуальным, [даже при правильном экспорте и импорте класса](https://www.codeproject.com/Articles/28969/HowTo-Export-C-classes-from-a-DLL) и получении полной информации о нем, все равно вызов его деструктора на этом этапе является проблемой — это, вероятно, приведет к [чисто виртуальному вызову функции](https://support.microsoft.com/en-us/help/125749/description-of-the-r6025-run-time-error-in-visual-c) (так как тип DataNew импортируется из уже выгруженного **файла B.dll**). Эта проблема возможна, даже если деструктор не является виртуальным.
13) если класс DataNew является [абстрактным полиморфным типом](https://en.cppreference.com/w/cpp/language/abstract_class), а его базовый класс имеет чистый виртуальный деструктор без тела, в любом случае [произойдет](https://www.geeksforgeeks.org/pure-virtual-destructor-c) чистый вызов виртуальной функции.
14) неопределенное поведение, если выделять память через new и удалять, используя delete[]
```
delete[] data2;
```
В целом, вы всегда должны быть [осторожны](https://eli.thegreenplace.net/2011/09/16/exporting-c-classes-from-a-dll) при освобождении объектов, полученных от внешних модулей.
Также хорошей практикой является [обнуление указателей](https://stackoverflow.com/questions/1931126/is-it-good-practice-to-null-a-pointer-after-deleting-it) на разрушенные объекты.
**Решение:**
* при удалении объекта должен быть известен его полный тип
* все деструкторы должны иметь тело
* библиотека, из которой экспортируется код, не должна выгружаться слишком рано
* всегда правильно использовать различные формы new и delete, не путать их
* указатель на удаленный объект должен обнуляться.
Также обратите внимание на следующее:
— вызов оператора delete для указателя на void [приведет](https://www.viva64.com/en/w/v772/) к неопределенному поведению
чисто виртуальные функции [не должны](https://scc.ustc.edu.cn/zlsc/sugon/intel/ssadiag_docs/index.htm#pt_reference/references/sc_cpp_pure_virtual_call_in_ctor.htm) вызываться из конструктора
— вызов виртуальной функции в конструкторе [не будет](https://wiki.sei.cmu.edu/confluence/display/cplusplus/OOP50-CPP.+Do+not+invoke+virtual+functions+from+constructors+or+destructors) виртуальным
— старайтесь избегать [ручного управления памятью](https://www.fluentcpp.com/2018/04/01/cpp-will-no-longer-have-pointers) — вместо этого используйте [контейнеры](http://www.cplusplus.com/reference/stl), [семантику перемещения](https://www.internalpointers.com/post/c-rvalue-references-and-move-semantics-beginners) и [умные указатели](https://en.wikipedia.org/wiki/Smart_pointer)
**Смотрите также**
[Heap corruption: What could the cause be?](https://stackoverflow.com/questions/1504251/heap-corruption-what-could-the-cause-be)
15) ExitThread — предпочтительный метод выхода из потока в C. В C++ при вызове этой функции поток завершится до вызова деструкторов локальных объектов (и любой другой автоматической очистки), поэтому завершение потока в C++ следует выполнять просто путем возврата из функции потока
```
ExitThread(0U);
```
**Решение:** никогда не используйте вручную эту функцию в C++ коде.
16) в теле DllMain вызов любых стандартных функций, для которых требуются системные **DLL**, отличные от **Kernel32.dll**, может привести к различным трудно диагностируемым проблемам
```
CoInitializeEx(nullptr, COINIT_MULTITHREADED);
```
**Решение в DllMain:**
* избегайте любой сложной (де)инициализации
* избегайте вызова функций из других библиотек (или, по крайней мере, будьте предельно аккуратны с этим)
17) некорректная инициализация генератора псевдослучайных чисел в многопоточной среде
18) т. к. время, возвращаемое функцией [time](http://www.cplusplus.com/reference/ctime/time), имеет разрешение 1 сек., любой поток в программе, который вызывает эту функцию в течение этого периода времени, получит на выходе одинаковое значение. Использование этого числа для инициализации ГПСЧ может привести к возникновению коллизий (например, генерации одинаковых псевдослучайных имён для временных файлов, одинаковых номеров портов и т.д.). Одно из возможных решений — смешать ([xor](https://stackoverflow.com/questions/2334218/why-are-xor-often-used-in-java-hashcode-but-another-bitwise-operators-are-used/2334270)) полученный результат с каким-то [псевдослучайным значением](http://www.pcg-random.org/posts/simple-portable-cpp-seed-entropy.html), таким как адрес любого стэка или объекта в куче, более точным временем и т.д.
```
srand(time(nullptr));
```
**Решение:** [MS VS требует инициализации ГПСЧ для каждого потока](https://stackoverflow.com/questions/6161322/using-stdlibs-rand-from-multiple-threads/6163508#6163508). Кроме того, [использование времени *Unix* в качестве инициализатора предоставляет недостаточно энтропии](https://wiki.sei.cmu.edu/confluence/display/cplusplus/MSC51-CPP.+Ensure+your+random+number+generator+is+properly+seeded), предпочтительнее использовать [более продвинутую генерацию инициализирующего значения](https://wiki.sei.cmu.edu/confluence/display/c/MSC32-C.+Properly+seed+pseudorandom+number+generators).
**Смотрите также**
[Is there an alternative to using time to seed a random number generation?](https://stackoverflow.com/questions/7617587/is-there-an-alternative-to-using-time-to-seed-a-random-number-generation)
[C++ seeding surprises](http://www.pcg-random.org/posts/cpp-seeding-surprises.html)
[Getting random numbers in a thread-safe way](https://devblogs.microsoft.com/pfxteam/getting-random-numbers-in-a-thread-safe-way) [C#]
19) может вызвать тупик или сбой (или создать циклы зависимости в порядке загрузки **DLL**)
```
OTHER_LIB = LoadLibrary("B.dll");
```
**Решение:** [не используйте LoadLibrary в точке входа DllMain](https://docs.microsoft.com/ru-ru/windows/desktop/Dlls/dynamic-link-library-best-practices). Любая сложная (де)инициализация должна выполняться в определенных экспортируемых разработчиком DLL функциях, таких как, например, *«Init»* и *«Deint»*. Библиотека предоставляет эти функции пользователю, а пользователь должен их корректно в нужный момент вызвать. Обе стороны должны строго соблюдать этот контракт.
20) опечатка (условие всегда ложно), неправильная логика программы и возможная утечка ресурсов (поскольку OTHER\_LIB никогда не выгружается при успешной загрузке)
```
if (OTHER_LIB = nullptr)
return FALSE;
```
[Оператор присваивания путём копирования](https://en.cppreference.com/w/cpp/language/copy_assignment) возвращает ссылку левого типа, т.е. if проверит значение OTHER\_LIB (которое будет nullptr) и nullptr будет интерпретировано как false.
**Решение:** всегда используйте обратную форму, чтобы избежать таких опечаток:
```
if/while ( == )
```
21) рекомендуется использовать системную функцию \_beginthread для создания нового потока в приложении (особенно если приложение было слинковано со статической версией библиотеки времени выполнения C) в противном случае могут возникнуть утечки памяти при вызове ExitThread, DisableThreadLibraryCalls
22) все внешние вызовы DllMain сериализуются, поэтому в теле этой функции не должны предприниматься попытки создавать потоки/процессы или осуществлять с ними какое-либо взаимодействие, иначе возможно возникновение взаимных блокировок
```
CreateThread(nullptr, 0U, &Init, nullptr, 0U, nullptr);
```
23) вызов функций COM во время завершения работы DLL может привести к некорректному доступу к памяти, поскольку соответствующий компонент уже может быть выгружен
```
CoUninitialize();
```
24) не существует способа контролировать порядок загрузки и выгрузки внутрипроцессных сервисов COM/OLE, поэтому не вызывайте OleInitialize или OleUninitialize из функции DllMain
```
OleUninitialize();
```
**Смотрите также**
[COM Clients and Servers](https://docs.microsoft.com/en-us/windows/win32/com/com-clients-and-servers)
[In-process, Out-of-process, and Remote Servers](http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/devwin32/oocinprocessoutofprocessandremoteservers_xml.html)
25) вызов free для блока памяти, выделенного с помощью new
26) если процесс приложения находится в стадии завершения своей работы (на что указывает ненулевое значение параметра lpvReserved), все потоки в процессе, кроме текущего, либо уже завершены, либо были принудительно остановлены при вызове функции ExitProcess, которая может оставить некоторые ресурсы процесса, такие как куча, в неконсистентном состоянии. В результате очищать ресурсы небезопасно для **DLL**. Вместо этого **DLL** должна позволять операционной системе восстанавливать память
```
free(INTEGERS);
```
**Решение:** убедитесь, что старый стиль C ручного выделения памяти не смешан с “новым” стилем, принятым в C++. Будьте предельно осторожны при управлении ресурсами в функции [DllMain](https://docs.microsoft.com/en-us/windows/win32/dlls/dllmain).
27) может привести к тому, что DLL будет использоваться даже после того, как система выполнила свой код завершения
```
const BOOL result = FreeLibrary(OTHER_LIB);
```
**Решение:** **не** вызывать [FreeLibrary](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-freelibrary) в точке входа DllMain.
28) произойдет сбой текущего (возможно, основного) потока
```
throw new std::runtime_error("Необходимый модуль не был загружен");
```
**Решение:** избегайте выбрасывания исключений в функции DllMain. Если **DLL** не может быть корректно загружена по какой-либо причине, функция должна просто вернуть FALSE. Выбрасывать исключения из секции DLL\_PROCESS\_DETACH также не следует.
Всегда будьте осторожны, выбрасывая исключения за пределы DLL. Любые сложные объекты (например, классы [стандартной библиотеки](https://en.wikipedia.org/wiki/C%2B%2B_Standard_Library)) могут иметь различное физическое представление (и даже логику работы) в различных исполняемых модулях в случае, если они скомпилированы с разными (несовместимыми) версиями [библиотек времени выполнения](https://en.wikipedia.org/wiki/Runtime_library).
Постарайтесь обмениваться между модулями только [простыми типами данных](https://en.wikipedia.org/wiki/Passive_data_structure) (с фиксированным размером и четко определенным бинарным представлением).
Помните, что завершение основного потока автоматически завершит все остальные потоки (которые не завершатся правильно и из-за этого могут повредить память, оставив примитивы синхронизации и другие объекты в непредсказуемом и некорректном состоянии. Кроме того, эти потоки уже перестанут существовать в тот момент, когда статические объекты начнут свою собственную деконструкцию, поэтому не пытайтесь в деструкторах статических объектов ожидать завершения каких-либо потоков).
**Смотрите также**
[Top 20 C++ multithreading mistakes and how to avoid them](https://www.acodersjourney.com/top-20-cplusplus-multithreading-mistakes)
29) [можно выкинуть исключение](https://en.cppreference.com/w/cpp/container/vector/push_back) (например, std::bad\_alloc), которое здесь не перехватывается
```
THREADS.push_back(std::this_thread::get_id());
```
Поскольку секция DLL\_THREAD\_ATTACH вызывается из какого-то неизвестного внешнего кода, не особо рассчитывайте увидеть здесь корректное поведение.
**Решение:** приложите с помощью команды try/catch те инструкции, которые могут выбрасывать исключения, которые вероятнее всего не могут быть обработаны правильно (особенно если они выходят из **библиотеки DLL**).
**Смотрите также**
[How can I handle a destructor that fails?](https://isocpp.org/wiki/faq/exceptions#dtors-shouldnt-throw)
30) **UB**, если **до** загрузки этой **DLL** были представлены потоки
```
THREADS.pop_back();
```
Уже существующие на момент загрузки DLL потоки (включая тот, который непосредственно загружает **DLL**) не вызывают функцию точки входа загружаемой **DLL** (поэтому они не регистрируются в векторе THREADS во время события DLL\_THREAD\_ATTACH), в то время как они по-прежнему вызывают его с событием DLL\_THREAD\_DETACH по завершении.
Это означает, что количество обращений к секциям DLL\_THREAD\_ATTACH и DLL\_THREAD\_DETACH функции DllMain будет разным.
31) лучше использовать [целочисленные типы фиксированного размера](https://en.cppreference.com/w/cpp/types/integer)
32) передача сложного объекта между модулями может вызвать сбой, если они скомпилированы с разными настройками и флагами линковки и компиляции (разные версии библиотеки времени выполнения и т. д.)
33) доступ к объекту c по его виртуальному адресу (который является общим для модулей) может вызвать проблемы, если указатели по-разному обрабатываются в этих модулях (например, если модули связаны с различными параметрами [LARGEADDRESSAWARE](https://docs.microsoft.com/en-us/cpp/build/reference/largeaddressaware-handle-large-addresses?view=vs-2019))
```
__declspec(dllexport) int Initialize(std::vector integers, int& c) throw()
```
**Смотрите также**
[Is it possible to use more than 2 Gbytes of memory in a 32-bit program launched in the 64-bit Windows?](https://www.viva64.com/en/k/0001)
[Application with LARGEADDRESSAWARE flag set getting less virtual memory](https://stackoverflow.com/questions/25424236/application-with-largeaddressaware-flag-set-getting-less-virtual-memory)
[Drawbacks of using /LARGEADDRESSAWARE for 32 bit Windows executables?](https://stackoverflow.com/questions/2288728/drawbacks-of-using-largeaddressaware-for-32-bit-windows-executables)
[how to check if exe is set as LARGEADDRESSAWARE](https://stackoverflow.com/questions/9054469/how-to-check-if-exe-is-set-as-largeaddressaware) *[C#]*
[/LARGEADDRESSAWARE может испортить вам весь день](https://stackoverflow.com/questions/9054469/how-to-check-if-exe-is-set-as-largeaddressaware) *[Ru]*
[ASLR (Address Space Layout Randomization)](https://ru.bmstu.wiki/ASLR_(Address_Space_Layout_Randomization)) *[Ru]*
**А также...**
[Virtual memory](https://en.wikipedia.org/wiki/Virtual_memory)
[Physical Address Extension](https://docs.microsoft.com/en-us/windows/win32/memory/physical-address-extension)
[Tagged pointer](https://en.wikipedia.org/wiki/Tagged_pointer)
[std::ptrdiff\_t](https://www.viva64.com/ru/a/0050)
[What is uintptr\_t data type](https://stackoverflow.com/questions/1845482/what-is-uintptr-t-data-type)
[Pointer arithmetic](https://www.learncpp.com/cpp-tutorial/6-8a-pointer-arithmetic-and-array-indexing)
[Pointer aliasing](https://en.wikipedia.org/wiki/Pointer_aliasing)
[What is the strict aliasing rule?](https://stackoverflow.com/questions/98650/what-is-the-strict-aliasing-rule)
[reinterpret\_cast conversion](https://en.cppreference.com/w/cpp/language/reinterpret_cast)
[restrict type qualifier](https://en.cppreference.com/w/c/language/restrict)
Вряд ли приведенный выше список является полным, поэтому вы наверняка сможете добавить что-нибудь важное в комментариях.
Работа с указателями на самом деле существенно сложнее, чем о ней обычно думают. Вне всяких сомнений, матерые разработчики смогут вспомнить и другие существующие нюансы и тонкости (например, что-то о разнице между [указателями на объект и указателями на функцию](https://en.cppreference.com/w/cpp/language/pointer), из-за чего, возможно, [не все биты указателя могут быть использованы](https://stackoverflow.com/questions/20763616/how-many-bytes-do-pointers-take-up), и т.д.).
34) внутри функции [может быть выброшено](http://www.cplusplus.com/reference/new/operator%20new%5B%5D) [исключение](http://www.cplusplus.com/reference/exception/exception):
```
INTEGERS = new std::vector(integers);
```
при этом спецификация throw() этой функции пуста:
```
__declspec(dllexport) int Initialize(std::vector integers, int& c) throw()
```
[std::unexpected вызывается средой выполнения C++](https://en.cppreference.com/w/cpp/error/unexpected) при нарушении спецификации исключения: исключение выбрасывается из функции, спецификация исключения которой запрещает исключения этого типа.
**Решение:** используйте try / catch (особенно при выделении ресурсов, особенно в **DLL**) или nothrow форму оператора new. В любом случае, [никогда не исходите из наивного предположения о том, что все попытки выделения разного рода ресурсов всегда будут заканчиваться успешно](https://wiki.sei.cmu.edu/confluence/display/c/MEM11-C.+Do+not+assume+infinite+heap+space).
**Смотрите также**
[RAII](https://en.wikipedia.org/wiki/Resource_acquisition_is_initialization)
[We do not use C++ exceptions](https://google.github.io/styleguide/cppguide.html#Exceptions)
[Memory Limits for Windows and Windows Server Releases](https://docs.microsoft.com/en-us/windows/win32/memory/memory-limits-for-windows-releases)
**Проблема 1:** формирование такого *«более случайного»* значения некорректно. Как утверждает [центральная предельная теорема](https://en.wikipedia.org/wiki/Central_limit_theorem), сумма независимых случайных величин стремится к [нормальному распределению](https://en.wikipedia.org/wiki/Normal_distribution), а не к равномерному (даже если сами исходные величины распределены равномерно).
**Проблема 2:** возможное переполнение целочисленного типа (что является [неопределенным поведением для целочисленных типов со знаком](https://en.wikipedia.org/wiki/Integer_overflow#Methods_to_mitigate_integer_overflow_problems))
```
return rand() + rand();
```
Работая с генераторами псевдослучайных чисел, шифрованием и тому подобными вещами, всегда остерегайтесь использования самодельных «решений». Если у вас нет специализированного образования и опыта работы с этими крайне специфическими областями, очень высоки шансы, что вы просто перехитрите сами себя и лишь усугубите ситуацию.
35) имя экспортируемой функции будет декорировано (изменено), чтобы предотвратить это использование extern «C»
36) имена, начинающиеся с '\_', неявно запрещены для C++, так как этот стиль именования зарезервирован для STL
```
__declspec(dllexport) long long int __cdecl _GetInt(int a)
```
**Несколько проблем (и их возможные решения):**
37) [rand](https://en.cppreference.com/w/c/numeric/random/rand) **не** является потокобезопасным, вместо него нужно использовать [rand\_r](https://linux.die.net/man/3/rand_r)/[rand\_s](https://docs.microsoft.com/ru-ru/cpp/c-runtime-library/reference/rand-s?view=vs-2019)
38) rand устарел, [лучше использовать](https://channel9.msdn.com/Events/GoingNative/2013/rand-Considered-Harmful) современный
```
C++11
```
39) не факт, что функция rand была инициализирована конкретно для текущего потока (MS VS требует инициализации этой функции для каждого потока, где она будет вызываться)
40) [существуют специальные генераторы псевдослучайных чисел](https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator), и в устойчивых ко взлому решениях [лучше использовать именно их](https://wiki.sei.cmu.edu/confluence/display/c/MSC30-C.+Do+not+use+the+rand%28%29+function+for+generating+pseudorandom+numbers) (подойдут переносимые решения вроде [**Libsodium**/randombytes\_buf](https://libsodium.gitbook.io/doc/generating_random_data), [**OpenSSL**/RAND\_bytes](https://www.openssl.org/docs/man1.1.0/man3/RAND_bytes.html) и т.д.)
41) потенциальное деление на ноль: может вызвать аварийное завершение текущего потока
42) в одном ряду использованы [операторы с разным приоритетом](https://en.cppreference.com/w/c/language/operator_precedence), что вносит хаос в порядок вычисления – применяйте скобки и/или [точки следования](https://en.wikipedia.org/wiki/Sequence_point) для задания очевидной последовательности вычисления
43) потенциальное [переполнение целочисленного типа](https://en.wikipedia.org/wiki/Integer_overflow)
```
return 100 / a <= 0 ? a : a + 1 + Random();
```
**Смотрите также**
[Do not use std::rand() for generating pseudorandom numbers](https://wiki.sei.cmu.edu/confluence/display/cplusplus/MSC50-CPP.+Do+not+use+std%3A%3Arand%28%29+for+generating+pseudorandom+numbers)
**А также...**
[ExitThread function](https://docs.microsoft.com/ru-ru/windows/win32/api/processthreadsapi/nf-processthreadsapi-exitthread)
[ExitProcess function](https://docs.microsoft.com/ru-ru/windows/win32/api/processthreadsapi/nf-processthreadsapi-exitprocess)
[TerminateThread function](https://docs.microsoft.com/ru-ru/windows/win32/api/processthreadsapi/nf-processthreadsapi-terminatethread)
[TerminateProcess function](https://docs.microsoft.com/ru-ru/windows/win32/api/processthreadsapi/nf-processthreadsapi-terminateprocess)
### И это еще не всё!
Представьте, что у вас есть какой-то важный контент в памяти (например, пароль пользователя). Конечно же, [вы не захотите хранить его в памяти](https://www.sjoerdlangkemper.nl/2016/05/22/should-passwords-be-cleared-from-memory) дольше, чем это реально необходимо, увеличивая таким образом вероятность того, что кто-то [может считать его оттуда](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-readprocessmemory).
[Наивный подход для решения этой проблемы](https://dwheeler.com/secure-programs/Secure-Programs-HOWTO/protect-secrets.html) будет выглядеть примерно так:
```
bool login(char* const userNameBuf, const size_t userNameBufSize,
char* const pwdBuf, const size_t pwdBufSize) throw()
{
if (nullptr == userNameBuf || '\0' == *userNameBuf || nullptr == pwdBuf)
return false;
// Here some actual implementation, which does not checks params
// nor does it care of the 'userNameBuf' or 'pwdBuf' lifetime,
// while both of them obviously contains private information
const bool result = doLoginInternall(userNameBuf, pwdBuf);
// We want to minimize the time this private information is stored within the memory
memset(userNameBuf, 0, userNameBufSize);
memset(pwdBuf, 0, pwdBufSize);
}
```
И это, конечно же, [**не** будет работать](https://www.viva64.com/en/k/0041) так, как бы нам хотелось. Что же тогда делать? :(
**Неправильное *«решение»* №1:** если *memset* не работает, давайте сделаем это вручную!
```
void clearMemory(char* const memBuf, const size_t memBufSize) throw()
{
if (!memBuf || memBufSize < 1U)
return;
for (size_t idx = 0U; idx < memBufSize; ++idx)
memBuf[idx] = '\0';
}
```
Почему и это нам тоже не подходит? Дело в том, что в этом коде нет никаких ограничений, которые бы **не** позволили современному компилятору [оптимизировать его](https://wiki.sei.cmu.edu/confluence/display/c/MSC06-C.+Beware+of+compiler+optimizations) (кстати, функция [memset](https://www.viva64.com/en/b/0360), если она всё же будет использоваться, скорее всего, будет [встроенной](https://docs.microsoft.com/en-us/cpp/intrinsics/compiler-intrinsics?view=vs-2019)).
**Смотрите также**
[The as-if rule](https://en.cppreference.com/w/cpp/language/as_if)
[Are there situations where this rule does not apply?](https://stackoverflow.com/questions/15718262/what-exactly-is-the-as-if-rule)
[Copy elision](https://en.cppreference.com/w/cpp/language/copy_elision)
[Atomics and optimization](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4455.html)
**Неправильное *«решение»* #2:** попытаться «улучшить» предыдущее «решение», поигравшись с ключевым словом [volatile](https://en.cppreference.com/w/cpp/language/cv)
```
void clearMemory(volatile char* const volatile memBuf, const volatile size_t memBufSize) throw()
{
if (!memBuf || memBufSize < 1U)
return;
for (volatile size_t idx = 0U; idx < memBufSize; ++idx)
memBuf[idx] = '\0';
*(volatile char*)memBuf = *(volatile char*)memBuf;
// There is also possibility for someone to remove this "useless" code in the future
}
```
Будет ли это работать? Возможно. Например, такой подход используется в [RtlSecureZeroMemory](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/aa366877(v%3Dvs.85)) (в чём вы можете убедиться самостоятельно, посмотрев фактическую реализацию этой функции в исходниках **Windows** [**SDK**](https://en.wikipedia.org/wiki/Software_development_kit)).
Однако, такой прием будет ожидаемо работать [не со всеми компиляторами](http://www.daemonology.net/blog/2014-09-04-how-to-zero-a-buffer.html).
**Смотрите также**
[volatile member functions](https://en.cppreference.com/w/cpp/language/member_functions#const-.2C_volatile-.2C_and_ref-qualified_member_functions)
**Неправильное *«решение»* #3:** использовать неподходящую функцию **API ОС** (например, *RtlZeroMemory*) или **STL** (например, std::fill, std::for\_each)
```
RtlZeroMemory(memBuf, memBufSize);
```
Другие примеры попыток решения данной проблемы [здесь](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1381.pdf).
#### И как же всё-таки правильно??
* использовать корректную функцию **API ОС**, например, RtlSecureZeroMemory для **Windows**
* использовать функцию *C11* [memset\_s](https://en.cppreference.com/w/c/string/byte/memset):
Кроме того, мы можем помешать компилятору оптимизировать код путем вывода (в файл, консоль или другой поток) значения переменной, но этот способ, очевидно, не очень полезен.
**Смотрите также**
[Safe clearing of private Data](https://www.viva64.com/en/b/0388)
### Подводя итоги
Это, конечно, не полный список всех возможных проблем, нюансов и тонкостей с которыми вы можете столкнуться при написании приложений на *C/C++*.
Есть также и такие замечательные вещи, как:
* [«живые» блокировки](https://en.wikipedia.org/wiki/Deadlock#Livelock);
* [состояния гонки](https://en.wikipedia.org/wiki/Race_condition) (например, вызванные неправильной реализацией [неблокирующего алгоритма](https://en.wikipedia.org/wiki/Non-blocking_algorithm), [проблемой ABA](https://en.wikipedia.org/wiki/ABA_problem), не потокобезопасными реализациями [счетчиков ссылок](https://en.wikipedia.org/wiki/Reference_counting), неправильными реализациями [блокировки с двойной проверкой](https://en.wikipedia.org/wiki/Double-checked_locking));
* [срезка объектов](https://stackoverflow.com/questions/274626/what-is-object-slicing);
* [потеря арифметической точности](https://en.wikipedia.org/wiki/Loss_of_significance) (из-за округления или числовой нестабильности алгоритмов, например, суммирование массива чисел с плавающей запятой без предварительной их сортировки);
* проблемы взаимодействия [потоков и GDI объектов;](https://docs.microsoft.com/en-us/windows/win32/procthread/multiple-threads-and-gdi-objects)
* путаница, непонимание и неправильное использование [volatile и atomic](http://www.drdobbs.com/parallel/volatile-vs-volatile/212701484) переменных;
* некорректное использование целочисленных литералов (например, 0603 вместо 603);
* проблема рассинхронизации проверки/доступа ([time-of-check to time-of-use](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use));
* лямбда-выражения, которые живут дольше своих захваченных по ссылкам объектов;
* [использование некорректных спецификаций формата в функциях семейства printf](https://en.wikipedia.org/wiki/Printf_format_string#Invalid_conversion_specifications);
* неправильный обмен данными между двумя устройствами с [разным порядком байтов](https://en.wikipedia.org/wiki/Endianness) (например, через сеть) и т. д. и т. п.;
И многое другое.
**Есть что добавить? Поделитесь своими интересным опытом в комментариях!**
**P.S. Хотите узнать больше?**
[Software security errors](https://vulncat.fortify.com/en/weakness?kingdom=Security%20Features)
[Common weakness enumeration](https://cwe.mitre.org/index.html)
[Common types of software vulnerabilities](https://www.owasp.org/index.php/Category:Vulnerability)
[Vulnerability database](https://www.sourceclear.com/vulnerability-database/search#_)
[Vulnerability notes database](https://www.kb.cert.org/vuls/bypublished/desc)
[National vulnerability database](https://en.wikipedia.org/wiki/National_Vulnerability_Database)
[Coding standards](https://wiki.sei.cmu.edu/confluence)
[Application security verification standard](https://cheatsheetseries.owasp.org/cheatsheets/IndexASVS.html)
[Guidelines for the use of the C++ language in critical systems](https://www.misra.org.uk/Activities/MISRAC/tabid/171/Default.aspx)
[Secure programming HOWTO](https://dwheeler.com/secure-programs/Secure-Programs-HOWTO/index.html)
[32 OpenMP Traps For C++ Developers](https://www.viva64.com/en/a/0054)
[A Collection of Examples of 64-bit Errors in Real Programs](https://www.viva64.com/en/a/0065) | https://habr.com/ru/post/521018/ | null | ru | null |
# Лучший способ выбора случайной точки в круге
Допустим, вам нужно найти случайную точку с равномерным распределением в круге. Как же это сделать лучше всего? Когда я впервые начал изучать эту задачу, я работал над программным проектом, требовавшим случайного распределения значений в круге, но довольно быстро я спустился в неожиданно глубокую кроличью нору, заполненную любопытной математикой, поэтому решил объединить все свои находки в одну статью.
Прежде чем переходить к кругу, давайте упростим задачу и выберем случайную точку внутри квадрата. Для этого достаточно выбрать случайные координаты  и  в пределах квадрата. В некоторых случаях этот принцип можно применить и к кругам. Например, точка может попадать в круг, но не всегда, поэтому нам нужен дополнительный этап — если выбранная точка находится за границами круга, то мы пробуем снова и снова, пока точка не окажется в круге. Этот процесс является примером выборки с отклонением (rejection sampling) — вместо того, чтобы преобразовать некое распределение, мы просто отклоняем все результаты, находящиеся вне нужного нам интервала.
Способ вполне рабочий, но мне не совсем нравится то, что этот алгоритм иногда приходится исполнять множество раз. Предположим ради простоты, что радиус нашей окружности равен  (но дальнейшие вычисления применимы к кругам любого радиуса). Вероятность того, что выбранная этим алгоритмом точка находится внутри круга, равна площади круга, разделённой на площадь квадрата, или , делённая на , что приблизительно равно . Это значит, что вероятность выбора алгоритмом неправильной точки  раз равна  в степени , где  — некое положительное число. С увеличением  это значение очень быстро становится очень малым. Вероятность четырёхкратного неправильного срабатывания алгоритма меньше четверти процента. Мы можем вычислить среднее количество необходимых попыток, или ожидаемое значение , которое обратно коэффициенту успешного выбора, то есть , что приблизительно равно . То есть в среднем нам достаточно будет сделать только одну попытку. Все эти вычисления дают нам понять, что не стоит беспокоиться о слишком долгом повторении процесса.
Давайте реализуем алгоритм на Python.
```
def rejection_sampling():
while True:
x = random() * 2 - 1
y = random() * 2 - 1
if x * x + y * y < 1:
return x, y
```
Если я выполню эту функцию красивое количество раз (), то получу желаемый результат — точки случайно, но равномерно распределены по кругу.
На этом можно было бы и остановиться, но мы можем сделать так, чтобы подходящая точка гарантированно выбиралась с первого раза. Проблема в том, что мы используем неправильную систему координат (декартову), которая ограничивает нас, заставляя выбирать два значения, представляющие собой расстояния на перпендикулярных осях, которые мы называем  и . Гораздо больше нашим целям подойдёт полярная система координат, в которой точки задаются расстоянием от точки начала координат и углом. Например, рассмотрим точку (, ). В декартовых координатах это будет точка на пересечении  и , но в полярных координатах это будет точка, расположенная в двух единицах от точки начала координат и повёрнутая на угол  радиан.
Достаточно взглянуть на графическое представление этих систем координат, чтобы понять, почему полярная система координат больше подходит для работы с кругами. Итак, всё, что нам нужно сделать — выбрать случайный радиус  в интервале от 0 до 1 и случайный угол  (тета) от  до . Для отрисовки эти координаты необходимо будет преобразовать обратно в декартовы, что можно сделать, умножив  на косинус или синус  для получения, соответственно, координат  и 
Реализация этого алгоритма на Python содержит случайную переменную  от  до  и случайную переменную  от  до , а возвращает , умноженный на косинус  и , умноженный на синус .
```
def random_polar():
theta = random() * 2 * pi
r = random()
return r * cos(theta), r * sin(theta)
```
Если мы снова выполним этот алгоритм 3141 раз, результаты должны выглядеть похожими на алгоритм выборки с отклонением… но это не так.
Как видите, точки гораздо плотнее располагаются в центре круга. Давайте разберёмся, почему. Мы знаем, что проблема не в генерировании , потому что точки равномерно распределены по кругу, поэтому виноват должен быть способ выбора значения . Используемый нами генератор случайных чисел имеет равномерное распределение, то есть вероятность выбора каждого возможного радиуса одинакова. Из этого следует, что каждое кольцо в круге в среднем будет содержать одинаковое количество точек. Возможно, вы уже видите в чём проблема — с увеличением длины окружности кольца количество точек остаётся постоянным, то есть в наружных кольцах с большим радиусом точки имеют меньшую плотность, чем во внутренних.
Мы можем описать процесс выбора радиуса или значения  при помощи функции плотности вероятности (probability density function, PDF) — функции, интеграл которой сообщает нам вероятность попадания непрерывной случайной переменной  в заданный интервал. Сейчас график этой функции является горизонтальной линией от  до , поскольку вероятность выбора каждого значения  одинакова.
Итак, мы знаем, что эта PDF нам не подходит. Давайте выясним, как она должна выглядеть для того, чтобы точки были равномерно распределены в круге. Так как длина окружности линейно зависит от радиуса, для сохранения одинаковой плотности точек их количество должно тоже линейно зависеть от радиуса. Следовательно, наша PDF должна быть линейной функцией, которую мы обозначим как , где  — некий наклон. Но как нам вычислить значение ? Вероятность того, что выбранное значение  будет находиться в интервале от  до , равна 100% или . Следовательно, интеграл или площадь под кривой нашей PDF от  до  тоже должна быть равна . Из этого мы можем вычислить высоту треугольника, а затем вычислить наклон гипотенузы, или составить интеграл. Именно так я и сделаю. При решении интеграла выясняется, что наклон нашей PDF равен , то есть её уравнение имеет вид .
Любопытно то, что каждая PDF имеет интеграл , то есть этот трюк будет срабатывать всегда. Теперь когда мы знаем, как должно выглядеть распределение, можно реализовать его при помощи одного генератора равномерно распределённых случайных чисел. Необходимо найти преобразование, применив которое к равномерному распределению, можно получить нужное нам линейное распределение. Для начала давайте создадим функцию распределения (cumulative distribution function, CDF), которую я обозначу как . Она представляет собой интеграл PDF, который в нашем случае равен . CDF обозначает вероятность того, что случайная переменная  будет меньше или равна аргументу функции.
При помощи этой CDF мы можем воспользоваться стратегией под названием «метод обратного преобразования» (inverse transform sampling): берётся равномерное распределение, например, распределение нашего генератора случайных чисел, и преобразуется так, что хотя наша случайная переменная x не будет иметь равномерного распределения, сами вероятности, отложенные на оси y, будут им обладать. Давайте посмотрим, что произойдёт, если мы возьмём эти вероятности в качестве аргумента функции, по сути получив функцию, обратную нашей CDF. Если мы возьмём какое-то число из равномерно расположенных значений , и посмотрим на соответствующие им значения , то увидим, что получим нужный результат там, где точки более плотно расположены при больших значениях  и более рассеяны при меньших значениях.
Такое понимание уже достаточно ценно, но я покажу вам более строгое доказательство того, что подстановка случайной переменной с равномерным распределением в функцию, обратную нашей CDF, даст нужное нам распределение. Пока мы знаем, что CDF обозначает вероятность того, что случайная переменная  будет меньше или равна аргументу функции , но давайте вернёмся к тому, как выглядит PDF равномерного распределения. Я обозначу случайную переменную с равномерным распределением от  до  как . График — это горизонтальная линия от  до  при  равном . Следовательно, уравнение CDF (интеграл PDF) будет . Из определения CDF следует, что вероятность того, что  будет меньше или равна , равна . Если мы подставим  вместо , то становится ясно, что вероятность того, что значение случайной переменной с равномерным распределением будет меньше или равно , равно , потому что оно находится посередине между  и . Вернувшись к методу обратного преобразования, мы можем сказать, что  равна вероятности того, что  будет меньше или равна . Теперь мы можем применить к обоим сторонам неравенства значение, обратное нашей CDF, что даст нам два неравенства, меньших или равных . Следовательно, , случайная переменная с нужным нам распределением, равна обратному значению CDF, применённому к случайной переменной с равномерным распределением, а мы знаем, что функция, обратная CDF, — это . Давайте реализуем всё это на Python.
```
def sqrt_dist():
theta = random * 2 * pi
r = sqrt(random())
return r * cos(theta), r * sin(theta)
```
Единственное отличие между этой и предыдущей функциями заключается в том, что для вычисления  я теперь беру квадратный корень случайного числа. Снова выполнив алгоритм 3141 раз, мы опять увидим, что точки равномерно распределились по кругу.
Итак, теперь у нас есть два приемлемых способа выбора случайной точки с равномерным распределением внутри круга, но давайте не будем останавливаться. Существует и ещё один очень любопытный способ, приводящий точно к такому же результату.
Круг можно рассматривать как набор бесконечного множества бесконечно узких равнобедренных треугольников, повёрнутых относительно точки. Поэтому мы можем выбрать случайный треугольник, а затем выбрать в этом треугольнике случайную точку, чтобы получить случайную точку с равномерным распределением в круге.
Давайте вернёмся к тому, как мы выбирали случайную точку в квадрате — этот способ можно применить и к параллелограммам. Так как мы имеем дело с равнобедренными треугольниками, воспользуемся ромбом, который, как известно, состоит из двух равнобедренных треугольников, соединённых основаниями. Просто выберем случайную точку на двух соседних сторонах, а затем из каждой точки проведём линию, параллельную соседней стороне, и найдём точку их пересечения. Чтобы ограничить интервал только треугольником, мы можем провести диагональ и отражать все точки, попавшие не в ту часть ромба. Давайте обозначим четыре вершины ромба как , ,  и , две случайные точки на соседних сторонах  и , а выбранную точку . Так как треугольники бесконечно тонкие, угол при вершине  будет стремиться к нулю, и при этом высота ромба тоже будет стремиться к нулю. Это значит, что все его стороны, по сути, становятся параллельными. Следовательно, расстояние от центральной точки  до выбранной точки  равна сумме  и .
Теперь мы при необходимости сможем отразить точку относительно диагонали, которая находится посередине между точками  и .
Всё это уже можно преобразовать в код на Python. Во-первых,  вычисляется как обычно, но это также можно рассматривать как выбор случайного треугольника, так как они бесконечно тонкие, поэтому каждый треугольник получает собственный угол. Затем сложением двух случайных величин  и  вычисляется . Если  больше или равен единице, это значит, что точка находится с неправильной стороны ромба и вычисляется значение её отражения вычитанием . Конструкция  остаётся такой же.
```
def sum_dist():
theta = random() * 2 * pi
r = random() + random()
if r >= 1:
r = 2 - r;
return r * cos(theta), r * sin(theta)
```
Мы снова выполним алгоритм 3141 раз и получим равномерное распределение точек по кругу.
Однако у меня возник вопрос: почему сложение двух случайных величин не равно умножению одной случайной переменной на два? Проще всего рассуждать над этим вопросом на примере игровых костей. Если мы возьмём результат броска одной честной кости и умножим его на два, то увидим, что возвращаются только чётные числа и что кость имеет равномерное распределение. Однако если сложить результаты двух честных костей, то можно увидеть, что вероятность результата  выше, чем вероятность любого другого числа, потому что получить сумму  на двух костях можно шестью разными способами. Сумму же  и  можно получить только одним способом, из-за чего их вероятность становится ниже. Если мы составим график частоты каждого возможного результата, то при приближении суммы к , что является средним  и , частоты сумм увеличиваются.
Если мы представим, что отражаем правую половину графика, результат будет выглядеть очень похожим на желаемую PDF, но на этом я заметил кое-что странное. Оба этих способа вычисляют  как квадратный корень от случайного числа, а отражение суммы двух случайных чисел должно иметь то же распределение с линейной PDF, равной  и квадратной CDF . Поначалу это кажется неправильным: как эти две кажущиеся не связанными друг с другом и совершенно разные функции могут иметь одинаковое распределение? Мы знаем, что распределение способа с квадратным корнем правильное, ведь мы вывели его непосредственно из нужной CDF. Давайте докажем распределение способа с суммами.
К счастью, уже существует распределение Ирвина-Холла, сообщающее нам распределение суммы  равномерно выбранных случайных чисел от 0 до 1. В нашем случае . Вот уравнения для PDF и CDF.
Можно использовать их, но на самом деле это необязательно, потому что существует очень изящный геометрический вывод, хорошо работающий с низкими значениями . Для начала полезно будет отложить две переменные  и  на осях  и , чтобы лучше их визуализировать. Можно начертить линию, представляющую все возможные способы суммирования  и  для получения некого числа  от  до . Уравнение прямой будет иметь вид . Длина этой линии будет пропорциональна PDF, возрастающей в интервале от  до  и снижающейся в интервале от  до . Площадь под этой прямой и в границах этого единичного квадрата представляет собой CDF.
Но нужно помнить о том, что любое значение  от  до  отражается и даёт нам значение . Это значит, что CDF всегда можно представить как площадь треугольника с основанием и высотой , то есть . Однако поскольку все точки в этом треугольнике по сути удваиваются в результате отражения, эту площадь нужно умножить на  и получить нужную нам CDF ().
Но зачем останавливаться на этом? Любая функция, имеющая такое распределение, теоретически должна выбирать значение , генерирующее случайную точку с равномерным распределением внутри круга.
Я покажу вам ещё один способ, но призываю вас попробовать найти собственный, поскольку я перечислил далеко не все варианты. В этом последнем способе выбор значения  выполняется взятием максимума от двух случайных переменных. Я не использую встроенную в Python функцию , поскольку её производительность ниже того, что вы видите в моём коде.
```
def max_dist():
theta = random() * 2 * pi
r = random()
x = random()
if x > r:
r = x
return r * cos(theta), r * sin(theta)
```
Мы снова равномерно распределим 3141 точку в круге, но это нужно доказать. Доказательство выполняется схожим с распределением Ирвина-Холла способом — откладыванием величин  и . Как и ранее, поскольку  равен их максимуму, мы можем разделить квадрат по диагонали. Любая точка, оказавшаяся в красной половине квадрата, возвращает , потому что он больше . Любая точка, оказавшаяся в синей половине квадрата, аналогично возвращает . CDF представлена квадратом с длиной стороны , в котором каждая точка  и  меньше или равна , а площадь квадрата снова даёт нам CDF, равную .
После разбора этих четырёх способов нам осталось протестировать их, чтобы узнать, какой выполняется быстрее всего. Выполнив каждую функцию 3 142 592 раза, мы получили такие значения времени:
*По увеличению скорости выполнения: первый способ (rejection\_sampling), четвёртый (max\_dist), второй (sqrt\_dist) и третий (sum\_dist)*
Значительно быстрее остальных оказалась выборка с отклонением (rejection sampling), и это логично, потому что остальные три способа содержат дополнительные затраты на выполнение операций синуса и косинуса. Значит ли это, что бОльшая часть нашей работы была проделана напрасно и что нам нужно было остановиться раньше? Я так не считаю, потому что если бы не эта задача, мне никогда бы не довелось познакомиться с PDF и CDF, да и с целым множеством интересных геометрических доказательств. | https://habr.com/ru/post/583838/ | null | ru | null |
# День, когда Dodo IS остановилась. Асинхронный сценарий
Привет, Хабр! Каждый SRE в нашей команде когда-то мечтал спокойно спать по ночам. Мечты имеют свойство сбываться. В этой статье я расскажу про это и про то, как мы достигаем производительности и устойчивости своей системы Dodo IS.
> **Цикл статей про крушение системы Dodo IS\***:
>
>
>
> 1. [День, когда Dodo IS остановилась. Синхронный сценарий.](https://habr.com/ru/company/dodopizzaio/blog/440676/)
>
> 2. День, когда Dodo IS остановилась. Асинхронный сценарий.
>
>
>
> \* *Материалы написаны на основе [моего выступления на DotNext 2018 в Москве](https://www.youtube.com/watch?v=XNuAJmOXgYw&fbclid=IwAR29kXTLGh6kdUhGlIXqze90C7kd8WNKZLVLS6LTJghZ-X9-D1qXjQPzHxM)*.
В прошлой статье мы рассмотрели проблемы блокирующего кода в парадигме Preemptive Multitasking. Предполагалось, что необходимо переписать блокирующий код на async/await. Так мы и сделали. Теперь поговорим о том, какие проблемы возникли, когда мы сделали это.
Вводим термин Concurrency
-------------------------
Перед тем, как подобраться к asynс, необходимо ввести термин Concurrency.
> В теории массового обслуживания **Concurrency** – это количество клиентов, которые в данный момент находятся внутри системы. Иногда Concurrency путают с Parallelism, но на самом деле это разные вещи.
Тем, кто столкнулся с термином Concurrency впервые, [я рекомендую видео Роба Пайка](https://blog.golang.org/concurrency-is-not-parallelism). Concurrency – это когда мы имеем дело со многими вещами одновременно, а Parallelism – когда делаем много вещей одновременно.
В компьютерах не так уж много вещей происходят параллельно. Одна из таких вещей – вычисления на нескольких процессорах. Степень параллелизма ограничена количеством потоков CPU.
На самом деле Threads – это часть концепции Preemptive Multitasking, один из способов моделировать Concurrency в программе, когда мы полагаемся на операционную систему в вопросе Concurrency. Эта модель остается полезной до тех пор, пока мы понимаем, что имеем дело именно с моделью Concurrency, а не с параллелизмом.
Async/await – это синтаксический сахар для State Machine, другая полезная модель Concurrency, которая может работать в однопоточной среде. По сути это Cooperative Multitasking – модель сама по себе вообще не учитывает параллелизм. В сочетании с Multithreading, мы получаем одну модель поверх другой, и жизнь сильно усложняется.
Сравнение работы двух моделей
-----------------------------
#### Как всё работало в модели Preemptive Multitasking
Допустим, у нас 20 Threads и 20 запросов в обработке в секунду. На картинке видно пик – 200 запросов в системе одновременно. Как такое могло произойти:
* запросы могли сгруппироваться, если 200 клиентов нажали кнопку в один и тот же момент;
* сборщик мусора мог остановить запросы на несколько десятков миллисекунд;
* запросы могли задержаться в какой-либо очереди, если прокси поддерживает очередь.
Есть масса причин, по которым запросы за короткий интервал времени накопились и пришли единой пачкой. В любом случае, ничего страшного не произошло, они встали в очередь Thread Pool и потихоньку выполнились. Пиков больше нет, всё идет дальше, как ни в чем не бывало.
Предположим, что умный алгоритм Thread Pool (а там есть элементы машинного обучения) решил, что пока нет резона увеличивать количество Threads. Connection Pool в MySql тоже 20, потому что Threads=20. Соответственно, нам нужно только 20 соединений к SQL.
В этом случае, уровень Concurrency сервера с точки зрения внешней системы = 200. Сервер уже получил эти запросы, но еще не выполнил. Однако для приложения, работающего в парадигме Multithreading, количество одновременных запросов ограничено текущим размером Thread Pool = 20. Итак, мы имеем дело со степенью Concurrency = 20.
#### Как всё теперь работает в модели async
Посмотрим, что произойдет в приложении, работающем с async/await при той же нагрузке и распределении запросов. Здесь нет никакой очереди перед тем, как создать Task, и запрос поступает в обработку сразу. Конечно, на короткое время используется Thread из ThreadPool, и первая часть запроса, до обращения в базу данных, выполняется сразу. Поскольку Thread быстро возвращается в Thread Pool, нам не нужно большого количества Threads для обработки. На этой диаграмме мы не отображаем Thread Pool вообще, он прозрачен.
Что это будет означать для нашего приложения? Внешняя картина такая же – уровень Concurrency = 200. При этом ситуация внутри поменялась. Раньше запросы «толпились» в очереди ThreadPool, теперь степень Concurrency приложения тоже равна 200, потому как у нас нет никаких ограничений со стороны TaskScheduler. Ура! Мы достигли цели async – приложение «справляется» практически с любой степенью Concurrency!
#### Последствия: нелинейная деградация системы
Приложение стало прозрачным с точки зрения Concurrency, поэтому теперь Concurrency проецируется на базу данных. Теперь нам нужен пул соединений такого же размера = 200. База данных – это CPU, память, сеть, хранилище. Это такой же сервис со своими проблемами, как и любой другой. Чем больше запросов одновременно пытаемся выполнить, тем медленнее они выполняются.
При полной нагрузке на базу данных, в лучшем случае, Response Time деградирует линейно: вы дали запросов в два раза больше, стало работать в два раза медленнее. На практике из-за конкуренции запросов обязательно возникнет overhead, и, может оказаться, что система будет деградировать нелинейно.
#### Почему так происходит?
Причины второго порядка:
* теперь базе данных нужно одновременно держать в памяти структуры данных для обслуживания большего количества запросов;
* теперь базе данных нужно обслуживать коллекции большего размера (а это алгоритмически невыгодно).
Причина первого порядка:
* contention, о которой уже немного говорилось [в предыдущей статье](https://habr.com/ru/company/dodopizzaio/blog/440676/).
В итоге async борется против ограниченных ресурсов и … побеждает! База данных не выдерживает и начинает замедляться. От этого сервер дополнительно наращивает Concurrency, и система уже не может выйти с честью из этой ситуации.
Синдром внезапной смерти сервера
--------------------------------
Иногда происходит интересная ситуация. У нас есть сервер. Он работает себе такой, все в порядке. Ресурсов хватает, даже с запасом. Потом мы вдруг получаем сообщение от клиентов, что сервер тормозит. Смотрим в график и видим, что был какой-то всплеск активности клиентов, но теперь все в норме. Думаем на DOS атаку или совпадение. Сейчас вроде всё нормально. Только вот сервер продолжает тупить, причем все жестче, пока не начинают сыпаться таймауты. Через некоторое время другой сервер, который использует ту же базу данных тоже начинает загибаться. Знакомая ситуация?
#### Почему умерла система?
Можно попробовать объяснить это тем, что в какой-то момент сервер получил пиковое количество запросов и «сломался». Но мы ведь знаем, что нагрузка была снижена, а серверу после этого очень долго не становилось лучше, вплоть до полного исчезновения нагрузки.
Риторический вопрос: а сервер вообще должен был сломаться от чрезмерной нагрузки? Они так делают?
#### Моделируем ситуацию падения сервера
Здесь мы не будем анализировать графики с реальной производственной системы. В момент падения сервера мы зачастую не можем получить такой график. Сервер исчерпывает ресурс CPU, и как следствие не может записывать логи, отдавать метрики. На диаграммах в момент катастрофы зачастую наблюдается разрыв всех графиков.
SRE должны уметь изготавливать системы мониторинга мало подверженные такому эффекту. Системы, которые в любой ситуации предоставляют хоть какую-то информацию, и, вместе с тем, умеют анализировать post-mortem системы по отрывочным сведениям. Для учебных целей мы в рамках данной статьи используем несколько другой подход.
Попробуем создать модель, которая математически работает так же, как сервер под нагрузкой. Далее будем изучать характеристики сервера. Отбросим нелинейность реальных серверов и смоделируем ситуацию, где при возрастающей сверх номинала нагрузке происходит линейное замедление. В два раза больше, чем нужно запросов – в два раза медленнее обслуживаем.
Такой подход позволит:
* рассмотреть то, что произойдет в лучшем случае;
* снять точные метрики.
Навигация по графику:
* синий – количество запросов к серверу;
* зеленый – ответы сервера;
* желтый – таймауты;
* темно-серый – запросы, которые зря тратили ресурсы сервера, так как клиент не дождался ответа по таймауту. Иногда клиент может сообщить об этом серверу обрывом соединения, но в общем случае такая роскошь может быть технически неосуществима, например, если сервер делает CPU-bound работу, без кооперации с клиентом.
Почему график запросов клиента (синий на диаграмме) получился именно таким? Обычно график заказов в наших пиццериях плавненько растет утром и убывает вечером. Но мы наблюдаем три пика на фоне обычной равномерной кривой. Эта форма графика выбрана для модели не случайно, а по поводу. Модель родилась при расследовании реального инцидента с сервером контакт-центра пиццерий в России во время чемпионата мира по футболу.
Кейс «Чемпионат мира по футболу»
--------------------------------
Мы сидели и ждали, что у нас будет больше заказов. К Чемпионату подготовились, теперь серверы смогут пройти проверку на прочность.
Первый пик – любители футбола идут смотреть чемпионат, они голодны и покупают пиццу. Во время первого тайма они заняты и не могут заказывать. Но равнодушные к футболу люди могут, поэтому на графике дальше все идет как обычно.
И вот кончается первый тайм, и наступает второй пик. Болельщики перенервничали, проголодались и сделали в три раза больше заказов, чем в первый пик. Пицца покупается со страшной скоростью. Потом начинается второй тайм, и снова не до пиццы.
Тем временем, сервер контакт-центра начинает потихоньку загибаться и обслуживать запросы все медленнее и медленнее. Компонент системы, в данном случае – веб-сервер Колл-центра, дестабилизирован.
Третий пик наступит, когда матч закончится. Болельщиков и систему ждет пенальти.
#### Разбираем причины падения сервера
Что произошло? Сервер мог удерживать 100 условных запросов. Мы понимаем, что он рассчитан на эту мощность и больше не выдержит. Приходит пик, который сам по себе не такой большой. Зато серая область Concurrency гораздо выше.
Модель рассчитана так, что Concurrency численно равна количеству заказов в секунду, поэтому визуально на графике оно должно быть такого же масштаба. Однако оно гораздо выше, потому что накапливается.
Мы видим здесь тень от графика – это запросы стали возвращаться к клиенту, выполняться (показано первой красной стрелкой). Масштаб времени здесь условный, чтобы увидеть смещение во времени. Второй пик уже выбил наш сервер. Он упал и стал обрабатывать вчетверо меньше запросов, чем в обычное время.
На второй половине графика видно, что какие-то запросы все-же сначала выполнялись, но потом появились желтые пятна – запросы перестали выполняться совсем.
Еще раз весь график. Видно, что Concurrency зашкаливает. Появляется огромная гора.
Обычно мы анализировали совсем другие метрики: насколько медленно запрос выполнялся, сколько запросов в секунду. А на Concurrency вообще не смотрим, даже не думали про эту метрику. А зря, потому что именно эта величина лучше всего показывает момент отказа сервера.
Но откуда взялась такая огромная гора? Самый большой пик нагрузки-то давно уже прошёл!
Закон Литтла
------------
Закон Литтла регулирует Concurrency.
*L (количество клиентов внутри системы) = λ (скорость их пребывания) ∗ W (время, которое они проводят внутри системы)*
Это в среднем. Однако у нас ситуация развивается драматически, нас среднее не устраивает. Мы это уравнение будем дифференцировать, потом интегрировать. Для этого посмотрим в книгу Джона Литтла, который эту формулу придумал, и увидим там интеграл.
У нас есть количество поступлений в систему и количество тех, кто уходит из системы. Запрос поступает и уходит, когда все выполнено. Ниже изображен регион графика роста, соответствующий линейному росту Concurrency.
Зеленых запросов мало. Это те, которые реально выполняются. Синие – те, которые поступают. Между таймами у нас обычное количество запросов, ситуация стабильная. Но Concurrency все равно растет. Сервер уже не справится с этой ситуацией сам. Это значит, что скоро он упадет.
Но почему Concurrency растет? Смотрим на интеграл константы. У нас ничего не меняется в системе, но интеграл выглядит как линейная функция, которая растет только вверх.
Поиграем?
---------
Объяснение с интегралами сложновато, если не помнить математики. Тут предлагаю размяться и сыграть в игру.
#### Игра № 1
**Предусловия**: На сервер поступают запросы, каждый требует три периода обработки на CPU. Ресурс CPU делится равномерно между всеми задачами. Это похоже на то, как расходуется ресурс CPU при Preemptive Multitasking. Число в клетке означает количество работы, оставшейся после данного такта. За каждый условный такт поступает новый запрос.
Представьте, что поступил запрос. Всего 3 единицы работы, по завершении первого периода обработки осталось 2 единицы.
Во втором периоде наслаивается еще один запрос, теперь оба CPU заняты. Они сделали по единице работы по первым двум запросам. Осталось доделать 1 и 2 единицы для первого и второго запроса соответственно.
Теперь пришел третий запрос, и начинается самое интересное. Казалось бы, первый запрос должен был быть завершен, но в этом периоде уже три запроса делят между собой ресурс CPU, поэтому степени завершенности для всех трех запросов теперь дробные по завершении третьего периода обработки:
Дальше еще интереснее! Добавляется четвертый запрос, и теперь степень Concurrency уже 4, так как всем четырем запросам потребовался ресурс в этом периоде. Тем временем, первый запрос к концу четвертого периода уже выполнился, в следующий период он не переходит, и ему осталось 0 работы для CPU.
Так как первый запрос уже выполнился, подведем итог для него: он выполнялся на треть дольше, чем мы ожидали. Предполагалось, что длина каждой задачи по горизонтали в идеале = 3, по количеству работы. Помечаем его оранжевым, в знак того, что мы не совсем довольны результатом.
Поступает пятый запрос. Степень Concurrency по прежнему 4, но мы видим, что в пятом столбике оставшейся работы в сумме больше. Это происходит, потому что в четвертом столбике оставалось больше несделанной работы, чем в третьем.
Продолжаем еще три периода. Ждем ответов.
– Сервер, алё!
–…
– Ваш звонок очень важен для нас…
Ну вот, наконец-то пришел ответ на второй запрос. Время ответа вдвое дольше, чем ожидалось.
Степень Concurrency выросла уже втрое, и ничто не предвещает, что ситуация изменится к лучшему. Я не рисовал дальше, потому что время ответа на третий запрос уже не влезет в картинку.
> Наш сервер вошел в нежелательное состояние, из которого он никогда не выйдет самостоятельно. **Game over.**
Чем характеризуется GameOver-состояние сервера?
-----------------------------------------------
Запросы накапливаются в памяти неограниченно. Рано или поздно попросту закончится память. Кроме этого, при увеличении масштаба возрастают накладные затраты на CPU на обслуживание различных структур данных. Например, пул соединений теперь должен отслеживать таймауты большего количества соединений, сборщик мусора теперь должен перепроверять большее количество объектов на хипе, и так далее.
Исследовать все возможные последствия накопления активных объектов не является целью этой статьи, но даже простого накопления данных в оперативной памяти уже достаточно, чтобы завалить сервер. Кроме того, мы уже рассмотрели, что сервер-клиент проецирует свои проблемы Concurrency на сервер базы данных, и другие сервера, которые он использует как клиент.
Самое интересное: теперь даже если подать на сервер меньшую нагрузку, он все равно не восстановится. Все запросы будут заканчиваться таймаутом, а сервер будет расходовать все доступные ресурсы.
А чего мы, собственно, ожидали?! Ведь мы заведомо дали серверу количество работы, с которым он не справится.
Когда занимаешься архитектурой распределенной системы, полезно подумать, как обычные люди решают такие проблемы. Возьмем, например, ночной клуб. Он перестанет функционировать, если туда зайдет слишком много людей. Вышибала справляется с проблемой просто: смотрит, сколько человек внутри. Один вышел – другого запускает. Новый гость придет и оценит размер очереди. Если очередь большая, уйдет домой. Что если применить этот алгоритм для сервера?
Давайте поиграем еще раз.
#### Игра № 2
**Предусловия**: Опять у нас два CPU, такие же задачи по 3 единицы, поступающие каждый период, но теперь мы поставим вышибалу, и задачи будут умные — если они видят, что длина очереди 2, то сразу идут домой.
Пришел третий запрос. В этом периоде он стоит в очереди. У него число 3 по окончании периода. Дробных чисел в остатках нет, потому что два CPU выполняют две задачи, по единице за период.
Хотя у нас три запроса наслаиваются, степень Concurrency внутри системы = 2. Третий стоит в очереди и не считается.
Пришел четвертый – та же картина, хотя уже накопилось больше оставшейся работы.
…
…
В шестом периоде третий запрос выполнился с отставанием на треть, и степень Concurrency уже = 4.
Степень Concurrency возросла в два раза. Больше она не может вырасти, ведь мы установили на это явный запрет. С максимальной скоростью выполнились только два первых запроса – те, кто пришел в клуб первыми, пока для всех хватало места.
Жёлтые запросы находились в системе дольше, но они стояли в очереди и не оттягивали на себя ресурс CPU. Поэтому те, кто был внутри спокойно развлекались. Это могло продолжаться и дальше, пока не пришел мужик и не сказал, что в очереди стоять не будет, а лучше отправится домой. Это невыполненный запрос:
Ситуация может повторяться бесконечно, при этом время выполнения запросов остается на одном уровне – ровно вдвое дольше, чем хотелось бы.
Мы видим, что простое ограничение уровня Concurrency устраняет проблему жизнеспособности сервера.
#### Как увеличить жизнеспособность сервера через ограничение уровня Concurrency
Простейшего «вышибалу» можно написать самому. Ниже привожу код с использованием семафора. Тут нет ограничения длины очереди снаружи. Код только для иллюстрации, не нужно его копировать.
```
const int MaxConcurrency = 100;
SemaphoreSlim bulkhead = new SemaphoreSlim(MaxConcurrency, MaxConcurrency);
public async Task ProcessRequest()
{
if (!await bulkhead.WaitAsync())
{
throw new OperationCanceledException();
}
try { await ProcessRequestInternal(); return; }
finally { bulkhead.Release(); }
}
```
Чтобы создать ограниченную очередь, нужно два семафора. Для этого подходит [библиотека Polly](https://github.com/App-vNext/Polly), которую рекомендует Microsoft. Обратите внимание на паттерн Bulkhead. Дословно переводится как «переборка» – элемент конструкции, позволяющий судну не тонуть. Если честно, я считаю, что лучше подходит термин «вышибала». Важно то, что этот паттерн позволяет серверу выживать в безнадежных ситуациях.
Сначала мы на нагрузочном стенде выдавливаем из сервера все, что можно, пока не определяем, сколько запросов он может держать. Например, мы определили, что это 100. Ставим bulkhead.
Дальше сервер пропустит только нужное количество запросов, остальные будут стоять в очереди. Разумно будет выбрать несколько меньшее число, чтобы был запас. Готовой рекомендации на этот счет у меня нет, потому что есть сильная зависимость от контекста и конкретной ситуации.
1. Если поведение сервера стабильно зависит от нагрузки с точки зрения ресурсов, то это число может приближаться к пределу.
2. Если среда подвержена флуктуациям нагрузки, следует выбрать более консервативное число, с учетом размера этих флуктуаций. Такие флуктуации могут возникать по разным причинам, например, для среды исполнения с GC характерны небольшие пики нагрузки на CPU.
3. Если сервер выполняет периодические задачи по расписанию, это также следует учесть. Можно даже разработать адаптивную переборку, которая будет вычислять, сколько можно давать одновременно запросов без деградации сервера (но это уже выходит за рамки данного исследования).
Эксперименты с запросами
------------------------
Взгляните на этот постмортем напоследок, больше мы такого не увидим.
Вся эта серая куча однозначно коррелирует с падением сервера. Серое – смерть для сервера. Попробуем просто срезать это и посмотреть, что произойдет. Кажется, что какое-то количество запросов пойдет домой, просто не выполнится. Но сколько?
#### 100 внутри, 100 снаружи
Оказалось, нашему серверу стало жить очень хорошо и весело. Он постоянно пашет на максимальной мощности. Конечно, когда происходит пик, его вышибает, но совсем ненадолго.
Окрыленные успехом попробуем сделать так, чтобы его совсем не вышибало. Попробуем увеличить длину очереди.
#### 100 внутри, 500 снаружи
Стало получше, но вырос хвост. Это те запросы, которые еще долго потом выполняются.
#### 100 внутри, 1000 снаружи
Раз уж что-то стало лучше, попробуем довести до абсурда. Разрешим длину очереди в 10 раз больше, чем можем обслуживать одновременно:
Если говорить о метафоре клуба и вышибалы, такая ситуация вряд ли возможна – никто не захочет ждать на входе дольше, чем проведет времени в клубе. Мы также не будем делать вид, что это нормальная ситуация для нашей системы.
Лучше вообще не обслуживать клиента, чем томить его на сайте или в мобильном приложении загрузкой каждого экрана по 30 секунд и портить репутацию компании. Лучше сразу честно сказать малой части клиентов, что сейчас мы не можем их обслужить. В противном случае, мы будем в несколько раз медленнее обслуживать всех клиентов, ведь график показывает, что ситуация сохраняется довольно долго.
Есть и еще один риск – другие компоненты системы могут быть не рассчитаны на такое поведение сервера, и, как мы уже знаем, Concurrency проецируется на клиентов.
Поэтому возвращаемся к первому варианту «100 на 100» и думаем, как масштабировать наши мощности.
#### Победитель – 100 внутри, 100 снаружи
¯\\_(ツ)\_/¯
При таких параметрах самая большая деградация по времени выполнения – ровно в 2 раза от «номинала». В то же время – это 100% деградация по времени выполнения запроса.
Если ваш клиент чувствителен ко времени выполнения (а это, как правило, справедливо, как с клиентами-людьми, так и с клиентами-серверами), то можно подумать о дальнейшем снижении длины очереди. В этом случае, мы можем брать какой-то процент от внутренней Concurrency, и будем точно знать, что сервис деградирует по времени ответа не больше, чем на этот процент в среднем.
По сути мы не пытаемся создать очередь, мы пытаемся защититься от флуктуаций нагрузки. Здесь так же, как и в случае определения первого параметра переборки (количество внутри), полезно определить, какие флуктуации нагрузки может накинуть клиент. Так мы будем знать, в каких случаях мы, грубо говоря, упустим прибыль от потенциального обслуживания.
Еще важнее определить, какие флуктуации Latency могут выдержать взаимодействующие с сервером другие компоненты системы. Так мы будем знать, что действительно выжимаем из существующей системы максимум без опасности потерять обслуживание полностью.
Диагноз и лечение
-----------------
Проблему Uncontrolled Concurrency мы лечим с помощью Bulkhead Isolation.
Этот метод, как и другие, рассматриваемые в этой серии статей, удобно реализовывать [библиотекой Polly](https://github.com/App-vNext/Polly).
Преимущество метода в том, что отдельную компоненту системы будет крайне трудно дестабилизировать как таковую. Система приобретает очень предсказуемое поведение по части времени на выполнение успешных запросов и гораздо более высокие шансы на успешное выполнение запросов вцелом.
Однако мы не решаем всех проблем. Например, проблему недостаточной мощности сервера. В данной ситуации нужно заведомо решиться на «сбрасывание балласта» в случае скачка нагрузки, которую мы оценили как чрезмерную.
Дальнейшие меры, которые наше исследование не затрагивает, могут включать, например, динамическое масштабирование. | https://habr.com/ru/post/461081/ | null | ru | null |
# Hibernate+jsp при поддержке сервлетов
Всем привет! В этой статье я расскажу о том, как связать JSP с Hibernate при помощи сервлета. Я надеюсь, что вы умеете работать с Hibernate, если же нет, то настоятельно рекомендую прочитать эту [статью](https://habrahabr.ru/post/320542/). Также я надеюсь, что вы знакомы с сервлетами и хоть раз их успешно запускали.
Для того, чтобы у вас была такая же база данных в MySQL, вставьте туда следующий код:
```
CREATE SCHEMA `hero` ;
CREATE TABLE `hero`.`heroes`
(
`idhero` INT NOT NULL AUTO_INCREMENT,
`name` VARCHAR(45) NOT NULL,
PRIMARY KEY (`idhero`));
```
Создаём maven проект и вставляем следующие зависимости и не только:
```
war
4.3.5.Final
javax.servlet
servlet-api
3.0-alpha-1
provided
commons-fileupload
commons-fileupload
1.2.2
commons-io
commons-io
2.4
org.hibernate
hibernate-core
${hibernate.version}
org.hibernate
hibernate-entitymanager
${hibernate.version}
javaee
javaee-api
5
mysql
mysql-connector-java
5.1.38
javax
javaee-web-api
6.0
provided
org.apache.commons
commons-lang3
3.4
jstl
jstl
1.2
```
Подключаемся к базе данных. Опять же: если вы не знаете, как это делается, то статья об этом и не только выше.
Затем подключаем web модуль.
Заходим в File,Project Structure вкладка modules. Передварительно удалите всё, что есть во вкладке modules(если оно там есть) нажав на -(красненький).Нажимаете на +(зелёный)
и добавьте web модуль:
Дальше во вкладке Artifacts тоже удаляете все артефакты и добавляете новый +,Web Application:Exploded,From modules,OK:
Дальше развертываем Hibernate и для того, чтобы было удобно, засуньте эту модель в папку model, которая находится в by, указав в этот путь при развертке Hibernate.
В папке by создайте папку util, а в ней класс HibernateUtil:
```
package by.util;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
private static SessionFactory sessionFactory=buildSessionFactory();
private static SessionFactory buildSessionFactory() {
try{
return new Configuration().configure().buildSessionFactory();
}catch (Exception e){
throw new ExceptionInInitializerError(e);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}
```
Благодаря HibernateUtil мы можем создать специальный SessionFactory под наш проект.
В папке by создаём папку DAO, в ней класс DAOImple (мы не создаём интерфейс DAO, так как пример небольшой):
```
package by.DAO;
import by.model.HeroesEntity;
import by.util.HibernateUtil;
import org.hibernate.Query;
import org.hibernate.Session;
import java.util.List;
public class DAOImple {
public void saveHero(HeroesEntity heroesEntity){
Session session= HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
session.save(heroesEntity);
session.getTransaction().commit();
session.close();
}
public List getAll(){
Session session=HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
List list=session.createQuery("from HeroesEntity").list();
session.getTransaction().commit();
session.close();
return list;
}
public void update(HeroesEntity heroesEntity){
Session session=HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
session.update(heroesEntity);
session.getTransaction().commit();
session.close();
}
public HeroesEntity getHeroById(int id){
Session session=HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
Query query= session.createQuery("from HeroesEntity where idhero=:id");
query.setInteger("id",id);
HeroesEntity heroesEntity= (HeroesEntity) query.uniqueResult();
session.getTransaction().commit();
session.close();
return heroesEntity;
}
public void deleteHeroes(int id){
Session session=HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
Query query=session.createQuery("from HeroesEntity where idhero=:id");
query.setInteger("id",id);
HeroesEntity heroesEntity= (HeroesEntity) query.uniqueResult();
session.delete(heroesEntity);
session.getTransaction().commit();
session.close();
}
}
```
Класс DAOImple нам нужен для того, чтобы работать с той информацией, что есть в базе данных.
В папке by создаём папку servlets, а в ней создаём сервлет (не класс!) SaveServlet (комментарии в коде):
```
package by.servlets;
import by.DAO.DAOImple;
import by.model.HeroesEntity;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class SaveServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
DAOImple daoImple=new DAOImple();
////////////////////////////////////////
//INDEX.JSP
////////////////////////////////////////
if(request.getParameter("add")!=null){//при нажатии на кнопку add
HeroesEntity heroesEntity=new HeroesEntity();//создаём экземпляр класса модели базы данных
heroesEntity.setIdhero(Integer.parseInt(request.getParameter("id")));//задаём ему id взятый из поля c именем id
heroesEntity.setName(request.getParameter("name"));//аналогично с прошлой строкой
daoImple.saveHero(heroesEntity);//сохраняем в базу данных полученный объект
request.setAttribute("list",daoImple.getAll());//создаём аттрибут который взял в себя всё что есть в базе данных
RequestDispatcher requestDispatcher=request.getRequestDispatcher("list.jsp");//перебрасываемся на list.jsp
requestDispatcher.forward(request,response);
}
if(request.getParameter("showAll")!=null){//при нажатии на кнопку showALL
request.setAttribute("list",daoImple.getAll());//создаём аттрибут который взял в себя всё что есть в базе данных
RequestDispatcher requestDispatcher=request.getRequestDispatcher("list.jsp");//перебрасываемся на list.jsp
requestDispatcher.forward(request,response);
}
///////////////////////////////////////////////////
//LIST.JSP
///////////////////////////////////////////////////
String action=request.getParameter("action");//создаём action который будет реагировать на те или иные действия
if(action.equalsIgnoreCase("update")){//если action отреагировал на update
request.setAttribute("hero",daoImple.getHeroById(Integer.parseInt(request.getParameter("idhero"))));//создаём атрибут который по id возвращает определённого HeroesEntity
RequestDispatcher requestDispatcher=request.getRequestDispatcher("update.jsp");////перебрасываемся на update.jsp
requestDispatcher.forward(request,response);
}
if(action.equalsIgnoreCase("delete")){//если action отреагировал на update
daoImple.deleteHeroes(Integer.parseInt(request.getParameter("idhero")));//удаляем по id
request.setAttribute("list",daoImple.getAll());//создаём аттрибут который взял в себя всё что есть в базе данных
RequestDispatcher requestDispatcher=request.getRequestDispatcher("list.jsp");//перебрасываемся на list.jsp
requestDispatcher.forward(request,response);
}
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
DAOImple daoImple = new DAOImple();
//////////////////////////////////
// UPDATE.JSP
//////////////////////////////////
if (request.getParameter("update") != null) {//при нажатии на кнопку update
HeroesEntity heroesEntity = new HeroesEntity();//создаём экземпляр класса
heroesEntity.setIdhero(Integer.parseInt(request.getParameter("idhero")));//задаём id из поля idhero
heroesEntity.setName(request.getParameter("name"));//задаём name из поля name
daoImple.update(heroesEntity);//апдейтим
request.setAttribute("list", daoImple.getAll());//создаём аттрибут который взял в себя всё что есть в базе данных
RequestDispatcher requestDispatcher = request.getRequestDispatcher("list.jsp");//перебрасываемся на list.jsp
requestDispatcher.forward(request, response);
}
}
}
```
Регестрируем сервлет в web.xml:
```
xml version="1.0" encoding="UTF-8"?
SaveServlet
by.servlets.SaveServlet
SaveServlet
/save
```
В папке web создаём index.jsp стартовую страницу:
```
<%--
Created by IntelliJ IDEA.
User: УВД
Date: 29.05.2017
Time: 18:18
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
```
а также list.jsp:
```
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
| | |
| --- | --- |
| id | name |
| ${list.idhero} | ${list.name} | ">update | [delete](/save?action=delete&idhero=${list.idhero}) |
```
и update.jsp:
```
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
">
">
```
Дальше настраиваем TomCat:
Даём ему артефакт(можно просто нажать внизу на кнопку с красной лампочкой и названием Fix):
Я надеюсь, что вам удалось запустить этот пример. Этот пример на github:[здесь](https://github.com/Dardem30/Hibernate-JSP).
Удачи! | https://habr.com/ru/post/329924/ | null | ru | null |
# Хлебные крошки (breadcrumbs) в asp.net MVC3
В данном посте будет рассмотрен процесс создания меню навигации и хлебных крошек в проекте asp.net MVC3. Сначала мы создадим пустой проект, потом добавим sitemap провайдер, несколько контроллеров и представлений и в итоге заставим провайдер вывести хлебные крошки.
#### УСТАНОВКА
Давайте начнем с **пустого** проекта MVC3. Запустите Visual Studio. Создайте новый Asp.Net MVC3 Web application. Я назову его SitemapDemo:
Для демонстрации я выбрал пустой шаблон с движком визуализации Razor.
Теперь, прежде чем что-либо делать, давайте вернемся и поставим [NuGet](http://nuget.org/) пакет. Выберите **View > Other Windows** и затем выберите “**Package Manager Console**”:
Чтобы добавить Asp.net MVC sitemap provider в текущий проект, нужно ввести следующую команду в Package Manager Console и нажать enter:
`PM> Install-Package MvcSiteMapProvider`
Эта команда скачает необходимые файлы (dlls, cshtml files) и добавит их в ваш MVC проект. Операция может занять несколько минут, в зависимости от вашего соединения. В случае успеха Package Manager Console выведет что-то вроде этого:
`PM> Install-Package MvcSiteMapProvider
Successfully installed 'MvcSiteMapProvider 3.1.0.0'.
Successfully added 'MvcSiteMapProvider 3.1.0.0' to SitemapDemo.
PM>`
Теперь давайте посмотрим что в действительности NuGet package manager добавил в наш проект:
* SitemapDemo > References > MvcSiteMapProvider – Ссылка на MvcSiteMapProvider.dll
* SitemapDemo > Mvc.sitemap – This file will be used to describe our MVC3 website in XML nodes
* SitemapDemo > Views > Shared > DisplayTemplates > MenuHelperModel.cshtml
* SitemapDemo > Views > Shared > DisplayTemplates > SiteMapHelperModel.cshtml
* SitemapDemo > Views > Shared > DisplayTemplates > SiteMapNodeModel.cshtml
* SitemapDemo > Views > Shared > DisplayTemplates > SiteMapNodeModelList.cshtml
* SitemapDemo > Views > Shared > DisplayTemplates > SiteMapPathHelperModel.cshtml
* SitemapDemo > Views > Shared > DisplayTemplates > SiteMapTitleHelperModel.cshtml
Т.к. в качестве движка визуализации мы используем Razor, мы можем удалить asax файлы, которые были добавлены в папка **SitemapDemo > Views > Shared > DisplayTemplates**. Вот как теперь выглядит наш проект:
Теперь все готово. Теперь давайте добавим несколько контроллеров и представлений перед тем, как начнем играться с SiteMapProvider.
##### ВАЖНО
MVC Sitemap provider в некоторых случаях тихо умрет если мы попытаемся заставить его работать с методами контроллеров, которых не существует, или несуществующими представлениями. Поэтому мы сначала создаем контроллеры и представления.
У всех сайтов есть домашняя страница, так что для начала давайте создадим ее. Кликаем правой кнопкой по папке Controllers и создаем контроллер “HomeController”:
Теперь ваш контроллер создан и отрыт, правый клик по действию Index и выбираем “**Add View…**”
В диалоге добавления представления просто жмем "**Add**". Ничего не надо менять. Теперь давайте поменяем текст в созданной странице. Добавим заголовок по типу “Index – this is the home page”.
Теперь по тому же принципу давайте добавим еще один контроллер. Назовем его NewsController. Добавим в него еще один метод “Sports”:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
namespace SitemapDemo.Controllers
{
public class NewsController : Controller
{
//
// GET: /News/
public ActionResult Index()
{
return View();
}
//
// GET: /News/Sports/
public ActionResult Sports()
{
return View();
}
}
}
```
Теперь давайте добавим представления для каждого метода контроллера NewsController. Сделаем это тем же способом, каком мы добавляли представления для домашней страницы – правым кликом по каждому методу в контроллере. Опять-таки, мы просто оставляем настройки диалогового окна “Add View” по-умолчанию и просто жмем “Add” для обоих представлений.
Давайте добавим еще один контроллер – AboutController. Как только создали, оставляем его без изменений и добавляем новое представление Index. Также редактируем заголовок на странице
Теперь в нашем проекте есть 4 страницы. Стоит их протестировать перед тем как начнем внедрять Site Map Provider. Снизу скриншоты получившихся страниц:
**Скриншоты**localhost:xxxx
localhost:xxxx/News
localhost:xxxx/News/Sports
localhost:xxxx/About
Отлично, теперь у нас маленький сайт с простой структурой. Представим структуру сайт в диаграмме:
Визуализация макета сайта поможет нам корректно описать структуру файла Mvc.sitemap. Наша страница Index является оберткой всего сайта, т.к. является домашней страницей и первой страницей при входе на сайт.
Теперь перейдем в конфигурации карты сайта. Начнем с редактирования файла Mvc.sitemap, которые находится в корне нашего проекта. Файл содержит в себе xml ноды, необходимые для представления комбинаций ваших контроллеров и методов.
Отредактируйте Mvc.Sitemap следующим образом:
```
xml version="1.0" encoding="utf-8" ?
```
И так мы сформировали структуру нашего сайта в файле MVC.Sitemap. Обычная ошибка здесь — забыть обернуть весь сайт xml-нодом, представляющим домашнюю страницу, которую посетитель видит в самом начале.
#### ДОБАВЛЕНИЕ НАВИГАЦИИ
Теперь, когда у нас есть несколько контроллеров и методов и структура сайта должным образом описана в Mvc.Sitemap, давайте добавим навигацию на страницы.
Откройте \_Layout.cshtml, находящийся в папке Views/Shared. Измените код тела страницы следующим образом:
```
@Html.MvcSiteMap().Menu(false, true, true)
@RenderBody()
```
Так мы вызываем библиотеку MvcSiteMap и говорим вывести меню навигации на всех страницах. Параметры вызова метода говорят о следующем:
* Мы не хотим стартовать с текущего нода
* Мы хоти показывать ноды в дочерних уровнях
* Мы хотим показать корневой нод. Если установить false, то нод “Home” не будет показан
Если запустим наше приложение, мы должны увидеть меню навигации на каждой странице:
#### РЕДАКТИРОВАНИЕ ПРЕДСТАВЛЕНИЯ НАВИГАЦИИ
Нам удалось вывести простое меню навигации на страницы нашего сайта. Если вы захотите изменить стили верстку, просто измените код в **Views/Shared/DisplayTemplates/MenuHelperModel.cshtml**. Давайте сделаем небольшое изменение — поменяем маркеры элементов списка с кружков на квадраты:
```
@foreach (var node in Model.Nodes) {
* @Html.DisplayFor(m => node)
@if (node.Children.Any()) {
@Html.DisplayFor(m => node.Children)
}
}
```
Можете обновить страницу без необходимости пересборки проекта. Начальная страница News должна выглядеть так:
#### ХЛЕБНЫЕ КРОШКИ
Так же легко мы можем добавить хлебные крошки. Откроем наш \_Layout.cshtml и напишем следующий код:
```
@Html.MvcSiteMap().Menu(false, true, true)
Start of Breadcrumbs:
@Html.MvcSiteMap().SiteMapPath()
@RenderBody()
```
Теперь на всех страницах есть удобные хлебные крошки:
Аналогично, если захотим настроить внешний вид хлебных крошек, нужно отредактировать файл **Views/Shared/DisplayTemplates/SiteMapPathHelperModel.cshtml**.
#### ДИНАМИЧНЫЙ URL / ПАРАМЕТРИЗОВАННЫЙ URL
Любой реальный сайт в какой-то момент будет использовать динамичный или параметризованный URL. Добавить динамичный URL в MVC Sitemap довольно просто, если знаешь как. Давайте начнем с добавления нового метода в NewsController:
```
//GET: News/Article/x
public ActionResult Article(int id)
{
ViewBag.id = id;
return View();
}
```
Теперь добавим представление. Отредактируем Article.cshtml следующим образом:
```
@{
ViewBag.Title = "Article";
}
Viewing Article @ViewBag.id
---------------------------
```
Откроем страницу в браузере localhost:xxxx/News/Article/1234:
Отметим, что новая страница не отмечена в sitemap и поэтому хлебные крошки пусты.
Для того, чтобы вставить в страницу в меню навигации, сначала нужно решить, где она будет находиться. Я хочу, чтобы она находилась внутри секции News. Отредактируем **Mvc.Sitemap** и добавим атрибут Key к ноду “News”.
```
```
Теперь добавим атрибуты к методу Article контроллера News:
```
//GET: News/Article/x
[MvcSiteMapNode(Title = "Article", ParentKey = "News")]
public ActionResult Article(int id)
{
ViewBag.id = id;
return View();
}
```
Соберем проект и откроем в браузере localhost:xxxx/News/Article/1234:
Теперь у нас есть хлебные крошки и меню навигации на новой странице, несмотря на динамичный URL!
#### СКАЧАТЬ РЕШЕНИЕ
Скачать решение можете [здесь](http://www.sendspace.com/file/48g1nw).
Перевод статьи: [edspencer.me.uk/2011/09/20/mvc-sitemap-provider-tutorial-2-breadcrumbs](http://edspencer.me.uk/2011/09/20/mvc-sitemap-provider-tutorial-2-breadcrumbs/) | https://habr.com/ru/post/178087/ | null | ru | null |
# Вариативность органики: как сделать так, чтобы искусственное выглядело естественным
* Раскрашиваем фрактал на основании глубины.
* Применяем случайную вариативность на основе последовательности.
* Добавляем листья с отличающимся внешним видом.
* Реализуем провисание фрактала под воздействием «гравитации».
* Добавляем вариативности для поворота и иногда меняем его направление.
В этом туториале мы изменим фрактал так, чтобы он выглядет более органически, нежели математически.
Туториал сделан в Unity 2019.4.18f1.
*Модифицированный фрактал, выглядящий органическиим.*
Градиент цвета
--------------
Фрактал, созданный нами в [предыдущем туториале](https://catlikecoding.com/unity/tutorials/basics/jobs/), очевидно, является результатом применения математики. Он выглядит строгим, точным, формальным и однородным. Он не выглядит ни органическим, ни живым. Однако внеся некоторые изменения, мы можем заставить математическое выглядеть в определнной степени органическим. Для этого мы внесём вариативность и случайность, а также симулируем поведение органики.
Наиболее простой способ повышения вариативности фрактала — это замена однородного цвета диапазоном цветов, и проще всего привязать его к уровню каждого отрисовываемого экземпляра.
### Переопределяем цвет
Наш поверхностный DRP-шейдер имеет свойство *\_Color*, которое мы пока настраиваем изменением материала, но можем переопределять в коде. Для этого будем отслеживать его идентификатор во `Fractal`.
```
static readonly int
colorId = Shader.PropertyToID("_Color"),
matricesId = Shader.PropertyToID("_Matrices");
```
Затем вызовем `SetColor` для блока свойства в цикле отрисовки внутри `Update`. Сначала мы зададим белый цвет, умноженный на текущее значение итератора цикла и разделённое на длину буфера минус один. При этом первый уровень станет чёрным, а последний — белым.
```
for (int i = 0; i < matricesBuffers.Length; i++) {
ComputeBuffer buffer = matricesBuffers[i];
propertyBlock.SetColor(
colorId, Color.white * (i / (matricesBuffers.Length - 1))
);
propertyBlock.SetBuffer(matricesId, buffer);
Graphics.DrawMeshInstancedProcedural(
mesh, 0, material, bounds, buffer.count, propertyBlock
);
}
```
Чтобы придать всем промежуточным уровням оттенки серого это должно быть деление с плавающей запятой, а не целочисленное, не имеющее дробной части. Мы можем обеспечить его, сделав вычитание единицы в делителе вычитанием с плавающей запятой. Остальная часть вычислений тоже станет вычислениями с плавающей запятой.
```
propertyBlock.SetColor(
colorId, Color.white * (i / (matricesBuffers.Length - 1f))
);
```
Чтобы это работало в графе шейдера URP, нам нужно убедиться, что для albedo используется *\_Color*. Внутреннее имя свойства отображается в графе шейдера как имя *Reference* свойства на blackboard.
*Внутреннее название Albedo — *\_Color*.*
В результате получается фрактал в градациях серого, идущий от чёрного цвета в корневом экземпляре до белого в экземплярах-листьях, как в DRP, так и в URP.
*Фрактал в градиентных оттенках серого.*
Обратите внимание, что вычитание единицы в делителе необходимо для получения белого на самом глубоком уровне. Но если глубина фрактала равна 1, то это приведёт к делению на ноль и к недопустимому цвету. Чтобы избежать этого, мы увеличим минимальную глубину до 2.
```
[SerializeField, Range(2, 8)]
int depth = 4;
```
### Интерполяция между цветами
Мы не ограничены только серыми или монохромными градиентами. Можно выполнять интерполяцию между двумя любыми цветами, вызывая статический метод `Color.Lerp` с двумя цветами и коэффициентом, который мы ранее использовали в качестве интерполятора. Таким образом мы создадим в `Update` двухцветный градиент, например, от жёлтого к красному.
```
propertyBlock.SetColor(
colorId, Color.Lerp(
Color.yellow, Color.red, i / (matricesBuffers.Length - 1f)
)
);
```
*Фрактал в жёлто-красном градиенте.*
### Настраиваемый градиент
Мы можем сделать ещё один шаг и реализовать поддержку произвольных градиентов, имеющих больше двух настраиваемых цветов и неравномерное распределение. Это можно сделать при помощи типа `Gradient` движка Unity. Используем его, чтобы добавить во
`Fractal` настраиваемый градиент.
```
[SerializeField]
Material material = default;
[SerializeField]
Gradient gradient = default;
```
*Свойство Gradient, которому заданы белый, красный и чёрный цвета.*
Чтобы использовать градиент, заменим вызов `Color.Lerp` в `Update` на вызов `Evaluate` градиента, снова с тем же значением интерполятора.
```
propertyBlock.SetColor(
colorId, gradient.Evaluate(i / (matricesBuffers.Length - 1f))
);
```
*Фрактал с настраиваемым бело-красно-чёрным градиентом.*
Произвольные цвета
------------------
Раскрашенный градиентом фрактал выглядит интереснее, чем однородный, но заметно, что раскраска реализована по формуле. В органических объектах обычно присутствует некая вариативность цвета, кажущаяся случайной. В нашем случае это означает, что отдельные экземляры мешей должны демонстрировать вариативность цветов.
### Функция цвета в шейдере
Чтобы одновременно выполнить работу и для поверхностного шейдера, и для графа шейдера, мы будем передавать цвет экземпляра через HLSL-файл *FractalGPU*. Начнём с объявления в нём поля свойства *\_Color*, за которым следует функция `GetFractalColor`, которая просто возвращает это поле. Разместим её над функциями графа шейдера.
```
float4 _Color;
float4 GetFractalColor () {
return _Color;
}
void ShaderGraphFunction_float (float3 In, out float3 Out) {
Out = In;
}
```
Затем удалим избыточное теперь свойство из поверхностного шейдера и вызовем `GetFractalColor` внутри `ConfigureSurface` вместо прямого доступа к полю.
```
//float4 _Color;
float _Smoothness;
void ConfigureSurface (Input input, inout SurfaceOutputStandard surface) {
surface.Albedo = GetFractalColor().rgb;
surface.Smoothness = _Smoothness;
}
```
Мы больше не используем инспектор материалов для настройки albedo, поэтому можем удалить его из блока `Properties`.
```
Properties {
//_Color ("Albedo", Color) = (1.0, 1.0, 1.0, 1.0)
_Smoothness ("Smoothness", Range(0,1)) = 0.5
}
```
Раскроем цвет фрактала нашему графу шейдера, добавив в функции графа выходной параметр, который мы для него создали.
```
void ShaderGraphFunction_float (float3 In, out float3 Out, out float4 FractalColor) {
Out = In;
FractalColor = GetFractalColor();
}
void ShaderGraphFunction_half (half3 In, out half3 Out, out half4 FractalColor) {
Out = In;
FractalColor = GetFractalColor();
}
```
В самом графе шейдера мы сначала должны удалить свойство *Albedo*. Его можно удалить через контекстное меню, открытое правой клавишей мыши на её метке на blackboard.
*Осталось только свойство smoothness.*
Затем добавим вывод к нашем ноду функции.
*Дополнительный вывод *FractalColor* нашей функции.*
И наконец соединим новый вывод с основным albedo.
*Используем *FractalColor* в качестве albedo.*
### Привязываем цвет к идентификатору экземпляра
Чтобы добавить вариативность, зависящую от экземпляра, нам нужно каким-то образом привязать `GetFractalColor` к идентификатору отрисовываемого экземпляра. Так как это целочисленное число, отсчёт которого ведётся с нуля, проще всего протестировать это можно, например, возвращая идентификатор экземпляра, уменьшенный на три порядка величин, что даст нам градиент в оттенках серого.
```
float4 GetFractalColor () {
return unity_InstanceID * 0.001;
}
```
Но теперь нам также нужно гарантировать, что мы выполняем доступ к идентификатору экземпляра только для вариантов шейдера, у которых включено процедурное создание экземпляров, как мы делали это в `ConfigureProcedural`.
```
float4 GetFractalColor () {
#if defined(UNITY_PROCEDURAL_INSTANCING_ENABLED)
return unity_InstanceID * 0.001;
#endif
}
```
Разница в данном случае заключается в том, что нам всегда нужно что-то возвращать, даже несмотря на то, что это не имеет особого смысла. Поэтому мы просто будем возвращать для вариантов шейдера без создания экземпляров заданный цвет. Это реализуется вставкой директивы `#else` перед `#endif` и возвратом между ними цвета.
```
#if defined(UNITY_PROCEDURAL_INSTANCING_ENABLED)
return unity_InstanceID * 0.001;
#else
return _Color;
#endif
```
*Раскраска по идентификатору экземпляра.*
Это демонстрирует, что наше решение работает, хоть и выглядит ужасно. Мы можем сделать градиент более приятным, например, повторяя его через каждые пять экземпляров. Для этого мы используем остаток от деления идентификатора экземпляра на пять при помощи оператора `%`. Это превращает ряд идентификаторов в повторяющуюся последовательность 0, 1, 2, 3, 4, 0, 1, 2, 3, 4,… Затем мы уменьшим их в четыре раза, чтобы интервал снизился с 0–4 до 0–1.
```
return (unity_InstanceID % 5.0) / 4.0;
```
*Раскраска делением с остатком на 5.*
Получившаяся раскраска уже кажется на первый взгляд произвольной, даже несмотря на регулярную зацикленность градиента, потому что она не полностью совпадает с геометрической структурой фрактала. Заметный паттерн заключается в том, что центральный столбец всегда чёрный, потому что состоит из первого экземпляра каждого уровня. Это явление также проявляет себя на более глубоких уровнях, когда последовательность начинает совпадать с геометрией.
Мы можем изменить паттерн, меняя длину последовательности, например, увеличив её до десяти. Это добавляет больше вариативности и снижает повторяемость чёрных столбцов, хоть и выделяет их сильнее.
```
return (unity_InstanceID % 10.0) / 9.0;
```
*Раскраска делением с остатком на 10.*
### Ряды Вейля
Немного иной способ создания повторяющегося градиента — это использование ряда Вейля. Если вкратце, то это ряды вида 0X поделить на 1 с остатком, 1X поделить на 1 с остатком, 2X поделить на 1 с остатком, 3X поделить на 1 с остатком, и так далее. Таким образом мы получаем только дробные значения из интервала 0–1, не включая 1. Если X — иррациональное число, то этот ряд будем равномерно распределён в данном интервале.
На самом деле нам не нужно идеальное распределение, только достаточная вариативность. В качестве X подойдёт случайное значение в интервале 0–1. Например, рассмотрим 0.381:
0.000, 0.381, 0.762, 0.143, 0.524, 0.905, 0.286, 0.667, 0.048, 0.429, 0.810, 0.191, 0.572, 0.953, 0.334, 0.715, 0.096, 0.477, 0.858, 0.239, 0.620, 0.001, 0.382, 0.763, 0.144, 0.525.
И мы получаем повторения почти трёхступенчатых, но иногда двухступенчатых возрастающих градиентов, каждый из которых немного отличается. Паттерн повторяется спустя 21 ступень, но со сдвигом на 0.001. При других значениях будут создаваться другие паттерны с другими градиентами, которые могут быть длиннее, короче или обратными.
В шейдере мы можем реализовать этот ряд простым умножением и передачей результата в функцию `frac`.
```
return frac(unity_InstanceID * 0.381);
```
*Раскрашенный ряд, основанный на значении 0.381.*
### Случайный коэффициент и смещение
Результат использования дробного ряда выглядит приемлемо, но мы всё равно получаем эти чёрные столбцы. Можно избавиться от них, добавив к ряду различное смещение для каждого уровня, и даже использовать на каждом уровне свой ряд. Для этого добавим вектор свойства шейдера для двух чисел ряда, первое будет множителем, а второе смещением, а затем используем их в `GetFractalColor`. Смещение должно прибавляться до изолирования дробной части значения, чтобы оно применило к ряду зацикленный сдвиг.
```
float2 _SequenceNumbers;
float4 GetFractalColor () {
#if defined(UNITY_PROCEDURAL_INSTANCING_ENABLED)
return frac(unity_InstanceID * _SequenceNumbers.x + _SequenceNumbers.y);
#else
return _Color;
#endif
}
```
Будем отслеживать идентификатор свойства шейдера в `Fractal`.
```
static readonly int
colorId = Shader.PropertyToID("_Color"),
matricesId = Shader.PropertyToID("_Matrices"),
sequenceNumbersId = Shader.PropertyToID("_SequenceNumbers");
```
Затем добавим массив чисел ряда для каждого уровня, изначально приравненный к нашей текущей конфигурации, то есть к 0.381 и 0. Для этого мы используем тип `Vector4`, потому что GPU можно передавать только четырёхкомпонентные векторы, даже если нам нужно меньше компонентов.
```
Vector4[] sequenceNumbers;
void OnEnable () {
…
sequenceNumbers = new Vector4[depth];
int stride = 12 * 4;
for (int i = 0, length = 1; i < parts.Length; i++, length *= 5) {
…
sequenceNumbers[i] = new Vector4(0.381f, 0f);
}
…
}
void OnDisable () {
…
sequenceNumbers = null;
}
```
Зададим число ряда для каждого уровня в цикле отрисовки в `Update`, вызывая `SetVector` для блока свойств.
```
propertyBlock.SetBuffer(matricesId, buffer);
propertyBlock.SetVector(sequenceNumbersId, sequenceNumbers[i]);
```
Далее, чтобы сделать ряды произвольными и разными для каждого уровня, мы заменим постоянные заданные числа ряда случайными значениями. Для этого мы воспользуемся для этого `UnityEngine.Random`, но этот тип конфликтует с `Unity.Mathematics.Random`, поэтому используем соответствующий тип явным образом.
```
using quaternion = Unity.Mathematics.quaternion;
using Random = UnityEngine.Random;
```
Затем для получения случайного значения просто заменим две константы на `Random.value`, возвращающий значение в интервале 0–1.
```
sequenceNumbers[i] = new Vector4(Random.value, Random.value);
```
*Раскрашенные ряды со случайными коэффициентами и смещениями.*
### Два градиента
Чтобы скомбинировать случайный ряд с имеющимся градиентом, мы добавим второй градиент и будем передавать оба цвета GPU. Поэтому заменим одно свойство цвета свойствами для цветов A и B.
```
static readonly int
colorAId = Shader.PropertyToID("_ColorA"),
colorBId = Shader.PropertyToID("_ColorB"),
matricesId = Shader.PropertyToID("_Matrices"),
sequenceNumbersId = Shader.PropertyToID("_SequenceNumbers");
```
Также заменим один настраиваемый градиент градиентами A и B.
```
[SerializeField]
Gradient gradientA = default, gradientB = default;
```
Затем вычислим оба градиента в цикле отрисовки `Update` и зададим их цвета.
```
float gradientInterpolator = i / (matricesBuffers.Length - 1f);
propertyBlock.SetColor(colorAId, gradientA.Evaluate(gradientInterpolator));
propertyBlock.SetColor(colorBId, gradientB.Evaluate(gradientInterpolator));
```
*Свойства двух градиентов.*
Также заменим свойство одного цвета в *FractalGPU* на два.
```
//float4 _Color;
float4 _ColorA, _ColorB;
```
И выполним интерполяцию между ними в `GetFractalColor` при помощи `lerp`, взяв в качестве интерполятора результат ряда.
```
return lerp(
_ColorA, _ColorB,
frac(unity_InstanceID * _SequenceNumbers.x + _SequenceNumbers.y)
);
```
Для случая `#else` просто будем возвращать цвет A.
```
#else
return _ColorA;
#endif
```
*Раскраска двумя градиентами.*
Обратите внимание, что результат является не двоичным выбором из двух цветов на экземпляр, а смешением.
Листья
------
Распространённая особенность растений заключается в том, что их конечные части специализированы. Примерами этого являются листья, цветы и фрукты. Мы можем добавить эту особенность в наш фрактал, сделав самый глубокий уровень отличающимся от остальных. Теперь мы будем считать его уровнем листьев, хоть он и не представляет собой настоящие листья.
### Цвета листьев
Чтобы сделать экземпляры-листья нашего фрактала отличающимися, мы придадим им другой цвет. Хоть мы и можем сделать это просто через градиент, удобнее будет настраивать цвет листа отдельно, оставив градиенты для ствола, ветвей и побегов. Поэтому добавим во `Fractal` опции конфигурации для двух цветов листьев.
```
[SerializeField]
Gradient gradientA = default, gradientB = default;
[SerializeField]
Color leafColorA = default, leafColorB = default;
```
*Свойства цветов листьев.*
В `Update` определим перед циклом отрисовки индекс листа, который равен последнему индексу.
```
int leafIndex = matricesBuffers.Length - 1;
for (int i = 0; i < matricesBuffers.Length; i++) { … }
```
Затем внутри цикла непосредственно используем настроенные для уровня листьев цвета, и вычислим градиенты для всех остальных уровней. Кроме того, поскольку теперь мы завершаем градиент на один шаг раньше, то при вычислении интерполятора вычитаем из длины буфера не 1, а 2.
```
Color colorA, colorB;
if (i == leafIndex) {
colorA = leafColorA;
colorB = leafColorB;
}
else {
float gradientInterpolator = i / (matricesBuffers.Length - 2f);
colorA = gradientA.Evaluate(gradientInterpolator);
colorB = gradientB.Evaluate(gradientInterpolator);
}
propertyBlock.SetColor(colorAId, colorA);
propertyBlock.SetColor(colorBId, colorB);
```
*Фрактал с отличающимися цветами листьев.*
Обратите внимание, что это изменение заставляет нас ещё больше инкрементировать минимальную глубину фрактала.
```
[SerializeField, Range(3, 8)]
int depth = 4;
```
### Меш листа
Теперь мы обрабатываем самый нижний уровень отдельно, поэтому для его отрисовки можем использовать и другой меш. Добавим для этого поле конфигурации. Благодаря этому в качестве листьев можно использовать куб, ведь для всего остального мы используем сферы.
```
[SerializeField]
Mesh mesh = default, leafMesh = default;
```
*Свойству меша листа задан куб.*
Используем соответствующий меш при вызове `Graphics.DrawMeshInstancedProcedural` в `Update`.
```
Mesh instanceMesh;
if (i == leafIndex) {
colorA = leafColorA;
colorB = leafColorB;
instanceMesh = leafMesh;
}
else {
float gradientInterpolator = i / (matricesBuffers.Length - 2f);
colorA = gradientA.Evaluate(gradientInterpolator);
colorB = gradientB.Evaluate(gradientInterpolator);
instanceMesh = mesh;
}
…
Graphics.DrawMeshInstancedProcedural(
instanceMesh, 0, material, bounds, buffer.count, propertyBlock
);
```
*Кубы в качестве листьев.*
Кроме того, что это выглядит интереснее, использование кубов в качестве листьев значительно повышает производительность, потому что большинство экземпляров теперь является кубами.
| Глубина | URP | DRP |
| --- | --- | --- |
| 6 | 430 | 142 |
| 7 | 140 | 91 |
| 8 | 49 | 31 |
### Smoothness
Кроме отличающегося цвета мы также можем придать листьям другую шероховатость (smoothness). На самом деле, мы можем варьировать smoothness так же, как варьируем цвет, на основании второго ряда. Чтобы настроить этот второй ряд нам достаточно заполнить в `OnEnable` два оставшихся компонента вектора чисел ряда случайными значениями.
```
sequenceNumbers[i] = new Vector4(
Random.value, Random.value, Random.value, Random.value
);
```
Затем мы по отдельности интерполируем каналы RGB и A в `GetFractalColor` на основании двух других заданных чисел для канала A.
```
float4 _SequenceNumbers;
float4 GetFractalColor () {
#if defined(UNITY_PROCEDURAL_INSTANCING_ENABLED)
float4 color;
color.rgb = lerp(
_ColorA.rgb, _ColorB.rgb,
frac(unity_InstanceID * _SequenceNumbers.x + _SequenceNumbers.y)
);
color.a = lerp(
_ColorA.a, _ColorB.a,
frac(unity_InstanceID * _SequenceNumbers.z + _SequenceNumbers.w)
);
return color;
#else
return _Color;
#endif
}
```
Мы делаем так, потому что теперь будем использовать канал A цвета для задания smoothness, что возможно благодаря тому, что мы не используем его для прозрачности. Это значит, что в нашем графе шейдера мы используем нод *Split* для извлечения альфа-канала из *FractalColor* и привязки его к основной smoothness. Затем удалим свойство smoothness из blackboard.
*Полученная smoothness.*
То же самое мы делаем в нашем поверхностном шейдере.
```
void ConfigureSurface (Input input, inout SurfaceOutputStandard surface) {
surface.Albedo = GetFractalColor().rgb;
surface.Smoothness = GetFractalColor().a;
}
```
**Не должны ли мы повторно использовать результат одного вызова GetFractalColor?**
Да, но мы уже и так делаем это. Компилятор шейдера распознаёт и оптимизирует дублируемую работу. Стоит заметить, что это всегда происходит в случае шейдеров, но обычно не происходит в обычном коде на C#.
Теперь мы можем удалить из поверхностного шейдера весь блок `Properties`.
```
//Properties {
//_Smoothness ("Smoothness", Range(0,1)) = 0.5
//}
```
Так как теперь мы можем использовать альфа-канал цвета для управления smoothness, нужно настроить цвета, чтобы учитывать это. Например, я задал smoothness листа равной 50% и 90%. Обратите внимание, что smoothness выбирается вне зависимости от цвета, хотя они вместе настраиваются через одно свойство. Мы просто пользуемся уже существующим каналом, который пока не использовался.
*Чёрные листья с варьируемой smoothness.*
Тоже самое нужно проделать и с градиентами, для которых по умолчанию установлено 100% альфы. Я задал им 80–90 и 140–160 из 255. Также я настроил цвета, чтобы фрактал больше походил на дерево.
*Фрактал раскрашен так, чтобы напоминать растение.*
Эффект наиболее реалистичен, когда глубина фрактала установлена на максимум.
*Та же раскраска с глубиной 8.*
Провисание ветвей
-----------------
Хотя наш фрактал уже выглядит намного органичнее, это относится только к его раскраске. Его структура по-прежнему жёсткая и идеальная. Проще всего увидеть это со стороны, когда окно сцены находится в ортографическом режиме, а вращение в `Update` временно установлено на ноль.
```
float spinAngleDelta = 0.125f * PI * Time.deltaTime * 0f;
```
*Идеально жёсткая структура.*
Органические структуры неидеальны. Кроме того, что они неравномерно добавляются в процессе роста, наиболее очевидным качеством растений является то, что они подвержены воздействию гравитации. Всё в растении хотя бы немного провисает под собственным весом. В нашем фрактале этого нет, но мы можем аппроксимировать это явление, изменив поворот каждой части.
### Ось поворота провисания
Мы можем симулировать провисание, повернув всё так, чтобы элементы немного наклонились вниз. То есть нам нужно повернуть каждый экземпляр вокруг какой-то оси, чтобы локальная ось вверх казалась опущенной вниз. Значит, первым делом нам нужно определить направленную вверх ось элемента в мировом пространстве. Это ось, которая указывает в направлении, противоположном родительскому элементу. Мы найдём её, повернув вектор вверх на изначальный поворот элемента в мире. Это надо выполнять без учёта собственного предыдущего провисания элемента, в противном случае поворот будет накапливаться и всё достаточно быстро станет направленным ровно вниз. Поэтому мы выполняем поворот в начале `Execute` на основании фиксированного локального поворота элемента и поворота его родителя в мировом пространстве, прежде чем изменять поворот элемента в мире.
```
public void Execute (int i) {
FractalPart parent = parents[i / 5];
FractalPart part = parts[i];
part.spinAngle += spinAngleDelta;
float3 upAxis =
mul(mul(parent.worldRotation, part.rotation), up());
part.worldRotation = mul(parent.worldRotation,
mul(part.rotation, quaternion.RotateY(part.spinAngle))
);
…
}
```
Если элемент не направлен прямо вверх, то его собственная ось вверх будет отличаться от оси вверх мира. Можно выполнить поворот от мировой оси вверх к оси вверх элемента, осуществив поворот вокруг ещё одной оси. Эту ось, которую мы назовём осью провисания, можно найти, взяв векторное произведение обоих осей при помощи метода `cross`.
```
float3 upAxis =
mul(mul(parent.worldRotation, part.rotation), up());
float3 sagAxis = cross(up(), upAxis);
```
Результатом векторного произведения является вектор, перпендикулярный обоим его аргументам. Длина вектора зависит от относительной ориентации и длин исходных векторов. Так как мы работаем с единичными веторами, длина оси провисания равна синусу угла между операндами. Поэтому чтобы прийти к оси единичной длины, нам нужно отмасштабировать её до единичной длины, для чего можно воспользоваться методом `normalize`.
```
float3 sagAxis = cross(up(), upAxis);
sagAxis = normalize(sagAxis);
```
### Применяем провисание
Теперь, когда у нас есть ось провисания, мы можем создать поворот провисания, вызвав `quaternion.AxisAngle` с осью и углом в радианах. Давайте создадим поворот на 45°, то есть на четверть π радиан.
```
sagAxis = normalize(sagAxis);
quaternion sagRotation = quaternion.AxisAngle(sagAxis, PI * 0.25f);
```
Чтобы применить провисание, нам нужно базировать поворот элемента в мире не напрямую на повороте родителя. Мы введём поворот по новому основанию, применив поворот провисания к повороту родительского элемента в мире.
```
quaternion sagRotation = quaternion.AxisAngle(sagAxis, PI * 0.25f);
quaternion baseRotation = mul(sagRotation, parent.worldRotation);
part.worldRotation = mul(baseRotation,
mul(part.rotation, quaternion.RotateY(part.spinAngle))
);
```
*Верхушка отсутствует.*
Разница очевидна, но результат неверный. Наиболее важная ошибка заключается в том, что вершина фрактала как будто отсутствует. Так получилось, потому что когда элемент направлен ровно вверх, угол ним и мировой осью вверх равен нулю. Поэтому результат векторного произведения равен вектору нулевой длины, для которого нормализацию выполнить не удаётся. Мы исправим эту ошибку проверкой того, больше ли нуля величина вектора провисания (его длина). Если это так, то применяем провисание, а в противном случае напрямую применяем поворот родительского элемента. Это логично с точки зрения физики, потому что если элемент направлен вверх, то находится в равновесии и не будет провисать.
Длину вектора, также известную как его величина, можно найти с помощью метода `length`. После этого вектору можно придать единичную длину, разделив его на его величину, что и делает `normalize`.
```
//sagAxis = normalize(sagAxis);
float sagMagnitude = length(sagAxis);
quaternion baseRotation;
if (sagMagnitude > 0f) {
sagAxis /= sagMagnitude;
quaternion sagRotation = quaternion.AxisAngle(sagAxis, PI * 0.25f);
baseRotation = mul(sagRotation, parent.worldRotation);
}
else {
baseRotation = parent.worldRotation;
}
part.worldRotation = mul(baseRotation,
mul(part.rotation, quaternion.RotateY(part.spinAngle))
);
```
*Вершина есть, но деформированная.*
Фрактал всё равно деформирован, потом что теперь мы по сути применяем ориентацию каждого элемента дважды. Сначала при провисании и позже, когда смещаем при использовании провисания, а потом когда смещаем его в определённом направлении. Исправим это, всегда выполняя смещение вдоль локальной оси вверх элемента.
```
part.worldPosition =
parent.worldPosition +
//mul(parent.worldRotation, (1.5f * scale * part.direction));
mul(part.worldRotation, float3(0f, 1.5f * scale, 0f));
```
*Равномерное провисание на 45°.*
Обратите внимание — это значит, что нам больше не надо отслеживать вектор направления каждой части и мы можем удалить весь связанный с ним код.
```
struct FractalPart {
//public float3 direction, worldPosition;
public float3 worldPosition;
public quaternion rotation, worldRotation;
public float spinAngle;
}
…
//static float3[] directions = {
// up(), right(), left(), forward(), back()
//};
…
FractalPart CreatePart (int childIndex) {
return new FractalPart {
//direction = directions[childIndex],
rotation = rotations[childIndex]
};
}
```
### Модулированное провисание
Похоже, провисание работает, но важно наблюдать его, когда фрактал в движении, поэтому заставим его снова вращаться.
```
float spinAngleDelta = 0.125f * PI * Time.deltaTime; // * 0f;
```
*Исправленное провисание.*
В целом это работает. Какой бы ни была ориентация элемента, кажется, что его тянет вниз. Но возникают случайные изменения направления. Это происходит, когда меняется направление провисания. Так как мы используем постоянный угол провисания, единственные варианты — провисать в положительном или отрицательном направлении, или не провисать совсем. Также это означает, что поворот распространяется на элементы, направленные почти прямо вниз, поднимая их вместо этого вверх.
Чтобы решить эту проблему, нужно сделать так, чтобы величина провисания зависела от угла между осью вверх мира и элемента. Если элемент направлен почти ровно вверх или вниз, то провисания почти не должно быть, а если элемент направлен в сторону под углом 90°, то провисание должно быть максимальным. Соотношение между величиной провисания и углом не должно быть линейным. На самом деле, хорошие результаты даёт синус угла. Это величина векторного произведения, которая у нас уже есть. Поэтому используем её для модуляции угла поворота провисания.
```
quaternion sagRotation =
quaternion.AxisAngle(sagAxis, PI * 0.25f * sagMagnitude);
```
*Модулированное провисание.*
Так как провисание вычисляется в мировом пространстве, на него влияет ориентация всего фрактала. Поэтому немного повернув game object фрактала, мы можем заставить провисать и верхушку.
*Фрактал, повёрнутый на 20° по оси Z.*
### Максимальный угол провисания
Теперь, когда провисание работает, сделаем его максимальный угол настраиваемым, снова добавив вариативности, раскрыв два значения для задания интервала. Для настройки этих углов мы воспользуемся градусами, потому что это легче, чем использовать радианы.
```
[SerializeField]
Color leafColorA = default, leafColorB = default;
[SerializeField, Range(0f, 90f)]
float maxSagAngleA = 15f, maxSagAngleB = 25f;
```
*Максимальные углы провисания.*
Добавим максимальный угол провисания в `FractalPart` и инициализируем его в `CreatePart` вызовом `Random.Range` с двумя заданными углами в качестве аргументов. Результат можно преобразовать в радианы с помощью метода `radians`.
```
struct FractalPart {
public float3 worldPosition;
public quaternion rotation, worldRotation;
public float maxSagAngle, spingAngle;
}
…
FractalPart CreatePart (int childIndex) {
return new FractalPart {
maxSagAngle = radians(Random.Range€(maxSagAngleA, maxSagAngleB)),
rotation = rotations[childIndex]
};
}
```
**Обязательно ли угол A должен быть меньше угла B?**
Хоть это и логично, но необязательно. Метод `Random.Range` просто использует случайное значение для интерполяции между двумя его аргументами.
Затем используем в `Execute` максимальный угол провисания элемента вместо постоянных 45°.
```
quaternion sagRotation =
quaternion.AxisAngle(sagAxis, part.maxSagAngle * sagMagnitude)
```
*Переменный максимальный угол провисания 15–25, глубина 8.*
Вращение
--------
Мы уже модифицировали наш фрактал так, что он выглядит достаточно органическим. Последним усовершенствованием будет добавление вариативности вращению.
### Переменная скорость
Как и в случае с максимальным углом провисания, добавим опции конфигурации для интервала скоростей вращения, задаваемых в градусах в секунду. Эти скорости должны быть равными или больше нуля.
```
[SerializeField, Range(0f, 90f)]
float maxSagAngleA = 15f, maxSagAngleB = 25f;
[SerializeField, Range(0f, 90f)]
float spinVelocityA = 20f, spinVelocityB = 25f;
```
*Скорости вращения.*
Добавим в `FractalPart` поле скорости вращения и случайным образом инициализируем его в `CreatePart`.
```
struct FractalPart {
public float3 worldPosition;
public quaternion rotation, worldRotation;
public float maxSagAngle, spinAngle, spinVelocity;
}
…
FractalPart CreatePart (int childIndex) {
return new FractalPart {
maxSagAngle = radians(Random.Range€(maxSagAngleA, maxSagAngleB)),
rotation = rotations[childIndex],
spinVelocity = radians(Random.Range€(spinVelocityA, spinVelocityB))
};
}
```
Затем избавимся от поля однородной дельты угла вращения в `UpdateFractalLevelJob`, заменив её полем дельты времени. Затем применим собственную скорость вращения элемента в `Execute`.
```
//public float spinAngleDelta;
public float scale;
public float deltaTime;
…
public void Execute (int i) {
FractalPart parent = parents[i / 5];
FractalPart part = parts[i];
part.spinAngle += part.spinVelocity * deltaTime;
…
}
```
После этого изменим `Update` так, чтобы в нём больше не использовалась однородная дельта угла вращения и вместо неё передавалась дельта времени.
```
//float spinAngleDelta = 0.125f * PI * Time.deltaTime;
float deltaTime = Time.deltaTime;
FractalPart rootPart = parts[0][0];
rootPart.spinAngle += rootPart.spinVelocity * deltaTime;
…
for (int li = 1; li < parts.Length; li++) {
scale *= 0.5f;
jobHandle = new UpdateFractalLevelJob {
//spinAngleDelta = spinAngleDelta,
deltaTime = deltaTime,
…
}.ScheduleParallel(parts[li].Length, 5, jobHandle);
}
```
*Изменяемая в интервале от 0 до 90 скорость вращения.*
### Обратное вращение
Дополнительно мы можем реализовать смену направления вращения некоторых элементов. Это можно сделать, добавив возможность отрицательных скоростей вращения. Однако если мы захотим использовать и положительные, и отрицательные скорости, то два сконфигурированных значения должны будут иметь разные знаки. Следовательно, интервал будет проходить через ноль и невозможно будет избежать низких скоростей. Нельзя будет настроить фрактал так, чтобы его скорость, например, находилась в интервале 20–25, но с положительным или отрицательным знаком.
Решение заключается в отдельном задании скорости и направления. Для начала переименуем velocity в speed, чтобы обозначить, что скорость не имеет направления. Затем добавим ещё одну опцию конфигурации для вероятности обратного вращения, выраженного в виде вероятности, то есть значение будет находиться в интервале 0–1.
```
[SerializeField, Range(0f, 90f)]
float spinSpeedA = 20f, spinSpeedB = 25f;
[SerializeField, Range(0f, 1f)]
float reverseSpinChance = 0.25f;
…
FractalPart CreatePart (int childIndex) {
return new FractalPart {
maxSagAngle = radians(Random.Range(maxSagAngleA, maxSagAngleB)),
rotation = rotations[childIndex],
spinVelocity = radians(Random.Range(spinSpeedA, spinSpeedB))
};
}
```
*Скорости и вероятность обратного вращения.*
Мы можем выбирать направление вращения в `CreatePart`, проверяя, меньше ли случайное значение вероятности обратного вращения. Если это так, то мы умножаем скорость на −1, в противном случае на 1.
```
spinVelocity =
(Random.value < reverseSpinChance ? -1f : 1f) *
radians(Random.Range(spinSpeedA, spinSpeedB))
```
*Разные направления вращения, скорость всегда равна 45°.*
Обратите внимание, что теперь элементы фрактала могут казаться относительно неподвижными. Это происходит, когда противоположные скорости вращения обнуляют друг друга.
### Производительность
Завершим мы снова изучением производительности после внесённых нами изменений. Похоже, время update увеличилось, приблизительно удвоившись для глубин 6 и 7, и увеличившись на 30% для глубины 8. Это не повлияло отрицательно на частоту кадров по сравнению с тем, когда мы измеряли её в последний раз.
| Глубина | MS | URP | DRP |
| --- | --- | --- | --- |
| 6 | 0.20 | 440 | 142 |
| 7 | 0.45 | 144 | 92 |
| 8 | 2.23 | 49 | 31 | | https://habr.com/ru/post/542026/ | null | ru | null |
# Как ускорить Swift с помощью Conformances
В рантайме Swift выполняет проверку соответствия протоколу, когда вы приводите тип к протоколу, например, с **as?** или **as!**. Эта операция на удивление медленная, как подробно описано в моем [предыдущем посте](https://www.emergetools.com/blog/posts/SwiftProtocolConformance). В этой статье мы рассмотрим простой способ ускорить этот процесс примерно на 20%, не внося никаких изменений в ваш исходный код. А начнём с краткого обзора проверок соответствия протокола.
### Обзор + улучшения iOS 16
Записи о каждом соответствии, которое вы пишете в исходном коде, сохраняются в разделе TEXT/const двоичного файла в форме, подобной этой:
```
struct ProtocolConformanceDescriptor {
// Offset to the protocol definition
let protocolDescriptor: Int32
// Offset to the type that conforms to the protocol
var nominalTypeDescriptor: Int32
let protocolWitnessTable: Int32
let conformanceFlags: UInt32
}
```
Типичное приложение может иметь десятки тысяч таких элементов. Многие из них соответствуют общим протоколам, таким как **Equatable**, **Hashable**, **Decodable**или **Encodable**. Когда в рантайме Swift встречает что-то вроде **myVar as? MyProtocol** (может отсутствовать непосредственно в вашем коде, общие функции, такие как **String(describing:)**, внутри выполняют **as?**), он перебирает каждый дескриптор **ProtocolConformanceDescriptor**в двоичном файле, а также любые динамически связанные двоичные файлы. Сложность этой операции **O(n)**. В худшем случае, если вам необходимо найти запись о соответствии протокола для каждого типа, то сложность будет **O(n2)**.
iOS 16 значительно улучшает этот процесс. Как я объяснял в [предыдущем посте](https://www.emergetools.com/blog/posts/iOS16LaunchTime), iOS 16 предварительно вычисляет соответствие протокола при закрытии **dyld**, а в рантайме Swift консультируется с **dyld**перед запуском поиска **O(n)**. Во время предыдущего сообщения в блоге компания Apple не выпустила исходный код **dyld**для iOS 16, но теперь мы можем увидеть действительную реализацию в функции [\_dyld\_find\_protocol\_conformance\_on\_disk](https://github.com/apple-oss-distributions/dyld/blob/c8a445f88f9fc1713db34674e79b00e30723e79d/dyld/DyldAPIs.cpp#L2424). Эта функция концептуально аналогична библиотеке [zconform library](https://github.com/EmergeTools/zconform/tree/main), которая ускоряет эти проверки, используя хеш-таблицу. Эта хеш-таблица отображает типы в список протоколов, которым они соответствуют.
Хотя это улучшение есть в iOS 16, его трудно измерить на практике, потому что это поведение **dyld**отключено при запуске приложения из Xcode или Instruments. В Emerge есть *local performance debugging tool* ([локальный инструмент отладки производительности](https://docs.emergetools.com/docs/performance-debugging)), который решает эту проблему и может использоваться для профилирования приложений, у которых есть доступ к закрытию **dyld**.
Даже с учётом улучшений есть ещё 3 случая, когда вы можете столкнуться с медленным поиском:
* При первом запуске после установки/обновления приложения. Замыкание **dyld**ещё не построено, и все поиски соответствия всё ещё медлительны.
* Когда поиск соответствия приводит к nil. Можно было бы использовать [\_dyld\_protocol\_conformance\_result\_kind\_definitive\_failure](https://github.com/apple-oss-distributions/dyld/blob/c8a445f88f9fc1713db34674e79b00e30723e79d/include/mach-o/dyld_priv.h#LL651C3-L651C60), но быстрое сканирование исходного кода показывает, что эта возможность ещё не реализована.
* Если вы не используете iOS 16. Например, пользуетесь более старой ОС или используете Swift на платформе, отличной от Apple, включая Swift на стороне сервера.
С помощью простого файла порядка линковки исходников мы можем сократить время выполнения во всех трёх случаях.
### Файл порядка линковки исходников
Файл порядка линковки исходников — это входные данные для компоновщика, которые ускоряют работу приложений за счет группировки кода, используемого вместе, в одной области двоичного файла. С файлом порядка линковки исходников ваше приложение получает доступ только к памяти, используемой кодом запуска приложения, а не считывает в память весь двоичный файл размером более 100 Мб. Этот принцип основан на понятии размера страницы памяти. Чтобы получить доступ к одному байту двоичного файла, загружается вся страница размером 16 КБ. Выгодно располагать необходимые данные на как можно меньшем количестве страниц. Ранее я подробно описал [файл порядка линковки исходников](https://www.emergetools.com/blog/posts/FasterAppStartupOrderFiles).
Хранение секторов используемой памяти близко друг к другу также важно для повышения частоты попаданий в кэш. iPhone имеет несколько уровней кэша памяти, например, iPhone 7/A10 имеет следующую структуру [[1](https://en.wikipedia.org/wiki/Apple_A10)]:
Специфика скоростей не публикуется компанией Apple и меняется из года в год, но некоторые тесты показывают, что повышение уровня может увеличить задержку в 5 раз [[2](https://www.anandtech.com/show/14892/the-apple-iphone-11-pro-and-max-review/3)].
### Соответствие заказа
По умолчанию соответствие протокола распространяется по всему разделу **\_\_TEXT/\_\_const** двоичного файла. Это связано с тем, что каждый модуль в приложении генерирует свой собственный статический двоичный файл. Когда они связаны с окончательным приложением, двоичные файлы размещаются рядом. Данные из разных модулей не чередуются в исполняемом файле.
Давайте представим это на примере приложения Uber. Версия, которую мы используем, имеет 102 800 записей соответствия (в зависимости от размера раздела **\_\_TEXT/\_\_swift5\_proto**) и раздел **\_\_TEXT/\_\_const** размером 12,7 МБ.
Соответствия на каждой двоичной странице раздела \_\_TEXT/\_\_const Uber. По оси Y показано количество соответствий на каждой странице. Верхняя диаграмма представляет собой тепловую карту показателей соответствия.На приведённом выше рисунке показано количество соответствий на каждой странице приложения Uber. Запись соответствия протоколу может различаться по размеру (зависит от таких деталей, как ассоциированные типы), но минимальный размер составляет 16 байт. Вы можете иметь максимум 1024 записи соответствия на одной странице памяти.
Интересно, что у Uber есть несколько пиков, когда страница не содержит ничего, кроме соответствия минимального размера. Это может быть связано с кодогенерацией, такой как внедрение зависимостей или сетевые модели, которые создают множество простых протоколов в одном модуле. Есть также пара диапазонов, не соответствующих требованиям, вероятно, из-за кода, отличного от Swift, в приложении. Ключевым выводом является то, что соответствия разбросаны по всему бинарному файлу, поэтому почти все страницы будут загружаться из памяти при перечислении соответствий.
Соответствия на каждой двоичной странице раздела Lyft \_\_TEXT/\_\_constТочно так же на приведённом выше рисунке показано соответствие приложения Lyft. Хотя больших пиков нет, на каждой странице есть около 250 соответствий, за исключением одного диапазона, который, вероятно, не является кодом Swift.Мы можем применить идею использования order files для группировки данных на как можно меньшее количество страниц к соответствиям и создать order files, который перемещает все соответствия на их собственные страницы.
Соответствия упорядочены в начале раздела \_\_TEXT/\_\_constНа приведённом выше рисунке показан результат использования файла порядка линковки исходников для группировки соответствий. Каждая из первых 250 страниц теперь содержит только дескрипторы соответствия протоколу, по 500 на страницу. Записи соответствия различаются по размеру, поэтому количество соответствий на странице не всегда одинаково. При таком порядке требуется загрузить менее половины раздела при выполнении поиска соответствия протоколу. На самом деле, общая память, используемая 250 страницами, меньше 4 МБ, поэтому в этом примере все они могут поместиться в кэш-память на уровне L3 в iPhone 7. В наших тестах совместное размещение таких соответствий привело к снижению производительности протокола более чем на 20%, время поиска соответствия на iPhone 7 под управлением iOS 15!
Вы можете создать файл порядка с таким результатом, проанализировав файл карты ссылок. Все соответствия протокола заканчиваются на Mc, поэтому вам просто нужны имена символов Swift, соответствующие этому шаблону, которые находятся в разделе **\_\_TEXT/\_\_const**. Вы можете написать подробный синтаксический анализатор структуры карты ссылок, но простая утилита **grep**также должна помочь:
```
cat Binary-arm64-LinkMap.txt | grep -v '<>|non-lazy-pointer-to-local' | grep -o '_$.*Mc$' > order_file.txt
```
Вот и всё! Теперь у вас есть файл порядка линковки исходников. Вы можете установить параметр сборки Xcode “Order File” на путь к этому файлу или ознакомиться с нашими документами с инструкциями по сторонним системам сборки. Это определённо стоит сделать, чтобы ускорить приложение для пользователей iOS 15 или первого запуска после обновления приложения на iOS 16. Если вы попробуете это улучшение в своем приложении, то я буду рад услышать об этом!
Свяжитесь с нами.
Emerge Launch Booster
iOS Launch Booster от Emerge автоматизирует процесс создания файла порядка линковки исходников и может сделать всё это за вас. Хотя оптимизация соответствия протокола в основном применяется к iOS 15 и первому запуску iOS 16, Launch Booster также включает в себя множество других оптимизаций, которые делают приложения быстрее для всех ваших пользователей.
[1] [Apple A10](https://en.wikipedia.org/wiki/Apple_A10)
[2] [The Apple iPhone 11, 11 Pro & 11 Pro Max Review: Performance, Battery, & Camera Elevated](https://www.anandtech.com/show/14892/the-apple-iphone-11-pro-and-max-review/3) | https://habr.com/ru/post/714758/ | null | ru | null |
# Манипулируем System.Drawing.Bitmap
Класс `System.Drawing.Bitmap` очень полезен в инфраструктуре .NET, т.к. позволяет считывать и сохранять файлы различных графических форматов. Единственная проблема – это то, что он не очень полезен для попиксельной обработки – например если нужно перевести битмап в ч/б. Под катом – небольшой этюд на эту тему.
Допустим у нас есть два битмапа, один из которых считан из файла, а другой должен содержать ч/б конверсию:
> `// загружаем картинку
>
> sourceBitmap = (Bitmap) Image.FromFile("Zap.png");
>
>
> // делаем пустую картинку того же размера
>
> targetBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height, sourceBitmap.PixelFormat);`
Мы хотим чтобы `targetBitmap` был как `sourceBitmap`, только черно-белый. На самом деле, в C# делается это просто:
> `void NaïveBlackAndWhite()
>
>
> {
>
>
> for (int y = 0; y < sourceBitmap.Height; ++y)
>
>
> for (int x = 0; x < sourceBitmap.Width; ++x)
>
>
> {
>
>
> Color c = sourceBitmap.GetPixel(x, y);
>
>
> byte rgb = (byte)(0.3 \* c.R + 0.59 \* c.G + 0.11 \* c.B);
>
>
> targetBitmap.SetPixel(x, y, Color.FromArgb(c.A, rgb, rgb, rgb));
>
>
> }
>
>
> }`
Это решение понятное и простое, но к сожалению жуть как неэффективное. Чтобы получить более «резвый» код, можно попробовать написать все это дело на С++. Для начала создадим структурку для хранения цветовых значений пикселя
> `// структура отражает один пиксель в 32bpp RGBA
>
> struct Pixel {
>
>
> BYTE Blue;
>
>
> BYTE Green;
>
>
> BYTE Red;
>
>
> BYTE Alpha;
>
>
> };`
Теперь можно написать функцию которая будет делать пиксель черно-белым:
> `Pixel MakeGrayscale(Pixel& pixel)
>
>
> {
>
>
> const BYTE scale = static\_cast<BYTE>(0.3 \* pixel.Red + 0.59 \* pixel.Green + 0.11 \* pixel.Blue);
>
>
> Pixel p;
>
>
> p.Red = p.Green = p.Blue = scale;
>
>
> p.Alpha = pixel.Alpha;
>
>
> return p;
>
>
> }`
Теперь собственно пишем саму функцию обхода:
> `CPPSIMDLIBRARY\_API void AlterBitmap(BYTE\* src, BYTE\* dst, int width, int height, int stride)
>
>
> {
>
>
> for (int y = 0; y < height; ++y) {
>
>
> for (int x = 0; x < width; ++x)
>
>
> {
>
>
> int offset = x \* sizeof(Pixel) + y \* stride;
>
>
> Pixel& s = \*reinterpret\_cast(src + offset);
>
>
> Pixel& d = \*reinterpret\_cast(dst + offset);
>
>
> // изменяем d
>
> d = MakeGrayscale(s);
>
>
> }
>
>
> }
>
>
> }`
А дальше остается только использовать ее из C#.
> `void UnmanagedBlackAndWhite()
>
>
> {
>
>
> // "зажимаем" байты обеих картинок
>
> Rectangle rect = new Rectangle(0, 0, sourceBitmap.Width, sourceBitmap.Height);
>
>
> BitmapData srcData = sourceBitmap.LockBits(rect, ImageLockMode.ReadWrite, sourceBitmap.PixelFormat);
>
>
> BitmapData dstData = targetBitmap.LockBits(rect, ImageLockMode.ReadWrite, sourceBitmap.PixelFormat);
>
>
> // отсылаем в unmanaged код для изменений
>
> AlterBitmap(srcData.Scan0, dstData.Scan0, srcData.Width, srcData.Height, srcData.Stride);
>
>
> // отпускаем картинки
>
> sourceBitmap.UnlockBits(srcData);
>
>
> targetBitmap.UnlockBits(dstData);
>
>
> }`
Это улучшило быстродействие, но мне захотелось еще большего. Я добавил директиву OpenMP перед циклом по `y` и получил предсказуемое ускорение в 2 раза. Дальше захотелось поэкспериментировать и попробовать применить еще и SIMD. Для этого я написал вот этот, не очень читабельный, код:
> `CPPSIMDLIBRARY\_API void AlterBitmap(BYTE\* src, BYTE\* dst, int width, int height, int stride)
>
>
> {
>
>
> // факторы для конверсии в ч/б
>
> static \_\_m128 factor = \_mm\_set\_ps(1.0f, 0.3f, 0.59f, 0.11f);
>
>
> #pragma omp parallel for
>
>
> for (int y = 0; y < height; ++y)
>
>
> {
>
>
> const int offset = y \* stride;
>
>
> \_\_m128i\* s = (\_\_m128i\*)(src + offset);
>
>
> \_\_m128i\* d = (\_\_m128i\*)(dst + offset);
>
>
> for (int x = 0; x < (width >> 2); ++x) {
>
>
> // у нас 4 пикселя за раз
>
> for (int p = 0; p < 4; ++p)
>
>
> {
>
>
> // конвертируем пиксель
>
> \_\_m128 pixel;
>
>
> pixel.m128\_f32[0] = s->m128i\_u8[(p<<2)];
>
>
> pixel.m128\_f32[1] = s->m128i\_u8[(p<<2)+1];
>
>
> pixel.m128\_f32[2] = s->m128i\_u8[(p<<2)+2];
>
>
> pixel.m128\_f32[3] = s->m128i\_u8[(p<<2)+3];
>
>
> // четыре операции умножения - одной командой!
>
> pixel = \_mm\_mul\_ps(pixel, factor);
>
>
> // считаем сумму
>
> const BYTE sum = (BYTE)(pixel.m128\_f32[0] + pixel.m128\_f32[1] + pixel.m128\_f32[2]);
>
>
> // пишем назад в битмап
>
> d->m128i\_u8[p<<2] = d->m128i\_u8[(p<<2)+1] = d->m128i\_u8[(p<<2)+2] = sum;
>
>
> d->m128i\_u8[(p<<2)+3] = (BYTE)pixel.m128\_f32[3];
>
>
> }
>
>
> s++;
>
>
> d++;
>
>
> }
>
>
> }
>
>
> }`
Несмотря на то, что этот код делает 4 операции умножения за раз (инструкция `_mm_mul_ps`), все эти конверсии не дали никакого выигрыша по сравнению с обычными операциями – скорее наоборот, алгоритм начал работать медленнее. Вот результаты выполнения функций на картинке 360×480. Использовался 2х-ядерный MacBook с 4Гб RAM, результаты усредненные.
А вот и конечный результат:
Выводы:
* `SetPixel/GetPixel` – это зло, их трогать не стоит.
* OpenMP продолжает радовать, давая линейный scalability.
* Использование SIMD не гарантирует повышение производительности. Зато доставляет много хлопот.
Если кто-нибудь из читателей готов написать еще более эффективный алгоритм – милости просим! Протестирую и опубликую его прямо здесь.
[](http://spbalt.net) | https://habr.com/ru/post/60085/ | null | ru | null |
# Пример использования Product API от Fetchee для парсинга товаров интернет-магазина
В этой инструкции мы расскажем о том, как с помощью Fetchee Product API получить данные о товаре по URL на примере интернет-магазина lamoda.
Для тех, кто не читал [нашу прошлую заметку](https://habrahabr.ru/company/fetchee/blog/314960/) — Product API будет полезен разработчикам, которым требуется получать данные о товарах из любого магазина, но которые не хотят тратить время на создание собственной системы парсинга или уже осознали, что open-source библиотеки обладают существенными ограничениями и требуют много времени на поддержку. Наш автоматический и не требующий настройки API для парсинга eCommerce данных даёт возможность сосредоточится на разработке основных функций вашего приложения. К тому же попробовать его очень просто. Детали под катом.
Для начала вам понадобится ключ доступа к API. Оставьте заявку на <https://fetch.ee/ru/developers/>. Мы предоставляем доступ всем желающим и обычно отвечаем на заявки в течении 24-х часов.
#### 1. Отправка запроса на парсинг товара по URL
Обратите внимание, что API принимает только POST запросы в формате application/json на URL <https://fetch.ee/api/v1/product>:
```
{
"url":"",
"api\_key":"",
"callback\_url":""
}
```
Пример запроса для товара по адресу <http://www.lamoda.ru/p/ug174awohj47/shoes-uggaustralia-uggi/> будет выглядеть следующим образом (мы добавили демонстрационный API-ключ, который проживёт пару дней):
```
curl -X POST -H "Content-type: application/json" -d "{\"url\": \"http://www.lamoda.ru/p/ug174awohj47/shoes-uggaustralia-uggi/\", \"api_key\": \"0e2bc30838d8bbbbbec787667c4ff34b\", \"callback_url\": \"http://requestb.in/onpdf2on\"}" https://fetch.ee/api/v1/product
```
Все параметры обязательные, если какого-то из них не будет, то сервер вернёт 403 ошибку, как и в случае неправильного API-ключа.
**ВАЖНО:** В примере указан временный callback\_url. Он перестанет действовать через пару часов, заменяйте его своим URL, который можно получить на <http://requestb.in>.
Product API обрабатывает запросы асинхронно, время получения ответа может варьироваться от пары секунд до нескольких десятков минут. Это связано с нагрузкой на систему в конкретном географическом регионе. API отправит данные на указанный вами URL по завершении парсинга (callback\_url).
Максимальное время ожидания составляет 30 минут, после чего в любом случае будет отправлен ответ с результатом или сообщение о невозможности завершить парсинг товара по указанному URL.
Для тестирования API удобно использовать сервис <http://requestb.in>. Заведите на нем новый контейнер (Create a RequestBin) и указывайте полученный URL в качестве callback\_url. Все ответы от API будут приходить на него, просто обновляйте страницу браузере.
#### 2. Поля и варианты ответа API
В ответе используются следующие поля:
* success – результат отправки URL на парсинг;
* id – уникальный ID запроса;
* already\_processed – запрос уже был недавно обработан;
* not\_shop – URL не принадлежит магазину;
* not\_product – по данному URL нет данных о товаре.
Любое из полей, кроме success, может отсутствовать.
Сразу после запроса, вы получите ответ в JSON формате. ID нужен для сопоставления отправленных вами запросов и полученных на callback\_url ответов. В данном случае всё прошло отлично и товар был принят на парсинг.
```
{
"success": true,
"id": "583ea83a09e9497a0eb1b82a"
}
```
Такой ответ последует, если вы попытаетесь отправить на парсинг URL, который уже был обработан менее 6 часов назад. В данном случае вызова на callback\_url не последует.
```
{
"success":true,
"id":"583ea83a09e9497a0eb1b82a",
"already_processed":true
}
```
Данный ответ вы получите, если API уже знает, что указанный URL не относится к сайту интернет-магазина. Товар не добавляется на парсинг и вызова callback\_url не будет. Мы ведём чёрный список сайтов, куда входят в том числе сомнительные и партнерские магазины (выступающие как витрины с товарами других магазинов).
```
{
"success":false,
"not_shop":true
}
```
Когда система знает, что по данному URL нет товара (страница категории, главная страница магазина и т.д.). Товар не добавляется на парсинг и вызова callback\_url не будет.
```
{
"success":false,
"not_product":true
}
```
#### 3. Получение результата парсинга
API отправляет POST запрос с ответом в JSON на указанный в callback\_url адрес. Через 20 секунд мы получили такой результат парсинга:
```
{
"id":"583ea83a09e9497a0eb1b82a",
"url":"http://www.lamoda.ru/p/ug174awohj47/shoes-uggaustralia-uggi/",
"created_at":"2016-11-30T10:21:46.865Z",
"title":"Обувь угги UGG Australia",
"price":22800,
"currency":"RUB",
"img_url":"https://fetch.ee/assets/item-images/583e/a843a9436d700e54ef37.jpg",
"brand":"UGG Australia"
}
```
Рассмотрим полученный JSON более подробно. В ответе всегда присутствуют 3 обязательных параметра:
* id – уникальный ID запроса;
* url – окончательный URL товара (если были редиректы, или мы вырезали различные ненужные query\_params из URL (UTM-метки, например);
* created\_at – время создания запроса на парсинг товара;
Любой из следующих параметров может отсутствовать:
* title – название товара;
* price – цена;
* currency – код валюты (например, RUB, USD, EUR);
* img\_url – ссылка на изображение товара;
* brand – производитель товара;
* out\_of\_stock: true – когда товар отсутствует в продаже;
* removed: true – когда товар вообще пропал из магазина и происходит перенаправление на страницу категории, главную страницу магазина или получаем 404 ответ от сервера;
* not\_shop: true – когда за время парсинга API определил, что URL не принадлежит магазину, хотя ранее принял запрос на обработку;
* not\_product: true – коза за время парсинга API определил, что URL не содержит информации о товаре, хотя запрос на обработку был принят;
* unprocessed: true – когда Product API не смог получить ключевые параметры товара title или price.
Если Product API может быть вам полезен, оставляйте заявку на [fetch.ee/ru/developers](https://fetch.ee/ru/developers/)! Напишите в комментариях какие ещё параметры товаров вы бы хотели получать в дополнение к уже доступным? | https://habr.com/ru/post/316558/ | null | ru | null |
# Вредные советы для React-разработчиков
Недавно британские ученые открыли, что на свете бывают непослушные разработчики, которые все делают наоборот. Им дают полезный совет: «Не подключай целую библиотеку ради одной функции», — они берут и подключают. Им говорят: «Будь внимателен на код-ревью», — они тут же начинают апрувить все подряд. Ученые придумали, что таким разработчикам нужно давать не полезные, а вредные советы. Они все сделают наоборот, и получится как раз правильно.
### ВРЕДНЫЙ СОВЕТ №1
> Компоненты в 500 строк —
>
> Это так, для всех игрушки.
>
> Делай больше! Делай тыщу!
>
> Чтоб вообще слететь с катушек.
>
>
 **На практике:**
Попробуйте спросить себя: «Этот участок кода делает/описывает ОДНУ вещь?» Независимо от того, находится ли это в области метода или класса, если он делает несколько вещей, вам, вероятно, следует отделить их друг от друга. А затем уже создать другой метод, который вызывает их последовательно.
Чем длиннее модуль, который вы пишете, тем больше (коротких) тестов и комментариев вам, вероятно, потребуется для него. Но будь то методы, классы или целые библиотеки, ответ заключается в том, что этот код больше зависит от того, насколько хорошо он спроектирован и насколько он удобочитаемый. Комментарии увеличивают длину, но также значительно повышают удобочитаемость. Проекты из 5000 строк могут быть нечитаемыми, в то время как системы из миллионов строк постоянно поддерживаются десятилетиями.
### ВРЕДНЫЙ СОВЕТ №2
> Чтоб жизнь медом не казалась,
>
> Логику программы всей
>
> В компонент один засунь ты.
>
> Время ведь совсем неважно,
>
> Не поспишь ты месяцок,
>
> Лишний рендер — так прекрасно.
>
> Подождем еще, дружок.
>
>
**На практике:**
Процесс создания крупномасштабного приложения React может стать причиной головной боли из-за повторного рендеринга. Рост вашего приложения может привести к долгому изучению того, почему «тяжелые» компоненты повторно отображают гораздо больше, чем вы ожидали.
Разберем это на примере и посмотрим, какие советы есть для повышения производительности:
```
const App = () => {
const [counter, setCounter] = useState(0);
return (
setCounter(counter + 1)}>Counter
);
};
```
Компонент App с состоянием, состоящий из 3 компонентов, в состав которых входит кнопка, обновляющая значение counter. К чему это приводит? К ререндеру App, FirstComponent и SecondComponent.
Как улучшить? Например, переместить хук useState в компонент с кнопкой CounterBtn, в результате чего компонент CounterBtn станет тем, кто обрабатывает setCounter, и повторно рендериться будет только он.
```
const App = () => {
return (
…
);
};
const CounterBtn = () => {
const [counter, setCounter] = useState(0);
return (
setCounter(counter + 1)}>Counter
);
}
```
*\*\*\* Мы могли бы использовать React.memo, чтобы он никогда не перерисовывался, но это потребовало бы от компонента каждый раз проверять свои реквизиты. В данном примере можно обойтись без него.*
Как еще можно избавиться от ненужного рендеринга? Если у вас до сих пор присутствуют классовые компоненты, можно переписать их на функциональные. Как и что делать, описывать не будем, а посмотрим на некоторых участках кода к чему приведет, например, использование хуков.
#### Redux
Возьмем подключение компонента к Redux:
```
@withRouter
@connect(
(state) => (
{
loading: getLoading(state),
blocks: getBlocks(state),
sections: getSections(state),
}
),
{
loadData,
updateSections,
updateBlocks,
},
)
```
В реальной жизни их значения могут увеличиваться в несколько раз. Нужно ли это все в этом компоненте? Нет. Все это получается через пропсы и далее передается в последующие компоненты, которые используются в компоненте Main. Прямо сейчас эта дорогостоящая логика будет повторно выполняться для каждого отправленного действия, приводящего к обновлению состояния. Даже если состояние изменяемого нами хранилища находилось в той части дерева состояний, о которой этот компонент не заботится.
Чего мы действительно хотим, так это повторно запускать эти дорогостоящие шаги только в том случае, если state.somedata действительно изменился. Вот тут-то и возникает идея мемоизации, то есть «запоминания».
Мемоизация — это форма кэширования. Она включает в себя отслеживание входных данных для функции и сохранение входных данных и результатов для дальнейшего использования. Если функция вызывается с теми же входными данными, что и раньше, функция может пропустить фактическую работу и вернуть тот же результат, который она сгенерировала при последнем получении этих входных значений.
Еще одна полезная вещь для redux — **Reselect.** Это простая библиотека селекторов, которую можно использовать для создания запоминаемых селекторов. Вы можете определить селекторы как функцию, извлекая фрагменты состояния Redux для компонентов React.
Рассмотрим участок кода без использования reselect:
```
const App = ({ blocks, tableSize}) => (
);
const addRowsLength = rows=> ({
tableSize: rows.length,
});
App = connect(state => {
return {
blocks: state.blocks,
tableSize: addRowsLength (state.rows)
};
})(App);
```
Каждый раз, когда данные блоков в состоянии изменяются, как Template, так и UDTable, компоненты будут перерисовываться. Это происходит даже тогда, когда addRowsLength не вносит никаких изменений в данные tableSize, поскольку addRowsLength вернет новый объект с другим идентификатором (помните {} != {}). Теперь, если мы перепишем addRowsLength с помощью Reselect, проблема исчезнет, так как Reselect будет возвращать последний результат функции до тех пор, пока ему не будут переданы новые входные данные.
```
import { createSelector } from "reselect";
const rowsSelector = state => state.rows;
const addRowsLength = createSelector(
rowsSelector ,
rows => ({
tableSize: rows.length
})
);
```
Допустим, мы перевели все на функциональные компоненты, используем reselect, что дальше? Хуки!
**useSelector.** Хук useSelector (или connect HOC) подписывается на хранилище и прослушивает изменения в дереве состояний. В результате каждое изменение состояния Redux распространяет обновления через подписки.
Механизм Redux уверяет нас, что для каждого используемого нами useSelector — только те компоненты, которые используют «useSelector», и только если состояние, возвращаемое хуком, изменится, компонент перерендерится. В результате все компоненты, которые он отображает, и их дочерние элементы будут повторно визуализированы.
Рассмотрим, как будет выглядеть теперь, когда нам в главном файле нужны только все блоки, секции и плейсхолдеры:
```
const Main = () => {
const blocks = useSelector(templateBlocksSelector);
const sections = useSelector(templateSectionsSelector);
const placeholders = useSelector(templatePlaceholdersSelector);
…
return (
…
);
};
```
```
import { createSelector } from "reselect";
const templateSelector = state => state.template;
const templateBlocksSelector= createSelector(
templateSelector ,
state=> state.blocks
);
const templateSectionsSelector= createSelector(
templateSelector ,
state=> state.sections
);
const templatePlaceholdersSelector= createSelector(
templateSelector ,
state=> state.placeholders
);
```
Стало гораздо читабельнее, а также повысилась производительность.
Разберем еще один способ использования мемоизации — React.Memo:
```
const ComponentInfo = ({ contractor}) => {
const {name, address, inn} = contractor;
return (
{name}
{address && Адрес: {address}
}
{inn && ИНН: {inn}
}
);
};
export default ContractorInfo;
```
Здесь все дочерние элементы в ComponentInfo основаны на свойствах. Этот компонент без сохранения состояния будет перерисовываться при изменении реквизита. Если маловероятно, что атрибут компонента ComponentInfo изменится, то он является хорошим кандидатом для мемоизации.
```
const ComponentInfo = ({ contractor}) => {
const {name, address, inn} = contractor;
return (
{name}
{address && Адрес: {address}
}
{inn && ИНН: {inn}
}
);
};
export default React.Memo(ContractorInfo);
```
### ВРЕДНЫЙ СОВЕТ №3
> Либа в проекте — это прекрасно,
>
> Жизнь облегчает сразу она.
>
> Главное помни — спустя даже годы
>
> Не обновляй ты её никогда.
>
>
**На практике:**
Безопасное программирование – это то, о чем нужно знать каждому программисту, и чему следует учить еще на начальном уровне. Но что есть **безопасное программирование**, а если быть точнее, что нужно считать **небезопасным**?
На эту тему можно долго дискутировать, но чтобы стало чуть более понятней, возьмем за основу всеми известный «webpack». Для небольшого веб-сайта нередко требуется несколько библиотек сценариев. Более того, эти библиотеки часто зависят от других библиотек, называемых «зависимостями». Мы не просто должны добавить webpack в проект, мы также должны понять, что загружается одновременно с ним.
К примеру, вот реальный кейс с одного из наших проектов. Заказчику требовалась оптимизация и дальнейшая поддержка проекта. Не удивительно, что заказчик был недоволен производительностью приложения, ведь там был подключен webpack 3-й версии, которая безнадежно устарела. Одновременно с этим необходимо было проверить зависимости, удалить неактуальные плагины или добавить новые (за помощью можно обратиться [к этому сайту](https://security.snyk.io/)). В старых версиях библиотек вероятность обнаружения уязвимости выше, чем в более новых.
Также бонусом можно немного скомпоновать код. У нас есть настройки для двух версий — production и development. И сразу, что может бросаться в глаза — это повторяющиеся куски кода. Для решения этой задачи на помощь приходит webpack-merge.
Создадим новый файл и назовем его, к примеру, webpack.base.js:
```
const baseConfig= {
module: {
rules: [
{
oneOf: [jsLoader, cssLoader, imageLoader],
},
],
},
resolve: {
alias: {
process: "process/browser",
},
extensions: [".jsx", ".js"],
},
plugins: [
new ProgressPlugin(),
new HtmlWebpackPlugin({
template: "public/index.html",
}),
],
optimization: {
splitChunks: {
minSize: 0,
chunks: "async",
},
},
};
export default baseConfig;
```
Теперь, когда мы захотим объединить эту конфигурацию с development версией, выглядеть это будет так:
```
import merge from "webpack-merge";
const config= {
mode: "development",
…
};
export = merge(config, baseConifg);
```
### ВРЕДНЫЙ СОВЕТ №4
> Если всего одну функцию надо,
>
> И самому ее лень написать,
>
> Подключи либу — и лучше всю сразу,
>
> И пусть проект будет весить больше раз в пять.
>
>
**На практике:**
Этот кейс мы разберем на примере того же проекта с повышением производительности, что и в предыдущем случае. Первым делом было принято решение — посмотреть, насколько часто используется та или иная библиотека. Что изначально бросалось в глаза — *express*. Фреймворк использовался только для авторизации — получения настроек пользователя и информации о нем. В остальных местах везде axios.
Возможно, у вас возникает вопрос, зачем тогда изначально добавили express. В проекте он использовался для получения переменных окружения, где одна из переменных API\_URL, необходимая для взаимодействия фронта и бэка.
Решение: переписываем все вызовы на axios, а переменные запоминаем с помощью webpack.
```
plugins: [
…
new webpack.DefinePlugin({
// достаем из нашего конфига переменную и записываем
API_URL: JSON.stringify(apiConfig.API_URL),
}),
],
```
Еще одним ярким примером является lodash. К примеру, вам понадобилось объединить два массива или поставить debounce, и для легкости вы решили сразу обратиться именно к этой библиотеке. Но так ли сильно она вам нужна, чтобы устанавливать такую дорогостоящую в плане объема библиотеку? Здесь лучше несколько раз подумать и написать вручную необходимые функции и проверки, чем загромождать проект.
### ВРЕДНЫЙ СОВЕТ №5
> Копипаста — это сказка.
>
> Ведь удобно и как встарь,
>
> И зачем куда-то лазить —
>
> Ты копируй и вставляй.
>
>
**На примере**:
В каких случаях копипаст может стать серьезной проблемой? И от каких важных факторов это зависит?
Во-первых, качество того, что вы копируете — насколько код понятен, насколько стабилен, сколько в нем багов. Никто не хочет начинать с наследования чужих проблем.
Также стоит обратить внимание на то, сколько копий уже было сделано. Общепринятое эмпирическое правило из книги Фаулера и Бека по рефакторингу гласит: «три удара — и вы рефакторингуете». Это правило исходит из следующего: делая копию того, что уже работает, и изменяя ее, вы создаете небольшую проблему обслуживания. И чем больше копий вы делаете, тем больше проблем с обслуживанием вы создаете — стоимость внесения изменений и исправлений в несколько копий возрастают. В таких случаях лучше вернуться, реструктурировать код и придумать более универсальное решение.
Да, программирование копипаста в некоторых кейсах дорогостоящая операция. Но, как и многие другие идеи и практики в разработке, этот способ нельзя однозначно назвать правильными или неправильными. Это инструмент, который можно использовать, но не злоупотреблять им.
Важно это признать и делать с особой осторожностью.
### ВРЕДНЫЙ СОВЕТ №6
> Функцию ты сам придумай
>
> И пиши как можно кратко.
>
> Назови там как угодно,
>
> Пусть всем будет непонятно.
>
>
**На примере:**
Часто можно услышать, как кто-то с гордостью говорит: «Я перфекционист», а затем добавляет: «Смотрите, я все делаю идеально». На самом деле здесь мало чем можно гордиться. Казалось бы, более успешными в работе и жизни должны быть люди, стремящиеся все делать идеально. Но на практике именно перфекционисты являются самыми заядлыми прокрастинаторами и лентяями. Почему это происходит? Давайте выясним.
Перфекционисты тратят много времени на совершенствование мелочей. Они не могут игнорировать незначительные детали и в результате уделяют одинаковое количество времени и внимания всему, что делают в тщетной попытке довести каждую мелочь до идеального исполнения. Так как перфекционист хочет сделать все идеально, ему гораздо сложнее решать любые вопросы. Груз ответственности за качество выполнения настолько давит, что проще вообще отложить выполнение.
«Я не могу это сделать, если я не сделаю это идеально», — такой подход погубил множество идей и проектов.
Но также есть и другая сторона медали – пофигисты. Программисты, которым важно только то, чтобы код был рабочим, не обращая внимания на логику, оптимизацию, форматирование и так далее. Ярким примером может послужить такая ситуация, когда кто-то делает обертку над компонентом и называет его «component» или же придумывая название для констант обзывает их как «i».
### ВРЕДНЫЙ СОВЕТ №7
> Дали задачу? Без промедлений
>
> Сразу садись и выполняй!
>
> В ней разобраться? Зачем тратить время?
>
> Расслабься немного и отдыхай!
>
>
**На практике:**
Анализ задачи — это процесс определения задачи и разложения всей системы на более мелкие подзадачи для определения возможных входных данных, процессов и выходных данных, связанных с проблемой.
Без анализа и проектирования перед разработкой мы, скорее всего, получим код, который будет иметь много созависимостей и низкую производительность. Это полная противоположность принципам программирования. По сути, ваш код (если вы даже заставите его работать) будет сложнее писаться, сложнее отлаживаться, и не будет работать так же хорошо. Это похоже на то, как строители приходят к пустой яме в земле и одновременно все пытаются построить дом. Подобно постройке дома, написание программы должно выполняться в определенном порядке, если мы хотим сделать это эффективно и в результате найти наилучшее решение.
### ВРЕДНЫЙ СОВЕТ №8
> Код форматировать и тратить время?
>
> Нет уж, извольте! Зачем это все?
>
> Вот как написано — так прочитают,
>
> Ютубчик мне нужно глянуть еще.
>
>
**На практике:**
Да, форматирование кода не столь важно для работы компонентов. Компьютеру не важно, насколько красиво выглядит код, если он правильный и не выдает ошибок.
Но тем не менее, кому же это может пригодиться? Людям. Таким же, как вы и я, которым нужно время от времени читать, понимать и изменять код.
В таких случаях намного проще, если у вас есть правильное форматирование и/или комментарии, облегчающие понимание логики и работы проекта. Неиспользование этого в коде эквивалентно отказу от форматирования в письменной форме. Вы бы не читали эту статью, если бы здесь не было абзацев и заголовка, независимо от того, насколько хорош контент в целом.
По этой причине было придумано некое соглашение, по которому код должен выглядеть максимально понятным. Это помогает избежать ошибок, устранить неполадки и значительно упростить обслуживание чужой или своей работы.
Однако важно отметить, что не существует единого окончательного способа стилизации. К примеру, можно разобрать Prettier c ESlint. Принимая во внимание, что Prettier используется для автоматической корректировки кода, чтобы обеспечить соблюдение самоуверенного формата, ESLint следит за тем, чтобы стиль кода всегда оставался в «хорошей форме».
Заключение
----------
Осознание своих вредных привычек и работа над их исправлением — единственный способ по-настоящему обновиться и стать компетентным разработчиком в долгосрочной перспективе. Надеюсь, каждый из вас сможет для себя что-то почерпнуть и в последующем также делиться своими знаниями и «плохими» советами.
Спасибо за внимание! Полезные материалы для разработчиков мы также публикуем в наших соцсетях – [ВК](https://vk.com/simbirsoft_team) и [Telegram](https://t.me/simbirsoft_dev). | https://habr.com/ru/post/683338/ | null | ru | null |
Subsets and Splits