text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Единорог заинтересовался микромиром
В этот раз интересные примеры ошибок нам преподнёс микромир. Мы проверили с помощью анализатора кода PVS-Studio открытый проект μManager. Это программный пакет для автоматизированного получения изображения с микроскопа.
μManager
--------
Это относительно небольшой проект. Объем исходного кода около 11 мегабайт. Для чего именно нужен этот проект, я не знаю. Меня попросили его проверить. И вот единорог уже спешит на помощь. Наверное, нужный и полезный проект, раз попросили.
Сайт проекта: [Micro-Manager](http://www.micro-manager.org/).
Анализ как всегда выполнен с помощью анализатора [PVS-Studio](http://www.viva64.com/en/pvs-studio/). Кстати, если вы пропустили, то вот сравнение, которое так долго ждали наши потенциальные пользователи: "[Сравнение анализаторов кода: CppCat, Cppcheck, PVS-Studio, Visual Studio](http://www.viva64.com/ru/b/0241/)".
На этом лирическое отступление окончено. Начнём рассматривать интересные фрагменты кода.
long != int
-----------
Проект μManager претендует на кроссплатформенность. Поэтому, надо быть аккуратным с типом 'long'. В 32-битных системах размер типа 'long' совпадает с размером типа 'int'. А вот в 64-битных системах может быть по-разному. В Win64 тип 'long' остался 32-битным. В 64-битном мире Linux принята другая [модель данных](http://www.viva64.com/ru/t/0012/), в которой 'long' является 64-битным. Нужно проявлять бдительность, используя этот тип.
Проект μManager содержит следующий неудачный код:
```
typedef struct _DCMOTSTATUS
{
unsigned short wChannel; // Channel ident.
unsigned int lPosition; // Position in encoder counts.
unsigned short wVelocity; // Velocity in encoder counts/sec.
unsigned short wReserved; // Controller specific use
unsigned int dwStatusBits; // Status bits (see #defines below).
} DCMOTSTATUS;
int MotorStage::ParseStatus(...., DCMOTSTATUS& stat)
{
....
memcpy(&stat.lPosition, buf + bufPtr, sizeof(long)); //<<<(1)
bufPtr += sizeof(long);
memcpy(&stat.wVelocity, buf + bufPtr, sizeof(unsigned short));
bufPtr += sizeof(unsigned short);
memcpy(&stat.wReserved, buf + bufPtr, sizeof(unsigned short));
bufPtr += sizeof(unsigned short);
memcpy(&stat.dwStatusBits,
buf + bufPtr, sizeof(unsigned long)); //<<<(2)
return DEVICE_OK;
}
```
В строке (1) и (2) происходит копирование данных в переменные, имеющие тип 'int'. Копируется количество байт, равное размеру типа 'long'. Вспомним, что в 64-битной программе 'long' может занимать 8 байт. А тип 'int' занимает только 4 байта.
В случае (1) в этом нет ничего страшного. Изменим значение следующих членов структуры. Дальше эти члены заполнятся ещё раз. Уже правильно.
А вот случай (2) критичен. Изменяется значение последнего члена. Произойдёт запись за переделами структуры. К чему это приведёт, зависит от везения и фазы луны.
Ошибки выявляются благодаря диагностическим сообщениям PVS-Studio:* V512 A call of the 'memcpy' function will lead to overflow of the buffer '& stat.lPosition'. MotorStage.cpp 247
* V512 A call of the 'memcpy' function will lead to overflow of the buffer '& stat.dwStatusBits'. MotorStage.cpp 256
Останови уплотнитель мусора!
----------------------------
```
const unsigned char stopSgn[2] = {0x04, 0x66};
int MotorStage::Stop()
{
....
if (memcmp(stopSgn, answer, sizeof(stopSgn) != 0))
return ERR_UNRECOGNIZED_ANSWER;
....
}
```
Ошибка в том, что функция memcmp() сравнивает только один байт. Почему? Обидная ошибка. Не там поставлена закрывающаяся скобка. Количество байт для сравнения вычисляется так: sizeof(stopSgn) != 0. Это выражение равно значению 'true', которое превращается в единицу.
Условие должно быть таким:
```
if (memcmp(stopSgn, answer, sizeof(stopSgn)) != 0)
```
Ошибка выявлена с помощью диагностики: V526 The 'memcmp' function returns 0 if corresponding buffers are equal. Consider examining the condition for mistakes. MotorStage.cpp 385
Идентичные сравнения
--------------------
```
const char* g_Out = "Out";
int FieldDiaphragm::OnCondensor(....)
{
....
std::string value;
....
if (value == g_Out)
return
g_hub.SetCondensorPosition(*this, *GetCoreCallback(), 0);
else if (value == g_Out)
return
g_hub.SetCondensorPosition(*this, *GetCoreCallback(), 1);
....
}
```
Второй оператор 'if' содержит неправильное условие. Каким должно быть второе условие, я не знаю. Однако, хорошо видно, что второе условие никогда не выполнится.
Диагностика, выявившая ошибку: V517 The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 1455, 1457. LeicaDMR.cpp 1455
Есть ещё один фрагмент кода с аналогичной ошибкой. Видимо, с установкой позиции какого-то колёсика будут проблемы:
```
class Wheel : public CStateDeviceBase
{
....
unsigned wheelNumber\_;
....
};
int Wheel::SetWheelPosition(int position)
{
unsigned char cmd[4];
cmd[0] = moduleId\_; cmd[2] = 0; cmd[3] = 58;
if (wheelNumber\_ == 1) {
switch (position) {
case 0: cmd[1] = 49; break;
case 1: cmd[1] = 50; break;
case 2: cmd[1] = 51; break;
case 3: cmd[1] = 52; break;
case 4: cmd[1] = 53; break;
case 5: cmd[1] = 54; break;
}
} else if (wheelNumber\_ == 1) {
switch (position) {
case 0: cmd[1] = 33; break;
case 1: cmd[1] = 64; break;
case 2: cmd[1] = 35; break;
case 3: cmd[1] = 36; break;
case 4: cmd[1] = 37; break;
case 5: cmd[1] = 94; break;
}
....
}
```
Диагностическое сообщение PVS-Studio: V517 The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 645, 654. Ludl.cpp 645
Кажется, мы о чём-то забыли
---------------------------
Предлагаю посмотреть вот на этот код. Заметите, чего в нём не хватает?
```
class MP285
{
....
static int GetMotionMode() { return m_nMotionMode; }
....
};
int ZStage::_SetPositionSteps(....)
{
....
if (MP285::GetMotionMode == 0)
{
long lOldZPosSteps = (long)MP285::Instance()->GetPositionZ();
dSec = (double)labs(lZPosSteps-lOldZPosSteps) / dVelocity;
}
else
{
dSec = (double)labs(lZPosSteps) / dVelocity;
}
....
}
```
Не хватает очень важной вещи. Забыты скобочки (). Программа должна вызывать функцию GetMotionMode() и сравнивать возвращаемое ей значение с нулём. Вместо этого с нулём сравнивается адрес функции.
Ошибка была обнаружена с помощью диагностики: V516 Consider inspecting an odd expression. Non-null function pointer is compared to null: 'MP285::GetMotionMode == 0'. MP285ZStage.cpp 558
Одинокой странник
-----------------
```
int HalogenLamp::SetIntensity(long intensity)
{
....
command_stream.str().c_str();
....
}
```
Что это такое? Побочный эффект рефакторинга? Недописанный код? Безобидная лишняя строчка или ошибка?
Есть два места, где можно увидеть таких одиноких странников:* V530 The return value of function 'c\_str' is required to be utilized. ZeissCAN.cpp 1553
* V530 The return value of function 'c\_str' is required to be utilized. ZeissCAN.cpp 2800
«Брамины»
---------
```
int LeicaScopeInterface::GetDICTurretInfo(....)
{
....
std::string tmp;
....
if (tmp == "DIC-TURRET")
scopeModel_->dicTurret_.SetMotorized(true);
else
scopeModel_->dicTurret_.SetMotorized(true);
....
}
```
Вот так выглядит программный "[брамин](http://www.viva64.com/go.php?url=1365)". Независимо, выполнится условие или нет, выполняется один и тот же код.
Предупреждение: V523 The 'then' statement is equivalent to the 'else' statement. LeicaDMIScopeInterface.cpp 1296
Ещё одна ошибка схожего рода. Здесь сравниваются одинаковые строки. Наверное, этот код содержит опечатку:
```
int XLedDev::Initialize()
{
....
if (strcmp(
XLed::Instance()->GetXLedStr(XLed::XL_WLedDevName +
m_nLedDevNumber).c_str(),
XLed::Instance()->GetXLedStr(XLed::XL_WLedDevName +
m_nLedDevNumber).c_str()
) != 0)
....
}
```
Предупреждение: V549 The first argument of 'strcmp' function is equal to the second argument. XLedDev.cpp 119
Что-то не стыкуется
-------------------
Значения 'false' и 'true' могут неявно приводиться к типу 'int':* false превращается в 0;
* true превращается в 1.
Например, вот такой код успешно скомпилируется:
```
int F() { return false; }
```
Функция F() возвращает 0.
Иногда люди ошибаются и вместо статуса ошибки, который имеет тип 'int', возвращают 'false' или 'true'. Происходит это по забывчивости. Ничего страшного, если статус ошибки кодируется значением 0.
Беда возникает в том случае, если статусы ошибок кодируются значениями, отличными от нуля. Именно это происходит в проекте μManager.
Имеются следующие предопределённые значения:
```
#define DEVICE_OK 0
#define DEVICE_ERR 1 // generic, undefined error
#define DEVICE_INVALID_PROPERTY 2
#define DEVICE_INVALID_PROPERTY_VALUE 3
#define DEVICE_INVALID_PROPERTY_TYPE 5
....
```
Обратите внимание, что 0 означает, что всё хорошо. Другие значения сообщают о наличии какой-то ошибки.
Мне кажется, в коде проекта μManager имеется путаница со статусами и значениями 'true', 'false'.
Рассмотрим функцию CreateProperty():
```
int MM::PropertyCollection::CreateProperty(....)
{
if (Find(pszName))
return DEVICE_DUPLICATE_PROPERTY;
....
if (!pProp->Set(pszValue))
return false;
....
return DEVICE_OK;
}
```
Обратите внимание, что если вызов pProp->Set(pszValue) закончился неудачно, то функция возвращает 'false'. Получается, что функция возвращает статус DEVICE\_OK. Это очень странно.
Другой подозрительный фрагмент кода:
```
int MM::PropertyCollection::RegisterAction(
const char* pszName, MM::ActionFunctor* fpAct)
{
MM::Property* pProp = Find(pszName);
if (!pProp)
return DEVICE_INVALID_PROPERTY;
pProp->RegisterAction(fpAct);
return true;
}
```
В конце мы видим «return true;». Это означает, что функция вернёт статус DEVICE\_ERR 1 (generic, undefined error). При этом, мне кажется, что на самом деле всё хорошо.
Возможно читать покажется странным, почему я называю эти места подозрительными, а не говорю, что это ошибки. Дело в том, что местами 'false' используется специально, чтобы выделить особые случаи. Пример:
```
int XYStage::Home()
{
....
if (ret != DEVICE_OK)
{
ostringstream os;
os << "ReadFromComPort failed in "
"XYStage::Busy, error code:" << ret;
this->LogMessage(os.str().c_str(), false);
return false; // Error, let's pretend all is fine
}
....
}
```
Обратите внимание на комментарий. Произошла ошибка. Но мы притворимся, что всё хорошо, вернув ноль. Возможно, 'false' написан вместо DEVICE\_OK, чтобы подчеркнуть особенность этого кода.
Таких комментариев правда только парочка. А вот в остальных местах непонятно, ошибка это или «хитрый финт ушами». Рискну предположить, что в половине мест всё правильно, а половина действительно окажутся ошибками.
В любом случае такой код очень плохо пахнет.
Вот список всех подозрительных мест:* V601 The 'false' value is implicitly casted to the integer type. Property.cpp 364
* V601 The 'true' value is implicitly casted to the integer type. Property.cpp 464
* V601 The 'false' value is implicitly casted to the integer type. PIGCSControllerCom.cpp 405
* V601 The 'false' value is implicitly casted to the integer type. Prior.cpp 778
* V601 The 'false' value is implicitly casted to the integer type. Prior.cpp 2308
* V601 The 'false' value is implicitly casted to the integer type. Prior.cpp 2313
* V601 The 'false' value is implicitly casted to the integer type. Prior.cpp 2322
* V601 The 'false' value is implicitly casted to the integer type. SutterLambda.cpp 190
* V601 The 'false' value is implicitly casted to the integer type. SutterLambda.cpp 269
* V601 The 'false' value is implicitly casted to the integer type. SutterLambda.cpp 285
* V601 The 'false' value is implicitly casted to the integer type. Tofra.cpp 900
* V601 The 'false' value is implicitly casted to the integer type. Tofra.cpp 1806
* V601 The 'false' value is implicitly casted to the integer type. Tofra.cpp 1830
Странный Get
------------
```
int pgFocus::GetOffset(double& offset)
{
MM_THREAD_GUARD_LOCK(&mutex);
deviceInfo_.offset = offset;
MM_THREAD_GUARD_UNLOCK(&mutex);
return DEVICE_OK;
}
```
Мне кажется, или с эти кодом что-то не в порядке?
Анализатору этот код не нравится: V669 The 'offset' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. pgFocus.cpp 356
И действительно, странно. Функция называется «Get\_\_\_\_». Функция возвращает статус. А ещё она принимает аргумент 'offset' по ссылке. И… И не записывает ничего в него. Я не знаю, как всё это работает. Но, быть может, надо было сделать присваивание наоборот? Как-то так:
```
offset = deviceInfo_.offset;
```
Ещё одна подозрительная функция GetTransmission():
```
int SpectralLMM5Interface::GetTransmission(....,
double& transmission)
{
....
int16_t tr = 0;
memcpy(&tr, answer + 1, 2);
tr = ntohs(tr);
transmission = tr/10;
....
}
```
Предупреждение PVS-Studio: V636 The 'tr / 10' expression was implicitly casted from 'int' type to 'double' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;. SpectralLMM5Interface.cpp 198
Обратите внимание, что возвращаемое значение имеет тип double (речь идёт о transmission). Но вычисляется это значение странно. Целочисленное значение делится на 10. У меня есть сильное подозрение, что происходит потеря точности. Например, если 'tr' равно 5, то после деления мы получим 0, а вовсе не 0.5.
Наверное, правильный код должен выглядеть так:
```
transmission = tr/10.0;
```
Ошибка или не ошибка? Первое впечатление может быть обманчиво.
--------------------------------------------------------------
В языке Си/Си++, числа начинающиеся с нуля считаются заданными в восьмеричном формате. В проекте μManager есть одно подозрительное место:
```
int LeicaDMSTCHub::StopXY(MM::Device& device, MM::Core& core)
{
int ret = SetCommand(device, core, xyStage_, 010);
if (ret != DEVICE_OK)
return ret;
return DEVICE_OK;
}
```
Предупреждение PVS-Studio: V536 Be advised that the utilized constant value is represented by an octal form. Oct: 010, Dec: 8. LeicaDMSTCHub.cpp 142
Не понятно, действительно хотели использовать число 8, написанное в восьмеричном формате или это ошибка. В других местах в функцию SetCommand() передаются числа, записанные в десятичной системе счисления. Например, так:
```
int ret = SetCommand(device, core, xyStage_, 35, ack);
```
Не знаю, найдена ошибка или нет, но упомянуть про это место стоит.
### Перфекционист негодует
Есть масса мелочей, которые не являются существенными. Однако, почти все программисты перфекционисты. Давайте поворчим.
Полно лишних строчек. Один из примеров:
```
int XYStage::OnTriggerEndX(MM::PropertyBase* pProp,
MM::ActionType eAct){
if (eAct == MM::BeforeGet)
{
int ret = GetCommandValue("trgse",xChannel_,chx_.trgse_);
if (ret!=DEVICE_OK)
if (ret!=DEVICE_OK)
return ret;
.....
}
```
Вторая проверка явно лишняя.
Другой пример:
```
int AFC::Initialize()
{
int ret = DEVICE_OK;
....
if (ret != DEVICE_OK)
return ret;
AddAllowedValue("DichroicMirrorIn", "0", 0);
AddAllowedValue("DichroicMirrorIn", "1", 1);
if (ret != DEVICE_OK)
return ret;
....
}
```
Вторая проверка опять не имеет смысла. Перед ней переменная 'ret' нигде не изменится. Вторую проверку можно смело удалить.
Таких лишних проверок достаточно много. Приведу их списком: [Micro-Manager-V571-V649.txt](http://www.viva64.com/external-pictures/txt/Micro-Manager-V571-V649.txt).
Ещё из мелочи можно отметить неправильной формат при работе с функциями sprintf(). Беззнаковая переменная распечатывается, как знаковая. Это может привести к некорректной распечатке больших значений.
```
int MP285Ctrl::Initialize()
{
....
unsigned int nUm2UStepUnit = MP285::Instance()->GetUm2UStep();
....
sprintf(sUm2UStepUnit, "%d", nUm2UStepUnit);
....
}
```
Нашлось три таких места:* V576 Incorrect format. Consider checking the third actual argument of the 'sprintf' function. The SIGNED integer type argument is expected. MP285Ctrl.cpp 253
* V576 Incorrect format. Consider checking the third actual argument of the 'sprintf' function. The SIGNED integer type argument is expected. MP285Ctrl.cpp 276
* V576 Incorrect format. Consider checking the third actual argument of the 'sprintf' function. The SIGNED integer type argument is expected. MP285Ctrl.cpp 327
Заключение
----------
Единичная проверка этого и любого другого проекта малоэффективна. Пользу можно получить только при регулярном использовании статических анализаторов кода. Тогда многие ошибки и опечатки будут исправлены на самом раннем этапе. Рассматривайте статический анализ, как расширение предупреждений, которые выдаёт компилятор.
Командам, создающим средние и крупные проекты для операционной системы Windows, мы рекомендуем использовать наш статический анализатор [PVS-Studio](http://www.viva64.com/ru/b/0222/). Цена зависит от размера команды и требуемого уровня поддержки.
Для небольших команд и индивидуальных разработчиков мы предлагаем инструмент [CppCat](http://www.cppcat.com/). Индивидуальная лицензия — $250. Продление — $200. При покупке нескольких лицензий — скидки.
Тем, кто работает с Linux, мы предлагаем обратить внимание на бесплатный анализатор кода [Cppcheck](http://www.viva64.com/ru/t/0083/). Или попробовать [Standalone](http://www.viva64.com/ru/b/0219/) версию PVS-Studio.
P.S.
----
Перевод этой статьи: "[The Unicorn's Travel to the Microcosm](http://www.viva64.com/en/b/0242/)".
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio и CppCat, версия 2014](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/216157/ | null | ru | null |
# Centos-admin.ru: познаем Ansible
Это не готовая инструкция, с большим количеством кода, а скорее описание алгоритма и результатов чего [мы](http://centos-admin.ru) добились.
Итак, не так давно у нас появился новый клиент. У него было несколько нетипичных для нас требований: использовать для конфигурирования серверов ansible, контент сайта хранится в git, каждый сайт находится на своей виртуальной машине. Все это не сулило ничего хорошего, так как совсем не укладывалось в стандартную схему «Клиент всегда прав!», и мы начали разрабатывать новую схему. Но обо всем по порядку.
Исходные данные: есть клиент, у которого более 30 сайтов которые надо перенести на нашу площадку. Каждый сайт должен располагаться в отдельном контейнере (мы используем OpenVZ контейнеры). Используется только один внешний IP. Для конфигурирования серверов используется ansible. Для каждого сайта есть архив с конфигурационными файлами. Контент сайта находится в git.
И мы начали творить… Что у нас получилось, можно посмотреть под катом. Забегая вперед, скажу, разворот нового сайта сводится к нескольким командам.
У нас есть несколько шаблонов для разворачивания новых контейнеров, в виде архивов. Для начала мы внесли некоторые изменения в эти шаблоны, а точнее добавили пользователя ansilble и ключи. Это позволило сразу после разворота, без дополнительных действий настраивать контейнер с помощью ansible.
В ansible у нас было создано несколько ролей, не буду описывать их все, только про самые интересные:
* create\_vm
* content\_update
create\_vm это роль, которая, собственно, и создает вм и и конфигурирует ее.
Чуть подробнее.
Эта роль применяется к хостовой машине на которой будет установлен контейнер. Сразу оговорюсь, везде активно используются host\_vars. У хостовой машине в host\_vars, есть только одна переменная vm\_number. Эта переменная содержит номер последнего контейнера +1, после выполнения playbook этот номер будет увеличен на 1. Так же в playbook для это роли используются «vars\_promt». Это первое, что нам показалось интересным и мало где описанный механизм. vars\_promt позволяет интерактивно задавать переменные при выполнении playbook и в дальнейшем к этим переменным можно обращаться в шаблонах, заданиях и тд. Мы вынесли в эти переменные такие уникальные данные для каждого сайта как имя сайта, репозитарий git (где хранится контент сайта) и адрес, где расположены конфигурационные файлы для сайта.
Получилось примерно так:
```
- name: Create new vm
hosts: ds
remote\_user: ansible
sudo: true
roles:
- new\_vm
vars\_prompt:
conf\_url: "Введите url c архивов конфигов который приложен к заданию"
area\_fqdn: "Введите имя сайта"
git\_repo: "Введите адрес git репозитария"
```
Описание самих тасков приводить не буду, так как получились достаточно длинными. Если кому-то будет интересно можем прислать.
А дальше все очень просто, ansible подключается к хосту, выкачивает архив шаблона, проверяет что вм с таким номером нет и создает вм, задает ей IP и имя, на этом все процедуры на хосте заканчиваются.
Дальше очень полезным оказался модуль ansible local\_action, который позволяет выполнять действия на хосте откуда запускается playbook. Asible выкачивает файлы конфигурации для сайта (nginx, apache и т.д.), по ссылке которую мы задаем в интерактивной переменной, создает структуру каталогов в ansible, добавляет новый контейнер к ролям в ansible и раскладывает конфиги. А также создается host\_vars для нового контейнера, в которых задается имя сайта и git репозитарий, это пригодится в дальнейшем, это нам потребуется в дальнейшем. На этом создание контейнера закончено.
Как было сказано в начале, есть только один белый ip для всех сайтов. Не проблема, был создан контейнер с проксирующим nginx. Для новых контейнеров надо добавлять правила проксирования. И тут нам на помощь пришли шаблоны и все те же интерактивные переменные. Также локально из шаблона создаётся файл конфигурации прокси для нового контейнера.
Ага, уже неплохо. Запустив playbook у нас создается контейнер со всеми настройками. Но на этом мы не останавливаемся. И добавили еще выгрузку контента из репозитария. За это как раз и отвечает роль content\_update.
Вкратце о роли content\_update. Ansible делает клон git репозитария и потом с помощью скрипта раскладывает контент сайта в нужные директории с нужными правами. На этом, собственно, подготовка контейнера почти закончена, остается запустить playbook для применения конфигурации для нового контейнера и все, контейнер можно передавать заказчику.
###### Автор: системный администратор [компании](http://centos-admin.ru) [Magvai69](http://habrahabr.ru/users/magvai69/) | https://habr.com/ru/post/259107/ | null | ru | null |
# А мы пойдем другим путем. Перемещаем модель в базу данных
В последнее время веб-разработка из наколенного поделия превратилась в серьезную инженерную дисциплину. Все это стало возможным стараниями легиона специалистов, которые разработали общие практики, которые позволяют писать веб-проекты, с использованием некой архитектуры, а не подобно исследователю, сбрасывающему ящик типографского шрифта с крыши небоскреба, в надежде, что тот чудесным образом сложится в первый том «Войны и Мира». Самой распространенной парадигмой веб-программирования является, вне всякого сомнения, [MVC](http://ru.wikipedia.org/wiki/Model-View-Controller) — Model-View-Controller. Говоря примитивно, эта парадигма предусматривает разделение кода приложения на слой управления (Controller), слой представления (View) и слой управления данными (Model). При этом MVC предусматривает, что Controller и View могут (но не обязаны) зависеть от Model, в то время как Model ни при каких условиях не должен зависеть от них.
Есть много различных подходов, как отделить бизнес-логику приложения от логики отображения и управления. Все они предусматривают, что модель является частью приложения и взаимодействует с БД, использую последнюю лишь в качестве хранилища данных. Мы же попытаемся пойти иным путем и по возможности максимально вынести бизнес-логику приложения на уровень БД.
**Предупреждение**: лицам с тонкой душевной организацией лучше не видеть того, что будет твориться под катом.
#### Введение
Чтобы не быть похожим на шизофреника, скажу: в своей жизни мне довелось увидеть одно очень большое приложение, написанное похожим образом. Практически вся его бизнес-логика выполнялась на уровне БД. Было эффективно с точки зрения производительности приложения и ужасно с точки зрения производительности программиста. Правда написано оно было под ASP.NET + MS SQL Server с его, несравненно большими возможностями. Мы же будем в своих экспериментах использовать опостылевшую связку: PHP (5.3.1) + Zend Framework (1.11) + MySQL (5.1.4).
Итак, окинем пристальным взором наш инструментарий и не будем сильно унывать (хотя есть от чего). Средства для работы с хранимыми процедурами и функциями в MySQL находятся в зачаточном состоянии, встроенной поддержки работы с хранимыми процедурами и функциями в PHP фактически нет.
#### А что ваять-то будем?..
В качестве Hello-world проекта возьмем простенький бложик с записями, комментариями и тэгами. Функционал по минимуму — наша задача просто исследовать принцип переноса модели в БД.
В качестве программной платформы будем использовать Zend Framework.
#### На штурм!
Итак база данных у нас имеет самую простую структуру из 4 таблиц:
Итак, наша задача — перенести всю (или хотя бы часть) бизнес-логику в слой БД. Для этого мы будем использовать хранимые процедуры и функции, хранящиеся и выполняющиеся непосредственно на стороне сервера БД.
Прежде всего инициализируем приложение Zend Framework из командной строки:
```
zf create project ./
zf create controller posts
zf create controller comments
zf create controller tags
zf create action add Posts
zf create action edit Posts
zf create action save Posts
zf create action delete Posts
zf create action addComment Posts
zf create action view Posts
zf create db-table Posts sb_posts
zf create db-table Comments sb_comments
zf create db-table Tags sb_tags
zf create db-table PostTags sb_post_tags
zf create form Post
zf create form Comment
zf enable layout
```
Для начала напишем процедуру по сохранению поста:
```
CREATE DEFINER = 'sqlblog'@'localhost' PROCEDURE `Posts_save`(
IN title VARCHAR(100),
IN text TEXT,
INOUT post_id INTEGER(11)
)
BEGIN
IF ISNULL(`post_id`) OR `post_id` = 0 THEN
INSERT INTO `sb_posts` (`title`, `text`, `date`)
VALUES (`title`, `text`, NOW());
SET `post_id` = LAST_INSERT_ID();
ELSE
UPDATE `sb_posts` AS p
SET p.`title` = `title`, p.`text` = `text`
WHERE p.`id` = `post_id` LIMIT 1;
END IF;
END;
```
Первые два параметра, передаваемые в процедуру — это заголовок записи и непосредственно текст записи. Последний параметр — ID записи. Этот параметр неслучайно имеет тип INOUT. Внимательный читатель уже мог убедиться, что данная процедура имеет двойственную логику: создает запись, если post\_id не передавался или передавался как 0, и обновляет запись в противном случае. После выполнения процедуры ID записи возвращается во все том же третьем параметре.
К сожалению, удобство работы с хранимыми процедурами из PHP оставляет желать лучшего. В частности, PDO позволяет при выполнении запроса указывать, что тип передаваемого параметра INOUT. В этом случае после выполнения запроса на вызов процедуры в переменной, указанной в качестве такого параметра будет возвращено значение, возвращаемое хранимой процедурой:
```
$post_id = 0;
$sth = $dbh->prepare('CALL Posts_save(?, ?, ?)');
$sth->bindParam(1, 'Post title', PDO::PARAM_STR);
$sth->bindParam(2, 'Post body', PDO::PARAM_STR);
$sth->bindParam(3, $post_id, PDO::PARAM_INT|PDO::PARAM_INPUT_OUTPUT, 11);
$sth->execute();
print("New post ID is: $post_id");
```
Однако сия замечательная функция не работает применительно к MySQL. Потому для нормальной работы с MySQL приходится извращаться и использовать переменные самого MySQL. Трюк прост: указываем в качестве третьего параметра переменную MySQL, а потом извлекаем ее значение при помощи SELECT:
```
SET @post_id = 12;
CALL Posts_save('Post title', 'Post body', @post_id);
SELECT @post_id AS post_id;
```
Первый запрос нужен только при обновлении существующей записи.
Для создания записи создадим следующую форму:
```
class Application_Form_Post extends Zend_Form
{
public function init()
{
$this
->addElement('hidden', 'id')
->addElement('text', 'title', array('label' => 'Title:', 'required' => true))
->addElement('textarea', 'text', array('label' => 'Text:', 'required' => true))
->addElement('text', 'tags', array('label' => 'Tags:', 'required' => true))
->addElement('submit', 'submit', array('label' => 'Add Post'));
}
public function prepareDecorators()
{
$this->setDecorators(array(
'FormElements',
'FormErrors',
'Form'
));
return $this;
}
}
```
Теперь в коде контроллера нам достаточно написать следующее:
```
class PostsController extends Zend_Controller_Action
{
public function addAction()
{
$this->view->form = $form = new Application_Form_Post(array(
'name' => 'postForm',
'action' => '/posts/save/'
));
$form->prepareDecorators();
}
public function saveAction()
{
$post_id = $this->_getParam('id');
$this->view->form = $form = new Application_Form_Post(array(
'name' => 'postForm',
'action' => '/posts/save/'
));
if ($this->getRequest()->isPost()) {
if ($form->isValid($this->getRequest()->getPost())) {
$result = $this->_helper->procedure()->Posts_save(
$form->getValue('title'),
$form->getValue('text'),
$post_id
);
if ($post_id) {
$tags = $form->getValue('tags');
$tags = explode(',', $tags);
$tags = array_map('trim', $tags);
$this->_helper->procedure()->Post_clearTags($post_id);
foreach ($tags as $tag) {
$this->_helper->procedure()->Post_addTag($post_id, $tag);
}
$this->_redirect('/posts/view/id/' . $post_id);
}
}
$this->view->form = $form->prepareDecorators();
}
else {
$this->_redirect('/posts');
}
}
}
```
Расширим слегка наш функционал. Как и предполагалось, к каждому посту автор добавляет тэги, которые затем нужно выводить в виде облака. Для того, чтобы выполнить эту задачу нам необходимо на каком-то этапе вычислять вес каждого тэга. Есть несколько вариантов:
1. Вычислять налету, запросом для каждого тэга
2. Хранить вес каждого тэга в таблице и обновлять его при любых изменениях
Первый вариант легко решается запросом:
```
SELECT t.*, getTagWeight(t.id) AS weight FROM sb_tags AS t
```
Здесь getTagWeight — заранее созданная функция, вычисляющая вес тэга. Однако, ввиду того, что облако тэгов будет выводится очень часто (гораздо чаще, чем будет изменяться порядок и состав тэгов), то такой запрос нельзя считать эффективным решением проблемы. Неплохим выходом из сложившейся ситуации было бы кэширование облака тэгов целиком, но мы попробуем решить эту проблему другим путем.
В MySQL, начиная с версии 5.0 появился механизм триггеров — процедур, которые запускаются при выполнении некого условия. Навешивается такой триггер и срабатывать может, например, до вставки данных или после удаления. Таким образом, мы можем решить проблему вычисления весов тэгов путем навешивания двух триггеров на связующую таблицу — sb\_post\_tags:
```
CREATE DEFINER = 'sqlblog'@'localhost' TRIGGER `sb_post_tags_after_ins_tr` AFTER INSERT ON `sb_post_tags`
FOR EACH ROW
BEGIN
UPDATE `sb_tags` AS t
SET t.`weight` = `Tag_calculateWeight`(`Tag_getById`(NEW . tag_id))
WHERE t.`id` = NEW.tag_id;
END;
CREATE DEFINER = 'sqlblog'@'localhost' TRIGGER `sb_post_tags_after_del_tr` AFTER DELETE ON `sb_post_tags`
FOR EACH ROW
BEGIN
UPDATE `sb_tags` AS t
SET t.`weight` = `Tag_calculateWeight`(`Tag_getById`(OLD.`tag_id`))
WHERE t.`id` = OLD.`tag_id`;
END;
```
Таким образом при каждой вставке/удалении в/из таблицы sb\_post\_tags веса тэгов пересчитываются и сохраняются в таблице sb\_tags, откуда их уже можно извлекать простым запросом.
#### Выводы
Итак, что же в сухом остатке? Простенькие проекты таким способом писать можно, но у крупных проектов при таком подходе расходы в человекочасах по моему мнению будут расти экспоненциально со сложностью проекта.
Есть ли плюсы? Есть: это быстро. Даже по сравнению с DDD это быстро. На написание 13 процедур и 7 функций я потратил 15-20 минут. И они пишутся реально легко и просто.
Минусы:
* С отладкой все плохо. Я не знаю, возможна ли пошаговая отладка хранимых процедур
* Связка PHP-Mysql применительно к хранимым процедурам работает отвратительно. Возможно, если использовать PgSQL или MSSql, то эффективность разработки можно повысить
* В связи с некоторыми ограничениями языка MYSQL, некоторую функциональность все-таки пришлось реализовывать стандартными средствами. В частности, я говорю о постраничном выводе, так как LIMIT может принимать только константные значения, за исключением случаев, когда используется связка PREPARE/EXECUTE
В любом случае, данный топик следует рассматривать лишь как эксперимент. Обсуждение приветствуется.
Я не рассматривал здесь все процедуры, а лишь указал ключевые моменты разработки. Для тех, кому интересен проект в целом, могу предложить репозиторий проекта на [github](https://github.com/tankist/sqlblog) | https://habr.com/ru/post/113124/ | null | ru | null |
# Selenium Manager: история одного интерфейса
Привет, Хабр!
Меня зовут Виталий Котов и я работаю в компании Badoo. В одной из предыдущих [статей](https://habrahabr.ru/company/badoo/blog/337126/) я рассказывал, что у нас есть некий интерфейс, который помогает взаимодействовать с автотестами как тестировщикам, так и разработчикам.
Не [раз](https://habrahabr.ru/company/badoo/blog/317700/#comment_9968226) и не [два](https://habrahabr.ru/company/badoo/blog/337126/#comment_10398118) меня просили рассказать о нём подробнее.
Под катом я (наконец!) расскажу о том, как писал этот интерфейс и что он умеет. Расскажу о фичах, которые прижились, и о тех, которые оказались невостребованными по тем или иным причинам. Возможно, некоторые идеи вам покажутся интересными, и вы тоже задумаетесь о подобном «помощнике».
С чего всё началось
-------------------
Итак, началось всё с Selenium-тестов. Отсюда название интерфейса — Selenium Manager. Хотя сейчас в нём можно запускать также [Smoke-тесты](https://habrahabr.ru/company/badoo/blog/316874/).
В какой-то момент мы поняли, что наши тесты умеют много всего. А понятно это стало по количеству дополнительных ключей, которые можно было указать при запуске, чтобы тесты выполнялись тем или иным образом. Вот лишь некоторые из них:
* **Platform** — определяет, на какой платформе (девел, шот или стейджинг) мы запускаем тесты. О том, какие этапы тестирования есть у нас в компании можно почитать [в этой статье](https://habrahabr.ru/company/badoo/blog/317700/).
* **App** — определяет, против какого из наших приложений будет запущен тест. Поскольку тест хранит в себе только бизнес-логику, отдельную от [PageObject](https://github.com/SeleniumHQ/selenium/wiki/PageObjects), этот ключ довольно полезный.
* **Browser** — задаёт браузер, на котором будет запущен тест.
* **Local** — если указать этот ключ, тест пойдёт на локально поднятый Selenium-сервер вместо Selenium-фермы.
* **Help** — если указать этот ключ, вместо запуска теста мы увидим инструкцию по всем ключам. :)
И так далее. В общей сложности я насчитал 25 ключей. И для 11 из них можно указать более двух вариантов значений. Это много, и не хотелось держать всё это в голове или пользоваться без конца командой «Help».
Первая версия
-------------
Первая версия интерфейса появилась в 2014 году. По моей задумке, он должен был просто парсить все возможные ключи и значения из конфига и рисовать соответствующий набор HTML-элементов в браузере. После того как пользователь выставлял необходимый набор параметров и нажимал на кнопку «получить команду запуска», он видел на экране соответствующую строчку, которую можно было скопировать в терминал.
За вечер «накидав» прототип, я пошёл показывать его ребятам. Конечно, всем понравилось, *«но, может быть, можно сделать так, чтобы тест сразу и запускался из этого интерфейса?»* — был ответ. Довольно ожидаемый, конечно.
Я начал думать в эту сторону…
Запуск теста из интерфейса
--------------------------
Наши тесты написаны на PHP. В качестве «пускалки» мы используем PHPUnit. Идея для запуска теста из консоли была следующая: мы выставляем необходимый набор параметров, указываем тест и AJAX-запросом отправляем на сервер, где будет выполняться код нашего теста.
На стороне сервера формируется строка-команда, которая будет запускаться при помощи команды [exec](http://php.net/manual/en/function.exec.php). Не забываем отвязать команду от консоли, иначе exec будет выполняться столько, сколько выполняется сам тест. Нам это не нужно — нам нужно получить только PID процесса.
Примерно так:
```
function launchTest($cmd, $logfile)
{
$cmd = escapeshellcmd($cmd);
exec($command = 'sh -c "' . $cmd . '" > ' . $logfile . ' & echo $!', $out);
if (count($out) !== 1) {
die("Wrong launch command: {$command}"]);
}
return $out[0];
}
```
Как видно из контекста, мы предварительно создаём logfile, куда будем писать лог по ходу прохождения теста.
Получив PID, мы возвращаем его и путь до лог файла клиенту, который запускает простенький [setInterval](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setInterval). Раз в N секунд клиент стучится на сервер и получает актуальное содержимое лог файла и статус PID. Если PID пропал, вызывается [clearInterval](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/clearInterval). Совсем просто:
```
var interval_id;
function startPidProcessing() {
interval_id = setInterval(self.checkPid, 4500);
}
function stopPidProcessing() {
clearInterval(interval_id);
interval_id = null;
}
```
Таким образом мы видим прогресс прохождения теста. И знаем, когда он завершился.
Запуск нескольких тестов параллельно
------------------------------------
В далёком 2013 году PHPUnit не умел запускать тесты параллельно. И это было серьёзной проблемой, поскольку уже тогда у нас было столько Selenium-тестов, что в один поток они могли идти не один час. Тогда же мой коллега Илья Кудинов писал статью о том, как мы [начали](https://habrahabr.ru/company/badoo/blog/181488/) решать эту задачу для юнит-тестов.
Но итоговое решение не очень подошло для Selenium-тестов.
Оптимальным решением стал Selenium Manager. Ведь если из него можно запустить один тест, то почему бы не открыть новую вкладку и не запустить второй? Шучу…
Это можно сделать из той же вкладки. Для этого достаточно хранить на стороне клиента список PID’ов для каждого из тестов и при запросе на сервер опрашивать их все, возвращая статус для каждого. С лог-файлами поступать аналогично.
Я добавил в интерфейс возможность выставить количество запускаемых одновременно тестов. По сути, это количество потоков, в которых будут запускаться тесты. Если потоков меньше, чем итоговое количество тестов, то тесты становятся в очередь и ждут, когда пройдёт один из запущенных, чтобы занять его место.
Запуск тестов по filter и group
-------------------------------
Этого оказалось недостаточно. Теперь нужно было открывать терминал и копировать оттуда пути до всех необходимых файлов с тестами. Тем более, иногда хочется запустить не все тесты из файла, а только некоторые (для этого в PHPUnit существует параметр [filter](https://phpunit.de/manual/current/en/textui.html#textui.examples.filter-patterns)).
Для решения этой проблемы я на клиенте сделал простой HTML-элемент textarea, куда можно было писать только названия классов, а через «::» указывать фильтр. Например, так:
Туда можно было написать что угодно и даже скопировать список упавших тестов из TeamCity. Всё это отправлялось на сервер и парсилось. Как определить, похоже ли какое-то сочетание на название класса, в котором есть такой-то тест? А затем определить путь до файла с этим классом, чтобы запустить тест?
Мой метод получился примерно таким:
```
public static function parseTestNames($textarea)
{
$parts = preg_split('/[,\s\n]+/', $textarea);
$tests = [];
foreach ($parts as $part) {
$part_splited = explode('::', $part);
$filter = $part_splited[1] ?? false;
$testname = $part_splited[0];
if (is_file($testname)) {
$testname = $filter ? $testname . '::' . $filter : $testname;
$tests[] = $testname;
} else {
$found_tests = self::findPathByClassName($testname, $filter, $hard);
foreach ($found_tests as $test) {
$test = $filter ? $test . '::' . $filter : $test;
$tests[] = $test;
}
}
}
$result = array_values(array_unique($tests));
return $result;
```
Содержимое мы разбиваем по знакам пробела или переноса. Далее поочерёдно обрабатываем каждую из частей. В ней мы в первую очередь ищем сочетание «::», чтобы получить значение для фильтра.
Далее мы смотрим на первую часть (до знака «::»). Если она указана в виде пути до файла, запускаем его. Если нет (например, был указан только класс) — запускаем метод findPathByClassName, который умеет искать по названию классов в тестовых папках и возвращать путь до необходимого.
В PHPUnit есть возможность задавать тестам группы (об этом [тут](https://phpunit.de/manual/current/en/appendixes.annotations.html)). И, соответственно, запускать тесты, указав эти группы. У нас эти группы привязаны к фичам на сайте, которые эти тесты покрывают. Чаще всего, когда требуется запустить много тестов (но не все), нужно запустить их для какой-то группы или групп.
Я добавил список групп, который получается интерактивно с помощью того же поиска, с возможностью выбрать несколько из них и запустить тесты, не указывая никаких путей и названий классов.
Интерфейс для запуска тестов по группам выглядит примерно так:
Теперь можно запускать тесты либо по группам, либо по списку названий этих тестов.
Сами же запущенные тесты выглядят так:
Тест помечается жёлтым цветом, если он уже запущен; зелёным — если он прошёл успешно, красным — если упал. Синим цветом помечены тесты, которые прошли успешно, но внутри которых есть skipped тесты.
Внутри ячеек — обычный лог, который мы видим при запуске теста через PHPUnit:
Определить, прошёл тест успешно или нет, можно довольно просто на стороне клиента, используя регулярные выражения:
```
function checkTestReport(reg_exp) {
let text = $(cell_id).html();
let text_arr = text.split("\n");
if (text_arr[0].search('PHPUnit') != -1) {
return reg_exp.test(text_arr[2]);
} else {
return -1;
}
}
this.isTestSuccessful = function(cell_id) {
return checkTestReport(/^[\.]+\s/);
};
this.isTestSkipped = function(cell_id) {
return checkTestReport(/^[\.SI]+\s/);
};
```
Это не самое отказоустойчивое решение. Если мы однажды перестанем использовать PHPUnit, или у него существенно изменится строка вывода, метод перестанет работать (об этом мы обязательно узнаем, получив ответ «-1»). Но ни то, ни другое в ближайшее время, скорее всего, не произойдёт.
Запуск тестов в «облаке»
------------------------
Пока я делал интерфейс для запуска тестов, мы активно начали запускать тесты для шотов. Оказалось, что запустить столько тестов, сколько нам хочется, в TeamCity непросто. [Агентов](https://confluence.jetbrains.com/display/TCD9/Build+Agent) не хватает, а стоит это дорого.
Тогда мы перевели запуск тестов на «облачную» систему. О ней мы, возможно, напишем подробную статью в следующий раз. А пока я остановлюсь на том, что, поскольку эта система — «облачная», собирать логи с неё проблематично.
Мы создали простенькую MySQL-табличку, куда тесты в конце прогона начали логировать результаты: прошёл тест успешно или упал, с какой ошибкой, сколько он длился и так далее.
На основе этой таблицы на другой вкладке Selenium Manager’а мы начали рисовать результаты прогонов по названию шота. С возможностью прямо из интерфейса перезапустить упавший тест (если тест проходит успешно, он пропадает из списка упавших) или узнать, падал ли этот тест на других шотах с такой же ошибкой (определяется по трейсу ошибки):
Можно группировать тесты либо по типу ошибки (всё тот же трейс), либо расставлять в алфавитном порядке.
Система инвестигейтов
---------------------
Помимо описанных выше страничек, я бы хотел подробно остановиться ещё на одной. Это страница инвестигейтов. Бывает так, что *важная задача* попадает в тестирование с незначительным багом. Скажем, JS-ошибкой, не влияющей на пользователя. Откатывать такую задачу нецелесообразно. Мы поступаем следующим образом: ставим на разработчика баг-тикет, а задачу пропускаем дальше.
Но что делать с тестом, который теперь будет честно падать и на стейджинге, и на шотах, мешая жить и засоряя логи? Мы знаем, почему он падает, мы знаем, что, пока задачу не сделают, он будет продолжать падать. Стоит ли тратить время на то, чтобы его запускать и получать ожидаемый результат?
Я решил, что можно решить проблему следующим способом: всё в той же MySQL создать табличку, в которую через интерфейс будет добавляться тест с указанием тикета, из-за которого он сломан.
Тесты перед запуском будут получать этот список и сравнивать своё название с названиями из него. Если тесту не надо запускаться, он будет помечен как skipped с указанием соответствующей задачи в логе.
Также я написал простенький скрипт, который по крону ходит в эту табличку, получает список задач и идёт в JIRA (наш багтрекер) за статусами для них. Если какая-то задача закрылась, запись из таблицы инвестигейтов удаляется, тест начинает запускаться автоматически.
Что ещё умеет Selenium Manager
------------------------------
Помимо перечисленного выше, Selenium Manager умеет ещё кучу интересных и не менее полезных вещей.
Например, получать список всех шотов для текущего билда и запускать указанный тест для каждого из них. Это крайне полезно, когда на стейджинге начал падать тест, а определить руками и глазами виновный тикет не удалось.
Ещё есть страничка с таблицей, где представлен список нестабильных тестов и самых частых ошибок (для разных тестов). Она полезна для инженеров по автоматизации, так как помогает держать тесты в порядке. Не стоит забывать, что Selenium-тесты, как и любые другие UI-тесты, по определению нестабильны, и это нормально. Но иметь статистику самых «плохих» тестов с целью их стабилизации — это хорошо.
Напротив каждого теста в этой табличке есть кнопка, при помощи которой можно в один клик создать и перевести на себя тикет по стабилизации теста. Ссылка на тикет останется в таблице, так что будет видно, если тестом уже кто-то занимается.
Выглядит это примерно так:
Есть страничка, на которой живут графики [нод Selenium-фермы](http://www.seleniumhq.org/docs/07_selenium_grid.jsp). Наш инженер по автоматизации Артём Солдаткин уже рассказывал о том, как пропатчить Selenium, чтобы по HTTP-запросу была возможность получить данные о количестве свободных браузеров, сгруппированных по этим браузерам и версиям. Подробнее об этом [тут](https://habrahabr.ru/company/badoo/blog/307502/).
Я написал простенький скрипт, который по крону ходит на Selenium-ферму и собирает эту информацию, складывая её в табличку MySQL. На стороне клиента я использовал [plotly.js](https://plot.ly/javascript/), чтобы по этим данным рисовать графики.
Выглядит примерно так:
Так что есть возможность узнать, хватает ли нам мощностей на все наши нужды. :)
Какие фичи не прижились
-----------------------
Чаще всего нельзя заранее сказать, будет фича полезной или нет, пока не попробуешь. Иногда полезная на первый взгляд идея оказывается невостребованной.
Например, у нас была страница, где каждый желающий мог подписаться на конкретный тест или группу тестов. Если эти тесты начинали падать на стейджинге, всем подписавшимся приходили уведомления в чат.
Изначально задумывалось, что это будет полезно для задач, которые нельзя полностью протестировать на девеле или шоте, когда ручной тестировщик сам следит за состоянием тестов. Подписавшись, он мог понять, что подходящая под описание группа тестов сломалась на стейджинге и что с задачей есть какие-то проблемы.
На деле же оказалось, что предсказать группу тестов сложно. Чаще всего приходило много лишних уведомлений, а иногда необходимые уведомления не приходили, потому что упавшие тесты были из других групп.
В итоге мы вернулись к прежней схеме, где автоматизаторы сами оповещают ребят из отдела тестирования, что есть какие-то проблемы.
Итоги
-----
Интерфейс был удачно интегрирован в процесс тестирования. Теперь можно легко, просто и быстро запускать тесты с любыми параметрами, следить за их стабильностью и за всей системой автотестов в целом.
В целом я доволен, что получилось уйти от консоли. Не потому, что в ней есть что-то плохое, а просто потому, что интерфейс в данном случае экономит кучу времени, которое можно потратить с пользой.
Какой вывод из этого можно сделать? Оптимизируйте и упрощайте работу с вашими инструментами — и будет вам счастье.
Спасибо за внимание. | https://habr.com/ru/post/344030/ | null | ru | null |
# Умножение матриц: эффективная реализация шаг за шагом
Введение
--------
Умножение матриц — это один из базовых алгоритмов, который широко применяется в различных численных методах, и в частности в алгоритмах машинного обучения. Многие реализации прямого и обратного распространения сигнала в сверточных слоях неронной сети базируются на этой операции. Так порой до 90-95% всего времени, затрачиваемого на машинное обучение, приходится именно на эту операцию. Почему так происходит? Ответ кроется в очень эффективной реализации этого алгоритма для процессоров, графических ускорителей (а в последнее время и специальных ускорителей матричного умножения). Матричное умножение — один из немногих алгоритмов, которые позволяет эффективно задействовать все вычислительные ресурсы современных процессоров и графических ускорителей. Поэтому не удивительно, что многие алгоритмы стараются свести к матричному умножению — дополнительная расходы, связанные с подготовкой данных, как правило с лихвой окупаются общим ускорением алгоритмов.
Так как реализован алгоритм матричного умножения? Хотя сейчас существуют множество реализаций данного алгоритма, в том числе и в открытых исходных кодах. Но к сожалению, код данных реализаций (большей частью на ассемблере) весьма сложен. Существует хорошая [англоязычная статья](https://arxiv.org/pdf/1609.00076.pdf), подробно описывающая эти алгоритмы. К моему удивлению, я не обнаружил аналогов на Хабре. Как по мне, этого повода вполне достаточно, чтобы написать собственную статью. С целью ограничить объем изложения, я ограничился описанием однопоточного алгоритма для обычных процессоров. Тема многопоточности и алгоритмов для графических ускорителей явно заслуживает отдельной статьи.
Процесс изложения будет вестись ввиде шагов с примерами по последовательному ускорению алгоритма. Я старался писать максимально упрощая задачу, но не более того. Надеюсь у меня получилось…
Постановка задачи (0-й шаг)
---------------------------
В общем случае функция матричного умножения описывается как:
```
C[i,j] = a*C[i,j] + b*Sum(A[i,k]*B[k,j]);
```
Где матрица **A** имеет размер M х K, матрица **B** — K х N, и матрица **C** — M х N.
Мы без ущерба для изложения, можем считать, что a = 0 и b = 1:
```
C[i,j] = Sum(A[i,k]*B[k,j]);
```
Ее реализация на С++ «в лоб» по формуле будет выглядеть следующим образом:
```
void gemm_v0(int M, int N, int K, const float * A, const float * B, float * C)
{
for (int i = 0; i < M; ++i)
{
for (int j = 0; j < N; ++j)
{
C[i*N + j] = 0;
for (int k = 0; k < K; ++k)
C[i*N + j] += A[i*K + k] * B[k*N + j];
}
}
}
```
Глупо было бы ожидать от нее какой-либо производительности, и действительно тестовые замеры показывают, что при (M=N=K=1152) она выполняется почти 1.8 секунды (тестовая машина — i9-7900X@3.30GHz, ОС — Ubuntu 16.04.6 LTS, компилятор — g++-6.5.0б опции компилятора — "-fPIC -O3 -march=haswell"). Минимальное количество операций для матричного умножения — 2\*M\*N\*K = 2\*10^9. Иначего говоря, производительность составляет 1.6 GFLOPS, что очень далеко от теоретического предела однопоточной производительности для данного процессора (~120 GFLOPS (float-32) если ограничится использованием AVX2/FMA и ~200 GFLOPS при использовании AVX-512). Так, что нужно предпринять, чтобы приблизится к теоретическому пределу? Далее мы в ходе ряда последовательных оптимизаций придем к решению, которое во многом воспроизводит то, что используется во многих стандартных библиотеках. В процессе оптимизации, я буду задействовать только AVX2/FMA, AVX-512 я касаться не буду, так как их распостраненность пока невелика.
Устраняем очевидные недостатки (1-й шаг)
----------------------------------------
Сначала устраним самые очевидные недостатки алгоритма:
1. Вычисление адресов элементов массивов можно упростить — вынести постоянную часть из внутреннего цикла.
2. В оригинальной версии доступ к элементам массива **B** производится не последовательно. Его можно упорядочить, если поменять порядок вычисления таким образом, чтобы внутренним циклом был последовательный обход по строчкам для всех трех матриц.
```
void gemm_v1(int M, int N, int K, const float * A, const float * B, float * C)
{
for (int i = 0; i < M; ++i)
{
float * c = C + i * N;
for (int j = 0; j < N; ++j)
c[j] = 0;
for (int k = 0; k < K; ++k)
{
const float * b = B + k * N;
float a = A[i*K + k];
for (int j = 0; j < N; ++j)
c[j] += a * b[j];
}
}
}
```
Результат тестовых замеров показывает время выполнения в 250 мс, или 11.4 GFLOPS. Т.е. такими небольшими правками мы получили ускорение в 8 раз!
Векторизуем внутренний цикл (2-й шаг)
-------------------------------------
Если внимательно посмотреть на внутренний цикл (по переменной j), то видно, что вычисления можно проводить блоками (векторами). Практически все современные процессоры позволяют проводить вычисления над такими векторами. В частности набор инструкций AVX оперирует с векторами размерностью 256 бит. Что позволяет выполнить 8 операций для вещественных чисел с одинарной точностью за такт. AVX2/FMA делает еще один шаг вперед — он позволяет выполнить слитную операцию умножения и сложения (d = a\*b + c) над вектором. Настольные процессоры Интел начиная с 4-го поколения имеют 2 256-bit FMA модуля, что позволяет им теоретически выполнять 2\*2\*8 = 32 операции (float-32) за такт. К счастью, инструкции AVX2/FMA достаточно легко задействовать напрямую из С/С++ при помощи встроенных функций (intrinsics). Для AVX2/FMA они объявлены в заголовочном файле .
```
void gemm_v2(int M, int N, int K, const float * A, const float * B, float * C)
{
for (int i = 0; i < M; ++i)
{
float * c = C + i * N;
for (int j = 0; j < N; j += 8)
_mm256_storeu_ps(c + j + 0, _mm256_setzero_ps());
for (int k = 0; k < K; ++k)
{
const float * b = B + k * N;
__m256 a = _mm256_set1_ps(A[i*K + k]);
for (int j = 0; j < N; j += 16)
{
_mm256_storeu_ps(c + j + 0, _mm256_fmadd_ps(a,
_mm256_loadu_ps(b + j + 0), _mm256_loadu_ps(c + j + 0)));
_mm256_storeu_ps(c + j + 8, _mm256_fmadd_ps(a,
_mm256_loadu_ps(b + j + 8), _mm256_loadu_ps(c + j + 8)));
}
}
}
}
```
Запускаем тесты, получаем время 217 мс или 13.1 GFLOPS. Упс! Ускорение всего на 15%. Какже так? Тут нужно учитывать, два фактора:
1. Компиляторы нынче умные пошли (не все!), и вполне справляются с задачей автовекторизации простых циклов. Уже в 1-м варианте компилятор фактически задействовал инструкции AVX2/FMA, потому ручная оптимизация не дала нам практически никаких преимуществ.
2. Скорость расчетов в данном случае упирается не в вычислителные возможности процессора, а в скорость загрузки и выгрузки данных. В данном случае процессору для задействования 2 256-bit FMA блоков требуется загрузить 4 и выгрузить 2 256-bit вектора за такт. Это в два раза превышает даже пропускную способность L1 кеша процессора (512/256 bit), не говоря уже о пропускной способности памяти, которая еще на порядок меньше (64-bit на канал)).
Итак, основная проблема в ограниченной пропускной способности памяти в современных процессорах. Процессор фактически простаивает 90% времени, ожидая, когда данные загрузятся и сохранятся в памяти.
Дальнейшие наши шаги по оптимизации алгоритма будут направлены на минимизацию доступа в память.
Пишем микроядро (3-й шаг)
-------------------------
В предыдущей версии на 1 FMA операцию приходится 2 загрузки и 1 выгрузка.
Больше всего загрузок и выгрузок происходит с результирующей матрицей **С**: данные из нее нужно загрузить, прибавить к ним произведение C[i][j] += A[i][k]\*B[k][j], а потом сохранить. И так много раз. Наиболее быстрая память, с которой может работать процессор — это его собственные регистры. Если мы будем хранить результирующее значение матрицы **С** в регистре процессора, то в процессе расчета нужно будет подгружать только значение матриц **A** и **B**. Теперь у нас на 1 FMA операцию приходится только 2 загрузки.
Если мы будем хранить в регистрах значения двух соседних столбцов матрицы C[i][j] и C[i][j+1], то сможем повторно использовать загруженное значение матрицы A[i][k]. И на 1 FMA операцию потребуется только 1.5 загрузки. Кроме того, сохраняя результат в 2 независимых регистра, мы позволим процессору выполнять 2 FMA операции за такт. Аналогично можно хранить в регистрах значения двух соседних строк — тогда будет осуществляться экономия на загрузке значений матрицы **B**.
Всего настольные процессоры Интел начиная с 2-го поколения имеют 16 256-bit векторных регистров (справедливо для 64-bit режима процессора). 12 из них можно использовать для хранения кусочка результирующей матрицы **С** размером 6x16. В итоге мы сможем выполнить 12\*8 = 96 FMA операций загрузив из памяти только 16 + 6 = 22 значений. И того нам удалось сократить доступ к памяти с 2.0 до 0.23 загрузки на 1 FMA операцию — почти в 10 раз!
Функция которая осуществляет вычисление такого маленького кусочка матрицы **С**, обычно называется микроядром, ниже приведен пример такой функции:
```
void micro_6x16(int K, const float * A, int lda, int step,
const float * B, int ldb, float * C, int ldc)
{
__m256 c00 = _mm256_setzero_ps();
__m256 c10 = _mm256_setzero_ps();
__m256 c20 = _mm256_setzero_ps();
__m256 c30 = _mm256_setzero_ps();
__m256 c40 = _mm256_setzero_ps();
__m256 c50 = _mm256_setzero_ps();
__m256 c01 = _mm256_setzero_ps();
__m256 c11 = _mm256_setzero_ps();
__m256 c21 = _mm256_setzero_ps();
__m256 c31 = _mm256_setzero_ps();
__m256 c41 = _mm256_setzero_ps();
__m256 c51 = _mm256_setzero_ps();
const int offset0 = lda * 0;
const int offset1 = lda * 1;
const int offset2 = lda * 2;
const int offset3 = lda * 3;
const int offset4 = lda * 4;
const int offset5 = lda * 5;
__m256 b0, b1, a0, a1;
for (int k = 0; k < K; k++)
{
b0 = _mm256_loadu_ps(B + 0);
b1 = _mm256_loadu_ps(B + 8);
a0 = _mm256_set1_ps(A[offset0]);
a1 = _mm256_set1_ps(A[offset1]);
c00 = _mm256_fmadd_ps(a0, b0, c00);
c01 = _mm256_fmadd_ps(a0, b1, c01);
c10 = _mm256_fmadd_ps(a1, b0, c10);
c11 = _mm256_fmadd_ps(a1, b1, c11);
a0 = _mm256_set1_ps(A[offset2]);
a1 = _mm256_set1_ps(A[offset3]);
c20 = _mm256_fmadd_ps(a0, b0, c20);
c21 = _mm256_fmadd_ps(a0, b1, c21);
c30 = _mm256_fmadd_ps(a1, b0, c30);
c31 = _mm256_fmadd_ps(a1, b1, c31);
a0 = _mm256_set1_ps(A[offset4]);
a1 = _mm256_set1_ps(A[offset5]);
c40 = _mm256_fmadd_ps(a0, b0, c40);
c41 = _mm256_fmadd_ps(a0, b1, c41);
c50 = _mm256_fmadd_ps(a1, b0, c50);
c51 = _mm256_fmadd_ps(a1, b1, c51);
B += ldb; A += step;
}
_mm256_storeu_ps(C + 0, _mm256_add_ps(c00, _mm256_loadu_ps(C + 0)));
_mm256_storeu_ps(C + 8, _mm256_add_ps(c01, _mm256_loadu_ps(C + 8)));
C += ldc;
_mm256_storeu_ps(C + 0, _mm256_add_ps(c10, _mm256_loadu_ps(C + 0)));
_mm256_storeu_ps(C + 8, _mm256_add_ps(c11, _mm256_loadu_ps(C + 8)));
C += ldc;
_mm256_storeu_ps(C + 0, _mm256_add_ps(c20, _mm256_loadu_ps(C + 0)));
_mm256_storeu_ps(C + 8, _mm256_add_ps(c21, _mm256_loadu_ps(C + 8)));
C += ldc;
_mm256_storeu_ps(C + 0, _mm256_add_ps(c30, _mm256_loadu_ps(C + 0)));
_mm256_storeu_ps(C + 8, _mm256_add_ps(c31, _mm256_loadu_ps(C + 8)));
C += ldc;
_mm256_storeu_ps(C + 0, _mm256_add_ps(c40, _mm256_loadu_ps(C + 0)));
_mm256_storeu_ps(C + 8, _mm256_add_ps(c41, _mm256_loadu_ps(C + 8)));
C += ldc;
_mm256_storeu_ps(C + 0, _mm256_add_ps(c50, _mm256_loadu_ps(C + 0)));
_mm256_storeu_ps(C + 8, _mm256_add_ps(c51, _mm256_loadu_ps(C + 8)));
}
```
Введем небольшую вспомогательную функцию для инициализации начального значения матрицы **С**:
```
void init_c(int M, int N, float * C, int ldc)
{
for (int i = 0; i < M; ++i, C += ldc)
for (int j = 0; j < N; j += 8)
_mm256_storeu_ps(C + j, _mm256_setzero_ps());
}
```
Здесь lda, ldb, ldc — длина строчки (Leading Dimension в общем случае) соответсвующей матрицы.
Тогда функция умножения примет следующий вид:
```
void gemm_v3(int M, int N, int K, const float * A, const float * B, float * C)
{
for (int i = 0; i < M; i += 6)
{
for (int j = 0; j < N; j += 16)
{
init_c(6, 16, C + i*N + j, N);
micro_6x16(K, A + i*K, K, 1, B + j, N, C + i*N + j, N);
}
}
}
```
Запускаем ее и получаем время исполнения 78.5 мс или 36.2 GFLOPS. Т.е. использование микроядра позволило ускорить матричное умножение почти в 3 раза. Но полученное быстродействие все еще далеко от максимального. Где теперь узкое место?
Переупорядочиваем матрицу B (4-й шаг)
-------------------------------------
Микроядро за каждую итерацию загружает два 256-bit вектора из матрицы **B**.
Причем каждый раз из новой строчки. Это делает невозможным для процессора эффективное кеширование этих данных. Для исправления этой ситуации сделаем два изменения:
1. Скопируем данные матрицы **B** во временный буфер таким образом, чтобы данные, необходимые одному микроядру лежали рядом.
2. Изменим порядок обхода матрицы **С**: сначала будем ходить по столбцам и только потом по строкам. Это позволит эффективнее использовать переупорядоченные значения матрицы **B**.
Для хранения буфера заведем небольшую структуру:
```
struct buf_t
{
float * p;
int n;
buf_t(int size) : n(size), p((float*)_mm_malloc(size * 4, 64)) {}
~buf_t() { _mm_free(p); }
};
```
Здесь стоит отметить, что загрузка и выгрузка AVX векторов оптимально работает при выровненных данных, потому используются специальные функции для выделения памяти.
Функция переупорядочивания матрицы **B**:
```
void reorder_b_16(int K, const float * B, int ldb, float * bufB)
{
for (int k = 0; k < K; ++k, B += ldb, bufB += 16)
{
_mm256_storeu_ps(bufB + 0, _mm256_loadu_ps(B + 0));
_mm256_storeu_ps(bufB + 8, _mm256_loadu_ps(B + 8));
}
}
```
Ну и собственно 4-я версия функции gemm:
```
void gemm_v4(int M, int N, int K, const float * A, const float * B, float * C)
{
for (int j = 0; j < N; j += 16)
{
buf_t bufB(16*K);
reorder_b_16(K, B + j, N, bufB.p);
for (int i = 0; i < M; i += 6)
{
init_c(6, 16, C + i*N + j, N);
micro_6x16(K, A + i*K, K, 1, bufB.p, 16, C + i*N + j, N);
}
}
}
```
Результаты тестирования (29.5 мс или 96.5 GFLOPS) показывают, что мы на правильном пути. Фактически достигнуто около 80% от теоретически возможного максимума.
Победа? К сожалению нет. Просто размер матриц, который мы использовали для тестирования (M=N=K=1152) оказался удобным для данной версии алгоритма. Если увеличить К в 100 раз (M=1152, N=1152, K=115200), то эффективность алгоритма упадет до 39.5 GFLOPS — почти в 2.5 раза.
Локализуем данные в кэше L1 (5-й шаг)
-------------------------------------
Так почему же с ростом параметра K, падает эффективность алгоритма? Ответ кроется в величине буфера, который мы использовали для хранения переупорядоченных значений **B**. При больших значениях K он просто не влазит в кэш процессора. Решением проблемы будет ограничение его величины до размера кэша данных L1. Для процессоров Интел размер кэша данных L1 составляет 32 kb. C ограничением размера буфера, микроядро будет пробегать не по всем значениям K, а только по диапазону, который влазит в L1 кэш. Результаты промежуточных расчетов матрицы **С** будут храниться в основной памяти.
Введем макроядро — вспомогательную функцию, которая производит расчеты над областью данных, которые влазят в кэш:
```
void macro_v5(int M, int N, int K, const float * A, int lda,
const float * B, int ldb, float * bufB, float * C, int ldc)
{
for (int j = 0; j < N; j += 16)
{
reorder_b_16(K, B + j, ldb, bufB);
for (int i = 0; i < M; i += 6)
micro_6x16(K, A + i*lda, lda, 1, bufB, 16, C + i*ldc + j, ldc);
}
}
```
В главной функции у нас добавится цикл по K, в котором мы будем вызывать макроядро:
```
void gemm_v5(int M, int N, int K, const float * A, const float * B, float * C)
{
const int L1 = 32 * 1024;
int mK = std::min(L1 / 4 / 16, K);
buf_t bufB(16 * mK);
for(int k = 0; k < K; k += mK)
{
int dK = std::min(K, k + mK) - k;
if(k == 0)
init_c(M, N, C, N);
macro_v5(M, N, dK, A + k, K, B + k*N, N, bufB.p, C, N);
}
}
```
Результаты замеров показывают, что мы движемся в правильном направлении: для (M=1152, N=1152, K=115200) производительность алгоритма составила 78.1 GFLOPS. Это значительно лучше, чем в прошлой версии, но все еще хуже, чем для матрицы средних размеров.
Переупорядочиваем матрицу A и локализуем в кэше L2 (6-й шаг)
------------------------------------------------------------
Ограничив размер K, который обрабатывается за один проход микроядра, мы сумели локализовать данные матрицы **B** в кэше L1. Данных, которые подгружаются из матрицы **A** почти в три раза меньше. Но давайте попробуем локализовать и их, заодно переупорядочив данные, чтобы они лежали последовательно. Напишем для этого специальную функцию:
```
void reorder_a_6(const float * A, int lda, int M, int K, float * bufA)
{
for (int i = 0; i < M; i += 6)
{
for (int k = 0; k < K; k += 4)
{
const float * pA = A + k;
__m128 a0 = _mm_loadu_ps(pA + 0 * lda);
__m128 a1 = _mm_loadu_ps(pA + 1 * lda);
__m128 a2 = _mm_loadu_ps(pA + 2 * lda);
__m128 a3 = _mm_loadu_ps(pA + 3 * lda);
__m128 a4 = _mm_loadu_ps(pA + 4 * lda);
__m128 a5 = _mm_loadu_ps(pA + 5 * lda);
__m128 a00 = _mm_unpacklo_ps(a0, a2);
__m128 a01 = _mm_unpacklo_ps(a1, a3);
__m128 a10 = _mm_unpackhi_ps(a0, a2);
__m128 a11 = _mm_unpackhi_ps(a1, a3);
__m128 a20 = _mm_unpacklo_ps(a4, a5);
__m128 a21 = _mm_unpackhi_ps(a4, a5);
_mm_storeu_ps(bufA + 0, _mm_unpacklo_ps(a00, a01));
_mm_storel_pi((__m64*)(bufA + 4), a20);
_mm_storeu_ps(bufA + 6, _mm_unpackhi_ps(a00, a01));
_mm_storeh_pi((__m64*)(bufA + 10), a20);
_mm_storeu_ps(bufA + 12, _mm_unpacklo_ps(a10, a11));
_mm_storel_pi((__m64*)(bufA + 16), a21);
_mm_storeu_ps(bufA + 18, _mm_unpackhi_ps(a10, a11));
_mm_storeh_pi((__m64*)(bufA + 22), a21);
bufA += 24;
}
A += 6 * lda;
}
}
```
Так как, данные матрицы **A** теперь идут последовательно, то параметр **lda** в макроядре нам больше не нужен. Также поменялись параметры вызова микроядра:
```
void macro_v6(int M, int N, int K, const float * A,
const float * B, int ldb, float * bufB, float * C, int ldc)
{
for (int j = 0; j < N; j += 16)
{
reorder_b_16(K, B + j, ldb, bufB);
for (int i = 0; i < M; i += 6)
micro_6x16(K, A + i*K, 1, 6, bufB, 16, C + i*ldc + j, ldc);
}
}
```
Размер буфера для переупорядоченной матрицы **A** ограничиваем размером L2 кэша процессора (он обычно составляет от 256 до 1024 kb для разных типов процессоров). В главной функции добавляется дополнительный цикл по переменной M:
```
void gemm_v6(int M, int N, int K, const float * A, const float * B, float * C)
{
const int L1 = 32 * 1024, L2 = 256*1024;
int mK = std::min(L1 / 4 / 16, K) / 4 * 4;
int mM = std::min(L2 / 4 / mK, M) / 6 * 6;
buf_t bufB(16 * mK);
buf_t bufA(mK * mM);
for(int k = 0; k < K; k += mK)
{
int dK = std::min(K, k + mK) - k;
for (int i = 0; i < M; i += mM)
{
int dM = std::min(M, i + mM) - i;
if (k == 0)
init_c(dM, N, C + i * N, N);
reorder_a_6(A + i * K + k, K, dM, dK, bufA.p);
macro_v6(dM, N, dK, bufA.p, B + k * N, N, bufB.p, C + i * N, N);
}
}
}
```
Результаты тестовых замеров для (M=1152, N=1152, K=115200) — 88.9 GFLOPS — приблизились еще на один шаг к результату для матриц среднего размера.
Задействуем кэш L3 (7-й шаг)
----------------------------
В процессорах помимо кэша L1 и L2 еще часто бывает кэш L3 (обычно его размер составляет 1-2 MB на ядро). Попробуем задействовать и его, например, для хранения переупорядоченных значений матриц **B**, чтобы избежать лишних вызовов функции reorder\_b\_16. В функции макроядра появится дополнительные параметр reorderB, который будет сообщать о том, что данныe матрицы **B** уже упорядочены:
```
void macro_v7(int M, int N, int K, const float * A,
const float * B, int ldb, float * bufB, bool reorderB, float * C, int ldc)
{
for (int j = 0; j < N; j += 16)
{
if(reorderB)
reorder_b_16(K, B + j, ldb, bufB + K*j);
for (int i = 0; i < M; i += 6)
micro_6x16(K, A + i*K, 1, 6, bufB + K*j, 16, C + i*ldc + j, ldc);
}
}
```
В основной функции добавится цикл по N:
```
void gemm_v7(int M, int N, int K, const float * A, const float * B, float * C)
{
const int L1 = 32 * 1024, L2 = 256*1024, L3 = 2*1024*1024;
int mK = std::min(L1 / 4 / 16, K) / 4 * 4;
int mM = std::min(L2 / 4 / mK, M) / 6 * 6;
int mN = std::min(L3 / 4 / mK, N) / 16 * 16;
buf_t bufB(mN * mK);
buf_t bufA(mK * mM);
for (int j = 0; j < N; j += mN)
{
int dN = std::min(N, j + mN) - j;
for (int k = 0; k < K; k += mK)
{
int dK = std::min(K, k + mK) - k;
for (int i = 0; i < M; i += mM)
{
int dM = std::min(M, i + mM) - i;
if (k == 0)
init_c(dM, dN, C + i * N + j, N);
reorder_a_6(A + i * K + k, K, dM, dK, bufA.p);
macro_v7(dM, dN, dK, bufA.p, B + k * N + j, N,
bufB.p, i == 0, C + i * N + j, N);
}
}
}
}
```
Результаты замеров для (M=1152, N=1152, K=115200) дают результат в 97.3 GFLOPS. Т.е. мы даже немного превысили результат для матриц среднего размера. Фактически мы получили универсальный алгоритм (на самом деле нет, про ограничения в следующем разделе), который практически одинаково эффективно (порядка 80% от теоретически достижимого макимума) работает для любого размера матриц. На этом предлагаю остановиться и описать, что у нас в итоге получилось.
Общая схема алгоритма
---------------------
На рисунке ниже приведена схема получившегося алгоритма:
#### Микро ядро
* **Цикл-1** по переменной k. Переупорядоченные данные из матрицы **B** лежат в кэше L1, переупорядоченные данные из матрицы **A** лежат в кэше L2. Сумма аккумулируется в регистрах (кэше L0). Результат записывается в основную память. Размеры микроядра определяются длиной SIMD вектора и количеством векторных регистров. Длина цикла определяется размером кэша L1, где хранится **B**.
#### Макро ядро
* **Цикл-2** по переменной i. Пробегает микроядром по переупорядоченным данным матрицы **A**, которые лежат в кэше L2.
* **Цикл-3** по переменной j. Пробегает микроядром по переупорядоченным данным матрицы **B**, которые лежат в кэше L3. Опционально переупорядочивает недостающие данные в **B**.
Размеры макроядра определяются величиной кэша.
#### Основная функция
* **Цикл-4** по переменной i. Пробегает макроядром по матрице **A**. На каждой итерации переупорядочивает значения **A**. Опционально инициализирует значения матрицы **С**.
* **Цикл-5** по переменной k. Пробегает макроядром по матрицам **A** и **B**.
* **Цикл-6** по переменной j. Пробегает макроядром по матрице **B**.
Что осталось за кадром?
-----------------------
В процессе изложения основных принципов, которые используются в алгоритме матричного умножения, я сознательно упростил задачу, иначе она бы не влезла ни в одну статью. Ниже я опишу некоторые вопросы, которые неважны для понимания основной сути алгоритма, но очень важны для практической их реализации:
1. В реальности, к сожалению, размер матриц не всегда кратен размерам микроядра, потому края матриц приходится обрабатывать особым образом. Для чего приходится реализовывать микроядра разных размеров.
2. Для разных типов процессоров реализуются разные наборы микроядер и функций переупорядочивания. Также свои микроядра будет для чисел с двойной точностью и для комплексных чисел. К счастью, зоопарк микроядер ограничен только ими и на верхнем уровне код достаточно универсальный.
3. Микроядра часто пишут прямо на ассемблере. Также проводят дополнительное разворачивание циклов. Но это не приводит к существенному ускорению — основные оптимизации заключаются в эффективном использовании кэшевой иерархии памяти процессора.
4. Для матриц малого размера (по любому измерению) применяют особые алгоритмы — иногда переупорядочивание не эффективно, иногда нужно применять другой порядок обхода матриц. А иногда и реализовывать особые микроядра.
5. В обобщенном алгоритме матричного умножения все три матрицы могут быть транспонированы. Казалось бы число возможных алгоритмов возрастает в 8 раз! К счастью применение переупорядочивания входных данных, позволяет для всех случаев обойтись унивесальными микроядрами.
6. Практически все современные процессоры — многоядерны. И библиотеки матричного умножения используют многопоточность для ускорения вычислений. Обычно для этого используется еще 1-3 дополнительных цикла, в которых происходит разбиение задач по разным потокам.
Заключение
----------
Приведенный алгоритм матричного умножения позволяет эффективно задействовать ресурсы современных процессоров. Но он наглядно показывает, что максимальная утилизация ресурсов современных процессоров — это далеко нетривиальная задача. Подход с использованием микроядер и максимальной локализации данных в кэше процессора можно с успехом использовать и для других алгоритмов.
Код проекта с алгоритмами из статьи можно найти на [Github](https://github.com/ermig1979/Examples/tree/master/mmosbs_cpu_st).
Надеюсь вам было интересно! | https://habr.com/ru/post/359272/ | null | ru | null |
# Кроссплатформенная новогодняя демка на .NET Core и Avalonia
"[ААА! Пришло время переписывать на .NET Coreǃ](https://habrahabr.ru/company/jugru/blog/345136/)", говорили они, WPF в комментариях обсуждали. Так давайте же проверим, можно ли написать кросс-платформенное GUI приложение на .NET / C#.
Новогоднее настроение навеяло идею сделать анимацию падающего снега. Были такие демки под DOS, горящий огонь, фракталы, снежок, падающий на ёлочку, и так далее.
Как увидим ниже, это не только весело, но и позволит испытать ключевой функционал UI фреймворка. Поехали!
Создание проекта и UI
=====================
Для Avalonia есть [Visual Studio Extension](https://marketplace.visualstudio.com/items?itemName=AvaloniaTeam.AvaloniaforVisualStudio) с шаблоном проекта. Устанавливаем, создаём `Avalonia .NET Core Application`. Видим привычные по WPF `App.xaml` и `MainWindow.xaml`. Однако, проект содержит `netcoreapp1.1;net461`, меняем на `netcoreapp2.0`, мы же не в каменном веке.
Расширение Avalonia для студии содержит XAML Designer, но у меня он не заработал. Решарпер немного сходит с ума в редакторе разметки, хочет везде вставить явные неймспейсы, так что и без него тоже обойдёмся.
В остальном у нас в руках привычный XAML с привычными контролами и пропертями. Обо всех отличиях можно почитать в [документации](http://avaloniaui.net/tutorial/from-wpf.html).
Для произвольного рисования существует одноимённый аналог `WriteableBitmap` из WPF. Огромный плюс в том, что нет проблем рисовать в нём из любого потока, выглядит это так:
```
using (ILockedFramebuffer buf = writeableBitmap.Lock())
{
uint* ptr = (uint*) buf.Address;
// Рисуем
*ptr = uint.MaxValue;
}
```
Однако `Image`, который привязан к нашему writeableBitmap, не обновится сам по себе, ему необходимо сказать `InvalidateVisual()`.
Таким образом, мы можем рисовать анимацию в фоновом потоке, не нагружая UI thread. Помимо `Image` добавим пару слайдеров для управления скоростью падения снега и количеством снежинок, здесь всё стандартно, `{Binding Mode=TwoWay}`. Плюс кнопка "начать заново", тоже стандартная привязка к `ICommand`. Замечу, что использованы векторные иконки на XAML, скопипащенные из гугла, фунциклирует как положено.
Разметка целиком: [MainWindow.xaml](https://github.com/ptupitsyn/let-it-snow/blob/master/AvaloniaCoreSnow/MainWindow.xaml)
Снежный алгоритм
================
### "Физика"
Двигаем снежинку вниз на один пиксель. Если пиксель уже занят "лежащей" снежинкой, проверяем точки слева и справа, и двигаем туда, где свободно. Всё занято — помечаем точку как "лежащую". Таким образом достигается скатывание снежинок с наклонных поверхностей.
### Параллакс
Для достижения объёмного эффекта зададим каждой снежинке рандомную скорость. Чем скорость ниже, тем более тёмный оттенок используем для рисования.
Чтобы наша "физика" работала корректно, необходимо перемещать снежинки не более, чем на 1 пиксель за кадр. То есть самые быстрые снежинки двигаются каждый кадр на пиксель, остальные — пропускают некоторые кадры. Для этого можно применить `float` координаты и просто перерисовывать каждую снежинку на каждый кадр. Вместо этого я использую два целочисленных `short` поля и перерисовываю снежинку только [если она реально сдвинулась](https://github.com/ptupitsyn/let-it-snow/blob/master/AvaloniaCoreSnow/SnowViewModel.cs#L259).
### Рендеринг
Основная идея — избежать полной перерисовки кадра. Нам надо как-то хранить "лежащий" снег, нарисованные пользователем точки, загруженные изображения (да, можно рисовать мышью и грузить пикчи правым кликом — снежок будет прилипать к ёлочкам и надписям).
Простое и эффективное решение — использовать сам `WriteableBitmap`. "Перманентные" пиксели пусть будут полностью непрозрачными (A = 255), а для движущихся снежинок A = 254.
Падающих снежинок всегда фиксированное количество, позицию и скорость каждой храним в массиве. В итоге, если снежинка сдвинулась — стираем точку на старой позиции и рисуем на новой. Если превратилась в "лежачую" — выставляем альфа-канал точки в 255, перемещаем живую снижинку обратно наверх.
Как это запустить?
==================
Благодаря возможности рисования прямо "по живому" получилась доволно залипательная штука, попробуйте :)
Для всех ОС инструкция одинаковая:
* Установить [.NET Core SDK](https://www.microsoft.com/net/download)
* `git clone https://github.com/ptupitsyn/let-it-snow.git`
* `cd let-it-snow/AvaloniaCoreSnow`
* `dotnet run`
Заключение
==========
.NET Core молод, Avalonia ещё в альфе, но уже сейчас эти инструменты решают поставленную задачу! Код простой и понятный, никаких хаков и лишних приседаний, прекрасно работает на Windows, macOS, Linux.
Альтернативы?
* Qt (посложнее будет в использовании)
* Java (нет нормального unsafe)
* Electron (JavaScript + HTML — нет уж, спасибо)
UI в данной демке очень прост, но он использует несколько наиболее важных фич:
* Layout (Grid, StackPanel, выравнивание) — основа вёрстки
* Binding (привязка контролов к свойствам модели)
* ItemsControl, ItemsPanel, DataTemplate — работа с коллекциями данных
* WriteableBitmap — прямая работа с изображениями
* OpenFileDialog, нативный на каждой платформе
Этого уже достаточно, чтобы построить UI любой сложности. Так что можем сказать, что закрыт последний пробел в экосистеме .NET: есть возможность создавать веб (ASP.NET Core), мобильные (Xamarin) и десктопные (Avalonia) приложения, при этом переиспользовать код, располагая его в библиотеках .NET Standard.
### Ссылки
* [Код на гитхабе](https://github.com/ptupitsyn/let-it-snow)
* [.NET Core](https://www.microsoft.com/net)
* [Avalonia UI](https://github.com/AvaloniaUI/Avalonia) | https://habr.com/ru/post/345708/ | null | ru | null |
# Опыт перехода с Sublime на Vim
Данная статья не раскрывает всех премудростей перемещения по тексту или его редактирования. Основные движения можно узнать в vimtutor, остальные комбинации изучаются в процессе работы. Некоторые из них, особо важные в процессе программирования, я освещу позже.
Я достаточно долгое время использовал sublime (около 4 лет) в качестве основной среды разработки, но в последнее время кое-что изменилось: я освоил слепой 9-ти пальцевый метод печати. В тот момент я начал понимать людей, которым неудобно тянуться к мышке или стрелочкам. Убирать пальцы с «домашних» позиций стало неестественно и непродуктивно. Тогда я включил vintage. Проблема, вроде бы, стала неактуальна, но чего-то не хватало. Не помню, что заставило меня пересесть за vim, но мне всегда нравилось, как в нем выделяются фигурные скобки (MatchParen) и как выглядит курсор :). Vim я пробовал и до этого, когда правил конфиги на сервере, правда, вся «магия» ограничивалась переходом в режим вставки и успешным сохранением/выходом из редактора.
Первое, что необходимо понять — vim из коробки годится разве что для правки конфигов, для комфортной работы с кодом необходимо установить несколько плагинов. Мне хватило 33. Я не ставил перед собой цель полностью копировать поведение sublime, скорее сделать работу в vim'е такой же простой и интуитивно понятной. Данное руководство описывает все установленные плагины, а также настройки, которые, по моему мнению, делают работу с плагинами и самим vim'ом более удобной. Нужные плагины вы можете найти на [официальном сайте](http://www.vim.org/scripts/script_search_results.php), хотя мне больше нравится [vimawesome](http://vimawesome.com/). В качестве окружения выступает Ubuntu 16.04 и консольный vim 7.4.
Все плагины находятся на github, где вы можете посмотреть краткое руководство по установке или использованию того или иного плагина, за подробным описанием стоит идти в help. Если из описания плагина не ясно, как его использовать, то, наверняка, нужная комбинация биндится в разделе горячих клавиш. Все настройки прописываем в ~/.vimrc или ~/.vim/vimrc, если файл не существует — создаем. Пожалуй, начнем.
**vundle**Нет ничего приятного в том, чтобы ставить плагины вручную. [Vundle](https://github.com/VundleVim/Vundle.vim) выступает в роли пакетного менеджера, среди которых есть также [pathogen](https://github.com/tpope/vim-pathogen), [vim-plug](https://github.com/junegunn/vim-plug) и другие. Не могу сказать, что удобнее, так как пользовался только Vundle. Выбирайте на свое усмотрение.
**Установленные плагины**
```
// set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
// let Vundle manage Vundle, required
Plugin 'VundleVim/Vundle.vim'
// common
Plugin 'scrooloose/nerdtree'
Plugin 'valloric/youcompleteme'
Plugin 'xolox/vim-easytags'
Plugin 'majutsushi/tagbar'
Plugin 'tpope/vim-fugitive'
Plugin 'easymotion/vim-easymotion'
Plugin 'ctrlpvim/ctrlp.vim'
Plugin 'terryma/vim-multiple-cursors'
Plugin 'vim-airline/vim-airline'
Plugin 'vim-airline/vim-airline-themes'
Plugin 'scrooloose/nerdcommenter'
Plugin 'matze/vim-move'
Plugin 'raimondi/delimitmate'
Plugin 'mattn/emmet-vim'
Plugin 'scrooloose/syntastic'
Plugin 'tpope/vim-surround'
Plugin 'sirver/ultisnips'
Plugin 'honza/vim-snippets'
Plugin 'xolox/vim-session'
Plugin 'xolox/vim-misc'
Plugin 'SyntaxAttr.vim'
Plugin 'dyng/ctrlsf.vim'
Plugin 'rking/ag.vim'
Plugin 'godlygeek/tabular'
// php
Plugin 'stanangeloff/php.vim'
Plugin 'sumpygump/php-documentor-vim'
Plugin 'arnaud-lb/vim-php-namespace'
// javascript
Plugin 'pangloss/vim-javascript'
// html
Plugin 'othree/html5.vim'
// twig
Plugin 'evidens/vim-twig'
// css
Plugin 'mtscout6/vim-tagbar-css'
// colors
Plugin 'damage220/solas.vim'
Plugin 'nanotech/jellybeans.vim'
Plugin 'mhartington/oceanic-next'
call vundle#end()
```
**Команды**
```
// просмотр всех установленных плагинов
:PluginList
// устанавливаем плагины
:PluginInstall
// удаляем ненужные плагины
:PluginClean
// поиск необходимого плагина
:PluginSearch foo
```
**Установка**
```
git clone https://github.com/VundleVim/Vundle.vim.git ~/.vim/bundle/Vundle.vim
```
**Зависимости**
```
git и curl
```
**solas** Из всех цветовых тем, что я пробовал, больше всего понравилась [jellybeans](https://github.com/nanotech/jellybeans.vim), но через некоторое время решил создать [свою тему](https://github.com/damage220/solas.vim). К счастью, узнать названия всех групп не составило труда, к несчастью, терминалы очень ограничены в цветовой палитре и поддерживают, как правило, 256 цветов. Solas основана на стандартной теме в PhpStorm.
**move** [Плагин](https://github.com/matze/vim-move) предназначен для перемещения текущей строки или выделенных строк вверх или вниз.
**Пользовательские настройки**
```
// биндим команды перемещения на и
let g:move\_key\_modifier = 'C'
```
**nerdtree**[Самый популярный плагин](https://github.com/scrooloose/nerdtree), предназначен для работы с файловой системой. Добавляет удобные горячие клавиши для создания, перемещения и удаления файлов и директорий.
**Пользовательские настройки**
```
// автоматически обновлять буфер после переименовывания файла
let NERDTreeAutoDeleteBuffer = 1
```
**php-documentor** [Плагин](https://github.com/sumpygump/php-documentor-vim) создает doc-блоки для классов, свойств класса, функций.
**php** [Плагин](https://github.com/stanangeloff/php.vim) предоставляет улучшенную поддержку синтаксиса. Обновлен список констант, классов и функций до версии 5.6.
**html5** [Плагин](https://github.com/othree/html5.vim) предоставляет улучшенную поддержку синтаксиса и отступов.
**javascript** [Плагин](https://github.com/pangloss/vim-javascript) предоставляет улучшенную поддержку синтаксиса и отступов.
**twig** [Плагин](https://github.com/evidens/vim-twig) добавляет поддержку шаблонов twig.
**fugitive** Удобная [обертка](https://github.com/tpope/vim-fugitive) над git, предоставляет множество команд.
**ultisnips** [Плагин](https://github.com/sirver/ultisnips) добавляет поддержку сниппетов в vim.
**Полезные комбинации**
```
- вставить сниппет
```
**snippets** [Набор сниппетов](https://github.com/honza/vim-snippets) для большинства языков программирования.
**Зависимости**
```
snipmate или ultisnips
```
**SyntaxAttr** [Плагин](https://github.com/vim-scripts/SyntaxAttr.vim) показывает группу синтаксиса, ссылки (hi link) и цвет группы. Удобный плагин для создания собственных цветовых схем.
**ctrlp** За 3 года я так сильно привык к нечеткому поиску, что с трудом представляю разработку без этой возможности. Насколько я помню, это был первый плагин, который я установил. [Ctrlp](https://github.com/ctrlpvim/ctrlp.vim) производит поиск по тегам, файлам, буферам и последним активным файлам.
**Команды**
```
// поиск тега в текущем файле (аналог Ctrl + R в sublime)
:CtrlPBufTag
```
**Полезные комбинации**
```
и - для перемещения курсора вниз и вверх соответственно
- открыть в текущем окне
- открыть в новой вкладке
- открыть файл слева/справа (зависит от настройки)
- открыть файл сверху/снизу (зависит от настройки)
- переключение режима поиска по имени файла или полному пути
```
**Пользовательские настройки**
```
// По умолчанию, CtrlP ищет файлы по их полному пути, что мне показалось странным, поскольку на запрос "repo", имея следующую структуру файлов:
// project/src/Repository/Repository.php
// project/src/Repository/Foo.php
// CtrlP может придать больший вес файлу Foo.php. К счастью, CtrlP, как и многие другие плагины для vim'a, имеет гибкую настройку. Для решения проблемы нужно прописать
let g:ctrlp_by_filename = 1
// откуда начинать поиск. w - ближайшая директория, которая содержит признаки наличия CVS (.git, .svn). r - текущая директория (pwd).
let g:ctrlp_working_path_mode = 'wr'
// по умолчанию, как не сложно догадаться, поиск активируется по нажатию , но т.к. у меня стоит другая комбинация (далее по тексту), я решил сбросить стандартное поведение.
let g:ctrlp\_map = ''
// убираем переменные из списка тегов
let g:ctrlp\_buftag\_types = {
\'php': '--php-kinds=icdf'
\}
```
**Зависимости**
```
Для поиска по тегам нужен ctags
```
**tagbar** Мне нравится миникарта в sublime, взглянув на неё можно сразу понять структуру файла. Естественно, я хотел такую же и в vim, и, надо же, плагин так и называется — [vim-minimap](https://github.com/severin-lemaignan/vim-minimap). К сожалению, плагин мне [совершенно не понравился](https://raw.githubusercontent.com/severin-lemaignan/vim-minimap/master/minimap.png). Нужна была альтернатива, и она нашлась — [tagbar](https://github.com/majutsushi/tagbar). Плагин показывает список тегов в текущем файле, группируя их и сортируя в нужном порядке.
**Пользовательские настройки**
```
// сортировать в том порядке, в котором тег появляется в коде, а не по имени
let g:tagbar_sort = 0
// замена стандартных стрелочек раскрытия/сворачивания группы тегов
let g:tagbar_iconchars = ['+', '-']
// обеспечиваем переключатель
let g:tagbar_map_close = ''
// Убираем переменные из списка
let g:tagbar\_type\_php = {
\'ctagstype': 'php',
\'kinds': [
\'i:interfaces',
\'c:classes',
\'d:constants',
\'f:functions'
\]
\}
```
**Зависимости**
```
ctags
```
**tagbar-css** [Плагин](https://github.com/mtscout6/vim-tagbar-css) добавляет поддержку css, less и scss для tagbar. Помимо установки самого плагина, пропишите следующие строки в ваш ~/.ctags
```
--langdef=css
--langmap=css:.css.less.scss
--regex-css=/^[ \t]*@([A-Za-z0-9_-]+)/@\1/v,var,variables/
--regex-css=/^[ \t]*\.([A-Za-z0-9_-]+)/.\1/c,class,classes/
--regex-css=/^[ \t]*#([A-Za-z0-9_-]+)/#\1/i,id,ids/
--regex-css=/^[ \t]*(([A-Za-z0-9_-]+[ \t\n,]+)+)\{/\1/t,tag,tags/
--regex-css=/^[ \t]*@media\s+([A-Za-z0-9_-]+)/\1/m,media,medias/
```
**Зависимости**
```
tagbar
```
**easymotion** [Один из лучших плагинов](https://github.com/easymotion/vim-easymotion), на мой взгляд. Позволяет моментально перемещаться по коду, введя всего несколько символов.
**Пользовательские настройки**
```
// отключаем зависимость от регистра
let g:EasyMotion_smartcase = 1
// отключаем тень (в момент выбора цели весь текст помечается как комментарий)
let g:EasyMotion_do_shade = 0
// какой группой подсвечивать цели
hi link EasyMotionTarget Search
```
**Примечание**
```
Поскольку easymotion работает с буфером напрямую, постоянно изменяя его, местами может появляться неприятный баг, когда вы попытаетесь отменить все изменения. Vim сообщит, что вы восстановили первоначальное состояние, но при попытке выйти из редактора, появится предупреждение о несохраненном буфере.
```
**session** [Плагин](https://github.com/xolox/vim-session) делает работу с сессиями более удобной, предоставляя обертку над стандартной командой :mksession.
**Команды**
```
// открыть сессию. Если вы закрыли терминал или случайно нажали , необходимо добавить "!" в конце команды, например, "OpenSession! name"
:OpenSession name
// сохранить сессию
:SaveSession name
```
**Пользовательские настройки**
```
// открывать сессию при старте. Опция игнорируется, если мы передаем vim некие файлы
let g:session_autoload = 'yes'
// включить автосохранение
let g:session_autosave = 'yes'
// сохранять состояние каждые 5 минут
let g:session_autosave_periodic = 5
// не сообщать ничего при автосохранении
let g:session_autosave_silent = 1
// открывать последнюю рабочую сессию вместо стандартной
let g:session_default_to_last = 1
```
**Зависимости**
```
misc
```
**misc** [Плагин](https://github.com/xolox/vim-misc), необходимый для работы session.**emmet** Об [emmet'e](https://github.com/mattn/emmet-vim) было сказано слишком много, чтобы писать о нем тут.
**Пользовательские настройки**
```
// разворачивать аббревиатуру по нажатию на
let g:user\_emmet\_expandabbr\_key = ''
```
**delimitmate** [Плагин](https://github.com/raimondi/delimitmate) ставит отступы между любыми скобками или кавычками.
**Пользовательские настройки**
```
// включить отступы по нажатию на enter
let delimitMate_expand_cr = 1
// включить отступы по нажатию на пробел. " |" превращается в " | "
let delimitMate_expand_space = 1
// для html, необходимо дописать >:<, чтобы выставлялись правильные отступы
au FileType vim,html let b:delimitMate_matchpairs = "(:),[:],{:},<:>,>:<"
```
**syntastic** [Плагин](https://github.com/scrooloose/syntastic) для проверки синтаксиса. В readme советуют ставить следующие настройки, не спорим.
**Пользовательские настройки**
```
let g:syntastic_always_populate_loc_list = 1
let g:syntastic_auto_loc_list = 1
let g:syntastic_check_on_open = 1
let g:syntastic_check_on_wq = 0
```
**NERDCommenter** От [плагина для комментирования кода](https://github.com/scrooloose/nerdcommenter) я хотел добиться следующего поведения: для комментирования участка кода используем , для комментирования строки, раскомментирования строки/фрагмента кода служит . Насколько я помню, из всех установленных мною плагинов (около 4-х), ни один в точности не справился с этой задачей. Чтобы раскомментировать фрагмент кода приходится использовать стандартную комбинацию — \cu, где \ — ",". Это не стандартная клавиша, по умолчанию используется "\". В остальном такое же поведение, как и в sublime.
**Пользовательские настройки**
```
// количество пробелов после символа(ов) комментария
let g:NERDSpaceDelims = 1
```
**airline** [Плагин](https://github.com/vim-airline/vim-airline) отображает удобную строку статуса, которую легко кастомизировать под свои нужды. Также можно позволить плагину управлять внешним видом вкладок. Для корректной работы нужны пропатченные шрифты, которые вы можете взять [отсюда](https://github.com/powerline/fonts).
**Пользовательские настройки**
```
// solarized не входит в стандартную поставку, необходимо загрузить набор тем
let g:airline_theme='solarized'
// использовать пропатченные шрифты
let g:airline_powerline_fonts = 1
// включить управление табами
let g:airline#extensions#tabline#enabled = 1
// всегда показывать tabline
let g:airline#extensions#tabline#tab_min_count = 0
// такое же поведение, как и в sublime: если файл с уникальным именем - показывается только имя, если встречается файл с таким же именем, отображается также и директория
let g:airline#extensions#tabline#formatter = 'unique_tail'
// скрыть буферы
let g:airline#extensions#tabline#show_buffers = 0
// имя файла + расширение :help filename-modifiers
let g:airline#extensions#tabline#fnamemod = ':t'
// убираем раздражающие ненужные красные панели с предупреждениями или ошибками. Предупреждения, как по мне, не нужны, поскольку ругаются даже на trailing-spaces и разные отступы: например табы и пробелы (привет от phpDoc). Для ошибок и так открывается дополнительное окно. Впрочем, вам решать.
let g:airline_section_warning = ''
let g:airline_section_error = ''
// убираем "X" для закрытия вкладки мышью (мышью!?)
let g:airline#extensions#tabline#show_close_button = 0
// убираем разделитель для вкладок
let g:airline#extensions#tabline#left_alt_sep = ''
// отключаем tagbar
let g:airline#extensions#tagbar#enabled = 0
// показывать номер вкладки
let g:airline#extensions#tabline#show_tab_nr = 1
// показывать только номер вкладки
let g:airline#extensions#tabline#tab_nr_type = 1
```
**airline-themes** [Набор тем](https://github.com/vim-airline/vim-airline-themes) для airline.
**Зависимости**
```
airline
```
**youcompleteme** [YCM](https://github.com/valloric/youcompleteme) предоставляет быстрое автодополнение кода с нечетким поиском. Самый «тяжелый» плагин из всех и самый неприятный в установке. Весит 275.9 mb и заметно замедляет запуск редактора. Для сравнения, все остальные плагины вместе взятые занимают 15.1 mb. Для работы плагина нужен vim, скомпилированный с поддержкой python. Для проверки выполните команду vim --version | grep "+python" в вашем терминале. Я не люблю компилировать из исходников и, к счастью, в моём репозитории есть пакет «vim-nox» с поддержкой скриптовых языков.
**Пользовательские настройки**
```
// ycm сам определяет подходящую версию интерпретатора, но, почему-то, с 3 версией дополнения не показываются - ставим вторую.
let g:ycm_server_python_interpreter='python'
// закрыть превью после ввода, например, при нажатии на закрывающую скобку ")"
let g:ycm_autoclose_preview_window_after_completion = 1
// позволяем ultisnips использовать tab для раскрытия сниппетов
let g:ycm_key_list_select_completion = ['']
```
**Установка**
```
Помимо установки самого плагина, необходимо запустить "install.py" с необходимыми флагами, подробнее в help.
```
**multiple-cursors** Название говорит само за себя — [плагин](https://github.com/terryma/vim-multiple-cursors) позволяет работать с несколькими курсорами одновременно.
**Команды**
```
// выделить все вхождения
:MultipleCursorsFind pattern
```
**Полезные комбинации**
```
- выделение следующего слова под курсором
- выделение предыдущего слова под курсором
- пропустить текущее слово и перейти к следующему
// После того, как вы выделили все слова, можно приступить к редактированию:
c - удалить и перейти в режим редактирования
I - вставить в начало
A - вставить в конец
```
**ctrlsf** Долгое время меня пугала мысль, как я буду реализовывать замену строки по всему проекту, да еще с предпросмотром и… подтверждением. И зря — для vim'a нашелся (причем почти сразу) замечательный [плагин](https://github.com/dyng/ctrlsf.vim), который предоставляет необходимый функционал. Достаточно набрать команду :CtrlSF pattern [filemask] и откроется окно со всеми вхождениями. Редактируем как обычный файл, сохраняем (:w). После чего, плагин запросит подтверждение и укажет сколько файлов подвергнутся изменениям. Будьте осторожны, если нажать на \, то данные всё равно закоммитятся. Впрочем, всегда можно отменить изменения (u) и сохранить буфер заново. Хорошо сочетается с множественными курсорами, особенно с командой :MultipleCursorsFind. CtrlSF — это абстракция над ack/ag, так что один из этих плагинов придется установить. Про установку ag читать ниже.
**Команды**
```
:CtrlSF foo *.php
```
**Полезные комбинации**
```
и <С-k> - перейти к следующему и предыдущему вхождению
```
**Пользовательские настройки**
```
// перемещаем окно вправо
let g:ctrlsf_position = 'right'
```
**Зависимости**
```
ack или ag
```
**ag** [Обертка](https://github.com/rking/ag.vim) над системным ag. По заявлению автора, за счет распараллеливания, ag работает в 34 раза быстрее ack, [подробнее](https://github.com/ggreer/the_silver_searcher). Для работы плагина нужно установить сам ag. В ubuntu пакет называется silversearcher-ag.
**php-namespace** [Плагин](https://github.com/arnaud-lb/vim-php-namespace) для более удобной работы с оператором «use». Подключает необходимый класс, используя тег-файл.
**Зависимости**
```
ctags, сгенерированный тег-файл.
```
**surround** [Плагин](https://github.com/tpope/vim-surround) позволяет добавлять, заменять или удалять окружающие текст кавычки, скобочки или xml-теги. ys, cs, ds — служат для вставки, замены и удаления обрамляющих символов соответственно.
**Полезные комбинации**
```
ds' - удалить одинарные кавычки
dst - удалить обрамляющий тег
cs'" - заменить одинарные кавычки на двойные
ysiw" - поместить слово в двойные кавычки
ysiw- поместить текст в тег
```
**tabular** [Плагин](https://github.com/godlygeek/tabular) выравнивает текст по определенному шаблону, например "=" или "|". Я не любитель «бьюти» кода, но недавно, когда я делал шпаргалку по временам в английском языке, плагин оказался весьма полезным.
**Команды**
```
// выравнивает текст по символу "|"
:Tabularize /|
```
**ctags** Для работы таких плагинов, как CtrlP, TagBar и php-namespace вам понадобится [ctags](https://ru.wikipedia.org/wiki/Ctags) — мощная утилита для анализа исходного кода программ. Ctags создает тег-файл, в котором содержатся названия классов, функций, переменных, ..., а также их позиции. Ctags 5.9 поддерживает 43 языка из коробки, но может быть расширен при помощи регулярных выражений (смотреть tagbar-css).
**Полезные ключи**
```
// список поддерживаемых языков
--list-languages
// список тегов для конкретного языка
--list-kinds=lang
```
**Установка**
```
Ищите в своих репозиториях пакет со схожим именем. Например, в ubuntu - это exuberant-ctags
```
**Примечание**
```
Для крупных проектов имеет смысл создать какой-нибудь "tags.vendor" и добавить этот файл в переменную "tags"
```
**easytags** Тег-файл предоставляет много информации, но создавать его вручную — дело не из приятных. [Easytags](https://github.com/xolox/vim-easytags) избавит вас от рутины, достаточно один раз прописать :UpdateTags -R в новом проекте, а все последующие изменения плагин проиндексирует сам.
**Пользовательские настройки**
```
// записываем теги локально для каждого проекта, вместо ~/.vimtags
let g:easytags_file = './tags'
// отключаем подсветку тегов
let g:easytags_auto_highlight = 0
// события (:help autocmd-events), которые слушает easytags
let g:easytags_events = ['BufWritePost']
// не блокировать vim во время обновления тег-файла
let g:easytags_async = 1
```
**Зависимости**
```
ctags
```
Довольно сложно описать каждый плагин подробно, да и незачем, наверное. Нет никакого смысла перечислять все команды, я лишь описал те, которые сам использовал, но и без того статья получилась весьма объемной. Теперь давайте рассмотрим возможности самого редактора.
**Настройки** За подробностями идем в **:help setting**
```
// Для работы с табами, вместо пробелов, присвойте tabstop и shiftwidth одинаковые значения
set tabstop=4
set shiftwidth=4
set softtabstop=4
// автоматически обновлять файл при его изменении
set autoread
// настраиваем отступы
set autoindent
set smartindent
// показывать относительные номера строк. Удобно тем, что можно легко переходить к нужной строке командой 10j, например
set rnu
// всегда показывать строку статуса
set laststatus=2
// Время, которое vim ждет для ввода следующего символа комбинации клавиш.
// Например, если в vim'e существует комбинация "df", то после ввода символа "d" у вас есть пол секунды,
// чтобы ввести "f", иначе в буфер вставиться символ "d".
set timeoutlen=500
// эту команду я плохо понимаю. В документации написано, что это время ожидания для ввода последовательностей клавиш,
// в таком случае, я не знаю в чем отличие от предыдущей команды. Тем не менее, когда ожидание равно нулю, то при нажатии
// для выхода из визуального режима или закрытия всплывающего меню, нет никакой заминки, что весьма приятно.
set ttimeoutlen=0
// более удобная работа с кириллицей. При нажатии в режиме вставки, vim изменит режим с "Insert" на "Insert (lang)",
// после чего будут вводиться русские символы. Если вернуться в нормальный режим, то все команды будут работать.
set keymap=russian-jcukenwin
set iminsert=0
set imsearch=0
// Выставляем кодировку
set encoding=utf-8
set termencoding=utf-8
// Отключаем swap-файлы. Ставьте на свое усмотрение, мне эта возможность чаще мешала
set noswapfile
// Если в течении этого времени, вы не будете перемещать курсор или печатать, vim обновит swap-файл,
// а также активирует событие CursorHold. Некоторые плагины, вроде tagbar, слушают это событие для обновления состояния.
// Так как swap-файлы я не использую, решил сделать значение поменьше (по умолчанию - 4000).
set updatetime=500
// :vsplit открывает окна справа
set splitright
// :split открывает окна снизу
set splitbelow
// убираем совместимость с vi
set nocompatible
// ищем тег-файл в текущей директории
set tags=./tags;
// Игнорировать регистр при поиске. Намного удобнее вводить команды без учета регистра, например ctrlsf, вместо CtrlSF.
// Для поиска с учетом регистра, нужно поместить \C в любое место искомой строки
set ignorecase
// например, при переходе к тегу, vim может ругаться, что текущий буфер не сохранен, hidden решает эту проблему
set hidden
// подсвечивать все совпадения при поиске
set hlsearch
// подсвечивать совпадение во время поиска на лету
set incsearch
// выделять строку, на которой находится курсор
set cursorline
// количество cтрок в всплывающем окне
set pumheight=10
// использовать пробелы в качестве разделителей окон. Не забудьте поставить в конце строки символ пробела
set fillchars+=vert:\
// меняем mapleader на ",", по умолчанию - "\"
let mapleader=","
// рекомендуемые настройки для Vundle
filetype off
filetype plugin on
filetype plugin indent on
// включить подсветку синтаксиса
syntax enable
// выбираем темный фон
set background=dark
// выбираем цветовую схему
colorscheme solas
```
**Комбинации клавиш** Синтаксис создания комбинации, как не сложно догадаться, следующий:
```
[[mode]nore]map keys command
```
где mode — режим или окружение, где работает комбинация
nore (non-recursive) — не «раскрывать» комбинацию, а использовать значение по умолчанию
```
:map j gg // j = gg
:map Q j // Q = gg
:noremap W j // W = j
- enter
- Ctrl
```
[Подробнее про назначение комбинаций](http://vim.wikia.com/wiki/Mapping_keys_in_Vim_-_Tutorial_(Part_1))
```
// выходим в "нормальный" режим по df. "d" используется гораздо чаще, чем "j"
// наверное, забиндить "jj" было бы куда уместнее, но я уже привык, к тому же так быстрее
imap df l
// часто нужно отделять блоки кода пустой строкой, например, перед return
nnoremap 2o o
// тоже самое, что и предыдущая команда, только в другом направлении
nnoremap 2O OO
// передвинуть текущую вкладку вправо
nnoremap tm :tabm +1
// передвинуть текущую вкладку влево
nnoremap tM :tabm -1
// убрать подсветку найденных совпадений
nnoremap :noh
// комментируем фрагмент кода
map NERDCommenterComment
// комментируем строку, повторное нажатие убирает комментарий
map NERDCommenterToggle
// создаем phpDoc для функций, классов, свойств
nnoremap :call PhpDoc()
// показать окно с тегами
nnoremap :TagbarToggle
// показать дерево проекта
nnoremap :NERDTreeToggle
// показать syntax group для участка кода, а также цвет этой группы. Удобно при создании своей цветовой схемы
nnoremap :call SyntaxAttr()
// мне гораздо удобнее нажать и для выбора последующего и предыдущего значения, чем и
inoremap
inoremap
cnoremap
cnoremap
// прописываем use
autocmd FileType php noremap :call PhpInsertUse()
// открыть ~/.vimrc
nnoremap :tabe ~/.vimrc:tabm 0
// сохранить ~/.vimrc и применить изменения
nnoremap :w:so $MYVIMRC
```
**Мне не нравится идея менять стандартное поведение клавиш, но следующие комбинации я нашел весьма удобными для себя. Я редко пользуюсь поиском символа в строке (f и F), а такие команды, как J и K, я ни разу так и не использовал.**
```
// переместиться в начало видимой области
nnoremap K H
// переместиться в конец видимой области
nnoremap J L
// открыть предыдущее окно
nnoremap H gT
// открыть следующее окно
nnoremap L gt
// окно поиска файлов
nnoremap F :CtrlP
nnoremap ff :CtrlP
// find tag - нечеткий поиск тега в файле
nnoremap ft :CtrlPBufTag
// find buffer - нечеткий поиск буфера
nnoremap fb :CtrlPBuffer
// find symbol - переместиться к любому символу в файле
nmap fs (easymotion-s)
// find line - переместиться к любому символу в строке
nmap fl (easymotion-sl)
// find current - найти текущий файл в дереве проекта
nnoremap fc :NERDTreeFind
// find pattern - поиск слова в проекте
nnoremap fp :CtrlSF
```
Самой сложной задачей для меня оказалась ~~установка youcompleteme~~ настройка переключения вкладок , на которую я потратил часов 5 (5, Карл!). Как я только не писал: , , , ^[1 — escape-последовательность (, потом Alt + 1). Читал :help :map-alt-keys, создавал файл ~/.inputrc с содержанием set convert-meta on. Забавно, но в xterm всё работало. Gnome-terminal преподнес мне уйму незабываемых ощущений, пока я не наткнулся на [этот ответ](http://stackoverflow.com/questions/6778961/alt-key-shortcuts-not-working-on-gnome-terminal-with-vim) на SO. Должен признаться, я почти сразу нашел этот ответ, но мне показалось, что программировать комбинацию клавиш, хм, слишком. Немного изменив пример, получаем:
```
for c in range(1, 9)
exec "set =\e".c
exec "map \e".c." "
let n = c - '0'
exec "map ". n ."gt"
endfor
```
Это какой-то мазохизм, и я верю, что есть что-то более адекватное (напишите в комментариях, если это так, пожалуйста), просто в тот момент я был рад любому решению.
**Некоторые стандартные комбинации**
```
// вставка из системного буфера. Нужен vim, скомпилированный с флагом "clipboard". Чтобы проверить, наберите vim --version | grep "+clipboard" в вашем терминале
\*
// центрировать экран на текущей строке
zz
// перейти к определению тега (необходим тег-файл)
// вернуться на уровень выше по стеку вызовов команды
// вставка последнего удаленного(d) или скопированного(y) текста. Удобно использовать в режиме вставки или в режиме командной строки
"
```
**Аббревиатуры** Vim позволяет создавать полезные сокращения команд, просто пропишите в вашем .vimrc следующее «abbr help tab help» и после ввода «help», и нажатия пробела, vim раскроет её до «tab help». Чтобы избежать «раскрытия», перед пробелом нажмите .
**Заключение**: vim дает свободу, несравнимую ни с чем. Возможно, emacs может составить конкуренцию, но с ним пока не работал. Переход от sublime'a к vim'у напоминает мне переучивание с 4-х пальцевой (насколько я помню) печати на 9-ти пальцевую. Не поймите меня неправильно, sublime замечательный редактор, речь о том, что поначалу вы теряете привычную скорость; проходит время, продуктивность возвращается до прежнего уровня и начиная с этого момента вы наращиваете скорость. Все основные функции, которыми я пользовался в sublime, перекочевали в vim в том или ином виде. Самое время отрабатывать комбинации и расширять стандартные возможности редактора с помощью viml. Есть еще одна особенность, которая напоминает мне смену основной ОС с Windows на Ubuntu. В Windows я пользовался терминалом, наверное, раз 10 за всё время. Я не могу сказать, что мне чего-то не хватало, вполне всё устраивало. Но когда переходишь на linux, то волей-неволей начинаешь использовать консольные команды. Не осознанно (и это важно) вы получаете инструмент (bash) для решения определенных задач. В vim'e приходится постоянно что-то гуглить в поисках решения тех или иных проблем. Очень часто я вижу решения, которые отличаются от привычной настройки sublime или похожих редакторов в стиле key:value. Вы в буквальном смысле программируете свой редактор. Почти сразу вы видите, как инициализировать переменную, чуть позже — как применить ту или иную настройку для определенного типа файлов, еще позже — как слушать события или создавать циклы. По крупицам информации вы получаете представление про viml и, возможно, скоро напишите свой первый плагин. Конечно, всё это можно узнать просто открыв документацию к языку, но, должен сказать, желания освоить python или api sublime у меня так и не появилось. Лично я уверен, что vim приберег для меня еще немало приятных сюрпризов, а мой .vimrc, похоже, будет меняться всё время, пока я работаю с этим редактором.
**Несколько вопросов** 1. Если буфер изменился, airline выделит таб другим цветом, тем не менее, когда мы переключаемся на другую вкладку, измененная вкладка окрашивается в обычный цвет. Из-за этого, при выходе из редактора, часто получаю предупреждение, что буфер не сохранен. Можно ли подсвечивать все измененные вкладки, независимо от того, активны они или нет?
2. В readme nerdtree сказано, что можно изменить символ открытия/закрытия директории прописав g:NERDTreeDirArrowExpandable и g:NERDTreeDirArrowCollapsible. Однако, при попытке выставить "+" и "-", nerdtree падает. Кто-нибудь пробовал починить?
3. Как подружить youcompleteme и omnicompletion? Приходится идти напрямую, нажимая .
4. В начале каждого php-скрипта стоит "php", когда курсор находится над "<", то vim ищет ближайший "". Как отключить подсветку этого символа для php-файлов? Что-то на подобии:
```
au FileType php set matchparen-=<
```
**.vimrc целиком**
```
" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" let Vundle manage Vundle, required
Plugin 'VundleVim/Vundle.vim'
" common
Plugin 'scrooloose/nerdtree'
Plugin 'valloric/youcompleteme'
Plugin 'xolox/vim-easytags'
Plugin 'majutsushi/tagbar'
Plugin 'tpope/vim-fugitive'
Plugin 'easymotion/vim-easymotion'
Plugin 'ctrlpvim/ctrlp.vim'
Plugin 'terryma/vim-multiple-cursors'
Plugin 'vim-airline/vim-airline'
Plugin 'vim-airline/vim-airline-themes'
Plugin 'scrooloose/nerdcommenter'
Plugin 'matze/vim-move'
Plugin 'raimondi/delimitmate'
Plugin 'mattn/emmet-vim'
Plugin 'scrooloose/syntastic'
Plugin 'tpope/vim-surround'
Plugin 'sirver/ultisnips'
Plugin 'honza/vim-snippets'
Plugin 'xolox/vim-session'
Plugin 'xolox/vim-misc'
Plugin 'SyntaxAttr.vim'
Plugin 'dyng/ctrlsf.vim'
Plugin 'rking/ag.vim'
Plugin 'godlygeek/tabular'
" php
Plugin 'stanangeloff/php.vim'
Plugin 'sumpygump/php-documentor-vim'
Plugin 'arnaud-lb/vim-php-namespace'
" javascript
Plugin 'pangloss/vim-javascript'
" html
Plugin 'othree/html5.vim'
" twig
Plugin 'evidens/vim-twig'
" css
Plugin 'mtscout6/vim-tagbar-css'
" colors
Plugin 'damage220/solas.vim'
Plugin 'nanotech/jellybeans.vim'
Plugin 'mhartington/oceanic-next'
call vundle#end()
" settings
set tabstop=4
set softtabstop=4
set shiftwidth=4
set autoread
set autoindent
set smartindent
set rnu
set laststatus=2
set timeoutlen=500
set ttimeoutlen=0
set keymap=russian-jcukenwin
set iminsert=0
set imsearch=0
set encoding=utf-8
set termencoding=utf-8
set updatetime=500
set noswapfile
set splitright
set splitbelow
set nocompatible
set tags=./tags;
set ignorecase
set hidden
set hlsearch
set incsearch
set cursorline
set pumheight=10
set fillchars+=vert:\
let mapleader=","
filetype off
filetype plugin on
filetype plugin indent on
" autocmd CompleteDone * pclose
" color
syntax enable
set background=dark
colorscheme solas
" abbreviations
abbr help tab help
" mappings
imap df l
nnoremap 2o o
nnoremap 2O OO
nnoremap tm :tabm +1
nnoremap tM :tabm -1
nnoremap K H
nnoremap J L
nnoremap H gT
nnoremap L gt
nnoremap F :CtrlP
nnoremap ff :CtrlP
nnoremap ft :CtrlPBufTag
nnoremap fb :CtrlPBuffer
nmap fs (easymotion-s)
nmap fl (easymotion-sl)
nnoremap fc :NERDTreeFind
nnoremap fp :CtrlSF
nnoremap :noh
map NERDCommenterComment
map NERDCommenterToggle
nnoremap :call PhpDoc()
nnoremap :TagbarToggle
nnoremap :NERDTreeToggle
nnoremap :call SyntaxAttr()
inoremap
inoremap
cnoremap
cnoremap
autocmd FileType php noremap :call PhpInsertUse()
nnoremap :tabe ~/.vimrc:tabm 0
nnoremap :w:so $MYVIMRC
" map to navigate through tabs
for c in range(1, 9)
exec "set =\e".c
exec "map \e".c." "
let n = c - '0'
exec "map ". n ."gt"
endfor
" nerdtree
let NERDTreeAutoDeleteBuffer = 1
" move
let g:move\_key\_modifier = 'C'
" youcompleteme
let g:ycm\_server\_python\_interpreter='python'
let g:ycm\_autoclose\_preview\_window\_after\_completion = 1
let g:ycm\_key\_list\_select\_completion = ['']
" emmet
let g:user\_emmet\_expandabbr\_key = ''
" airline
let g:airline\_theme='solarized'
let g:airline\_powerline\_fonts = 1
let g:airline#extensions#tabline#enabled = 1
let g:airline#extensions#tabline#tab\_min\_count = 0
let g:airline#extensions#tabline#formatter = 'unique\_tail'
let g:airline#extensions#tabline#show\_buffers = 0
let g:airline#extensions#tabline#fnamemod = ':t'
let g:airline\_section\_warning = ''
let g:airline\_section\_error = ''
let g:airline#extensions#tabline#show\_close\_button = 0
let g:airline#extensions#tabline#left\_alt\_sep = ''
let g:airline#extensions#tagbar#enabled = 0
let g:airline#extensions#tabline#show\_tab\_nr = 1
let g:airline#extensions#tabline#tab\_nr\_type = 1
" easymotion
let g:EasyMotion\_smartcase = 1
let g:EasyMotion\_do\_shade = 0
hi link EasyMotionTarget Search
hi EasyMotionTarget2First ctermfg=202 ctermbg=None cterm=None
hi EasyMotionTarget2Second ctermfg=202 ctermbg=None cterm=None
" session
let g:session\_autoload = 'yes'
let g:session\_autosave = 'yes'
let g:session\_autosave\_periodic = 5
let g:session\_autosave\_silent = 1
let g:session\_default\_to\_last = 1
" NERDCommenter
let g:NERDSpaceDelims = 1
" html
au BufNewFile,BufRead \*.tpl set filetype=html syntax=php
" syntastic
let g:syntastic\_always\_populate\_loc\_list = 1
let g:syntastic\_auto\_loc\_list = 1
let g:syntastic\_check\_on\_open = 1
let g:syntastic\_check\_on\_wq = 0
" tagbar
let g:tagbar\_sort = 0
let g:tagbar\_width = 35
let g:tagbar\_iconchars = ['+', '-']
let g:tagbar\_map\_close = ''
let g:tagbar\_type\_php = {
\'ctagstype': 'php',
\'kinds': [
\'i:interfaces',
\'c:classes',
\'d:constants',
\'f:functions'
\]
\}
let g:tagbar\_type\_javascript = {
\'ctagstype':'JavaScript',
\'kinds' : [
\'f:functions',
\'c:classes',
\'m:methods',
\'p:properties'
\]
\}
" delimitmate
let delimitMate\_expand\_cr = 1
let delimitMate\_expand\_space = 1
au FileType vim,html let b:delimitMate\_matchpairs = "(:),[:],{:},<:>,>:<"
" NERDTree
" let g:NERDTreeDirArrowExpandable = '+'
" let g:NERDTreeDirArrowCollapsible = '-'
" ctrlp
let g:ctrlp\_by\_filename = 1
let g:ctrlp\_working\_path\_mode = 'wr'
let g:ctrlp\_map = ''
let g:ctrlp\_buftag\_types = {
\'php': '--php-kinds=icdf'
\}
" ctrlsf
let g:ctrlsf\_position = 'right'
" easytags
let g:easytags\_file = './tags'
let g:easytags\_auto\_highlight = 0
let g:easytags\_events = ['BufWritePost']
let g:easytags\_async = 1
```
**vim как ide** Предвидя некоторые вопросы в стиле: «как в vim'e рефакторить код также удобно, как и в моей любимой ide?», пожалуй, [отвечу сразу](https://www.youtube.com/watch?v=VJfK-QLv27o).
Если вы заядлый vim'ер, то вам могут понравиться следующие расширения для chrome:
**vimium** Расширение добавляет комбинации для навигации по странице и удобному перемещению по ссылкам, [подробнее](https://www.youtube.com/watch?v=t67Sn0RGK54).
**wasavi** Добавляет основные возможности vim'a для работы с текстовыми полями. Расширение можно активировать, нажав \, или же при фокусе текстового поля (настраивается).
**PS**: вместо родного символа комментария viml (двойная кавычка), я решил использовать "//", поскольку viml на хабре нет, и я не знаю, есть ли язык со схожим комментированием кода.
**PS2**: некоторые комбинации экранированы символом "\", дабы парсер не считал их за html-теги. Тег «pre» — блочный, решил, что лучше уж так.
**UPD**: добавлена поддержка gui для solas. | https://habr.com/ru/post/303524/ | null | ru | null |
# Классовый мутатор Binds.
В обсуждении [недавнего топика](http://habrahabr.ru/blogs/mootools/39794/) хабрасообщество заинтересовалось подробностями написания классов для MooTools и, в частности, мутаторами. В связи с этим мне захотелось что-нибудь написать на эту тему, пока не наткнулся на статью одного из разработчиков MooTools. В этом топике привожу перевод статьи, в которой Jan Kassens описывает пример использования классовых мутаторов.
Во время написания класса вам может понадобиться привязать метод класса к событию в качастве обработчика и использовать `this` внутри него в качестве экземпляра класса. Вы можете сказать, что это не проблема при использовании `bind()`. Все это верно, но ровно до тех пор, пока дело не доходит до удаления обработчика события, т.к. `Function::bind()` работает так, что возвращает новую функцию, оборачивающую оригинал. Поэтому Вам нужно где-то сохранить ту самую обертку, чтобы удалить обработчик (без удаления всех обработчиков событий элемента, что не очень хорошо внутри переносимого класса).
**Примечание автора перевода**. Автор статьи имеет в виду случай, когда обработчик события назначается с помощью `el.addEvent('click', myFn.bind(this))`. Таким образом его нельзя удалить с помощью `el.removeEvent('click', myFn.bind(this))`, потому что `bind()` вернет уже новую функцию, не ту что была использована в `addEvent()`. Единственным в данном случае решением будет удаление всех обработчиков элемента с помощью `el.removeEvents('click')`, но это затронет все обработчики, включая те, которые могли быть назначены сторонними классами.
Что я видел несколько раз — это объект, содержащий все привязанные функции, который создается в конструкторе, как видно из примера:
`> var MyClass = new Class({
>
> initialize: function(){
>
> this.bound = {
>
> sayHello: this.sayHello.bind(this),
>
> sayGoodbye: this.sayGoodbye.bind(this)
>
> }
>
> // Далее используем только this.bound.sayHello и
>
> // this.bound.sayGoodbye внутри класса
>
> },
>
>
>
> sayHello: function() { /\* ... \*/ },
>
> sayGoodbye: function() { /\* ... \*/ }
>
> });`
Мне такое решение не понравилось, потому что оно слишком громоздко: зачем мне использовать `this.bound.myFn` всегда, когда я пользуюсь привязанными функциями? И, потом, я не хочу каждый раз привязывать эти функции вручную. После рассмотрения различных решений я пришел к одному, оптимальному по скорости (не бойтесь, это быстрее, чем решение выше) и удобству.
Это — новый, так называемый «классовый мутатор» `Binds`. Многие из вас, возможно, не слышали о классовых мутаторах раньше, но точно их использовали при написании своих классов. Встроенные мутаторы: `Implements` и `Extends`, а вот и код `Binds`:
`> Class.Mutators.Binds = function(self, methods) {
>
> $splat(methods).each(function(method){
>
> var fn = self[method];
>
> self[method] = function(){
>
> return fn.apply(self, arguments);
>
> };
>
> });
>
> };`
Этот мутатор переопределяет все методы, переданные в него в строках новыми версиями, привязанными к экземпляру. `Binds: 'foo'` просто привяжет `foo` к классу, `Binds: ['foo', 'bar']` привяжет `foo` и `bar`. Довольно просто, не правда ли?
Теперь давайте посмотрим, насколько упростится класс с использованием мутатора `Binds`:
`> var MyClass = new Class({
>
> Binds: ['sayHello', 'sayGoodbye'],
>
>
>
> initialize: function(){
>
> // Теперь используем только this.sayHello и
>
> // this.sayGoodbye внутри класса
>
> },
>
>
>
> sayHello: function() { /\* ... \*/ },
>
> sayGoodbye: function() { /\* ... \*/ }
>
> });`
Надеюсь, вы немного разобрались и сможете найти этому применение. | https://habr.com/ru/post/40059/ | null | ru | null |
# Как расширить функционал приложения, размещенного на Mac Store, при помощи Apple Script
С тех пор, как для прохождения модерации на Mac Store стала требоваться поддержка Sandbox, прошло уже 5 лет. Хотя возможности MacOS и Sandbox постепенно расширяются, разработчики, желающие публиковаться в официальном магазине Apple, по-прежнему ограничены в возможностях работы c этой ОС. Особенно остро эта проблема стоит для утилит и системных приложений.
Sandbox призван сделать macOS безопасней и уберечь пользователя от вредоносных и потенциально опасных приложений — все действия приложений, которые могут гипотетически принести вред, должны сопровождаться запросом к пользователю на предоставление доступа. В теории это разумная мера предосторожности, однако в действительности под санкции попадают многие приложения, которым пользовательские данные необходимы для осуществления базовых функций. В данной статье мы расскажем, как внедряли подобные функции в приложение, поддерживая совместимость с Sandbox, — возможно, этот опыт будет полезен для других разработчиков, работающих с официальным маркетом.
Наши партнеры столкнулись с подобной необходимостью при работе с утилитой для мониторинга системы [MaCleaner X](http://wgames.ssdzoner.com/go.php?id=W9iL17). Вся линейка продуктов MaCleaner распространяется исключительно через Mac App Store.
Отличительными особенностями MaCleaner X являются поддержка [тачбара](https://habrahabr.ru/company/everydaytools/blog/317232/) и кастомизированный дизайн: приложение автоматически определяет модель Mac и предлагает особый вариант интерфейса для каждого девайса. Однако в дополнение к этому мы в данный момент работаем над тем, чтобы реализовать в расширенной версии некоторые функции, которые пользователи хотели бы видеть в программе и которые для утилит, распространяемых вне Mac Store, считаются привычными.
В первую очередь это:
* удаление приложений и всей связанной с ними информации;
* удаление неиспользуемых служебных файлов из macOS (логи, локализации, temp);
* получение системной информации о железе (например, о жестком диске);
* мониторинг температуры и других показателей системы.
**Способ решения**
Для начала в общем виде наметим, по какой схеме будет происходить весь процесс:
* Пользователь должен дать согласие на доступ для расширения функционала (фактически ему нужно будет осуществить несколько действий вне приложения);
* Приложение всегда работает в песочнице, но в случае необходимости перед каждым действием, требующим администраторские права доступа, запрашивает у пользователя разрешение.
Для выполнения этой операции вне песочницы воспользуемся следующей возможностью macOS: приложения, которые поддерживают расширение своего функционала при помощи Apple Script, могут запускать эти скрипты вне песочницы, если они находятся в папке ~/Library/Application Scripts. Приложение, поддерживающее Sandbox, не может самостоятельно копировать в эту папку скрипты — это пресекается модераторами Apple.
Таким образом, последовательность действий у нас вырисовывается следующая:
1. Реализация master-приложения, поддерживающего расширения при помощи Apple Script из папки Application Scripts.
2. Прохождение модерации и публикация приложения в Mac Store
3. Подготовка extension-приложения. В его задачи будет входить копирование нужных скриптов в общую папку c master-приложением. Для этого они должны иметь общую AppGroup, при помощи которой будет происходить обмен.
4. Публикация extension-приложения на собственном сайте.
**Пример**
В качестве примера рассмотрим возможность получения информации о текущих носителях при помощи bash-команды `system_profiler SPStorageDataType`.
**Подготовка Extension-приложения**
Все, что требуется от этой компоненты — это копирование скрипта в определенную папку. Поэтому в его интерфейсе мы отобразим единственную возможность: включение или отключение отображения информации о носителях (чтобы не грузить пользователя подробностями, это может быть представлено как включение/отключение плагинов в master-приложении).
Apple Sript — bash
Содержимое файла extract\_storage\_info.scpt, который копируется ectention'ом:
```
do shell script "system_profiler SPStorageDataType"
```
**Подготовка Master-приложения**
Для корректной работы приложения с точки зрения пользователя необходимо осуществлять проверку доступности дополнительного функционала и скрывать соответствующие части UI:
```
- (BOOL) isStorageInfoAvailable {
return [self _storageInfoScriptTask] != nil;
}
#pragma mark - Private
- (NSUserAppleScriptTask *)_storageInfoScriptTask {
NSUserAppleScriptTask *result = nil;
NSError *error;
NSURL *directoryURL = [[NSFileManager defaultManager] URLForDirectory:NSApplicationScriptsDirectory inDomain:NSUserDomainMask appropriateForURL:nil create:YES error:&error];
if (directoryURL) {
NSURL *scriptURL = [directoryURL URLByAppendingPathComponent: StorageInfoScriptFileName];
result = [[NSUserAppleScriptTask alloc] initWithURL:scriptURL error:&error];
if (error != nil) {
NSLog(@"No AppleScript \"%@\" task error: %@", StorageInfoScriptFileName, error);
}
} else {
// Возникнет в случае, если приложение запущено не в Sandbox
NSLog(@"No Application Scripts folder error: %@", error);
}
return result;
}
```
Если скрипт доступен, его вызов осуществляется следующим образом:
```
NSUserAppleScriptTask * automationScriptTask = [self _storageInfoScriptTask];
if (automationScriptTask != nil) {
[automationScriptTask executeWithAppleEvent:nil completionHandler:^(NSAppleEventDescriptor *resultEventDescriptor, NSError *error) {
if (error != nil) {
NSLog(@"AppleScript \"%@\" executing error: %@", StorageInfoScriptFileName, error);
//TODO: Обработка ошибки в GUI
}
else {
NSString* resultString = [resultEventDescriptor stringValue];
NSLog(@"Result string:\n%@", resultString);
// Парсинг и вывод информации
}
}];
} else {
//TODO: Обработка ошибки в GUI
}
```
В нашем упрощенном примере, мы выводим полученную от выполненного скрипта строку как есть. Для стилизации под интерфейс приложения необходимо будет парсить результат и отображать только необходимую информацию.
**Совместная работа приложений**
В результате мы получаем следующую схему работы.
**Master-приложение**
1. В случае недоступности дополнительного функционала скрывает элементы UI.
2. В случае наличия расширяющих скриптов, Apple Script (по определенному формату) активирует UI и выполняет их.
3. Если функции, которые выполняет Apple Script, требуют ввода данных администраторской учетной записи, пользователь увидит стандартный диалог авторизации — эту работу выполнит за нас Apple Script.
**Extension-приложение**
1. Должно быть скачано пользователем с сайта разработчика. Мы говорим о специальном сайте, потому что необходимо разъяснить пользователю принцип функционирования системы и действия, которые ему необходимо осуществить для корректной работы. Отчасти это можно сделать через GUI extension-а.
2. Несмотря на то, что работаем вне песочницы, мы предлагаем пользоваться общим AppGroup для компонент-решения.
3. Этот компонент может быть представлен даже более широко — как Менеджер Расширений. Благодаря согласованному интерфейсу, master-приложение может расширяться по мере появления расширений в общей папке: они могут быть добавлены вместе с файлами описаний и конфигурациями.
4. Копируемый Apple Script может даже содержать общую функцию task(bash\_script), принимающую на вход произвольную bash-команду и выполняющую ее. Но этот подход открывает большую дыру в безопасности, а также обязует master-приложение содержать расширение перед публикацией в App Store.
**Выводы**
Плюсы подхода:
* Расширение функционала приложения
* Конфигурируемость расширения
Минусы:
* Нерационально с точки зрения юзабилити. От пользователя требуется дополнительное действие — скачивание стороннего приложения.
* Потенциальная дыра в безопасности и необходимость дополнительных проверок, согласованности форматов.
Данная статья предлагает решение проблемы с ограничениями функционала продукта, диктуемыми Sandbox, для разработчиков. В будущем мы расскажем вам о том, как ситуация выглядит со стороны пользователей. Если вы находили другие обходные пути, будем рады, если вы поделитесь ими в комментариях. | https://habr.com/ru/post/323982/ | null | ru | null |
# Selenium для всех: как мы учим QA-инженеров работать с автотестами
Привет, Хабр! Меня зовут Виталий Котов, я работаю в Badoo в отделе QA, занимаюсь автоматизацией тестирования, а иногда и автоматизацией автоматизации тестирования.
Сегодня я расскажу о том, как мы в Badoo упростили работу с Selenium-тестами, научили ребят из отдела ручного тестирования работать с ними и какой профит с этого получили. Прочитав статью, вы сможете оценить трудозатратность каждого из этапов и, возможно, захотите частично перенять наш опыт.
### Введение
Со временем количество автотестов становится довольно внушительным, и приходит понимание, что система, в которой количество автоматизаторов – константа, а количество тестов непрерывно растёт, – неэффективна.
В Badoo серверная часть наравне с Desktop Web релизится два раза в день. Об этом очень подробно и интересно рассказал мой коллега Илья Кудинов в статье [«Как мы уже 4 года выживаем в условиях двух релизов в день»](https://habrahabr.ru/company/badoo/blog/317700/). Я советую ознакомиться с ней, чтобы дальнейшие примеры в этой статье были вам более понятны.
Вполне очевидно, что чем выше покрытие автотестов, тем бóльшее их количество окажется затронутым в процессе релиза. Где-то изменили функционал, где-то поменяли вёрстку и локаторы перестали находить нужные элементы, где-то включили A/B-тест и бизнес-логика для части юзеров стала другой и так далее.
В какой-то момент мы оказались в ситуации, когда правка тестов после релиза занимала почти всё время, которое было у автоматизатора до следующего релиза. И так по кругу. Не оставалось времени на написание новых тестов, на поддержку и развитие архитектуры и решение каких-то новых задач. Что делать в такой ситуации? Первое решение, которое приходит в голову, — нанять ещё одного автоматизатора. Однако у такого решения есть существенный минус: когда тестов снова станет в два раза больше, мы снова будем вынуждены нанимать ещё одного автоматизатора.
Поэтому мы пошли по другому пути, мы решили научить ребят из отдела ручного тестирования работать с тестами, условившись, что в своих задачах они будут самостоятельно править тесты до релиза. Какие плюсы у этого решения?
Во-первых, если тестировщик способен поправить автотест, он тем более способен разобраться в причине его падения. Таким образом, повышается вероятность, что он найдет баг на максимально раннем этапе тестирования. Это хорошо, потому что исправить проблему в этом случае можно быстро и просто, а задача уедет на продакшн в назначенный [due date](https://habrahabr.ru/company/badoo/blog/335622/).
Во-вторых, наши автотесты для Desktop Web написаны на PHP, как и сам продукт. Следовательно, работая с кодом автотестов, тестировщик развивает в себе навык работы с этим языком программирования, и ему становится легче и проще понять дифф задачи и разобраться, что там было сделано и куда стоит в первую очередь посмотреть при тестировании.
В-третьих, если ребята правят тесты, они иногда могут выделять время для написания новых. Это и интересно самому тестировщику, и полезно для покрытия.
И последнее, как вы уже поняли, у автоматизатора появляется больше времени, которое он может тратить на решение архитектурных вопросов, ускоряя прохождение тестов и делая их проще и понятнее.
С плюсами разобрались. Теперь давайте подумаем, какие могут быть минусы.
Тестирование задачи начнет занимать больше времени, потому что QA-инженеру придется помимо проверки функционала исправлять тесты. С одной стороны это действительно так. С другой стороны стоит понимать, что маленькие задачи у нас в Badoo превалируют над масштабными рефакторингами, где затрагивается всё или почти всё. О том, почему это так и как мы к этому пришли, хорошо рассказал глава отдела QA Илья Агеев в статье [«Как workflow разработки влияет на декомпозицию задач»](https://habrahabr.ru/company/badoo/blog/335254/). Следовательно, исправления должны сводиться к нескольким строчкам кода, а это не займет много времени.
В крупных же задачах, где сломалось большое количество тестов, и багов тоже может быть много. Не раз мы сталкивались с ситуацией, когда в процессе починки тестов после таких рефакторингов находились баги, пропущенные при ручном тестировании. А как мы помним, чем раньше мы найдём баг, тем легче его исправить.
Итак, дело за малым – сделать тесты пригодными для того, чтобы в них мог разобраться человек, не имеющий опыта написания автотестов.
### Рефакторинг тестов
Первый этап был довольно скучным. Мы принялись за рефакторинг наших тестов, стараясь максимально отделить логику работы теста со страницей от логики самого теста, так, чтобы при изменении внешнего вида проекта было достаточно поправить несколько констант-локаторов, не трогая при этом код самого теста. В итоге у нас получились классы наподобие [PageObject](https://github.com/SeleniumHQ/selenium/wiki/PageObjects). Каждый из них описывает элементы, относящиеся к одной странице или одному компоненту, и методы взаимодействия с ними: дождаться элемент, подсчитать количество элементов, кликнуть по нему и так далее. Мы договорились, что никаких логических проверок типа assert в таких классах быть не должно – только взаимодействие с UI.
Благодаря этому мы получили тесты, которые читаются довольно просто:
```
$Navigator->openSignInPage();
$SignInPage->enterEmail($email);
$SignInPage->enterPassword($password);
$SignInPage->submitForm();
$Navigator->waitForAuthPage();
```
И простые UI-классы, которые выглядят примерно так:
```
сlass SignInPage extends Api
{
const INPUT_EMAIL = ‘input.email’;
const INPUT_PASSWORD = ‘input.password’;
const INPUT_SUBMIT_BUTTON = ‘button[type=”submit”]’;
public function enterEmail($email)
{
$this->driver->element(self::INPUT_EMAIL)->type($email);
}
public function enterPassword($password)
{
$this->driver->element(self::INPUT_PASSWORD)->type($password);
}
public function submitForm()
{
$this->driver->element(self::INPUT_SUBMIT_BUTTON)->click();
}
}
```
Теперь, если локатор для пароля изменится, и тест сломается, не найдя нужное поле ввода, будет понятно, как его поправить. Более того, если метод enterPassword() используется в нескольких тестах, изменение соответствующего локатора починит сразу всё.
В таком виде тесты уже можно показывать ребятам. Они читаемые, и с ними вполне можно работать, не имея опыта написания кода на PHP. Достаточно рассказать основы. Для этого мы провели ряд обучающих семинаров с примерами и заданиями для самостоятельного решения.
### Обучение
Обучение велось постепенно, от простого к сложному. После первого занятия была задача починить сломанный тест, где нужно было поправить несколько локаторов. После второго занятия требовалось расширить существующий тест, дописав несколько методов в UI-класс и использовав их в тесте. После третьего ребята уже вполне могли написать новый тест самостоятельно.
На основе этих семинаров были написаны статьи в нашу внутреннюю Wiki о том, как правильно работать с тестами и с какими подводными камнями можно столкнуться в процессе. В них мы собрали best practices и ответы на часто задаваемые вопросы: как правильно составить локатор, в каком случае стоит создавать новый класс под тест, а в каком – добавлять тест в уже существующий, когда создавать новый UI-класс, как правильно называть константы для локаторов и так далее.
Сейчас, когда в компанию приходит новый QA-инженер, он получает список тех самых статей из Wiki, с которыми необходимо ознакомиться для работы с автотестами. И когда он в процессе тестирования впервые сталкивается с падающим тестом, он уже во всеоружии и знает, что делать. Само собой, в любой момент он может подойти ко мне или к другому автоматизатору и что-то уточнить или спросить, это нормально.
У нас есть договорённость, что умение QA инженера работать с автотестами, в том числе писать новые – это одно из требований для роста внутри компании. Если ты хочешь развиваться (а кто же не хочет, верно?), надо быть готовым к тому, что придётся заниматься и автоматизацией в том числе.
### TeamCity
Наши Selenium-тесты лежат в том же репозитории, где и код проекта. Когда мы только начинали писать первые Selenium-тесты, у нас уже был PHPUnit и некоторое количество unit-тестов. Чтобы не плодить технологии, мы решили запускать Selenium-тесты, используя тот же PHPUnit, и положили их в соседнюю с unit-тестами папку. Пока тестами занимались только автоматизаторы, мы могли вносить правки в тесты сразу в Master, поскольку делали это уже после релиза. И, соответственно, запускали в TeamCity тесты тоже с Master.
Когда ребята начали работать с тестами в своих задачах, мы договорились, что правки будут вноситься в ту же ветку, где лежит код задачи. Во-первых, это обеспечивало одновременную доставку правок для тестов в Master с самой задачей, во-вторых, в случае отката задачи из релиза правки для неё также откатывались без дополнительных действий. В итоге мы начали запускать тесты в TeamCity с ветки релиза.
Таким образом, мы получили систему, в которой автоматизатор может следить только за тестами для релиза, а новая задача при этом приходит в релиз сразу с правками для тестов. В такой системе пожизненный зелёный билд обеспечен. :)
Но это ещё не всё.
### Запуск тестов по диффу задачи
Гонять все тесты для каждой задачи крайне затратно как по времени, так и по ресурсам. Каждый тест необходимо обеспечить браузером, следовательно, нужно поддерживать мощную Selenium-ферму. Также нужен мощный сервер, на котором будет развёрнут проект и по которому параллельно будет ходить большое число автотестов. А это – дорогое удовольствие.
Мы решили, что было бы круто вычислять динамически для каждой задачи, какие именно тесты стоит запускать. Для этого мы каждому тесту присвоили [набор групп](https://phpunit.de/manual/current/en/appendixes.annotations.html#appendixes.annotations.group), которые привязаны к проверяемым фичам или страницам: Search, Profile, Registration, Chat, и написали скрипт, который отлавливает тесты без групп и пишет соответствующие нотификации автоматизаторам.
Далее перед запуском тестов на задаче мы при помощи Git научились анализировать изменённые файлы. Они по большей части тоже называются как-то похоже на фичи, к которым имеют отношение, или лежат в соответствующих папках:
* `/js/search/common.js`
* `/View/Chat/GetList.php`
* `/tpls/profile/about_me_block.tpl`
Мы придумали пару правил для файлов, которые не соответствуют названию ни одной группы. Например, у нас часть файлов называется, скажем, не chat, а messager. Мы сделали карту алиасов и, если натыкаемся на файл, который называется messager, запускаем тесты для группы Chat, а если файл лежит где-то в core-папках, то мы делаем вывод, что стоит запустить полный набор тестов.
Конечно, универсального алгоритма решения такой задачи не существует – всегда есть вероятность, что изменение в каком-то классе затронет проект в самом неожиданном месте. Но это нестрашно, поскольку на стейджинге мы запускаем полный набор тестов и обязательно заметим проблему. Более того, мы придумаем правило, как в следующий раз не пропустить подобную проблему и обнаружить её заранее.
### Нестабильные и сломанные тесты
Последнее, что осталось сделать, — это разобраться с нестабильными и сломанными тестами. Никто не захочет возиться с сотней упавших тестов, разбираясь, какие из них сломаны на Master, а какие – просто упали, потому что проходят в 50% случаев. Если доверия к тестам нет, тестировщик не будет внимательно их изучать и тем более править.
Бывает, что при релизе больших задач допускается некоторое количество мелких багов, которые незаметны пользователю (например, JS-ошибка, которая не влияет на функционал) и которые можно исправить в следующем релизе, не задерживая выкладку важных изменений на продакшн.
И если с тестировщиком можно договориться, то с тестами всё сложнее – они честно будут находить проблему и падать. Причём, когда баг окажется в Master, тесты начнут падать на других задачах, что совсем плохо.
Для таких тестов мы придумали следующую систему. Мы завели MySQL-табличку, где можно указать название падающего теста и тикет, в котором проблему исправят. Тесты перед запуском получают этот список, и каждый тест ищет себя в нём. Если находит, помечается как Skipped с сообщением, что такой-то тикет не готов, и тест запускать нет смысла.
В качестве багтрекера мы используем JIRA. Параллельно по cron’у гоняется скрипт, который через [JIRA API](https://docs.atlassian.com/jira/REST/cloud/) проверяет статусы тикетов из этой таблицы. Если тикет переходит в статус Closed, мы удаляем запись, и тест автоматически начинает снова запускаться.
В итоге сломанные тесты исключаются из результатов прогонов. С одной стороны, это хорошо – на них больше не тратится время при прогоне, и они не «засоряют» результаты этого прогона. С другой стороны, тестировщику приходится постоянно открывать SeleniumManager и смотреть, какие тесты отключены, чтобы при необходимости проверять кейзы руками. Так что мы стараемся не злоупотреблять этой фичей, у нас редко бывает больше одного–двух отключенных тестов.
Теперь вернёмся к проблеме нестабильных тестов. Поскольку речь в статье идёт о UI-тестах, нужно понимать, что это тесты высокого уровня: интеграционные и системные. Такие тесты по определению нестабильны, это нормально. Однако хочется всё же ловить эти нестабильности и отделять от тестов, явно падающих «по делу».
Мы довольно давно пришли к выводу, что стоит логировать запуски всех тестов в специальную MySQL-таблицу. Название теста, время прогона, результат, для какой задачи или на стейджинге был запущен этот тест и так далее. Во-первых, нам это нужно для статистики; во-вторых, эта таблица используется в SeleniumManager – веб-интерфейсе для запуска и мониторинга тестов. О нём однажды я напишу отдельную статью. :)
Помимо вышеперечисленных полей, в таблицу было добавлено новое – код ошибки. Этот код формируется на основе трейса упавшего теста. Например, в задаче А тест упал на строке 74, где он вызвал строку 85, где был вызван UI-класс на строке 15. Почему бы нам не склеить и не записать эту информацию: 748515? В следующий раз, когда тест упадёт на какой-то другой задаче Б, мы получим код для текущей ошибки и простым select’ом из таблицы узнаем, были ли ранее похожие падения. Если были, то тест очевидно нестабильный, о чём можно сделать соответствующую пометку.
Само собой, тесты иногда меняются, и строки, на которых они падают, тоже могут измениться. И какое-то время старая ошибка будет считаться новой. Но, с другой стороны, это происходит не так часто, поскольку, как вы помните, логика теста отделена от логики UI и меняется редко. Так что бóльшую часть нестабильных тестов таким образом мы действительно отлавливаем и помечаем. В SeleniumManager есть интерфейс, позволяющий перезапускать нестабильные тесты для выбранной задачи с целью убедиться, что функционал работает.
### Итог
Я постарался подробно, но без излишней дотошности описать наш путь от точки А, где автотестами занималась только группа «избранных» ребят, до точки Б, где тесты стали удобными и понятными всем.
Этот путь состоял из следующих этапов:
1. Разработка специальной архитектуры, в рамках которой должны быть написаны все тесты. Рефакторинг старых тестов.
2. Проведение обучающих семинаров и написание документации для новых сотрудников.
3. Оптимизация работы автотестов: изменение флоу запуска тестов в TeamCity, запуск тестов по диффу для конкретной задачи.
4. Упрощение результатов прогона тестов: тестировщик в первую очередь должен видеть те упавшие тесты, которые наверняка связаны с его задачей.
В итоге мы пришли к системе, в которой ручным тестировщикам довольно комфортно работать с Selenium-тестами. Они понимают, как они устроены и как их запускать, умеют их править и могут при необходимости писать новые.
В то же время автоматизаторы получили возможность и время заниматься сложными задачами: создавать более точные системы для отлавливания нестабильных тестов и править их, создавать удобные интерфейсы для запуска тестов и интерпретации результатов прогонов, ускорять и улучшать сами тесты.
Совершенствуйте свои инструменты и делайте их проще в использовании и будет вам «щасте». Спасибо за внимание! | https://habr.com/ru/post/337126/ | null | ru | null |
# Qt? ImGUI? wxWidgets? Пишем свое
Привет, хабровчане! Хочу рассказать о своей системе UI, которую я написал для своего игрового движка, на которой делаю редактор для него же. Вот такой:
Итак, вот уже в который раз я начал писать движок, и твердо решил что в этот раз сделаю все хорошо и правильно. Одним из этих "хорошо и правильно" является WYSIWYG редактор а-ля Unity3D. К слову сказать, до этого у меня уже был опыт разработки подобных редакторов, на Qt. И к тому моменту я уже понимал, что задача стоит не простая, если я хочу сделать по-настоящему хороший редактор. И для этого нужна очень хорошая и гибкая система UI, в которой я буду очень хорошо разбираться и знать всякие тонкости. Ведь в таком редакторе будет очень много кастомных виджетов, контролов и т.п. Поэтому не должно быть компромисса между качеством редактора и возможностями UI системы.
При этом в самом движке стояла задача сделать хорошую систему UI. Т.к. движок для 2D игр, и в таких играх бывает очень много интерфейсов (бизнес-логика игр, чаты, кланы, инвентари и т.д.), то и система UI в нем должна быть гибкой и удобной.
"Что ж, почему бы не убить двух зайцев одновременно?" - подумал я.
У меня был простой рендер спрайтов и текста, простая система обработки ввода, из которой можно было получать информацию о мышке и нажатых клавишах, и всякие утилиты-обвязки вспомогательных систем движка. В общем какую-то простую картинку вывести я мог. В последствии это все очень сильно изменилось и поросло архитектурными хитростями. Думаю не стоит описывать всю их эволюцию, а сосредоточиться лишь на финальном виде.
Сейчас система UI непосредственно держится на следующих вещах:
* Рендер
* Система обработчиков кликов
* Иерархия сцены
* Система UI-виджетов
Остановимся на каждом по отдельности.
Рендер
------
Все UI-элементы рисуются с помощью двух примитивов: спрайт и текст. Они в свою очередь рисуются мешами из треугольников. То есть каждый спрайт или текст - это набор треугольников на плоскости с наложенной на них текстурой.
Так же для отрисовки UI необходимо отсечение по прямоугольнику - внутри всяких списков, полей ввода и т.д.
Рендеринг треугольников происходит с применением батчинга (группировки): меши, попадающие на отрисовку с одинаковой текстурой и отсечением, группируются в большие меши, с целью оптимизации отправки данных на видеокарту. Если каждый маленький меш рисовать отдельно (draw call), то видеокарта будет простаивать, пока процессор готовит команды для нее, что и как рисовать. Поэтому на старых графических API меши группируются, дабы уменьшить кол-во запросов к видеокарте.
### Спрайт
В простом виде спрайт - это картинка, имеющее какое-то положение на экране. По сути два треугольника, объединенные в квадрат с наложенной текстурой. Однако такой простой спрайт имеет недостаток: если его начинать растягивать, то он начинает плыть, очертания форм нарушаются и скругленные края кнопки уже становятся овальными.
Чтобы избежать этого используются 9-slice спрайты. Это те же спрайты, но разделенные на 9 частей:
В таком спрайте, при изменении размера, углы всегда остаются оригинального размера, зоны по краям растягиваются в одном направлении, а зона посередине тянется во всех направлениях. Это позволяет использовать компактные спрайты для кнопок и других прямоугольных примитивов, а так же растягивать как угодно без потерь качества и формы объектов.
Уже здесь есть нюанс - как должен вести себя спрайт, если его размер стал меньше размера углов? Размеры углов (и сторон) должны пропорционально уменьшаться. Это позволяет вписывать любой спрайт в любые размеры, а так же более-менее адекватно соединять скругленные части. Последнее оказывается очень полезно при отрисовке прогресс-баров с закругленными краями.
Кроме этих двух режимов есть и другие, которые применяются реже, но иногда нужны:
Много гифок с режимами спрайтаПростой спрайт, просто растягивается9-slice спрайт, растягивается пропорциональноПоказывает прогресс круговым заполнением Вертикальное заполнениеГоризонтальное заполнениеПовторение текстурыСохранение соотношения сторон и вписываниеГенерация меша для одного спрайта - довольно недорогая операция. Однако, если спрайтов тысячи, это становится дорого. Поэтому меши спрайтов кешируются и обновляются только при изменении трансформации спрайта или других его параметров.
Код спрайта можно посмотреть [здесь](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Render/Sprite.h#L16).
Текст
-----
Как уже описано выше, текст - это набор треугольников.
Здесь два основных вопроса:
* Получить текстуру с глифами символов
* Сформировать меш
Глифы можно получить двумя путями:
* Нарисовать самому в графическом редакторе или утилите, и сгруппировать в одной текстуре
* Рендерить глифы через FreeType из векторного шрифта
У меня в основном используется второй подход, т.к. он гибче и удобнее. Во-первых не нужно заботиться о размере шрифта, можно рендерить глифы любого размера. Во-вторых на глифы можно накладывать эффекты, такие как тень, обводка, градиент или что-то свое. В-третьих глифы рендерятся по мере необходимости, и динамично размещаются в текстуре-атласе. Если в подходе с заранее отрисованными глифами появляется проблема с китайскими языками, где тысячи иероглифов, то в подходе динамичной отрисовки глифов мы можем рендерить только нужные глифы.
Итак, мы так или иначе получили текстуру, в которой лежат глифы для нашего текста. Теперь необходимо сформировать его меш. Эта задача делится на два этапа:
* Формирование посимвольного описания расположения символов
* Формирование меша по сгенерированному ранее описанию расположения
Самое интересное конечно же первая часть. Здесь на входе поступает прямоугольник, в который необходимо вписать текст. А так же его форматирование: высота символов, цвет, выравнивание по горизонтали и вертикали, тип обрезания. Ну и конечно же сам текст. Алгоритм построчно размещает символы, начиная с точки соответствующей выравниванию. Учитываются межсимвольные расстояния, кернинг, межстроковые расстояния. Так же, если включен режим обрезания через окончание на "...", проверяется влезет ли следующий символ и производится замена на три точки.
Вторая часть по сути формирует пары из двух треугольников под каждый символ, назначая текстурные координаты соответствующие символу из текстуры.
Здесь важный нюанс - строить новый текст очень дорого и затратно. Поэтому если текст передвинулся на Х пикселей в сторону, текст не перегенерируется заново, достаточно сместить вершины меша на Х пикселей.
Код текста можно посмотреть [здесь](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Render/Text.h#L18).
IRectDrawable
-------------
Чтобы унифицировать отрисовку спрайта и текста, у них есть общий интерфейс [IRectDrawable](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Render/RectDrawable.h#L13). Он отображает некую сущность, которая описывается прямоугольником (а точнее матрицей трансформации 2х3), которая может быть нарисована, может быть включена или выключена, и имеет цвет. Сам IRectDrawable наследуется от [IDrawable](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Render/IDrawable.h#L12) (сущности которая может быть нарисована) и [Transform](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Utils/Math/Transform.h#L15) (описывает трансформацию объекта матрицей 2х3, или [Basis](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Utils/Math/Basis.h#L11)).
Отсечение
---------
На первый взгляд довольно простая задача, отдал в [Graphic API](https://en.wikipedia.org/wiki/Category:3D_graphics_APIs) прямоугольник для отсечения, затем сбросил, и все готово. Все и правда так просто, однако в случае вложенных UI виджетов расчет итогового прямоугольника может быть нетривиален. Например, у нас есть прокручиваемая область, у которой есть видимая зона, вне которой все отсекается. Внутри нее может быть еще одна прокручиваемся зона или поле ввода текста, внутри которого тоже есть отсечение. И иногда эти вложенные зоны отсечения выходят за пределы более верхнеуровневого отсечения, и приходиться рассчитывать пересечение этих зон. Самому делать это вручную довольно сложно, нужно постоянно обращаться вверх по иерархии объектов и пытаться узнать у них их зону отсечения, если такая вообще есть.
Но все это можно решать с помощью стека прямоугольников отсечения на уровне системы рендера. Алгоритм прост: мы добавляем прямоугольник в стек, обновляя текущий прямоугольник отсечения. Текущий получается как пересечение предыдущего и нового. И добавлять можем сколько угодно. Затем извлекаем прямоугольники по одному, восстанавливая промежуточные посчитанные прямоугольники.
То есть сначала родительский элемент в начале отрисовки добавляет прямоугольник отсечения, без каких-либо расчётов. Затем рисуются виджеты-дети, которые добавляют в начале отрисовки свои отсечения. На каждом уровне текущий прямоугольник пересчитывается с учетом предыдущего. Затем, в конце отрисовки каждый виджет извлекает из стека свой прямоугольник отсечения.
Получается все просто - каждый элемент заботится только о своем отсечении, но в итоге получается что они взаимосвязаны.
Забегая вперед скажу еще что интерфейс IDrawable в момент отрисовки запоминает текущий прямоугольник отсечения, чтобы затем корректно отметать клики по этим объектам вне зоны отсечения.
Обработка ввода
---------------
Итак, у нас есть возможность что-то нарисовать. Теперь хочется сделать это интерактивным - дать возможность потыкать курсором в эти рисуемые сущности.
На входе у нас есть информация о курсоре (нескольких точнее, для touch-screen), событиях нажатия курсора, движения, отпускания. А так же рисуемые в определенном порядке сущности. Наша задача понять в кого нажимает пользователь.
Здесь есть пара нюансов. Во-первых, как описано выше, отсечение. Если спрайт отсекается, то нажатие по его отсеченной части не должно срабатывать. Во-вторых - это перекрытие спрайтов друг другом. Очевидно нажиматься должно то, что нарисовано выше всех остальных под курсором, собственно что и видит конечный пользователь.
Для обработки кликов от пользователя есть специальный интерфейс [CursorAreaEventsListener](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Events/CursorAreaEventsListener.h#L15). В нем есть солидная пачка виртуальных функций, которые вызываются на реакцию пользователя. Здесь клики, вход и выход курсора, для разных курсоров и клавиш мышки. А так же есть система, которая занимается правильной рассылкой этих сообщений [EventsSystem](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Events/EventSystem.h#L24), основной частью которой является [CursorAreaEventListenersLayer](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Events/CursorAreaEventsListenersLayer.h#L10).
Как же правильно понять в кого именно попал курсор? Не отсечен ли этот объект под курсором? Не перекрыт ли другим? Обычно это решается на уровне иерархии. Допустим, пришел ивент о том что пользователь нажал кнопку мыши. Начинаем с верхнеуровневых объектов, спрашиваем не попал ли курсор в них, не попал ли в отсеченную часть. Если попали - идем ниже по иерархии, спрашиваем то же самое у детей, и ниже и ниже, пока не доберемся до последней, которая скажет что в нее попали, и уже у нее вызовем соответствующий ивент на нажатие курсора.
У этого подхода есть ряд минусов. Элементов могут быть тысячи, и на каждый кадр перебирать иерархию довольно дорого. Плюс дети должны быть всегда внутри родителей, иначе ребенок не получит сообщение, т.к. не попали в родителя. Или же придется отказаться от этой оптимизации и просчитывать вообще все дерево, что еще дороже. Здесь еще ряд минусов, такие как сложная реализация "сквозных" ивентов, например когда клик должна принять и прокручиваемая область, и кнопка внутри нее.
На самом деле для обработки ввода у нас есть много информации по ходу отрисовки. Ведь по сути они очень связаны, порядок отрисовки определяет перекрытие, и прямоугольник отсечения так же рассчитывается в стеке.
Поэтому я применил другой подход, нежели обход иерархии. При отрисовке сущности, которая обрабатывает сообщения курсора, она сообщает системе ввода что сущность отрисовалась в данный момент. Система ввода хранит линейный список таких отрисованных сущностей, в порядке их отрисовки. Плюс, как уже писал выше, запоминаем актуальный прямоугольник отсечения для каждой сущности. Так же у каждой такой сущности есть виртуальный метод проверки попадания точки в эту сущность. Этот метод очень простой и работает без учета всяких отсечений и т.п. По сути просто проверка попадания в прямоугольник для IRectDrawable.
Поочередная отрисовка с перекрытиемДалее, после отрисовки сцены, происходит "трассирование" каждого курсора. Мы идем с конца списка отрисованных сущностей, от последнего отрисованного к первому, проверяем что курсор попадает в прямоугольник отсечения, проверяем попадание в геометрию. Если все возвращает истину - курсор попадает в эту сущность, алгоритм останавливается. Если нет, берем следующий с конца и снова проверяем.
Далее, имея данные о состоянии нажатия курсора, о том какая сущность была трассирована на предыдущем кадре, мы можем формировать сообщения о кликах, входе или выходе курсора.
Эта система работает быстро и стабильно при большом количестве объектов. При этом пользователю достаточно перегрузить функцию попадания точки в геометрию (что в большинстве случаев даже не нужно, если это IRectDrawable), и в момент отрисовки вызвать функцию IDrawable::OnDrawn(). Далее система автоматически рассылает нужные сообщения.
Иерархия сцены
--------------
В своем движке я выбрал типичный подход с иерархичной сценой с компонентами. Базовый элемент - [Actor](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Scene/Actor.h#L33), примитивный объект, у которого есть имя, трансформация, набор компонент, определяющих его поведение, и список дочерних Actor'ов. Они строятся в древовидную структуру на сцене. Сцена - это просто список Actor'ов.
Так же Actor'ы могут быть разных типов. То есть это просто базовых интерфейс, от него можно унаследоваться и реализовать свою логику. Это можно сделать и с помощью компонент, но в отличие в том, что компонента не является главной сущностью, она вспомогательная, и их может быть несколько на Actor'е.
Система UI строится на базе этой иерархии сцены. То есть все виджеты, все элементы UI - это наследники Actor'а. Но у них есть один общий интерфейс [Widget](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Scene/UI/Widget.h#L25).
Widget
------
Это самый элементарный "кирпичик" системы интерфейсов. Если Actor описывается простой трансформацией, включающей в себя позицию, поворот, размер и скейл, то положение Widget'а описывается более сложной структурой и уже зависит от родителя.
Положение Widgеt'а описывается структурой [WidgetLayout](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Scene/UI/WidgetLayout.h#L16), которая является наследником от [ActorTransform](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Scene/ActorTransform.h#L20). То есть это надстройка над обычными позицией, поворотом, размером и скейлом Actor'а.
Эта надстройка включает в себя относительные якоря и смещения от них. Якоря задаются в процентах и располагаются относительно родителя. Затем к этим якорям прибавляются смещения в пикселях. Это позволяет делать адаптивную верстку. Задавая якоря правильным образом можно добиваться растягивания дочерних элементов вслед за родителем, или наоборот "приклеивать" детей к определенным точкам, углам или центру. Аналогичный принцип применяется в [Unity GUI](https://docs.unity3d.com/Packages/com.unity.ugui@1.0/manual/UIBasicLayout.html).
WidgetLayer
-----------
Помимо обычной структуры дочерних Actor'ов, внутри Widget'а хранится список слоев [WidgetLayer](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Scene/UI/WidgetLayer.h#L25). Слой - это очень упрощенный Widget, который имеет на борту IRectDrawable и аналогичную WidgetLayout'у структуру с описанием адаптивного положения слоя [WidgetLayerLayout.](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Scene/UI/WidgetLayerLayout.h#L10)
Слоев может быть очень много, у слоев могут быть дочерние слои. За счет упрощения достигается оптимизация, т.к. этими более легковесными сущностями гораздо быстрее и проще оперировать.
Их вполне можно заменить дочерними Widget'ами, но это нарушит целостность понятия Widget'а. Например, кнопка воспринимается как кнопка, а не набор дочерних картинок. Окно воспринимается как контейнер других виджетов, и не хочется чтобы фон, заголовок и другие вспомогательные вещи были перемешаны с содержимым окна.
Поэтому слои - это графическая часть Widget'а, отделенная от дочерних Widget'ов.
WidgetState
-----------
Интерфейс не должен быть статичен и как-то реагировать на действия пользователя. При наведении курсора кнопка должна подсвечиваться, а при нажатии становиться темной. Списки должны разворачиваться, курсор ввода текста мигать и т.д. Желательно чтобы это все происходило плавно и красиво.
Для этого в Widget'е есть анимированные состояния - [WidgetState](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Scene/UI/WidgetState.h#L16)'ы. Они работают по принципу простой стейт-машины. Каждое состояние - это некая анимация, которая имеет два положения вкл. и выкл. При переводе во вкл. анимация проигрывается вперед, при переключении в выкл. анимация проигрывается назад. Причем, анимация может пойти в другую сторону не дождавшись окончания. За счет этого достигается быстрый отклик на действия пользователя.
Сами анимации вещь довольно сложная и для них можно написать отдельную статью. Но суть у них простая - они могут изменять любой параметр любого объекта внутри иерархии Actor'ов, включая Widget'ы, Layout'ы, WidgetLayer'ы и т.д. Здесь помогает собственная рефлексия, о которой когда-то уже [писал](https://habr.com/ru/post/277329/). Она позволяет искать нужные параметры по стоковым путям, например `children/0/transform/anchor`.
Каждый виджет может иметь набор таких состояний, и они могут включаться и выключаться отдельно друг от друга. Например, для кнопки можно задать такой список состояний
* курсор наведен - подсвечиваем кнопку
* кнопка нажата - затемняем кнопку
* кнопку в фокусе - показываем рамку вокруг
* скрытие и показ кнопки - плавное исчезновение и появление
Так как эти состояния работают через анимации, их можно делать сложными и составными, добавлять различные кривые плавности и т.д.
Эти состояния переключаются как изнутри Widget'ов, так и доступны для переключения извне.
Внутренние Widget'ы
-------------------
Иногда бывает ситуация, когда внутри одного Widget'а может находиться другой Widget, но при этом не хочется чтобы он был виден как дочерний. Например кнопка закрыть в виде крестика на окне. Окно - это отдельный цельный Widget, и кнопка закрыть ощущается как его часть. А дети окна - это уже содержимое собственно окна.
Реализовывать поведение кнопки закрытия можно и через слои, но это сложнее, чем просто добавить кнопку. Поэтому Widget'ы, кроме списка дочерних Widget'ов, имеют список "внутренних" Widget'ов. Которые ведут себя точно так же как и дочерние, разве что не отображаются вместе с реальными дочерними Widget'ами в иерархии.
Layout-Widget'ы
---------------
Это специальные Widget'ы, отвечающие за определенные алгоритмы расположения дочерних Widget'ов. Например, [HorizontalLayout](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Scene/UI/Widgets/HorizontalLayout.h#L10) раскладывает своих детей в линию по горизонтали. Аналогично работает [VerticalLayout](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Scene/UI/Widgets/VerticalLayout.h#L10), только раскладывает по вертикали. А так же есть [GridLayout](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Scene/UI/Widgets/GridLayout.h#L10), который раскладывает равномерной сеткой.
Комбинация Horizontal/VerticalLayoutУ этих Layout'ов можно настраивать точку отсчета (от угла, середины), расстояние между элементами, растягивать ли элементы по горизонтали или вертикали. Эти настройки позволяют покрыть практически все возможные вариации с адаптивной версткой.
Пример адаптивной верстки в редакторе параметров Алгоритм у этих Layout'ов такой:
* Рекурсивно рассчитываем размеры дочерних Widget'ов. То есть как бы заглядываем в будущее, какого размера они будут. За основу берем минимальный размер элементов
* Рассчитываем пространство, которое дочерние элементы могут занять. Берем текущий размер Layout'а, вычитаем все минимальные размеры дочерних элементов, вычитаем промежутки между ними. Получается "пространство, которое можно распределить"
* Пытаемся распределить это свободное место между элементами. Но если для какого-то элемента этого пространства оказывается слишком много, то есть у него ограничен максимальный размер, он исключается из алгоритма и пространство распределяется уже без него
* Получив конечные размеры дочерних элементов, им проставляются соответствующие параметры WidgetLayout
Типы Widget'ов
--------------
На базе этого простого элемента системы UI строится масса других типов элементов, каждый из них реализует определенную логику. Стоит отметить, что базовый Widget не умеет обрабатывать сообщения ввода. Если Widget должен реагировать на ввод пользователя, он дополнительно наследуется от соответствующих интерфейсов [KeyboardEventsListener](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Events/KeyboardEventsListener.h#L11), [CursorAreaEventsListener](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Events/CursorAreaEventsListenersLayer.h#L10).
На данный момент поддерживается следующий список типов:
* Кнопка
* Checkbox
* Поле ввода текста, однострочное и многострочное
* Выпадающий список
* Список
* Изображение
* Надпись
* Зона прокрутки
* Горизонтальный/вертикальный progress-bar
* Горизонтальный/вертикальный scroll bar
* Спойлер
* Окно
### Попапы
Попап - это часть интерфейса, которая рисуется поверх всего остального. Для них существует отдельный алгоритм отложенной отрисовки.
Все попапы наследуются от общего класса [PopupWidget](https://github.com/zenkovich/o2/blob/b5cfe57a6a61a381920f3d29df76f4fee0d49300/Framework/Sources/o2/Scene/UI/Widgets/PopupWidget.h#L11). К попапам так же относятся контекстные меню. Внутри в виде статичной переменной хранится текущий видимый попап. Именно он рисуется в отложенном рендеринге сцены. Так же сам попап может содержать дочерний попап, который будет рисоваться вместе с этим отложенным попапом. Это применяется, например, в контекстных меню: некоторые пункты могут открывать подпункты меню, которые являются дочерними попапами.
Иерархичное контекстное менюТак же попапы умеют автоматически закрываться при клике снаружи, закрывая все свои дочерние попапы.
Бонус: anti-aliased линии
-------------------------
Иногда в редакторе нужно рисовать линии и кривые. Те, кто пользовался OpenGL или D3D, знают, что по умолчанию линии рисуются с "лесенкой". Но я хотел себе гладкие линии.
Есть разные подходы к отрисовке графики а anti-aliasing'ом. Я решил попробовать один простой трюк: рисовать по краям линии полигоны, уходящие в нулевую альфу, то есть в плавно исчезающие. И так как эти края очень маленькие, но все же есть, при растеризации видеокарта выбирает некоторые полупрозрачные пиксели с краев основного тела линии, и получается эффект сглаживания.
Дешево в плане рендеринга, но тяжеловато в расчете таких мешей. Ведь есть еще проблема с острыми углами, и там получается 8 проверок пересечения лучей. Но это уже другая история. В целом результат после "подгона" параметров вполне хорош
Оптимизации
-----------
Итак, у нас есть система иерархии элементов, мы можем нарисовать все что угодно, оно умеет обрабатывать ввод и умеет адаптироваться к изменению размера. Графика уже вполне оптимизирована, меши кешируются, и не нужно постоянно перестраивать геометрию. Однако, элементов бывает очень много. Например, в моем редакторе их пара тысяч, плюс по несколько слоев на каждом из них. Да и вообще требования к мобильным играм довольно серьезные, кроме отрисовки и обработки интерфейса еще нужно нарисовать и обработать целую игру, 60 раз в секунду.
При этом и на десктопе редактор должен работать шустро, даже в отладочном режиме. Учитывая что С++ в режиме отладки обычно работает на порядок медленнее.
У меня есть большой опыт работы с Unity3D, и с интерфейсами в нем в частности. Если в Unity3D делать интерфейс "в лоб", то уже довольно скоро все начнет лагать, управление станет не отзывчивым, а процессор перегреется и начнет "[троттлить](https://ru.wikipedia.org/wiki/%D0%94%D1%80%D0%BE%D1%81%D1%81%D0%B5%D0%BB%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D1%82%D0%B0%D0%BA%D1%82%D0%BE%D0%B2)", ухудшая итак плохую производительность. И мне очень хотелось избежать такого же. Моей целью было сделать такую систему, которая при обычных задачах не требовала специальных оптимизаций или разделения на Canvas'ы, чтобы уменьшить перегенерацию мешей, как в Unity3D.
Собственно практически сразу, как я начал делать редактор, я столкнулся с проблемой производительности. И это произошло при разработке окна дерева сцены. Дело в том, что на сцене может быть несколько тысяч Actor'ов, и нужно уметь рисовать иерархию для каждого из них. Первый вариант был простой - для всех развернутых нод дерева создается Widget. Конечно при достижении пары сотен развернутых нод оперирование ими занимало приличное время. Поэтому пришлось отсекать.
Отсечение невидимых Widget'ов
-----------------------------
Обычно, если в каком-то месте много Widget'ов, то большинство их них не видны. Это списки, деревья и зоны прокрутки. Очевидно то, что скрыто, можно не рисовать. И даже более - не обсчитывать в некоторых ситуациях.
Для начала отсечение невидимых. Как ни странно, отсечение на уровне графического API решает проблему частично, видеокарта не растеризует отсеченные прямоугольники и пиксели. Однако, мы все еще формируем батчи для них и отсылаем в видеокарту. На этом можно сэкономить.
Чтобы понять, что какой-то Widget скрыт, нужно знать зону отсечения его родителей, а так же свою полную площадь с учетом всех слоев и детей. При изменении трансформации или каких-либо параметров, эта площадь пересчитывается, начиная от самых конечных детей.
Далее, в Widget'е есть специальный метод CheckClipping, который определяет отсечен ли он. Здесь же еще одна оптимизация: проверка на отсечение в основном нужна при прокрутке, то есть при линейных сдвигах. Например, есть зона прокрутки с кучей дочерних Widget'ов. Обычно прокрутка происходит вверх-вниз или влево-вправо, и размеры элементов не меняются. Поэтому достаточно взять площадь элемента и просто сдвинуть ее на величину прокрутки.
Так же в длинных списках или деревьях не создаются Widget'ы под каждый элемент. Создается некий буффер элементов, и при прокрутке показываются только те, что попадают в поле видимости. Это позволяет делать списки с тысячами элементов, без сильных затрат памяти и процессора.
Будущие оптимизации
-------------------
Сейчас редактор в режиме отладки работает приемлемо, а в релизной сборке практически без лагов. Однако, весь интерфейс перерисовывается каждый кадр, что занимает процессор и видеокарту.
Здесь напрашивается оптимизация на статичные части интерфейса. Их можно отрендерить один раз, и затем кусочно перерисовывать измененные участки. Для этого я планирую применить подход с "грязными" областями. Если Widget как-то изменился, что требует его перерисовки, то он сообщает общей системе что его область загрязнена. Если таких Widget'ов несколько, их площадь суммируется, одним прямоугольников покрывающим все. Далее, если этот итоговый "грязный" прямоугольник нулевой, то просто ничего не рисуем, оставляем на экране предыдущий кадр. Если он не нулевой, то изначально включаем отсечение по этому прямоугольнику, а затем рисуем только те элементы, который с ним пересекаются.
Это будет работать хорошо, когда изменения будут небольшие и не частые, как в редакторе. Но в играх такая оптимизация будет только потреблять накладные ресурсы, т.к. в игровых интерфейсах много эффектов и они более чем вероятно постоянно будут обновляться.
Редактор
--------
Что было первое, курица или яйцо? Система интерфейсов или редактор этих интерфейсов? Да, редактор написанный на системе интерфейсов позволяет их редактировать. Даже есть отладочный режим, в котором видна иерархия редактора и там можно поисследовать редактор изнутри.
Сейчас редактор умеет практически все что нужно:
* Отображение иерархии сцены и Widget'ов в том числе. Отображение слоев и внутренних Widget'ов
* Визуальное окно редактирование верстки
* Окно настроек параметров Actor'ов
* Редактор анимаций
Заключение
----------
Сейчас система UI в довольно зрелом состоянии, она хорошо показывает себя в разработке редактора. Но еще много работы по улучшению и правке багов редактора.
В общей сумме на эту систему интерфейсов потрачено примерно 6 человеко-месяцев. Я вполне доволен тем что решил сделать свой велосипед. У меня есть опыт разработки подобного редактора на ImGUI, и могу сказать что чужое решение ограничивает, приходится тратить на его "допиливание" время, сопоставимо с написанием своего велосипеда.
*PS: Если кому-то интересно позаниматься разработкой движка для 2D игры, буду рад посотрудничать. Одному получается очень долго.* [*Репозиторий движка*](https://github.com/zenkovich/o2)*, и* [*тестового проекта на нем*](https://github.com/zenkovich/PetStory)*.* | https://habr.com/ru/post/521306/ | null | ru | null |
# Препарируем Яндекс-карты: «Вас поставили подслушивать, а Вы тут подглядываете». Информация о точках доступа Wi-fi используется для определения местоположения
 Эта статья в большей степени совсем не о яндекс-картах, а о способе прослушки траффика на symbian 9.
Итак, снифферов для 9 симбы я не нашел, однако острое ~~шило в ....~~ желание поковыряться в технологии определения местоположения без GPS меня не покидало.
Технология эксперимента
-----------------------
Сначала я решил рубить всё под корень, т.е под DNS.
А именно: прописать в свойствах подключения MTS-Internet свои левые DNS, которые будут отдавать на все хосты один и тот же IP с прокси и сниффером.
Но в процессе прописки левых резолверов меня ждал приятный сюрприз, я наткнулся на возможность прямо прописать прокси, что с радостью и сделал.
Так как IP у меня белый, процедура настройки прокси и снифера не заняла много времени и не потребовала сторонних серверов, а свелась лишь к перебросу портов с точки доступа на ноут.
В качестве прокси был выбран [freeproxy](http://www.handcraftedsoftware.org/), а сниффера — [wireshark](http://www.wireshark.org/).
Freeproxy внезапно оказался совсем не сложный, вся процедура свелась к прописке нужного порта и «from any to any» и не потребовала даже открытия хелпа.
Передаваемые данные
-------------------
Итак, начнем.
Сразу после старта программа шлёт все о об устройстве
`GET /startup?app_version=370&app_platform=s60v3&screen_w=240&screen_h=320&manufacturer=Nokia&model=E52-1&utf&uuid=222afe80620551cf7f03f33f44e28ba0&clid=43593 HTTP/1.1\r\n`
На что получает ответ
``> </fontxml version="1.0" encoding="UTF-8"?>
>
> <startup>
>
> <wap\_warning>0wap\_warning>
>
> <app cur\_app\_version="347" min\_app\_version="200">m.ya.ru/download/maps/update-mts/yandexmaps-s60v3.sisxapp>
>
> <changelog>
>
> changelog>
>
> <hellostr timeout="5">hellostr>
>
> <ui\_actions\_log events="0,1,4,5,6,7,8,9">1ui\_actions\_log>
>
> <banner timeout="5" url\_text="" phone\_text="" action\_url="" action\_phone="" call\_warning="" call\_counter="" banner\_timeout="32000" user\_inactive="32000" first\_timeout="32000">banner><maps\_updated>1249254602maps\_updated>
>
> <uuid>222afe80620551cf7f03f33f44e28ba0uuid>
>
> <operator>operator>
>
> <maps min\_map\_version="1" cur\_map\_version="5">
>
> <changes version="5">{бинарные данные}changes>
>
> <changes version="1">changes>
>
> maps>
>
> <openpos lat="55.454039" lon="37.3190485" zoomid="12" success="0" /><query\_hosts><host type="default">mts.mobile-partners.maps.yandex.nethost>query\_hosts><objectshowintervals><interval object="semaphores" min\_zoom="7" max\_zoom="17" /><interval object="userpoi" min\_zoom="10" max\_zoom="17" /><interval object="scaleline" min\_zoom="5" max\_zoom="17" />objectshowintervals>startup>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ответ содержит: информацию о версии приложения и ссылку на её скачку, информацию об изменении карты, сервер, координаты на которых приложение было закрыто в прошлый раз.
Пока ничего интересного.
Далее:
`GET /cellid_location/?lac=6315&cellid=54105&operatorid=01&countrycode=250&signalstrength=83&wifinetworks=0022B03EE503:-83,0022158EBB72:-43,0022154880FF:-75,0016B6AC649B:-91,00221548159C:-89&uuid=222afe80620551cf7f03f33f44e28ba0 HTTP/1.1\\r\\n`
А вот тут приложение шлёт не что иное, как MAC близжайших точек доступа.
//«ради вот этой строчки всё остальное и писалось»
На что приходят долгожданные координаты
``> </fontxml version="1.0" encoding="UTF-8"?>
>
> <location source="FoundByWifi">
>
> <coordinates latitude="55.4490813" longitude="37.1869310" nlatitude="55.5499704" nlongitude="37.1885115" />
>
> location>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Виден источник их получения, и сами координаты.
Далее запрашиваются категории значков(ремонтные работы и дтп в окрестности пользователя).
``GET /userpoi/getcatlist?uuid=222afe80620551cf7f03f33f44e28ba0&ver=1 HTTP/1.1\\r\\n
> </fontxml version="1.0" encoding="windows-1251"?><catlist iconsversion="10" count="6"> <cat idx="0" name="ДТП" default\_show="1" editable="1">cat><cat idx="1" name="Дорожные работы" default\_show="1" editable="1">cat><cat idx="2" name="Камера" default\_show="0" editable="1">cat><cat idx="3" name="Прочее" default\_show="0" editable="1">cat><cat idx="4" name="Перекрытие" default\_show="0" editable="0">cat><cat idx="5" name="Разведение мостов" default\_show="0" editable="0">cat>catlist>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Потом идет отправка непонятой закриптованой пачки. Видимо путь, ответ не интересный. error=0
`(Chat/Sequence): POST /uiactionslog HTTP/1.1\r\n`
Далее обмен информацией превращается в что-то совсем не информативное
Отправка координат> OK> запрос POI> POI> отправка статистики(скорость координаты)> OK> запрос POI>…
Ну и иногда подгружаются участки карты.
Собственно в остатке:
* Яндекс собирает данные о wifi и использует их для определения местоположения
* Узнать как определить свое положение по БС оператора не удалось, может положение определяется совсем не по БС?
* Появились и вопросы.
Вопросы:
Как сэмулировать телефон с вставленной симкой или прослушать траффик на симбе или телефоне с java?
Как использовать, а главное получать данные о БС?
Куда стучится приложения для преобразования информации о БС в координаты?
Надеюсь услышать интересные вопросы и еще более интересные ответы.``` | https://habr.com/ru/post/102332/ | null | ru | null |
# Home видео для Selenium aka WebDriver. Или чем записать экран, если у вас есть java, поломанные тесты и немного времени
Решили мы на работе автоматизировать тесты для нескольких своих веб приложений. И кроме информации, когда упали тесты, захотелось еще и увидеть, как выглядела страница на этот печальный момент.
Я уже давно не брал в руки шашки и Selenium, поэтому пришлось немного покопаться в интернете и поискать — что в этой ситуации делают умные люди. Решение, которое меня устроило в итоге, собрало несколько технологий: Java + Selenium + Junit + Allure + ffmpeg + VideoRecorder (by Pirogov). Но поскольку я все таки честно копался, пытаясь найти лучшее решение проблемы, то нашлось еще несколько альтернативных моему и более простых способов — как можно сделать слепок экрана.
Поскольку найденная информация, раскидана по всему интернету, то иметь некоторый сжатый конспект в одном месте было бы, считаю, неплохо. По сути статья получилась как небольшая вводная для новичков. Которые озабочены той же самой проблемой — посмотреть глазами, что было или чего не было, когда автотесты выкинули красный флаг.
Давайте посмотрим, что нам предлагают сделать.
Как получить скриншот экрана
----------------------------
Самый первый вариант, который можно придумать для нашей проблемы — снимать скриншоты экрана. Т.е. подгадать момент, когда тест свалится, и получить картинку. Можно вообще на каждое действие снимать скриншот. Или снимать скриншот с некой периодичностью (например раз в полсекунды).
**[Способ 1. Selenium](https://github.com/SeleniumHQ/seleniumhq.github.io)**
Поскольку тесты многие пишутся на Selenium/WebDriver то было бы разумно использовать его методы. Например:
```
WebDriver driver = new FirefoxDriver(); driver.get("http://www.google.com/");
File scrFile = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);
FileUtils.copyFile(scrFile, new File("c:\\tmp\\screenshot.png"));
```
**[Способ 2. Selenide](https://ru.selenide.org/documentation/screenshots.html)**
Второй способ использовать обертки для Selenium, например Selenide. Этоn фреймворк упрощает работу с драйвером и кроме всего прочего делает скриншоты при возникновении ошибки автоматически и сам. По умолчанию скриншоты складываются в папку “test-result/reports”.
**[Способ 3. java.awt.Robot](https://docs.oracle.com/javase/7/docs/api/java/awt/Robot.html)**
Следующий способ — использовать вообще стандартный класс Java (с версии 1.3) для работы напрямую с операционной системой. Небольшой пример, как может выглядеть подобный код:
```
BufferedImage image = new Robot().createScreenCapture(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));
ImageIO.write(image, "png", new File("/screenshot.png"));
```
**Способ 4. Использование внешних программ**
Найти программу, которая делает скриншоты и использовать ее API. Такой способ конечно же есть, но в этом направлении я даже не копал.
**Способ 5. Использовать облачные технологии**
Если совсем на хочется заморачиваться, и деньги жгут ляжку вашему работодателю, то можно перейти на запуск тестов в облачных сервисах. Инфраструктура подобных сервисов вообще позволяет делать чудеса логирования, создания отчетов для запусков на разных операционных системах и в разных браузерах. В том числе доступно получения видео пройденных тестов. Сервисы не упоминаю специально — чтобы не рекламировать. Все гуглится.
Как получить видео экрана
-------------------------
С видео — несколько сложнее. Нельзя просто так взять и снять видео. Нужно немного поплясать.
Есть два основных способа танцев:
* Наделать скриншоты и конвертировать их в видео (далее способ 1)
* Сразу снимать видео (далее способ 2 и 3)
**Способ 1. Конвертация картинок в видео руками (на примере ffmpeg)**
Для получения видео можно сделать скриншоты с периодичностью в полсекунды и потом свести их в одно видео. Например при помощи библиотеки ffmpeg (https://ffmpeg.org/)
Для файлов с расширенем PNG, расположенных в одном каталоге, команда может выглядеть так:
```
ffmpeg -framerate 1 -pattern_type glob -i '*.png' \ -c:v libx264 -r 30 -pix_fmt yuv420p out.mp4
```
Можно добавить автоматизации и, например, сделать скрипт который запускает подобную команду по окончании тестов.
**[Способ 2. Рекордер видео — Monte Screen Recorder](http://www.randelshofer.ch/monte/)**
Другой способ создания видео — миновать этап создания скриншотов и использовать рекордеры сразу.
Первым, на который я наткнулся, был Monte Screen Recorder и ниже следует небольшой пример использования Java обертки для этого рекордера (https://github.com/stephenc/monte-screen-recorder):
```
GraphicsConfiguration gc = GraphicsEnvironment
.getLocalGraphicsEnvironment()
.getDefaultScreenDevice()
.getDefaultConfiguration();
screenRecorder = new ScreenRecorder(gc,
gc.getBounds(),
new Format(MediaTypeKey, MediaType.FILE, MimeTypeKey, MIME_AVI),
new Format(MediaTypeKey, MediaType.VIDEO, EncodingKey, ENCODING_AVI_TECHSMITH_SCREEN_CAPTURE,
CompressorNameKey, ENCODING_AVI_TECHSMITH_SCREEN_CAPTURE,
DepthKey, 24, FrameRateKey, Rational.valueOf(15),
QualityKey, 1.0f,
KeyFrameIntervalKey, 15 * 60),
new Format(MediaTypeKey, MediaType.VIDEO, EncodingKey, "black", FrameRateKey, Rational.valueOf(30)),
null,
new File(targetFolder));
screenRecorder.start();
```
Недостаток данного рекордера в том, что для просмотра видео вам понадобится установленный на компьютере кодек TSC (https://www.techsmith.com/products.html).
**Способ 3. Рекордер — ffmpeg**
Вторым рекордером на который я наткнулся, была наиболее известная и широко используемая библиотека ffmpeg. Я уже приводил пример ее использования для конвертации картинки в видео. Для библиотеки есть несколько оберток. В итоге я остановился на [github.com/SergeyPirogov/video-recorder-java](https://github.com/SergeyPirogov/video-recorder-java).
Привлекла меня эта библиотечка тем, что обновления достаточно новые — значит проект живой и можно надеяться, что баги будут исправятся оперативно. Кроме этого обертка написана специально в поддержку нашей проблемы — снимать видео, когда тесты свалились. Самый простой способ использования — Java аннотации *[Video](https://habr.com/ru/users/video/)(name = «second\_test»)*
Например:
```
@Test
@Video(name = "second_test")
public void videoShouldHaveNameSecondTest(){
Thread.sleep(1000);
assertTrue(false);
}
```
Главное нужно не забыть, что по умолчанию обертка использует кодек Monte, а не ffmpeg. Поэтому не забудьте переопределить формат видео в файле конфигурации (можно посмотреть как это делается на центральной Git странице проекта)
Выводов не будет. Для себя я выбрал VideoRecorder (by Pirogov), но без использования аннотаций, а напрямую используя классы позволяющие стартовать и останавливать съемку видео. В следующей заметке планирую расписать этот способ
Было бы нечестно не сослаться на страницы, с которых честно украден код в исследовательских конечно же целях:
* [www.ontestautomation.com/creating-a-video-capture-of-your-selenium-tests-using-monte-screen-recorder](https://www.ontestautomation.com/creating-a-video-capture-of-your-selenium-tests-using-monte-screen-recorder/)
* [habr.com/ru/sandbox/67456](https://habr.com/ru/sandbox/67456/)
* [stackoverflow.com/questions/24961127/how-to-create-a-video-from-images-with-ffmpeg](https://stackoverflow.com/questions/24961127/how-to-create-a-video-from-images-with-ffmpeg)
* [github.com/stephenc/monte-screen-recorder](https://github.com/stephenc/monte-screen-recorder)
* [habr.com/ru/sandbox/67456](https://habr.com/ru/sandbox/67456/)
P.S.: Если вдруг совершенно случайно у вас завалялись идеи что еще можно сделать — нижайшая просьба добавлять ссылками или текстом в комментариях. Спасибо. | https://habr.com/ru/post/517446/ | null | ru | null |
# Отрабатываем Git hooks на автоматизации commit message
Привет, Хабр! В этой статье я расскажу о Git hooks и о том, как они могут помочь с некоторыми насущными кейсами организации создания commit’ов и commit message. Пост основан на реальном опыте из моей практики: как я упрощал то, что всем надоело делать руками. Я уверен, что хуки могут оказаться полезны почти каждому разработчику. Ведь все мы пишем в сообщении коммита чуть больше, чем «fixed what was broken», верно?
Обо мнеМеня зовут Роман Горбатенко, я Java-разработчик в компании DINS, на момент написания текста тружусь в команде Contact Center. Занимаюсь разработкой больше 3-х лет и прошел путь от личинки стажера до middle девелопера. Считаю Git одним из самых полезных инструментов. Многие не используют его возможности на полную, — надеюсь, мне удастся это немного исправить.
### Итак, о проблеме, для затравки
На прошлом месте работы релизный процесс включал в себя ручной сбор commit’ов, относящихся к задачам, которые входят в этот самый релиз (не правда ли, здорово?). В связи с этим, команда корабля решила облегчить себе жизнь и завести правило, по которому commit message должен обязательно (!) предваряться префиксом с названием ветки.
Известно, что любое повторяющееся действие порождает случайные ошибки. И вообще, программисты не любят в повторение, мы любим в оптимизацию. Выход был найден — работу по добавлению префикса возложили на механизм Git hooks.
Ниже я расскажу, как создать prepare-commit-msg хук, немного опишу типы хуков и принципы их работы для тех, кто ~~не знал~~ забыл, расскажу, как завести наконец правило написания сообщений commit’ов и даже его соблюдать. Помимо этого, приведу несколько полезных штук, которые я подметил в процессе исследования и дам ссылки на источники, которые меня вдохновляли.
На всякий случай: я не претендую на экспертность в вопросах Git и Git hooks, некоторые читатели Хабр могут и должны знать больше меня о данной теме. Я буду рад любой помощи и советам в комментариях. Участие в опросах в конце статьи поможет мне при написании следующей статьи о Git.
### О самих Git hooks и основных типах
Если вкратце, hook — кастомный скрипт, выполняющийся до или после событий вроде commit, push. Вот и все, действительно очень просто. Каждый проект после инициализации содержит папку .git/hooks, в которой Git ищет скрипты для выполнения при наступлении событий.
Хуки разделяются на клиентские (локальные) и серверные (удаленные). Локальные хуки не затрагивают мою команду, и их можно оптимизировать под себя как угодно.
На схеме ниже показано время действия части локальных и серверных хуков относительно основных событий — commit и push.
Локальные хуки бывают нескольких типов и срабатывают после создания commit’a:
1. pre-commit выполняется каждый раз при вызове git commit. На этом этапе можно выполнять различные проверки commit’ов.
2. prepare-commit-msg выполняется после pre-commit и позволяет работать с commit message (круто, то, что надо!)
3. commit-msg похож на prepare-commit-msg, но вызывается после того, как вы ввели commit message. Это, например, хорошая возможность высветить предупреждение разработчикам о том, что сообщение commit’a не соответствует принятым стандартам.
4. post-commit вызывается сразу после commit-msg хука. К примеру, так можно триггерить отправку письма начальнику после каждого commit’a.
Я перечислил не все типы хуков, но это и не является моей задачей. Больше информации содержит [данный гайд](https://www.atlassian.com/git/tutorials/git-hooks).
В статье я последовательно рассмотрю prepare-commit-msg и commit-msg.
Думаю, теории хватит. Наша цель практическая, больше информации вы сможете найти самостоятельно или по ссылкам на источники в конце статьи.
Про Git hooks на WindowsВ конце статьи будет дана ремарка на счет работы хуков на Windows, поскольку запуск скриптов написанных на Python немного отличается. За исключением этого момента, содержание статьи верно и для хуков на Windows
> Если в процессе прочтения вам не захочется разбираться, как устроены хуки, или удобнее смотреть в код целиком, переходите в [GitHub репозиторий](https://github.com/Elanlum/python_git_hooks) с кодом из этой статьи.
>
>
### Перейдем к имплементации
#### prepare-commit-msg hook
Для начала нужно определиться, на каком языке можно/нужно писать скрипты, которые будут исполняться как хуки. Строго говоря, писать можно на любом скриптовом языке, будь то Bash, Python, Ruby, Perl, Rust, Swift или Go.
Я пробовал Bash и Python, последний зашел больше, т.к. Bash крайне тяжело поддается с наскока, без опыта чтения/писания на нем. В статье приведены скрипты именно на Python, поскольку я могу ручаться за то, что в них написано.
Обозначать, на каком языке написан скрипт, я буду специальным символом **шебанг** (#!), за которым следует путь до интерпретатора конкретного языка. В случае с **Mac** или **Linux** стандартный путь к интерпретатору для Python представлен */usr/bin.*
Итого получается:
```
#!/usr/bin/python3
```
Для Bash путь чуть другой:
```
#!/bin/bash
```
Уже почти время написать наш хук.
Сформулирую задачу: название ветки содержит буквенно-численный номер Jira тикета. Регистр не важен, помимо этого номера название ветки может содержать и другую информацию.
Ниже я реализую скрипт, который из ветки вида «ABC-123-bugfix» вытащит префикс вида «ABC-123», затем из commit message вида «initial commit message» сделает итоговое сообщение «[ABC-123] initial commit message».
#### Механизм работы моего prepare-commit-msg hook
Для лучшего понимания идеи ниже приведена схема, которая повторяет формулировку задачи:
Ниже находится листинг самого скрипта prepare-commit-msg hook:
```
1 #!/usr/bin/python3
2
3 import re
4 import sys
5 from subprocess import check_output
6
7 commit_msg_filepath = sys.argv[1]
8 branch = (
9 check_output(["git", "symbolic-ref", "--short",
10 "HEAD"]).decode("utf-8").strip()
11 )
12
13 regex = r"^[A-Z]{1,9}-[0-9]{1,9}"
14
15 found_obj = re.match(regex, branch)
16
17 if found_obj:
18 prefix = found_obj.group(0)
19 with open(commit_msg_filepath, "r+") as f:
20 commit_msg = f.read()
21 if commit_msg.find(prefix) == -1:
22 f.seek(0, 0)
23 f.write(f"[{prefix}] {commit_msg}")
```
Разберу построчно, что же тут происходит.
* Line 1 — шебанг.
* Lines 3-5 — блок импортов.
* Line 7 — получение файла, в который сохраняется изначальное commit message.
* Lines 8-10 — получаем имя ветки.
* Line 13 — регулярное выражение, по которому я сверяю, что имя ветки содержит название Jira-тикета вида **ABC-123.**
* Lines 15 — по регулярке получаем сам префикс (ветка может помимо тикета содержать что-то еще, отсекаем лишнее).
* Lines 17-18 — читаем текст commit message.
* Line 21 — проверяю, что сообщение коммита уже не содержит префикс, который я собираюсь добавлять.
* Line 22 — устанавливаем «каретку» в начало текстового файла, у нас ведь префикс.
* Line 23 — заключаем наш префикс в [ ] перед исходным сообщением.
Дополнительно отмечу лишь один момент — проверка на наличие префикса необходима, поскольку редактирование commit message средствами той же Intellij Idea приводит к повторному появлению префикса. Я совсем этого не хочу.
#### Результат выполнения prepare-commit-msg hook
Создам commit с сообщением и увижу в результате префикс, который добавлен хуком:
```
(base) ➜ python_git_hooks git:(ABC-123) ✗ git commit -m "my commit message"
[ABC-123 c80a30a] [ABC-123] my commit message
1 file changed, 1 insertion(+), 1 deletion(-)
```
Результат команды git log для последнего commit:
```
commit c80a30a163ac08cbdcb7a345b91823870dc8b184 (HEAD -> ABC-123)
Author: Elanlum
Date: Thu Oct 21 12:11:56 2021 +0300
[ABC-123] my commit message
```
#### commit-msg hook
На примере данного хука я продемонстрирую еще один способ автоматизации commit message.
Представим, что тимлид устал читать одинаково бессмысленные сообщения коммитов других разработчиков и решил группировать их по ключевым словам. Для этого он предложил ввести правило — писать в сообщении, о чем коммит — Fix, Update, Rework и так далее.
С этой задачей отлично справится Git hook — он будет сообщать разработчикам об ошибке в случае, если они забыли добавить в сообщение ключевое слово.
```
#!/usr/bin/python3
import re
import sys
green_color = "\033[1;32m"
red_color = "\033[1;31m"
color_off = "\033[0m"
blue_color = "\033[1;34m"
yellow_color = "\033[1;33m"
commit_msg_filepath = sys.argv[1]
regex = r"Add: |Created: |Fix: |Update: |Rework:"
error_msg = "Commit message format must match regex " + regex
with open(commit_msg_filepath, "r+") as file:
commit_msg = file.read()
if re.search(regex, commit_msg):
print(green_color + "Good Commit!" + color_off)
else:
print(red_color + "Bad commit " + blue_color + commit_msg)
print(yellow_color + error_msg)
print("commit-msg hook failed (add --no-verify to bypass)")
sys.exit(1)
```
Механизм работы: проверяем наличие ключевого слова в тексте сообщения коммита. Если совпадение найдено, хвалим программиста, если нет, напоминаем ему о забывчивости и отменяем создание коммита.
#### Результат выполнения commit-msg hook
В случае отсутствия одного из «тэгов» хук сообщает, что нам нужно его добавить и НЕ создает коммит. Также он сообщает, что этот механизм можно обойти.
```
➜ git commit -m "text of commit"
Bad commit [ABC-123] text of commit
Commit message format must match regex Add: |Created: |Fix: |Update: |Rework:
commit-msg hook failed (add --no-verify to bypass)
```
В случае, если тэг присутствует, хук хвалит разработчика за заботу о нервах тимлида.
```
➜ git commit -m "Rework: text of commit"
Good Commit!
[ABC-123 e993c7a] [ABC-123] Rework: text of commit
1 file changed, 1 deletion(-)
```
### Включаем хуки
Как я уже отмечал выше, работа Git hooks на Windows немного отличается, потому рассмотрим в отдельности системы.
Для начала текст скриптов описанных выше нужно скопировать в файл с соответствующим именем, без расширения.
#### Mac OS и Linux
**1.** Сделать файл хука исполняемым. Это очень просто:
```
chmod +x /path_to_hooks/hook_name
```
**2.** Поместить файл хука в папку проекта или общую папку.
После создания хука нужно сделать так, чтобы Git для вашего проекта мог им воспользоваться. Существует 2 способа добавить хуки на исполнение:
**A.** Поместить их в специальную директорию .git/hooks в каждый (!) проект. Эта директория уже содержит файлы хуков с расширением .sample. Достаточно убрать .sample и вставить в файл скрипт, как все заработает.
> Еще раз: Git hook должен называться точно так же, как .sample файл, но не иметь расширения. Проще всего заменить содержимое .sample файла и затем убрать расширение
>
>
Можно представить, как это неудобно — каждый раз для нового проекта добавлять хуки заново. Я вроде бы хотел избавиться от повторяющихся действий, разве нет?
**B.** Существует и второй способ, более элегантный, если подразумевается, что ваши хуки применимы для всех проектов. Нужно добавить в глобальный конфиг Git параметр **core.hooksPath**, значение которого содержит путь до глобальной папки с хуками, откуда Git будет все тянуть в первую очередь.
Команда довольно простая и многим знакомая:
```
git config --global core.hooksPath /your_path_to_hooks_folder
```
Проверим, что конфиг сохранился:
```
git config --global --list
```
И увидим в списке глобальных переменных что-то вроде:
```
core.hookspath=/usr/local/.../git/hooks
```
Таким образом, все старые и новые проекты будут пользоваться преимуществами добавленных в общую директорию хуков.
**3.** Git hooks добавлены и готовы к работе. Вы восхитительны!
#### Windows
Все приведенное выше так же верно для хуков на Windows за исключением того, что скрипт написанный на Python не может так просто запускаться в качестве Git hook, поскольку Windows не может идентифицировать интерпретатор Python с помощью шебанга.
Выход есть — можно сделать shell скрипт, который будет запускать Python скрипт. Нужно всего-то несколько действий:
**1.** Сделать собственно сам shell скрипт:
```
#!/bin/sh
COMMIT_MSG_FILE=$1
python .git/hooks/prepare-commit-msg.py "$COMMIT_MSG_FILE"
```
Нам нужен соответствующий шебанг - **#!/bin/sh**
Аргумент **COMMIT\_MSG\_FILE** содержит путь до временного текстового файла, который содержит commit message, нам нужно передать этот путь дальше Python скрипту, который выполнит основную работу.
**2.** Убедиться, что shell скрипт исполняемый, его имя соответствует названию хука и не содержит расширения.
**3.** Нужно удалить шебанг для интерпретатора Python из скрипта (например, у меня это prepare-commit-msg.py) и поместить сам Python файл рядом с самим Git hook.
### Полезные замечания
Смысл решения в том, чтобы держать описанные выше хуки локально. Не думаю, что добавлять хуки в репозиторий и версионировать их — хорошая идея. На это есть причины:
* Может случиться так, что программист не будет знать, что у него под капотом орудует хук и что-то правит.
* Пути до интерпретаторов разные на разных системах (Python на Windows запросто может не быть), значит нельзя гарантировать, что хуки будут работать у всех разработчиков в команде из коробки.
* Добавлять хуки во много проектов = превратить их поддержку в итеративный ад (я все еще хочу избежать повторяющихся действий).
Думаю, читатель уже догадался, что для работы Git hooks на Windows (и некоторых сборок Linux) понадобится установить Python 3, на Mac OS он имеется по умолчанию. Проверял работоспособность на версии 3.9, но и с более ранними проблем не возникнет.
Для того, чтобы адаптировать префикс под свои нужды, нужно в Python скрипте изменить итоговое сообщение, которое пишется в файл commit message.
### Полезные ссылки
* Обязательно зацените [GitHub репозиторий с хуками](https://github.com/Elanlum/python_git_hooks) из этой статьи.
* Довольно подробная [документация Atlassian](https://www.atlassian.com/git/tutorials/git-hooks), где можно подробнее узнать о всех типах хуков, посмотреть идеи для использования и примеры реализации на Python.
* Неплохая [статья с примерами на Bash](https://codeburst.io/understanding-git-hooks-in-the-easiest-way-bad9afcbb1b3), отсюда я взял пару идей, это помогло на начальном этапе.
* Для всех начинающих, забывчивых или юзающих Git только через любимую IDE — вот [отличный тренажер](https://learngitbranching.js.org/?locale=ru_RU) для развития понимания Git.
### Вместо заключения
Это моя первая статья и мне не терпится поделиться знаниями с аудиторией Хабра. Если статья зайдет, я пойму, что можно продолжить разговор и придумать еще интересные кейсы использования хуков. Возможно, вы сможете подкинуть идеи в комментариях. | https://habr.com/ru/post/584562/ | null | ru | null |
# Расширяем и улучшаем Cache в ASP.NET
Про ASP.NET-объект [Cache](http://msdn.microsoft.com/ru-ru/library/system.web.caching.cache.aspx "Описание класса") наверняка знает каждый web-разработчик на платформе .NET. Совсем не странно, ведь это единственное решение для кэширования данных web-приложения в ASP.NET, доступное прямо из коробки.
Достаточно функциональный и легкий, снабженный механизмами приоритета, вытеснения, зависимостей и обратных вызовов, Cache хорошо подходит для небольших приложений, работая внутри AppDomain. Кажется, Microsoft предусмотрела все, что необходимо… Но я, тем не менее, хочу сделать его еще немного лучше. Чем же именно?
### Синхронизация обновлений
Закэшированным данным, как и многому в нашем мире, со временем свойственно терять актуальность. Поэтому, по истечении отведенного интервала времени или при изменении одной из зависимостей, сохраненный элемент исчезнет из кэша, и нам придется положить его туда заново. MSDN [расскажет](http://msdn.microsoft.com/ru-ru/library/xhy3h9f9.aspx) нам, как это сделать, и мы напишем так:
> `List products;
>
> products = (List)Cache["Products"];
>
> if (products == null)
>
> {
>
> products = db.Products.ToList();
>
> Cache.Insert("Products", products);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все выглядит правильно, но ровно до тех пор, пока мы не осознаем, что код может выполняться одновременно в нескольких потоках. И в этих нескольких строчках мы только что организовали классическое состояние гонки (race condition). Ничего страшного, конечно, не произойдет, просто элемент кэша будет обновлен несколько раз, и каждый раз для этого мы обратимся к базе данных. Но это лишняя работа, и ее можно избежать, применив обычную double-check блокировку. Вот так:
> `private static object \_lock = new object();
>
>
>
> ...
>
>
>
> object value;
>
> if ((value = Cache["Products"]) == null)
>
> {
>
> lock (\_lock)
>
> {
>
> if ((value = Cache["Products"]) == null)
>
> {
>
> value = db.Products.ToList();
>
> Cache.Insert("Products", value);
>
> }
>
> }
>
> }
>
> var products = (List)value;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Таким образом, мы гарантируем, что только один поток отправится в базу данных за списком товаров, а остальные подождут его возвращения. Можно писать такой код всякий раз, когда мы работаем с кэшем, но лучше реализовать расширение объекта Cache при помощи extension-метода.
#### Итак,
> `public static T Get(this Cache cache, string key, object @lock, Func selector,
>
> DateTime absoluteExpiration)
>
> {
>
> object value;
>
> if ((value = cache.Get(key)) == null)
>
> {
>
> lock (@lock)
>
> {
>
> if ((value = cache.Get(key)) == null)
>
> {
>
> value = selector();
>
> cache.Insert(key, value, null,
>
> absoluteExpiration, Cache.NoSlidingExpiration,
>
> CacheItemPriority.Normal, null);
>
> }
>
> }
>
> }
>
> return (T)value;
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Если в кэше нашелся элемент с заданным ключом, метод просто возвратит его, а в противном случае установит блокировку и выполнит загрузку. Конструкции `value = Cache.Get(key)` нужны для того, чтобы не получить такую же гонку при удалении элемента кэша в другом потоке. Теперь для получения нашего списка товаров мы можем написать только одну строку, а все остальное наше расширение возьмет на себя. Перегрузки можно добавить по вкусу :)
> `private static object myLock = new object();
>
> ...
>
> var products = Cache.Get<List>("Products", myLock,
>
> () => db.Products.ToList(), DateTime.Now.AddMinutes(10));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Итак, с одной задачей мы расправились, но есть еще кое-что интересное. К примеру, ситуация, когда необходимо объявить невалидными сразу несколько связанных элементов кэша. ASP.NET Cache предоставляет нам возможность создания зависимости от одного или нескольких элементов. Примерно так:
> `string[] dependencies = { "parent" };
>
> Cache.Insert("child", someData,
>
> new CacheDependency(null, dependencies));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И при обновлении элемента *parent* элемент *child* будет удален. Пока ничего не напоминает? Что ж, еще немного кода, и у нас появится полноценная…
### Поддержка тегов и групповой инвалидации
Подсистема тегирования будет работать вполне прозрачно, используя уже описанный механизм зависимостей от ключа в кэше. Такими ключами и будут — угадайте что? — теги. При добавлении в кэш элемента с некоторой коллекцией тегов мы создадим соответствующее количество ключей в кэше и зависимость от них.
> `public static CacheDependency CreateTagDependency(
>
> this Cache cache, params string[] tags)
>
> {
>
> if (tags == null || tags.Length < 1)
>
> return null;
>
>
>
> long version = DateTime.UtcNow.Ticks;
>
> for (int i = 0; i < tags.Length; ++i)
>
> {
>
> cache.Add("\_tag:" + tags[i], version, null,
>
> DateTime.MaxValue, Cache.NoSlidingExpiration,
>
> CacheItemPriority.NotRemovable, null);
>
> }
>
> return new CacheDependency(null, tags.Select(s =>
>
> "\_tag:" + s).ToArray());
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь в качестве значения версии тега я использую текущее время, как рекомендовалось в [статье о Memcached](http://habrahabr.ru/blogs/webdev/43539/), но в нашем случае сравнивать ничего не придется, этим займется ASP.NET. Теперь при добавлении элемента в кэш мы можем легко и просто создать зависимость от указанных нами тегов.
> `Сache.Insert("key", value, Сache.CreateTagDependency("tag1", "tag2"));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Осталось совсем немного — обеспечить сброс такой группы элементов в кэше. Для этого нужно всего лишь обновить элементы кэша, представляющие интересующие нас теги. Все остальное произойдет само собой.
> `public static void Invalidate(this Cache cache, params string[] tags)
>
> {
>
> long version = DateTime.UtcNow.Ticks;
>
> for (int i = 0; i < tags.Length; ++i)
>
> {
>
> cache.Insert("\_tag:" + tags[i], version, null,
>
> DateTime.MaxValue, Cache.NoSlidingExpiration,
>
> CacheItemPriority.NotRemovable, null);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Обратите внимание на то, что в методе, создающем зависимость от тегов, использовался метод `cache.Add`, а здесь — `cache.Insert`. Существенная разница между этими в остальном очень похожими методами в том, что первый записывает информацию в кэш только в том случае, если указанный ключ не был создан ранее, а второй — записывает в любом случае, затирая старые данные. Это различие очень важно в нашем случае, потому что при простом добавлении элемента в кэш нам не нужно обновлять уже существующие теги.
На этом, кажется, и все…
### Я требую продолжения банкета!
А продолжать тут еще есть куда. Например, можно доработать приведенный здесь метод Get так, чтобы вместо немедленного удаления данные кэша временно «переезжали» в другую ячейку, и вместо блокировки возвращать запрошенную информацию из нее, пока новые данные загружаются в кэш.
Можно вместо extension-методов сделать некую абстракцию провайдера кэширования и работать с любым хранилищем без изменения кода приложения или полностью отключать кэш при отладке, использовать IoC… да мало ли что!
И я надеюсь, что подходы, описанные в моей статье, окажутся полезными для вас ;)
**UPDATE**: Посмотрев незамыленным глазом на собственный код, я узрел в нем одну нехорошую вещь — блокировка при синхронизации выставлялась на весь кэш целиком. Поэтому я изменил extension-метод *Get* с тем, чтобы он принимал пользовательский объект для блокировки. | https://habr.com/ru/post/61617/ | null | ru | null |
# Интерфейс для Яндекс.Диска в Ubuntu 14.04
Как известно, Яндекс.Диск на Ubuntu существует только как консольный клиент. Сегодня я решил «хватит это терпеть» и написал для себя простенький скрипт, который значительно упрощает работу с ним (исходники внизу статьи).
Стоит пояснить, что данный скрипт писался для личного пользования, но знакомый уговорил выложить тут, поэтому такие вещи, как абсолютные адреса файлов, будут не абсолютными и вам стоит подправить их для собственной системы.
Для работы нам нужно только три файла:
1. Файл запуска для взаимодействия с пользователем
2. Bash скрипт для взаимодействия с клиентом
3. Иконка сервиса Яндекс.Диск
Начнем с BASH. Создаём в любом удобном месте файл **ya-disk.sh**:
```
#!/bin/bash
case $1 in
start) # Команда запуска
deamon=`yandex-disk start`
notify-send -i "$HOME/Розробка/yandex-disk/icon.png" "$deamon"
;;
stop) # Команда остановки
deamon=`yandex-disk stop`
notify-send -i "$HOME/Розробка/yandex-disk/icon.png" "$deamon"
;;
*) # Команда проверки статуса
deamon=`yandex-disk status`
if [[ "$deamon" == "Ошибка: демон не запущен" ]] # Проверяем состояние демона и если он не запущен - Запускаем.
then
deamon=`yandex-disk start`
notify-send -i "$HOME/Розробка/yandex-disk/icon.png" "$deamon"
else # Если демон уже запущен собираем информацию и выводим
status=`yandex-disk status | grep -o '^Статус ядра синхронизации: .*$' | grep -o ': .*$'`
all=`yandex-disk status | grep -o 'Всего:.*'`
nfree=`yandex-disk status | grep -o 'Занято:.*'`
free=`yandex-disk status | grep -o 'Свободно:.*'`
maxfile=`yandex-disk status | grep -o 'Максимальный размер файла:.*'`
trash=`yandex-disk status | grep -o 'Размер корзины:.*'`
if [[ "$status" == ": синхронизация" ]] # Если демон в процесе синхронизации
then
SUNC=`yandex-disk status | grep -o 'Статус синхронизации: .*' | grep -o '[^:]*$'`
notify-send -i "$HOME/Розробка/yandex-disk/icon.png" "Синхронизация" "Прогресс:$SUNC\n$all\n$nfree\n$free\n$maxfile\n$trash"
elif [[ "$status" == ": обработка данных" ]]; then # Если демон ведёт учет файлов
notify-send -i "$HOME/Розробка/yandex-disk/icon.png" "Статус$status"
else # Если демон простаивает
notify-send -i "$HOME/Розробка/yandex-disk/icon.png" "Статус$status" "$all\n$nfree\n$free\n$maxfile\n$trash"
fi
fi
;;
esac #окончание оператора case.
exit 0
```
Теперь создадим файл запуска.
Переходим по адресу, где лежат все наши ярлыки приложений:
```
cd /usr/share/applications/
```
Теперь создаем ярлык нашего нового приложения командой:
```
sudo gedit ya-disk.desktop
```
Со следующим содержанием:
```
[Desktop Entry]
Version=1.0
Type=Application
Name=Яндекс.Диск
Comment=Позволяет Запускать, останавливать и получать информацию о состоянии вашего Яндекс.Диска
Exec=/home/alex/Розробка/yandex-disk/ya-disk.sh
Terminal=false
Icon=/home/alex/Розробка/yandex-disk/icon.png
StartupNotify=true
Actions=Window;Document;
[Desktop Action Window]
Name=Запустить
Exec=/home/alex/Розробка/yandex-disk/ya-disk.sh start
OnlyShowIn=Unity;
[Desktop Action Document]
Name=Остановить
Exec=/home/alex/Розробка/yandex-disk/ya-disk.sh stop
OnlyShowIn=Unity;
```
Не забудьте изменить значение параметров **Exec** и **Icon**. Они должны вести на соответствующие файлы на вашем.
И последний штрих. Скачайте и разместите иконку по адресу, который указан в параметре **Icon**.
Для меня это:
```
/home/alex/Розробка/yandex-disk/icon.png
```
Вот и всё.
В Dash появится иконка Яндекс.Диск. Если вынести её на панель Unity, то правой кнопкой можно останавливать и запускать демон.
Обещанные [исходники](https://yadi.sk/d/iZav63aceLGpP). | https://habr.com/ru/post/249267/ | null | ru | null |
# Пишем свой отладчик под Windows [часть 1]
#### Вступление
Все мы, время от времени, используем дебаггер для отладки программ. Отладчик может использоваться с C++, C#, Java и ещё сотней других языков. Он может быть как внешним (WinDbg), так и встроенным в среду разработки (Visual Studio). Но вы хоть раз задавались вопросом, как же работает отладчик?
И вам повезло. В этом цикле статей мы разберёмся от и до, как же работает отладка изнутри. В этой статье рассматривается только написание отладчика под Windows. Без компиляторов, линковщиков и других сложных систем. Таким образом, мы сможем отлаживать только исполняемые файлы, так как мы напишем внешний отладчик. Эта статья потребует от читателя понимание основ многопоточности.
Как отлаживать программу:
1. Запустить процесс с флагом DEBUG\_ONLY\_THIS\_PROCESS или DEBUG\_PROCESS;
2. запустить цикл дебага, который будет отлавливать сообщения и события;
Прежде, чем мы начнём, запомните:
* Дебаггер — это процесс/программа, которая будет отлаживать другой процесс;
* отлаживаемая программа (ОП) – это процесс/программа, которая отлаживается;
* именно отладчик присоединяется к ОП. Также отлачик может подключаться к различным процессам (в разных потоках);
* отлаживать можно лишь те процессы, которые были запущены из под отладчика. Таким образом, CreateProcess и цикл отладчика должны находится в одном потоке;
* когда завершается процесс отладчика, то он также завершает ОП;
* Когда отладчик занят обработкой событий, он замораживает все потоки ОП на время. Об этом позже;
##### Запуск процесса с флагом отладки
Запускаем процесс с помощью функции CreateProcess и в шестом её параметра (dwCreationFlags) указываем флаг DEBUG\_ONLY\_THIS\_PROCESS. Этот флаг указывает Windows подготовить запускаемый процесс для отладки (отладочные события, старт/завершение процесса, исключения и т.п.). Более подробное объяснение чуть позже. Прошу обратить внимание, что мы будем использовать именно DEBUG\_ONLY\_THIS\_PROCESS. Это значит, что мы хотим отлаживать только тот процесс, который мы запускаем, а не ещё и порождаемые им.
```
STARTUPINFO si;
PROCESS_INFORMATION pi;
ZeroMemory( &si, sizeof(si) );
si.cb = sizeof(si);
ZeroMemory( π, sizeof(pi) );
CreateProcess ( ProcessNameToDebug, NULL, NULL, NULL, FALSE,
DEBUG_ONLY_THIS_PROCESS, NULL,NULL, &si, π );
```
После этого, вы должны увидеть новый процесс в диспетчере задач, но на самом деле, он ещё не запустился. Вновь созданный процесс пока ещё заморожен. Нет, не угадали, нам надо не вызвать ResumeThread, а написать отладочный цикл.
#### Отладочный цикл
Отладочный цикл – это сердце отладчика, и строится он вокруг функции WaitForDebugEvent. Она получает два параметра: указатель на структуру DEBUG\_EVENT и таймаут (DWORD). В качестве таймаута мы укажем INFINITE. Эта функция содержится в kernel32.dll, поэтому никаких дополнительных библиотек нам линковать не надо.
```
BOOL WaitForDebugEvent(DEBUG_EVENT* lpDebugEvent, DWORD dwMilliseconds);
```
Структура DEBUG\_EVENT включает в себя много отладочной информации: код события, ID процесса, ID потока и прикладную информацию о событии. Как только WaitForDebugEvent завершится и вернёт нам управление, мы получим сообщение отладчика, а после этого вызовем ContinueDebugEvent для продолжения выполнения кода. Ниже вы можете увидеть минимальный отладочный цикл.
```
DEBUG_EVENT debug_event = {0};
for(;;)
{
if (!WaitForDebugEvent(&debug_event, INFINITE))
return;
ProcessDebugEvent(&debug_event); // User-defined function, not API
ContinueDebugEvent(debug_event.dwProcessId,
debug_event.dwThreadId,
DBG_CONTINUE);
}
```
Вызывая ContinueDebugEvent, мы просим ОС продолжить выполнение ОП. dwProcessId и dwThreadId указывает нам на процесс и поток. Эти значения мы получили из WaitForDebugEvent. Последний параметр указывает, продолжить выполнение или нет. Этот параметр будет иметь значение только тогда, когда в отладку пришло исключение. Это мы рассмотрим позже. Ну а пока используем просто DBG\_CONTINUE (другое возможное значение – это DBG\_EXCEPTION\_NOT\_HANDLED).
#### Получение событий отладки
Есть девять основных событий отладки, и 20 подсобытий в категории исключений. Рассмотрим это, начиная с самого простого. Ниже приведена структура DEBUG\_EVENT:
```
struct DEBUG_EVENT
{
DWORD dwDebugEventCode;
DWORD dwProcessId;
DWORD dwThreadId;
union {
EXCEPTION_DEBUG_INFO Exception;
CREATE_THREAD_DEBUG_INFO CreateThread;
CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
EXIT_THREAD_DEBUG_INFO ExitThread;
EXIT_PROCESS_DEBUG_INFO ExitProcess;
LOAD_DLL_DEBUG_INFO LoadDll;
UNLOAD_DLL_DEBUG_INFO UnloadDll;
OUTPUT_DEBUG_STRING_INFO DebugString;
RIP_INFO RipInfo;
} u;
};
```
Когда WaitForDebugEvent успешно завершается, он заполняет эту структуру. dwDebugEventCode указывает, какое событие отладки к нам пришло. В зависимости от этого кода, один из членов union’a u содержит информацию о событии. Например, если dwDebugEventCode==OUTPUT\_DEBUG\_STRING\_EVENT, то верно заполнится тольк OUTPUT\_DEBUG\_STRING\_INFO.
#### Обработка OUTPUT\_DEBUG\_STRING\_EVENT
Для вывода текста в output, разработчики обычно пользуются функцией OutputDebugString. В зависимости от языка/фреймворка, который вы используете, вы должны быть знакомы с макросами TRACE/ATLTRACE. Разработчики .NET, возможно, знакомы с System.Diagnostics.Debug.Print/System.Diagnostics.Trace.WriteLine. Но все эти методы вызывают OutputDebugString, если объявлен макрос \_DEBUG, и отладчик получает сообщение.
Когда сообщение отладки получено, мы обрабатываем DebugString. Структура OUTPUT\_DEBUG\_STRING\_INFO представлена ниже:
```
struct OUTPUT_DEBUG_STRING_INFO
{
LPSTR lpDebugStringData; // char*
WORD fUnicode;
WORD nDebugStringLength;
};
```
Поле nDebugStringLength содержит в себе длину строки, включая завершающий null. Поле fUnicode равно нулю, если строка ANSI, и не равна нулю, если юникод. В этом случае, мы должны считывать nDebugStringLength x2 байт. Внимание! lpDebugStringData содержит указатель на строку с сообщением, но указатель ссылается на данные **относительно памяти отлаживаемой программы**, а не отладчика.
Чтобы прочитать данные из памяти другого процесса, нам необходимо вызвать ReadProcessMemory и у нас должно на это быть разрешение. Так как мы же и создали процесс для отладки, то проблем с разрешением нет.
```
case OUTPUT_DEBUG_STRING_EVENT:
{
CStringW strEventMessage; // Force Unicode
OUTPUT_DEBUG_STRING_INFO & DebugString = debug_event.u.DebugString;
WCHAR *msg=new WCHAR[DebugString.nDebugStringLength];
// Don't care if string is ANSI, and we allocate double...
ReadProcessMemory(pi.hProcess, // HANDLE to Debuggee
DebugString.lpDebugStringData, // Target process' valid pointer
msg, // Copy to this address space
DebugString.nDebugStringLength, NULL);
if ( DebugString.fUnicode )
strEventMessage = msg;
else
strEventMessage = (char*)msg; // char* to CStringW (Unicode) conversion.
delete []msg;
// Utilize strEventMessage
}
```
###### Что если ОП завершится во время считывания памяти?
Что ж, такого не будет Позвольте вам напомнить, что отладчик замораживает все потоки ОП во время отработки отладочного сообщения. Таким образом, сам себя процесс завершить не сможет, Ни один диспетчер задач (стандартный или нет) так же не сможет завершить процесс. Если попробовать, то в следующем сообщении наш отладчик получит событие EXIT\_PROCESS\_DEBUG\_EVENT.
#### Обработка CREATE\_PROCESS\_DEBUG\_EVENT
Событие появляется, когда ОП только запускается. Это должно быть первое сообщение, которое получает отладчик. Для этого сообщения, соответствующее поле DEBUG\_EVENT будет CreateProcessInfo. Ниже вы можете увидеть саму структуру CREATE\_PROCESS\_DEBUG\_INFO:
```
struct CREATE_PROCESS_DEBUG_INFO
{
HANDLE hFile; // The handle to the physical file (.EXE)
HANDLE hProcess; // Handle to the process
HANDLE hThread; // Handle to the main/initial thread of process
LPVOID lpBaseOfImage; // base address of the executable image
DWORD dwDebugInfoFileOffset;
DWORD nDebugInfoSize;
LPVOID lpThreadLocalBase;
LPTHREAD_START_ROUTINE lpStartAddress;
LPVOID lpImageName; // Pointer to first byte of image name (in Debuggee)
WORD fUnicode; // If image name is Unicode.
};
```
Обратите внимание, что hProcess и hThread могут отличаться от тех, которые мы получаем в PROCESS\_INFORMATION. ID процесса и потока должны быть теми же. Каждый хэндл, который вы получаете от Windows, отличается от остальных. Для этого есть различные причины.
hFile, так же как и lpImageName, может использоваться для получения имени файла ОП. Правда мы уже знаем имя этого файла, ведь мы его и запустили. Но расположение EXE или DLL нам важно знать, потому что при получении сообщения LOAD\_DLL\_DEBUG\_EVENT, хорошо бы знать имя библиотеки.
Как вы можете прочитать в MSDN, lpImageName никогда не содержит полное имя файла и оно будет содержаться в памяти ОП. Более того, не существует гарантий, что в памяти ОП будет также лежать полное имя файла. А ещё имя файла может быть неполный. Поэтому, мы будет получать имя файла из hFile.
#### Как получить имя файла из hFile
К сожалению, нам необходимо будет использовать метод, описанный в [MSDN](http://msdn.microsoft.com/en-us/library/aa366789(VS.85).aspx), который содержит примерно 10 вызовов функций. Ниже сокращённый вариант:
```
case CREATE_PROCESS_DEBUG_EVENT:
{
CString strEventMessage =
GetFileNameFromHandle(debug_event.u.CreateProcessInfo.hFile);
// Use strEventMessage, and other members
// of CreateProcessInfo to intimate the user of this event.
}
```
Вы могли заметить, что я не рассмотрел несколько полей этой структуры. В следующих частях мы рассмотрим это всё досконально.
#### Обработка LOAD\_DLL\_DEBUG\_EVENT
Это событие похоже на CREATE\_PROCESS\_DEBUG\_EVENT, и как вы уже догадались, это событие вызывается, когда ОС загружает DLL. Это событие возникает каждый раз, когда загружается DLL, явно или неявно. Отладочная информация содержит только время, когда была загруженаDLL, и её виртуальный адрес. Для обработки события, мы используем поле union’a LoadDll. Оно имеет тип LOAD\_DLL\_DEBUG\_INFO
```
struct LOAD_DLL_DEBUG_INFO
{
HANDLE hFile; // Handle to the DLL physical file.
LPVOID lpBaseOfDll; // The DLL Actual load address in process.
DWORD dwDebugInfoFileOffset;
DWORD nDebugInfoSize;
LPVOID lpImageName; // These two member are same as CREATE_PROCESS_DEBUG_INFO
WORD fUnicode;
};
```
Для получения имени файла, мы будем использовать функцию GetFileNameFromHandle, такую же, как мы использовали в CREATE\_PROCESS\_DEBUG\_EVENT. Я покажу этот код, когда буду рассказывать про UNLOAD\_DLL\_DEBUG\_EVENT. Событие UNLOAD\_DLL\_DEBUG\_EVENT не содержит полной информации об имени DLL библиотеки.
#### Обработка CREATE\_THREAD\_DEBUG\_EVENT
Это событие генерируется, когда ОП создаёт новый поток. Практически как CREATE\_PROCESS\_DEBUG\_EVENT, это событие создаётся перед тем, как новый поток будет запущен. Чтобы получить информацию об этом событии, мы используем поле CreateThread. Структура CREATE\_THREAD\_DEBUG\_INFO описана ниже:
```
struct CREATE_THREAD_DEBUG_INFO
{
// Handle to the newly created thread in debuggee
HANDLE hThread;
LPVOID lpThreadLocalBase;
// pointer to the starting address of the thread
LPTHREAD_START_ROUTINE lpStartAddress;
};
```
ID потока доступен в DEBUG\_EVENT::dwThreadId, поэтому нам легко вывести всю информацию о потоке:
```
case CREATE_THREAD_DEBUG_EVENT:
{
CString strEventMessage;
strEventMessage.Format(L"Thread 0x%x (Id: %d) created at: 0x%x",
debug_event.u.CreateThread.hThread,
debug_event.dwThreadId,
debug_event.u.CreateThread.lpStartAddress);
// Thread 0xc (Id: 7920) created at: 0x77b15e58
}
```
lpStartAddress – адрес начала функции потока относительно ОП, а не отладчика; Мы его просто отображаем для законченности. Обратите внимание, что это событие не генерируется, когда начинает работу основной поток ОП, только при создании новых потоков основным.
#### Обработка EXIT\_THREAD\_DEBUG\_EVENT
Это событие генерируется, как только дочерний поток завершается и возвращает код возврата в систему. Поле dwThreadId в DEBUG\_EVENT содержит ID завершающегося потока. Для получения хэндла потока и другой информации из CREATE\_THREAD\_DEBUG\_EVENT, нам необходимо хранить эту информацию в каком-либо массиве. Для получения информации об этом событии, мы используем поле ExitThread, которое имеет тип EXIT\_THREAD\_DEBUG\_INFO:
```
struct EXIT_THREAD_DEBUG_INFO
{
DWORD dwExitCode; // The thread exit code of DEBUG_EVENT::dwThreadId
};
```
Ниже код обработчика события:
```
case EXIT_THREAD_DEBUG_EVENT:
{
CString strEventMessage;
strEventMessage.Format( _T("The thread %d exited with code: %d"),
debug_event.dwThreadId,
debug_event.u.ExitThread.dwExitCode); // The thread 2760 exited with code: 0
}
```
#### Обработка UNLOAD\_DLL\_DEBUG\_EVENT
Конечно же событие содержит информацию и выгружаемой DLL из памяти ОП. Но не всё так просто! Оно генерируется только в случае вызова FreeLibrary, а не когда система сама выгружает библиотеку. Для получения информации, используйте UnloadDll (UNLOAD\_DLL\_DEBUG\_INFO):
```
struct UNLOAD_DLL_DEBUG_INFO
{
LPVOID lpBaseOfDll;
};
```
Как вы видите, для нас доступен только базовый адрес библиотеки. Именно поэтому я не рассказал вам сразу про код для LOAD\_DLL\_DEBUG\_EVENT. Во время загрузки DLL, мы также получаем lpBaseOfDll. Можно использовать Map для хранения имени библиотеки, помимо её адреса.
Важно заметить, что не все события загрузки библиотеки получат своё событие выгрузки. Тем не менее, мы должны хранить все имена библиотек, так как LOAD\_DLL\_DEBUG\_EVENT не даёт нам информации о том, как библиотека была загружена.
Ниже код для обработки обоих событий:
```
std::map < LPVOID, CString > DllNameMap;
...
case LOAD_DLL_DEBUG_EVENT:
{
strEventMessage = GetFileNameFromHandle(debug_event.u.LoadDll.hFile);
// Storing the DLL name into map. Map's key is the Base-address
DllNameMap.insert(
std::make_pair( debug_event.u.LoadDll.lpBaseOfDll, strEventMessage) );
strEventMessage.AppendFormat(L" - Loaded at %x", debug_event.u.LoadDll.lpBaseOfDll);
}
break;
...
case UNLOAD_DLL_DEBUG_EVENT:
{
strEventMessage.Format(L"DLL '%s' unloaded.",
DllNameMap[debug_event.u.UnloadDll.lpBaseOfDll] ); // Get DLL name from map.
}
break;
```
#### Обработка EXIT\_PROCESS\_DEBUG\_EVENT
Это одно из самых простых событий, и как вы можете догадаться, вызывается тогда, когда процесс ОП завершается. Это событие показывает нам, как завершился процесс: нормально или экстренно (например, через диспетчер задач), или отлаживаемая программа упала. Информацию мы получаем из EXIT\_PROCESS\_DEBUG\_INFO ExitProcess;
```
struct EXIT_PROCESS_DEBUG_INFO
{
DWORD dwExitCode;
};
```
Как только мы получим это событие, нам необходимо прервать цикл отладки и завершить поток отладки. Для этого мы можем завести флаг, который будет сигнализировать о завершении отладки.
```
bool bContinueDebugging=true;
...
case EXIT_PROCESS_DEBUG_EVENT:
{
strEventMessage.Format(L"Process exited with code: 0x%x",
debug_event.u.ExitProcess.dwExitCode);
bContinueDebugging=false;
}
break;
```
#### Обработка EXCEPTION\_DEBUG\_EVENT
Это самая удивительная и сложная вещь во всех событиях отладки. Из MSDN:
> Это событие генерируется, когда возникает исключение в отлаживаемом процессе (возможно при делении на ноль, выходе за границы массива, выполнения инструкции int 3 или любого другого исключения, описанного в SEH). Структура DEBUG\_EVENT содержит структуру EXCEPTION\_DEBUF\_INFO. Именно она описывает исключение.
Описание обработки этого события требует отдельной статьи, чтобы рассказать про это полностью (да пусть хоть даже и частично). Поэтому я расскажу пока про один тип исключения.
Поле Exception содержит информацию о только что произошедшем исключении. Ниже можно увидеть описание структуры EXCEPTION\_DEBUG\_INFO:
```
struct EXCEPTION_DEBUG_INFO
{
EXCEPTION_RECORD ExceptionRecord;
DWORD dwFirstChance;
};
```
Поле ExceptionRecord содержит детальную информацию об исключении.
```
struct EXCEPTION_RECORD
{
DWORD ExceptionCode;
DWORD ExceptionFlags;
struct _EXCEPTION_RECORD *ExceptionRecord;
PVOID ExceptionAddress;
DWORD NumberParameters;
ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; // 15
};
```
Прежде чем мы углубимся в EXCEPTION\_RECORD, хотелось бы с вами обсудить EXCEPTION\_DEBUG\_INFO::dwFirstChance
Когда процесс находится под отладкой, отладчик всегда получает исключение до того, как ОП его получит. Вы должно быть видели запись “First-chance exception at 0x00412882 in SomeModule” пока отлаживали приложение под С++. Это ссылается на First Chance исключения. Такие же исключения могут быть, а могут не быть на second chance исключениях.
Когда ОП кидает исключение, оно трактуется как second chance. ОП может обработать это исключение, а может просто упасть. Эти исключения принадлежат не к C++ исключениям, а к механизму Windows SEH. Я раскрою немного больше в следующей части статьи.
Сначала сообщение об исключении получает отладчик (first chance exception), это помогает ему обработать исключение быстрее ОП. Некоторые библиотеки генерируют исключения first-chance чтобы помочь отладчику делать его работу.
#### Ещё немного о ContinueDebugEvent
Третий параметр этой функции (dwContinueStatus) важен нам только получения исключения. Для остальных событий этот параметр игнорируется.
После получения исключения, ContinueDebugEvent должен быть вызван с:
* DBG\_CONTINUE, если исключение было успешно поймано отладчиком. От отлаживаемой программы больше ничего не надо и она может выполняться нормально.
* DBG\_EXCEPTION\_NOT\_HANDLED, если это исключение не обработано (не может быть обработано) отладчиком. Отладчик может лишь сделать запись о том, что это исключение было.
Обратите внимание, что если вернуть DBG\_CONTINUE во время того события отладки, в котором это возвращать нельзя, то точно такое же исключение бросится в отладчике, и такое же событие придёт моментально. Но так как мы только начинаем писать отладчик, давайте будет играть с безопасной рогаткой, а не пистолетом, и будем возвращать EXCEPTION\_NOT\_HANDLED. Исключение в этой статье составляет int 3 (точка останова), которое мы обсудим позже.
#### Коды исключений
1. EXCEPTION\_ACCESS\_VIOLATION
2. EXCEPTION\_ARRAY\_BOUNDS\_EXCEEDED
3. EXCEPTION\_BREAKPOINT
4. EXCEPTION\_DATATYPE\_MISALIGNMENT
5. EXCEPTION\_FLT\_DENORMAL\_OPERAND
6. EXCEPTION\_FLT\_DIVIDE\_BY\_ZERO
7. EXCEPTION\_FLT\_INEXACT\_RESULT
8. EXCEPTION\_FLT\_INVALID\_OPERATION
9. EXCEPTION\_FLT\_OVERFLOW
10. EXCEPTION\_FLT\_STACK\_CHECK
11. EXCEPTION\_FLT\_UNDERFLOW
12. EXCEPTION\_ILLEGAL\_INSTRUCTION
13. EXCEPTION\_IN\_PAGE\_ERROR
14. EXCEPTION\_INT\_DIVIDE\_BY\_ZERO
15. EXCEPTION\_INT\_OVERFLOW
16. EXCEPTION\_INVALID\_DISPOSITION
17. EXCEPTION\_NONCONTINUABLE\_EXCEPTION
18. EXCEPTION\_PRIV\_INSTRUCTION
19. EXCEPTION\_SINGLE\_STEP
20. EXCEPTION\_STACK\_OVERFLOW
Успокойтесь, я не собираюсь описывать их все. Только EXCEPTION\_BREAKPOINT:
```
case EXCEPTION_DEBUG_EVENT:
{
EXCEPTION_DEBUG_INFO& exception = debug_event.u.Exception;
switch( exception.ExceptionRecord.ExceptionCode)
{
case STATUS_BREAKPOINT: // Same value as EXCEPTION_BREAKPOINT
strEventMessage= "Break point";
break;
default:
if(exception.dwFirstChance == 1)
{
strEventMessage.Format(L"First chance exception at %x, exception-code: 0x%08x",
exception.ExceptionRecord.ExceptionAddress,
exception.ExceptionRecord.ExceptionCode);
}
dwContinueStatus = DBG_EXCEPTION_NOT_HANDLED;
}
break;
}
```
Вам должно быть известно, что такое точка останова. Вне стандартной точки зрения, точку останова можно вызвать с помошью DebugBreak API, или с помощью инструкции ассемблера { int 3 }. В .NET её можно создать с помощью System.Diagnostics.Debugger.Break. Отладчик получит код STATUS\_BREAKPOINT (такой же, как EXCEPTION\_BREAKPOINT). Отладчик обычно использует это событие для остановки текущего процесса, и может показать исходный код того места, где произошло событие. Но так как у нас отладчик только начинает разрабатываться, то мы будем показывать пользователю только базовую информацию без исходного кода.
Если точка останова будет вызвана в приложении, которое не находится под отладчиком, то оно просто упадёт. Можно использовать следующую конструкцию:
```
if ( !IsDebuggerPresent() )
AfxMessageBox(L"No debugger is attached currently.");
else
DebugBreak();
```
В заключении, хотелось бы привести простейшее событие отладки: EXCEPTION\_DEBUG\_EVENT. Это событие будет приходить постоянно. Отладчики вроде Visual Studio игнорируют его, а WinDbg нет.
#### Заключение
Используйте любой отладчик для DebugMe.
Вторая часть будет ещё интереснее и она на подходе!
**UPD:** [Часть 2](http://habrahabr.ru/post/190800/) | https://habr.com/ru/post/154847/ | null | ru | null |
# Снегопад с помощью фильтров FFmpeg
FFmpeg — мощное ПО со большим набором возможностей. В статье я постараюсь рассказать о немного необычном применении фильтров ffmpeg и о том что можно сделать используя исключительно их. Видео ниже сделано с помощью 1 команды ffmpeg (ни один графический редактор не пострадал).
Я буду использовать последнюю версию ffmpeg, собранную из [git](http://www.ffmpeg.org/download.html). Так что, если вы хотите чтобы мои примеры работали, рекомендую собрать из ветки master. Сборка и установка тривиальна и описана на сайте ffmpeg.org, при ./configure не забудьте указать "--enable-libfreetype".
Для начала нам нужно создать фон для нашего видео и мы будем использовать средства ffmpeg. Дело в том что ffmpeg позволяет использовать в качестве входного источника не только реальные устройства (например, видео-камеры или sdi-карты) и файлы, но и может использовать собственное виртуальное устройство, которое называется **lavfi**.
FFmpeg содержит в себе несколько готовых фильтров, которые генерируют видеоизображение. Среди них:
* testsrc — тестовый экран с таймером и меняющуйся строкой
* cellauto — заполнение экрана случайными черно-белыми ячейками
* life — заполнение экрана алгоритмом типа игры life
* mandelbrot — фрактальное множество Мандельброта
* rgbtestsrc — 3 цветных полосы
* smptebars — несколько цветных полос
Полный список фильтров можно посмотреть командой
`ffmpeg -filters`
Вот как они выглядят:
Поскольку я указал что буду использовать исключительно ffmpeg, то и это изображение я сгенерировал с помощью 1 команды ffmpeg. Вот она:
```
ffmpeg \
-f lavfi -i "testsrc=s=320x240" \ #Указываем все входные lavfi источники и ставим им размер в 320x240
-f lavfi -i "cellauto=s=320x240" \
-f lavfi -i "life=s=320x240" \
-f lavfi -i "mandelbrot=s=320x240" \
-f lavfi -i "rgbtestsrc=s=320x240" \
-f lavfi -i "smptebars=s=320x240" \
-filter_complex \
"[0:0]pad=iw*6:ih[a];\ #Делаем падинг изображений с помощью фильтра pad
[1:0]pad=iw:ih[b];\
[2:0]pad=iw*2:ih[c];\
[3:0]pad=iw*3:ih[d];\
[4:0]pad=iw*4:ih[e];\
[5:0]pad=iw*5:ih[f];\
[a][b]overlay=w[x];\ # Склеиваем изображения с помощью фильтра overlay
[x][c]overlay=w[y];\
[y][d]overlay=w[z];\
[z][e]overlay=w[v];\
[v][f]overlay=w" -vframes 1 all_filters.jpg
```
Хотя я сделал картинку, с помощью этой команды можно также объединить 6 видео в ряд или сделать «мозайку», нужно лишь подставить в качестве входных источников видео-файлы и изменить параметры для фильтров pad и overlay. Пробежимся по опциям:
* -f lavfi — входной формат для ffmpeg — виртуальное устройство lavfi
* -i "=" — использовать в качестве входных файлов фильтр с этими опциями
* -filter\_complex — далее мы укажем [граф фильтров](http://ffmpeg.org/ffmpeg-filters.html#Filtergraph-description)
* [0:0]pad= — используем входной источник 0, поток 0 и применяем к нему фильтр pad
* iw/ih — внутренние алиасы ffmpeg, которые указывают ширину и высоту входного изображения
* iw\*6:ih[a] — увеличиваем ширину изображения в 6 раз и присваиваем этому потоку имя «a»
* [a][b]overlay=w[x] — применяем фильтр overlay к потокам «a» и «b» и присваиваем этому потоку имя «x»
* vframes 1 — количество видеокадров 1, т.к. хотим получить картинку, а не видео
* all\_filters.jpg — имя файла для сохранения картинки, расширения ffmpeg понимает, так что если укажите .mp4, ffmpeg выдаст вам mp4 контейнер
И так, создадим фон для нашего видео:
```
ffmpeg2 -f lavfi -i "color=lightblue" -t 30 -y blue.ts
```
Тут все тоже самое что и в примере с картинками, за исключением того, что здесь мы создаем видео и вместо фильтров-генераторов, используем простой фильтр цвета. Помимо количества кадров, вы можете задать продолжительность видео через ключ "-t". По умолчанию ffmpeg задаст fps выходного потока равным 25. Поскольку я указал расширение выходному файлу .ts, то ffmpeg будет использовать контейнер MPEG2TS, а кодек mpeg2video.
Теперь добавим снежинку. Для этого будем использовать фильтр drawtext. Да, да, мы нарисуем снежинку текстом, вернее специальным юникод символом "" (U+2744).
Команда, которая это делает:
```
ffmpeg -f lavfi -i "color=lightblue" \
-vf "drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=50:text='':fontcolor=white:x=sin(n/10)*30+w/2:y=n" \
-t 5 -y snow.gif
```
Опции фильтра drawtext:
* fontfile — путь до файла шрифта
* fontsize — размер шрифта
* text — отображаемый текст
* fontcolor — цвет шрифта
* x,y — координаты текста
Как можно заметить, вся соль в координатах. Дело в том, что ffmpeg позволяет менять параметры некоторых своих фильтров «на лету», например, в зависимости от номера кадра или таймстемпа. В данном примере, помимо уже знакомых w и h, я использовал очередной внутренний алиас ffmpegа «n» — номер текущего кадра и функцию синуса чтобы придать снежинке движение из стороны в сторону. В фильтрах ffmpeg вы можете использовать тригонометрические и арифметические функции, такие как trunc и random. Полный список функций можно посмотреть вот [здесь](http://www.ffmpeg.org/ffmpeg-utils.html#Expression-Evaluation).
Теперь осталось только добавить еще фильтров (нужно больше фильтров!) для создания других снежинок и изменить их размер и движения. **Итоговая строчка запуска ffmpeg**
```
ffmpeg -f lavfi -i "color=lightblue" \
-vf "drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=10:text='':fontcolor=white:x=sin(n/10)*30:y=3*n,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=16:text='':fontcolor=white:x=cos(n/9)*3+w/3:y=n/2-h/16,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=19:text='':fontcolor=white:x=sin(n/7)*10+w/9:y=n/3-h/20,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=15:text='':fontcolor=white:x=cos(n/25)*20+w/2:y=n-h/9,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=20:text='':fontcolor=white:x=sin(n/19)*4+w-w/3:y=n-h/20,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=17:text='':fontcolor=white:x=cos(n/10)*9+w/7:y=n/2-h/18,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=16:text='':fontcolor=white:x=sin(n/20)*23+w-w/7:y=2*n-h/15,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=19:text='':fontcolor=white:x=cos(n/15)*15+w/5:y=n-h/6,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=20:text='':fontcolor=white:x=sin(n/15)*50+w-w/9:y=n-h/10,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=12:text='':fontcolor=white:x=cos(n/30)+w/2:y=n*2,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=16:text='':fontcolor=white:x=cos(n/9)*3+w/3:y=n/2-h/6,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=19:text='':fontcolor=white:x=sin(n/7)*10+w/9:y=n/4-h/2,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=15:text='':fontcolor=white:x=cos(n/25)*20+w/2:y=n/5-h/2,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=20:text='':fontcolor=white:x=sin(n/19)*4+w-w/3:y=n-h/2,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=17:text='':fontcolor=white:x=cos(n/10)*9+w/7:y=n/2-h/2,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=16:text='':fontcolor=white:x=sin(n/20)*23+w-w/7:y=2*n-h/3,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=19:text='':fontcolor=white:x=cos(n/15)*15+w/5:y=n/6-h/2,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=20:text='':fontcolor=white:x=sin(n/15)*50+w-w/9:y=2*n-h/2,\
drawtext=fontfile=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf:fontsize=12:text='':fontcolor=white:x=cos(n/22)+w/2:y=2+h"\
-qscale 1 -s 720x560 -t 12 -y snow.mp4
```
На видео выше результат выполнения этой команды. К сожалению, мне не удалось заставить параметр fontsize принимать в качестве значения результат функции random, скорее всего это пока не поддерживается. Напоследок укажу еще один нюанс с которым я с столкнулся — параметр text тоже не принимает значения вида text=n. Для того чтобы отображать номер кадра используйте конструкцию «text=%{expr\\:n}». На этом у меня все, надеюсь вы узнали для себя что нибудь новое. | https://habr.com/ru/post/203314/ | null | ru | null |
# Вычисляем точный адрес любого пользователя по номеру телефона или адресу электронной почты
С помощью этой инструкции вы сможете без труда вычислить точный адрес (улица, номер дома, номер квартиры) любого человека, который пользуется услугами интернет-провайдера InterZet (или DomRU).
### Предыстория
8-го декабря 2017-го года была выпущена новая версия приложения для iOS. В ней обновили дизайн, поправили мелкие недоработки и т.д. и т.п. Скачав приложение на телефон, я столкнулся с проблемой: не получалось пройти процедуру аутентификации. Пытался вводить в поле логина и номер договора, и номер телефона, и почту – ничего не помогало, все попытки оканчивались фиаско.
Проблема наблюдалась только в приложении, сайт же работал (да и работает) безупречно – пускает меня полностью. Сообщение об ошибке не очень-то и информативно. Что же пошло не так?
### Анализ трафика приложения
Для того, чтобы установить, почему же наш пациент не хочет жить, воспользуемся программой mitmproxy. Она позволит нам посмотреть коммуникацию между приложением и сервером.
Попробуем аутентифицироваться, чтобы получить запрос клиента и ответ сервера.
Судя по ответу, передается невалидный timestamp:
Взглянем на запрос:
В поле «timestamp$c» передаётся время отправления запроса. Не понимаю, зачем доверять клиенту в таких вопросах?
### Решение проблемы
Разработчики не учли то, что люди используют разные форматы времени; *timestamp* формируется неправильно, если стоит 12-и часовой формат (как в моём случае), поэтому запрос не может пройти проверку на сервере. Меняем формат отображения времени в настройках телефона на 24-х часовой и успешно проходим аутентификацию. Отличие запросов лишь в том, что в 24-х часовом формате в *timestamp* нет AM/PM.
Корректный запрос выглядит так:
**Вычисляем по номеру телефона или адресу электронной почты**
Во время анализа трафика приложения на этапе аутентификации, я наткнулся на одну весьма интересную недоработку системы. Некорректное поведение функции «восстановить пароль». Она отдаёт очень интересную информацию.
Запрос выглядит следующим образом:
Нас интересует параметр "*param\_values\_arr$c*".
* Если в нём передать номер договора пользователя услуг Interzet/DomRU, то мы получим привязанные к договору контактные данные: номер телефона, адрес электронной почты.
* Если передать в нём номер телефона или адрес электронной почты, то в ответе мы увидим точный адрес пользователя.
Пример ответа:
Видим точный адрес своей квартиры, понимаем, что это фиаско, а так же улыбаемся и машем!
**P.S**: на сайте всё работает корректно, вроде бы, адрес звездочками закрывают :)
К слову, судя по ошибкам, которые выдаёт сервер в случае отсутствия пользователя в базе, на сервере включен режим отладки. Не понимаю, зачем?
```
debug$n=24: exception: ORA-20001: debug=2 backtrace: ORA-06512: at "EXCELLENT3.WEBCAB\_XML\_PROC", line 6264 ORA-06512: at line 1 ORA-06512: at "EXCELLENT3.WEB\_CABINET", line 1064
```
**Как повторить?**
У каждого города, я подозреваю, своя БД и URL. Ниже приведен пример для города Санкт-Петербург.
Простой запрос через cURL:
```
curl "https://spb.db.ertelecom.ru/cgi-bin/ppo/es_webface/web_cabinet.get_info\
?param_names_arr%24c=client_contact\
¶m_values_arr%24c=habr@example.com\
¶ms=get_agr_list_contact_xml"
```
Меняем *habr@example.com* на необходимый номер телефона или адрес электронной почты.
**UPDATE:** проблема исправлена, теперь адрес закрыт звездочками.
*Вся информация предоставлена исключительно в ознакомительных целях. Я не несу ответственность за любой возможный вред или ущерб, причиненный материалами данной статьи.* | https://habr.com/ru/post/344348/ | null | ru | null |
# Что может сделать стартап за месяц
[](http://picfor.me "Picfor.me -закладки на картинки")
Это юбилейный пост, которым мы хотим отметить первый месяц работы нашего молодого проекта [Picture for me](http://picfor.me). Ровно месяц назад мы сообщили о наше сервисе [закладок для картинок](http://habrahabr.ru/blogs/i_am_advertising/36646/) хабра сообществу.
И вот кратко что добавилось за этот месяц:
**RSS** (спасибо [Paranoid](https://habrahabr.ru/users/paranoid/));
**PicPower** (сила пользователя, аля хабрасила), по ней мы и определяем самых активных пользователей;
добавили защиту от «сисек», но там ещё надо поработать;
можно проследить, кто смотрел твои картинки, добавлял комментарии и закладки;
для более удобной навигации по бокам картинки добавили стрелочки (спасибо [EKCTPEMICT](https://habrahabr.ru/users/ekctpemict/));
если вы перешли на картинку по тегу, можно, при помощи стрелок, просмотреть все картинки этого тега, это можно попробовать на примере галереи по тэгу [Melissa Theuriau](http://picfor.me/tag/Melissa-Theuriau/2481).
Так же много сил и времени ушло на продвижение нашего проекта в сеть, но это была приятная работа, потому как множество людей нас поддерживают хорошим словом или идеей или даже найденным жуком ;).
Отдельные благодарности хабралюдям [develop7](https://habrahabr.ru/users/develop7/) за первый пост, [ido](https://habrahabr.ru/users/ido/), [mad\_s](https://habrahabr.ru/users/mad_s/) за идеи и [nooze](https://habrahabr.ru/users/nooze/), [Leprechaun](https://habrahabr.ru/users/leprechaun/), [sosedoff](https://habrahabr.ru/users/sosedoff/), [Nickolay](https://habrahabr.ru/users/nickolay/), [brutaler](https://habrahabr.ru/users/brutaler/) за баги ну и за критику [explanent](https://habrahabr.ru/users/explanent/).
Ну и само собой всем 775-и пользователям нашего серсиса.
`mysql> select count(*) from megausers;
+----------+
| count(*) |
+----------+
| 775 |
+----------+
1 row in set (0.00 sec)`
Всех программистов с праздником и айда на ПИВО!
upd: совсем забыл мы же его на 5-и языках сделали. Думаю в течении 2-х недель будет словацкий, венгерский | https://habr.com/ru/post/39657/ | null | ru | null |
# Удаленная отладка Spring Boot приложений (IntelliJ + Eclipse)
Локальная разработка на вашей машине удобна. Но как только вы развернете свое приложение, у вас будет совсем другая среда, что может привести к непредвиденному поведению или ошибкам. Использование ручной печати
```
System.out.println («Теперь мы находимся здесь, а переменная X is =» + x);
```
делает код вашего приложения довольно громоздким и его выполнение занимает много времени. К счастью в **Java** есть зрелая отладочная экосистема. Это позволяет нам удаленно отлаживать приложения Spring Boot и анализировать его рабочий процесс на удаленном сервере / облаке.
Чтобы показать вам, насколько на самом деле **проста удаленная отладка** с помощью **Java**, я буду использовать приложение **Spring Boot 2.3**, работающее на **Java 11**. Я разверну приложение как в виде контейнера Docker, так и с помощью старой школы java -jar… way. Наконец, вы узнаете, как удаленно отлаживать интерфейс REST с помощью **IntelliJ IDEA (2019.1)** и **Eclipse (2019-03)**.
Настройка проекта
-----------------
Для приложения я выбрал простое приложение **Spring Boot 2.3**. Он включает в себя встроенную базу данных **H2** и **JPA** для обслуживания книг, которые генерируются случайным образом при запуске.
Класс контроллера, который я позже буду использовать для отладки, выглядит следующим образом:
```
@Slf4j
@RestController
@RequestMapping("/api/books")
public class BookController {
@Autowired
private BookRepository bookRepository;
@GetMapping
public List getAllBooks() {
log.info("Retrieving all available books");
List allAvailableBooks = bookRepository.findAll();
return allAvailableBooks;
}
@GetMapping("/{id}")
public Book getBookById(@PathVariable("id") Long id) {
log.info("Retrieving book with id: {}", id);
Optional book = bookRepository.findById(id);
if (book.isEmpty()) {
throw new BookNotFoundException("Can't find book with id: " + id);
}
return book.get();
}
}
```
Остальная часть приложения опущена, но вы можете найти весь [исходный код на GitHub](https://github.com/rieckpil/blog-tutorials/tree/master/remote-debugging-spring-boot-application).
Развертывание
-------------
Чтобы иметь возможность удаленной отладки вашего Java-приложения Spring Boot, мы должны передать в **JVM** следующие **аргументы**:
```
-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:8000
```
Указанный порт в этом аргументе позже используется для подключения наших **IDE** к работающей **JVM** и не должен совпадать с портом приложения.
Аргумент может быть передан в **JVM** с помощью следующей команды:
```
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:8000 -jar target/remote-debugging-spring-boot-application.jar
```
При использовании **Docker** мы можем добавить этот аргумент в нашу ENTRYPOINT и просто нужно отобразить дополнительный порт при запуске **Docker контейнера**:
```
FROM openjdk:11-jdk-slim
VOLUME /tmp
COPY target/remote-debugging-spring-boot-application.jar app.jar
ENTRYPOINT ["java","-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:8000","-jar","/app.jar"]
```
```
docker run -d -p 8080:8080 -p 8000:8000 --name debug-me debug-me
```
**Важное замечание**: Чтобы выполнить удаленную отладку на удаленном сервере в следующих шагах, убедитесь, что никакое правило брандмауэра не блокирует этот порт, и вы можете получить к нему доступ с локального компьютера.
Удаленная отладка приложений Spring Boot с помощью IntelliJ IDEA
Удаленная отладка приложения Spring Boot с IntelliJ IDEA требует, чтобы вы открыли проект (исходный код) с IntelliJ. Затем мы можем перейти к редактированию конфигурации… в правом верхнем углу рядом с зеленой кнопкой запуска:
Выберите создание новой конфигурации Run / Debug, нажимая кнопку +, и выберите Remote. Старые версии IntelliJ могут иметь разные названия, такие как Remote Debugging (удаленная отладка), Debugging (отладка) и т.д.:
Затем введите имя для выбранной вами конфигурации удаленной отладки и укажите порт и хост, к которому вы хотите подключиться (в нашем примере это порт 8000). Убедитесь, что вы выбрали правильный проект для **Use module classpath** (Использовать classpath модуля) и нажмите **Apply** или **Ok**:
Теперь отметьте в исходном коде строку, которую вы хотите отладить, и запустите конфигурацию удаленной отладки Remote debugging configuration(убедитесь, что ваше приложение уже запущено):
Теперь попробуйте получить доступ к конечной точке (<http://localhost:8080/api/books> в этом примере) с помощью браузера или клиента API, и вы сможете отладить указанную часть вашего приложения в вашей IDEA:
Чтобы остановить удаленную отладку приложения, просто нажмите красную кнопку остановки.
Удаленная отладка приложений Spring Boot в Eclipse
--------------------------------------------------
Для Eclipse вы также сначала должны импортировать проект, а затем перейти к пункту меню **Run -> Debug Configurations**: | https://habr.com/ru/post/513520/ | null | ru | null |
# Интеграция GNU/Linux и Microsoft Windows
Из недавно опубликованного топика [Mac OS X глазами Windows-юзера](http://habrahabr.ru/post/146880/) я узнал о программе «Parallels Desktop», которая позволяет очень дружелюбным для пользователя образом запускать приложения другой операционной системы. И мне так понравилась эта идея, что я решил попробовать сделать тоже самое с VirtualBox. (как напоминают в комментариях, такая возможность есть и во многих других программах для виртуализации — например, VMWare)
Немного «погуглив», я узнал, что большая часть необходимых мне возможностей уже есть в этой замечательной виртуальной машине, поэтому для опытных пользователей VirtualBox'а этот топик может показаться немного капитанским.
Всем остальным предлагаю проследовать «под кат» ↓
#### Шаг 1. Установка Oracle VirtualBox и Microsoft Windows XP
Начнем с VirtualBox'а. Для начала настоятельно советую поискать его в репозиториях вашего дистрибутива GNU/Linux. Поскольку это свободное программное обеспечение, то вероятность встретить его там очень высока.
Если же VirtualBox'а там не оказалось, то скачайте его с официального сайта — [www.virtualbox.org/wiki/Downloads](https://www.virtualbox.org/wiki/Downloads).
После установки запустим его графическую оболочку и создадим новую виртуальную машину:
Должен открыться мастер по созданию новой виртуальной машины. Укажите тип ОС «Microsoft Windows XP» — это позволит VirtualBox'у автоматически проставить минимальные параметры для данной системы. Естественно, что потом мы сможем изменить их!
Далее вас спросят, хотите ли вы создать новый виртуальный диск или использовать уже существующий *(тоже виртуальный)* диск. Создаем новый. На вопрос о том, какой диск («фиксированный» или «динамический») создать, отвечаем сами.
* Для **динамического диска** вы задаете начальный размер, который потом может увеличиваться по мере необходимости. Только учтите, что уменьшаться он не может. Также есть мнение, что он немного медленнее, чем
* **Фиксированный диск**, для которого вы задаете размер, и который не может меняться. Уменьшить или увеличить его вам, скорее всего, не удастся. Я выбрал именно этот вариант, но логика мне подсказывает, что я поступил неправильно.
**UPD:** Как [подсказывает](http://habrahabr.ru/post/146919/#comment_4950051) [Vumik](http://habrahabr.ru/users/vumik/) в комментариях, лучше **до установки ОС** в свойствах виртуальной машины указать несколько ядер.
Далее вставляем в свой компьютер диск с системой Microsoft Windows, запускаем виртуальную машину, «скармливаем» ей наш диск и перезагружаемся с него.
Установка выбранной мною Microsoft Windows XP происходит очень просто, не сложнее установки большинства GNU/Linux-дистрибутивов.
На определенном этапе установки вас спросят лицензионный ключ:
Он должен быть написан на коробке, из которой вы извлекли диск.
Если вы скачали iso-образ из сети Интернет, и у вас пока еще нет ключа, то оставьте это поле пустым. В таком случае компания Microsoft предлагает вам использовать систему 30 дней совершенно бесплатно. По истечении указанного срока вы должны будете купить Windows или удалить ее.
#### Шаг 2. Сглаживание шрифтов
К сожалению, лично я не могу продолжить настраивать Windows, пока не включено сглаживание шрифтов. В Windows за это отвечает технология «ClearType», которую сейчас нужно будет настроить.
Для этого выполняем следующие действия:
* В меню *Пуск* последовательно выбираем *Панель управления*, *Оформление и темы*, *Экран*.
* На вкладке *Оформление* нажимаем кнопку *Эффекты*.
* Устанавливаем флажок *Применять следующий метод сглаживания экранных шрифтов* и выбираем в списке *ClearType*.
Не забудьте нажать *«ОК»*.
Подробнее о включении ClearType можно прочитать на официальном сайте Microsoft — [support.microsoft.com/kb/306527/ru](http://support.microsoft.com/kb/306527/ru).
#### Шаг 3. Добавляем немного ресурсов
По-умолчанию VirtualBox выделяет для Windows слишком уж смешные характеристики, на которых даже далеко не каждый современный GNU/Linux-дистрибутив работать будет. По этому идем в свойства виртуальной машины и даем ей ресурсов по принципу «сколько не жалко». При этом стоит учитывать две вещи:
* «Сколько не жалко» не должно снижать отданные VirtualBox'ом по-умолчанию ресурсы.
* Если указать слишком много, то может начать тормозить ваша основная ОС, и, как следствие, виртуальная машина тоже. Поэтому нужно найти «золотую середину».
#### Шаг 4. Установка «Дополнений гостевой ОС»
Сейчас Windows наивно полагает, что она запущена на обычном PC. Ну или знает, что мы запустили ее в виртуальной машине, но из вежливости не подает виду.
Так или иначе, нам необходимо установить дополнительное ПО от компании Oracle, которое позволит нам начать интеграцию двух систем.
Установить его гораздо проще, чем вы думаете. Просто нажмите Host+D (обычно «Host»=«Ctrl») или нажмите в меню виртуальной машины «Устройства» → «Установка дополнений гостевой ОС».
Появится мастер установки, который поможет вам установить нужные программы:
*Примечание: смотрите как клево «Винда» шрифты сглаживает :-)*
Теперь нам нужно перезагрузить Windows («Пуск» → «Выключение» → «Перезагрузка»).
#### Шаг 5. «Режим интеграции дисплея»
Начнем с интеграции дисплеев. Будем очень хитро накладывать экран виртуальной машины на экран нашей основной системы так, что одно окно можно будет «протащить» под другим. Для этого нужно нажать Host+D или «Вид» → «Режим интеграции дисплея».
VirtualBox при этом растянет свое окно на весь экран и уберет рабочий стол Windows. Должно получиться примерно следующее:
Также внизу вы можете обнаружить новую панель — «Панель задач Windows»:
#### Шаг 6. Общий буфер обмена
Когда вы установили «Дополнения гостевой ОС», то должна была заработать «фича» по объединению буфера обмена вашей и гостевой ОС (Windows). Если она не заработала сама, то проверьте, включена ли соответствующая настройка в свойствах виртуальной машины:
Теперь можно попробовать скопировать какой-нибудь текст или картинку в GNU/Linux и вставить ее в Windows. Или наоборот.
#### Шаг 7. Общие папки
Сейчас мы сделаем маленькую хитрость — подключим свою папку с документами к виртуальной машине как «общую папку» и укажем Windows, что это и есть наша папка с документами.
Таким образом, вы сможете, например, работать над изображением в PhotoShop'е и GIMP'е одновременно. Причем так, что GIMP будет запущен в GNU/Linux, а Adobe Photoshop в Windows.
Для этого нам нужно **остановить виртуальную машину с Windows**, зайти в ее свойства и указать свою папку с документами.
Теперь опять запускаем виртуальноую машину с Windows, открываем программу «Командная строка Windows» (*«Пуск»* → *«Все программы»* → *«Стандартные»* → *«Командная строка»*) и вводим следующую команду:
```
net use x: \\vboxsvr\Документы
```
Должно будет появиться новое устройство («Диск») — «Документы на `vboxsvr` (X:)», которое будет содержать все ваши документы из GNU/Linux:
Теперь делаем клик правой кнопкой мыши на «Мои документы» и указываем новый путь назначения:
После нажатия «ОК» Windows предложит переместить все ваши документы в эту «новую» папку, соглашайтесь, если вы уже успели создать их :-)
#### Заключение
Такими вот нехитрыми способами можно объединить работу в двух системах — GNU/Linux и Microsoft Windows. Можно также попытаться поставить еще какую-нибудь систему, например, Apple MacOS (только говорят, что это незаконно). Только в таком случае нужно обладать довольно мощным компьютером и придумать как разместить панели и окна различных ОС (например, можно попробовать держать MacOS и Windows на разных виртуальных рабочих столах).
#### Кое-что еще
Предугадывая вопросы типа «Зачем так подробно описывать настройку Windows, ведь и так все понятно!», отвечаю: топик предназначен для пользоватлей GNU/Linux, которые могут не уметь работать в Microsoft Windows. Ведь для пользователей Windows инструкции по GNU/Linux тоже выглядят так, как-будто их писал сам Капитан Очевидность! | https://habr.com/ru/post/146919/ | null | ru | null |
# Функциональное программирование с точки зрения EcmaScript. Рекурсия и её виды
Привет, Хабр!
Сегодня мы продолжим наши изыскания на тему функционального программирования в разрезе EcmaScript, на спецификации которого основан JavaScript. В предыдущих статьях цикла были рассмотрены следующие темы:
1. [Чистые функции, лямбды, имутабельность](https://habr.com/ru/post/474702/)
2. [Композиция, каррирование, частичное применение](https://habr.com/ru/post/475324/)
Рекурсия
--------
Как всегда, википедия помогает нам с поиском определения:
> Реку́рсия — определение, описание, изображение какого-либо объекта или процесса внутри самого этого объекта или процесса, то есть ситуация, когда объект является частью самого себя. Термин «рекурсия» используется в различных специальных областях знаний — от лингвистики до логики, но наиболее применение находит в математике и информатике.
Применительно к программированию под рекурсией подразумевают **процессы, которые вызывают сами себя в своём теле**. Рекурсивная функция имеет несколько обязательных составляющих:
* **Терминальное условие** — условие прекращения выполнения
* Правило по которому осуществляется **движение в глубь** по рекурсии
Рассмотрим самый популярный пример рекурсии — вычисление факториала.
```
const factorial = (n) => {
if (n === 0) {
return 1;
}
return n * factorial(n - 1);
}
```
Выделим характерные составляющие рекурсивной функции. Терминальное условие
```
if (n === 0) {
return 1;
}
```
и правило движения по рекурсии
```
return n * factorial(n - 1);
```
Важно осознавать, что рекурсия это не какая-то специфическая фича JS, а техника очень распространённая в программировании.
#### Рекурсивный и итеративный процессы
Рекурсию можно организовать двумя способами: через рекурсивный процесс или через итеративный.
Рекурсивный процесс мы с вами уже видели:
```
const factorial = (n) => {
if (n === 0) {
return 1;
}
return n * factorial(n - 1);
}
```
Итеративное решение задачи о факториале выглядело бы так:
```
const factorial = (n) => {
const iter = (counter, acc) => {
if (counter === 1) {
return acc;
}
return iter(counter - 1, counter * acc);
};
return iter(n, 1);
};
```
Оба этих варианта это рекурсия. В обоих решениях есть характерные для рекурсии черты: терминальное условие и правило движения по рекурсии. Давайте разберём их отличия.
Рекурсивный процесс на каждом шаге запоминает действие. которое надо сделать. Дойдя до термального условия, он выполняет все запомненные действия в обратном порядке. Поясним на примере. Когда рекурсивный процесс считает факториал 6, то ему нужно запомнить 5 чисел чтобы посчитать их в самом конце, когда уже никуда не деться и рекурсивно двигаться вглубь больше нельзя. Когда мы находимся в очередном вызове функции, то где-то снаружи этого вызова в памяти хранятся эти запомненные числа.
Выглядит это примерно так:
```
factorial(3); //для 6ти писать много, поэтому ограничусь факториалом 3ки
3 * factorial(2);
3 * 2 * factorial(1);
3 * 2 * 1;
3 * 2;
6;
```
Как видите, основная идея рекурсивного процесса — откладывание вычисления до конца.
Такой процесс порождает **изменяемое во времени состояние**, которое хранится «где-то» снаружи текущего вызова функции.
Думаю, вы помните, что в первой статье из цикла о [Функциональном программировании](https://habr.com/ru/post/474702/) мы говорили о важности имутабельности и отсутствия состояния. Наличие состояния порождает много проблем, с которыми не всегда легко справится.
**Итеративный процесс** отличается от **рекурсивного** фиксированным количеством состояний. На каждом своём шаге итеративный процесс считает всё, что может посчитать, поэтому каждый шаг рекурсии существует независимо от предыдущего.
Выглядит это так:
```
iter(3, 1); // iter(3 - 1, 1 * 3); //обратите внимание, что тут мы записали факториал 6ти,
iter(2, 3); // iter(2 - 1, 2 * 3);//но количество строк меньше, чем в предыдущем примере для 3ки
iter(1, 6); // counter === 1, return 6
6;
```
Думаю, очевидно, что итеративный процесс потребляет меньше памяти. Следовательно, всегда при создании рекурсии следует использовать его. Единственное исключение: если мы не можем посчитать значение до достижения термального условия.
### Древовидная рекурсия
Многие считают, что деревья и работа с ними это что-то очень заумное, сложное и не понятное простым смертным. На самом деле это не так. Любая иерархическая структура может быть представлена в виде дерева. Даже человеческое мышление подобно дереву.
Чтобы лучше понять древовидную рекурсию разберём простой и популярный пример — числа Фибоначчи.
> Чи́сла Фибона́ччи — элементы числовой последовательности 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, … (последовательность A000045 в OEIS), в которой первые два числа равны либо 1 и 1, либо 0 и 1, а каждое последующее число равно сумме двух предыдущих чисел. Названы в честь средневекового математика Леонардо Пизанского (известного как Фибоначчи).
Математически довольно просто сформулировать описание (а ведь декларативное программирование и есть описание) данной последовательности:
```
fib(n) = [
равно 0 если n = 0,//(1)
равно 1 если n = 1,//(2)
fib(n-1) + fib(n-2) во всех остальных случаях
]
```
Теперь давайте перейдём от математики к логическим рассуждениям(нам ведь нужно программную логику написать). Для вычисления fib(5) нам придётся вычислить fib(4) и fib(3). Для вычисления fib(4) нам придётся вычислить fib(3) и fib(2). Для вычисления fib(3) нам придётся вычислить fib(2) и так до тех пор пока мы не дойдём до известных значений (1) и (2) в нашей математической модели.
На какие мысли нас должны навести наши рассуждения? Очевидно, мы должны использовать рекурсию. Термальное условие можно сформулировать как n <= 1. Однако, вместо одной ветви рекурсии(как в предыдущих примерах) у нас будет две ветви: fib(n-1), fib(n-2).
```
const fib = (n) => (n <= 1 ? n : fib(n - 1) + fib(n - 2));
```
У данного решения есть существенный минус! Оно считает результат о одинакового значения n несколько раз в разных ветках. Для решения этой проблемы существует техника функционального программирования, которая называется **мемоизация**, о ней мы говорим в одной из следующих статей.
### Заключение
Рекурсия является очень мощным средством программирования. Напомню, что, как правило, мы используем итеративный процесс. Использовать рекурсивный процесс стоит только в том случаем если мы не можем посчитать промежуточный результат на каждом шаге рекурсии. | https://habr.com/ru/post/480520/ | null | ru | null |
# Лексоранги — что это такое и как их использовать для эффективной сортировки списков
В этой статье я расскажу, что такое Лексоранги, как ими пользуются в Jira, и как ими воспользовались мы для эффективной сортировки списков и перетаскивания элементов в нашем мобильном приложении.
Перетаскивание элементов в списке – популярная фича в современных приложениях, наличие которой только порадует пользователей. Однако реализуя такой функционал нужно постараться не наступить на грабли плохой оптимизации: большое количество элементов, пересчет позиции каждый раз, а если в списке ещё и несколько секций – то при перетаскивании между секциями, скорее всего, нужно реализовать дополнительную логику. Как не получить по лбу, уменьшить количество вычислений, и как нам в этом помогут лексоранги – читайте под катом.
### Обозначим проблему
Итак, Вы решили добавить в своё приложение возможность перетаскивать элементы. Значит, нужно как-то сортировать элементы, иначе никакого смысла в перетаскивании. И что первое приходит в голову?
### Позиции
Самые обычные ничем не примечательные позиции. Те самые числа от 1 до бесконечности(не совсем). Работать с ними просто и удобно, элементы сортируются без проблем. На первый взгляд, всё хорошо. На столько хорошо, что для большинства приложений это – то, что нужно.
*Что же тогда не так с числовой позицией?*
Проблема таится в сопутствующих операциях. Нужно внедрить элемент между вторым и третьим элементами? Смещаем всё вперёд на один начиная с третьего элемента, не забыв при этом обновить данные в БД. Выполнение такой операции единожды не выглядит сложно, однако эта операция будет выполняться довольно часто.
Еще одна проблемная операция – обновление данных на сервере. Обновили задачу – нужно послать апдейт всех затронутых задач на сервер. Сервер в свою очередь должен разослать этот апдейт всем, кто “подписан” на список задач. Чем чаще пользователи изменяют порядок задач в списке, тем больше данных нужно послать на сервер, и тем больше данных сервер должен разослать клиентам.
Получается, при перетягивании одной задачи мы будем не только изменять позиции у большого количества элементов, но и отсылать их на сервер, который будет после рассылать их другим пользователям.
Вывод: хочется что-то более оптимальное
### Варианты решений
Когда мы в компании столкнулись с подобной проблемой, первым возможным решением стал следующий алгоритм: всем элементам мы расставим какие-нибудь стандартные позиции через равные интервалы(шаги). Так, первый элемент будет иметь позицию равной 1, а второй – равной 1000. Когда пользователь захочет перетащить что-нибудь между этими двумя элементами, мы посчитаем среднюю позицию – (1000 + 1) / 2 = ~500. И так далее, и так далее.
Чем плох этот вариант, думаю, вы догадались сразу. Мы ограничены в количестве шагов, которые можно сделать. Т.е. между 1 и 1000 – 500. Между 1 и 500 – 250. Потом 125… и в конечном итоге места не останется. Увеличение шага эту проблему не решает.
Может воспользуемся дробными числами?
Нет, дробные числа не исправляют проблему, а лишь оттягивают момент её появления.
Немного подумав и погуглив, мы наткнулись на доклад о том, как в Жире (Jira) используются лексоранги (Lexorank, [доклад](https://www.youtube.com/watch?v=OjQv9xMoFbg)).
Основаны они на трёх вещах:
1 – строки легко сортировать в алфавитном порядке
2 – между двумя строками можно найти среднюю строку (не всегда, и это уже не так просто)
3 – нельзя найти среднюю? Воспользуемся ведром(звучит странно, да)
С сортировкой всё понятно, идём сразу к пункту номер 2.
Есть в английском алфавите буквы в «a» и «c», а между ними, очевидно, «b». Но как найти эту «b» математическим путём?
Давайте просто отнимем от кода буквы «c» код буквы «a», получим 2 («c» = 143, «a» = 141). Осталось поделить результат пополам. Получили 1. И правда, если прибавить к коду «а» единицу, мы получим код буквы «b».
*Комбинация английских букв и называется **лексорангом***
Ситуации, когда между двумя строками нет места, тут так же имеют место быть, и я уже писал, что для их решения используются вёдра.
*Ведро – это метка перед рангом*, выглядит так: «0|aaa». Здесь 0 – номер ведра. Когда места не остаётся, элементы перекладываются из одного ведра в другое, а метки расставляются заново с сохранением порядка. Вот и вся магия!
**Как этим воспользовались мы**
Точно не сказано (скорее, просто мы не нашли) как легко и безболезненно найти среднюю строку между двумя. Поэтому мы напряглись и придумали вот что. Сразу окунаемся в пример.
Возьмём две строки: «aa» и «cc» и найдём между ними среднюю.
После посимвольного вычитания как выше мы получим число 11. Но что делать дальше? Вы можете подумать, что нужно просто добавить результат к строке «aa». Тут и правда получится строка «bb», находящаяся между «аа» и «сс», однако алгоритм будет неверным, и сейчас мы с вами увидим почему.
Давайте подумаем, на что это похоже? «aa», «cc», «11». На какую-то систему счисления. На какую? А на 26-ричную! Почему? Потому что в английском алфавите 26 букв. Вот так вот.
Надо перевести результат, «11», из 26-ричной системы счисления в привычную нам 10-ричную.
Формула довольно простая:
*X = y0 + y1 \* size + y2 \* size^2… yn \* size^(n-1)*
*Здесь за **size** обозначен **«размер»** системы счисления (в данном случае size = 26)*
yn – n-ное число справа
Запомним эту формулу как, например, *формула 1*, она нам ещё пригодится.
Подставляем наши числа и вот что получается: 2 + 2 \* 26 = 54. Теперь мы знаем, сколько символов между строкой «аа» и «сс». Но нам нужно взять среднюю между этими двумя. Делим 54 на 2, получаем 27. Остаётся только правильно добавить к кодам «аа» наш результат.
Как это сделать? Вначале узнаем, сколько нужно прибавить к первому (правому) символу. Для этого получим остаток от деления 27 на 26. Получится 1. Прибавляем к «а» 1 – получится буква «b».
Теперь надо подумать, как узнать, на сколько символов надо сдвинуть второй символ.
Тут нам поможет следующая формула:
*X = Y / size^(n-1) % size*
По этой формуле мы можем узнать, сколько нужно добавить к определённому месту(символу, задаётся с помощью n).
Подставляем всё туда, получаем(n = 2): (27/ 26) % 26 = 1. Прибавляем. Получаем финальный результат «bb».
Реализовать алгоритм на каком-либо ЯП не так сложно, когда точно знаешь, как он работает. Ниже я добавил реализацию алгоритма на языке Dart(приложение, в котором возникла данная проблема, написано на Flutter'е).
**Наша реализация нахождения 'средней' строки**
```
String getRankBetween({@required String firstRank, @required String secondRank}) {
assert(firstRank.compareTo(secondRank) < 0, "First position must be lower than second. Got firstRank $firstRank and second rank $secondRank");
/// Make positions equal
while (firstRank.length != secondRank.length) {
if (firstRank.length > secondRank.length)
secondRank += "a";
else
firstRank += "a";
}
var firstPositionCodes = [];
firstPositionCodes.addAll(firstRank.codeUnits);
var secondPositionCodes = [];
secondPositionCodes.addAll(secondRank.codeUnits);
var difference = 0;
for (int index = firstPositionCodes.length - 1; index >= 0; index--) {
/// Codes of the elements of positions
var firstCode = firstPositionCodes[index];
var secondCode = secondPositionCodes[index];
/// i.e. ' a < b '
if (secondCode < firstCode) {
/// ALPHABET_SIZE = 26 for now
secondCode += ALPHABET_SIZE;
secondPositionCodes[index - 1] -= 1;
}
/// formula: x = a * size^0 + b * size^1 + c * size^2
final powRes = pow(ALPHABET_SIZE, firstRank.length - index - 1);
difference += (secondCode - firstCode) * powRes;
}
var newElement = "";
if (difference <= 1) {
/// add middle char from alphabet
newElement = firstRank +
String.fromCharCode('a'.codeUnits.first + ALPHABET_SIZE ~/ 2);
} else {
difference ~/= 2;
var offset = 0;
for (int index = 0; index < firstRank.length; index++) {
/// formula: x = difference / (size^place - 1) % size;
/// i.e. difference = 110, size = 10, we want place 2 (middle),
/// then x = 100 / 10^(2 - 1) % 10 = 100 / 10 % 10 = 11 % 10 = 1
final diffInSymbols = difference ~/ pow(ALPHABET_SIZE, index) % (ALPHABET_SIZE);
var newElementCode = firstRank.codeUnitAt(
secondRank.length - index - 1) + diffInSymbols + offset;
offset = 0;
/// if newElement is greater then 'z'
if (newElementCode > 'z'.codeUnits.first) {
offset++;
newElementCode -= ALPHABET_SIZE;
}
newElement += String.fromCharCode(newElementCode);
}
newElement = newElement
.split('')
.reversed
.join();
}
return newElement;
}
```
### Но это ещё не всё
Во всяком случае, для нас это было не всё. Мы добавляли данную фичу в уже выпущенное приложение, поэтому нужна была миграция. Написать миграции для SQL проблем не составляет, а вот посчитать стандартные ранги уже не так просто. Но, зная как находится средняя строка, сделать это становится не сложно. Алгоритм будет следующий:
* задаём начало и конец промежутка(у нас это «ааа» и «zzz» соответственно)
* считаем, сколько комбинаций разных символов между строками, тут нам поможет *формула 1*
* теперь делим то, что получилось на максимально возможное количество элементов в списке
* итак, у нас есть шаг, есть начальная позиция, остаётся только к начальной позиции прибавить шаг, получить ранг, потом к этому рангу прибавить шаг, получить новый ранг, потом снова прибавить шаг и так далее
Всё так же на Dart'е. параметр *forNumOfTasks* отвечает за то, сколько позиций вы получите. Если вы проставляете позиции для списка, где сейчас всего три элемента, нет смысла рассчитывать позиции на весь список(на 50, 100 или ещё сколько-то)
**Наша реализация нахождения 'дефолтных' рангов**
```
/// modify field forNumOfTasks to get certain number of positions
List‹String› getDefaultRank({int forNumOfTasks = TASK_FOR_PROJECT_LIMIT_TOTAL}) {
final startPos = START_POSITION;
final endPos = END_POSITION;
final startCode = startPos.codeUnits.first;
final endCode = endPos.codeUnits.first;
final diffInOneSymb = endCode - startCode;
/// x = a + b * size + c * size^2
final totalDiff = diffInOneSymb + diffInOneSymb * ALPHABET_SIZE + diffInOneSymb * ALPHABET_SIZE * ALPHABET_SIZE;
/// '~/' – div without remainder
final diffForOneItem = totalDiff ~/ (TASK_FOR_PROJECT_LIMIT_TOTAL + 1);
/// x = difference / size^(place - 1) % size
final List‹int› diffForSymbols = [
diffForOneItem % ALPHABET_SIZE,
diffForOneItem ~/ ALPHABET_SIZE % ALPHABET_SIZE,
diffForOneItem ~/ (pow(ALPHABET_SIZE, 2)) % ALPHABET_SIZE
];
List‹String› positions = [];
var lastAddedElement = startPos;
for (int ind = 0; ind < forNumOfTasks; ind++) {
var offset = 0;
var newElement = "";
for (int index = 0; index < 3; index++) {
final diffInSymbols = diffForSymbols[index];
var newElementCode = lastAddedElement.codeUnitAt(2 - index) + diffInSymbols;
if (offset != 0) {
newElementCode += 1;
offset = 0;
}
/// 'z' code is 122 if 'll be needed
if (newElementCode > 'z'.codeUnitAt(0)) {
offset += 1;
newElementCode -= ALPHABET_SIZE;
}
final symbol = String.fromCharCode(newElementCode);
newElement += symbol;
}
/// reverse element cuz we are calculating from the end
newElement = newElement.split('').reversed.join();
positions.add(newElement);
lastAddedElement = newElement;
}
positions.sort();
positions.forEach((p) => print(p));
return positions;
}
```
Фуууух, устали? Самое сложное уже позади, осталось совсем немного!
Нам не очень понравилась идея с вёдрами. Объективно – она хороша. Но нам не нравилась сама идея наличия алгоритма «восстановления»: закончились позиции – восстанавливайся с помощью вёдер! Так что, никаких вёдер. Однако, ранги не бесконечные, а значит что-то придумать надо.
*И мы придумали*
Если места между строками не осталось, то мы решили просто добавить к нижней границе среднюю букву английского алфавита («n»). Т.е. если мы захотим всунуть элемент между «аа» и «аb», то получится «aa», «aan» и «ab». Благодаря тому, что строки сортируются поэлементно слева-направо, удлинение строки не испортит сортировку. Зато у нас появилось место для новых элементов, и это без каких-либо алгоритмов восстановления.
Этот кусочек кода можно найти также и в алгоритме нахождения средней строки.
**Кусочек кода с добавлением 'среднего' символа**
```
if (difference <= 1) {
/// add middle char from alphabet
newElement = firstRank +
String.fromCharCode('a'.codeUnits.first + ALPHABET_SIZE ~/ 2);
}
```
### Резюме
Лексоранги показались нам отличным инструментом индексации, использование которого оптимизирует работу с БД и сервером: при изменении порядка задач необходимо обновить только одну измененную задачу.
Делитесь своим мнением по поводу лексорангов и тем, какие у Вас мысли по поводу решения подобных задач.
Ну и для всех читателей Хабра предлагаем оценить результат, который у нас получился. А также забрать себе [полезный список “Кодекс авторов Хабра”](https://sharry.whisperarts.com/list/Uy9idNttX6BZMgHa9).
Спасибо за внимание! | https://habr.com/ru/post/510448/ | null | ru | null |
# Алгоритм seam carving для изменения размера изображения
Seam carving это алгоритм для изменения размера картинки, сохраняющий важный контент и удаляющий менее значимый. Он был описан в статье [S. Avidan & A. Shamir](http://www.win.tue.nl/~wstahw/2IV05/seamcarving.pdf). Он дает лучший результат, чем обычное растягивание изображения ввиду того, что не меняет пропорций значимых элементов изображения. Две фотографии ниже демонстрируют работу алгоритма – исходное изображение имеет размер 332x480, в то время как модифицированное seam carving'ом 272x400.
В данной статье я опишу работу алгоритма используя псевдокод и код Matlab. Оригинал статьи, написанный мной на английском доступен [тут](http://kirilllykov.github.io/blog/2013/06/06/seam-carving-algorithm/), исходный код на [гитхабе](https://github.com/KirillLykov/cvision-algorithms/blob/master/src/seamCarving.m).
##### Энергия изображения
В целях упрощения изложения, я буду описывать только случай уменьшения размера изображения. Увеличение картинки – схожий процесс.
Идея алгоритма в том, чтобы удалять контент который имеет меньшее значения для пользователя (содержит меньше информации). Мы назовем меру этой информации “энергией”. В качестве такой функции, мы можем использовать градиент изображения в пространстве l1:
Если картинка имеет 3 канала, то в качестве градиента всего изображения используем сумму градиентов каждого канала. Matlab код ниже демонстрирует этот подход:
```
function res = energyRGB(I)
% returns energy of all pixelels
% e = |dI/dx| + |dI/dy|
res = energyGrey(I(:, :, 1)) + energyGrey(I(:, :, 2)) + energyGrey(I(:, :, 3));
end
function res = energyGrey(I)
% returns energy of all pixelels
% e = |dI/dx| + |dI/dy|
res = abs(imfilter(I, [-1,0,1], 'replicate')) + abs(imfilter(I, [-1;0;1], 'replicate'));
end
```
А так выглядит результат применения функции энергии используемому изображению:
##### Seam
Если мы удалим пиксели с минимальной энергией, но произвольной позицией, то изображение будет испорчено. Если мы удалим колонки/столбцы с минимальной энергией, то появятся нежелательные артефакты. Здесь под колонкой я подразумеваю {(i, j)| j зафиксированно}, а под столбцом {(i, j)| i зафиксированно}. Решение дилеммы – ввести обобщение понятия колонка/столбец.
Формально, пусть I это nxm изображение, тогда назовем вертикальным seam ,
где x: [1,..,n]->[1,..,m]. То есть вертикальный seam это путь от верха изображения до низа такой, что длинна пути это ширина изображения, и для каждого элемента (i, j), принадлежащего seam, следующий элемент может быть только (i+1, j-1), (i+1, j), (i+1, j +1). Аналогично, мы можем ввести горизонтальный seam. Примеры вертикальных и горизонтальный seams показаны ниже:
Нас интересуют seams с минимальной энергией 
Чтобы найти такой seam, используем динамическое программирование:
1. Нахождение матрицы M минимальной энергии для всех возможных seams для каждого (i, j):
* Заполнить первую строку M значениями из матрицы энергии e
* Для всех строк, начиная со второй:
M[i, j] = e[i, j] + min(M[i — 1, j], M[i, j], M[i +1, j]);
2. Найти минимальное значение в последней строке матрицы M и построить путь из этого пикселя до первой строки, выбирая на каждом шаге пискель с минимальной энергией (аналогично, для (i, j) рассматривать значения M в позициях [i — 1, j], [i, j], [i + 1, j]).
В целях эффективности, в Matlab коде я представляю seam с помощью nxm битовой матрицы. Если пиксель принадлежит seam, он помечен 0, иначе 1.
```
function [optSeamMask, seamEnergy] = findOptSeam(energy)
% finds optimal seam
% returns mask with 0 mean a pixel is in the seam
% find M for vertical seams
% for vertical - use I`
M = padarray(energy, [0 1], realmax('double')); % to avoid handling border elements
sz = size(M);
for i = 2 : sz(1)
for j = 2 : (sz(2) - 1)
neighbors = [M(i - 1, j - 1) M(i - 1, j) M(i - 1, j + 1)];
M(i, j) = M(i, j) + min(neighbors);
end
end
% find the min element in the last raw
[val, indJ] = min(M(sz(1), :));
seamEnergy = val;
optSeamMask = zeros(size(energy), 'uint8');
%go backward and save (i, j)
for i = sz(1) : -1 : 2
%optSeam(i) = indJ - 1;
optSeamMask(i, indJ - 1) = 1; % -1 because of padding on 1 element from left
neighbors = [M(i - 1, indJ - 1) M(i - 1, indJ) M(i - 1, indJ + 1)];
[val, indIncr] = min(neighbors);
seamEnergy = seamEnergy + val;
indJ = indJ + (indIncr - 2); % (x - 2): [1,2]->[-1,1]]
end
optSeamMask(1, indJ - 1) = 1; % -1 because of padding on 1 element from left
optSeamMask = ~optSeamMask;
end
```
Для того, чтобы найти горизонтальный seam, просто передайте транспонированную матрицу энергии в функцию findOptSeam.
##### Нахождение оптимального порядка удаления seams
Итак, теперь мы умеем находить минимальный seam и с помощью кода ниже можем удалить его из изображения:
```
function [optSeamMask, seamEnergy] = findOptSeam(energy)
% finds optimal seam
% returns mask with 0 mean a pixel is in the seam
% find M for vertical seams
% for vertical - use I`
M = padarray(energy, [0 1], realmax('double')); % to avoid handling border elements
sz = size(M);
for i = 2 : sz(1)
for j = 2 : (sz(2) - 1)
neighbors = [M(i - 1, j - 1) M(i - 1, j) M(i - 1, j + 1)];
M(i, j) = M(i, j) + min(neighbors);
end
end
% find the min element in the last raw
[val, indJ] = min(M(sz(1), :));
seamEnergy = val;
optSeamMask = zeros(size(energy), 'uint8');
%go backward and save (i, j)
for i = sz(1) : -1 : 2
%optSeam(i) = indJ - 1;
optSeamMask(i, indJ - 1) = 1; % -1 because of padding on 1 element from left
neighbors = [M(i - 1, indJ - 1) M(i - 1, indJ) M(i - 1, indJ + 1)];
[val, indIncr] = min(neighbors);
seamEnergy = seamEnergy + val;
indJ = indJ + (indIncr - 2); % (x - 2): [1,2]->[-1,1]]
end
optSeamMask(1, indJ - 1) = 1; % -1 because of padding on 1 element from left
optSeamMask = ~optSeamMask;
end
```
Этого набора операций уже достаточно, для того чтобы изменять размер изображения в ширину или в высоту, сохраняя важные детали – просто удаляем сколько нужно горизонтальные и вертикальные seams.
Но что если нам нужно одновременно уменьшить размер изображения по вертикали и по горизонтали? Как понять на каждой итерации что лучше в терминах минимизации энергии — удалить вертикальный seam или горизонтальный?
Эта проблема снова может быть решена с помощью динамического программирования. Пусть n' и m' — желаемый размер изображения (n’ < n, m’ < m). Введем матрицу T, которая определяет для каждого n’ x m’ стоимость оптимальной последовательности удаления вертикальный и горизонтальных seams. В целях удобства введем r = n – n’, m = m – m’, которые описывают количество вертикальных и горизонтальных удалений. В добавок к T, введем матрицу TBM размера r x c, которая для каждого T(i, j) хранит 0 или 1 в зависимости от того пришли мы в T(i, j) путем удаления вертикального (1) или горизонтального (0) seam. Псевдокод продемонстрирован ниже:
1. T(0, 0) = 0;
2. Инициализируем значения T на границе:
for all j {
T(0, j) = T(0, j — 1) + E(seamVertical);
}
for all i {
T(i, 0) = T(j — 1, 0) + E(seamHorizontal);
}
3. Инициализируем значения TBM на границе:
for all j { T(0, j) = 1; }
for all i { T(0, i) = 0; }
4. Заполнить T и TBM:
for i = 2 to r {
imageWithoutRow = image;
for j = 2 to c {
energy = computeEnergy(imageWithoutRow);
horizontalSeamEnergy = findHorizontalSeamEnergy(energy);
verticalSeamEnergy = findVerticalSeamEnergy(energy);
tVertical = T(i — 1, j) + verticalSeamEnergy;
tHorizontal = T(i, j — 1) \_ horizontalSeamEnergy;
if (tVertical < tHorizontal) {
T(i, j) = tVertical;
transBitMask(i, j) = 1
} else {
T(i, j) = tHorizontal;
transBitMask(i, j) = 0
}
// move from left to right — delete vertical seam
imageWithoutRow = removeVerticalSeam(energy);
}
energy = computeEnergy(image);
image = removeHorizontalSeam(energy);
}
5. Находим путь из T(r, c) в T(1, 1), удаляя строку или колонку в зависимости от значения TBM(i, j).
И реализация на Matlab:
```
function [T, transBitMask] = findTransportMatrix(sizeReduction, image)
% find optimal order of removing raws and columns
T = zeros(sizeReduction(1) + 1, sizeReduction(2) + 1, 'double');
transBitMask = ones(size(T)) * -1;
% fill in borders
imageNoRow = image;
for i = 2 : size(T, 1)
energy = energyRGB(imageNoRow);
[optSeamMask, seamEnergyRow] = findOptSeam(energy');
imageNoRow = reduceImageByMask(imageNoRow, optSeamMask, 0);
transBitMask(i, 1) = 0;
T(i, 1) = T(i - 1, 1) + seamEnergyRow;
end;
imageNoColumn = image;
for j = 2 : size(T, 2)
energy = energyRGB(imageNoColumn);
[optSeamMask, seamEnergyColumn] = findOptSeam(energy);
imageNoColumn = reduceImageByMask(imageNoColumn, optSeamMask, 1);
transBitMask(1, j) = 1;
T(1, j) = T(1, j - 1) + seamEnergyColumn;
end;
% on the borders, just remove one column and one row before proceeding
energy = energyRGB(image);
[optSeamMask, seamEnergyRow] = findOptSeam(energy');
image = reduceImageByMask(image, optSeamMask, 0);
energy = energyRGB(image);
[optSeamMask, seamEnergyColumn] = findOptSeam(energy);
image = reduceImageByMask(image, optSeamMask, 1);
% fill in internal part
for i = 2 : size(T, 1)
imageWithoutRow = image; % copy for deleting columns
for j = 2 : size(T, 2)
energy = energyRGB(imageWithoutRow);
[optSeamMaskRow, seamEnergyRow] = findOptSeam(energy');
imageNoRow = reduceImageByMask(imageWithoutRow, optSeamMaskRow, 0);
[optSeamMaskColumn, seamEnergyColumn] = findOptSeam(energy);
imageNoColumn = reduceImageByMask(imageWithoutRow, optSeamMaskColumn, 1);
neighbors = [(T(i - 1, j) + seamEnergyRow) (T(i, j - 1) + seamEnergyColumn)];
[val, ind] = min(neighbors);
T(i, j) = val;
transBitMask(i, j) = ind - 1;
% move from left to right
imageWithoutRow = imageNoColumn;
end;
energy = energyRGB(image);
[optSeamMaskRow, seamEnergyRow] = findOptSeam(energy');
% move from top to bottom
image = reduceImageByMask(image, optSeamMaskRow, 0);
end;
end
```
##### Заключение
Алгоритм работает хорошо на ландшафтных изображениях, см. gif демонстрирующий работу алгоритма в динамике (спасибо [shara](http://habrahabr.ru/users/shara/)):
Но как есть он плохо подходит для портретов или изображений насыщенных деталями. На ландшафтных изображениях небо или море — содержит мало информации, и изображение, как правило, уменьшается за счет них. Если же взять изображение содержащее много мелких деталей, то алгоритм даст не лучший результат (пример взят из статьи Avidan & A. Shamir):
Без участия пользователя не следует применять seam carving к портретным фотографиям, так как значимый для нас объект — человек — содержит меньше информации с точки зрения seam carving:
Алгоритм может быть применен для удаления помеченных объектов с изображения (пример взят из статьи Avidan & A. Shamir):
 | https://habr.com/ru/post/183638/ | null | ru | null |
# Новое в Git 3: замыкания
Git — популярная система контроля версий. В ней атомарное изменение одного или нескольких файлов называется коммитом, а несколько последовательно идущих коммитов объединяются в ветку. Ветки используются для того, чтобы реализовывать новые идеи (фичи).
[](https://habr.com/en/post/445676/)
Случается, что идея оказывается тупиковой, разработчик сворачивает не туда, и возникает необходимость отката к изначальной версии, для этого нужно забыть о новой ветви и переключиться на главную **dev** или **master**, и затем продолжить работу как ни в чем не бывало. В этом случае "отросток" повиснет навсегда, как и желание его удалить. Но как удалить, если это часть истории? Этот отросток показывает усилия трудяги-программиста, пусть и тщетные. Так легче отчитываться перед начальством, ведь неудачный результат — тоже результат!
Спешу обрадовать: разработчики Git в 3 версии введут новую команду для замыкания таких беспризорных ветвей. Напомню, что текущая актуальная версия — [2.21.0](https://git-scm.com/downloads).
Как использовать эту команду, что она дает и что думают IT компании? Статья отвечает на эти и другие вопросы.
Описание
--------
Теперь можно замкнуть неудачную ветку с одним из предыдущих коммитов. Желтым цветом на рисунках ниже раскрашены дуги замыкания.
Здесь коммит `4` — последний у неудачной фичи. Его замкнули с `1`, а затем вернулись в мастер и пошли по другому пути, с коммита `5`.
Также можно замыкать коммит в самого себя, таким образом создавая [петли](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%82%D0%BB%D1%8F_(%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D1%8F_%D0%B3%D1%80%D0%B0%D1%84%D0%BE%D0%B2)):
Можно замыкаться в любой коммит — умный Git сам подсчитает разницу и правильно все объединит:
Как пользоваться?
-----------------
В команду `merge` функциональность замыканий не вмержить, так как для первого случая ветвь будет [фаст-фордиться](https://stackoverflow.com/q/9069061/1046374), а для второго не будет ничего делать (`git already up to date`).
Чтобы не менять старое поведение, разработчики решили ввести команду для замыкания:
```
git closure -s $source_commit -d $dest_commit -m $message
```
Первым аргументом `-s $source_commit` задается хеш коммита, из которого нужно протянуть "петлю", а вторым, опциональным `-d $dest_commit`, задается коммит, в который петлю нужно замкнуть. Если он отсутствует, то замыкание происходит в текущую check-out ветвь. Параметром `-m $message` задается сообщение замыкания, типа `failed feature, revert to origin`. Впрочем, доступен и параметр `--allow-empty-message`, разрешающий коммиты без текста сообщения. По умолчанию Git разрешает ровно одно замыкание для пары коммитов. Для обхода этого ограничения доступна опция `--allow-multiple-closures`.
После исполнения команды гит сам вычислит изменения, и в конечном коммите станет виден двойной diff: из базовой и замыкающей ветвей. В общем случае это n-мерный diff, то есть выполнять замыкание можно сколько угодно раз. closure-commit похож на merge-commit с той разницей, что в нем хранится несколько сообщений, а не одно.
К сожалению, существующие GUI для работы с Git пока что до конца не поддерживают замыкания. Превью-версия [GitExtensions](https://github.com/gitextensions/gitextensions) строит кривые как у слияния вместо красивой дуги. Обратите внимание на новые поля `Closure message` и `Closure diff`:
Стоит отметить, что команда `closure` всегда изменяет историю (еще бы, теперь Git — полноценная машина времени!), поэтому пушить ветки теперь можно только с опцией `--force`, либо с помощью безопасной `--force-with-lease`.
Рибейзы для ветвей с петлями также доступны, правда, логика пересчета коммитов в них сложна.
Также опция `auto` позволяет автоматически замыкать все старые ветви. В этом случае замыкающий коммит тот, от которого пошло разветвление. С помощью плагинов к Git IDE замыкания можно запускать периодически. В GitExtensions аналогичный плагин **Delete obsolete branches** удаляет устаревшие ветви.
Мнение IT компаний
------------------
Крупные IT компании: Google, Facebook, Apple, DeepMind, Positive Technologies, а особенно Microsoft, с нетерпением ожидают замыканий, ведь теперь можно будет формализировать жизненный цикл ветвей, в том числе несмерженных.
Один из топ-менеджеров Microsoft, Михаэль Рихтер, [пишет](https://blogs.microsoft.com/git-closure):
> Новая возможность гита, безусловно, уменьшит хаос в мире Open Source разработки и не только. В наших репозиториях очень много "висящих" ветвей. Например, в [vscode](https://github.com/Microsoft/vscode) их более 200, а в [TypeScript](https://github.com/Microsoft/TypeScript) их вообще более 300! И это проблема не только Microsoft. Замыкания не только улучшают организацию, но и позволяют отслеживать рассуждения программиста, порой совсем непонятные даже коллегам :) Замыкания напомнили мне фильм "Back to the Future" — там герои путешествовали в прошлое и будущее. Я люблю этот фильм, несколько раз его пересматривал. И думаю, что полюблю гит из-за этого еще больше :)
На заметку
----------
Если раньше граф коммитов представлял из себя [направленный ациклический граф](https://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) (DAG), то замыкания расширяют его до обобщенного [ориентированного графа](https://ru.wikipedia.org/wiki/%D0%9E%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B3%D1%80%D0%B0%D1%84). С помощью Git можно будет описывать регулярные выражения, в которых состояниями будут коммиты, а алфавитом — множество всех сообщений. Но это попахивает хабом "ненормальное программирование", а потому выходит за рамки статьи. Однако если вам такое интересно, то ознакомьтесь со [статьей](https://habr.com/post/351158/), описывающей, как можно хранить генеалогические деревья внутри Git. | https://habr.com/ru/post/445676/ | null | ru | null |
# Использование паттерна MVC при проектировании TableView
Привет, Хабр! Представляю вашему вниманию перевод статьи [«iOS Tableview with MVC»](https://medium.com/ios-os-x-development/ios-tableview-with-mvc-a05103c01110), опубликованной в октябре 2016 года на Medium.com разработчиком Stan Ostrovskiy.
*Пример использования UITableView в приложении*
В данной статье на конкретном примере вы сможете ознакомиться с применением популярного паттерна MVC, при проектировании одного из самых популярных элементов интерфейса *UITableView*. Также данная статья в довольно понятном и доступном виде дает возможность понять базовые архитектурные принципы при проектировании вашего приложения, а также дает возможность ознакомиться с элементом *UITableView*. Учитывая тот факт, что немалое количество разработчиков часто пренебрегают какими-либо архитектурными решениями при создании своих приложений, считаю что данная статья будет очень полезна как для начинающих разработчиков, так и для программистов с определенным опытом. Паттерн MVC продвигается самой компанией Apple и является самым популярным шаблоном, используемым при разработке под iOS. Это не значит, что он подходит для любых задач и всегда является оптимальным выбором, но, во-первых, с помощью MVC проще всего получить общее понимание построения архитектуры вашего приложения, и, во-вторых, довольно часто MVC действительно хорошо подходит для решения определенных задач проекта. Данная статья поможет вам структурировать ваш код, сделать его удобным, переиспользуемым, читаемым и компактным.
Если вы занимаетесь разработкой iOS проектов, то вы уже знаете что одним из самых используемых компонентов является *UITableView*. Если же вы пока не разрабатываете под iOS, то в любом случае можете увидеть что *UITableView* используется во многих современных приложениях, таких как Youtube, Facebook, Twitter, Medium, а также в подавляющем большинстве мессенджеров и т.д. Проще говоря, каждый раз, когда вам необходимо отображать переменное количество объектов данных, вы используете *UITableView*.
*Другой базовый компонент для этих целей это CollectionView, который лично я предпочитаю использовать, потому что он более гибкий чем TableView.*
Итак, вы хотите добавить *UITableView* в ваш проект.
Самый очевидный путь, которым обычно идут это *UITableViewController*, в который уже сразу встроен *UITableView*. Его настройка довольно проста, вам необходимо добавить свой массив данных и создать ячейку таблицы. Это выглядит просто и работает так как мы хотим, кроме нескольких моментов: во-первых, код *UITableViewController* становится огромным и во-вторых, это ломает всю концепцию паттерна MVC.
*Даже если вы не хотите иметь дело ни с какими паттернами проектирования, вы в любом случае скорее всего захотите разбить на части код *UITableViewController*, состоящий из нескольких тысяч строк.*
Существует несколько методов передачи данных между Model и Controller, в это статье я буду использовать делегирование. Этот подход позволяет получить понятный, модульный и переиспользуемый код.
Вместо использования одного *UITableViewController*, мы разобьем его на несколько классов:
* DRHTableViewController: мы сделаем его подклассом *UIViewController*, и добавим *UITableView* как его подвид(subview)
* DRHTableViewCell: подкласс *UITableViewCell*
* DRHTableViewDataModel: этот класс будет заниматься запросами API, формировать данные и возвращать их в *DRHTableViewController* используя делегирование
* DRHTableViewDataModelItem: простой класс, который содержит данные, которые мы будем отображать в ячейке *DRHTableViewCell*
Давайте начнем с UITableViewCell
**Часть 1: TableViewCell**
Создайте новый проект как “Single View Application”, и удалите стандартные файлы ViewController.swift и Main.storyboard. Все файлы которые нам потребуются мы создадим позже, шаг за шагом.
Для начала создайте подкласс *UITableViewCell*. Если вы хотите использовать XIB-файл, отметьте опцию “Also create XIB file”.
Для этого примера мы используем ячейку таблицы со следующими полями:
1. Avatar Image (изображение пользователя)
2. Name Label (имя пользователя)
3. Date Label (дата)
4. Article Title (заголовок статьи)
5. Article Preview (предпросмотр статьи)
Вы можете использовать Autolayout как угодно, потому что дизайн ячейки таблицы не влияет ни на что, из того что мы делаем в данном руководстве. Создайте outlet для каждого подвида(subview). Ваш файл *DRHTableViewCell.swift* должен выглядеть следующим образом:
```
class DRHTableViewCell: UITableViewCell {
@IBOutlet weak var avatarImageView: UIImageView?
@IBOutlet weak var authorNameLabel: UILabel?
@IBOutlet weak var postDateLabel: UILabel?
@IBOutlet weak var titleLabel: UILabel?
@IBOutlet weak var previewLabel: UILabel?
}
```
*Как вы можете заметить, я поменял все дефолтные значения @IBOutlet с "!" на "?". Каждый раз, когда вы добавляете UILabel из InterfaceBuilder в ваш код, то к переменной автоматически в конце добавляется "!", это означает что переменная объявлена как неявно извлекаемый опционал. Так происходит чтобы обеспечить совместимость с API Objective-C, но я предпочитаю не пользоваться принудительным извлечением, поэтому использую вместо этого обычные опционалы.*
Далее нам необходимо добавить метод для инициализации всех элементов ячейки таблицы(ярлыки, картинки и тд.). Вместо использования отдельных переменных для каждого элемента давайте создадим небольшой класс *DRHTableViewDataModelItem*.
```
class DRHTableViewDataModelItem {
var avatarImageURL: String?
var authorName: String?
var date: String?
var title: String?
var previewText: String?
}
```
*Дату конечно лучше хранить как тип Date, но для упрощения, в нашем примере будем хранить ее как String.*
Все переменные являются опционалами, поэтому можно не переживать за их значения по умолчанию. Чуть позже мы напишем Init(), а теперь давайте вернемся к *DRHTableViewCell.swift* и добавим следующий код, который проинициализирует все элементы нашей ячейки таблицы.
```
func configureWithItem(item: DRHTableViewDataModelItem) {
// setImageWithURL(url: item.avatarImageURL)
authorNameLabel?.text = item.authorName
postDateLabel?.text = item.date
titleLabel?.text = item.title
previewLabel?.text = item.previewText
}
```
*Метод SetImageWithURL зависит от того как вы собираетесь работать подгрузкой изображений в проекте, поэтому я не буду описывать его в данной статье.*
Теперь, когда у нас готова ячейка, можно переходить к таблице TableView
**Часть 2: TableView**
В этом примере будем использовать *viewController* в Storyboard. Сначала создадим подкласс *UIViewController*:
В данном проекте я буду использовать *UIViewController* вместо *UITableViewController*, чтобы расширить возможности контроля на элементами. Также, использование *UITableView* в качестве подвида, позволит вам разместить таблицу как угодно, при помощи *Autolayout*. Далее, создадим файл storyboard и дадим ему аналогичное имя *DRHTableViewController*. Перетащите *ViewController* из библиотеки с объектами и впишите в него имя класса:
Добавьте *UITableView* привяжите ее ко всем четырем краям контроллера:
И в конце добавьте аутлет *tableView* в *DRHTableViewController*:
```
class DRHTableViewController: UIViewController {
@IBOutlet weak var tableView: UITableView?
}
```
Мы уже создали *DRHTableViewDataModelItem*, поэтому можем добавить следующую локальную переменную в класс:
```
fileprivate var dataArray = [DRHTableViewDataModelItem]()
```
Эта переменная хранит данные, которые мы будем отображать в таблице.
*Обратите внимание, что мы не инициализируем этот массив в классе ViewController: это просто пустой массив для данных. Мы заполним его данными позже, с помощью делегирования.*
Теперь установите все основные свойства *tableView* в методе *viewDidLoad*. Вы можете настроить цвета и стили как вам хочется, единственное свойство которое нам обязательно понадобится в этом примере это *registerNib*:
```
tableView?.register(nib: UINib?, forCellReuseIdentifier: String)
```
Вместо того чтобы создавать nib перед вызовом этого метода и вписывать длинный и сложный идентификатор нашей ячейки, мы сделаем и Nib и ReuseIdentifier свойствами класса *DRHTableViewCell*
*Всегда старайтесь избегать использования длинных и сложных идентификаторов в теле проекта. Если нет никаких других вариантов, можно сделать строковую переменную и присвоить ей это значение.*
Откройте *DRHTableViewCell* и добавьте следующий код в начало класса:
```
class DRHMainTableViewCell: UITableViewCell {
class var identifier: String {
return String(describing: self)
}
class var nib: UINib {
return UINib(nibName: identifier, bundle: nil)
}
.....
}
```
Сохраните изменения и вернитесь в DRHTableViewController. Вызов метода registerNib станет выглядеть намного проще:
```
tableView?.register(DRHTableViewCell.nib, forCellReuseIdentifier: DRHTableViewCell.identifier)
```
Не забудьте настроить *tableViewDataSource* и *TableViewDelegate* на self.
```
override func viewDidLoad() {
super.viewDidLoad()
tableView?.register(DRHTableViewCell.nib, forCellReuseIdentifier:
DRHTableViewCell.identifier)
tableView?.delegate = self
tableView?.dataSource = self
}
```
Как только вы это сделаете, компилятор выдаст ошибку: “*Cannot assign value of type DRHTableViewController to type UITableViewDelegate*”(Не могу присвоить значение типа *DRHTableViewController* типу *UITableViewDelegate*).
*Когда вы используете подкласс UITableViewController, у вас уже есть встроенные delegate и datasource. Если же вы добавляете UITableView как подвид UIViewController, вам необходимо реализовывать соответствие UIViewController протоколам UITableViewControllerDelegate и UITableViewControllerDataSource самостоятельно.*
Чтобы избавиться от данной ошибки, просто добавьте два расширения классу *DRHTableViewController*:
```
extension DRHTableViewController: UITableViewDelegate {
}
extension DRHTableViewController: UITableViewDataSource {
}
```
После этого появится другая ошибка: *“Type DRHTableViewController does not conform to protocol UITableViewDataSource”*(Тип *DRHTableViewController* не соответствует протоколу *UITableViewDataSource*). Это происходит потому что существует несколько обязательных методов, которые необходимо реализовать в этих расширениях.
```
extension DRHTableViewController: UITableViewDataSource {
func tableView(_ tableView: UITableView, cellForRowAt
indexPath: IndexPath) -> UITableViewCell {
}
func tableView(_ tableView: UITableView, numberOfRowsInSection
section: Int) -> Int {
}
}
```
*Все методы в UITableViewDelegate являются необязательными, поэтому ошибок не будет если вы их не переопределите. Кликните мышкой с зажатым «Command» на UITableViewDelegate, чтобы посмотреть какие методы доступны. Самые часто используемые это методы выбора ячеек таблицы, установки высоты ячейки таблицы и конфигурации верхнего и нижнего заголовков таблицы.*
Как вы могли заметить, два метода, упомянутые выше, должны возвращать значение, поэтому вы снова видите ошибку *”Missing return type”*(Отсутствует возвращаемое значение). Давайте это поправим. Для начала установим количество столбцов в секции: мы уже объявили массив данных *dataArray*, поэтому мы можем просто взять его количество элементов:
```
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return dataArray.count
}
```
Некоторые могли заметить, что я не переопределил другой метод: *numberOfSectionsInTableView*, который обычно используется в *UITableViewController*. Этот метод необязательный и он возвращает значение по умолчанию равное единице. В данном примере у нас только одна секция в *tableView*, поэтому нет никакой необходимости переопределять данный метод.
Последний шаг в конфигурировании *UITableViewDataSource* это настройка ячейки таблицы в методе *cellForRowAtIndexPath*:
```
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
if let cell = tableView.dequeueReusableCell(withIdentifier:
DRHTableViewCell.identifier, for: indexPath) as? DRHTableViewCell
{
return cell
}
return UITableViewCell()
}
```
Давайте рассмотрим его построчно.
Для того чтобы создать ячейку таблицы, мы вызываем метод *dequeueReusableCell* с идентификатором *DRHTableViewCell*. Он возвращает *UITableViewCell*, и, соответственно, мы используем опциональное приведение типов из *UITableViewCell* в *DRHTableViewCell*:
```
let cell = tableView.dequeueReusableCell(withIdentifier:
DRHTableViewCell.identifier, for: indexPath) as? DRHTableViewCell
```
Далее мы производим безопасное извлечение опционала и в случае успеха возвращаем ячейку:
```
if let cell = tableView.dequeueReusableCell(withIdentifier:
DRHTableViewCell.identifier, for: indexPath) as? DRHTableViewCell
{
return cell
}
```
Если же не получилось извлечь значение, то возвращаем ячейку по умолчанию *UITableViewCell*:
```
if let cell = tableView.dequeueReusableCell(withIdentifier:
DRHTableViewCell.identifier, for: indexPath) as? DRHTableViewCell
{
return cell
}
return UITableViewCell()
```
Может мы все-таки что-то забыли? Да, нам надо проинициализировать ячейку данными:
```
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
if let cell = tableView.dequeueReusableCell(withIdentifier:
DRHTableViewCell.identifier, for: indexPath) as? DRHTableViewCell
{
cell.configureWithItem(item: dataArray[indexPath.item])
return cell
}
return UITableViewCell()
}
```
Теперь мы готовы к заключительной части: надо создать и подключить *DataSource* к нашей *TableView*
**Часть 3: DataModel**
Создайте класс *DRHDataModel*.
Внутри этого класса мы запрашиваем данные либо из файла JSON, либо с помощью HTTP-
запроса или просто из локального файла с данными. Это не то, на чем бы мне хотелось сосредоточиться в данной статье, поэтому, поэтому я предположу что мы уже сделали API-запрос и он вернул нам опциональный массив типа AnyObject и опциональную ошибку Error:
```
class DRHTableViewDataModel {
func requestData() {
// code to request data from API or local JSON file will go
here
// this two vars were returned from wherever:
// var response: [AnyObject]?
// var error: Error?
if let error = error {
// handle error
} else if let response = response {
// parse response to [DRHTableViewDataModelItem]
setDataWithResponse(response: response)
}
}
}
```
В методе *setDataWithResponse* мы заполним массив из *DRHTableViewDataModelItem*, используя полученный в запросе массив. Добавьте следующий код ниже *requestData*:
```
private func setDataWithResponse(response: [AnyObject]) {
var data = [DRHTableViewDataModelItem]()
for item in response {
// create DRHTableViewDataModelItem out of AnyObject
}
}
```
Как вы помните, мы не еще не создали никакого инициализатора для *DRHTableViewDataModel*. Поэтому давайте вернемся в класс *DRHTableViewDataModel* и добавим метод для инициализации. В этом случае мы будем использовать опциональный инициализатор со словарем [String: String]?..
```
init?(data: [String: String]?) {
if let data = data, let avatar = data[“avatarImageURL”], let name = data[“authorName”], let date = data[“date”], let title = data[“title”], let previewText = data[“previewText”] {
self.avatarImageURL = avatar
self.authorName = name
self.date = date
self.title = title
self.previewText = previewText
} else {
return nil
}
}
```
Если какое-либо поле будет отсутствовать в словаре, или сам словарь будет nil, инициализация не пройдет (вернет nil).
Имея данный инициализатор мы можем создать метод *setDataWithResponse* в классе *DRHTableViewDataModel*:
```
private func setDataWithResponse(response: [AnyObject]) {
var data = [DRHTableViewDataModelItem]()
for item in response {
if let drhTableViewDataModelItem =
DRHTableViewDataModelItem(data: item as? [String: String]) {
data.append(drhTableViewDataModelItem)
}
}
}
```
После завершения цикла for у нас будет готовый заполненный массив из *DRHTableViewDataModelItem*. Как же теперь передать этот массив в *TableView*?
**Часть 4: Delegate**
Сначала создайте протокол делегата *DRHTableViewDataModelDelegate* в файле *DRHTableViewDataModel.swift* сразу над объявлением класса *DRHTableViewDataModel*:
```
protocol DRHTableViewDataModelDelegate: class {
}
```
Внутри этого протокола мы также создадим два метода:
```
protocol DRHTableViewDataModelDelegate: class {
func didRecieveDataUpdate(data: [DRHTableViewDataModelItem])
func didFailDataUpdateWithError(error: Error)
}
```
*Ключевое слово «class» в протоколе ограничивает применяемость протокола до типов класса(исключая структуры и перечисления). Это важно, если мы собираемся использовать слабую ссылку на делегата. Мы должны быть уверены, что не создадим цикл сильных ссылок между делегатом и делегируемыми объектами, поэтому мы используем слабую ссылку(см. ниже)*
Далее добавьте опциональную слабую переменную в класс *DRHTableViewDataModel*:
```
weak var delegate: DRHTableViewDataModelDelegate?
```
Теперь нам необходимо добавить метод делегата. В данном примере, нам необходимо передать ошибку Error, в случае если запрос данных не прошел, в случае же успешного запроса мы создадим массив данных. Метод обработчика ошибки находится внутри метода *requestData*
```
class DRHTableViewDataModel {
func requestData() {
// code to request data from API or local JSON file will go
here
// this two vars were returned from wherever:
// var response: [AnyObject]?
// var error: Error?
if let error = error {
delegate?.didFailDataUpdateWithError(error: error)
} else if let response = response {
// parse response to [DRHTableViewDataModelItem]
setDataWithResponse(response: response)
}
}
}
```
И, наконец, добавьте второй метод делегата в конец метода *setDataWithResponse*:
```
private func setDataWithResponse(response: [AnyObject]) {
var data = [DRHTableViewDataModelItem]()
for item in response {
if let drhTableViewDataModelItem =
DRHTableViewDataModelItem(data: item as? [String: String]) {
data.append(drhTableViewDataModelItem)
}
}
delegate?.didRecieveDataUpdate(data: data)
}
```
Теперь мы готовы передать данные в *tableView*.
**Часть 5: Отображение данных**
С помощью *DRHTableViewDataModel* мы можем заполнить наш *tableView* данными. Для начала нам надо создать ссылку на *dataModel* внутри *DRHTableViewController*:
```
private let dataSource = DRHTableViewDataModel()
```
Далее, нам необходимо сделать запрос данных. Я сделаю это внутри *ViewWillAppear*, чтобы данные обновлялись каждый раз, когда открывается страница.
```
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(true)
dataSource.requestData()
}
```
*Это простой пример, поэтому я делаю запрос данных в viewWillAppear. В реальном же приложении это будет зависеть от множества факторов, таких как время кэширования данных, использования API, и логики работы приложения.*
Далее, установим делегата на self, в методе *ViewDidLoad*:
```
dataSource.delegate = self
```
Вы снова увидите ошибку, потому что *DRHTableViewController* пока еще не реализует функции *DRHTableViewDataModelDelegate*. Исправьте это, добавив следующий код в конец файла:
```
extension DRHTableViewController: DRHTableViewDataModelDelegate {
func didFailDataUpdateWithError(error: Error) {
}
func didRecieveDataUpdate(data: [DRHTableViewDataModelItem]) {
}
}
```
И наконец, нам надо обработать события *didFailDataUpdateWithError* и *didRecieveDataUpdate*:
```
extension DRHTableViewController: DRHTableViewDataModelDelegate {
func didFailDataUpdateWithError(error: Error) {
// handle error case appropriately (display alert, log an error, etc.)
}
func didRecieveDataUpdate(data: [DRHTableViewDataModelItem]) {
dataArray = data
}
}
```
Как только мы инициализируем данными наш локальный массив *dataArray*, мы готовы обновить таблицу. Но вместо того чтобы делать это в методе *didRecieveDataUpdate*, мы используем обозреватель свойства *dataArray*:
```
fileprivate var dataArray = [DRHTableViewDataModelItem]() {
didSet {
tableView?.reloadData()
}
}
```
Код внутри *didSet* выполнится сразу же после инициализации *dataArray*, то есть именно тогда когда нам надо.
Вот и все! Теперь у вас есть работающий прототип *tableView*, с индивидуально сконфигурированной ячейкой таблицы и инициализированной данными. И у вас нет никаких классов *tableViewController*'а c несколькими тысячами строк кода. Каждый блок кода который вы создали является переиспользуемым и может быть использован повторно в любом месте проекта, что дает неоспоримые преимущества.
Для вашего удобства, вы можете ознакомиться с полным кодом проекта по следующей [ссылке](https://github.com/Stan-Ost/DRHTableViewTutorial/tree/master/DRHTableViewTutorial) на Github. | https://habr.com/ru/post/354326/ | null | ru | null |
# Как и зачем я отключил свой фавикон
Если вдруг кому интересно то я веду [телеграм канал по фронтенду](https://t.me/frontendnoteschannel) где выкладываю интересные статьи на разные темы а так же сам периодически пишу шорт-риды которые могут быть вам полезны.
---
Перевод статьи "[Disabling My Favicon: How and Why](https://hackernoon.com/disabling-my-favicon-how-and-why)"
Привет Хабр! Недавно в недельной подборке я увидел эту статейку на английском языке и решил ее перевести так как она показалась мне довольно интересной. Далее перевод.
И так начнем: на моем сайте нет фавикона, и, скорее всего, его никогда не будет.
Нельзя с полной уверенностью сказать, почему я пришел к такому решению, но, учитывая тот момент, что у меня нет логотипа — и я действительно не хочу его иметь — то и создание значка для сайта мне показалось излишним.
Но есть проблемка, фавикон нельзя просто не задать, поскольку большинство веб-браузеров все равно попытаются его запросить. А это в свою очередь означает, что при каждой загрузке страницы будет повторный запрос файла favicon.ico, который определится как Not Found.
Не знаю как вас, а меня это раздражает.
Итак, что же нам делать?
Самый простой способ решить эту проблему это сделать прозрачную фавиконку, но это не решает мою проблему так как я хочу избавиться от лишнего запроса а не просто получить успешный ответ при запросе.
Попытка первая
--------------
Хотя пропуск тега icon и не приводит к желаемому результату, я решил поэкспериментировать со значениями, которые он дает. Моей первой попыткой было использовать простой хэш:
В целом, хоть это и помогло устранить ответ 404 Not Found в запросе, но затем я столкнулся с другой проблемой - повторно запрошена вся страница. Это объясняется тем, что # в конечном итоге интерпретируется браузером как https://flower.codes/#, как практически и любой другой символ, с которым вы, возможно, захотите поэкспериментировать (пробелы, вопросительные знаки и т. д.).
**Итог этого решения:** не подходит.
Попытка вторая
--------------
И так, мы не можем просто пропустить фавикон и не можем использовать произвольный символ... Что же тогда делать?
Немного покопавшись, я наткнулся на концепцию, с которой большинство веб-разработчиков довольно хорошо знакомы: Data URLs.
Для непосвященных: URI данных позволяют встраивать файлы непосредственно в HTML, а не выполнять внешний запрос. Если максимально упростить, они обычно состоят из определения типа загружаемого файла (например, text/html или text/plain) и содержимого файла.
Это означает, что вместо загрузки внешнего файла вы можете включить его в строку следующим образом:
`data:text/html,alert('hi');`
Однако для наших целей мы можем определить Data URL, который фактически является пустым, просто опустив как тип контента, так и само содержимое:
**Итог этого решения:** подходит.
**Хорошо, но... Зачем?**
Как и ожидалось, это решило мою проблему. Включив содержимое напрямую и оставив его пустым, мы можем устранить повторный запрос, не вызывая никаких ошибок в консоли.
Но зачем мне все эти проблемы?
Хотите верьте, хотите нет, но мне на самом деле нравятся фавиконки. Я думаю, что они значительно упрощают организацию вкладок и закладок. Но во всемирной паутине, плотно заполненной ими, отказ от одного на моем собственном сайте казался маленьким способом выделиться (а пройти лишнюю милю, чтобы сделать это «правильным» способом – это просто вишенка на торте).
Если вдруг кому интересно то я веду [телеграм канал по фронтенду](https://t.me/frontendnoteschannel) где выкладываю интересные статьи на разные темы а так же сам периодически пишу шорт-риды которые могут быть вам полезны. | https://habr.com/ru/post/669028/ | null | ru | null |
# Введение в модульное тестирование T-SQL помощью tSQLt
tSQLt — это мощный фреймворк с открытым исходным кодом для модульного тестирования кода SQL Server.
Модульное тестирование SQL-кода — полезная практика в разработке баз данных, которая позволяет обнаруживать ошибки до попадания их в продакшн. Хотя надо сказать, есть разные мнения, и некоторые разработчики все еще спорят о необходимости модульного тестирования SQL-кода. Модульное тестирование очень важно для контроля и проверки поведения отдельных частей базы данных и не стоит игнорировать написание модульных тестов кода базы данных. По сути, модульные тесты позволяют автоматически проверять поведение объектов базы данных (хранимых процедур, триггеров, функций и т. д.) при регрессионном тестировании.
В части тестирования SQL-кода у tSQLt есть ряд преимуществ:
* Тесты пишутся на языке T-SQL. Это основное преимущество. Нет необходимости в изучении нового языка программирования или платформы для написания и выполнения SQL-тестов. Для теста нужна только база данных с установленным tSQLt и SQL Server Management Studio или любой другой редактор запросов.
* Каждый модульный тест автоматически запускается в рамках транзакции. После выполнения теста все операции изменения данных автоматически откатываются и нет необходимости в какой-либо очистке данных.
* tSQLt позволяет использовать заглушки (mock, fake) реальных объектов. Заглушки/фейки имитируют поведение реального объекта, что позволяет изолировать зависимости и писать изолированные тесты. Например, нам нужно протестировать хранимую процедуру, использующую внутри пользовательскую функцию. Мы можем изолировать тест хранимой процедуры, написав mock-функцию, используемую только в рамках данного теста.
* tSQLt полностью бесплатен и с открытым исходным кодом.
* tSQLt можно интегрировать в SSDT-проекты. Для интеграции с Visual Studio можно использовать [tSQLt Test Adapter for Visual Studio 2017](https://marketplace.visualstudio.com/items?itemName=vs-publisher-263684.tSQLtTestAdapterforVisualStudio2017) или [ApexSQL Unit Test](https://www.apexsql.com/sql-tools-unit-test.aspx).
### Установка tSQLt
Установка tSQLt очень проста. Сначала нужно включить CLR (SQL Common Language Runtime) и свойство `TRUSTWORTHY` базы данных, в которую устанавливается tSQLt.
```
EXEC sp_configure 'clr enabled', 1;
RECONFIGURE;
GO
EXEC sp_configure 'clr enabled'
```
В этой статье мы будем использовать демонстрационную базу данных [WideWorldImporters](https://docs.microsoft.com/en-us/sql/samples/wide-world-importers-what-is?view=sql-server-2017).
```
USE WideWorldImporters
GO
ALTER DATABASE WideWorldImporters SET TRUSTWORTHY ON;
```
Далее скачиваем архив tSQLt с [tsqlt.org](https://tsqlt.org/downloads/).
Выполняем содержимое файла tSQLt.class.sql в SQL Server Management Studio. Если установка прошла успешно, вы увидите сообщение "Thank you for using tSQLt" и версию tSQLt.
Примечание — в Azure SQL включать CLR и TRUSTWORTHY не нужно, достаточно выполнить файл tSQLt.class.sql.
Проверить установку компонент tSQLt можно с помощью следующего запроса:
```
SELECT @@VERSION,name
FROM sys.objects sysobj where schema_id = (
select sch.schema_id from sys.schemas sch where name='tSQLt' )
order by sysobj.name
```
### Пишем первый тест
Сначала нужно создать "тест-класс" (тестовый класс), который группирует тесты (test case). Приведенный ниже скрипт создает новый класс с именем `DemoUnitTestClass`.
```
USE WideWorldImporters
GO
EXEC tSQLt.NewTestClass 'DemoUnitTestClass';
```
Тестовый класс tSQLt, по сути, представляет собой схему БД с дополнительным расширенным свойством с информацией о том, что данная схема создана для тестового класса. В этом можно убедиться с помощью следующего запроса:
```
select SCHEMA_NAME,objtype,name,value from INFORMATION_SCHEMA.SCHEMATA SC
CROSS APPLY fn_listextendedproperty (NULL, 'schema', NULL, NULL, NULL, NULL, NULL) OL
WHERE OL.objname=sc.SCHEMA_NAME COLLATE Latin1_General_CI_AI
and SCHEMA_NAME = 'DemoUnitTestClass'
```
Также это можно посмотреть через SSMS в расширенных свойствах (extended properties) схемы.
* Откройте в SSMS узел **Security**->**Schemas** для базы данных.
* Щелкните правой кнопкой мыши на схеме DemoUnitTestClass и откройте свойства (**Properties**).
* Выберите страницу **Extended Properties**.
Для удаления класса можно использовать хранимую процедуру tSQLt.DropClass, принимающую в параметре имя тестового класса.
```
EXEC tSQLt.DropClass 'DemoUnitTestClass'
```
Хранимая процедура `DropClass` удаляет не только сам класс (схему), но и все тестовые объекты, связанные с этим классом. Если создать класс с уже существующим именем, то поведение будет аналогично процедуре DropClass: удаляются все объекты, связанные с тестовым классом, и создается пустой тестовый класс с указанным именем.
#### Ассерты в tSQLt
Для проверки результата выполнения tSQLt предлагает несколько хранимых процедур:
* tSQLt.AssertEquals
* tSQLr.AssertEqualsTable
* tSQLt.AssertEmptyTable
* tSQLt.AssertEqualsString
* tSQLt.AssertEqualsTableSchema
* tSQLt.AssertLike
* tSQLt.AssertNotEquals
* tSQLt.AssertObjectDoesNotExist
* tSQLt.AssertObjectExists
* tSQLt.AssertResultSetsHaveSameMetaData
* tSQLt.Fail
Рассмотрим подробнее tSQLt.AssertEquals.
Процедура tSQLt.AssertEquals сравнивает ожидаемое и фактическое значение и принимает три параметра:
* [@expected](/users/expected) — ожидаемое значение, которое будет сравниваться с проверяемым значением.
* [@actual](/users/actual) — полученный результат, который и тестируем.
* [@message](/users/message) — сообщение, которое выводится при падении теста.
Давайте напишем простой модульный тест функции, вычисляющей налог для суммы, переданной в параметре.
Сама функция `CalculateTaxAmount`:
```
CREATE OR ALTER FUNCTION CalculateTaxAmount(@amt MONEY)
RETURNS MONEY
AS BEGIN
RETURN (@amt /100)*18
END;
GO
select dbo.CalculateTaxAmount(100) AS TaxAmount
```
В этом примере мы передаем в параметре 100 и получаем в результате 18. Теперь напишем тест для этой функции.
```
EXEC tSQLt.NewTestClass 'DemoUnitTestClass';
GO
CREATE OR ALTER PROC DemoUnitTestClass.[test tax amount]
AS
BEGIN
DECLARE @TestedAmount as money = 100
DECLARE @expected as money = 18
DECLARE @actual AS money
SET @actual = dbo.CalculateTaxAmount(100)
EXEC tSQLt.AssertEquals @expected , @actual
END
```
Для выполнения теста используется хранимая процедура tSQLt.Run. В параметре можно передать имя тестового класса, чтобы запустить все тесты, связанные с указанным классом, или указать конкретный тест.
```
tSQLt.Run 'DemoUnitTestClass.[test tax amount]'
```
```
tSQLt.Run 'DemoUnitTestClass'
```
Как видно, наш тест выполнился успешно. Давайте изменим ожидаемый результат и повторно запустим тест.
```
CREATE OR ALTER PROC DemoUnitTestClass.[test tax amount]
AS
BEGIN
DECLARE @TestedAmount as money = 100
DECLARE @expected as money = 20
DECLARE @actual AS money
SET @actual = dbo.CalculateTaxAmount(100)
EXEC tSQLt.AssertEquals @expected , @actual
END
GO
tSQLt.Run 'DemoUnitTestClass.[test tax amount]'
```
Тест упал. Сообщения о результатах выполнения теста вполне понятные. В первой строке мы можем увидеть причины падения теста: ожидаемые и фактические значения различны.
Важный момент — именование тестов. Имена тестов должны начинаться с "test". Если назвать по-другому, то tSQLt не сможет найти и выполнить тест.
```
CREATE OR ALTER PROC DemoUnitTestClass.[test tax amount]
AS
BEGIN
DECLARE @TestedAmount as money = 100
DECLARE @expected as money = 20
DECLARE @actual AS money
DECLARE @Message AS VARCHAR(500)='Wrong tax amount'
SET @actual = dbo.CalculateTaxAmount(100)
EXEC tSQLt.AssertEquals @expected , @actual ,@Message
END
GO
tSQLt.Run 'DemoUnitTestClass.[test tax amount]'
```
Мы рассмотрели только самый базовый пример, в реальном мире, конечно, тесты могут быть намного сложнее. Поэтому необходимо хорошо понимать паттерн Arrange-Act-Assert относительно SQL-тестов. Этот паттерн предлагает разделять тест на три части:
* **Arrange** — объявление переменных, определение предварительных условий и входных данных.
* **Act** — выполнение проверяемого кода и фиксация результата выполнения.
* **Assert** — сравнение ожидаемого и фактического значения.
Укажем в нашем тесте эти части в комментариях:
```
CREATE OR ALTER PROC DemoUnitTestClass.[test tax amount]
AS
BEGIN
----------------------Arrange-----------------------------
DECLARE @TestedAmount as money = 100 ---
DECLARE @expected as money = 20 ---
DECLARE @actual AS money ---
DECLARE @Message AS VARCHAR(500)='Wrong tax amount' ---
----------------------------------------------------------
----------------------Act---------------------------------
SET @actual = dbo.CalculateTaxAmount(100) ---
----------------------------------------------------------
----------------------Assert------------------------------
EXEC tSQLt.AssertEquals @expected , @actual ,@Message ---
----------------------------------------------------------
END
```
### Заключение
В этой статье мы поговорили о важности модульного тестирования SQL-кода и о том, как реализовать этот подход с помощью фреймворка tSQLt.
---
Модульное тестирование кода бэкенда прочно вошло в нашу жизнь, но код базы данных по-прежнему мало кто тестирует. Приглашаем всех заинтересованных на открытое занятие «Тестирование T-SQL кода с помощью tSqlt». На этом уроке поговорим о модульном тестировании кода SQL Server и использовании для этого tSqlt. Регистрация открыта [по ссылке.](https://otus.pw/VhzW/) | https://habr.com/ru/post/710934/ | null | ru | null |
# GNS3 1.0 beta и Cisco IOU
Всем привет!
Совсем недавно вышла [публичная бета](http://new.gns3.net/personal.php) популярного симулятора сетевого оборудования GNS3 1.0. Интересен он в первую очередь тем, что стал поддерживать switching (раньше поддерживал лишь routing) с помощью **Cisco IOU**. Так как я пользуюсь им, начиная с альфа-версии, то решил написать небольшой гайд, как подружить GNS3 и IOU.
Дисклеймер. Cisco IOU могут использовать только сотрудники компании Cisco.
Ниже представлена инструкция и для Windows, и для Linux.
#### Windows
На официальном сайте GNS3 [скачиваем](http://new.gns3.net/personal.php) All in One Installer под Windows.
Вместе с GNS3 будет предложено установить SuperPutty, Wireshark, WinPcap и некоторые другие программы.
После установки уже можно пользоваться базовой функциональностью этого симулятора (routing) с помощью Dynamips. Но на этом этапе IOU ещё не заработает.
Нам необходим **VirtualBox**, виртуалка **OVA**, созданная командой GNS3, и IOU образы (images).
Выложить ссылки на IOU images я не могу, что не отменяет того факта, что можно найти в Интернете всё что нужно. На сегодняшний день самыми популярными являются эти 2 образа:
**l2-adventerprise-ms.nov11-2013-team\_track
l3-adventerprisek9-15.4.1T**
Скачать виртуалку можно [здесь](http://sourceforge.net/projects/gns-3/files/IOU%20VMs/GNS3%20IOU%20VM.ova/download).
Открываем **VirtualBox**, добавляем эту виртуалку с помощью *File -> Import Appliance*. Заходим в настройки *VM -> Serial Ports ->* снимаем галочку *Enable serial port*, сохраняем настройки и запускаем виртуалку.
Заходим в браузер по адресу **http://<адрес вашей виртуалки>:8000/upload**, если вы используете настройки по умолчанию для VirtualBox, то адрес будет таким:
**192.168.56.101:8000/upload**
Добавляем IOU images сюда и копируем путь к каждому образу, например:
**/home/gns3/GNS3/images/i86bi-linux-l3-adventerprisek9-15.4.1T.bin**
Открываем *GNS3 -> Edit -> Preferences -> GNS3 Server -> Remote Servers*, добавляем адрес и порт веб сервера на виртуалке, в нашем случае это **192.168.56.101, 8000 TCP**, нажимаем *Add -> Apply*.
Открываем *Edit -> Preferences -> IOU Devices*, в поле *IOU path* добавляем скопированный путь и нажимаем *Save*. Проделываем для каждого образа.
Выбираем раздел *IOS on UNIX*, и в поле *Path to IOURC* указываем путь к текстовому файлу лицензии **IOURC** (выложить я его, к сожалению, не могу).
Всё, теперь можно добавлять IOU устройства из панели *Routers -> IOU device* или *Switches -> IOU device*.
#### Linux (на примере Ubuntu x64 14.04)
Для того, чтобы работал GNS3 1.0 под Linux, нам нужно убедиться, что у нас установлены python3, pip, pyQt:
```
sudo apt-get install python3 python3-pip python3-pyqt4
```
Также нам необходимо собрать **Dynamips** из исходников:
```
sudo apt-get install libelf-dev uuid-dev libpcap0.8-dev cmake git
git clone git://github.com/GNS3/dynamips.git
cd dynamips
mkdir build
cd build
cmake ..
sudo make install
```
А теперь собрать **GNS3 GUI** и **Server**:
```
cd ~
git clone https://github.com/GNS3/gns3-gui.git
cd gns3-gui
sudo python3 setup.py install
cd ~
git clone https://github.com/GNS3/gns3-server.git
sudo apt-get install python3-zmq python3-tornado python3-netifaces
cd gns3-server
sudo python3 setup.py install
```
Чтобы избавиться от ошибок при заходе в настройки, можно установить **VirtualBox**, собрать и установить **vboxwrapper**:
```
cd ~
git clone https://github.com/GNS3/vboxwrapper
sudo apt-get install python-pip
cd vboxwrapper
sudo python2 setup.py install
sudo cp vboxwrapper.py tcp_pipe_proxy.py vboxcontroller_4_3.py /usr/local/lib/python2.7/dist-packages/
```
Осталось лишь установить **iouyap**, чтобы **IOU** заработал. Можно [скачать](http://sourceforge.net/projects/gns-3/files/Tools/iouyap.tar.gz/download) уже скомпилированный или собрать из исходников. Я выбрал первый вариант:
```
tar -zxvf iouyap.tar.gz
sudo cp iouyap /usr/local/bin/iouyap
```
Прежде, чем мы перейдём к настройке, нам необходимо сделать ещё кое-что. Дело в том, что GNS3 будет запускать некоторые 32-битные бинарники на 64-битной системе. Для этого необходимо выполнить дополнительные действия:
```
sudo dpkg --add-architecture i386
sudo apt-get update
sudo apt-get install libc6:i386 libstdc++6:i386
sudo apt-get install libssl1.0.0:i386
sudo ln -s /lib/i386-linux-gnu/libcrypto.so.1.0.0 /lib/i386-linux-gnu/libcrypto.so.4
```
Как и в случае с установкой под Windows, нам необходимо иметь IOU образы (images) и файл лицензии **iourc**.
Осталось лишь настроить GNS3 и всё готово.
Запускаем gns3 с помощью команды *gns3* в терминале.
Заходим в *Edit -> Preferences*. В разделе *GNS3 Server* прописываем путь: **/usr/local/bin/gns3server**
В разделе *Dynamips* прописываем путь: **/usr/local/bin/dynamips**
В разделе *VirtualBox* прописываем путь: **/usr/local/bin/vboxwrapper**
В разделе *IOS on Unix* прописываем путь к **iouyap**: **/usr/local/bin/iouyap** и путь к файлу лицензии **iourc**.
В разделе *IOU Devices* в поле *IOU path* прописываем путь для каждого образа и нажимаем *Save*.
Опционально, можно поменять консоль в разделе *General -> Console Applications*. Для GNS3 я использую **KDE Konsole** вместо **Gnome Terminal**, так как последний подсоединяется ко всем устройствам в разных окнах, а не вкладках.
Теперь осталось лишь проверить, всё ли работает.
~~У меня~~ всё заработало, надеюсь, что и у вас тоже. Скрин, конечно, не мой.
#### Замечания и наблюдения
* Под Windows я пользовался лишь второй альфой GNS3, при большом количестве устройств загрузка процессора доходила до 70-80%, и иногда всё сильно подтормаживало. Поэтому с момента появления публичной беты я использую GNS3 в виртуалке ubuntu. Судя по ощущениям — так работать намного комфортнее.
**Примечание**Извиняюсь, если какие-то команды в терминале должны использоваться без sudo или вообще другие, я не специалист по Linux.
* Теперь можно готовиться к CCNP без реального оборудования, что не может не радовать. К сожалению, некоторые фичи не работают. Проблема не в GNS3, а в доступных образах. Надеюсь, что скоро в IOU внедрят поддержку этих фич. Например, не работают Private VLAN, L3 PortChannel, DHCP snooping и некоторые другие фичи.
* В новом GNS3 используется другой формат файла топологии (теперь это JSON), который несовместим с предыдущей версией GNS3, из-за чего все доступные лабы просто так не запустятся (правда при желании можно написать скрипт конвертации из одного в другой). | https://habr.com/ru/post/234195/ | null | ru | null |
# Вебсокеты: боевое применение
[Вебсокеты](http://en.wikipedia.org/wiki/WebSocket) — это прогрессивный стандарт полнодуплексной (двусторонней) связи с сервером по TCP-соединению, совместимый с HTTP. Он позволяет организовывать живой обмен сообщениями между браузером и веб-сервером в реальном времени, причем совершенно иным способом, нежели привычная схема «запрос URL — ответ». Когда два года назад я присматривался к этому стандарту, он был еще в зачаточном состоянии. Существовал лишь неутвержденный набросок черновика и экспериментальная поддержка некоторыми браузерами и веб-серверами, причем в Файрфоксе он был по умолчанию отключен из-за проблем с безопасностью. Однако теперь ситуация изменилась. Стандарт приобрел несколько ревизий (в том числе без обратной совместимости), получил статус RFC ([6455](http://tools.ietf.org/html/rfc6455)) и избавился от детских болезней. Во всех современных браузерах, включая IE10, заявлена поддержка одной из версий протокола, и есть вполне готовые к промышленному использованию веб-серверы.
Я решил, что настало время попробовать это на живом проекте. И теперь делюсь, что из этого вышло.
Суть задачи
-----------
На моем личном небольшом сайте Клавогонки.ру есть центральная часть — список действующих в данных момент игр-заездов. Список крайне динамичный: новый заезд создается игроками каждые несколько секунд, иногда несколько в секунду. Заезды начинаются с отсчета времени, по завершению перемещаются из раздела открытых игр в раздел активных. После выхода всех игроков заезд убирается со страницы. В один заезд заходит от одного и иногда до ста игроков, что требуется отображать тут же.
Как это работало раньше
-----------------------
Изначально, когда появилась необходимость сделать эту часть функциональности сайта, возникло много трудностей с динамическим обновлением списка. На странице списка могут находиться десятки человек одновременно, каждый из которых хочет видеть свежую картину. У многих заездов может быть таймаут отсчета от создания до старта всего 10-20 секунд, и чтобы успеть присоединиться к ним, обновление должно происходить достаточно живо.
Обновление всей страницы по таймауту здесь не подходило вообще никак, и нужно было искать другие варианты (тут надо сделать ремарку, что использовать флеш на сайте не хотелось без очень сильной на то необходимости).
Самым очевидным и простым решением здесь на первый взгляд казался [long-polling](http://en.wikipedia.org/wiki/Push_technology#Long_polling) — висящее подключение к серверу, которое обрывается в момент поступления нового события и переоткрывается заново. Однако после некоторых тестов этот вариант тоже оказался нежизнеспособным: события поступали непрерывным потоком, ведь клиенту нужно сообщать не только о создании новой игры, но и об изменении параметров всех игр (например, старт таймаута, смена статуса, состава игроков), и количество запросов начало вызывать определенную степень недовольства у сервера. Да и оверхед на открытие-закрытие запросов тоже выходил немаленький.
HTTP-streaming не получилось использовать из-за проблем с прокси-серверами у многих пользователей.
Поэтому я остановился на простом варианте обновления содержимого страницы по таймауту раз в 3 секунды через ajax-запросы. На сервере текущие данные кешировались и отдавались клиентам из кэша в json, при этом для экономии трафика отдавался не весь список каждый раз, а лишь измененные данные через систему версионирования (увеличилась версия по сравнению с запрашиваемой — отдаем новую информацию о заезде, иначе отдаем только текущий номер версии).
Система показала себя неплохо и проработала долгое время. Однако был большой минус — очень трудно зайти в заезд с 10-секундным таймаутом до старта. Кроме того, это совсем не соответствовало духу динамичной гоночной онлайн-игры и выглядело не слишком технологично в целом.
**Увидеть эту страницу в ее старом варианте вы можете по [этой ссылке](http://klavogonki.ru/gamelist?old=1).**
Как это работает сейчас
-----------------------
Если говорить кратко, вебсокеты позволили внести драйв в весь этот процесс.
Для начала был выбран сервер, который должен жить в связке с действующим игровым бэкэндом. По ряду причин я выбрал для этого [node.js](http://nodejs.org/) — событийно-ориентированная модель и хорошо развитые коллбэки в javascript идеально подошли для этой задачи.
Общей средой общения между php-бэкэндом и сервером на node.js стали [pubsub-каналы redis](http://redis.io/topics/pubsub). При создании новой игры или любом действии, изменяющем данные, php делает примерно следующее (код здесь и далее сильно упрощен):
```
$redis = new Redis();
$redis->pconnect('localhost', 6379);
$redis->publish("gamelist", json_encode(array(
"game created", array(
'gameId' => $id))));
```
Redis работает как отдельный демон на отдельном TCP-порте и принимает/рассылает сообщения от любого количества подключенных клиентов. Это дает возможность хорошо масштабировать систему, невзирая на количество процессов (ну и серверов, если думать оптимистично) php и node.js. Сейчас крутится примерно 50 php-процессов и 2 node.js-процесса.
На стороне node.js при старте идет подключение к прослушке redis-канала под названием `gamelist`:
```
var redis = require('redis').createClient(6379, 'localhost'),
redis.subscribe('gamelist');
```
Для работы с клиентами используется обвязочная библиотека [Socket.IO](http://socket.io) (**upd:** товарищи [Voenniy](https://habrahabr.ru/users/voenniy/) и [Joes](https://habrahabr.ru/users/joes/) в комментах [говорят](http://habrahabr.ru/post/162301/#comment_5572927), что есть более качественные альтернативы вроде [SockJS](https://github.com/sockjs/sockjs-client) и [Beseda](https://github.com/GeometriaLab/Beseda), что вполне может быть правдой). Она позволяет использовать вебсокеты как основной транспорт, откатываясь при этом на другие транспорты вроде флеша или xhr-polling если браузер не поддерживает вебсокеты. Вдобавок, она упрощает работу с клиентами в целом, например дает API для мультиплексирования и разделения подключенных клиентов по разным псевдокаталогам (каналам), позволяет именовать события и некоторые другие плюшки.
```
var io = require('socket.io').listen(80);
var gamelistSockets = io.of('/gamelist');
```
При подключении браузера клиента к `ws://ws.klavogonki.ru/gamelist` он распознается как подключенный к socketio-каналу `gamelist`. Браузер для этого делает следующее:
```
...
var socket = io.connect('ws.klavogonki.ru/gamelist');
```
При поступлении по redis-каналу события из бэкэнда оно всячески предварительно анализируется и потом отсылается всем подключенным клиентам в `gamelistSockets`:
```
redis.on('message', function(channel, rawMsgData) {
if(channel == 'gamelist') {
var msgData = JSON.parse(rawMsgData);
var msgName = msgData[0];
var msgArgs = msgData[1];
switch(msgName) {
case 'game created': {
...
gamelistSockets.emit('game created', info);
break;
}
case 'game updated': {
...
gamelistSockets.emit('game updated', info);
break;
}
case 'player updated': {
...
gamelistSockets.emit('player updated', info);
break;
}
}
}
});
```
Браузер получает событие ровно таким же образом и рендерит необходимые изменения на странице.
```
socket.on('game created', function(data) {
insertGame(data);
});
socket.on('game updated', function(data) {
updateGame(data);
});
socket.on('player updated', function(data) {
updatePlayer(data);
});
```
Принцип совершенно прост и ясен. Продвинутые технологии в основе этой схемы позволяют сильно упростить процесс и сосредоточиться на логике самой работы. Хотя пришлось несколько повозиться с переделкой некоторых частей php-кода для работы в идеологии «сообщаем об изменении, а не о состоянии», а также вынести домен вебсокетов на отдельную от основной машину (чтобы не мучиться с разделяющим прокси на 80 порту), но в сухом остатке плюсы вышли очень существенными:
* Высочайшая динамичность интерфейса, обновление происходит в реальном времени, можно отслеживать единичные изменения и чувствовать себя в онлайн-игре, а не на страничке чата 90-х годов.
* Практически полное отсутствие необходимости в кэшировании, ведь данные идут транзитом от бэкэнда прямо в браузер.
* Органичная экономия трафика на отсылке только необходимых изменений состояния (если постараться прикрутить компрессию, то будет еще интересней).
* Роста сетевой нагрузки практически незаметно, так как node.js разрабатывался как раз с целью держать и обрабатывать любое мыслимое число одновременных подключений; а рост нагрузки на цпу даже упал, ведь просчет изменения состояния делается один раз на бэкэнде и всем клиентам рассылается уже в готовом виде.
* Событийно-ориентированная схема дает возможность знать о всех моментах изменений данных и, например, делать анимация всплывания и уплывания при этом.
Сплошной профит, короче.
**Посмотреть на то, что получилось в итоге, вы [можете здесь](http://klavogonki.ru/gamelist?new=1).** Разница видна невооруженным взглядом.
В качестве бонуса две таблички, небольшая статистика по аудитории Клавогонок, браузеры и используемые в Socket.IO транспорты:
| Браузер | Доля | Транспорт | Доля |
| --- | --- | --- | --- |
| Chrome | 51% | websocket | 90% |
| Firefox | 20% | xhr-polling | 5% |
| Opera | 15% | flashsocket | 4% |
| IE (примерно пополам 8 и 9) | 6% | jsonppolling | 1% |
Как видно, вполне готово к употреблению.
Итог
----
Тут могла бы быть заключительная резюмирующая часть с итогами, библиографией и моралью. Но я сэкономлю ваше время и скажу просто: **вебсокеты — это очень круто!**
P.S. Во вновь разрабатываемых частях проекта (включая описанное выше) используются также такие интересные слова, как [mongodb](http://www.mongodb.org/) и [angular.js](http://angularjs.org/). Если есть интерес, то следующие топики будут на эту тему. | https://habr.com/ru/post/162301/ | null | ru | null |
# Автоматический регулятор температуры газовой колонки
Хочу рассказать о создании несложного устройства, которое сильно облегчило жизнь домашним обитателям — автоматический регулятор температуры газовой колонки. Подобные устройства уже создавались и описывались здесь на хабре, хотелось сделать чуть более продвинутый девайс и подробно описать весь процесс создания от задумки и измерения до реализации, без использования готовых модулей типа Arduino. Устройство будет собрано на макетной плате, язык программирования — C. Это моя первая разработка законченного (и работающего!) устройства.
### 1. Исходные данные
Мы живем на съёмной квартире, которая обладает одним очень неприятным свойством: в доме нет горячей воды, холодная вода нагревается на месте при помощи нагревателя (Водонагреватель Проточный Газовый — **ВПГ**), который расположен на кухне. Во время принятия душа если происходит очередной скачок давления — приходится голышом шлепать до колонки или звать кого-нибудь. Интегрировать полноценный «умный дом» возможности нет, поэтому решено было внедрить автоматическое регулирование нагревателя. К слову, довольно быстро нашел несколько похожих решений, например [здесь](http://geektimes.ru/post/252796/), а значит проблема моя известна и решена в своем виде.
Модель ВПГ: Vector lux eco 20-3 (китай)
Давление воды: около 1.5 кгс/см² (давление низкое, нагреватель работает чуть выше допустимого предела)
#### Требования к решению
* Простота
* ПИД-регулятор или его подобие
* Возможность выбора поддерживаемой температуры
* Отображение текущих параметров
* Решение вопросов безопасности устройства
#### Архитектура системы
После некоторых размышлений архитектура устройства была набросана следующим образом:
* Сервопривод (непосредственно в теле ВПГ)
* Термодатчик штатный ВПГ
* Блок усиления сигнала термодатчика и стабилизатор питания сервопривода (непосредственно в теле ВПГ)
* Блок управления (внешний)
Далее опишу процесс разработки в хронологическом порядке.
### 2. Сервопривод
Так как профессия у меня программная и механика всегда оставалась самой сложной частью — начать решил с неё. Надо сказать что к первому этапу долго не мог собраться, ВПГ очень боязно было трогать, но очередной перепадок давления вынудил меня начать.
Разобрав колонку и осмотревшись — нашёл места для установки сервомашинки TowerPro MG995, как-то давно заказанной «на сдачу» на aliexpress.
Для устранения люфта привода тяг сделал одну тягу подпружиненной. Люфт был полностью устранен, но выяснилась другая проблема — сервомашинка с моментом > 10 кг\*см оказалась слишком дерзкой для ВПГ. При включении переходные процессы в электронике машинки вызывают рывок в рандомное положение и через пару холостых включений тяга оказалась погнутой! Силумин колонки точно не выдержит такого обращения. Так же вызывала нарекания геометрия качалки, которая была не на оси регулятора — что приводило к нелинейности регулировки. Финальный вид узла привода дросселя:
Узел переделан — использованы пружины от ВАЗ (от карбюратора — куплены в магазине автозапчастей) и качалка теперь на геометрической оси вала. Такая конструкция имеет небольшой люфт, но зато линейна в регулировке и может демпфировать бешенство рулевой машинки. Углы выставлены на оптимальные значения для регулировки в наиболее востребованных положениях регулятора.
### 3. Блок датчиков ВПГ
Терморезистор ВПГ меняет своё сопротивление в пределах 20..50 КОм, использовать напрямую в качестве делителя проблематично — получим низкую точность измерения. Но как оказалась на практике — при повышении питающего напряжения до 12В можно без проблем получить приемлемый диапазон выходного сигнала — только использовать ОУ в режиме повторителя (при необходимости можно поменять коэффициент усиления) для изоляции делителя от нагрузки. Схема блока внутри ВПГ:
Делитель R2 и термодатчик колонки формирует сигнал с напряжением 1.4..4.96 В в полном диапазоне измерений (на практике — 20..60 градусов цельсия). Изначально разработал мостовую схему — которая может компенсировать уход источника питания, но была отброшена из-за того что источник питания влиял слабо, а первый пункт «ТЗ» был — «простота». Операционный усилитель обеспечивает развязку делителя и нагрузки. Стабилитрон D1 ограничивает выходное напряжение на уровне 5.1 В для случаев отсоединения датчика (в противном случае на выходе было бы 12В — что смертельно опасно для контроллера) — что схемой контроллера будет считаться безусловной ошибкой. Интегральный стабилизатор 7805 питает сервомашинку — решение неудачное, при стопоре машинки он ужасно нагревается и думаю может выйти из строя при клине привода (если не сработает встроенная защита). Более на этом блоке не буду заострять внимание.
### 4. Контроллер
Контроллер собран на базе ИМС Atmega8 в dip-корпусе.
Тактирование — внутренний осцилятор на 8 МГц. Питание — ещё один 7805 на плате. Индикация через стандартный LCD1602 дисплей. Схема блока:
Управление питанием блока осуществляется от колонки через транзистор — используя малогабаритное реле. Сигнал термодатчика (Контакт №4 разьема) имеет подтяжку на землю и при отсоединении датчика во время работы покажет очень высокую температуру — что приведет к уменьшению регулятора и не вызовет опасных ситуаций. Собранный блок:
### 4. Испытания и регулировка
Для отработки ПИД-регулятора была написана модель ВПГ на Qt. На ней были отработаны основные моменты и ситуации работы нагревателя — старт холодный/горячий, перепады давления. Для снятия характеристик был добавлен UART-разьем на плату контроллера, куда раз в секунду отправлялись данные о показателях — текущая температура, положение дросселя и т.д.
При испытаниях выявилось следующее:
* Очень большая инерция ВПГ от начала воздействия до реакции на термодатчике — порядка 30 секунд
* Округление до градуса в микропрограмме контроллера — плохая идея, алгоритм может работать более точно
Результаты измерения и калибровки термодатчика, Зависимость можно считать условно-линейной:
Первые прогоны в программе отрисовки телеметрии от колонки:
(забыл на графики добавить легенду. Здесь и далее — **красный** — температура датчика, **зеленый пунктирный** — положение дросселя, **синий** — желаемая юзером температура)
*Почти удачная регулировка*
*Удачные варианты коэффициентов*
*Неплохой вариант старта*
Первые прогоны показали основные параметры системы, дальше уже не составило труда замерить их и [настроить по ускоренной формуле](http://we.easyelectronics.ru/Theory/prostoy-metod-nastroyki-pid-regulyatora.html), параметры подбирал долго и мучительно. Полностью от колебаний избавится не удалось, но колебания в пределах 1 градуса считаются приемлемыми. Принятый вариант:
В процессе подбора интегральый коэффициент пришлось полностью отключить, думаю что это из-за большой инерции системы. Итоговые коэффициенты:
```
float Pk = 0.2;
float Ik = 0.0;
float Dk = 0.2;
```
### 5. Корпусирование
Устройство собрано в пластмассовом корпусе распределительной коробки.
И в таком виде работает.
### 6. Безопасность использования
Важный вопрос, которым задавался с самого начала.Пройдемся по основным пунктам.
#### Гальваническая развязка цепей колонки и регулятора
Что будет если блок питания 12В закоротит и на цепи датчика окажется 220 вольт? Не вызовет это подачу газа в колонку. Как оказалось — не вызовет — в колонке имеется два уровня подачи газа — электромагнитный клапан контроллера и механический клапан воды. Открыть только соленоид мало — газ не поступит без тока воды.
#### Отключение или отрыв датчика внутри ВПГ
При отключении терморезистора от блока внутри ВПГ на выходе будет генерироваться сигнал 0xFF (5.1В) что проверяется программой как ошибка, контроллер останавлиает выполнение программы, сервопривод выставляется на минимум.
#### Отключение или отрыв датчика от контроллера
В этом случае генерируется большая температура (подтяжка линии датчика к земле) что приведет к выводу привода в минимальное значение, что так же безопасно для юзера.
#### Электронно-механическая защита ВПГ
Цени защиты ВПГ остаются функционировать в штатном режиме, в случае кипения/перегрева/датчика тяги колонки штатные системы должны отключить её.
### 7. Файлы
Полный архив проекта доступен на [github](https://github.com/petrows/boiler-autotemp). В директориях проекта доступны результаты измерений, прошивка контроллера и можели бойлера на Qt.
Спасибо за внимание! | https://habr.com/ru/post/262437/ | null | ru | null |
# Go: справляемся с конфликтами при блокировках с помощью пакета Atomic
> Перевод материала подготовлен в рамках курса [**"Golang Developer. Professional"**](https://otus.pw/PZDD/). Если вам интересно узнать подробнее о курсе, приглашаем на [**день открытых дверей**](https://otus.pw/eDSS/) онлайн.
>
>
---
️ *Эта статья берет за основу Go 1.14.*
Go предоставляет механизмы синхронизации памяти, такие как канал (channel) или мьютекс (mutex ), которые помогают решать различные проблемы. Касательно разделяемой памяти, мьютекс защищает память от гонки данных. Однако, несмотря на существование двух типов мьютексов, в целях повышения производительности Go также предоставляет атомарные примитивы памяти в пакете atomic. Но давайте сначала вернемся к гонкам данных, прежде чем углубляться в решения.
### Гонка данных
Гонка данных (data race) может возникать, когда две или более горутины одновременно обращаются к одной и той же области памяти, и хотя бы одна из них выполняет запись. В то время как map имеет собственный механизм защиты от гонки данных, простые структуры их не имеют, что делает их уязвимыми к этой проблеме.
Чтобы проиллюстрировать гонку данных, я возьму пример конфигурации, которая постоянно обновляется горутиной. Вот ее код:
Выполнение этого кода ясно показывает, что результат недетерминирован из-за гонки данных:
```
[...]
&{[79167 79170 79173 79176 79179 79181]}
&{[79216 79219 79220 79221 79222 79223]}
&{[79265 79268 79271 79274 79278 79281]}
```
Ожидалось, что каждая строка будет непрерывной последовательностью целых чисел, но на деле результат был совершенно рандомным. Запуск той же программы с флагом `-race` указывает на гонку данных:
```
WARNING: DATA RACE
Read at 0x00c0003aa028 by goroutine 9:
[...]
fmt.Printf()
/usr/local/go/src/fmt/print.go:213 +0xb5
main.main.func2()
main.go:30 +0x3b
Previous write at 0x00c0003aa028 by goroutine 7:
main.main.func1()
main.go:20 +0xfe
```
Защита чтения и записи от гонок данных может быть реализована с помощью мьютекса или (что является наиболее распространенным решением) пакетом atomic.
### Mutex vs Atomic
Стандартная библиотека предоставляет два вида мьютексов в пакете `sync`: `sync.Mutex` и `sync.RWMutex`; последний оптимизирован для случаев, когда ваша программа имеет дело с множеством читателей и очень небольшим количеством записывателей. Вот одно из решений:
Теперь программа выведет ожидаемый результат; числа увеличились как и должны были:
```
[...]
&{[213 214 215 216 217 218]}
&{[214 215 216 217 218 219]}
&{[215 216 217 218 219 220]}
```
Второе решение может быть выполнено благодаря пакету `atomic`. Вот код:
Результат также является вполне ожидаемым:
```
[...]
&{[32724 32725 32726 32727 32728 32729]}
&{[32733 32734 32735 32736 32737 32738]}
&{[32753 32754 32755 32756 32757 32758]}
```
Что касается сгенерированного вывода, похоже, что решение с использованием пакета atomic намного быстрее, поскольку он может генерировать более высокую последовательность чисел. Сравнение обеих программ поможет выяснить, какая из них наиболее эффективная.
### Производительность
Бенчмарк следует интерпретировать в соответствии с тем, что замеряется. В этом случае я буду измерять предыдущую программу, где у нее есть записыватель, который постоянно хранит новую конфигурацию, а также несколько читателей, которые постоянно ее читают. Чтобы охватить больше потенциальных случаев, я также включу тесты для программы, в которой есть только считыватели, при условии, что конфигурация меняется не очень часто. Вот пример этого нового кейса:
Выполнение теста десять раз бок о бок дает следующие результаты:
```
name time/op
AtomicOneWriterMultipleReaders-4 72.2ns ± 2%
AtomicMultipleReaders-4 65.8ns ± 2%
MutexOneWriterMultipleReaders-4 717ns ± 3%
MutexMultipleReaders-4 176ns ± 2%
```
Бенчмарк подтверждает то, что мы видели раньше в отношении производительности. Чтобы понять, где именно находится узкое место с мьютексом, мы можем перезапустить программу с включенным трассировщиком.
*Для получения дополнительной информации о пакете trace я предлагаю вам прочитать мою статью «*[*Go: Discovery of the Trace Package*](https://medium.com/a-journey-with-go/go-discovery-of-the-trace-package-e5a821743c3c)*.».*
Вот профиль программы, использующей пакет `atomic`:
Горутины работают без перерывов и могут выполнять свои задачи. Что касается профиля программы с мьютексом, картина совсем другая:
Время выполнения теперь довольно фрагментировано, и это связано с мьютексом, который паркует горутину. Это подтверждается обзором горутины, где показано время, затраченное на синхронизацию в блокировке:
Время блокировки составляет примерно треть всего времени. Это можно детализировать из профиля блокирующего:
Пакет `atomic` определенно дает преимущество в этом случае. Однако в некоторых случаях производительность может снизиться. Например, если вам нужно сохранить большую map, вам придется копировать ее каждый раз при обновлении map, что делает ее неэффективной.
*Для получения дополнительной информации о мьютексах я предлагаю вам прочитать мою статью «*[*Go: Mutex and Starvation*](https://medium.com/a-journey-with-go/go-mutex-and-starvation-3f4f4e75ad50)*».*
---
> Узнать подробнее о курсе [**"Golang Developer. Professional"**](https://otus.pw/PZDD/)
>
> Смотреть демо-урок [**«Форматирование данных»**](https://otus.pw/Aqu5/)
>
> | https://habr.com/ru/post/557312/ | null | ru | null |
# Готовим нестандартные данные для нейросети
Сталкивались ли вы когда-либо с проблемой в обучении нейросетей, когда датасет слишком большой, чтобы загрузить его в оперативную память полностью и программа выдает Out-of-Memory Error? Например, при обучении классификатора изображений, у нас нет возможности загрузить все картинки в память до обучения. Даже если это и возможно для игрушечных наборов данных, в реальных задачах объёмы данных измеряются в сотнях, тысячах гигабайт. И мы не можем использовать лишь часть датасета, так как качество обученной модели тоже упадёт. Конечно, у нас есть возможность использовать готовые инструменты (например ImageDagaGenerator в библиотеке Tensorflow), но такой подход работает только если у нас стандартные данные, такие как папки с файлами jpg/png или csv файлы. А что делать, если у нас несколько различных типов данных (например, входные данные - это изображения и их текстовое описание), или большое количество табличных данных, где, например, каждый файл это данные за один день? В этих случаях для загрузки и подготовки данных на вход модели придётся писать свой собственный генератор данных.
В данной статье я детально расскажу, как я создавал свой DataGenerator в Kaggle соревновании по определению наличия опухоли головного мозга по МРТ.
Итак, посмотрим на данные, которые нам предоставили. Для обучения у нас имеется 585 примеров. Каждый пример представляет собой МРТ скан в четырех режимах: Fluid Attenuated Inversion Recovery (FLAIR), T1-weighted pre-contrast (T1w), T1-weighted post-contrast (T1Gd), T2-weighted (T2). Скан в каждом режиме представляет собой набор одноканальных изображений в формате DICOM. Возьмем один из примеров и посмотрим разрешение и количество файлов для каждого режима:
```
from os import listdir
from os.path import isfile, join
import pydicom
examples = ['00000','00178']
for ex in examples:
p1, p2, p3, p4 = 'FLAIR', 'T2w', 'T1w', 'T1wCE'
base_path = f'/kaggle/input/rsna-miccai-brain-tumor-radiogenomic-classification/train/{ex}'
print(f'Образец №{ex}:')
for p in [p1, p2, p3, p4]:
onlyfiles = [f for f in listdir(f'{base_path}/{p}/') if isfile(join(f'{base_path}/{p}/', f))]
img = pydicom.read_file(f'{path}/{onlyfiles[0]}').pixel_array
print(f'Количество файлов в типе {p}: {len(onlyfiles)}, примеры файлов: {onlyfiles[:2]}, разрешение: {img.shape}')
```
Можно заметить, что количество изображений различно и в каждом режиме и в разных примерах. Теперь загрузим информации о классе каждого образца.
```
train_df = pd.read_csv("/kaggle/input/rsna-miccai-brain-tumor-radiogenomic-classification/train_labels.csv")
train_df.head()
```
Столбец ‘BraTS21ID’ означает номер образца, а ‘MGMT\_value’ его класс. Добавим для удобства в качестве столбцов пути к каждому режиму образца. Эти столбцы понадобятся нам в дальнейшем.
```
train_df['FLAIR_path'] = '/kaggle/input/rsna-miccai-brain-tumor-radiogenomic-classification/train/' + train_df['BraTS21ID'].astype(str).str.zfill(5) + '/FLAIR/'
train_df['T1w_path'] = '/kaggle/input/rsna-miccai-brain-tumor-radiogenomic-classification/train/' + train_df['BraTS21ID'].astype(str).str.zfill(5) + '/T1w/'
train_df['T2w_path'] = '/kaggle/input/rsna-miccai-brain-tumor-radiogenomic-classification/train/' + train_df['BraTS21ID'].astype(str).str.zfill(5) + '/T2w/'
train_df['t1wCE_path'] = '/kaggle/input/rsna-miccai-brain-tumor-radiogenomic-classification/train/' + train_df['BraTS21ID'].astype(str).str.zfill(5) + '/t1wCE/'
```
Анализируя полученную информацию, мы делаем вывод, что наш генератор должен приводить все образцы во всех режимах к одинаковому числу изображений и одинаковому разрешению. Одним из параметров генератора мы будем передавать нашу таблицу, откуда мы возьмем пути к папкам и значение (y), которое мы будем предсказывать.
Теперь поговорим о генераторе данных. Согласно документации Tensorflow Keras для наиболее безопасного распараллеливания и обучения желательно использовать класс tf.keras.utils.Sequence, так как он обеспечивает то, что сеть при обучении будет использовать каждый образец за эпоху один раз. Таким образом, нужно создать свой класс, унаследованный от класса Sequence. Необходимо реализовать и методы класса Sequence \_\_getitem\_\_ и \_\_len\_\_. Метод \_\_getitem\_\_ должен возвращать окончательный батч для подачи в сеть. Также при желании можно реализовать метод on\_epoch\_end для изменения датасета между эпохами.
Расмотрим код генератора для этой задачи (по этой ссылке можно найти весь код из статьи <https://www.kaggle.com/fipoka2/generator-test>):
```
import pydicom, re
import tensorflow as tf
class MRIDataGenerator(tf.keras.utils.Sequence):
def __init__(self, df, X_col, y_col, batch_size,
input_size= (256, 256), depth_size=64,
shuffle=True):
self.df = df.copy()
self.X_col = X_col
self.y_col = y_col
self.depth_size = depth_size
self.batch_size = batch_size
self.input_size = input_size
self.shuffle = shuffle
self.n = len(self.df)
def on_epoch_end(self):
if self.shuffle:
self.df = self.df.sample(frac=1).reset_index(drop=True)
def __get_input(self, path, target_size):
def _rescale(self, arr):
def _normalize(self, arr):
def __get_data(self, batches):
def __getitem__(self, index):
```
Задача метода \_\_getitem\_\_ - это выдать один батч данных в формате (x, y), где x – это наши изображения в виде numpy.array размерности [batch\_size, input\_depth, input\_height, input\_width, num\_channels].
```
def __getitem__(self, index):
batches = self.df[index * self.batch_size:(index + 1) * self.batch_size]
X, y = self.__get_data(batches)
return X, y
```
Внутри этого метода мы вызываем вспомогательный метод \_\_get\_data, задача которого из полученной части данных, сформировать наши массивы. В зависимости от параметров, мы можем использовать все режимы (каналов в этом случае будет 4) или какой-то конкретный.
```
def __get_data(self, batches):
if self.X_col is None:
PATHS = ['FLAIR_path', 'T1w_path', 'T2w_path', 'T1wCE_path']
X_batch = []
for p in PATHS:
batch_part_path = batches[p]
X_batch.append(np.asarray([self.__get_input(x, self.input_size) for x in batch_part_path]))
y_batch = batches[self.y_col].values
X_batch = np.concatenate(X_batch, axis=4)
else:
path_batch = batches[self.X_col]
X_batch = np.asarray([self.__get_input(x, self.input_size) for x in path_batch])
y_batch = batches[self.y_col].values
return X_batch, y_batch
```
Создание numpy.array из одного режима происходит путем вызовов вспомогательного метода \_\_get\_input. Это ключевой метод генератора, формирующий массив для одного канала одного образца батча, остановимся на нём подробнее.
```
def __get_input(self, path, target_size):
scan3d = None
onlyfiles = [f for f in listdir(path) if isfile(join(path, f))]
filepatt = 'Image-{}.dcm'
digits = [int(re.search('\d+',i).group()) for i in listdir(path) if re.match(filepatt.format('\d+\\'),i)]
digits.sort()
onlyfiles = [filepatt.format(dig) for dig in digits]
center = len(onlyfiles) // 2
left = max(0, center - (self.depth_size // 2))
right = min(len(onlyfiles), center + (self.depth_size // 2))
onlyfiles = onlyfiles[left: right]
if len(onlyfiles) < self.depth_size:
img_shape = pydicom.read_file(f'{path}{onlyfiles[0]}').pixel_array.shape
add_z = self.depth_size - len(onlyfiles)
scan3d = np.zeros((add_z, target_size[0], target_size[1],1))
scans = []
for f in onlyfiles:
img = pydicom.read_file(f'{path}{f}')
img = img.pixel_array
img = self._rescale(img)
img = np.expand_dims(img, axis=-1)
img = tf.image.resize(img,(target_size[0], target_size[1])).numpy()
img = self._normalize(img)
scans.append(img)
if scan3d is not None:
return np.concatenate([np.array(scans), scan3d])
else:
return np.array(scans)
```
Первым делом, мы упорядочиваем файлы в папке по возрастанию их номера. Это необходимо для корректного создания глубины объёмного изображения. Так как количество изображений в разных примерах и режимах различно, мы берем фиксированное параметризованное значение. Если изображений меньше фиксированного значения, мы добавляем по краям черные фоновые изображения (путем создания матрицы, заполненной нулями). Если же изображений больше, берем нужное количество из середины (по глубине) изображения.
Далее начинаем работать с каждым изображением. Данная работа состоит из трех этапов.
1. Масштабирование
2. Изменение размеров
3. Нормализация/стандартизация
Масштабирование необходимо, так как формат DICOM не использует стандартный масштаб пикселя от 0 до 255, как в обычных изображениях. Для этого используем вспомогательный метод rescale, который отмасштабирует каждый пиксель скана к значению 0-255.
```
def _rescale(self, arr):
arr_min = arr.min()
arr_max = arr.max()
if (arr_max - arr_min) == 0:
return arr
return (arr - arr_min) / (arr_max - arr_min)
```
Далее нужно изменить разрешение изображения до указанного в параметрах. Для этого используем готовую функцию tf.image.resize из библиотеки TensorFlow. Последним шагом будет нормализация/стандартизация изображения. Для этого будем из каждого значения пикселя вычитать его среднее и делить на стандартное отклонение. Это важный этап, так как стандартизация входных данных может ускорить обучение и снизить вероятность застревания в локальных оптимумах.
```
def _normalize(self, arr):
img = arr - arr.mean()
# divide by the standard deviation (only if it is different from zero)
if np.std(img) != 0:
img = img / np.std(img)
return img
```
Посмотрим, как работает наш генератор. Для этого воспользуемся библиотекой imageio и склеим наши изображения в одном из образцов.
```
import imageio
from IPython.display import Image
def visualize_data_gif(images):
imageio.mimsave("/kaggle/working/1.gif", images, duration=5.0 / images.shape[0])
return Image(filename="/kaggle/working/1.gif", format='png')
gen = MRIDataGenerator(train_df, None, 'MGMT_value', 10, (256, 256), 64, True)
iterator = iter(gen)
data = next(iterator)[0] * 255
images = []
for i in range(4):
a = data[:,:,:,:, i]
images.append(np.stack([a,a,a], axis=4).reshape((*a.shape[:4], 3)))
val = np.concatenate(images, axis=3)
visualize_data_gif(val[5])
```
Мы убедились, что из исходных данных генератор корректно собирает объёмное изображение.
Теперь необходимо убедиться, что созданный нами класс корректно работает при обучении нейросети. Создадим простейшую свёрточную 3D нейросеть для классификации и используем наш генератор (из за ограничений используемого GPU возьмем только один режим FLAIR и снизим значения параметров).
```
depth = 64
resolution = (192, 192)
batches = 8
gen = MRIDataGenerator(train_df, 'FLAIR_path’, 'MGMT_value', batches, resolution, depth, True)
with tf.device('/gpu:0'):
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv3D, MaxPooling3D, Flatten, Dense
model = Sequential()
model.add(Conv3D(32, kernel_size=(3, 3, 3), activation='relu', kernel_initializer='he_uniform', input_shape=(64,192, 192, 1)))
model.add(MaxPooling3D(pool_size=(2, 2, 2)))
model.add(Conv3D(64, kernel_size=(3, 3, 3), activation='relu', kernel_initializer='he_uniform'))
model.add(MaxPooling3D(pool_size=(2, 2, 2)))
model.add(Conv3D(128, kernel_size=(3, 3, 3), activation='relu', kernel_initializer='he_uniform'))
model.add(MaxPooling3D(pool_size=(2, 2, 2)))
model.add(Conv3D(256, kernel_size=(3, 3, 3), activation='relu', kernel_initializer='he_uniform'))
model.add(MaxPooling3D(pool_size=(2, 2, 2)))
model.add(Flatten())
model.add(Dense(128, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(64, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(1, activation='sigmoid'))
model.compile(
optimizer='adam',
loss='binary_crossentropy',
metrics=[tf.keras.metrics.BinaryAccuracy()]
)
history = model.fit(gen, steps_per_epoch = batches,
verbose=1,
epochs = 10
)
```
В результате видно, что генератор корректно работает с нейросетью, ошибок при обучении не возникает.
У нас получился генератор, который можно использовать на любых объемах данных с разными размерами. Данные будут загружаться не все сразу, а по мере надобности. Слегка изменив код, можно адаптировать это генератор для загрузки датасетов, состоящих из видеофайлов. Также для более быстрой загрузки, мы можем применить код обработки изображений заранее и в процессе обучения загружать в генераторе данные, уже сохраненные как numpy массивы. Дополнительно можно добавить возможности аугментации данных (такие как сдвиги, повороты и т.д.), код которых придётся самостоятельно добавлять в наш класс. Тем не менее полученный генератор достаточно прост и эффективен, и даже в таком базовом варианте способен эффективно справляться с задачей. | https://habr.com/ru/post/579524/ | null | ru | null |
# Книга «Наглядный CSS»
[](https://habr.com/ru/company/piter/blog/560650/)Привет, Хаброжители!
На 1 июня 2018 года CSS содержал 415 уникальных свойств, относящихся к объекту style в любом элементе браузера Chrome. Сколько свойств доступно в вашем браузере на сегодняшний день? Наверняка уже почти шесть сотен. Наиболее важные из них мы и рассмотрим. Грег Сидельников упорядочил свойства по основной категории (положение, размерность, макеты, CSS-анимация и т. д.) и визуализировал их работу. Вместо бесконечных томов документации – две с половиной сотни иллюстраций помогут вам разобраться во всех тонкостях работы CSS.
Эта книга станет вашим настольным справочником, позволяя мгновенно перевести пожелания заказчика и собственное видение в компьютерный код!
Позиционирование
----------------
### Тестовый элемент
Обратите внимание: на самом деле здесь три элемента. Во-первых, сам документ. Но теоретически это может быть html, или body, или любой другой родительский контейнер. Фактические стили будут применены к тестовому элементу в данном родительском контейнере. Данный образец в качестве примера будет использоваться в главе 6, касающейся позиции элемента.
Позиционирование элементов в CSS может зависеть от свойств родительского контейнера. Для представления различных вариантов данная конкретная настройка будет полезна без отображения полного сайта или макета приложения.
Доступно пять типов позиционирования: static (статичное) (по умолчанию), relative (относительное), absolute (абсолютное), fixed (фиксированное) и sticky («липкое»). Мы рассмотрим их на протяжении всей этой главы.
По умолчанию для всех элементов используется статичное позиционирование:
Относительное позиционирование практически такое же, как и статичное:
### Статичное и относительное позиционирование
По умолчанию свойство position установлено в static, то есть элементы отображаются в том порядке, в котором они были указаны в вашем HTML-документе, в соответствии с нормальным потоком HTML-страницы.
На статично позиционированные элементы не влияют свойства top, left, right и bottom.
Чтобы понять разницу, создадим несколько основных стилей CSS:
```
001 /* Применить границу ко всем элементам \*/
002 div { border: 1px solid gray; }
003
004 /\* Установить произвольные значения ширины и положения \*/
005 #A { width: 100px; top: 25px; left: l00px; }
006 #B { width: 215px; top: 50px; }
007 #C { width: 250px; top: 50px; left:25px; }
008 #D { width: 225px; top: 65px; }
009 #E { width: 200px; top: 70px; left:50px; }
```
Граница 1px solid gray применена ко всем элементам div, поэтому теперь легче увидеть фактические размеры каждого HTML-элемента при отображении его в браузере.
Далее мы применим свойства position: static и position: relative к элементу div, чтобы увидеть разницу между статичным и относительным позиционированием.
По сути, элементы с позиционированием static и relative одинаковы, за исключением того, что элементы relative могут иметь top (верхнюю) и left (левую) позиции относительно их исходного местоположения. Относительные элементы также могут иметь right (правое) и bottom (нижнее) положение.
Относительное позиционирование хорошо подходит для оформления текста. Хотя достичь того же эффекта более правильно с помощью свойства padding и margin. Вы обнаружите, что относительного позиционирования недостаточно для размещения блокирующих элементов, таких как изображения, в определенном месте внутри области родительского элемента.
Следовательно, свойство position: relative не гарантирует полную точность при необходимости разместить элемент в идеальном месте в его родительском контейнере. Для такой цели больше всего подходит свойство position: absolute.
### Абсолютное и фиксированное позиционирование
Абсолютное позиционирование используется для идеального размещения пикселов внутри родительского контейнера. Фиксированные элементы практически идентичны позиционированным абсолютно. За исключением того, что они не реагируют на изменения положения ползунка полосы прокрутки.
Это пример того, как элементы с позиционированием absolute и fixed схлопывают родительский элемент, если для родительского контейнера не заданы размеры. Это может казаться неважным, однако при верстке макетов вы часто будете сталкиваться с такими случаями, особенно при переключении элементов с позиционирования relative на absolute.
В данной главе мы рассмотрим более приближенные к реальности примеры.
Обратите внимание: если свойства width и height родителя не указаны явно, то применение позиционирования absolute (или fixed) к его единственному дочернему элементу преобразует его размеры в 0 × 0, однако данный элемент все равно будет позиционироваться относительно него:
На предыдущей схеме слева абсолютно позиционированные элементы не заполняют свой родительский контейнер содержимым. Они как бы плавают над ним, сохраняя положение относительно своего элемента-контейнера. Справа размеры родительского элемента заданы явно. Технически для потомка со свойством position: absolute не задан никакой эффект, его точка поворота все еще находится в положении 0 × 0 родительского элемента.
Чтобы элементы со свойством position: absolute были выровнены относительно их родителя, его свойство position не должно быть установлено в static (по умолчанию):
Для того чтобы понять, как абсолютное позиционирование влияет на элемент, к которому применяется, нужно провести черту между часто происходящими двумя уникальными случаями.
Как видите, элементы с абсолютным позиционированием ведут себя по-разному в зависимости от того, внутри какого контейнера они находятся: статичного или нестатичного.
Использование свойства position: absolute для выравнивания элементов по углам родителя:
Изменить начальную точку, из которой будет рассчитываться смещение, можно, комбинируя положения top, left, bottom и right. Однако не получится одновременно использовать положения left и right, так же как и top и bottom. При таком применении один элемент перекроет другой.
Использование свойства position: absolute с отрицательными значениями:
### Фиксированное позиционирование
Данное позиционирование работает идентично абсолютному, за исключением того, что такие элементы не реагируют на полосу прокрутки. Элементы остаются в том месте на экране (относительно документа), где они были размещены, независимо от текущей позиции полосы прокрутки.
Использование свойства position: fixed для размещения элементов в фиксированном месте на экране относительно документа:
Использование свойства position: fixed с отрицательными значениями:
### «Липкое» позиционирование
Это позиционирование было одним из последних дополнений в CSS. Ранее для достижения того же эффекта вам приходилось писать собственный код JavaScript или мультимедийный запрос.
«Липкое» позиционирование часто используется для создания плавающих панелей навигации:
Далее приведен простой код, чтобы навигационная панель «прилипала» к верхней (top: 0) границе экрана. Обратите внимание: добавлен код -webkit-sticky для совместимости с браузерами на движке Webkit (такими как Chrome):
```
001 .navbar {
002 /* Определение некоторых основных настроек */
003 padding: 0px;
004 border: 20px solid silver;
005 background-color: white;
006 /* Добавить липкость */
007 position: -webkit-sticky;
008 position: sticky;
009 top: 0;
010 }
```
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product/vizualnyy-css)
» [Оглавление](https://www.piter.com/product/vizualnyy-css#Oglavlenie-1)
» [Отрывок](https://www.piter.com/product/vizualnyy-css#Otryvok-1)
Для Хаброжителей скидка 25% по купону — **CSS**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/560650/ | null | ru | null |
# Использование функционала Xen
Доброго времени суток. Среда виртуализации Xen позволяет нам довольно гибко управлять аппаратными ресурсами нашего сервера для получения максимальной производительности. Для комфортного управления виртуальными машинами, отображения более подробных логов, управления выделяемой памятью и процессорными ядрами и ведения полноценного мониторинга за потреблением оперативной памяти необходима так называемая обратная связь между хостовой и виртуальной машиной. Эта связь достигается за счет установки набора утилит которые именуются «Xen tools» или «Xen guest utilities». Данная публикация как раз им и посвящена.
Итак имеется у нас несколько хост-машин с установленными Xen серверами на них и крутящимся на них зоопарком различных виртуалок (различные задачи требуют различных инструментов для решения). 60% зоопарка составляют машины на базе ОС Windows (win 7 32/64, win serv 2003/2008, есть даже пара XP) оставшиеся базируются на Ubuntu Server / Debian / Centos и есть парочка машин на базе FreeBSD (одна из них это роутер pfSense 2.2). И вот именно эти машинки и выделялись в XenCenter отсутствием многих удобных функций и белыми пятнами в сводной статистике.
А еще раздражающей надписью:
**XenServer Tools not installed**
С виртуальными машинами на базе ОС Windows управиться с такой проблемой очень даже легко достаточно кликнуть по этой надписи, или кликнув правой кнопкой мыши (ПКМ) по нужной машине в списке виртуалок и выбрать пункт Install XenServer Tools… — дальше в вируталку автоматически примонтируется миниобраз содержащий в себе эти утилиты и в зависимости от настроек системы начнется установка (или появится запрос на установку, или ничего не появится и надо будет самому зайти в виртуальный диск и выбрав там файл «installwizard.msi» запустить его). Для установки XenTools требуется наличие .Net Framework 4.0 В процессе инсталяции система потребует перезагрузки. После которой будут доустановлены оставшиеся компоненты и система будет готова к бою.
Чуток посложнее с ОС семейства Linux.
Для начала надо так же подключит миниобраз к нашей виртуальной ОС. Следующий этап монтирование этого миниобраза в систему — тут нам на помощь приходит следующая команда:
```
mount /dev/cdrom /mnt
```
Следующий шаг:
```
bash /mnt/Linux/install.sh
```
Лично я обычно смотрю содержимое примонтированного каталога с помощью:
```
ls -l /mnt
ls -l /mnt/Linux
```
После чего устанавливаю нужный пакет, например вот так:
```
dpkg -i /mnt/Linux/xe-guest-utilities_6.1.0-1031_amd64.deb
```
По окончании установки отмонтируем CD-Rom:
```
umount /mnt
```
И перегружаем машинку:
```
reboot
```
После перезагрузки страшная надпись пропадает и нам становятся доступны вкусные плюшечки…
Самое сложное было подружиться с ОС Freebsd, а конкретнее с собранной на базе FreeBSD 10.1 pfSense 2.2
Итак для чистой FreeBSD последовательность действий следующая:
```
pkg install xe-guest-utilities
```
Дождавшись окончания загрузки пакетов и их установки внесем правки в файл автозагрузки etc/rc.conf:
```
ee /etc/rc.conf
```
В этом файлике необходимо добавить вот такую строку:
**xenguest\_enable=«YES»**
По окончании файл необходимо сохранить и перегрузить машину.
```
reboot
```
Чтобы проверить работу сервиса без перезагрузки можно стартануть сервис командой:
```
service xenguest start
```
Ну и на сладкое pfSense. На самом деле отличий тут не так уж и много, но они есть, заданы в неявном виде и попортили немножко капель крови. Установка выполняется той же командой:
```
pkg install xe-guest-utilities
```
А вот дальше внимание, файл rc.conf — при перезагрузке удаляется и его содержимое не читается, поэтому запись для автозагрузки вносим в файл /etc/rc.conf.local:
```
ee /etc/rc.conf.local
```
Так как pfSense не даст нам запустить при старте скрипт без расширения .sh то делаем на него симлинк:
```
ln -s /usr/local/etc/rc.d/xenguest /usr/local/etc/rc.d/xenguest.sh
```
После этого можно перегружаться и любоваться результатом:
```
reboot
```
Надеюсь этот материал, собранный в одном месте, убережет ваши нервы от долгих поисков, не забывайте делать резервные копии данных и снапшоты машин перед экспериментами.
Всего доброго. | https://habr.com/ru/post/254659/ | null | ru | null |
# Rust новости #4 (декабрь 2018)
Поскольку праздники кончились, предлагаю вашему вниманию субъективную подборку ржавых новостей за декабрь. В этой подборке: безумие с растом, страшен ли раст, волна пророчеств, Rust 2018, Rust Analyzer.
[Rust 1.31 & Rust 2018](https://habr.com/post/432640)
-----------------------------------------------------
Самое важное событие декабря — [выпуск Rust 1.31 и Rust 2018](https://habr.com/post/432640), конечно. Туда очень много всего вошло:
> редакция 2018, нелексические времена жизни, изменения системы модулей, дополнительные правила вывода времен жизни, const fn, новые инструменты, инструментальные проверки качества кода, документация, новый веб-сайт, улучшения в cargo.
Изменений так много, что обзор всех не получилось запихнуть в один пост, так что через несколько дней были опубликованы вспомогательные заметки:
* [Procedural Macros in Rust 2018](https://blog.rust-lang.org/2018/12/21/Procedural-Macros-in-Rust-2018.html) ([обсуждение](https://www.reddit.com/r/rust/comments/a8chzq/procedural_macros_in_rust_2018/)) — о процедурных макросах;
* [Tools in the 2018 edition](https://blog.rust-lang.org/2018/12/17/Rust-2018-dev-tools.html) ([обсуждение](https://www.reddit.com/r/rust/comments/a72mn0/tools_in_the_2018_edition/)) — о расширении инструментария;
Также, имеет смысл полистать мозиловский хорошо структурированный обзор/ликбез 2018й редакции языка: [Rust 2018 is here… but what is it?](https://hacks.mozilla.org/2018/12/rust-2018-is-here) ([перевод](https://habr.com/post/432564), [обсуждение](https://www.reddit.com/r/rust/comments/a3phk7/rust_2018_is_here_but_what_is_it)).
Волна постов про планы на 2019й год
-----------------------------------
Был кинут официальный запрос сообществу делиться мнениями о 2019м годе — [A call for Rust 2019 Roadmap blog posts](https://blog.rust-lang.org/2018/12/06/call-for-rust-2019-roadmap-blogposts.html) ([обсуждение](https://www.reddit.com/r/rust/comments/a3q7h4/a_call_for_rust_2019_roadmap_blog_posts_is_here)). В ответ последовала волна из более чем сотни статей (со всеми можно ознакомиться на [readrust.net/rust-2019](https://readrust.net/rust-2019)). Вот несколько интересных ответов:
* Лодочник: ["Rust 2019: Organizational Debt"](https://boats.gitlab.io/blog/post/rust-2019/) ([обсуждение](https://www.reddit.com/r/rust/comments/a6rfia/rust_2019_organizational_debt));
* Грейдон: ["Rust 2019 and beyond: limits to (some) growth"](https://graydon2.dreamwidth.org/263429.html) ([обсуждение](https://www.reddit.com/r/rust/comments/a9stnw/rust_2019_and_beyond_limits_to_some_growth), [перевод](https://habr.com/post/434684));
* Клабник: ["Thoughts on Rust in 2019"](https://words.steveklabnik.com/thoughts-on-rust-in-2019) ([обсуждение](https://www.reddit.com/r/rust/comments/a9zx7g/thoughts_on_rust_in_2019/));
* Ральф: ["My thoughts on Rust 2019"](https://raphlinus.github.io/rust/2018/12/16/rust-2019.html) ([перевод](https://habr.com/company/piter/blog/433910));
RustRush 2018
-------------
15-16 декабря в Москве проходил [RustRush 2018](https://rustrush.ru).
Записи докладов будут постепенно опубликованы на [Youtube канале](https://www.youtube.com/channel/UCr6mn18SzIuHjMX0CgrpCew), пока доступны два:
* [Keynote. Ashley Williams](https://www.youtube.com/watch?v=fgJjzgSxTXk) — про дух сообщества и wasm-bindgen;
* [Libp2p, a Rust peer-to-peer library. Pierre Krieger](https://www.youtube.com/watch?v=Sss2Tl7WRDQ);
Также, [Pierre Chevalier](https://github.com/pierrechevalier83) выложил [отчет о поездке](https://medium.com/safenetwork/rustrush-2018-a-trip-report-acda361b67d4).
[Генерация типаж-объектов на лету (или безумие с Rust)](https://habr.com/post/432202)
-------------------------------------------------------------------------------------
[idubrov](https://habr.com/users/idubrov/) написал занятную статью о низкоуровневых хаках с лютым unsafe'ом. Отличный эксперимент в целях обучения, но, надеюсь, в реальные проекты оно все-таки не пойдет.
[Так ли страшен Rust, как его малюют](https://habr.com/post/434200)
-------------------------------------------------------------------
[PsyHaSTe](https://habr.com/users/psyhaste/) борется с восприятием ржавчины исключительно как системного языка.
[Rust Analyzer in 2018 and 2019](https://ferrous-systems.com/blog/rust-analyzer-2019)
-------------------------------------------------------------------------------------
[Леша matklad](https://github.com/matklad) поделился информацией о ходе проекта [rust-analyzer](https://github.com/rust-analyzer/rust-analyzer), который является альтернативой [RLS](https://github.com/rust-lang/rls) ([обсуждение](https://www.reddit.com/r/rust/comments/a6ph8p/rust_analyzer_in_2018_and_2019)).
Важное дело, учитывая что IDE это очень болезненная тема для раста.
[Игрострой](http://arewegameyet.rs)
-----------------------------------
* [A simple agenda for the Rust Game Development WG](https://medium.com/rustgamedev/a-simple-agenda-for-the-rust-game-development-wg-485cfc72b088) ([обсуждение](https://www.reddit.com/r/rust/comments/a45q5i/a_simple_agenda_for_the_rust_game_development_wg)) — Эрланд предлагает создать Игровую Рабочую Группу и сконцентрироваться вокруг Аметиста, сделав его локомотивом экосистемы;
* Выпущена паззл игра ["Adventures of Pascal Penguin"](http://www.luduminis.com/pascal/about/) ([обсуждение](https://www.reddit.com/r/rust_gamedev/comments/a6ive6/adventures_of_pascal_penguin_is_complete), [трейлер](https://www.youtube.com/watch?v=EgFr73AUwps)) — работает в вебе, играбельна по ссылке;
* [Using Rust for Gamedev](https://medium.com/@michelotti.matthew/using-rust-for-gamedev-2f60b0e4cc5c) ([обсуждение](https://www.reddit.com/r/rust/comments/acr83h/using_rust_for_gamedev_xpost_rrust_gamedev/)) — автор вышеупомянутого пингвина рассказывает о своем опыте работы над ним;
* [Russian AI Cup 2018](https://blog.kuviman.com/2019/01/01/russian-ai-cup-2018.html) — в этом году мэйлрушный Russian AI Cup использует симулятор на Rust+WASM ([*GIF*](https://blog.kuviman.com/assets/images/raic2018/start.gif)) (кстати, [прошлогодний пост](https://blog.kuviman.com/2018/01/11/web-renderer-for-russian-ai-cup.html) тоже очень интересный) ;
* [Sandspiel](https://sandspiel.club/) ([обсуждение](https://www.reddit.com/r/rust/comments/a6v0p1/sandspiel_a_falling_sand_game_built_in_rustwebgl)) — залипательная физическая WASM песочница;
* [Published my first game written in Rust: Energy Grid](https://agmcleod.itch.io/energygrid) ([обсуждение](https://www.reddit.com/r/rust/comments/abpx2y/published_my_first_game_written_in_rust)) — экономическая стратегия;
* [Dose Response](https://tryjumping.com/dose-response-roguelike) ([код](https://github.com/tryjumping/dose-response), [обсуждение](https://www.reddit.com/r/rust/comments/a8be46/dose_response_roguelike_game_written_in_rust)) — небольшой наркоманский рогалик с ASCII графикой, проходится минут за пять-десять, доступна [веб версия](https://tryjumping.com/dose-response-roguelike/play);
* [This year in gfx-rs: 2018](https://gfx-rs.github.io/2018/12/27/this-year.html) ([обсуждение](https://www.reddit.com/r/rust/comments/aa17g2/this_year_in_gfxrs_2018)) — краткий обзор случившегося с проектом gfx от [kvark](https://habr.com/users/kvark/);
* кстати, [пакет gfx-hal выложен на crates.io](https://crates.io/crates/gfx-hal) ([обсуждение](https://www.reddit.com/r/rust/comments/a9z1cc/gfxhal_is_finally_published)) — кажется, переработка gfx проекта потихоньку устаканивается и поверх новой версии может начинать расти экосистема;
* [nitric](https://users.rust-lang.org/t/announcing-nitric-the-successor-of-specs/23388) ([обсуждение](https://www.reddit.com/r/rust_gamedev/comments/a7ptso/announcing_nitric_the_successor_of_specs)) — наследник/переработка [specs](https://github.com/slide-rs/specs) для возвращения техдолга разросшегося проекта и повышения его гибкости;
* [17cupsofcoffee/tetra](https://github.com/17cupsofcoffee/tetra) ([обсуждение](https://www.reddit.com/r/rust_gamedev/comments/a8axgd/tetra_another_simple_2d_game_framework_written_in/)) — еще одна попытка написать простой ржавый 2д движок, более высокоуровневый чем ggez;
* Вышел [Amethyst 0.10](https://www.amethyst.rs/blog/release-0-10) ([обсуждение](https://www.reddit.com/r/rust_gamedev/comments/a48qkv/amethyst_010_released_and_2019_plans)): Rust 2018, переход на nalgebra, упрощение тестирования и много более мелких изменений;
* [This month in rustsim #3 (December 2018)](https://www.rustsim.org/blog/2019/01/01/this-month-in-rustsim):
+ nphysics: Добавлены дешевые фиксированные точки для деформируемых тел: [видео](https://www.youtube.com/watch?v=KEt14fhsFnw);
+ nphysics: Добавлена поддержка соединений для мультител, что дает возможность прикреплять другие тела к деформируемому телу: [видео](https://www.youtube.com/watch?v=oWFHogFH14E);
+ ncollide: добавлена поддержка капсул и карт высот: [видео](https://www.youtube.com/watch?v=FGpIaQdvmKo);
+ nalgebra: переработано индексирование матриц, что позволяет [удобнее получать срезы](http://nalgebra);
+ nalgebra-glm: добавлены ортографические и перспективные проекции;
+ цели на следующий год: интеграция с аметистом, поддержка жидкостей, "непрерывное" обнаружение столкновений, улучшение производительности;
Одной строкой
-------------
По васму и встройке в декабре заметной активности было мало, поэтому отдельных секций у них не будет.
* Обновления от [IntelliJ-Rust](https://intellij-rust.github.io): [#88](https://intellij-rust.github.io/2018/12/10/changelog-88.html), [#89](https://intellij-rust.github.io/2018/12/25/changelog-89.html) — в том числе подсветка unsafe кода ([*GIF*](https://user-images.githubusercontent.com/2539310/50443734-b9f03080-0915-11e9-9a41-c178c91d0d18.gif)) и всякая стыковка с 2018й редакцией языка;
* [What are various red flags for you in Rust code reviews?](https://www.reddit.com/r/rust/comments/a7xswn/what_are_various_red_flags_for_you_in_rust_code) — реддит-обсуждение со списками более-менее часто встречающихся запахов кода. Даже если вы не часто отсматриваете чужой код, такие списки могут просто лишний раз заставить задуматься над тем как вы пишете свой код;
* [How I Wrote a Modern C++ Library in Rust](https://hsivonen.fi/modern-cpp-in-rust) ([обсуждение](https://www.reddit.com/r/rust/comments/a2r7w6/how_i_wrote_a_modern_c_library_in_rust_for_firefox)) — как написать ржавую библиотеку с полноценным плюсовым интерфейсом;
* [More on RLS version numbering](https://www.ncameron.org/blog/more-on-rls-version-numbering/) ([обсуждение](https://www.reddit.com/r/rust/comments/a37o5e/more_on_rls_version_numbering)) — споры про "стабилизацию" и позиционирование RLS продолжаются — RLS теперь будет иметь ту же версию что и компилятор (1.31 в посте), общественность в целом негодует что до 1.0 RLS и близко не дорос;
* [Async in Rust, circa 2018](https://rust-lang-nursery.github.io/wg-net/2018/12/13/async-update.html) ([обсуждение](https://www.reddit.com/r/rust/comments/a5v0co/async_in_rust_circa_2018)) — статус интеграции async/await в язык;
* [async-io-demo](https://github.com/Hexilee/async-io-demo) ([обсуждение](https://www.reddit.com/r/rust/comments/a9g43y/rust_asynchronous_io_from_mio_to_coroutine/)) — обучающее демо асинхронного io: от [mio](https://github.com/carllerche/mio) до безстековых корутин;
* [Reflecting on Rust and WebAssembly in 2018](https://rustwasm.github.io/2018/12/06/reflecting-on-rust-and-wasm-in-2018.html) ([обсуждение](https://www.reddit.com/r/rust/comments/a3q3lg/reflecting_on_rust_and_webassembly_in_2018)) — как принято, ретроспектива этого года и прогноз на следующий;
* [/r/rust "writing "\*" for crates in cargo.toml won't always mean "latest version""](https://www.reddit.com/r/rust/comments/a8kzo6/psa_writing_for_crates_in_cargotoml_wont_always) — еще одно напоминание, что не стоит использовать "\*" версии зависимостей, потому что оно, например, вполне может взять и откатиться к старой версии зависимости;
* [The Swiss Army Knife of Hashmaps](https://blog.waffles.space/2018/12/07/deep-dive-into-hashbrown/) ([обсуждение](https://www.reddit.com/r/rust/comments/a42gzd/the_swiss_army_knife_of_hashmaps_a_deep_dive_into/)) — экскурсия по внутренностям [hashbrown](https://github.com/Amanieu/hashbrown) (быстрая альтернатива стандартному `HashMap`'у);
* [habr: Изучаю Rust: Как я UDP чат сделал c Azul](https://habr.com/post/433624) — отчет от [VanquisherWinbringer](https://habr.com/users/vanquisherwinbringer/);
* [habr: Первые шаги по Rust](https://habr.com/post/433302/) — обзор языка от [zharko\_mi](https://habr.com/users/zharko_mi/);
* [Alexa Skills in Rust](https://medium.com/@amalec/building-alexa-skills-in-rust-4cf54a497ea4) ([обсуждение](https://www.reddit.com/r/rust/comments/a4p1df/alexa_skills_in_rust)) — написание [навыков](https://developer.amazon.com/alexa-skills-kit) для виртуального помощника от амазона;
* [Inside Rust's Async Transform](https://blag.nemo157.com/2018/12/09/inside-rusts-async-transform.html) ([обсуждение](https://www.reddit.com/r/rust/comments/a4md4f/inside_rusts_async_transform/)) — экскурсия в async;
* [The Spirit tutorial](https://vorner.github.io/2018/12/09/Spirit-Tutorial.html) ([обсуждение](https://www.reddit.com/r/rust/comments/a4lb6a/spirit_tutorial/)) — урок по демонизации при помощи пакета [spirit](https://github.com/vorner/spirit);
* [/r/rust: Porting C code to Rust- notes, questions, and request for review](https://www.reddit.com/r/rust/comments/aanedt/porting_c_code_to_rust_notes_questions_and) — опыт портирования [status\_monitor](https://dwm.suckless.org/status_monitor/) с Си на Rust и ревью кода;
* [A Rusty Advent of Code: My AOC Experience with the Rust Community](https://cprimozic.net/blog/a-rusty-aoc/) ([обсуждение](https://www.reddit.com/r/rust/comments/aa6svx/a_rusty_advent_of_code_my_aoc_experience_with_the)) — отчет об участии в [adventofcode](https://adventofcode.com);
* [Comparing Pythagorean triples in C++, D, and Rust](https://atilanevesoncode.wordpress.com/2018/12/31/comparing-pythagorean-triples-in-c-d-and-rust) ([обсуждение](https://www.reddit.com/r/rust/comments/ab7hsi/comparing_pythagorean_triples_in_c_d_and_rust));
* [/r/rust: Making Rust Float Parsing Fast and Correct](https://www.reddit.com/r/rust/comments/a6j5j1/making_rust_float_parsing_fast_and_correct) — роскошный пост о быстром парсере чисел с плавающей точкой;
* [Tokio: A great 2018, an even better 2019](https://tokio.rs/blog/2018-12-recap-2018) — ([обсуждение](https://www.reddit.com/r/rust/comments/a7ovc6/tokio_a_great_2018_an_even_better_2019)) — рефлексия про прошедший год от проекта [Tokio](https://tokio.rs);
* [Using C libraries in Rust: making a \*-sys crate](https://kornel.ski/rust-sys-crate) — отличный экскурс в написание ржавых оберток к сишным библиотекам;
Новые и обновленные пакеты
--------------------------
* ['cargo-crev' and Rust 2019 fearless code reuse](https://dpc.pw/cargo-crev-and-rust-2019-fearless-code-reuse) ([обсуждение](https://www.reddit.com/r/rust/comments/aaisq7/cargocrev_and_rust_2019_fearless_code_reuse), [код](https://github.com/dpc/crev)) — платформа для публичного ревью пакетов ([демо скринкаст](https://asciinema.org/a/216695?speed=3));
* [enum\_dispatch](https://gitlab.com/antonok/enum_dispatch) ([обсуждение](https://www.reddit.com/r/rust/comments/a7n5hb/enum_dispatch_speed_up_your_dynamic_dispatched)) — макрос, помогающий в некоторых ситуациях удобно заменить типаж-объекты на перечисления (пробрасывает вызов функции кажому из вариантов перечисления);
* [structview](https://gitlab.com/ra_kete/structview-rs) ([обсуждение](https://www.reddit.com/r/rust/comments/a7mbfw/structview_viewing_binary_data_as_highlevel_data/)) — позволяет безопасно получить представление бинарных данных в виде высокоуровневых структур;
* [cargo-call-stack](https://github.com/japaric/cargo-call-stack) ([твит](https://twitter.com/japaricious/status/1069569802241486850)) — Japaric опубликовал расширение cargo для статического анализа стека вызовов;
* [swc](https://github.com/swc-project/swc) ([обсуждение](https://www.reddit.com/r/rust/comments/a8i3sd/v100alpha_release_of_swc_superfast_alternative)) — очень быстрая альтернатива [babel](https://github.com/babel/babel);
* [ds\_store](https://github.com/sinistersnare/ds_store) ([обсуждение](https://www.reddit.com/r/rust/comments/aah5qb/a_ds_store_parser_for_rust)) — парсер `.DS_Store` файлов;
* [sd](https://github.com/chmln/sd) ([обсуждение](https://www.reddit.com/r/rust/comments/a9sncx/sd_an_intuitive_find_replace_cli_sed_alternative)) — "s[earch] & d[isplace]", ржавая альтернатива sed с более интуитивным интерфейсом;
* [enigma](https://github.com/archSeer/enigma) ([обсуждение](https://www.reddit.com/r/rust/comments/a90hnz/enigma_a_toy_erlang_vm_in_rust_cross_post_elixir/)) — игрушечная реализация виртуальной машины Erlang'а;
* [http\_static](https://github.com/arjsin/http_static) ([обсуждение](https://www.reddit.com/r/rust/comments/a94idq/http_static_a_simple_command_line_static_file/)) — простой статический веб сервер, использует [tower-web](https://github.com/carllerche/tower-web);
* [ws-unix-framed-bridge](https://github.com/Kixunil/ws-unix-framed-bridge) ([обсуждение](https://www.reddit.com/r/rust/comments/a7wb2j/ive_created_a_simple_proxy_that_forwards)) — перенаправляет сообщения из вебсокетов в юникс-сокеты и наоборот;
* [Exonum 0.10](https://medium.com/meetbitfury/weve-launched-exonum-version-0-10-60234da0c675) — фреймворк для построения приватных блокчейнов сменил свою сериализацию на protobuf, изменил формат сообщений, а биткоин анкоринг теперь использует [segwit](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki);
* [Rocket v0.4](https://rocket.rs/v0.4/news/2018-12-08-version-0.4) ([обсуждение](https://www.reddit.com/r/rust/comments/a4cbbt/rocket_v04_typed_uris_database_support_revamped)) — веб фреймворк получил типизированные URI, поддержку БД и переработанные запросы;
* [resvg 0.4](https://github.com/RazrFalcon/resvg) ([обсуждение](https://www.reddit.com/r/rust/comments/a5vjql/resvg_04_an_svg_rendering_library)) — библиотека отрисовки svg файлов получила начальную поддержку фильтров, накладывающихся масок/clippath, условного рендеринга и много чего еще;
* [Tantivy 0.8](https://github.com/tantivy-search/tantivy) ([обсуждение](https://www.reddit.com/r/rust/comments/a9kasw/tantivy_08_released_and_talking_at_fosdem2019)) — в библиотеке полнотекстового поиска был переработан апи коллекций и улучшена поддержка многопоточности;
---
Особо интересных RFC под конец года мной не было замечено, так что это все на сегодня, спасибо за внимание!
Если я не добавил какую-то важную ссылку или событие, смело закидывайте в комментарии. :)
(КДПВ взята [отсюда](https://www.reddit.com/r/rustjerk/comments/a6nbi0/art_new_users_vs_borrowck), остальные картинки из сайтов соответствующих проектов.) | https://habr.com/ru/post/435614/ | null | ru | null |
# Танчики в консоли, статья первая: «От спора к написанию кода»
Пожалуй нужно начать с небольшой предыстории: сижу я как-то на паре и решили мы с одногруппником поспорить о возможности создания простейших танчиков в консоли (по типу дендивских), но для игры по сети.
Так как компьютерных сетей у нас ещё не было, мне пришлось самой учить всё с нуля. Прочитав, пожалуй, страниц 30 отборного текста и прослушав четыре лекции по этой теме, мне стало очень скучно и лениво слушать это дальше, и я наконец приступила к проекту.
### Ну что, все готовы? Начинаем!
Эта статья будет короткой, но информативной (для новичков, как я).
На момент написания статьи я знала всего несколько языков и рассуждала о выборе каждого из них и насколько он подходит для разработки этих самых танчиков. Но опираясь на знания я решила распределить всё так:
C# — клиент (так как самый лёгкий в изучении язык)
Rust — сервер (так как самый безопасный и быстрый)
Php/html/css/javascript — сайт (который мы ВОЗМОЖНО будем делать)
Часть первая: постановка задачи
-------------------------------
Главное что я должна была сделать, дабы доказать правоту — это простые танчики, но я решила сделать универсальный клиент. Как это? — это когда сервер одинаково оптимизирован как и для WinForm, так и для консоли (потому что я хочу хорошие танчики в винформ).
Так что наша задача звучит так: Необходимо разработать три приложения, первое — для WinForm (стандартное окошко виндовс), второе — консольное (эмулятор денди) и третье — сам сервер.
Часть вторая: идеи и огрехи...
------------------------------
Что необходимо делать хорошему приложению? — этот вопрос я задала при проектировании и в моей голове прозвучал ответ:«Быть быстрым».
Что это значит? — то, что нам придётся работать с несколькими потоками приёма/передачи данных. Снаряд не может ждать, пока отрисуется танчик, танк не может ждать пока рисуется стена, чтобы пошевелиться.
Мы все знаем как это обидно, когда у тебя падает фпс или не успевает что-то отрисоваться и тебя убивают. Таких ситуаций быть не должно!
Подумав, я решила распределить их именно так:
1-й поток (мэйн) — должен отправлять нажатую клавишу на сервер.
2-й поток должен принимать координаты танков.
3-й координаты стен.
4-й координаты снарядов.
Также желательно было создать чат для общения танкистов во время игры (вдруг в разных кабинетах будем), но это пока не реализовано.
Теперь немного конкретики с потоками, первый должен быть простым отправителем (то есть организовывать минимальны вычисления и отправлять их на сервер), остальные же должны вечно принимать и отрисовывать всё в нашем приложении. В виде кода всё будет примерно так:
```
static async void Tank_coordinate()
{
//Приём координат танков
await Task.Run(
() =>
{
});
}
static async void Coordinate_wall()
{
//Приём координат стен
await Task.Run(
() =>
{
});
}
static async void Shot()
{
//Приём координат снарядов
await Task.Run(
() =>
{
/* ДЛЯ СПРАВКИ: ТУТ МЫ ПИШЕМ СВОЙ КОД, КОТОРЫЙ БУДЕТ ВЫПОЛНЕН АСИНХРОННО */
});
}
static void To_key()
{
//Приём нажатой клавиши
}
```
После всего этого у меня возникли несколько вариантов организации данных, для их отправки на сервер, и тут в бой пошли лекции. Выбор стоял великий: или всё организовать в интовских/стринговских переменных и рисовать через них, или создать структуру для данных, объекты я не рассматривала т.к. не хотела возится с ссылками. Спустя часик гугляния на форумах я остановилась на втором, так как организация данных в виде структуры **гораздо легче**, да и писать документацию будет удобнее (совет: если есть группы данных, которые схожи по назначению — лучше будет объединить их в структуру, ибо так гораздо легче читать код и искать переменные). Наша новая задача звучит так: создать структуру в которой будут поля отвечающие за нажатую клавишу, координату игрока, угол поворота танка и (для консоли) — позицию последнего символа и желательно какой-то регулятор отрисовки. Для чего нам последнее? — чтобы не использовались координаты с которыми мы работаем (увеличиваем/уменьшаем/отправляем на сервер)
В чём же были ошибки? — спросите меня вы.
Первоначально я начала лезть в дебри http модели (хотелось сделать на http), но спустя количество времени n мне стало ясно что лучше сделать на tcp (и проблем поменьше и с растом возится легче будет).
Мы определились с потоками и с идеей, что же дальше?
А дальше, друзья, будет самое интересное.
Часть третья: создание структуры и метода Main(). Конец первого этапа разработки
--------------------------------------------------------------------------------
Сразу кину код, чтобы нетерпеливые читатели сразу его скопипастили:
```
//структура наша будет приватной
//и через методы мы присваиваем ей значения
///
/// Координаты игрока(численные значения)
///
public struct player_coor
{
public static void new_player_coor (int x_, int y_, string dir_, ConsoleKey key_, int last_x_, int last_y_)
{
x = x_; y = y_; dir = dir_; key = key_; last_x = last_x_; last_y = last_y_;
}
static int x = 2;//стартовые координаты
static int y = 2;//
static string dir;//стартовое положене
static ConsoleKey key;//нажатая клавиша
static int last_x;//
static int last_y;//последний 'y' и 'x'
}
static void Main(string[] args)
{
}
```
Но это не самый удобный код, наилучший вариант был предложен: [norver](https://habrahabr.ru/users/norver/)
и выглядит так:
```
// Класс для удобного представления координат
public class Position
{
// Публичные свойства класса
public int X { get; set; }
public int Y { get; set; }
public Position(int x, int y)
{
X = x;
Y = y;
}
}
// Структура состояние игрока, бывшая "player_coor"
public struct PlayerState
{
// Метод с названием идентичным названию класса или структуры
// называется конструктор, он позволяет инициализировать свойства
// и поля структуры или класса
///
/// Конструктор структуры
///
/// Экземпляр позиции
/// Направление корпуса игрока (градусы)
/// Нажатая клавиша
/// Предыдущая позиция игрока
public PlayerState(Position startPosition, int dir_, ConsoleKey key_, Position lastPosition)
{
StartPosition = startPosition;
LastPosition = lastPosition;
dir = dir_;
key = key_;
}
private Position StartPosition { get; set; }
private Position LastPosition { get; set; }
//стартовое положение
static int dir;
//нажатая клавиша
static ConsoleKey key;
}
static void Main(string[] args)
{
// Создаем экземпляр класса Position, с координатами 2, 2
var startPosition = new Position(2, 2);
// Создаем экземпляр класса Position, с координатами 5, 10
var currentPosition = new Position(5, 10);
// Создаем экземпляр структуры PlayerState
var currentState = new PlayerState(startPosition, int,
ConsoleKey.UpArrow, currentPosition);
// А вот так можно получить доступ к свойствам класса Position
Console.WriteLine("X={0}, Y={1}", startPosition.X, startPosition.Y);
}
```
Небольшая ремарка: в ходе написания продолжения этой статьи я выяснила что гораздо легче будет хранить числовую переменную, чем текстовую, именно поэтому в переменной dir (то есть позиция) мы будем хранить целочисленное значение.
Это самый простецкий код, но он делает огромную работу: он распоточивает наше будущее приложение.
Небольшое описание потоков: любой поток создаётся через пространство System.Threading. Создаём мы его так же, как и экземпляр класса, но в аргументе потока указываем void функцию.
После создания потока его можно запустить методом .Start() и отключить (вызвать исключение) методом .Abort(), но это есть синхронная модель (то есть едим и ножом и вилкой, но не можем резать, пока не возьмём вилкой), но есть асинхронная (мы едим и пылесосим, а ноги наши при этом делают жим лёжа по +100500 подходов), которую мы и взяли к использованию.
Вот мы написали свой первый «псевдокод» и основные положения/идеи нашего проекта. Первая стадия подошла к концу, а так же подошло к концу наше бездумство, далее мы будем разрабатывать функции и нам придётся попотеть.
#### Огромное спасибо:
[lair](https://habrahabr.ru/users/lair/),
[unsafePtr](https://habrahabr.ru/users/unsafeptr/), [vlreshet](https://habrahabr.ru/users/vlreshet/), [domix32](https://habrahabr.ru/users/domix32/), [vadimturkov](https://habrahabr.ru/users/vadimturkov/), [myxo](https://habrahabr.ru/users/myxo/), [norver](https://habrahabr.ru/users/norver/) за идеи и правки статьи.
Жду ваших пожеланий и идей, да и прибудет с вами сила! | https://habr.com/ru/post/344226/ | null | ru | null |
# AppCode 2016.2: новые рефакторинги и инспекции, live templates, улучшения автодополнения кода, и все это — про Swift
Привет, Хабр!
Недавно вышел **AppCode 2016.2**, новый релиз нашей IDE для разработки под iOS/OSX. Под катом много гифок и размышлений об автоматизированных рефакторингах в Objective-C и Swift.
Swift
=====
Introduce Variable
------------------
**Introduce Variable** (он же **Extract Variable**) — это локальный рефакторинг, который позволяет автоматически извлечь часть сложного выражения в локальную переменную. Конечно, это можно сделать и вручную. Напечатать название переменной, проставить ее тип, присвоить ей нужное выражение, вручную поправить все в коде, проконтролировать, что не забыл исправить каждое вхождение… Хорошая привычка, и по собственному опыту помню, при разработке под iOS она вырабатывается довольно быстро.
Правда в том, что эта работа рутинна, а рутинные задачи всегда лучше автоматизировать. Для Objective-C этот рефакторинг был реализован в AppCode достаточно давно. Кстати, интересным эффектом его частого использования становится нежелание самому писать названия переменных и вообще начинать строку кода с привычного “тип переменной — название переменной”.
Ведь можно сначала написать выражение — а потом автоматически выделить его в переменную, выбрав подсказку для ее названия или напечатав свое:
Для реализации **Introduce Variable** для Swift пришлось научиться обрабатывать огромное количество конструкций языка — ведь для извлечения переменной нам необходимо знать ее тип, и это всего лишь одно из условий.
По умолчанию всегда извлекается константа, а изменить **let** на **var** можно во всплывающем окне:
Ну и чтобы стало еще проще — опционально можно автоматически подставить тип переменной:
К слову, и руками заменять все вхождения в коде не нужно — AppCode это сделает сам:
Ошибки и предупреждения в окне редактора кода
---------------------------------------------
Когда пишешь код, все ошибки и предупреждения хочется видеть сразу же. И в любом случае не после компиляции. В этой версии мы решили интегрировать **SourceKit** для отображения ошибок и предупреждений в редакторе:
А также дать возможность нашим пользователям использовать те же самые быстрые исправления, которые выдает Xcode:
Фактически, в AppCode SourceKit используется как внешний линтер для кода, а мы тем временем продолжаем работать над новыми возможностями кодогенерации, использующими платформу IntelliJ.
Проверка правописания
---------------------
Казалось бы, опечатки в исходном коде или комментариях не так важны — ведь на работоспособность библиотеки или приложения они не оказывают абсолютно никакого влияния. Но что если проект становится публичным и все эти опечатки попадают в автоматически сгенерированную на основе исходного кода документацию? В этом случае возникает необходимость избегать их, а проверять вручную большой объем кода — неблагодарное занятие.
Теперь AppCode ищет опечатки как в комментариях к коду на Swift, так и в самом исходном коде — названиях переменных, классов и даже их частях, помогая быстро внести исправления:
В Objective-C, как и в C++, такая возможность тоже есть. Более того — это один из механизмов платформы IntelliJ, адаптированный под конкретный язык программирования. Подробнее про то, как в AppCode устроена работа с инспекциями кода, можно прочитать [здесь](https://confluence.jetbrains.com/display/OBJC/Inspections).
Live Templates
--------------
**Live Templates** — это наши шаблоны исходного кода. Суть — дать возможность быстро вставить фрагмент исходного кода по аббревиатуре, аналог сниппетов в XCode. В чем различие? Например, с помощью **Live Templates** можно сделать вот так:
Кстати, для Objective-C аналогом является встроенный шаблон с аббревиатурой **each**:
В чем магия? В том, что поля ввода значений в AppCode можно сприптовать. Например, скопировать значение вводимого значения из одного поля в другое. Или — как в шаблоне **for** — сделать так, чтобы поле ввода искало в своей окрестности массивы, по которым можно проитерировать. Возможности не безграничны, но они есть — а подробнее про них можно прочитать [вот тут](https://confluence.jetbrains.com/display/OBJC/Live+Templates).
Второе базовое отличие — возможность обернуть выделенный фрагмент исходного кода в какое-либо выражение (**Surround With** templates):
В AppCode 2016.2 мы добавили поддержку всех этих механизмов для Swift и сделали базовый набор шаблонов, аналогичный сниппетам в Xcode.
Поля ввода значений при автодополнении
--------------------------------------
В коде на Objective-C и Swift есть названия параметров — такова специфика языка. Вручную их вставлять неудобно, поэтому еще одна базовая возможность, добавленная в этот релиз, — это автоматическая вставка названий параметров и полей для ввода значений при автодополнении функций и методов в Swift:
Objective-C
===========
Complete Statement
------------------
В числе типов автодополнения кода в продуктах JetBrains есть возможность быстро завершить конкретную конструкцию в коде: вставить точку с запятой (даже если курсор стоит отнюдь не в конце выражения), круглые или фигурные скобки и сразу же перейти к набору следующего выражения. В этой версии мы основательно доработали этот тип автодополнения, и теперь он работает вот так:
Документация
------------
Нас очень давно просили сделать генерацию документационных комментариев для методов и функций в Objective-C, и большинство запросов ограничивалось просьбой дать функциональность, аналогичную VVDocumenter. И если бы в нашем понимании “правильно сделанная поддержка документации для Objective-C в AppCode” ограничивалась бы действием “вставить шаблон комментария с предзаполненным параметрами”, то мы бы давно это сделали — вот так:
Кстати, автодополнение названий параметров и документационных тэгов тоже работает:
Но этого мало. Документацию необходимо обновлять, и каждый, кто хоть однажды документировал свой проект целиком, знает, что заставить себя обновить однажды написанный комментарий значительно сложнее, чем написать его в первый раз. Поэтому мы реализовали обработку комментариев в коде так, чтобы **Rename** для названий параметров (как нам кажется, наиболее частый случай изменений) работал корректно:
Дополнительный бонус — сильно улучшилось отображение таких комментариев в окне **Quick Documentation**.
Рефакторинг Rename в смешанном коде
-----------------------------------
Swift — новый, активно развивающийся язык. Но еще долгое время он будет существовать бок о бок с Objective-C, и разработчики будут использовать их вместе. Поэтому мы говорим “рефакторинги в Swift”, а в реальности в большинстве случаев имеем в виду “рефаторинги в смешанном коде”. В AppCode уже достаточно давно есть **Rename** и для Swift, и для сущностей Objective-C, используемых из Swift. В этой версии мы работали над **Rename** для методов классов Swift, используемых из Objective-C.
Когда метод класса в Swift не содержит никаких дополнительных аттрибутов, переименовать его просто, т. к. название в Objective-C совпадает с названием метода в Swift:
Все становится намного интереснее, если у метода есть псевдоним, сделанный с помощью аннотации **@objc**. В этом случае при вызове **Rename** из Objective-C AppCode определит имя функции в Swift и менять будет именно его:
Другой интересный случай — наличие внешнего названия у параметра функции в Swift. Например, для функции `function(extParam param:String)` соответствующий метод в Objective-C будет называться `functionWithExtParam`. И такой случай мы тоже обрабатываем корректно:
Пока эти возможности реализованы только для методов и классов, в будущем планируем сделать то же самое для полей классов.
Форматирование кода
-------------------
Про настройки форматирования кода в AppCode можно написать отдельную статью, но мы просто кратко отметим, что для Objective-C/C/C++ добавлены два новых предопределенных стиля форматирования — [LLVM](http://llvm.org/docs/CodingStandards.html) и [LLDB](http://lldb.llvm.org/lldb-coding-conventions.html).
Демо
----
Небольшое демо (на английском) с демонстрацией новых возможностей:
Все платформенные изменения отлично описаны [в посте](https://habrahabr.ru/company/JetBrains/blog/306028/) [anastasiak2512](https://habrahabr.ru/users/anastasiak2512/), в нем же можно прочитать про новые возможности генерации кода для C++ (**Generate operators** и **Generate definitions**). Традиционно все они доступны в AppCode.
На этом все. Читайте о других возможностях продукта [у нас на сайте](https://www.jetbrains.com/objc/whatsnew/), следите за обновлениями в нашем [англоязычном блоге](http://blog.jetbrains.com/objc/), и задавайте любые возникшие вопросы в комментариях к этому посту. | https://habr.com/ru/post/306738/ | null | ru | null |
# Глубокое обучение при помощи Spark и Hadoop: знакомство с Deeplearning4j
Здравствуйте, уважаемые читатели!
Мы вполне убедились в мегапопулярности глубокого обучения (Deep Learning) на языке Python в нашей целевой аудитории. Теперь предлагаем поговорить о высшей лиге глубокого обучения — то есть, о решении этих задач на языке Java при помощи библиотеки [Deeplearning4j](https://ru.wikipedia.org/wiki/Deeplearning4j). Мы перевели для вас июньскую статью из блога компании Cloudera, где в интереснейших подробностях рассказано о специфике этой библиотеки и о глубоком обучении в Hadoop и Spark.
Приятного чтения.
В конце 2016 года Бен Лорика (Ben Lorica) из O’Reilly Media [объявил](https://www.oreilly.com/ideas/2017-will-be-the-year-the-data-science-and-big-data-community-engage-with-ai-technologies), что “в 2017 году сообщество специалистов по data science и большим данным всерьез займется технологиями ИИ.” До 2017 года в университетах и НИИ практиковалось в основном глубокое обучение на GPU, но в настоящее время все шире, в разных компаниях и предметных областях распространяется *распределенное глубокое обучение на CPU*. Тогда как GPU обеспечивают при числовых вычислениях максимальную производительность, современные CPU также подтягиваются к ним по эффективности, как благодаря совершенствованию оборудования, так и по той причине, что теперь их можно задействовать «скопом». Появились такие свободные инструменты, наиболее интересным из которых является библиотека deeplearning4j – они обеспечивают быстрое глубокое обучение в крупномасштабных системах (стек Hadoop) и должны в целом серьезно повлиять на глубокое обучение в ближайшие годы.
В этой статье мы подробно рассмотрим работу со свободными инструментами – Apache Spark, Apache Hadoop, Deeplearning4j (DL4J) – работающими на недорогом (и широко доступном) аппаратном обеспечении. Постараемся максимально качественно решить задачу по распознаванию образов, располагая ограниченным набором обучающих данных. Библиотека DL4J API написана на Java и особенно интересна Java- и Scala-разработчикам, уже умеющим обращаться с виртуальной машиной Java. Кроме того, возможность распараллеливать обучение моделей в Spark (для этого требуется всего несколько строк кода) упрощает эффективное использование имеющихся кластерных ресурсов. Таким образом, процесс обучения удается ускорить, не жертвуя при этом точностью.
**Deeplearning4j: инструментарий для глубокого обучения на JVM**
[Deeplearning4j](https://github.com/deeplearning4j/deeplearning4j) – один из многочисленных свободных комплектов для крупномасштабного обучения глубоких нейронных сетей на CPU и GPU. Deeplearning4j создана для JVM и специально ориентирована на глубокое обучение для больших предприятий. Библиотека deeplearning4j создана в 2014 году, поддерживается стартапом [Skymind](https://skymind.ai/) и обладает встроенной интеграцией с Apache Spark. Хотя, deeplearning4j предназначена для работы с JVM, в ней используется высокопроизводительная нативная библиотека линейной алгебры Nd4j, которая позволяет выполнять сильно оптимизированные вычисления на CPU или GPU.
**Классификация объектов из набора изображений Caltech-256**
В этой статье рассказано, как пользоваться Apache Spark, Apache Hadoop и deeplearning4j для решения задачи классификации изображений. В частности, здесь пошагово описано, как построить сверточную нейронную сеть, способную классифицировать изображения из набора [Caltech-256](http://www.vision.caltech.edu/Image_Datasets/Caltech256/). Фактически, в этом наборе есть 257 категорий объектов, в каждой из которых содержится от 80 до 800 изображений; таким образом, всего в этом наборе имеем 30 607 изображений.
Следует отметить, что максимальная точность классификации этого набора данных в настоящее время колеблется в диапазоне 72 – 75%. Этот результат можно побить при помощи DL4J и Spark.
**Эффективное глубокое обучение на небольших данных**
У современных сверточных сетей может быть по несколько сотен миллионов параметров. Одна из самых мощных таких сетей называется [Large Scale Visual Recognition Challenge](http://image-net.org/challenges/LSVRC/2017/) (также известная под названием “ImageNet”), в ней нужно обучать 140 миллионов параметров! Такие сети не только потребляют массу вычислительных и дисковых ресурсов (даже при наличии кластера GPU на обучение могут уходить недели), но и требуют много данных. При наличии всего 30 000 изображений непрактично обучать столь сложную модель на Caltech-256, поскольку в этом наборе слишком мало примеров для адекватного обучения столь многим параметров. Лучше воспользоваться методом под названием «[перенос обучения](http://cs231n.github.io/transfer-learning/)», при котором берется предварительно обученная модель, адаптируемая для других вариантов использования. Перенос обучения также позволяет значительно снизить вычислительную нагрузку и избавиться от многочисленных специализированных вычислительных ресурсов, например, GPU.
Такие модели можно переориентировать, поскольку сверточные нейронные сети, обучаемые на наборах изображений, обычно вычленяют [самые общие признаки](https://arxiv.org/abs/1411.1792), и именно такое обучение по признакам может пригодиться и при обработке других наборов изображений. Например, сеть, обученная на ImageNet, скорее всего, будет распознавать фигуры, черты лица, узоры, текст и т.д., что, несомненно, пригодится при обработке набора данных Caltech-256.
**Загрузка предварительно обученной модели**
В следующем примере используется модель [VGG16](https://arxiv.org/abs/1409.1556), занявшая второе место на конкурсе ImageNet в 2014 году. К счастью, сейчас эта модель выложена в общий доступ, все 140 миллионов весов уже оптимизированы для прогнозирования на материале набора ImageNet. Поскольку мы собираемся работать с иным набором изображений, потребуется модифицировать небольшие элементы модели, чтобы заточить ее под такое прогнозирование. Эта модель обладает примерно 140 миллионами параметров, занимает около 500 MB дискового пространства.
Для начала получим такую версию модели VGG16, которая понятна DL4J, и с которой эта библиотека может работать. Оказывается, что подобная возможность встроена прямо в API DL4J и реализуется всего в нескольких строках на Scala.
```
val modelImportHelper = new TrainedModelHelper(TrainedModels.VGG16)
val vgg16 = modelImportHelper.loadModel()
val savePath = "./dl4j-models/vgg16.zip"
val locationToSave = new File(savePath)
// сохраняем модель в нативном формате DL4J, что в дальнейшем позволит ускорить считывание
ModelSerializer.writeModel(vgg16, locationToSave, saveUpdater = true)
```
Теперь наша модель в таком формате, который удобно использовать в DL4J. Исследуем встроенную model summary.
```
val modelFile = new File("./dl4j-models/vgg16.zip")
val vgg16 = ModelSerializer.restoreComputationGraph(modelFile)
println(vgg16.summary())
```
```
VertexName (VertexType) nIn,nOut TotalParams ParamsShape Vertex Inputs
input_2 (InputVertex) -,- - - -
block1_conv1 (ConvolutionLayer) 3,64 1792 b:{1,64}, W:{64,3,3,3} [input_2]
block1_conv2 (ConvolutionLayer) 64,64 36928 b:{1,64}, W:{64,64,3,3} [block1_conv1]
block1_pool (SubsamplingLayer) -,- 0 - [block1_conv2]
block2_conv1 (ConvolutionLayer) 64,128 73856 b:{1,128}, W:{128,64,3,3} [block1_pool]
block2_conv2 (ConvolutionLayer) 128,128 147584 b:{1,128}, W:{128,128,3,3} [block2_conv1]
block2_pool (SubsamplingLayer) -,- 0 - [block2_conv2]
block3_conv1 (ConvolutionLayer) 128,256 295168 b:{1,256}, W:{256,128,3,3} [block2_pool]
block3_conv2 (ConvolutionLayer) 256,256 590080 b:{1,256}, W:{256,256,3,3} [block3_conv1]
block3_conv3 (ConvolutionLayer) 256,256 590080 b:{1,256}, W:{256,256,3,3} [block3_conv2]
block3_pool (SubsamplingLayer) -,- 0 - [block3_conv3]
block4_conv1 (ConvolutionLayer) 256,512 1180160 b:{1,512}, W:{512,256,3,3} [block3_pool]
block4_conv2 (ConvolutionLayer) 512,512 2359808 b:{1,512}, W:{512,512,3,3} [block4_conv1]
block4_conv3 (ConvolutionLayer) 512,512 2359808 b:{1,512}, W:{512,512,3,3} [block4_conv2]
block4_pool (SubsamplingLayer) -,- 0 - [block4_conv3]
block5_conv1 (ConvolutionLayer) 512,512 2359808 b:{1,512}, W:{512,512,3,3} [block4_pool]
block5_conv2 (ConvolutionLayer) 512,512 2359808 b:{1,512}, W:{512,512,3,3} [block5_conv1]
block5_conv3 (ConvolutionLayer) 512,512 2359808 b:{1,512}, W:{512,512,3,3} [block5_conv2]
block5_pool (SubsamplingLayer) -,- 0 - [block5_conv3]
flatten (PreprocessorVertex) -,- - - [block5_pool]
fc1 (DenseLayer) 25088,4096 102764544 b:{1,4096}, W:{25088,4096} [flatten]
fc2 (DenseLayer) 4096,4096 16781312 b:{1,4096}, W:{4096,4096} [fc1]
predictions (DenseLayer) 4096,1000 4097000 b:{1,1000}, W:{4096,1000} [fc2]
Total Parameters: 138357544
Trainable Parameters: 138357544
Frozen Parameters: 0
```
Вот красивая и лаконичная общая характеристика модели; впрочем, весьма полезно показать ее и в виде картинки.
В VGG16 13 сверточных слоев, перемежающихся со слоями, в которых выбирается максимальное значение (max-pooling); это делается для сжатия изображения. Весовые значения в сверточном слое – это, по сути, фильтры, которые обучаются вычленять визуальные признаки из изображения, а слои с выбором максимального значения «сжимают» изображение – и поэтому фильтры в следующих сверточных слоях полнее «увидят» изображение. Поэтому результат работы сверточных слоев – это [самые общие визуальные признаки](https://arxiv.org/pdf/1311.2901.pdf) входного изображения, например, «на картинке лицо?» или «на картинке закат?». Результат работы сверточных слоев подается в ряд из трех полносвязных (плотных) слоев, способных выучить нелинейные взаимосвязи между этими визуальными характеристиками и выходной информацией.
Это – одно из основных свойств сверточных сетей, обеспечивающее перенос обучения. Речь о том, что можно пропускать новую информацию об изображениях через уже обученную сеть VGG16 и вычленять признаки из каждого изображения. Такая операция называется «характеризация» (featurizing): после извлечения признаков остается работать лишь с последними частями сети VGG16, а эта задача гораздо подъемнее как с вычислительной точки зрения, так и по уровню сложности.
**Характеризация изображений при помощи VGG16**
Набор данных можно скачать с сайта [Caltech-256](http://www.vision.caltech.edu/Image_Datasets/Caltech256/), где он разделен на фрагменты для обучения/проверки/тестирования и сохранен в HDFS ([подробные инструкции](https://github.com/sethah/dl4j-demo)). Когда это будет сделано, берем весь набор изображений и пропускаем его через все сверточные слои, а также через первый плотный слой, а вывод сохраняем в HDFS.
По некоторым причинам желательно делать именно так и, чтобы понять важность такого подхода, отметим одно общее правило, касающееся сверточных сетей: большая часть компьютерного времени и вычислительной мощности тратится в сверточных слоях, а большинство параметров (весов) в сети VGG16 локализуется в плотных слоях. Благодаря переносу обучения можно воспользоваться предварительно обученными сверточными слоями для извлечения признаков входных изображений, поэтому переобучать приходится лишь небольшую часть исходной модели – плотные слои. Оставшаяся часть остается статической или «замороженной». Можно сэкономит массу времени и вычислительных мощностей, всего один раз передав необработанные изображения через замороженную часть сети, а затем вообще не возвращаться к этой части.
Для начала извлечем ту часть сети, которая будет использоваться на этапе характеризации. В библиотеке deeplearning4j есть встроенный API для переноса обучения, который можно задействовать именно для этой цели. Чтобы разделить модель после первого полносвязного слоя “fc1” сначала получим список слоев до и после разделения.
```
val modelFile = new File("./dl4j-models/vgg16.zip")
val vgg16 = ModelSerializer.restoreComputationGraph(modelFile)
val (frozenLayers: Array[Layer], unfrozenLayers: Array[Layer]) = {
vgg16.getLayers.splitAt(vgg16.getLayers.map(_.conf().getLayer.getLayerName).indexOf("fc2") + 1)
}
```
Теперь берем пакет org.deeplearning4j.nn.transferlearning, чтобы извлечь только слои до «fc2» включительно.
```
val builder = new TransferLearning.GraphBuilder(model)
.setFeatureExtractor(frozenLayers.last.conf().getLayer.getLayerName)
// удаляем все незамороженные слои, оставляем только ту часть модели, которая не будет обучаться
unfrozenLayers.foreach { layer =>
builder.removeVertexAndConnections(layer.conf().getLayer.getLayerName)
}
builder.setOutputs(frozenLayers.last.conf().getLayer.getLayerName)
val frozenGraph = builder.build()
```
Далее необходимо перейти собственно к считыванию файлов изображений, которые сохраняются в HDFS в формате JPEG, каждый по отдельности. Изображения разложены по подкаталогам, и каждый подкаталог содержит набор картинок, относящихся к определенному классу. Начнем загружать сохраненные в HDFS изображения при помощи sc.binaryFiles и применяем инструменты для обработки изображений, входящие в библиотеку DataVec (нативная ETL-библиотека для DL4J) и с их помощью преобразуем изображения в массивы INDArray, представляющие собой нативные тензорные представления, потребляемые DL4J (полный код [здесь](https://github.com/sethah/dl4j-demo/blob/master/dl4j-cnn/src/main/scala/com/cloudera/datascience/dl4j/cnn/examples/caltech256/SaveFeaturizedData.scala) ). Наконец, используем замороженный граф для выдачи прогнозов по входным изображениям: в сущности, пропускаем их через дорогие слои, которые будут отбрасываться.
```
val finalOutput = Utils.getPredictions(data, frozenGraph, sc)
val df = finalOutput.map { ds =>
(Nd4j.toByteArray(ds.getFeatureMatrix), Nd4j.toByteArray(ds.getLabels))
}.toDF()
df.write.parquet("hdfs:///user/leon/featurizedPredictions/train")
```
Теперь новый набор данных сохраняется в HDFS, и с его помощью можно приступать к построению моделей с переносом обучения. Такие данные с признаками позволяют радикально сократить длительность обучения и снизить сложность вычислений. В вышеприведенном примере новые данные состоят из 30607 вектором длиной 4096.
**Замена слоя прогнозирования VGG16**
Модель VGG16 обучалась на наборе данных ImageNet, представляющем собой множество классифицированных объектов, разделенных на 1000 различных категорий. Последний слой в типичной нейронной сети для классификации изображений, так называемый «слой вывода» на основе ввода генерирует вероятности для каждого объекта, содержащегося в наборе данных. Следовательно, такой ввод можно считать обобщенной картиной визуальных признаков изображения, содержащей полезную информацию о том, что представляет собой объект, и что в нем содержится. Интуитивно понятно, что тот самый «обобщенный» ввод, поступающий в последний слой, должен пригодиться и для генерации иного набора вероятностей, оптимизированный для распознавания объектов в наборе данных Caltech-256.
После характеризации данных по вышеописанному принципу определяем новую модель, занимающую 4096-мерный вывод в слое “fc2” и генерирующую 257 вероятностей для набора данных Caltech256.
```
val conf = new NeuralNetConfiguration.Builder()
.seed(42)
.optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
.iterations(1)
.activation(Activation.SOFTMAX)
.weightInit(WeightInit.XAVIER)
.learningRate(0.01)
.updater(Updater.NESTEROVS)
.momentum(0.8)
.graphBuilder()
.addInputs("in")
.addLayer("layer0",
new OutputLayer.Builder(LossFunction.NEGATIVELOGLIKELIHOOD)
.activation(Activation.SOFTMAX)
.nIn(4096)
.nOut(257)
.build(),
"in")
.setOutputs("layer0")
.backprop(true)
.build()
val model = new ComputationGraph(conf)
```
Вот как это выглядит.
Итак, теперь эту модель можно обучать при помощи тяжелых вычислений DL4J и масштабировать при помощи Spark. Для обучения в Spark используем интерфейс `ParameterAveragingTrainingMaster` в DL4J — лаконичный API для распределенного обучения моделей в Spark. Название для этого интерфейса подобрано удачно, поскольку распределенное обучение в нем достигается при помощи алгоритма SGD на каждом из рабочих ядер в кластере Spark и усреднения различных моделей, изученных на каждом ядре, при помощи операций RDD-агрегации.
```
val tm = new ParameterAveragingTrainingMaster.Builder(1)
.averagingFrequency(5)
.workerPrefetchNumBatches(2)
.batchSizePerWorker(32)
.rddTrainingApproach(RDDTrainingApproach.Export)
.build()
val model = new SparkComputationGraph(sc, graph, tm)
```
Теперь обучаем `SparkComputationGraph` для заданного количества эпох и отслеживаем статистику обучения, чтобы видеть, как идет прогресс.
```
model.setListeners(new ScoreIterationListener(1))
(1 to param.numEpochs).foreach { i =>
logger4j.info(s"epoch $i starting")
model.fit(trainRDD)
// выводим точность модели и «счет» на каждом учебном и проверочном наборе каждые 5 итераций
if (i % 5 == 0) {
logger4j.info(s"Train score: ${model.calculateScore(trainRDD, true)}")
logger4j.info(s"Train stats:\n${Utils.evaluate(model.getNetwork, trainRDD, 16)}")
if (validRDD.isDefined) {
logger4j.info(s"Validation stats:\n${Utils.evaluate(model.getNetwork, validRDD.get, 16)}")
logger4j.info(s"Validation score: ${model.calculateScore(validRDD.get, true)}")
}
}
}
```
Наконец, запускаем учебное задание при помощи spark submit и через [графический веб-интерфейс DL4J](https://github.com/sethah/dl4j-demo/blob/master/dl4j-ui/src/main/scala/com/cloudera/datascience/dl4j/ui/RunUIServer.scala) отслеживаем прогресс и диагностируем проблемы. Ниже видим «счет» модели – этот показатель в данном случае означает отрицательный логарифм правдоподобия миниблока, чем меньше – тем лучше. На графике он изображается в соотношении с «сырыми» значениями (числами) и сглаженной линией тренда. Учтите, что при обучении с помощью Spark «счет» каждого миниблока фактически соответствует всего одному ядру в кластере Spark, а у нас могут быть тысячи таких ядер. В идеале счет на одном ядре должен соответствовать счету на других, но если данные не рандомизированы правильно, то эти показатели в кластере могут резко отличаться от ядра к ядру.
По-видимому, на этот раз модель обучается гораздо быстрее даже при пониженном коэффициенте скорости обучения, так как используемые на этот раз признаки обладают гораздо более высокой прогностической ценностью, чем вероятности ImageNet.
```
17/05/12 16:06:12 INFO caltech256.TrainFeaturized$: Train score: 0.6663876733861492
17/05/12 16:06:39 INFO caltech256.TrainFeaturized$: Train stats:
Accuracy: 0.8877570632327504
Precision: 0.8937314411403346
Recall: 0.876864905154427
17/05/12 16:07:17 INFO caltech256.TrainFeaturized$: Validation stats:
Accuracy: 0.7625918867410836
Precision: 0.7703367671469078
Recall: 0.7383574179140013
17/05/12 16:07:26 INFO caltech256.TrainFeaturized$: Validation score: 1.08481537405921
```
Похоже, в данном случае модель переобучена, так как точность обучения составляет 88.8%, а точность проверки — всего 76.3%. Чтобы убедиться, что модель не переобучается и на проверочном наборе, оценим ее на слепом тестовом наборе.
`Accuracy: 0.7530218882718066
Precision: 0.7613121478786196
Recall: 0.7286152891276695`
Хотя точность немного снизилась, она все равно превосходит ультрасовременные результаты для этого набора данных, а ведь мы воспользовались простой архитектурой для глубокого обучения, построенной на основе готовой архитектуры Hadoop и дешевых CPU! Да, не титаническое достижение, однако, этот результат все равно помогает распробовать, чего можно достичь при помощи глубокого обучения на Java.
**Выводы**
Хотя, библиотека deeplearning4j – просто один из многих инструментов для глубокого обучения, она оснащена нативной интеграцией с Apache Spark и написана на Java, поэтому особенно удачно вписывается в экосистему Hadoop. Поскольку доступ к информации на предприятиях повсеместно обеспечивается через Hadoop, а ее обработка происходит в Spark, библиотека deeplearning4j позволяет ускорить развертывание и сократить издержки, и можно сразу извлекать такую информацию, полученную методом глубокого обучения. Библиотека использует для сложных вычислений ND4J – другую хорошо оптимизированную библиотеку, отлично взаимодействующую с дешевыми CPU, но также поддерживающую работу с GPU, когда требуется резко нарастить производительность. Deeplearning4j – это полнофункциональная библиотека для глубокого обучения, в ней имеется полный набор инструментов, обеспечивающих обработку данных от потребления до развертывания. При помощи этой библиотеки можно решать всевозможные задачи: распознавание изображений и видео, обработка аудио, обработка естественного языка, создание рекомендательных систем и т.д. | https://habr.com/ru/post/344824/ | null | ru | null |
# Cетевое взаимодействие посредством TCP в C# — свой велосипед
Приветствую!
Продолжу серию постов посвященных программированию, на этот раз я хочу поговорить на тему сетевого взаимодействие посредством TCP соединения между .Net приложениями. Статья может быть полезна новичкам или тем кто еще не сталкивался с сетью по отношению к .Net. Полностью работоспособный пример прилагается: <http://yadi.sk/d/1OxmAFuCN3kmc>.
Подробности под катом.
##### Зачем нужна эта статья
Конечно, на данный момент доступно большое количество разнообразных библиотек для сетевого взаимодействия, тот же WCF, но тем не менее, умение соединить два приложения, написанных в том числе и на разных языках программирования может быть полезно.
##### Немного теории
Сетевое соединение фактически представляет собой поток (stream), куда клиент записывает байты, а сервер считывает и наоборот.
Соответственно, необходимо реализовать механизм команд, которые должны сериализоваться на передающей стороне и десериализоваться на принимающей.
##### Моя реализация
В общем виде команда представляет собой объект с двумя методами «ToBytes» и «FromBytes», а также набором свойств которые мы хотим передать принимающей стороне.
**SingleCommand**
```
public class SingleCommand: BaseCommand
{
public int IntField { get; set; }
public decimal DecimalField { get; set; }
//преобразует объект в массив байт
public override byte[] ToBytes()
{
//вычисляем длину команды
const int messageLenght = sizeof(int) + sizeof(decimal);
//инициализируем массив байт в который будут сохраняться данные
var messageData = new byte[messageLenght];
using (var stream = new MemoryStream(messageData))
{
//записываем по очереди наши свойства
var writer = new BinaryWriter(stream);
writer.Write(IntField);
writer.Write(DecimalField);
return messageData;
}
}
//возвращает объект из массива байт, критически важно считывать данные в том же порядке что и были записаны
public static SingleCommand FromBytes(byte[] bytes)
{
using (var ms = new MemoryStream(bytes))
{
var br = new BinaryReader(ms);
var command = new SingleCommand();
command.IntField = br.ReadInt32();
command.DecimalField = br.ReadDecimal();
return command;
}
}
}
```
При необходимости отправки команды содержащий свойство переменной длины, например строка, в свойствах необходимо указывать длину этой строки:
**StringCommand**
```
public class StringCommand : BaseCommand
{
//длина передаваемой строки
private int StringFieldLenght { get; set; }
//строка
public string StringField { get; set; }
public override byte[] ToBytes()
{
//преобразуем строку к массиву байт
byte[] stringFieldBytes = CommandUtils.GetBytes(StringField);
//задаем ко-во байт строки
StringFieldLenght = stringFieldBytes.Length;
//вычисляем длину команды в байтах
int messageLenght = sizeof(int) + StringFieldLenght;
var messageData = new byte[messageLenght];
using (var stream = new MemoryStream(messageData))
{
var writer = new BinaryWriter(stream);
//первым делом записываем длину строки
writer.Write(StringFieldLenght);
//записываем саму строки
writer.Write(stringFieldBytes);
return messageData;
}
}
public static StringCommand FromBytes(byte[] bytes)
{
using (var ms = new MemoryStream(bytes))
{
var br = new BinaryReader(ms);
var command = new StringCommand();
//считываем из потока длину строки
command.StringFieldLenght = br.ReadInt32();
//считываем из потока указанное количества байт и преобразуем в строку
command.StringField = CommandUtils.GetString(br.ReadBytes(command.StringFieldLenght));
return command;
}
}
}
```
Чтобы принимающая сторона узнала что за команда пришла, необходимо перед отправкой команды отослать заголовок, который указывает количество ( в примере этот момент упущен, прием идет только по одной команде) и тип команды:
**CommandHeader**
```
public struct CommandHeader
{
// тип команды, соответствует перечислению CommandTypeEnum
public int Type { get; set; }
// количество команд
public int Count { get; set; }
public static int GetLenght()
{
return sizeof(int) * 2;
}
public static CommandHeader FromBytes(byte[] bytes)
{
using (var ms = new MemoryStream(bytes))
{
var br = new BinaryReader(ms);
var currentObject = new CommandHeader();
currentObject.Type = br.ReadInt32();
currentObject.Count = br.ReadInt32();
return currentObject;
}
}
public byte[] ToBytes()
{
var data = new byte[GetLenght()];
using (var stream = new MemoryStream(data))
{
var writer = new BinaryWriter(stream);
writer.Write(Type);
writer.Write(Count);
return data;
}
}
}
```
В моем случае, взаимодействие сервера с клиентом, происходит по следующему алгоритму:
1. Клиент создает подключение.
2. Отправляет команду
3. Получает ответ.
4. Закрывает соединение.
5. Если ответ от сервера не пришел, отключается по таймауту.
Отправка команды серверу:
**Вызов метода отправки команды на сервер**
```
//создаем команду содержащую строку текста
var stringCommand = new StringCommand
{
StringField = stringCommandTextBox.Text
};
//отправляем на локальный сервер
CommandSender.SendCommandToServer("127.0.0.1", stringCommand, CommandTypeEnum.StringCommand);
```
**Тело метода команды отправки на сервер**
```
public static void SendCommandToServer(string serverIp, BaseCommand command, CommandTypeEnum typeEnum)
{
//создаем заголовок команды, которые указывает тип и количество
var commandHeader = new CommandHeader
{
Count = 1,
Type = (int)typeEnum
};
//соединяем заголовок и саму команду
byte[] commandBytes = CommandUtils.ConcatByteArrays(commandHeader.ToBytes(), command.ToBytes());
//отправляем на сервер
SendCommandToServer(serverIp, Settings.Port, commandBytes);
}
private static void SendCommandToServer(string ipAddress, int port, byte[] messageBytes)
{
var client = new TcpClient();
try
{
client.Connect(ipAddress, port);
//добавляем 4 байта указывающие на длину команды
byte[] messageBytesWithEof = CommandUtils.AddCommandLength(messageBytes);
NetworkStream networkStream = client.GetStream();
networkStream.Write(messageBytesWithEof, 0, messageBytesWithEof.Length);
//получаем и парсим от сервера ответ
MessageHandler.HandleClientMessage(client);
}
catch (SocketException exception)
{
Trace.WriteLine(exception.Message + " " + exception.InnerException);
}
}
```
**Получение команд от клиентов на стороне сервера**
```
public class CommandListener
{
private readonly TcpListener _tcpListener;
private Thread _listenThread;
private bool _continueListen = true;
public CommandListener()
{
//слушаем любой интерфейс на указанном порту
_tcpListener = new TcpListener(IPAddress.Any, Settings.Port);
}
public void Start()
{
//прием команд ведется в отдельном потоке
_listenThread = new Thread(ListenForClients);
_listenThread.Start();
}
private void ListenForClients()
{
_tcpListener.Start();
while (_continueListen)
{
TcpClient client = _tcpListener.AcceptTcpClient();
//обработка каждой отдельной команды ведется в отдельном потоке
var clientThread = new Thread(HandleClientCommand);
clientThread.Start(client);
}
_tcpListener.Stop();
}
private void HandleClientCommand(object client)
{
//обработка команд
MessageHandler.HandleClientMessage(client);
}
public void Stop()
{
_continueListen = false;
_tcpListener.Stop();
_listenThread.Abort();
}
}
```
**Обработка полученных команд:**
```
public static void HandleClientMessage(object client)
{
var tcpClient = (TcpClient)client;
//задаем таймаут в три секунды
tcpClient.ReceiveTimeout = 3;
//получаем поток
NetworkStream clientStream = tcpClient.GetStream();
var ms = new MemoryStream();
var binaryWriter = new BinaryWriter(ms);
var message = new byte[tcpClient.ReceiveBufferSize];
var messageLenght = new byte[4];
int readCount;
int totalReadMessageBytes = 0;
//получаем общую длину сообщения
clientStream.Read(messageLenght, 0, 4);
//преобразуем к целому числу
int messageLength = CommandUtils.BytesToInt(messageLenght);
//считываем данные из потока пока не дошли до конца сообщения
while ((readCount = clientStream.Read(message, 0, tcpClient.ReceiveBufferSize)) != 0)
{
binaryWriter.Write(message, 0, readCount);
totalReadMessageBytes += readCount;
if (totalReadMessageBytes >= messageLength)
break;
}
if (ms.Length > 0)
{
//парсим полученные байты
Parse(ms.ToArray(), tcpClient);
}
}
private static void Parse(byte[] bytes, TcpClient tcpClient)
{
if (bytes.Length >= CommandHeader.GetLenght())
{
CommandHeader commandHeader = CommandHeader.FromBytes(bytes);
IEnumerable nextCommandBytes = bytes.Skip(CommandHeader.GetLenght());
var commandTypeEnum = (CommandTypeEnum)commandHeader.Type;
if (commandTypeEnum == CommandTypeEnum.MessageAccepted)
{
if (OnMessageAccepted != null)
OnMessageAccepted();
}
else
{
BaseCommand baseCommand = BytesToCommands[commandTypeEnum].Invoke(nextCommandBytes.ToArray());
switch (commandTypeEnum)
{
case CommandTypeEnum.StringCommand:
if (OnStringCommand != null)
OnStringCommand((StringCommand)baseCommand, tcpClient);
break;
case CommandTypeEnum.SingleCommand:
if (OnSingleCommand != null)
OnSingleCommand((SingleCommand)baseCommand, tcpClient);
break;
case CommandTypeEnum.FileCommand:
if (OnSingleCommand != null)
OnFileCommand((FileCommand)baseCommand, tcpClient);
break;
case CommandTypeEnum.SaveUserCommand:
if (OnSingleCommand != null)
OnSaveUserCommand((SaveUserCommand)baseCommand, tcpClient);
break;
}
}
}
}
```
##### Взаимодействие с Java
Команда передает на сервер одно значение
**Команда**
```
package com.offviewclient.network.commands;
import java.io.*;
public class IntCommand implements Serializable {
public int IntNumber;
public static int GetLenght()
{
return 4 ;
}
public static IntCommand FromBytes(byte[] bytes) throws IOException {
ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
DataInputStream ois = new DataInputStream(inputStream);
IntCommand commandType = new IntCommand();
commandType.IntNumber = ois.readInt();
return commandType;
}
public byte[] ToBytes() throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
DataOutputStream oos = new DataOutputStream (bos);
oos.writeInt(this.IntNumber);
byte[] yourBytes = bos.toByteArray();
oos.close();
bos.close();
return yourBytes;
}
}
```
**Отправка команды и получение ответа от сервера (код из рабочего проекта) :**
```
private void SendPacket(byte[] packetBytes) throws IOException {
byte[] packetBytesWithEOF = CommandUtils.AddCommandLength(packetBytes);
Socket socket = new Socket(serverIP, port);
socket.setSoTimeout(5000);
OutputStream socketOutputStream = socket.getOutputStream();
socketOutputStream.write(packetBytesWithEOF);
byte[] answerBytes = ReadAnswerBytes(socket);
socket.close();
Parse(answerBytes);
}
private byte[] ReadAnswerBytes(Socket socket) throws IOException {
InputStream out = socket.getInputStream();
DataInputStream dis = new DataInputStream(out);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
DataOutputStream binaryWriter = new DataOutputStream (bos);
int readCount;
byte[] message = new byte[10000];
byte[] messageLength = new byte[4];
dis.read(messageLength , 0, 4);
int messageLength = CommandUtils.BytesToInt(messageLength);
int totalReadMessageBytes = 0;
while ((readCount = dis.read(message, 0, 10000)) != 0)
{
binaryWriter.write(message, 0, readCount);
totalReadMessageBytes += readCount;
if(totalReadMessageBytes >= messageLength)
break;
}
return bos.toByteArray();
}
private void Parse(byte[] messageBytes) throws IOException {
if (messageBytes.length >= CommandHeader.GetLenght())
{
CommandHeader commandType = CommandHeader.FromBytes(messageBytes);
int skipBytes = commandType.GetLenght();
if(commandType.Type == CommandTypeEnum.MESSAGE_ACCEPTED)
{
RiseMessageAccepted();
}
if(commandType.Type == CommandTypeEnum.SLIDE_PAGE_BYTES)
{
List drawableList = new Vector();
for(int i = 0; i< commandType.Count; i++)
{
PresentationSlideCommand presentationSlideCommand = PresentationSlideCommand.FromBytes(messageBytes, skipBytes);
drawableList.add(presentationSlideCommand.FileBytes);
skipBytes += presentationSlideCommand.GetLenght();
}
RiseMessageAcceptSlideEvent(drawableList);
}
}
}
```
Важный момент при взаимодействии Java и .Net: java хранить байты элементарных типов по отношению к .Net наоборот, поэтому на стороне .Net все числовые значение надо разворачивать вызовом метода [IPAddress.HostToNetworkOrder](http://msdn.microsoft.com/ru-ru/library/system.net.ipaddress.hosttonetworkorder(v=vs.110).aspx):
##### Использование
В качестве примера, научим сервер принимать команду на сохранение пользователя. Данные пользователя будут содержать имя и фамилию.
Для этого нужно:
1. Добавить новую команду в перечисление
```
public enum CommandTypeEnum : int
{
StringCommand = 1,
MessageAccepted = 2,
SingleCommand = 3,
FileCommand = 4,
SaveUserCommand = 5 // команда на сохранение пользователя
}
```
2. Добавить данные передающиеся с командой:
```
public class SaveUserCommand : BaseCommand
{
private int FirstNameLenght { get; set; }
public string FirstName { get; set; } //имя пользователя
private int SecondNameLenght { get; set; }
public string SecondName { get; set; } //фамилия
public override byte[] ToBytes()
{
byte[] firstNamebytes = CommandUtils.GetBytes(FirstName);
FirstNameLenght = firstNamebytes.Length;
byte[] secondNamebytes = CommandUtils.GetBytes(SecondName);
SecondNameLenght = secondNamebytes.Length;
int messageLenght = sizeof(int) * 2 + FirstNameLenght + SecondNameLenght; // длина сообщения
var messageData = new byte[messageLenght];
using (var stream = new MemoryStream(messageData))
{
var writer = new BinaryWriter(stream);
writer.Write(FirstNameLenght);
writer.Write(firstNamebytes);
writer.Write(SecondNameLenght);
writer.Write(secondNamebytes);
return messageData;
}
}
public static SaveUserCommand FromBytes(byte[] bytes)
{
using (var ms = new MemoryStream(bytes))
{
var br = new BinaryReader(ms);
var command = new SaveUserCommand();
command.FirstNameLenght = br.ReadInt32();
command.FirstName = CommandUtils.GetString(br.ReadBytes(command.FirstNameLenght));
command.SecondNameLenght = br.ReadInt32();
command.SecondName = CommandUtils.GetString(br.ReadBytes(command.SecondNameLenght));
return command;
}
}
}
```
3. Дополнить MessageHandler новым кейсом
```
case CommandTypeEnum.SaveUserCommand:
if (OnSingleCommand != null)
OnSaveUserCommand((SaveUserCommand)baseCommand, tcpClient);
break;
```
4. Дополнить MessageHandler новым маппингом на делегат десериализации
```
private static void FillBytesToCommandsDictionary()
{
BytesToCommands.Add(CommandTypeEnum.StringCommand, StringCommand.FromBytes);
BytesToCommands.Add(CommandTypeEnum.SingleCommand, SingleCommand.FromBytes);
BytesToCommands.Add(CommandTypeEnum.FileCommand, FileCommand.FromBytes);
BytesToCommands.Add(CommandTypeEnum.SaveUserCommand, SaveUserCommand.FromBytes);
}
```
5. Отправляем новую команду на стороне клиента:
```
var saveUserCommand = new SaveUserCommand
{
FirstName = firstNameTextBox.Text,
SecondName = secondNameTextBox.Text
};
CommandSender.SendCommandToServer(serverIpTextBox.Text, saveUserCommand, CommandTypeEnum.SaveUserCommand);
```
6. Принимаем на стороне сервера:
```
MessageHandler.OnSaveUserCommand += CommandListener_OnSaveUserCommand;
private static void CommandListener_OnSaveUserCommand(SaveUserCommand saveUserCommand, TcpClient tcpClient)
{
Console.WriteLine("SaveUserCommand accepted, FirstName:{0}, SecondName:{1}", saveUserCommand.FirstName, saveUserCommand.SecondName);
CommandSender.SendMessageAcceptedToClient(tcpClient);
}
```
Надеюсь, что это все будет кому-то полезным. Демо проект на яндекс диске: <http://yadi.sk/d/1OxmAFuCN3kmc>.
Всем спасибо! | https://habr.com/ru/post/220285/ | null | ru | null |
# Автоматический дымоуловитель для пайки, основанный на Arduino
Автор статьи, перевод которой мы представляем вашему вниманию, хочет рассказать о том, как сделать датчик, основанный на Arduino, который автоматически включает дымоуловитель при извлечении паяльника из держателя.
[](https://habr.com/ru/company/ruvds/blog/554290/)
Для этого проекта вам понадобится [Arduino UNO Wifi Rev.2](https://store.arduino.cc/usa/arduino-uno-wifi-rev2), инфракрасный [датчик](https://www.amazon.com/HiLetgo-Infrared-Obstacle-Avoidance-Sensor/dp/B082Y1GFJF/) препятствий KY-032 и одноканальное [реле](https://www.amazon.com/ARCELI-KY-019-Channel-Module-arduino/dp/B07BVXT1ZK/) на 5В. Некоторые элементы надо будет напечатать на 3D-принтере. Для сборки готового устройства нужно будет воспользоваться паяльником.
Обзор проекта
-------------
Создание разных электронных устройств — это интересное, творческое занятие. Но тому, кто этим занимается, нельзя забывать о безопасности. В частности, в процессе пайки электронных компонентов выделяется дым, который не стоит вдыхать. Простым решением этой проблемы является дымоуловитель для пайки.
Мои проблемы, касающиеся использования дымоуловителя, вызваны моими же ошибками. Например, часто я так погружён в мысли о том, что к чему нужно припаять, или о том, каким будет готовый проект, что попросту забываю включать вентилятор дымоуловителя. А иногда, когда надо, например, перепаять лишь одно соединение или поправить один-два провода, мне просто не хочется тратить время на включение и выключение вентилятора. Может — это от лени? Вполне вероятно, что так оно и есть.
С другой стороны, кто-то может просто включить дымоуловитель в начале работы и всё время держать его работающим. И хотя это решает задачу избавления от вредного дыма, не очень приятным может оказаться шум. Я предпочёл бы в процессе работы слушать музыку, а не шум вентилятора.
Можно ли как-то решить эту проблему? Сделать так, чтобы дымоуловитель включался только тогда, когда он нужен? Да — можно. Её решением является система, автоматически включающая дымоуловитель в нужные моменты и выключающая его тогда, когда он не нужен.
Сборка системы
--------------
Мой проект представляет собой устройство, которое автоматически включает вентилятор дымоуловителя каждый раз, когда паяльник вынимают из держателя, и выключает тогда, когда паяльник возвращают на место. При таком подходе мне не приходится заботиться о том, чтобы самостоятельно включать и выключать вентилятор, но при этом я всегда защищён от вредного дыма. Вот как выглядит держатель паяльника с установленным на нём датчиком, ответственным за включение и выключения вентилятора.
*Самодельная система для включения и выключения дымоуловителя*
Сердцем проекта является инфракрасный датчик препятствий KY-032. Такие часто используют в проектах, где нужно обнаруживать препятствия. А я, после экспериментов, выяснил, что этот датчик хорошо показывает себя в деле обнаружения любых объектов, в том числе — паяльника. Этот датчик мы будем использовать для того чтобы узнавать о том, находится или нет перед ним паяльник, то есть — о том, установлен ли паяльник в держатель или нет.
*Инфракрасный датчик препятствий KY-032*
### ▍Шаг 1: 3D-печать крепления датчика
Сначала я, пользуясь Fusion 360, спроектировал крепление для инфракрасного датчика. Я остановился на размещении датчика перпендикулярно паяльнику, на достаточном расстоянии от него, чтобы жар от паяльника не повредил бы крепление.
*Крепление датчика*
### ▍Шаг 2: реле и монтажная коробка
На следующем шаге работы я подключил высоковольтный кабель к реле. Если сомневаетесь в своих способностях — не работайте с опасным напряжением и всегда помните о безопасности. Когда датчик обнаруживает то, что паяльник вынут из крепления, на реле поступает сигнал, благодаря которому замыкается соответствующая цепь и на вентилятор дымоуловителя подаётся питание.
*Реле и монтажная коробка*
### ▍Шаг 3: подключение Arduino
Ниже показана схема проекта, ей я руководствовался, собирая воедино все его компоненты.
*Схема проекта (*[*оригинал*](https://hacksterio.s3.amazonaws.com/uploads/attachments/1254137/solder_fan_schem_arduino_2XcsmjLD0h.jpg)*)*
Плата Arduino, после подключения, устанавливается в особом отсеке монтажной коробки, защищающем плату от внешних воздействий.
*Монтажная коробка с Arduino*
### ▍Шаг 4: программирование Arduino
Ниже приведёт код, используемый в моём проекте:
```
#define ledPin D4
#define sensorPin D1
#define relayPin D2
unsigned long previousMillis = 0;
const long interval = 1000;
int serialAlert = 0;
void setup() {
// тут размещают код для настройки системы, выполняемый однократно:
Serial.begin(9600);
pinMode(ledPin, OUTPUT);
pinMode(sensorPin, INPUT);
pinMode(relayPin, OUTPUT);
}
void loop() {
// тут размещают код, который надо выполнять по много раз:
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
previousMillis = currentMillis;
if (digitalRead(sensorPin) == LOW) {
if (serialAlert == 0) {
Serial.println("Objected Detected");
serialAlert = 1;
}
digitalWrite(ledPin, HIGH);
digitalWrite(relayPin, LOW);
}
else {
if (serialAlert == 1) {
Serial.println("No Objected Detected");
serialAlert = 0;
}
digitalWrite(ledPin, LOW);
digitalWrite(relayPin, HIGH);
}
} // окончание цикла
}
```
А именно, тут имеется цикл, в котором считываются показания датчика. Если датчик не «видит» объекта — срабатывает реле, включающее вентилятор дымоуловителя. Если датчик фиксирует наличие объекта — вентилятор выключается.
Вот как всё это работает.
*Демонстрация работы системы автоматического включения дымоуловителя*
Итоги
-----
Работать над этим проектом было очень увлекательно. Он функционирует именно так, как мне нужно. Надеюсь, мой рассказ вдохновит кого-нибудь на создание чего-нибудь такого же интересного.
Используете ли вы Arduino в каких-нибудь домашних проектах?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=avtomaticheskij_dymoulovitel_dlya_pajki,_osnovannyj_na_arduino) | https://habr.com/ru/post/554290/ | null | ru | null |
# ВебМани тихо и незаметно усилили защиту. Возможно, у некоторых будут затыки с платежами
WebMoney усилило безопасность денежных переводов, в связи с чем многие могут потерять время и нервы.
Так как я их уже потерял, пишу этот пост, чтобы ~~получить профит~~ вы эти грабли обошли стороной.
Итак, если вы пользователь этой системы и планируете в обозримом будущем вывод денег, новая защита может на вас сработать и перестараться.
**Подробности, инструкции**:
ВебМани ввели смс-подтверждение финансовых операций. Казалось бы — здорово. Неудобство возникло в двух моментах:
1. Его включили по-умолчанию, никого не спросив.
2. Об этом никого не предупредили и не уведомили о включении.
В итоге для меня стало сюрпризом новое поле, тем более никаких смсок не пришло.
При этом смски приходят на тот мобильный номер, который **вы указали при регистрации**, даже если после этого вы его 10 раз поменяли, забыли, подтвердили новые номера.
Если вы номер с тех пор точно не меняли, то шаг 1 пропускаем.
**Шаг 0**. Запускаем наш кипер.
**Шаг 1**. Нигде в интерфейсах не значится изначальный контактный телефон, и поменять его можно только через саппорт ВебМани.
Через сам интерфейс кошелька в саппорт по этому вопросу обращаться бесполезно, поэтому сразу звоним сюда: +7 (495) 7274333.
Перед звонком забиваем в веб-интерфейсе свой актуальный сотовый и авторизуем его
`https://passport.webmoney.ru/asp/certView.asp?wmid=ваш_вм_айди_юзернейм`
По телефону просим, чтобы они вручную вбили у себя в системе этот новый телефон. Возможно придется вспомнить, какой был старый (хотя бы сам номер).
**Шаг 2**. Если ворочаете крупными суммами и готовы мучатся ради перестраховки, можно оставить всё как есть, коды будут приходить на актуальный номер.
**Шаг 3**. Если там у вас не астрономические суммы, и лень возиться с кодом, отменить это можно [по адресу](https://security.webmoney.ru/asp/transconfirm.asp).
Если телефон меняли недавно, получится не с первого раза.
*P.S. Надеюсь, это нововведение принесёт больше головной боли мошенникам, чем порядочным пользователям.*
*P.P.S. Судя по отзывам комментаторов, спонтанные включения уведомлений не сильно массовые, затронуло далеко не всех пользователей.* | https://habr.com/ru/post/108337/ | null | ru | null |
# Взлом и защита шифрования дисков LUKS
Шифрование дисков предназначено для защиты данных в компьютере от несанкционированного физического доступа. Бытует распространённое заблуждение, что дисковое шифрование с этой задачей действительно справляется, а сценарии, в которых это не так, представляются уж слишком экзотическими и нереалистичными. В этой статье показано, что извлечение мастер-ключа шифрованного тома LUKS легко осуществимо на практике, и предложен (давно не новый) метод защиты.
Суть проблемы
-------------
Отдельно стоит остановиться на предназначении дискового шифрования. Действительно, когда физический доступ невозможен и данными владеет запущенная система, проблем никаких нет. Могут быть проблемы с безопасностью самой системы, но тут шифрование дисков никак не поможет. Дисковое шифрование должно оберегать данные, когда у любопытствующей стороны есть возможность получить доступ к дискам минуя систему, например физически подключив диски к своей системе или загрузив свою ОС на инспектируемом компьютере. Сценарий физического доступа — единственный сценарий, при котором дисковое шифрование имеет какой-то смысл.
Проблема состоит в том, что атакующий может незаметно вмешаться в цепь загрузки ОС и вынудить систему выдать ключи шифрования, как только она их получит при очередном запуске.
Такая атака требует лишь одного акта доступа к компьютеру: данные с диска можно скопировать совместно с подменой цепи загрузки, а потом расшифровать их, дождавшись появления ключа. В сравнении с незашифрованными дисками неудобство состоит только в том, что нужно озаботиться тем, как ключ будет передан, и дождаться запуска.
Далее перейдём к демонстрации такой техники на практике. Может оказаться так, что для её реализации атакующему потребуется меньше усилий, чем владелец системы затратил на настройку какого-то своего экзотического метода разблокировки дисков (например, удалённо).
Практическая демонстрация
-------------------------
Демо я проведу на примере виртуальной машины с Debian 9, на которой шифрование дисков было включено при установке системы.
Установка Debian 9 с шифрованием создаёт загрузочный раздел и раздел с шифрованным LVM. Снимок экрана установленной системы с запросом пароля расшифровки для наглядности:
Всё готово, можно приступать. Выключаем машину, копируем диск. В моем случае это выглядит так:
```
[root@dt1 ~]# virsh destroy debian9-boothack
Домен debian9-boothack разрушен
[root@dt1 ~]# cp -v /var/lib/libvirt/images/debian9-boothack.qcow2 ~
'/var/lib/libvirt/images/debian9-boothack.qcow2' -> '/root/debian9-boothack.qcow2'
```
Монтируем диск машины, извлекаем инитрамдрайв:
```
[root@dt1 ~]# mkdir /guest
[root@dt1 ~]# guestmount -a /var/lib/libvirt/images/debian9-boothack.qcow2 -m /dev/sda1 /guest
[root@dt1 ~]# cp -v /guest/initrd.img-4.9.0-9-amd64 ~user/tmp
'/guest/initrd.img-4.9.0-9-amd64' -> '/home/user/tmp/initrd.img-4.9.0-9-amd64'
```
Распаковываем инитрамдрайв:
```
[user@dt1 tmp]$ mkdir unpacked
[user@dt1 tmp]$ cd unpacked/
[user@dt1 unpacked]$ zcat ../initrd.img-4.9.0-9-amd64 | cpio -idm
[user@dt1 unpacked]$ ls
bin conf etc init lib lib64 run sbin scripts
```
Готово, можно редактировать инитрамдрайв. Зная, что машина имеет постоянное сетевое подключение, я хочу организовать зашифрованную отправку мастер-ключа после открытия дисков. Для этого мне потребуется:
1. [Утилита для шифрованной отправки по сети](https://gist.github.com/Snawoot/641c1fd31e0a59df70275219db3db5a8). Добавляю её в `/sbin`
2. [Шелл-скрипт для извлечения ключа и отправки](https://gist.github.com/Snawoot/b495eadebe0e8c6712d4facb2e21620f). Отправляется в `/scripts/local-top` и добавляется в список `/scripts/local-top/ORDER` после `cryptoroot`.
3. Недостающий [родной скрипт обработки событий udhcpc](https://gist.github.com/Snawoot/1c7863669fca8a99a6389bb2d3c77733), чтобы запустить автонастройку сети прямо в рамдрайве, пользуясь встроенными средствами. Его законное место в `/etc/udhcpc/default.script`
Исполняемый файл secsend собран статически, чтобы устранить зависимости от каких-либо библиотек. При обычных условиях сборка даёт на выходе файл размером 2,7 МБ, что довольно ощутимо по сравнению с размером рамдрайва — 62 мегабайта в распакованном виде и 20 в сжатом. Однако, при сборке всех библиотек и исполняемого файла с минималистичной musl libc размер выходного файла получается ~250 КБ и 120 КБ после сжатия UPX. Сам secsend просто читает стандартный вход, шифрует его cryptobox-ом из libsodium с использованием заданного публичного ключа Curve25519 и отправляет данные на заданный адрес по TCP. Его использование непринципиально для основной цели демонстрации, он скорее показывает что атакующий по сути ничем не ограничен: можно запускать код, который делает что хочет атакующий и как он этого хочет.
После добавления этих трёх файлов и редактирования ещё одного можно запаковывать всё обратно и возвращать изменённый файл на место:
```
[user@dt1 unpacked]$ find . | cpio -o -c | gzip -9 > ../initrd.img-4.9.0-9-amd64
125736 блоков
[user@dt1 unpacked]$ sudo cp -v ../initrd.img-4.9.0-9-amd64 /guest
'../initrd.img-4.9.0-9-amd64' -> '/guest/initrd.img-4.9.0-9-amd64'
[user@dt1 unpacked]$ sudo guestunmount /guest
```
Потребуется некоторый сервер для приёма зашифрованного мастер-ключа, например [такой](https://gist.github.com/Snawoot/1b0cb9f448f721c233062574dd5f58c3) (Python 3.5.3+). Запустив его с указанием секретной части ключевой пары, дожидаемся, пока условная жертва включит свой компьютер:
При включении виртуальной машины с зашифрованным диском всё внешне выглядит как обычно, ничего не изменилось:
А вот на стороне слушателя подключений появился секретный мастер-ключ:
С этого момента сама виртуальная машина с данными и её пользователь со знанием пароля шифрования уже не представляют интереса для злоумышленника. Особо отмечу, что смена парольной фразы не меняет мастер-ключ, которым зашифрован весь том. Даже если между снятием копии и отправкой ключа как-то затесалась смена парольной фразы — это не помеха. Воспользуемся мастер-ключом для открытия тома. Для этого преобразуем его 16ричную запись в логе в бинарный файл:
```
[root@dt1 ~]# echo 'fa0c53***********4bd8c' | xxd -r -p > master.key
```
Монтируем диски со снятой копии:
```
[root@dt1 ~]# modprobe nbd max_part=8
[root@dt1 ~]# qemu-nbd --connect=/dev/nbd0 /root/debian9-boothack.qcow2
[root@dt1 ~]# ls /dev/nbd0*
/dev/nbd0 /dev/nbd0p1 /dev/nbd0p2 /dev/nbd0p5
[root@dt1 ~]# file -s /dev/nbd0p5
/dev/nbd0p5: LUKS encrypted file, ver 1 [aes, xts-plain64, sha256] UUID: fb732477-ef98-40b5-86a2-8526c349f031
[root@dt1 ~]# cryptsetup --master-key-file=master.key luksOpen /dev/nbd0p5 crackeddisk
[root@dt1 ~]# pvs
PV VG Fmt Attr PSize PFree
/dev/mapper/crackeddisk debian9-boothack-vg lvm2 a-- 19,75g 0
/dev/sda3 dt1 lvm2 a-- <215,01g 8,00m
[root@dt1 ~]# lvs
LV VG Attr LSize Pool Origin Data% Meta% Move Log Cpy%Sync Convert
root debian9-boothack-vg -wi-a----- 18,75g
swap_1 debian9-boothack-vg -wi-a----- 1,00g
root dt1 -wi-ao---- 215,00g
[root@dt1 ~]# mkdir /hackedroot
[root@dt1 ~]# mount /dev/mapper/debian9--boothack--vg-root /hackedroot/
[root@dt1 ~]# ls /hackedroot/
bin boot dev etc home initrd.img initrd.img.old lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var vmlinuz vmlinuz.old
[root@dt1 ~]# cat /hackedroot/etc/hostname
debian9-boothack
```
Данные извлечены.
Меры защиты
-----------
Как можно заключить — корень проблемы в запуске недоверенного кода. Вот небольшой обзор методик, которые стоит рассмотреть в контексте этого вопроса.
### Шифрование загрузочного раздела
Некоторые дистрибутивы предлагают и такую возможность при установке (например OpenSuSE). В таком случае загрузочный раздел расшифровывается загрузчиком, а затем с него загружаются ядро и инитрамдрайв. Такой подход не имеет особого смысла по следующим причинам:
* Самый главный вопрос с подменой кода всё равно остаётся открытым. Только теперь подменять нужно будет загрузчик.
* Для загрузочного раздела важнее не конфиденциальность данных, а целостность данных. Обычное шифрование LUKS не предоставляет такой гарантии. Некоторая выгода здесь заключается только в том, что на таком зашифрованном разделе трудно сформировать осмысленную подмену.
* И шифрование LUKS2 с проверкой целостности (dm-integrity) тоже не защищает от вмешательств, потому что оно не даёт гарантий против атак, связанных с повторным воспроизведением секторов. Например, имея дамп такого раздела и конфиг загрузчика на нём, всё равно можно взять и откатить ядро на состояние, скопированное ранее. Это не даёт преимуществ конкретно в вопросе извлечения ключа (разве что если старое ядро было уязвимо и это можно каким-то образом использовать), это скорее довод в пользу бесполезности шифрования загрузочного раздела.
### Использование TPM для хранения ключа шифрования и валидации безопасной среды загрузки
TPM — по сути криптопроцессор, который работает как безопасный анклав или смарткарта в системе. Секретные данные, зашифрованные с его помощью, могут быть расшифрованы только с помощью него и только на его условиях — когда сходятся значения PCR системы, которые зависят от состояния платформы и запускаемого в ней кода. Технология достаточно перспективная и может позволить реализовать безопасное шифрование в системе, не требуя ввода ключа (например, выполняя вход по отпечатку пальца или по несвязанным с шифрованием методам аутентификации). В идеальном случае он должен работать совместно с UEFI Secure Boot, запрещая расшифровку, когда конфигурация не сходится.
Однако в линуксе поддержка TPM пока находится в зачаточном состоянии. Загрузчик TrustedGRUB2 (приспособленный для работы с TPM загрузчик) не поддерживает UEFI и от этого пропадает весь смысл затеи. Кроме того наличие рабочего TPM 2.0 только сейчас начинает появляться в железе, зачастую вместе с обновлениями BIOS. Большинство материнских плат не имеют дискретного TPM-модуля, вместо этого TPM программно реализован внутри Intel ME. По всем этим причинам я пока не рассматриваю такую конфигурацию как рабочую и пригодную для широкого использования.
### Использование UEFI Secure Boot для полного покрытия загрузочной цепи электронной подписью
Существуют дистрибутивы (Fedora, OpenSuSE) и одиночные решения, которые позволяют использовать Secure Boot в Linux. Однако, коробочные решения зачастую не обеспечивают целостность кода в цепи загрузки. Они предназначены преимущественно для того, чтобы Linux просто запускался при включенном Secure Boot. Обычно просто используется EFI shim, подписанный сертификатом Microsoft, который дальше запускает всё что угодно. Соответственно, при использовании внешнего сертифицирования покрыть подписью инитрамдрайв, который генерируется прямо в установленной системе, просто невозможно.
На хабре имеются статьи, которые предлагают использовать собственную PKI для подписи кода. Это позволяет подписывать всё, что нужно, самостоятельно и таким образом покрыть всю цепь UEFI → загрузчик → ядро и инитрамдрайв.
1. [Укрощаем UEFI SecureBoot](https://habr.com/ru/post/273497/) — первая статья на хабре на эту тему, очень подробная.
2. [Используем Secure Boot в Linux на всю катушку](https://habr.com/ru/post/308032/) — здесь особенно хорошо написано, почему Secure Boot с установленными сертификатами Microsoft эквивалентен его отсутствию.
Требуемый результат получается во второй статье. Подпись инитрамдрайва достигается слиянием рамдрайва и ядра в одно EFI-приложение, без использования загрузчика, и UEFI напрямую проверяет подпись сразу оптом. Оба руководства требуют массу ручной работы на каждой защищаемой системе.
Доступное решение
-----------------
Мне встретился [подход к полноценному внедрению Secure Boot, совместимый с общепринятой схемой загрузки](https://www.crowdstrike.com/blog/enhancing-secure-boot-chain-on-fedora-29/) и не требующий серьёзного вмешательства в систему: отдельный загрузчик, отдельный рамдрайв, отдельное ядро. UEFI проверяет подпись только загрузчика GRUB2, загрузчик имеет вшитый конфиг с ключом для проверки подписи и паролем администратора, и дальше проверяет ядро и рамдрайв. Подписанный загрузчик устанавливается параллельно со старым и при необходимости сохраняется возможность запуститься обычным образом, выключив Secure Boot. Разумеется, эта возможность должна быть закрыта паролем администратора в меню настроек UEFI.
Я решил автоматизировать процесс внедрения Secure Boot с собственным PKI и сделать его простым и независимым от дистрибутива насколько возможно. В результате получился вот такой набор из рецепта Makefile и утилит: <https://github.com/Snawoot/linux-secureboot-kit>. Для debian, ubuntu, fedora и centos весь процесс требует всего несколько команд.
Конкретно на примере Debian 9 установка выглядит примерно следующим образом (предполагая, что UEFI уже в Setup Mode):
```
apt update && apt install -y unzip make sbsigntool
wget https://gist.github.com/Snawoot/1937d5bc76d7b0a29f2039aa679c0449/raw/74a63c99be07ec93cfc1df47d2e98e54920c97b7/efitools-1.9.2-static.tar.xz && \
tar xpJf efitools-1.9.2-static.tar.xz -C /
wget https://github.com/Snawoot/linux-secureboot-kit/archive/master.zip
unzip master.zip
cd linux-secureboot-kit-master/
make debian9-install
```
Здесь все команды введены от имени суперпользователя. В итоге остаётся только убедиться, что Secure Boot включён в меню BIOS и защитить настройки BIOS паролем администратора.
А вот как выглядит попытка подмены рамдрайва на такой инсталляции:
Подмена загрузчика (внешний вид зависит от платформы):
Итог
----
Одного лишь дискового шифрования недостаточно для обеспечения конфиденциальности данных. Подпись всей цепи загрузки с использованием UEFI Secure Boot и GPG позволяет достичь хорошего уровня защиты от подмены исполняемого кода при условии, что эксплуатант компьютера способен распознать сброс или подмену системной платы, или даже всего компьютера. В противном случае крайне трудно предложить адекватные способы защиты, если пользователь готов ввести пароль/передать ключ в любую машину, которая случайно оказалась на столе или в серверной.
**ОБНОВЛЕНИЕ** (2020-09-24 20:24:24+00:00): NSA опубликовало технический отчёт со схожими рекомендациями по усилению безопасности загрузочной цепи: [ссылка](https://media.defense.gov/2020/Sep/15/2002497594/-1/-1/0/CTR-UEFI-SECURE-BOOT-CUSTOMIZATION-20200915.PDF/CTR-UEFI-SECURE-BOOT-CUSTOMIZATION-20200915.PDF), [зеркало](https://web.archive.org/web/20200924062024/https://media.defense.gov/2020/Sep/15/2002497594/-1/-1/0/CTR-UEFI-SECURE-BOOT-CUSTOMIZATION-20200915.PDF/CTR-UEFI-SECURE-BOOT-CUSTOMIZATION-20200915.PDF). | https://habr.com/ru/post/457542/ | null | ru | null |
# Решение задания с pwnable.kr 23 — md5 calculator. Разбираемся со Stack Canary. Подключаем библиотеки C в python
В данной статье решим 23-е задание с сайта [pwnable.kr](https://pwnable.kr/index.php), узнаем, что такое stack canary и подключим libc в python.
**Организационная информация**Специально для тех, кто хочет узнавать что-то новое и развиваться в любой из сфер информационной и компьютерной безопасности, я буду писать и рассказывать о следующих категориях:
* PWN;
* криптография (Crypto);
* cетевые технологии (Network);
* реверс (Reverse Engineering);
* стеганография (Stegano);
* поиск и эксплуатация WEB-уязвимостей.
Вдобавок к этому я поделюсь своим опытом в компьютерной криминалистике, анализе малвари и прошивок, атаках на беспроводные сети и локальные вычислительные сети, проведении пентестов и написании эксплоитов.
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Stack Canary
------------
Канарейки (canary) — это известные значения, которые помещаются между буфером и управляющими данными в стеке для мониторинга переполнения буфера. После переполнения буфера, первыми подлежащими повреждению данными, как правило, будет канарейка. Таким образом, значение канарейки будет проверяться и в случае неудачной проверки сигнализировать о переполнении буфера. Существует три типа канареек:
1. Terminator. Канарейки построены из нулевых терминаторов, CR, LF и -1. В результате злоумышленник должен написать нулевой символ перед записью адреса возврата, чтобы избежать изменения канарейки. Это предотвращает атаки с использованием strcpy() и других методов, которые возвращаются при копировании нулевого символа, в то время как нежелательным результатом является известность канарейки.
2. Random. Генерируются случайным образом. Обычно случайная канарейка генерируется при инициализации программы и сохраняется в глобальной переменной. Эта переменная обычно дополняется неотображенными страницами, поэтому попытка ее чтения с использованием любых уловок, использующих ошибки для чтения из ОЗУ, вызывает ошибку сегментации, завершающую программу.
3. Random XOR. Cлучайные канареи, которые ксорятся с контрольных данными. Таким образом, как только канарейка или контрольные данные будут засорены, значение канарейки будет неправильным. Имеют те же уязвимости, что и случайные канарейки, за исключением того, что метод «чтения из стека» для получения канарейки немного сложнее. Атакующий должен получить канарейку, алгоритм и контрольные данные, чтобы заново сгенерировать исходную канарейку, необходимую для подделки защиты.
Решение задания md5 calculator
------------------------------
Продолжаем второй раздел. Скажу сразу, что сложнее первого и нам не предоставляется исходный код приложений. Не забываем про обсуждение [здесь](https://t.me/RalfHackerPublicChat). Начнем.
Нажимаем на иконку с подписью md5 calculator. Нам дают адрес и порт для подключения и саму программу.
Скачиваем все что нам дают, проверяем бинарник.
Это 32-битный elf с установленной канарейкой и неисполняемым стеком. Декомпилируем в IDA Pro.
В программе встроена проверка капчи. Видим две функции интересные функции: my\_hash() и process\_hash(). Начнем с первой.
Давайте переопределим типы переменных и сделаем код более легким для анализа:
Таким образом функция вернет какое-то случайное число. При этом v3 — это данные по адресу EBP-0xC. Давайте глянем другую функцию.
Здесь переменная v4 получает значение по адресу EBP-0xC, а потом ксорится на выходе из функции с этим значением. Далее под переменную v3 выделяется 512 байт, считывается ввод с клавиатуры в переменную g\_buf. После чего, строка из g\_buf декодируется в Base64 и записывается в v3. От v3 вычисялется md5 хеш. Таким образом, ввод в g\_buf и копирование в v3 не ограничиваются, поэтому есть переполнение буфера! Давайте глянем на стек.
Переменная v3 есть стековая канарейка, расположенная после буфера. Также в программе вызывается функция систем. Что же, составим шаблон для эксплоита.
```
from pwn import *
p = remote('127.0.0.1', 9002)
p.recvuntil('captcha : ')
captcha = int(p.recv())
p.sendline(str(captcha))
p.interactive()
```
Для начала разберемся в полезной нагрузкой. Мы должны вызвать функцию system с параметром “/bin/sh”. Но так как стек неисполняемый, мы вызовем функцию систем, передав управление на ее адрес в программе, а в качестве параметра — адрес на строку “/bin/sh”, которую мы запишем в g\_buf.
Таким образом (смотрим по стеку): Нужно записать 512 байт мусора, потом 4 байта значение канарейки, потом еще 12 байт мусора. Теперь для ret мы должны указать адрес функции system (4 байта), адрес строки “/bin/sh”(4 байта), и сама строка “/bin/sh”.
Теперь найдем неизвестные: адрес вызова system.
Это 0x8049187. И адрес строки “bin/sh”. Для этого нам нужно к адресу g\_buf прибавить количество байт до строки “/bin/sh” с учетом кодировки base64 — это 4/3 от исходного значения.
То есть адрес строки: 0x804b0e0 + (512+4+12+4+4+1)\*4/3 = 0x804b3ac. Составим полезную нагрузку.
```
payload = 'A' * 512
payload += p32(canary)
payload += 'A' * 12
payload += p32(0x8049187)
payload += p32(0x804b3ac)
payload = b64e(payload)
payload += "/bin/sh\x00"
```
Осталось найти канарейку. Как мы выяснили, она суммируется со случайными значениями в функции my\_hash(), что в результате дает нам канарейку. А в качестве семени для функции rand используется srand(time(0)). То есть если сы повторим процедуру в своему експлоите, а потом вычтем из присланного куки сгенерированное значение, мы найдем канарейку. Вызываем rand() из libc в python.
```
from ctypes import *
import os
import time
libc=CDLL('libc.so.6')
t = int(time.time())
libc.srand(t)
n = [libc.rand() for _ in range(8)]
canary = captcha - n[1] - n[5] - n[2] + n[3] - n[7] - n[4] + n[6]
canary &= 0xffffffff
```
Все. Полный код выглядит так.
```
from pwn import *
from ctypes import *
import os
import time
libc=CDLL('libc.so.6')
t = int(time.time())
libc.srand(t)
n = [libc.rand() for _ in range(8)]
p = remote('127.0.0.1', 9002)
p.recvuntil('captcha : ')
captcha = int(p.recv())
p.sendline(str(captcha))
canary = captcha - n[1] - n[5] - n[2] + n[3] - n[7] - n[4] + n[6]
canary &= 0xffffffff
payload = 'A' * 512
payload += p32(canary)
payload += 'A' * 12
payload += p32(0x8049187)
payload += p32(0x804b3ac)
payload = b64e(payload)
payload += "/bin/sh\x00"
p.sendline(payload)
p.interactive()
```
Запускал несколько раз и не работало, потом понял, что из-за скорости интернета и разницы времени не совпадает результат rand(). Запустил на сервере.
Получаем искомый флаг. Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). | https://habr.com/ru/post/467485/ | null | ru | null |
# Обзор языка функционального программирования Koka
Как-то заглянув на [GitHub](https://github.com/), обнаружил [Koka](https://koka-lang.github.io/koka/doc/index.html) — язык функционального программирования со статической типизацией. Koka разрабатывается с 2012 года [Daan Leijen](https://www.microsoft.com/en-us/research/people/daan/) в [Microsoft Research, USA](https://www.microsoft.com/en-us/research/project/koka/). Его исходники выкладываются на [GitHub](https://github.com/koka-lang/koka) под лицензией *Apache 2.0*. Как признаются его авторы, он ещё не готов для промышленного применения: у него нет библиотек, менеджера пакетов и полной поддержки в средах разработки. При этом сам язык достаточно стабилен, а компилятор полностью разработан. Отдельными моментами язык напоминает Rust, Haskell и Scala. Сам же по себе он интересен контролем побочных эффектов. Это его основная фишка. Приглашаю познакомиться с Koka и обсудить его свойства.
```
fun main(): console ()
println("Hello, World!")
```
Сначала пробежимся по свойствам языка, а затем рассмотрим один небольшой пример.
Итак, Koka обладает следующими свойствами:
* статическая типизация с выводом типов;
* функциональная парадигма;
* неизменяемость при наличии настоящих переменных;
* разделение на чистый код и код с побочными эффектами;
* синтаксис, напоминающий таковой у Rust и Scala;
* идентификаторы допускают символ дефис `-` (как в Lisp);
* комбинация синтаксисов со скобками и с отступами;
* типы-объединения и типы-структуры;
* полиморфизм;
* отсутствие циклов (при этом рекурсивный код при компиляции
может быть преобразован в циклический);
* оператор возврата из функции необязателен:
результатом будет значение последнего выражения;
* сопоставление с образцом;
* оператор точка, позволяющий заменить вложенные вызовы функций на их последовательность
(как операция `|>` в Elm или Elixir);
* оператор `with`, позволяющий избавиться от использования анонимных функций;
* необязательные и именованные параметры функций;
* отсутствие сборщика мусора;
* компиляция в машинный код и другие целевые платформы;
* имеется REPL.
Подробно о языке можно почитать в [официальной документации](https://koka-lang.github.io/koka/doc/book.html).
Инструкции по установке Koka есть на главной странице проекта. Поддерживаются только 64-х разрядные системы. Можно собрать из исходников, которые написаны на *Haskell*. Также дистрибутив можно получить с [GitHub](https://github.com/koka-lang/koka/releases) проекта. Например, для Debian и Ubuntu предлагаются готовые к установке пакеты.
После установки, кроме компилятора со стандартной библиотекой языка, будут установлены дополнения для подсветки синтаксиса в GNU Emacs, Atom и Visual Studio Code. В Code расширение было подхвачено автоматически. А в Emacs потребовалось написать в `.emacs/init.el` пару строчек:
```
(load "/usr/share/koka/v2.4.0/contrib/emacs/koka-mode")
(require 'koka-mode)
```
Вычисляем числа Фибоначчи, или программирование с эффектами
-----------------------------------------------------------
Чтобы познакомиться с Koka на деле, напишем программу, которая вычисляет n-е число Фибоначчи и печатает его в консоли.
Синтаксис языка достаточно прост, чтобы набросать начальную версию программы:
```
fun main()
val n = 10
println(fib(n))
fun fib(n : int) : int
match n
0 -> 0
1 -> 1
_ -> fib(n - 1) + fib(n - 2)
```
Сохраним файл с именем `fibonacci.kk` и попробуем скомпилировать эту программу:
```
koka fibonacci.kk
```
И получим вот такое сообщение компилятора:
```
compile: fibonacci.kk
loading: std/core
loading: std/core/types
loading: std/core/hnd
check : fibonacci
fibonacci.kk(5, 5): error: effects do not match
context : fib
term : fib
inferred effect: (<>)
expected effect:
because : effect cannot be subsumed
```
Здесь мы видим, что компиляция прошла успешно, то есть синтаксически программа корректна, но вот проверку программа уже не прошла: функция `fib` была неявно объявлена с эффектом `total`, коротко обозначаемым как `<>`, что означает чистоту. Но чекер обнаружил, что у функции эффект другого типа `div`. Этот тип эффектов возникает в программах, в которых не гарантируется останов. По видимому компилятор так решил, потому что наша функция рекурсивна. (Добавление проверки на отрицательный аргумент не делает функцию с точки зрения чекера тотальной. Оставлю читателю этот эксперимент в качестве упражнения.)
У нас есть два варианта:
* задать конкретный тип эффекта `div`;
* или попросить вывести тип эффекта, указав `_`.
```
fun main()
val n = 10
println(fib(n))
fun fib(n : int) : _ int
match n
0 -> 0
1 -> 1
_ -> fib(n - 1) + fib(n - 2)
```
Теперь программа успешно соберётся. Запустим и убедимся в правильности результата:
```
./.koka/v2.4.0/gcc-debug/fibonacci
```
Вообще, этот код с подвохом: мы не задали тип для функции `main`. Каков же он на самом деле? Давайте попробуем разобраться.
Запустим REPL:
```
koka
```
Загрузим наш модуль:
```
:l fibonacci.kk
```
И запросим тип функции `fib`:
```
:t fib
```
Получим ожидаемое:
```
check : interactive
(n : int) -> div int
```
Теперь для `main`:
```
:t main
```
Оказывается у `main` тип такой:
```
check : interactive
() -> ()
```
То есть `main` ничего не возвращает (имеет пустой тип `()`) и имеет два эффекта: `div` и `console`. Первый эффект обусловлен вызовом из `main` функции с таким эффектом, а второй связан с тем, что `main` осуществляет ввод-вывод.
В Koka есть ещё два вида эффектов:
* `exn` для функций, генерирующих исключения;
* `ndet` для недетерминированных функций.
Но вы можете создавать свои собственные эффекты и их обработчики.
Так что давайте этом займёмся: добавим в наш код печать отладочной информации — будем выводить в консоль каждое вычисленное значение числа Фибоначчи. Обычное решение в этом случае — вставить в нужное место кода функцию печати:
```
fun debug-info(value : int) : _ int
println(value)
return value
fun fib(n : int) : _ int
debug-info(match n {
0 -> 0
1 -> 1
_ -> fib(n - 1) + fib(n - 2)})
fun main()
val n = 10
println(fib(n))
```
Но что если мы хотим в разных местах кода для вызова `fib` печатать по разному? Вот здесь нам уже пригодятся эффекты с обработчиками:
```
effect fun debug-info(value : int) : int
fun fib(n : int) : _ int
debug-info(match n {
0 -> 0
1 -> 1
_ -> fib(n - 1) + fib(n - 2)})
fun main()
val n = 10
with handler
fun debug-info(value)
println(value)
return value
println(fib(n))
with handler
fun debug-info(value)
println("* " ++ show(value) ++ " *")
return value
println(fib(n))
```
В первой строке кода мы объявили абстрактный эффект, а перед вызовом кода, где вычисляется `fib` мы определяем обработчик этого эффекта с помощью конструкции `with handler`.
На практике
-----------
Как уже говорилось выше, для Koka нет ни библиотек (кроме стандартной), ни менеджера пакетов, а для редакторов кода есть только синтаксическая подсветка. И кажется, что Koka никуда не годится, однако это не совсем так. Автор языка разработал на нём транслятор для markdown в HTML и PDF (с привлечением TeX) для научных текстов [Madoko](https://www.madoko.net/). (В Ubuntu для работы Madoko потребуется дополнительно установить пакет `texlive-science`.)
Что дальше поизучать
--------------------
* Посмотреть и послушать [доклад](https://www.youtube.com/watch?v=6OFhD_mHtKA) на конференции от самого автора языка Daan Leijen. Видео длинное, два с половиной часа, но достаточно интересное и понятное.
* Проштудировать официальную документацию. На одной странице рассмотрены все концепции языка.
* Ознакомиться с примерами кода в исходных текстах Koka на GitHub и с исходниками его стандартной библиотеки (там же).
* Попытаться прочитать научные статьи, в которых описывается математика языка и его компилятора. Ссылки можно найти в README исходных текстов.
© Симоненко Евгений, 2022 | https://habr.com/ru/post/651803/ | null | ru | null |
# Со скрипта на «верфь»
Использование того или иного продукта в проекте - это всегда попытка найти лучшее решение, балансируя между ограниченным бюджетом, возможностями роста практически по любому сценарию и высотой "порога входа". Существует много продуктов, которые связаны с контейнерами, что выбрать подходящий инструмент становится всё сложнее и сложенее, а community с "промытыми мозгами" и мышлением "ёжиков жрущих кактус" только добавляет сложности (хотя в противовес оным есть хейтеры, которые наоборот обгадят решение, просто потому что в своё время оно им не подошло).
В целом, чтобы выбрать нужное решение чаще всего приходится поднять лабу, которая покроет 90% задач, чтобы понять насколько решение подходящее, а это значит пройти какую-то боль, потратить время и деньги. Но ещё помогают статьи, в которых рассматриваются частные случаи внедрения и подбор инструментов, чтобы научиться на чужих ошибках через объективный взгляд со стороны. Надеюсь, эта статья о том, почему и как мы пришли к решению с werf, поможет кому-то подобрать инструмент для своих нужд.
---
Дисклеймер* У меня нет цели прорекламировать какой-либо продукт. Это опыт, где-то положительный, а где-то негативный. Лучше всего рассматривать эту статью как частное исследование.
* Я понимаю, что "всё можно было сделать по другому", но мне так больше нравится.
* Нет, я не получу каких-то плюшек или бонусов от фланта за статью ;) Хотя, who knows...
С чего всё началось?
--------------------
Поступил заказ на довольно обширный по нашим меркам проект, который нужно было спроектировать и написать так, чтобы начав работу с ним, можно было легко масштабироваться в случае успеха. Т.к. команда не большая, то вариант с микросервисами отпал сразу (да и смысла нет). Поэтому мы выбрали классическую сервисную архитектуру на подходящем нам стеке (Vue.js для фронта и Django Rest Framework для бэка) и разделили подвижные части на 4 основных сервиса: базы, кеши, очереди и S3-хранилища. В целом не много, но docker-compose быстро вырос до 7-10 сервисов + traefik для маршрутизации всего этого безобразия.
Естественно для развёртывания всего этого в production нужно было так же подобрать инструмент, который мог быть и достаточно простым, но в то же время хорошо скейлиться. Изначально, в силу скромных размеров проекта и нежелании плодить новые инструменты, выбор пал на docker swarm. В целом интересный инструмент, который хорошо подошёл бы для определённой ниши (например, если бы мы сидели на django-channels и одной точке входа, кмк). Однако для наших задач и ожидаемого формата масштабирования от данного решения пришлось отказаться.
ЖмякВообще масштабирование - это была не основная проблема. Самое обидное было в том, что адекватно перенести тестовое окружение разработчика на деплой в прод вообще было нельзя. Для swarm'а конфиг уж очень сильно отличался. Как итог, все профиты от использования одного инструмента были просто неприменимы. Можно было бы развернуть на каждой машине swarm кластер, но для нескольких нод уже надо было иначе действовать.
Короче говоря, если решение простое, то не всегда правильное. Мы начали об этом думать, когда пришлось прикрутить много костылей, чтобы завести всё это на сварме.
В мире контейнеров не сильно богатый выбор, поэтому решили не обращаться ко всякой экзотике и сразу перейти к эротическим отношениям с kNs (почему N, я расскажу дальше). С точки зрения инструментов, там было всё, что нам нужно, практически "из коробки" (маршрутизация по path'ам, сертификаты, сжатие, кеширование, независимость от расположения контейнера в кластере, мониторинг, автоскейлинг под нагрузкой, пакетный менеджер и т.д.). Если говорить о тестовом окружении, то есть куча готовых инструментов, типа [rke](https://habr.com/ru/post/418691/) и rancher, [k3sup](https://habr.com/ru/company/southbridge/blog/551214/), [k0s](https://habr.com/ru/company/timeweb/blog/534490/), minikube и т.п.
Почему k3supИзначально мы подсели на rke и rancher, но почему-то он оказался сильно прожорливым, поэтому самым оптимальным нашли для себя k3sup. Он достаточно экономичен по ресурсам, лёгкок в деплое на несколько машин и в целом очень приятный продукт.
k0s нужно было деплоить по сути руками, а разработчики по натуре ленивые (в хорошем смысле этого слова). Поэтому, дабы не плодить костыли, решили использовать готовое решение.
Был только один геморой. У них там какая-то бага с ключами RSA, поэтому самым простым решением является использование ecdsa. Чтобы развернуть среду из трёх нод, nginx-ingress и metallb требовалось 15 минут максимум. Если завернуть в скрипт, то минут 5. На скрипт не стали тратить время, потому что тестовый стенд развернуть надо 1 раз, а для локальной отладки можно и миникуб использовать.
Когда мы говорим о кубере, то что первое приходит на ум для развёртывания приложения? [Helm](https://habr.com/ru/post/547682/) и [Kustomize](https://habr.com/ru/company/flant/blog/469179/) наиболее популярные способы деплоя, но они не занимаются сборкой. Пришлось смириться, тем более было принято решение сохранить и поддерживать docker-compose для прям совсем локальной разработки. Остановились на helm, потому что популярнее, да и понравился больше.
Итак, подойдя к этому этапу, что мы имеем?
* docker-compose для сборки и локальной отладки.
* Helm chart с описанием всех сервисов и доступа к ним.
* Отдельная репа, практически готовая для GitOps, с конфигом куба и values чартов.
Автоматизация и борьба с bus-factor
-----------------------------------
Команда, как я уже сказал, у нас небольшая, с x2 репликацией всего. Соответственно релизным менеджером был просто наиболее компетентный сотрудник. Нужно скейлить на второго, а мы уже знаем, что разработчики люди ленивые, поэтому написали простой скрипт, который будет собирать свежий образ и выкатывать всё на staging с помощью чарта. Скрипт получился довольно сложный, но учитывал всё самое важное:
```
#!/usr/bin/env bash
HELM_DEPLOY_TIMEOUT=${HELM_DEPLOY_TIMEOUT:-600s}
HELM_VALUES=${HELM_VALUES:-"values.yaml"}
COMPOSE_PATH=${COMPOSE_PATH:-"../project/docker-compose.yml"}
IMAGE_BASE=${CI_REGISTRY_IMAGE:-"registry.example.com/project"}
BACKEND_IMAGE="${IMAGE_BASE}:backend"
FRONTEND_IMAGE="${IMAGE_BASE}:frontent"
CHART_PATH=$(dirname ${COMPOSE_PATH})/chart/
KUBECONFIG=`pwd`/kube_config_cluster.yml
kubectl config set-context default
docker-compose -f $COMPOSE_PATH build --pull --progress plain backend frontend && \
docker tag frontend $FRONTEND_IMAGE && \
docker tag backend $BACKEND_IMAGE && \
docker push $FRONTEND_IMAGE && \
docker push $BACKEND_IMAGE && \
BACKEND_IMAGE=$(docker inspect --format='{{.RepoDigests}}' $BACKEND_IMAGE | sed 's/^\[//g' | sed 's/\]$//g' | awk '{ print $1 }') && \
FRONTEND_IMAGE=$(docker inspect --format='{{.RepoDigests}}' $FRONTEND_IMAGE | sed 's/^\[//g' | sed 's/\]$//g' | awk '{ print $1 }') && \
COMMAND=$(echo helm upgrade project $CHART_PATH \
-f $HELM_VALUES \
--set "project.image_back=${BACKEND_IMAGE}" \
--set "project.image_front=${FRONTEND_IMAGE}" \
--install \
--wait \
--timeout $HELM_DEPLOY_TIMEOUT
) && \
echo $COMMAND && \
helm template project $CHART_PATH \
-f $HELM_VALUES \
--set "project.image_back=${BACKEND_IMAGE}" \
--set "project.image_front=${FRONTEND_IMAGE}" && \
$COMMAND
```
Весь процесс можно описать следующими тезисами:
* Собираем базовые образы. Так уж вышло, что мы собираем 2 образа на все сервисы. Если бы реализовывали сервисы в разных образах, то сэкономили бы всего с десяток килобайт. А так довольно удобно отладкой заниматься.
* Ретагаем собранные образы и пушим их в репозиторий. Мы держим только один тег, потому что хранилище не резиновое, а чистить docker registry - та ещё боль. У нас self-hosted Gitlab, поэтому мы стараемся не превращать его в помойку. У них, конечно, есть система автоочистки, но она показалась не слишком гибкой.
* Получаем RepoDigests образа и формируем переменные для чарта. Использование RepoDigests оказалось самым удачным решением, потому что так мы убили сразу двух зайцев: перевыкатку подов при изменении образа и привязку к конкретному состоянию кода.
* Выводим рендер всего проекта (для отладки) и выкатываем проект.
В целом решение рабочее, трудилось несколько месяцев. Проект мог развернуть любой, но нужно было следить за состоянием ветки на рабочей машине. Попытки перенести это в CI были осторожными и требовали docker в сервисах. Хотелось скорости всего процесса. Более того, хотелось автоматизировать не только staging, но и production. Проще говоря - нужен был инструмент доставки. Что попало под выбор:
* [FluxCD](https://habr.com/ru/post/574432/) - kubernetes оператор, который приводит кластер к нужному состоянию. Можно указать некоторое количество git-проектов. Flux не занимается сборкой и работает внутри кластера (или нескольких). В целом всё сводится к тому, что в ConfigMap'е описывается набор переменных, а в чём-то вроде деплоймента описывается то, к какому чарту этот набор применить. Если честно, хотя его и позиционируют как GitOps инструмент, я бы назвал его KubeOps, потому что практически всё содержится в самом кластере, а не в гите.
* [ArgoCD](https://habr.com/ru/company/otus/blog/555832/) - по сути это тот же Flux (не в буквальном смысле), но с GUI (довольно красивым, хочу заметить). Хотя имеется cli-утилита, но я так и не увидел в ней каких-либо преимуществ. Арго разворачивает свой набор деплойментов и сервисов внутри кластера, предоставляет веб-морду, в которой можно настроить что, откуда и как развернуть. Если сравнивать с Flux, то у Арго сильно приятнее работа с semver, наличие GUI снижает порог входа, да и в целом продукт выглядит более простым в управлении. Система плагинов добавляет так же плюсов проекту, потому что можно легко реализовать гибридную систему со сборкой (внутри боевого кластера, ага). Единственное, насколько я понял, работа с несколькими кластерами куба проще реализуется во Flux.
* [Werf](https://habr.com/ru/company/flant/blog/460351/) - cli утилита (в отличии от предыдущих двух) для сборки и доставки контейнеров. Если сравнивать с предыдущими, то верфь как ansible, а Argo и Flux - как Chef и Puppet. Недавно, они [подружились с ArgoCD](https://habr.com/ru/company/flant/blog/666100/). Кардинальное отличие от предыдущих двух инструментов в том, что это наверное самый GitOps'ный инструмент из всех, потому что всё, что нужно, верфь берёт из гита и, в каком-то смысле, является stateless (registry не в счёт, потому что там хранятся образы и манифесты на основе гита). Проще говоря, если вы потеряете кластер и docker registry, то с вероятностью 99.9999% вы получите тот же результат при деплое приложения.
Выбирать сложно, но согласитесь, на наш выбор очень часто влияют наши привычки. У меня вот привычка использовать безагентные инструменты. Но, как видно из описания, это не единственное преимущество. Выбор пал на werf, потому как она ещё умеет в сборку образов. Но моё сердце растаяло перед сборкой в режиме buildah. Освободиться от docker была очень привлекательна перспектива.
Внедряем
--------
Для начала нужно сразу обозначить мой подход к внедрению инструментов. Сейчас идёт повальная мода на то, чтобы привязываться к вендору, будь то GCP, AWS или Azure. Я против такого подхода, потому что не раз сталкивался с ситуациями, когда такая привязка заканчивалась плохо. Именно поэтому я уцепился за возможность использовать уже имеющийся чарт и пробросить в него переменные. Но обо всём по порядку.
#### Сборка
Всё начинается с файла `werf.yaml`. Было необходимо описать все образы и их контекст.
```
configVersion: 1
project: project-deployment
---
image: backend
dockerfile: Dockerfile
context: .
---
image: frontend
dockerfile: Dockerfile
context: frontend
```
Теперь можно использовать [werf build](https://ru.werf.io/documentation/v1.2/reference/cli/werf_build.html). А ещё и `werf compose`, который является [обёрткой над docker-compose](https://ru.werf.io/documentation/v1.2/reference/cli/werf_compose_up.html). Правда пришлось немного подрихтовать сам конфиг, заменив образ на `image: ${WERF_BACKEND_DOCKER_IMAGE_NAME:-backend}` (для фронтенда соответственно`WERF_FRONTEND_DOCKER_IMAGE_NAME`). Это довольно удобно. Были некоторые проблемы с пересборкой, но оказалось, что у разработчиков [неплохой канал](https://t.me/werf_ru) связи в телеграмме. Вообще, я успел их изрядно там задолбать...
#### Субчарт
Итак, со сборкой разобрались, осталось сделать то, ради чего это всё затевалось - доставку приложения. Верфь умеет под капотом работать как helm, притом расширяет его возможности. Можно было пойти простым путём - использовать текущий чарт и двигаться дальше, но пришлось бы многое поменять внутри и заточить под верфь, а это не наш путь. Уверен, что способность использовать нативные инструменты нам ещё пригодится.
Используя документацию, мы [создали чарт](https://ru.werf.io/documentation/v1.2/advanced/helm/configuration/chart.html), в который сразу подтянули некоторые [зависимости](https://ru.werf.io/documentation/v1.2/advanced/helm/configuration/chart_dependencies.html). В дальнейшем вижу возможность перенести это в основной чарт, а этот использовать как плацдарм для тестирования возможностей. В конечном счёте, werf-chart принял следующий вид:
```
apiVersion: v2
name: project-deployment
version: 0.1.0
dependencies:
- name: centrifugo
repository: https://centrifugal.github.io/helm-charts
version: 7.4.0
- name: deigmata
repository: file://../chart
version: 0.1.0
export-values:
- parent: global.project
child: project
- parent: werf.image.backend
child: project.image_back
- parent: werf.image.frontend
child: project.image_front
```
Хочу обратить внимание на `export-values`, который позволяет [пробрасывать в чарт](https://ru.werf.io/documentation/v1.2/advanced/helm/configuration/chart_dependencies.html#%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%87%D0%B0-%D0%B4%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85-values-%D0%B8%D0%B7-%D1%80%D0%BE%D0%B4%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D1%81%D0%BA%D0%BE%D0%B3%D0%BE-%D1%87%D0%B0%D1%80%D1%82%D0%B0-%D0%B2-%D1%81%D0%B0%D0%B1%D1%87%D0%B0%D1%80%D1%82%D1%8B) любые переменные, в том числе из автогенерируемых верфью. Не хватает только циклов и маппинга, чтобы сопоставлять имена образов верфи и чарта, но, как по мне, и так неплохо. `export-values`имеют наивысший приоритет, поэтому имено образы никак не перегрузить, что хорошо и исключает возможность нанести вред неосторожными перегрузками.
Кстати, с этим тоже возникли проблемы после обновления с 1.2.80 на 1.2.109, но ребята довольно быстро отреагировали в чате, и уже на следующий день всё работало как часы (не швейцарские конечно, но хорошие такие отечественные с качественным сервисом и душевными мастерами). Вообще, очень хочу похвалить их за терпение и оперативность, потому что некоторые моменты, которые были просто непонятны из документации, они довольно хорошо донесли, а если у них не получалось что-то воспроизвести, то они не просто кидали "у нас всё работает", а по прежнему пытались выяснить, что не так.
Есть одна немного раздражающая особенность у werf, которая называется [гитерменизм](https://ru.werf.io/documentation/v1.2/advanced/giterminism.html). Всё, что используется для сборки или доставки, должно жить внутри Git, но это не всегда удобно. Конкретно в нашем случае, было бы удобнее прокидывать некоторые переменные в чарт, тем самым менять настройки в самом Gitlab, а не коммитить все изменения в репозиторий. Если для staging окружения ещё нормально, то для production - уже геморой. Единственное, что верфь "кушает" без проблем - это `KUBECONFIG`. Для того, чтобы обходить эти ограничения, существует целый конфиг - [werf-giterminism.yaml](https://ru.werf.io/documentation/v1.2/reference/werf_giterminism_yaml.html). Поэтому, если собираетесь делать проект переиспользуемым, то советую обратить внимание на то, как будете менять конфигурацию развёртываемого приложения, и учесь эту особенность в гитерминизме.
#### Доставка
Переходя непосредственно к доставке, я рассматриваю конкретно наш случай с Gitlab. В документации довольно хороший пример того, как надо пользоваться CI, в том числе для разных систем вроде Gitlab, Github и универсальный подход. В целом, они приводят хорошие примеры как для production/staging окружений, так и для Review.
Лично я пришёл к следующему конфигу (поясню некоторые моменты ниже):
```
.release_env_jobs: &release_template
stage: release
image: registry.werf.io/werf/werf
environment:
name: "$CI_COMMIT_BRANCH"
url: "$ENDPOINT"
before_script:
- type werf && source $(werf ci-env gitlab --as-file)
- werf version
ReleaseToProd:
<<: *release_template
script:
- werf helm repo add centrifugo https://centrifugal.github.io/helm-charts
- werf helm dependency build .helm
- werf build -p
- werf converge --skip-build --set "env_url=$(echo ${CI_ENVIRONMENT_URL} | cut -d / -f 3)"
rules:
- if: '$KUBECONFIG && $CI_PIPELINE_SOURCE != "schedule"'
when: manual
- when: never
Cleanup:
<<: *release_template
stage: cleanup
environment:
name: "$CI_COMMIT_BRANCH"
url: "$ENDPOINT"
action: access
script:
- werf cr login -u nobody -p ${WERF_IMAGES_CLEANUP_PASSWORD} ${WERF_REPO}
- werf cleanup
rules:
- if: '$KUBECONFIG && $CI_PIPELINE_SOURCE == "schedule"'
when: on_success
- when: never
```
Я отказался от многослойной сборки и доставки и остановился на одном ReleaseToProd (слитно для дальнейшего использования в ChatOps гитлаба). После какой-то проблемы, я решил, что использование `werf version` - это обязательный элемент, который прям на уровне документации надо прописать.
К сожалению, токены, предоставляемые Gitlab CI, не позволяют удалять ничего из registry, поэтому приходится использовать костыль в виде `WERF_IMAGES_CLEANUP_PASSWORD`, который по сути personal token с правами на насилие над registry. Не сказать, чтобы это было изящным решением, но позволяет контролировать процесс очистки. Для self-hosted можно прописать на уровне всего инстанса (но с осторожностью, осознавая все последствия).
Пример того, как выглядит pipeline job, можно посмотреть [здесь](https://gitlab.com/vstconsulting/werf-build-error/-/jobs/2593577772). Там только сборка и рендер чарта, но выглядит очень красиво (по моему скромному мнению). Во время выката всего в кластер, верфь выводит периодически статус подов, сгруппированных по деплойментам, и, если есть, выводит логи этих самых подов. В целом это избавляет от необходимости лезть в [Lens](https://k8slens.dev/), чтобы смотреть, что же там сломалось.
---
Итог
----
Подводя итог, хочу заметить, что я не считаю этот инструмент чем-то "вау!" или "самым лучшим". Думаю, что по моим слегка язвительным высказываниям о некоторых особенностях проекта, можно заметить отсутствие эмоциональной любви к продукту. Однако, в целом проект крут тем, что использует безагентную систему доставки и сборки, и я бы его рекомендовал там, где много сервисов и даже микросервисов, а кластер эфемерная сущность, которая сегодня есть, а завтра нет.
Очень удобно, что можно описать несколько образов в одном конфиге, а потом просто прокинуть их в свой чарт как переменные. Наверное, если заморочиться, то можно прикрутить что-то вроде [этого](https://habr.com/ru/company/nixys/blog/668782/), для деплоя огромного количества сервисов.
Несмотря на раздражающий гитерминизм, можно с помощью некоторого набора переменных окружения клонировать проект и разворачивать его как продукт, что очень удобно. Сборка, хоть и имеет некоторые проблемы с кешированием слоёв, даёт предсказуемые результаты и не требует дополнительных сервисов (по крайней мере если использовать их образ для сборки).
Надеюсь, наш опыт поможет более объективно взглянуть на выбор инструментов доставки приложения в кластер куба, взвешивая все преимущества и недостатки верфи. | https://habr.com/ru/post/673014/ | null | ru | null |
# Вызов метода Javascript без его вызова фактически
Иногда мы бываем просто ленивыми. Особенно, когда доходит дело до написания кода. И хоть круглые скобки в вызове функции не приводят к избыточности, иногда все же они могут утомлять, особенно когда javascript-метод не нуждается в передаваемых ему аргументах. Иногда это просто надоедает.
Как ни странно, все это не тяжело делать в языке Javascript, как и большинство других методов, которые вызывается… toString — вероятно один из немалоизвестных, но также, как и valueOf, который делает более-менее то же самое, но касательно числовых (и некоторых других) типов в языке JavaScript.
Наиболее простой вариант его вызова, включая знак «плюс»:
> `+myFunction;`
что фактичесски обозначает:
> `window.parseFloat(myFunction.valueOf());`
Так, все что нам надо сделать, это заставить метод valueOf запускать на выполение функцию, переданную ему:
> `Function.prototype.valueOf=function(){this.call(this); return 0;};`
… и вдруг знак «плюс» становится всем, что нам нужно для этого вызова.
Особенно в ООП, вы можете иметь очень много подобных вызовов, но можно исправить эти методы таким образом, чтобы они вызывались в рамках самого метода:
> `Function.prototype.fix=function(s){var t=this; return function(){ return t.apply(s,arguments); }; };`
Используя данный метод в конструкторе, можно сделать обертку:
> `var Foo=function(){
>
> this.myMethod=this.myMethod.fix(this);
>
> };`
или немножко автомазировав:
> `var Foo=function(){
>
> for(var i in this)
>
> if(typeof(this[i])=="function")
>
> this[i]=this[i].fix(this);
>
> };`
и наконец, закончим полным примером (после маленького ООП-рефакторинга):
> `1. var StandardClass=function(){};
> 2.
> 3. StandardClass.prototype.initMethods=function(){
> 4. for(var i in this)
> 5. if(typeof(this[i])==”function” && this[i].dontWrap!==true)
> 6. this[i]=this[i].fix(this);
> 7. };
> 8.
> 9. StandardClass.prototype.initMethods.dontWrap=true;
> 10.
> 11. Function.prototype.fix=function(s){
> 12. var t=this;
> 13. return function(){
> 14. return t.apply(s,arguments);
> 15. };
> 16. };
> 17.
> 18. Function.prototype.valueOf=function(){
> 19. this.call(this);
> 20. return 0;
> 21. };
> 22.
> 23. var Foo=function(name){
> 24. this.initMethods();
> 25. this.name=name;
> 26. };
> 27.
> 28. Foo.prototype=new StandardClass;
> 29.
> 30. Foo.prototype.showName=function(){
> 31. alert(this.name);
> 32. };
> 33.
> 34. Foo.prototype.showNameUpperCase=function(){
> 35. alert(this.name.toUpperCase());
> 36. };
> 37.
> 38. var myFoo=new Foo(“Hello World”);
> 39.
> 40. +myFoo.showName;
> 41. +myFoo.showNameUpperCase;
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/90432/ | null | ru | null |
# Yii2-advanced: альтернативное размещение папок для нескольких приложений
Хочу поделиться альтернативным рецептом файловой структуры для нескольких приложений в Yii2-advanced, не прибегая к модулям. Внешние отличия, к которым мы придем, выглядят следующим образом:
### Вступление
Я видел на Хабре статью, как разные окружения превратить в модули и сложить их аккуратно внутри проекта. Мне кажется идея, которую мне показал коллега — намного круче и удобнее!
* Идея такова, что мы не пишем в коде /site/site/index: мы пишем /site/index!
* Мы не мучаемся с настройкой виртуальных хостов, сим-линков и реврайтов: мы все кидаем в один и тот же файл!
* Мы можем иметь на бюджетном хостинге (теоретически) любое количество доменов, оплатив опцию «1 сайт»!
Разве это не круто?!
**PS:** Да, и кстати, к радости начинающих: вы можете решить проблему «как сделать общий upload для front&back».
**PPS:** Я рассчитываю, что вы уже установили и опробовали YII2 Advanced, и понимаете, зачем вам именно этот вариант.
Интересно? Тогда — вперед! Для примера беру последнюю, на текущий момент версию: 2.0.10.
### Переходим к рефакторингу: первые шаги
1. Если вы в предвкушении революции на работающем проекте, срочно жмем в папке своего проекта «tar -cf saveAndProtect.tar ./» Или выражаясь проще: предохраняемся, путем бекапа последней работающей версии. У меня чистая версия всего с одной вьюхой.
2. Как видели на скриншоте выше: нужные нам приложения (applications) складываем в папку **apps** в корне проекта (да, ее нужно создать самому).
3. В корне создаем папку **web** и перекидываем в нее содержимое своего фронт-энда (frontend). В папке backend удаляем папку web: теперь она общая. Лично мы тут храним лишь статику из картинок и шрифтов. Стили и JS так часто меняются, что лучше пользоваться ассетами (assets).
4. Теперь перенастройте свои домены на новую папку **web**, в корне проекта, и приступаем к более сложным манипуляциям.
### Шаг второй: немного доработать напильником (с)
1. Правим первые три инклуда (include) в **index.php**, где подключается autoload, Yii и common/ bootstrap: просто убрать один уровень соответственно. Последний инклуд мы подключить пока не можем, т.к. это уже bootstrap, который относится к конкретному приложению из папки **apps**.
2. Различать приложения, для старта будем банально: $\_SERVER['HTTP\_HOST']. Пишем switch-case и заменяем этим кодом последний инклуд и на этом с index.php мы закончили. Должно получится так:
```
// определяем запрошенный APP
switch ($_SERVER['HTTP_HOST']) {
case 'frontend.dev':
case 'site.ru':
define('YII_APP', 'frontend');
break;
case 'backend.dev':
case 'admin.site.ru':
define('YII_APP', 'backend');
break;
default:
// лично у меня тут 301й редирект на главную
exit("domain not defined");
}
// определяем папку приложения и подключаем его конфиг
define('YII_APP_DIR', Yii::getAlias('@apps') . '/' . YII_APP);
require(YII_APP_DIR . '/config/bootstrap.php');
```
3. Могли обратить внимание, что добавился новый алиас(alias) **@apps**: это как раз наша новая папка. А константа **YII\_APP** — конкретное приложение-папка, что необходимо подключить. Все прозрачно! Выглядит — ну да, соглашусь: может слегка «топористо». Но именно то, что нужно для быстрого старта.
4. В мерже (merge) конфига у нас остались старые пути. В одном случае понижаем инклуд на уровень, во втором — используем нашу новую константу:
```
$config = yii\helpers\ArrayHelper::merge(
require(__DIR__ . '/../common/config/main.php'),
require(__DIR__ . '/../common/config/main-local.php'),
require(YII_APP_DIR . '/config/main.php'),
require(YII_APP_DIR . '/config/main-local.php')
);
```
5. Теперь пора определить алиас **@apps** и поправить наши имеющиеся. Это правится в третьем подключаемом файле: **common\config\bootstrap.php**
Добавляем алиас: **Yii::setAlias('@apps', dirname(dirname(\_\_DIR\_\_)). '/apps');**
Наши приложения правим по принципу: **Yii::setAlias('@console', Yii::getAlias('@apps'). '/console');**.
6. И последнее: осталось настроить нашу **console**. Вы можете это сделать сами, из спортивного интереса. А можете открыть спойлер и получить готовое решение:
**Настройка консольной части Yii2****./yii.php**
```
#!/usr/bin/env php
php
defined('YII_DEBUG') or define('YII_DEBUG', true);
defined('YII_ENV') or define('YII_ENV', 'dev');
define('YII_APP', 'console');
require(__DIR__ . '/vendor/autoload.php');
require(__DIR__ . '/vendor/yiisoft/yii2/Yii.php');
require(__DIR__ . '/common/config/bootstrap.php');
require(__DIR__ . '/apps/console/config/bootstrap.php');
$config = yii\helpers\ArrayHelper::merge(
require(__DIR__ . '/common/config/main.php'),
require(__DIR__ . '/common/config/main-local.php'),
require(__DIR__ . '/apps/console/config/main.php'),
require(__DIR__ . '/apps/console/config/main-local.php')
);
$application = new yii\console\Application($config);
$exitCode = $application-run();
exit($exitCode);
```
**apps\console\config\main.php** правим участок с merge
```
$params = array_merge(
require(__DIR__ . '/../../../common/config/params.php'),
require(__DIR__ . '/../../../common/config/params-local.php'),
require(__DIR__ . '/params.php'),
require(__DIR__ . '/params-local.php')
);
```
**Все!**
### Резюме
Довольно простыми манипуляциями для человека немного поработавшего с YII2 мы получили структурированный по приложениям проект, который откликается на любое количество доменов и удобен на бюджетных хостингах, когда у нас есть лишь 1 каталог. Либо манипуляции с каталогами и сим-линками вызывает определенные проблемы.
Рассчитываю, что мой труд оказался вам интересен. В конце лишь добавлю возможные вопросы, которые могут возникнуть в этой непривычной архитектуре.
**В:** У меня, на шаге Х просто белый экран!
**О:** Вы допустили опечатку до инициализации Yii. Временно добавьте в самое начало index.php строку: **ini\_set(«display\_errors»,«1»); ini\_set(«error\_reporting», E\_ALL);**
**В:** Скомпиленные Ассеты могут смешаться?
**О:** Вряд ли. Почти за год работы проекта не отмечено ни одного случая
**В:** Robots и favico не для каждого домена, а смешаны в кучу?
**О:** Всегда можно разрулить реврайтами апача по **RewriteCond %{HTTP\_HOST}**
**В:** А как можно получить ссылку из другого приложения? На примере «модулей», это было бы элементарно.
**О:** Создайте дополнительную компоненту и **Yii::$app->urlManagerFrontend->createUrl(...);** | https://habr.com/ru/post/316966/ | null | ru | null |
# Динамический полиморфизм с использованием std::variant и std::visit
> *Привет, хабровчане. В рамках курса* [*"C++ Developer. Professional"*](https://otus.pw/vYZR/) *подготовили для вас перевод материала.
>
> Также приглашаем на открытый вебинар по теме* [*«Области видимости и невидимости».*](https://otus.pw/6if1/) *Участники вместе с экспертом на полуторачасовом занятии реализуют класс общего назначения и попробуют запустить несколько unit-тестов с использованием googletest.*
>
>
---
Динамический полиморфизм (или полиморфизм времени выполнения) обычно связан с v-таблицами и виртуальными функциями. Однако в этой статье я покажу вам современную технику C++, которая использует `std::variant` и `std::visit`. Этот метод C++17 может предложить вам не только лучшую производительность и семантику значений, но и интересные паттерны проектирования.
**Последнее обновление:** 2 ноября 2020 г. (передача аргументов, бенчмарк времени сборки, исправления).
### Виртуальные функции
Могу поспорить, что во многих случаях, когда вы слышите о динамическом полиморфизме, вам на ум в первую очередь приходят виртуальные функции.
Вы объявляете виртуальную функцию в базовом классе, а затем переопределяете ее в производных классах. Когда вы вызываете такую функцию для ссылки или указателя на базовый класс, компилятор вызовет правильную перегрузку. В большинстве случаев компиляторы реализуют эту технику с помощью виртуальных таблиц (v-таблиц). Каждый класс, имеющий виртуальный метод, содержит дополнительную таблицу, указывающую на адреса функций-членов. Перед каждым вызовом виртуального метода компилятор должен просмотреть v-таблицу и разрешить адрес производной функции.
Канонический пример:
```
class Base {
public:
virtual ~Base() = default;
virtual void PrintName() const {
std::cout << "calling Bases!\n"
}
};
class Derived : public Base {
public:
void PrintName() const override {
std::cout << "calling Derived!\n"
}
};
class ExtraDerived : public Base {
public:
void PrintName() const override {
std::cout << "calling ExtraDerived!\n"
}
};
std::unique_ptr pObject = std::make_unique();
pObject->PrintName();
```
В чем преимущества этой техники? Назовем несколько:
* Синтаксис встроен в язык, поэтому это очень естественный и удобный способ написания кода.
* Если вы хотите добавить новый тип, вы просто пишете новый класс, не нужно менять базовый класс.
* Объектно-ориентированность — позволяет создавать глубокие иерархии.
* Можно хранить разнородные типы в одном контейнере, просто сохраняя указатели на базовый класс.
* Передавать параметры в функции очень просто.
Хочу обратить ваше внимание на «расширяемость». Например, благодаря этому функционалу вы можете реализовать систему плагинов. Вы раскрываете интерфейс через некоторый базовый класс, но вы не знаете окончательное количество плагинов. Они даже могут загружаться динамически. Виртуальная диспетчеризация является важной частью этой системы.
А в чем недостатки?
* Виртуальный метод должен быть разрешен до вызова, поэтому возникают дополнительные накладные расходы на производительность (компиляторы изо всех сил стараются максимально девиртуализировать вызовы, но в большинстве случаев это невозможно).
* Поскольку вам нужен указатель для вызова метода, обычно это также означает динамическую аллокацию, которая может еще больше повысить накладные расходы на производительность.
* Если вы хотите добавить новый виртуальный метод, вам нужно пройти через базовый и производные классы и добавить туда эту новую функцию.
Однако в C++17 (и немного раньше, благодаря библиотекам boost) у нас также есть другой способ реализовать динамический полиморфизм! Давайте посмотрим на него.
### Динамический полиморфизм с помощью std::variant и std::visit
С `std::variant`, доступным с C++17, вы теперь можете использовать безопасные объединения типов и хранить множество разных типов в одном объекте. Вместо указателя на базовый класс хранить все «производные» классы может `std::variant`.
Давайте перепишем наш первый пример с базовым классом `Base`, используя эту новую технику:
Во-первых, классы:
```
class Derived {
public:
void PrintName() const {
std::cout << "calling Derived!\n"
}
};
class ExtraDerived {
public:
void PrintName() const {
std::cout << "calling ExtraDerived!\n"
}
};
```
Как видите, базового класса больше нет! Теперь у нас может быть куча несвязанных типов.
А теперь основная часть:
```
std::variant var;
```
`var` определяет объект, который может быть Derived или ExtraDerived. По умолчанию он инициализируется значением по умолчанию первой альтернативы. Вы можете узнать больше о variant в моей отдельной большой статье: [Все, что вам нужно знать о std::variant из C ++ 17](https://www.bfilipek.com/2018/06/variant.html).
#### Вызов функций
Как нам вызвать `PrintName()` в зависимости от типа, который в данный момент активен внутри var?
Нам нужны две вещи: вызываемый объект и `std::visit`.
```
struct CallPrintName {
void operator()(const Derived& d) { d.PrintName(); }
void operator()(const ExtraDerived& ed) { ed.PrintName(); }
};
std::visit(CallPrintName{}, var);
```
В приведенном выше примере я создал структуру, которая реализует две перегрузки для оператора вызова. Затем `std::visit` принимает вариантный объект и вызывает правильную перегрузку.
Если наши вариантные подтипы имеют общий интерфейс, мы также можем выразить посетителя (visitor) с помощью обобщенной лямбды:
```
auto caller = [](const auto& obj) { obj.PrintName(); }
std::visit(caller, var);
```
#### Передача аргументов
Наши функции «печати» не принимают никаких аргументов… но что, если они вам понадобятся?
С обычными функциями это не сложно, просто напишите:
```
void PrintName(std::string_view intro) const {
std::cout << intro << " calling Derived!\n;
}
```
Но с нашим объектом-функцией это непросто. Основная проблема заключается в том, что `std::visit()` не имеет возможности передавать аргументы в вызываемый объект. Он принимает только объект-функцию и список объектов `std::variant` (или всего один в нашем случае).
Один из способов разрешить это неудобство — создать дополнительные переменные-члены для хранения параметров и вручную передать их в операторы вызова.
```
struct CallPrintName {
void operator()(const Derived& d) { d.PrintName(intro); }
void operator()(const ExtraDerived& ed) { ed.PrintName(intro); }
std::string_view intro;
};
std::visit(CallPrintName{"intro text"}, var);
```
Если ваш посетитель (visitor) является лямбда-выражением, вы можете захватить аргумент и затем передать его функциям-членам:
```
auto caller = [&intro](const auto& obj) { obj.PrintName(intro); }
std::visit(caller, var);
```
Давайте теперь рассмотрим плюсы и минусы такого подхода. Видите ли вы отличия от виртуальной диспетчеризации?
#### Преимущества полиморфизма с std::variant
* Семантика значений, отсутствие динамической аллокации
* Легко добавить новый «метод», вам нужно реализовать новую вызываемую структуру. Нет необходимости изменять реализацию классов
* Нет необходимости в базовом классе, классы могут быть не связанными
* Утиная типизация (Duck typing): хотя виртуальные функции должны иметь одинаковые сигнатуры, это не тот случай, когда вы вызываете функции из посетителя (visitor). У них может быть разное количество аргументов, типов возвращаемых значений и т. д. Это дает нам дополнительную гибкость.
#### Недостатки полиморфизма с std::variant полиморфизма
* Вам необходимо знать все типы заранее, во время компиляции. Это исключает возможность создания таких конструкций, как система плагинов. Также сложно добавлять новые типы, так как это подразумевает изменение типа variant и всех посетителей.
* Это может привести к избыточному потреблению памяти, так как `std::variant` имеет размер равный максимальному размеру поддерживаемых типов. Итак, если один тип занимает 10 байт, а другой — 100 байт, тогда каждый вариант будет составлять не менее 100 байт. Таким образом, вы потенциально потеряете 90 байт.
* Утиная типизация: это как преимущество, так и недостаток, в зависимости от правил, необходимых для обеспечения соблюдения функций и типов.
* Для каждой операции требуется писать отдельного посетителя. Иногда их организация может быть проблемой.
* Передача параметров не так проста, как с обычными функциями, поскольку `std::visit` не имеет для этого интерфейса.
### Пример
Ранее я показал вам базовый искусственный пример, но давайте попробуем что-нибудь более полезное и реалистичное.
Представьте себе набор классов, которые представляют метку (Label) в пользовательском интерфейсе. У нас может быть `SimpleLabel` с каким-нибудь текстом, затем `DateLabel`, который умеет красиво отображать значение даты, а затем `IconLabel`, который отображает значок рядом с текстом.
Для каждой метки нам нужен метод, который сгенерирует HTML-синтаксис, чтобы ее можно было отобразить позже:
```
class ILabel {
public:
virtual ~ILabel() = default;
[[nodiscard]] virtual std::string BuildHTML() const = 0;
};
class SimpleLabel : public ILabel {
public:
SimpleLabel(std::string str) : _str(std::move(str)) { }
[[nodiscard]] std::string BuildHTML() const override {
return "" + \_str + "
";
}
private:
std::string _str;
};
class DateLabel : public ILabel {
public:
DateLabel(std::string dateStr) : _str(std::move(dateStr)) { }
[[nodiscard]] std::string BuildHTML() const override {
return "Date: " + \_str + "
";
}
private:
std::string _str;
};
class IconLabel : public ILabel {
public:
IconLabel(std::string str, std::string iconSrc) :
_str(std::move(str)), _iconSrc(std::move(iconSrc)) { }
[[nodiscard]] std::string BuildHTML() const override {
return "![](\"")" + \_str + "
";
}
private:
std::string _str;
std::string _iconSrc;
};
```
В приведенном выше примере показан интерфейс `ILabel`, а затем несколько производных классов, которые реализуют функцию-член BuildHTML.
А здесь мы видим вариант использования, где у нас есть вектор с указателями на ILabel и мы вызываем виртуальную функцию для генерации окончательного HTML-вывода:
```
std::vector> vecLabels;
vecLabels.emplace\_back(std::make\_unique("Hello World"));
vecLabels.emplace\_back(std::make\_unique("10th August 2020"));
vecLabels.emplace\_back(std::make\_unique("Error", "error.png"));
std::string finalHTML;
for (auto &label : vecLabels)
finalHTML += label->BuildHTML() + '\n';
std::cout << finalHTML;
```
Ничего сверхъестественного, вызовы BuildHTML являются виртуальными, поэтому в конце мы получим ожидаемый результат:
```
Hello World
Date: 10th August 2020
Error
```
А вот вариант с `std::variant`:
```
struct VSimpleLabel {
std::string _str;
};
struct VDateLabel {
std::string _str;
};
struct VIconLabel {
std::string _str;
std::string _iconSrc;
};
struct HTMLLabelBuilder {
[[nodiscard]] std::string operator()(const VSimpleLabel& label) {
return "" + label.\_str + "
";
}
[[nodiscard]] std::string operator()(const VDateLabel& label) {
return "Date: " + label.\_str + "
";
}
[[nodiscard]] std::string operator()(const VIconLabel& label) {
return "![](\"")" + label.\_str + "
";
}
};
```
В предыдущем фрагменте кода я упростил интерфейс для классов `Label`. Теперь они хранят только данные, а HTML-операции перемещены в `HTMLLabelBuilder`.
И вариант использования:
```
using LabelVariant = std::variant;
std::vector vecLabels;
vecLabels.emplace\_back(VSimpleLabel { "Hello World"});
vecLabels.emplace\_back(VDateLabel { "10th August 2020"});
vecLabels.emplace\_back(VIconLabel { "Error", "error.png"});
std::string finalHTML;
for (auto &label : vecLabels)
finalHTML += std::visit(HTMLLabelBuilder{}, label) + '\n';
std::cout << finalHTML;
```
Пример доступен на сайте [Coliru.](http://coliru.stacked-crooked.com/a/e20e60c0e96771e6)
#### Альтернативы
`HTMLLabelBuilder` — это только один вариант, который мы можем использовать. В качестве альтернативы мы также можем написать обобщенную лямбду, которая вызывает функцию-член из производных классов:
```
struct VSimpleLabel {
[[nodiscard]] std::string BuildHTML() const {
return "Date: " + \_str + "
";
}
std::string _str;
};
struct VDateLabel {
[[nodiscard]] std::string BuildHTML() const {
return "Date: " + \_str + "
";
}
std::string _str;
};
struct VIconLabel {
[[nodiscard]] std::string BuildHTML() const {
return "![](\"")" + \_str + "
";
}
std::string _str;
std::string _iconSrc;
};
auto callBuildHTML = [](auto& label) { return label.BuildHTML(); };
for (auto &label : vecLabels)
finalHTML += std::visit(callBuildHTML, label) + '\n'
```
На этот раз мы используем обобщенную лямбду, преимущество которой заключается в том, что вызов находится в одном месте.
#### Добавление концептов (Concepts) в обобщенные лямбды
В разделе посвященному недостаткам `std::variant/std::visit` я упомянул, что утиная типизация иногда может быть проблемой. Если хотите, вы можете применить интерфейс к типам и функциям. Например, с помощью C++20 мы можем написать концепт, который позволяет нам вызывать обобщенную лямбду только для типов, которые предоставляют требуемый интерфейс.
(Спасибо Mariusz J за эту идею)
```
template
concept ILabel = requires(const T v)
{
{v.buildHtml()} -> std::convertible\_to;
};
```
Этому концепту удовлетворяют все типы, у которых есть константная функция-член `buildHtml()`, которая возвращает типы, конвертируемые в `std::string`.
Теперь мы можем использовать его для принудительного применения обобщенной лямбды (благодаря краткому синтаксису `constrained auto`):
```
auto callBuildHTML = [](ILabel auto& label) -> std::string { return label.buildHtml(); };
for (auto &label : vecLabels)
finalHTML += std::visit(callBuildHTML, label) + '\n';
```
Смотрите пример на [@Wandbox.](https://wandbox.org/permlink/YXLR8D0i12mi0dlF)
#### Дополнительные примеры
У меня также есть еще одна статья, где я экспериментировал со своим старым проектом и заменил кучу производных классов на подход `std::variant`.
Взгляните при случае:
[Замена unique\_ptr на std::variant из C++17 - эксперимент](https://www.bfilipek.com/2020/09/replacing-into-variant.html#problem-passing-arguments) на практике
### Производительность
Еще один важный вопрос, которым вы, возможно, в первую очередь зададитесь, касается производительности этой новой техники.
Является ли `std::visit` быстрее, чем виртуальная диспетчеризация?
Давайте выясним.
Когда я создал простой бенчмарк для моего примера с `ILabel`, я не заметил никакой разницы.
Вы можете посмотреть бенчмарк здесь [@QuickBench.](http://quick-bench.com/nYqkvPMs9qVzlxDfxLwH38WWkMg)
Я полагаю, что обработка строк имеет достаточно высокую стоимость по сравнению с выполнением всего остального кода; кроме того, в данном варианте не так много типов, что делает фактический вызов очень похожим.
Но у меня есть другой бенчмарк, в котором используется система частиц.
```
using ABC = std::variant;
std::vector particles(PARTICLE\_COUNT);
for (std::size\_t i = 0; auto& p : particles) {
switch (i%3) {
case 0: p = AParticle(); break;
case 1: p = BParticle(); break;
case 2: p = CParticle(); break;
}
++i;
}
auto CallGenerate = [](auto& p) { p.generate(); };
for (auto \_ : state) {
for (auto& p : particles)
std::visit(CallGenerate, p);
}
```
Класс `Particle` (и его версии AParticle, BParticle и т. д.) использует 72 байта данных, и у них есть метод `Generate()`, который является «виртуальным».
И на этот раз я получил 10% за улучшение для версии с `std::visit`!
Так почему код может быть быстрее? Я думаю, здесь может быть несколько причин:
* Версия с variant не использует динамическое распределение памяти, поэтому все частицы находятся в одном блоке памяти. ЦП могут использовать это для повышения производительности.
* В зависимости от количества типов может случиться так, что среда выполнения, если она используется для проверки текущего активного типа в варианте, намного быстрее и более предсказуема для компилятора, чем поиск указателя в v-таблице.
Вот еще один бенчмакр, который показывает, что версия с variant на 20% медленнее, чем вектор с всего одним типом: `td::vector particles(PARTICLE_COUNT);`. Смотрите в [QuickBench](http://quick-bench.com/op4OzjWFZ7OyY691aHzbREDmjWk)
#### Другие результаты производительности
Мой тест был относительно простым и не мог безапелляционно утверждать, что `std::visit` всегда быстрее. Но для лучшего понимания вы можете взглянуть на [эту](https://www.youtube.com/watch?v=gKbORJtnVu8) отличную презентацию от Матеуша Пуша, который реализовал целую машину состояний TCPIP и добился гораздо большей производительности с помощью `std::visit`. Время выполнения также было более стабильным и предсказуемым, чем виртуальные вызовы.
[*CppCon 2018: Матеуш Пуш «Эффективная замена динамического полиморфизма на std::variant»*](https://www.youtube.com/watch?v=gKbORJtnVu8)
#### Раздувание кода и время сборки
Есть также опасения по поводу раздувания кода, которое может возникнуть из-за `std::visit`. Поскольку эта функция является чистой библиотечной реализацией без дополнительной поддержки со стороны языка, мы можем смело ожидать, что она добавит дополнительные байты в наш исполняемый файл.
Если вас заботит эта проблема, вам следует взглянуть на следующие ссылки:
* [Явление вариантов V2 – Майкл Парк](https://mpark.github.io/programming/2019/01/22/variant-visitation-v2/)
* Раздувание кода из-за [std::variant? Похоже это вина std::visit fault : r/cpp](https://www.reddit.com/r/cpp/comments/9khij8/stdvariant_code_bloat_looks_like_its_stdvisit/)
* Раздувание кода из-за [std::variant? Похоже это вина std::visit fault (Part 2) : r/cpp](https://www.reddit.com/r/cpp/comments/9mxvw5/stdvariant_code_bloat_looks_like_its_stdvisit/)
Также стоит помнить, что библиотечное решение работает со всем многообразием `std::variant`, даже с множеством переданных вариантов, поэтому вы платите за эту «общую» поддержку . Если вас не устраивает производительность библиотеки и у вас ограниченный набор вариантов использования, вы можете откатить свою реализацию и посмотреть, улучшит ли это ваш код.
#### Производительность сборки при использовании std::visit и std::variant
Я показал вам некоторые цифры с производительностью во время выполнения, но у нас также есть инструмент, который позволяет нам проверить скорость компиляции этих двух подходов.
Ищите их здесь [@BuildBench](https://build-bench.com/b/gW_QHAF4nGnHVmMszzMj_Ja4Oig)
И результаты: GCC 10.1, C++17, O2:
Так что это почти то же самое! Что касается предварительно обработанных строк, оно еще меньше для вариантной версии — 39k против 44k. Что касается ассемблера, то это 2790 LOC для вариантной версии и 1945 LOC для виртуальной.
Извините за небольшое отступление от темы.
Я приготовил для вас небольшой бонус, если вам интересен современный C++, [приглашаю вас сюда.](https://us8.list-manage.com/subscribe?u=e93417593cbf4da3dba03d672&id=b7dee14c64)
### Резюме
В статье мы рассмотрели новую технику реализации динамического полиморфизма. С помощью `std::variant` мы можем описать объект, который может иметь много разных типов — например, типобезопасное объединение с семантикой значений. А затем с помощью `std::visit` мы можем вызвать объект посетителя, который вызовет операцию на основе активного типа в варианте, что позволяет иметь разнородные коллекции и вызывать функции аналогично виртуальным функциям.
Но разве полиморфизм на основе `std::variant` лучше обычного «виртуального» полиморфизма? Нет однозначного ответа, поскольку у обоих техник есть свои сильные и слабые стороны. Например, с `std::variant` вам нужно заранее знать все возможные типы, что может быть невозможно, когда вы пишете общую библиотеку или какую-то систему плагинов. Но, с другой стороны, `std::variant` предлагает семантику значений, которая может улучшить производительность системы и уменьшить необходимость использования динамической аллокации.
Я также получил отличное резюме от людей, которые использовали такой код в продакшене. Вот один замечательный комментарий от Бориса Дж. (Смотрите [его профиль на Github](https://github.com/borysjelenski)):
> Некоторое время назад я использовал std::variant/std::visit для реализации обработки различных типов команд во встроенной системе. В вариантах хорошо то, что полиморфизм работает без косвенного обращения - вам не нужен указатель или ссылка, как в случае с виртуальными функциями. Это помогает в тех случаях, когда объект необходимо создать в функции, а затем вернуть из нее. Я часто пишу код вообще не использующий кучу/динамическую память, поэтому я не могу просто создать объект динамически внутри функции, а затем передать право владения вверх. С variant я могу просто вернуть его по значению (при условии, что оно достаточно мало) без потери полиморфизма.
>
> С другой стороны, используя их в качестве техники ветвления на основе типов, я обнаружил, что когда вы перемещаете их (в общем смысле, я не имею в виду move семантику), и вам нужно обрабатывать их на разных этапах, вы в конечном итоге пишете новый тип посетителя каждый раз, когда вам нужно что-то сделать с вариантом. Что еще хуже, иногда способ обработки разных типов в варианте отличается лишь незначительно. В результате вы получаете несколько посетителей, некоторые из которых являются промежуточными и неестественными, каждый из которых имеет несколько отдельных функций-членов для каждого типа варианта. В конце концов, вы снова скатываетесь в старый добрый callback hell. Конечно, вы можете использовать конструкцию перегрузки лямбды, но это не сильно меняет дело.
>
>
А как насчет вас:
* Использовали ли вы `std::variant` и `std::visit`?
* Вы использовали их в продакшене или просто в своем небольшом проекте?
Поделитесь своим опытом в комментариях ниже.
---
> ***Узнать подробнее о курсе*** [***"C++ Developer. Professional"***](https://otus.pw/vYZR/)***.***
>
> ***Смотреть открытый вебинар по теме*** [***«Области видимости и невидимости».***](https://otus.pw/6if1/)
>
> | https://habr.com/ru/post/546158/ | null | ru | null |
# Haskell. Монады. Монадные трансформеры. Игра в типы
*Еще одно введение в монады для совсем совсем начинающих.*
Лучший способ понять монады — это начать их использовать. Нужно забить на монадические законы, теорию категорий, и просто начать писать код.
Написание кода на Haskell похоже на игру, в которой вы должны преобразовать объекты к нужному типу. Поэтому вам в первую очередь нужно понять правила этой игры. При написании кода вы должны четко понимать, какой тип имеет каждый конкретный кусок кода.
С обычными функциями все понятно. Если имеется функция типа «a->b», то подставив в неё аргумент типа «a», вы получите результат типа «b».
С монадами все не так очевидно. Под катом подробно расписано, как работать с do-конструкцией, как последовательно преобразуются типы, и зачем нужны монадные трансформеры.
###### **1. Do-конструкция**
Начнем с простого примера.
```
main = do
putStr "Enter your name\n"
name <- getLine
putStr $ "Hello " ++ name
```
Каждая do-конструкция имеет тип «m a», где «m» — это монада. В нашем случае это монада IO.
Каждая строчка в do-конструкции так же имеет тип «m a». Значение «a» в каждой строчке может быть разным.
Символ "<-", как бы, преобразует тип «IO String» в тип «String».
Если нам необходимо произвести в монаде некоторые вычисления, не связанные с данной монадой, то мы можем воспользоваться функцией *return*.
```
return :: a -> m a
main = do
text <- getLine
doubleText <- return $ text ++ text
putStr doubleText
```
Функция *return* заворачивает любой тип «a» в монадический тип «m a».
В данном примере, с помощью *return* выражение типа «String» преобразуется к типу «IO String», которое потом обратно разворачивается в «String». Как вариант, внутри do-конструкции можно использовать ключевое слово *let*.
```
main = do
text <- getLine
let doubleText = text ++ text
putStr doubleText
```
Вся do-конструкция принимает тип последней строчки.
Допустим, мы хотим прочитать содержимое файла. Для этого у нас имеется функция *readFile*.
```
readFile :: FilePath -> IO String
```
Как видим, функция возвращает «IO String». Но нам нужно содержимое файла в виде «String». Это значит, что мы должны выполнить нашу функцию внутри do-конструкции.
```
printFileContent = do
fileContent <- readFile "someFile.txt"
putStr fileContent
```
Здесь переменная *fileContent* имеет тип «String», и мы можем работать с ней, как с обычной строкой (например, вывести на экран). Обратите внимание, что получившаяся функция *printFileContent* имеет тип «IO ()»
```
printFileContent :: IO ()
```
###### **2. Монады и монадные трансформеры**
Я приведу следующую простую аналогию. Представьте, что монада — это пространство, внутри которого можно производить некоторые, специфичные для данного пространства, действия.
Например, в монаде «IO» можно выводить текст в консоль.
```
main = do
print "Hello"
```
В монаде «State» есть некоторое внешнее состояние, которое мы можем модифицировать.
```
main = do
let r = runState (do
modify (+1)
modify (*2)
modify (+3)
) 5
print r
-- OUTPUT:
-- ((), 15)
```
В этом примере мы взяли число 5, прибавили к нему 1, умножили результат на 2, затем прибавили еще 3. В результате получили число 15.
С помощью функции *runState*
```
runState :: State s a -> s -> (a, s)
```
мы «запускаем» нашу монаду.
На монаду можно посмотреть с двух сторон: изнутри и снаружи. Изнутри мы можем выполнить некоторые, специфичные для данной монады, действия. А снаружи — мы можем её «запустить», «распечатать», преобразовать к некоторому немонадическому типу.
Это позволяет нам вкладывать одну do-конструкцию в другую, как в приведенном выше примере. Монада *IO* — это единственная монада, на которую нельзя посмотреть «снаружи». Все в конечном итоге оказывается вложенным в *IO*. Монада *IO* — это наш фундамент.
Приведенный выше пример имеет определенные ограничения. Внутри монады *State* мы не можем выполнять действия, доступные в *IO*.
Мы оказались «подвешенными в воздухе», потеряли связь с землей.
Для решения этой проблемы существуют **монадные трансформеры**.
```
main = do
r <- runStateT (do
modify (+1)
modify (*2)
s <- get
lift $ print s
modify (+3)
) 5
print r
-- OUTPUT:
-- 12
-- ((), 15)
```
Данная программа делает то же самое, что и предыдущая. Мы заменили *State* на *StateT* и добавили две строчки:
```
s <- get
lift $ print s
```
с помощью которых выводим промежуточный результат в консоль. Обратите внимание, операция ввода/вывода выполняется внутри «вложенной» монады StateT.
Здесь *runStateT* запускает монаду *StateT*, а функция *lift* «поднимает» операцию, доступную в *IO*, до монады *StateT*.
```
runStateT :: StateT s m a -> s -> m (a, s)
lift :: IO a -> StateT s IO a
```
Изучите внимательно, как последовательно преобразуется тип в данном примере.
Операция «print s» имеет тип «IO ()». С помощью *lift* мы «поднимаем» его до типа «StateT Int IO ()». Внутренняя do-конструкция теперь имеет тип «StateT Int IO ()». Мы «запускаем» её и получаем тип «Int -> IO ((), Int)». Затем мы подставляем значение «5» и получаем тип «IO ((), Int)».
Поскольку, мы получили тип «IO», то мы можем использовать его во внешней do-конструкции. Стрелочка "<-" снимает монадический тип и возвращает "((), Int)". В консоль выводится результат "((), 15)".
Внутри *StateT* мы можем менять внешнее состояние и выполнять операции ввода/вывода. Т.е. монада *StateT* не «болтается в воздухе», как *State*, а осталась связанной с внешней монадой *IO*.
Таким образом, в программе может быть куча монад, вложенных друг в друга. Некоторые из этих монад будут сцеплены друг с другом, некоторые — нет.
Надеюсь, моя аналогия помогла Вам взглянуть на вещи с новой точки зрения, и Вы сможете в будущем стать настоящим повелителем монад.
 | https://habr.com/ru/post/315022/ | null | ru | null |
# Conditional indexing. Оптимизируем процесс полнотекстового поиска
В этой статье я хочу поговорить про интеграцию Apache Lucene и Hibernate Search. Если быть более точным, то про один из механизмов Hibernate Search, который может здорово увеличить производительность на проекте с полнотекстовым поиском.
Ни для кого, кто работал с перечисленными выше технологиями, не секрет, что для полнотекстового поиска необходима индексация. Иначе говоря, при добавлении и изменении записей в БД необходимо добавлять/изменять индексы, по которым, собственно, и будет осуществляться полнотекстовый поиск. За данный процесс и отвечает Apache Lucene. А вот как мы уведомляем Люцену, что данную сущность необходимо индексировать:
```
@Entity
@Indexed
public class SomeEntity {
@Id
@GeneratedValue
private Integer id;
@Field
private String indexedField;
private String unindexedField;
//getters and setters
}
```
В приведенном выше классе аннотация [Indexed](https://habrahabr.ru/users/indexed/) говорит о том, что данная сущность индексируется Люценой. Аннотация `@Field` указывает, какие именно поля будут индексироваться. Т.к. аннотация `@Field` надвешена только над полем indexedField, это значит, что мы сможем осуществлять полнотекстовый поиск только по этому полю.
**Примечание.** *Для нормального функционирования Люцены необходимы и другие настройки кроме данных аннотаций. Но так как статья посвящена не настройке Люцены в целом, а лишь оптимизации процесса индексирования, то эти подробности мы опустим.*
Теперь давайте рассмотрим пример индексации некоторой сущности. Предположим, что у нас есть сайт объявлений. А вот и наша сущность:
```
@Entity
public class Ad {
@Id
@GeneratedValue
private Integer id;
private String text;
private AdStatus status;
//getters and setters
}
```
Мы хотим предоставить нашим пользователям возможность полнотекстового поиска по всем объявлениям сайта. Для этого добавляем соответствующие аннотации:
```
@Entity
@Indexed
public class Ad {
@Id
@GeneratedValue
private Integer id;
@Field
private String text;
private AdStatus status;
//getters and setters
}
```
Теперь самое время упомянуть, что у объявления может быть один из следующих статусов: DRAFT, ACTIVE, ARCHIVE. После недолгого раздумья мы приходим к решению, что пользователям в результатах поиска необходимо отображать только объявления в статусе ACTIVE. Рассмотрим два варианта решения данной проблемы. Первый — в лоб. Добавляем аннотацию @Field над полем status. И каждый раз при поиске добавляем predicate, который и будет указывать, каким должен быть этот статус. Минусы данного решения: ощутимое падение производительности при большом количестве объявлений в статусе ARCHIVE и DRAFT, излишняя индексация сущностей, по которым уже не будет проводиться поиск.
Тут же в голову приходит другое решение — не индексировать/удалять существующие индексы для объявлений во всех статусах кроме ACTIVE. В этом нам и поможет такой механизм, как interceptors. Сначала поставим задачу. Мы хотим, чтобы при изменении сущности индексация производилась в зависимости от нового статуса объявления. Теперь приступаем к реализации. Создаем класс AdIndexInterceptor, который реализует интерфейс EntityIndexingInterceptor:
```
public class AdIndexInterceptor implements EntityIndexingInterceptor {
@Override
public IndexingOverride onAdd(Ad entity) {
if (entity.getStatus() == AdStatus.ACTIVE) {
return IndexingOverride.APPLY\_DEFAULT;
}
return IndexingOverride.SKIP;
}
@Override
public IndexingOverride onUpdate(Ad entity) {
if (entity.getStatus() == AdStatus.ACTIVE) {
return IndexingOverride.UPDATE;
}
return IndexingOverride.REMOVE;
}
@Override
public IndexingOverride onDelete(Ad entity) {
return IndexingOverride.APPLY\_DEFAULT;
}
@Override
public IndexingOverride onCollectionUpdate(Ad entity) {
return onUpdate(entity);
}
}
```
Как видно выше, в классе должно быть реализовано 4 метода, которые будут вызываться при добавлении записи, редактировании записи, удалении и обновлении коллекции записей соответственно. Каждый из этих методов должен вернуть одно из значений IndexingOverride, который в свою очередь является enum. Всего имеется четыре значения данного enum. Распишу, что происходит при возврате каждого из них:
* **APPLY\_DEFAULT** — процесс индексации продолжается так, как бы он проходил при отсутствии interceptor’a.
* **SKIP** — индексация не происходит.
* **UPDATE** — обновляется существующий индекс.
* **REMOVE** — удаляется существующий индекс, новый не создается.
Теперь вернемся к классу сущности. Для того, чтобы Люцена знала, что перед индексацией необходимо вызвать соответствующие методы interceptor’a, добавляем в аннотацию [Indexed](https://habrahabr.ru/users/indexed/) над сущностью атрибут interceptor:
```
@Entity
@Indexed(interceptor = AdIndexingInterceptor.class)
public class Ad {
@Id
@GeneratedValue
private Integer id;
@Field
private String text;
private AdStatus status;
//getters and setters
}
```
Осталось только корректно задокументировать использование данного interceptor’a, чтобы поведение Люцены было ожидаемым и для ваших коллег по команде.
**P.S.** В официальной документации разработчики указывают, что данная фича является экспериментальной и ее функционирование может измениться в зависимости от обратной связи с пользователями.
[Ссылка](http://docs.jboss.org/hibernate/search/4.1/reference/en-US/html/search-mapping.html#search-mapping-indexinginterceptor) на официальную документацию. | https://habr.com/ru/post/247897/ | null | ru | null |
# Измерение тока в домашней сети
Существует целый класс устройств под названием Ethernet Relay, которые позволяют удаленно управлять подключенной нагрузкой через сеть. Большинство из них достаточно дорогие – ближе к 100 долл., и заведомо уступают по цене и по гибкости настройки связке, скажем, Raspberry Pi + [PiFace](http://www.piface.org.uk/products/piface_digital/). А что если задача не только включать-выключать нагрузку, но и измерять протекающий ток? Для этого требуется собственно датчик (на шунте или эффекте Холла) и АЦП (Raspberry Pi не содержит встроенного АЦП). В качестве датчика можно взять недорогой ACS712, а в качестве АЦП, например, [ADC-Pi](http://www.abelectronics.co.uk/products/3/Raspberry-Pi/17/ADC-Pi-V2---Raspberry-Pi-Analogue-to-Digital-converter).
ADC-Pi мне не понравился по двум причинам:
* при той частоте измерений, которая требуется для определения силы переменного тока в сети, этот АЦП дает очень большую погрешность (скорее всего я до конца не разобрался с регистрами)
* используя этот АЦП в связке с Raspberry Pi под Linux сложно обеспечить необходимую стабильность периода измерений. Устанавливать и настраивать RTOS Linux только для этой задачи мне показалось слишком сложным предприятием, тем более что есть более простое и проверенное решение: [Arduino](http://www.arduino.cc/)
У всех Arduino уже есть АЦП (8-битный, но этого вполне достаточно), скетчи для Arduino исполняются с необходимой стабильностью, для связи с Raspberry Pi есть различные варианты, самый простой из которых – USB кабель. Ну и конечно, привлекательная цена.
Связка, которую я использовал, приведена на картинке.
Измерение силы тока представляется несложной задачей, если бы не одно «но»: физические датчики «шумят». На рисунке приведен пример фактических и расчетных показателей тока для моей схемы при 512 последовательных измерениях.
Таким образом, задача измерения переменного тока заключается в том, чтобы вычислить амплитуду синусоиды по набору фактических измерений, содержащих значительную долю ошибок.
##### Попытка номер раз
Формула переменного тока (кто забыл – см. [wiki](http://ru.wikipedia.org/wiki/Переменный_ток))
i=Im sin(ωt+ψ)
где:
Im – максимальное значение тока
ω – угловая частота
t – время (порядковый номер) изменения
ψ – начальная фаза тока
Можно попытаться найти необходимые параметры, используя аналитические инструменты. И тут нас ждет приятный сюрприз: осенью прошлого (2013) года компания Wolfram выпустила версию своего замечательного пакета [Mathematica для Raspberry Pi](http://www.wolfram.com/raspberry-pi/). Бесплатно (для домашнего использования). И мы можем применить его для анализа данных, считанных с датчика.
Пример вызова пакета расчета в Raspberry Pi:
`pi@raspi ~ $ wolfram -script calc_current.wl datafile=/tmp/data.csv`
Сам скрипт calc\_current.wl ниже с комментариями:
Прочитать данные из файла, переданного в качестве параметра. Файл содержит строки вида <номер измерения>,<значение>.
`data=Import[$CommandLine[[4]]]`
Когда данные прочитаны, можно проделать анализ Фурье (Fast Fourier Transform) для того чтобы определить, приблизительно, количество циклов синусоиды на имеющейся выборке. Зависимость силы тока от времени нелинейна, и приблизительная угловая скорость, рассчитанная по FFT и переданная в качестве начального значения, резко увеличит шансы подобрать правильные параметры синусоиды.
`fourier=Take[Abs[Fourier[data[[All,2]]]],{2,256}]`
Если максимальное значение FFT не сильно отличается от среднего по выборке, можно сделать вывод, что выраженной синусоиды нет, все показатели представляют собой «шум», а реальная сила тока равна нулю.
`topcycle=Ordering[fourier,-1]`
`avg=Mean[fourier]`
`top=fourier[[topcycle[[1]]]]`
`If[top < 10 * avg, Print["No AC"]; Exit[]]`
Если выраженная синусоида найдена, можно попытаться подобрать параметры функции, используя наиболее выраженный цикл для расчета начального значения угловой скорости.
`nlm=NonlinearModelFit[data, a Sin[b x + c]+d, {a,{b, 2 Pi * topcycle[[1]] / 512}, c, d},x]`
Зная физические характеристики АЦП (размерность 1024, базовое напряжение 5V) и датчика (в моей версии 0.185V / A), можно вычислить эффективную силу тока:
`imax=Abs[nlm["BestFitParameters"][[1]][[2]]] / (1024 / 5 * 0.185)`
`Print["Imax=", imax]`
`iefc=imax / Sqrt[2]`
`Print["Iefc=", iefc]`
`Print["Power=", iefc * 230]`
Предложенный метод работает в большинстве случаев. Количество измерений, когда NonlinearModelFit не смогла верно подобрать параметры синусоиды, составило около 5 процентов. Однако каждое измерение требует много времени – у меня в среднем 5 секунд – для запуска приложения wolfram. Поэтому…
##### Попытка номер два
Поскольку частота переменного тока в сети стабильна и составляет (в России) 50 Гц, угловую скорость можно вычислить заранее и вместо нелинейной регрессии получить регрессию линейную. В самом деле,
или
Дифференцируя по X и Y, получаем систему линейных уравнений:
Решая систему по Крамеру, получим значения коэффициентов:
Тогда по теореме Пифагора максимальное значение тока составит:
Arduino-скетч, который реализует данный алгоритм, можно найти на [Github-е](https://github.com/babinvn/homegrid/blob/master/homegrid.ino). Метод обеспечивает хорошую точность измерений: для схемы на рисунке измеренное значение тока составляло стабильно 0.13A, что соответствует потреблению 29.9 Вт при напряжении 230V. Номинал лампочки, которая служила нагрузкой, 30 Вт.
Кстати, для Arduino также есть шилды с реле и весь функционал управления и мониторинга нагрузки можно реализовать на этой платформе. Raspberry Pi в таком случае будет использоваться только для организации удобного пользовательского интерфейса, например, через веб-сервер и как шедулер. | https://habr.com/ru/post/212459/ | null | ru | null |
# Разработка на Django под Windows с помощью Docker-machine
В этой статье я расскажу как я решил проблему настройки окружения для разработки на Django под Windows.
Используется следующая связка:
1) Docker-machine
2) PyCharm
В Docker-machine:
1) PostgreSQL
2) Data container для PostgreSQL
3) Redis
4) И собственно само приложение на Django.
Сперва нам нужно установить Docker-machine в систему. Для этого скачиваем с официального сайта [docs.docker.com/engine/installation/windows](https://docs.docker.com/engine/installation/windows/). Так же нам понадобится VirtulaBox.
После установки в системе появится Docker Quickstart Terminal. Нужно его запустить и он запустит docker-machine, с которой в дальнейшем и будет проходить всё взаимодействие.
После того как docker-machine будет запущена, через этот терминал мы сможем выполнять docker команды.
Для того, чтобы запустить PostgreSQL и Redis, и для дальнейшего автоматического старта этих контейнеров при запуске docker-machine, создадим файл docker-compose.yml:
```
postgres:
restart: always
image: postgres:latest
volumes_from:
- data
ports:
- "5432:5432"
data:
restart: always
image: postgres:latest
volumes:
- /var/lib/postgresql
command: "true"
redis:
restart: always
image: redis:latest
ports:
- "6379:6379"
```
Через терминал нужно перейти в директорию с этим файлом и выполнить команду **docker-compose up -d**.
После того, как контейнеры запустятся их можно проверить командой **docker ps**. Эта команда должна показать примерно следующий результат:
Сейчас с компьютера можно например с помощью pgadmin подключиться к PostgreSQL по адресу: 192.168.99.100:5432.
Само приложение Django мы будем запускать при помощи PyCharm. Но для начала в корне созданного проекта создаем файл: Dockerfile с содержимым:
```
FROM django:onbuild
```
Так же в корне проекта должен лежать файл requirements.txt, если конечно используются какие-либо внешние зависимости.
Пример файла requirements.txt:
```
Django==1.9.4
psycopg2==2.6.1
gunicorn==19.4.5
redis==2.10.5
django-celery==3.1.17
```
В терминале выполняем команду **docker build -t container\_name path\_to\_docker\_file** .
Первый запуск займёт достаточно продолжительное время, так как будет скачан базовый образ и установлены все зависимости из файла requirements.txt.
После того, как образ с приложением будет создан, нужно проект в PyCharm и настроить удалённый интерпретатор. Для настройки нужно зайти в settings -> Project: project\_name -> Project interpreter. В строке выбора интерпретатора выбрать пункт *add remote*.
Далее нужно подтвердить все изменения, если потребуется перезапустить PyCharm, если IDE не будет видеть пакетов.
И можно запускать проект. По умолчанию он будет запущен по адресу: [192.168.99.100](http://192.168.99.100):8000
При необходимости можно запускать удаленный manage.py из PyCharm, либо заходить, через docker в контейнер и выполнять нужные команды оттуда. | https://habr.com/ru/post/282099/ | null | ru | null |
# Android: Вращаем на все четыре стороны AndEngine
Однажды мне пришлось решать задачу — запускать четыре разные игры написанные на andengine в зависимости от ориентации экрана. Обычные положения — landscape и portrait вопросов не вызывали. Вопросы возникли для остальных положений — противоположных для указанных. Четыре варианта переворота устройства. Пришлось обратиться к работе с сенсорами. Указанный ниже подход применим не только к AndEngine, но и к обычным Activity.Для начала создал класс работы с сенсорами в котором вычислялось положение устройства в пространстве:
```
public class SensorRotation {
private SensorManager sensorManager;
private long lastUpdateTime;
private int orientation = 1;
private SensorEventListener sensorListener;
private Activity activity;
private boolean rightPosition = false;
public SensorRotation instance;
/**
* Инициализация сенсора
*
* @param context контекст
*/
public SensorRotation(Context context) {
sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
lastUpdateTime = 0;
}
/**
* Регистрация активити как слушателя сенсора
*
* @param activity
* @param listener
*/
public void register(Activity activity, SensorEventListener listener) {
try {
if (sensorListener != null) {
sensorManager.unregisterListener(sensorListener);
}
this.sensorListener = listener;
this.activity = activity;
sensorManager.registerListener(sensorListener, sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION), SensorManager.SENSOR_DELAY_GAME);
Log.v("Activity = " + activity.getLocalClassName());
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Удаляет слушатель
*/
public void unregister() {
sensorManager.unregisterListener(sensorListener);
Log.v("unregister");
}
private boolean in(float value, int min, int max) {
return (value > min && value < max);
}
private int getCurrentOrientation(SensorEvent event) {
float y = event.values[1];
float z = event.values[2];
// Ниже приведенные числа координат ограничивающие наклон рассчитаны эмпирически. Вы можете их варьировать под себя.
if (in(z, 60, 100)) return 1;
if (in(z, -20, 20) && y > 50) return 2;
if (in(z, -20, 20) && y < -50) return 0;
if (in(z, -100, -60)) return 3;
return -1;
}
/**
* Реакция на поворот
*
* @param event
*/
public boolean onSensorChanged(SensorEvent event) {
if (System.currentTimeMillis() - lastUpdateTime < 500) return false;
lastUpdateTime = System.currentTimeMillis();
orientation = getCurrentOrientation(event);
if (activity.getClass() == Guitar.class) if (orientation == 0) rightPosition = true;
if (activity.getClass() == Sing.class) if (orientation == 1) rightPosition = true;
if (activity.getClass() == Drums.class) if (orientation == 2) rightPosition = true;
if (activity.getClass() == Piano.class) if (orientation == 3) rightPosition = true;
if (!rightPosition) return false;
Intent intent = null;
switch (orientation) {
case 0: {
Log.v("Orientation = " + orientation + ", launching Guitar");
intent = new Intent(activity, Guitar.class);
break;
}
case 1: {
Log.v("Orientation = " + orientation + ", launching Sing");
intent = new Intent(activity, Sing.class);
break;
}
case 2: {
Log.v("Orientation = " + orientation + ", launching Drums");
intent = new Intent(activity, Drums.class);
break;
}
case 3: {
Log.v("Orientation = " + orientation + ", launching Piano");
intent = new Intent(activity, Piano.class);
break;
}
}
if (intent != null) {
activity.startActivity(intent);
activity.finish();
return true;
}
return false;
}
}
```
Затем создаем Activity от которой наследуется остальные игровые Activity.
```
public abstract class TalentGameActivity extends BaseGameActivity implements SensorEventListener {
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
@Override
public void onSensorChanged(SensorEvent event) {
if (GameModel.getInstance().sensorRotation.onSensorChanged(event)) {
// Ваши действия при повороте
}
}
@Override
public void onLoadComplete() {
....
// не забудьте проинициализировть instance перед использованием
SensorRotation.instance.sensorRotation.register(this, this);
.....
}
}
```
Теперь мы создаем все игровые активити. Активити которые должны быть перевернуты на 180 градусов должны в процессе создания перевернуть камеру на 180 градусов как указано ниже.
```
public class Drums extends TalentGameActivity {
@Override
public Engine onLoadEngine() {
super.onLoadEngine();
mCamera = new Camera(0, 0, Const.ENGINE_PORTRAIT_WIDTH, Const.ENGINE_PORTRAIT_HEIGHT);
mCamera.setRotation(180); // Здесь мы задаем поворот на 180 градусов для перевернутых активити и не используем для обычных положений.
mEngine = new Engine(new EngineOptions(true, ScreenOrientation.PORTRAIT, new FillResolutionPolicy(), mCamera));
// ScreenOrientation - выставляйте нужную ориентацию
//mEngine = new Engine(new EngineOptions(true, ScreenOrientation.LANDSCAPE, new FillResolutionPolicy(), mCamera));
super.onLoadEngine();
return mEngine;
}
}
```
Вот и все. | https://habr.com/ru/post/124845/ | null | ru | null |
# SoC: пишем реализацию framebuffer для контроллера в FPGA
Приветствую!
[В прошлый раз](http://habrahabr.ru/company/metrotek/blog/248145/) мы остановились на том, что подняли DMA в FPGA.
Сегодня мы реализуем в FPGA примитивный LCD-контроллер и напишем драйвер фреймбуфера для работы с этим контроллером.
Вы ещё раз убедитесь, что разработка под FPGA и написание драйверов под Linux дело очень простое, но интересное.
Также в конце есть маленький опрос — хочется узнать мнение сообщества. Если не сложно, прошу проголосовать.
Так сложилось, что в HPS на [Cyclone V](https://www.altera.com/products/fpga/cyclone-series/cyclone-v/overview.html) нет встроенного графического контроллера. А жить без дисплея нам никак нельзя — куда же выводить [результаты измерений](http://metrotek.spb.ru/b3et.html).
Конечно, можно обойтись только программной реализацией фреймбуфера (с добавлением всяких полезностей в виде deferred\_io и двойной буферизации). Но это, всё равно, будет не очень шустро и точно не будет так интересно, как то, что выберем мы.
А мы выбираем реализацию очень простого, но полностью рабочего LCD-контроллера в FPGA, который позволит снять с CPU ненужную нагрузку в виде записи данных в дисплей.
Использовать мы будем LCD на базе чипа [ILI9341](http://www.newhavendisplay.com/app_notes/ILI9341.pdf).
Итак, план на сегодня:
* Думаем над архитектурой
* Изучаем наш LCD
* Пишем Linux драйвер
* Разрабатываем модуль в FPGA
* Настраиваем кое-что в U-boot
* Отлаживаемся
### Архитектура
Что такое [фреймбуфер](https://ru.wikipedia.org/wiki/Linux_framebuffer) в Linux?
В двух словах — это просто область памяти, запись в которую приводит к отображению записанного на дисплее.
Из userspace доступ выполняется через файл устройства **/dev/fb[N]**.
Обычно реализованы стандартные системные вызовы — open(), close(), read(), write(), lseek() и mmap().
В драйвере большая часть функций выполняет одну задачу — обновить кадр, который хранится в памяти.
Иногда также присутствуют функции, которые копируют данные из памяти в LCD, если это не реализовано аппаратно.
Все структуры и функции хорошо и подробно описаны в этих статьях — [ссылка раз](http://habrahabr.ru/post/164635/) и [ссылка два](http://habrahabr.ru/post/213775/).
Смысла дублировать информацию нет, поэтому проанализируем только то, что влияет на нашу архитектуру.
Итак, у нас есть несколько функций, которые предназначены для обновления данных в памяти. Они имеют немного разную сигнатуру. Используя эти функции можно перерисовать как весь кадр целиком, так и только несколько пикселей.
После обновления кадра нужно сделать так, чтобы он попал в LCD. Естественно, копирование только изменённой части кадра требует передачи меньшего количества данных. И если бы мы копировали данные при помощи CPU, то нам обязательно стоило бы это учесть.
Но у нас копирование будет выполнять DMA-контроллер в FPGA, поэтому мы не станем беспокоиться по этому поводу и будем перерисовывать весь кадр целиком.
Следующий вопрос в том, когда перерисовывать кадр. Одно из простых решений — выполнять отрисовку синхронно, то есть в конце каждой функции, которая обновляет данные в памяти. Это хорошо работает во всех случаях, кроме использования mmap().
После выполнения отображения не так просто определить, когда userspace'ный процесс изменил содержание памяти. Эту задачу можно решить при помощи **deferred\_io** (а заодно и определить конкретные страницы памяти, которые обновились и которые нужно перерисовывать). Но мы хотим, чтобы наша реализация была как можно более простой и понятной, поэтому мы сделаем по-другому.
Наш контроллер в FPGA будет выполнять отрисовку всего кадра с частотой в n FPS. И делать это он будет асинхронно относительно обновления памяти драйверными функциями. Таким образом всё, что нужно сделать в драйвере — это инициализация LCD и FPGA-контроллера. И даже запись данных в память фреймбуфера нам реализовывать не потребуется, для этого уже есть стандартные функции.
Контроллер в FPGA тоже будет достаточно простым. Его задачи:
* Читать данные из указанной области по интерфейсу **fpga2sdram** либо **fpga2hps**
* Передавать прочитанные данные в LCD, сформировав нужные транзакции
* Давать возможность CPU получить прямой доступ к интерфейсу до LCD
* Выдавать заданный FPS
### Описание нашего LCD
Всё, что нам нужно знать про LCD — как его инициализировать и как выглядит транзакция записи.
Инициализацию рассмотрим, когда дойдём до драйвера, а сейчас займемся изучением транзакций.
Их нам придётся реализовывать как в FPGA (для передачи данных), так и в драйвере (для настройки дисплея).
[ILI9341](http://www.newhavendisplay.com/app_notes/ILI9341.pdf) поддерживает несколько интерфейсов. У меня используется параллельный 16-битный интерфейс, называемый 8080 по имени процессора от Intel, в котором он впервые появился. Вот какие сигналы там есть (вначале указано более распространённое название, а в скобках — название из даташита на ILI9341):
* CS (CSX) — chip-select, активный уровень 0. Сигнал выбора чипа, у меня заведён на землю.
* RST (RESX) — reset, активный уровень 0. Сигнал сброса, у меня заведён на GPIO HPS.
* RS (D/CX) — register select. Если сигнал равен 0, то на шине DATA выставлена команда, иначе — данные.
* WR (WRX) — write strobe. Строб записи.
* RD (RDX) — read strobe. Строб чтения.
* DATA (D) — данные или команда, в зависимости от RS.
Транзакция записи предельно простая:
**Write transaction**
Транзакция чтения не сложнее, но нам она не понадобится, поэтому рассматривать её не будем.
### Linux драйвер
Что же есть у нас в драйвере?
Во-первых, функции для чтения/записи регистров FPGA. Подробнее о том, что такое контрольно-статусные регистры, и как их использовать, можно прочитать [в статье](http://habrahabr.ru/company/metrotek/blog/263005/) моего коллеги [ishevchuk](https://habr.com/ru/users/ishevchuk/).
**CSR read/write functions**
```
static void fpga_write_reg(int reg, u16 val)
{
iowrite16(val, fpga_regs + 2*reg);
}
static u16 fpga_read_reg(int reg)
{
u16 tmp;
tmp = ioread16(fpga_regs + 2*reg);
return tmp;
}
static void fpga_set_bit(int reg, int bit)
{
unsigned long tmp = fpga_read_reg(reg);
set_bit(bit, &tmp);
fpga_write_reg(reg, tmp);
}
static void fpga_clear_bit(int reg, int bit)
{
unsigned long tmp = fpga_read_reg(reg);
clear_bit(bit, &tmp);
fpga_write_reg(reg, tmp);
}
```
Во-вторых, функции для прямой записи в LCD команд и данных. Они будут использоваться для инициализации дисплея.
Функции абсолютно «топорные» — просто делаем транзакцию такой, какой она изображена в даташите (и выше в этой статье).
**LCD data/command write functions**
```
static void lcd_write_command(u16 val)
{
/* Write command code */
fpga_write_reg(LCD_DATA_CR, val);
/* WR and RS low, RD high */
fpga_write_reg(LCD_CTRL_CR, LCD_CTRL_CR_RD);
ndelay(1);
/* RS low, WR and RD high */
fpga_write_reg(LCD_CTRL_CR, LCD_CTRL_CR_RD | LCD_CTRL_CR_WR);
ndelay(1);
/* All control signals high */
fpga_write_reg(LCD_CTRL_CR, LCD_CTRL_CR_RD | LCD_CTRL_CR_WR |
LCD_CTRL_CR_RS);
}
static void lcd_write_data(u16 data)
{
/* Write data */
fpga_write_reg(LCD_DATA_CR, data);
/* WR low, RD and RS high */
fpga_write_reg(LCD_CTRL_CR, LCD_CTRL_CR_RD | LCD_CTRL_CR_RS);
ndelay(1);
/* All control signals high */
fpga_write_reg(LCD_CTRL_CR, LCD_CTRL_CR_RD |
LCD_CTRL_CR_RS | LCD_CTRL_CR_WR);
}
```
Ну и, собственно, наша нехитрая инициализация LCD.
**LCD initialization function**
```
static void lcd_init(struct fb_info *info)
{
// Clear data
fpga_write_reg(LCD_DATA_CR, 0);
// All control signals high
fpga_write_reg(LCD_CTRL_CR, LCD_CTRL_CR_RD | LCD_CTRL_CR_RS | LCD_CTRL_CR_WR);
mdelay(100);
lcd_write_command(ILI9341_DISPLAY_ON);
lcd_write_command(ILI9341_SLEEP_OUT);
lcd_write_command(ILI9341_INVERTION_OFF);
lcd_write_command(ILI9341_MEM_ACCESS_CTRL);
lcd_write_data(MY | MX | MV | BGR);
lcd_write_command(ILI9341_PIXEL_FORMAT);
lcd_write_data(0x0055);
lcd_write_command(ILI9341_COLUMN_ADDR);
lcd_write_data(0x0000);
lcd_write_data(0x0000);
lcd_write_data((DISPLAY_WIDTH-1) >> 8);
lcd_write_data((DISPLAY_WIDTH-1) & 0xFF);
lcd_write_command(ILI9341_PAGE_ADDR);
lcd_write_data(0x0000);
lcd_write_data(0x0000);
lcd_write_data((DISPLAY_HEIGHT-1) >> 8);
lcd_write_data((DISPLAY_HEIGHT-1) & 0xFF);
lcd_write_command(ILI9341_MEM_WRITE);
}
```
Коротко про используемые команды.
ILI9341\_DISPLAY\_ON (0x29) и ILI9341\_SLEEP\_OUT (0x11), хоть это и неожиданно, включают дисплей и выводят его из спящего режима.
ILI9341\_MEM\_ACCESS\_CTRL (0x36) — это настройка направления сканирования памяти.
ILI9341\_PIXEL\_FORMAT (0x3a) — формат изображения, у нас это 16 бит на пиксель.
ILI9341\_COLUMN\_ADDR (0x2a) и ILI9341\_PAGE\_ADDR (0x2b) задают рабочую область нашего дисплея.
ILI9341\_MEM\_WRITE (0x2c) — эта команда говорит, что дальше последуют транзакции с данными. При этом текущая позиция выставляется на начальные столбец и строку, которые были заданы, соответственно, при помощи ILI9341\_COLUMN\_ADDR и ILI9341\_PAGE\_ADDR. После каждой транзакции столбец будет автоматически инкрементироваться на 1. Когда столбец станет равным конечному, произойдет переход на следующую строку. Когда и столбец и строка станут равны конечным, позиция вернётся в начальную.
Таким образом, после команды ILI9341\_MEM\_WRITE контроллер в FPGA может просто «по кругу» отсылать данные из памяти в LCD, ни о чём больше не заботясь.
Последнее, что нас интересует в драйвере, это функция probe.
**Driver probe function**
```
struct fb_info *info;
int ret;
u32 vmem_size;
unsigned char *vmem;
dma_addr_t dma_addr;
pdev->dev.dma_mask = &platform_dma_mask;
pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
vmem_size = (etn_fb_var.width * etn_fb_var.height * etn_fb_var.bits_per_pixel) / 8;
vmem = dmam_alloc_coherent(&pdev->dev, vmem_size, &dma_addr, GFP_KERNEL);
if (!vmem) {
dev_err(&pdev->dev, "FB: dma_alloc_coherent error\n");
return -ENOMEM;
}
memset(vmem, 0, vmem_size);
info = framebuffer_alloc(0, &pdev->dev);
if (!info)
return -ENOMEM;
info->screen_base = vmem;
info->fbops = &etn_fb_ops;
info->fix = etn_fb_fix;
info->fix.smem_start = dma_addr;
info->fix.smem_len = vmem_size;
info->var = etn_fb_var;
info->flags = FBINFO_DEFAULT;
info->pseudo_palette = &etn_fb_pseudo_palette;
/* Get FPGA registers address */
fpga_regs = devm_ioremap(&pdev->dev, FPGA_REGS_BASE, REGSIZE);
/* Disable refreshing */
fpga_write_reg(LCD_DMA_CR, 0);
lcd_init(info);
set_dma_addr(dma_addr);
set_fps(fps);
/* Enable refreshing */
fpga_set_bit(LCD_DMA_CR, LCD_DMA_CR_REDRAW_EN);
ret = register_framebuffer(info);
if (ret < 0) {
framebuffer_release(info);
return ret;
}
platform_set_drvdata(pdev, info);
return 0;
```
Что в ней происходит?
Вначале мы выделяем память в DMA-совместимой зоне при помощи функции **dmam\_alloc\_coherent()**. При этом мы получаем два адреса, которые «указывают» на выделенную область. Один будет использоваться в драйвере, а второй мы запишем а FPGA, чтобы DMA-контроллер мог прочитать данные из этой области.
Пара слов о DMA-отображениях. Они бывают двух типов:
* Потоковые (Streaming)
* Согласованные (Coherent или Сonsistent)
Согласованные отображения доступны одновременно и процессору и устройству. При доступе каждая из сторон гарантировано получит «свежие» данные. Чаще всего используются, когда буфер существует на протяжении всей жизни драйвера. Пример использования — наша память фреймбуфера.
При использовании потоковых отображений доступ возможен строго по очереди. Чаще всего создаются на время одной операции.
Теоретически, могут быть более производительными. Пример — приём/отправка сетевых пакетов.
Вернёмся к функции probe. Дальше мы заполняем **fb\_info**.
Потом мы мапим адресное пространство FPGA, чтобы иметь возможность читать и писать в контрольно-статусные регистры.
После этого мы записываем в FPGA требуемое значение FPS и наш DMA-адрес (не забыв перевести его в номер слова, при необходимости).
Затем включаем отрисовку в FPGA и регистрируем наш фреймбуфер. Всё готово!
### Модуль в FPGA
Мы добрались до модуля в FPGA. Тут тоже всё просто.
Напомню, что нам нужно реализовать:
* Прямой доступ CPU к LCD
* Чтение данных из памяти фреймбуфера
* Формирование транзакций записи в сторону LCD
* Получение нужного FPS
Для обеспечения прямого доступа CPU к LCD у нас, естественно, будут использоваться контрольные регистры.
И обычный мультиплексор — когда управление идёт от CPU, то на интерфейс до LCD коммутируются сигналы с регистров, иначе — сигналы из модуля в FPGA. Выбор происходит в зависимости от состояния конечного автомата, который описан ниже.
Код примитивный:
**LCD bus MUX**
```
always_ff @( posedge clk_i )
if( state == IDLE_S )
begin
lcd_bus_if.data <= lcd_ctrl_if.data;
lcd_bus_if.rd <= lcd_ctrl_if.rd;
lcd_bus_if.wr <= lcd_ctrl_if.wr;
lcd_bus_if.rs <= lcd_ctrl_if.rs;
end
else
// Send data transactions from FPGA.
begin
lcd_bus_if.data <= lcd_data_from_fpga;
lcd_bus_if.rd <= 1'b1;
lcd_bus_if.wr <= lcd_wr_from_fpga;
lcd_bus_if.rs <= 1'b1;
end
```
Следующая задача — прочитать данные из памяти и записать их в LCD. Тут нужно немного подумать.
Мы не можем непрерывно читать данные, так как пропускная способность интерфейса чтения у нас много больше, чем скорость, с которой мы будем записывать данные в LCD (помним, что нам нужно соблюдать указанные в документации времянки).
То есть нам нужно искусственно ограничить скорость чтения. Для этого есть следующие варианты:
* Читать и записывать в LCD последовательно — прочитали, записали, прочитали, записали и т.д.
* Рассчитать скорость, с которой нам нужно вычитывать данные, и поддерживать её
* Использовать FIFO
Первый вариант приведёт к тому, что данные на LCD будут поступать с большими (по меркам FPGA) паузами.
Учитывая прикладную задачу (нам вряд ли нужно получить FPS больше 50), вполне возможно, что нам этого хватит.
Но очень уж это топорно и некрасиво. Поэтому этот вариант отметаем.
Второй вариант — рассчитать, с какой скоростью нужно читать данные из памяти, чтобы мы могли получить непрерывный поток к LCD. Тоже вполне рабочий вариант, особенно если учесть, что жестких требований к постоянству скорости выходного потока у нас нет. Но, в общем случае, из-за переменной величины задержки в транзакциях чтения нам всё равно пришлось бы использовать буфер для согласования скоростей.
Третий вариант очень простой и достаточно надежный. Суть его в том, что мы используем FIFO — буфер, в который мы на большой скорости записываем прочитанные из памяти данные. Когда в буфере заканчивается место мы приостанавливаем чтение. При этом мы можем непрерывно вычитывать данные из буфера и формировать транзакции на LCD с постоянной скоростью. Как только в FIFO появляется место, мы опять возобновляем чтение из памяти.
Мы выбираем третий вариант. Для начала нам нужно FIFO:
**FIFO instance**
```
buf_fifo #(
.AWIDTH ( FIFO_AWIDTH ),
.DWIDTH ( AMM_DATA_W )
) buf_fifo (
.clock ( clk_i ),
.aclr ( ),
.wrreq ( fifo_wr_req ),
.data ( fifo_wr_data ),
.rdreq ( fifo_rd_req ),
.q ( fifo_rd_data ),
.almost_full ( ),
.full ( ),
.empty ( fifo_empty ),
.usedw ( fifo_usedw )
);
```
Для определения момента приостановки чтения мало знать, насколько FIFO уже заполнено. Ведь у нас также есть транзакции чтения, которые сейчас «в процессе». То есть это данные, чтение которых мы уже запросили, но которые к нам ещё не доставлены.
Нам необходимо знать количество таких транзакций в текущий момент. Для этого каждый раз, когда выполняется запрос на чтение, мы будем увеличивать соответствующий счётчик, а при получении подтверждения прочитанных данных — уменьшать.
**Pending transactions calculation**
```
// Count of read transactions in progress
logic [FIFO_AWIDTH-1:0] pending_read_cnt;
always_ff @( posedge clk_i )
case( { read_req_w, amm_if.read_data_val } )
2'b01:
pending_read_cnt <= pending_read_cnt - 1'd1;
2'b10:
pending_read_cnt <= pending_read_cnt + 1'd1;
endcase
```
В итоге останавливать чтение мы будем, когда сумма записанных в FIFO слов и транзакций «в процессе» почти сравняется с глубиной нашей очереди. В качестве «почти» выберем 50 свободных слов:
**Stop reading**
```
logic stop_reading;
assign stop_reading = ( pending_read_cnt + fifo_usedw ) > ( 2**FIFO_AWIDTH - 'd50 );
```
Формирование самих транзакций чтения на **Avalon MM** примитивно. Главное правильно инкрементировать адрес в зависимости от типа интерфейса: **fpga2sdram** или **fpga2hps** (более подробное описание интерфейсов и различий см. [тут](http://habrahabr.ru/company/metrotek/blog/248145/)):
**Read transactions**
```
// fpga2sdram used word address, so we must added 1 every time,
// fpga2hps used byte address, so we must added 8 (for 64-bit iface).
logic [31:0] addr_incr;
assign addr_incr = ( USE_WORD_ADDRESS == 1 ) ? 1 : ( AMM_DATA_W >> 3 );
always_ff @( posedge clk_i )
if( state == IDLE_S )
amm_if.address <= lcd_ctrl_if.dma_addr;
else
if( read_req_w )
amm_if.address <= amm_if.address + addr_incr;
// Always read all bytes in word
assign amm_if.byte_enable = '1;
// We don't use burst now
assign amm_if.burst_count = 1;
assign amm_if.read = ( state == READ_S );
// Remove Quartus warnings
assign amm_if.write_data = '0;
assign amm_if.write = 0;
```
Читать данные мы научились, теперь нужно научиться писать их в LCD. Для этого сделаем простенький конечный автомат на два состояния: если в FIFO есть данные, автомат переходит в состояние отправки транзакции. А после окончания записи возвращается обратно в IDLE:
**FSM for writing to LCD**
```
enum int unsigned {
LCD_IDLE_S,
LCD_WRITE_S
} lcd_state, lcd_next_state;
always_ff @( posedge clk_i )
lcd_state <= lcd_next_state;
always_comb
begin
lcd_next_state = lcd_state;
case( lcd_state )
LCD_IDLE_S:
begin
if( !fifo_empty )
lcd_next_state = LCD_WRITE_S;
end
LCD_WRITE_S:
begin
if( lcd_word_cnt == 5'd31 )
lcd_next_state = LCD_IDLE_S;
end
endcase
end
assign fifo_rd_req = ( lcd_state == LCD_IDLE_S ) && ( lcd_next_state == LCD_WRITE_S );
```
Нужно помнить, что одна транзакция до LCD — это передача 16 бит данных, а каждое слово в FIFO имеет размер 64 бита (зависит от настройки интерфейса fpga2sdram/fpga2hps). Поэтому на каждое прочитанное слово мы будем формировать 4 транзакции.
Формировать их просто — для этого нам достаточно сделать один счётчик и использовать в нём нужные разряды:
**Read transactions**
```
// ILI9341 Data transaction from FPGA:
// __ __ __ __ __ __ __ __ __
// clk/4 | __| |__| |__| |__| |__| |__| |__| |__| |__| |
//
// data | ///< split[0] | split[1] | split[2] | split[3] >////
//
// _______________________________________________
// rd | xxxx xxxx
//
// _____ _____ _____ _____
// wr | xxxx_____| |_____| |_____| |_____| xxxx
//
// _______________________________________________
// rs | xxxx xxxx
logic [3:0][15:0] fifo_rd_data_split;
assign fifo_rd_data_split = fifo_rd_data;
logic [15:0] lcd_data_from_fpga;
logic lcd_wr_from_fpga;
logic [4:0] lcd_word_cnt;
always_ff @( posedge clk_i )
if( lcd_state == LCD_IDLE_S )
lcd_word_cnt <= '0;
else
lcd_word_cnt <= lcd_word_cnt + 1'd1;
assign lcd_data_from_fpga = fifo_rd_data_split[ lcd_word_cnt[4:3] ];
assign lcd_wr_from_fpga = ( lcd_state == LCD_IDLE_S ) ? 1'b1 : lcd_word_cnt[2];
```
Почти всё. Осталось сделать основной конечный автомат, который будет управлять всем вышеописанным.
Логика его работы простая — если наш модуль LCD контроллера включен, то нужно отрисовать один кадр.
Для реализации заданного FPS есть «состояние-пауза», в котором происходит ожидание нужного количества тактов.
После этого стартует чтение данных из памяти (запись в LCD начнётся автоматически, как только в FIFO появятся данные).
Когда будет прочитан весь кадр, останется только дождаться завершения транзакций к LCD:
**Main FSM**
```
logic [31:0] word_cnt;
always_ff @( posedge clk_i )
if( state == IDLE_S )
word_cnt <= '0;
else
if( read_req_w )
word_cnt <= word_cnt + 1'd1;
logic reading_is_finished;
assign reading_is_finished = ( word_cnt == WORD_IN_FRAME - 1 ) && read_req_w;
logic stop_reading;
assign stop_reading = ( pending_read_cnt + fifo_usedw ) > ( 2**FIFO_AWIDTH - 'd50 );
logic all_is_finished;
assign all_is_finished = ( pending_read_cnt == 0 ) &&
( fifo_usedw == 0 ) &&
( lcd_state == LCD_IDLE_S );
enum int unsigned {
IDLE_S,
FPS_DELAY_S,
READ_S,
WAIT_READIND_S,
WAIT_WRITING_S
} state, next_state;
always_ff @( posedge clk_i )
state <= next_state;
// FIXME:
// If lcd_ctrl_if.redraw_en == 1
// CPU have one takt for read 0 in lcd_ctrl_if.dma_busy
// Fix: add WAIT_WRITING_S -> FPS_DELAY_S path
always_comb
begin
next_state = state;
case( state )
IDLE_S:
begin
if( lcd_ctrl_if.redraw_stb || lcd_ctrl_if.redraw_en )
next_state = FPS_DELAY_S;
end
FPS_DELAY_S:
begin
if( fps_delay_done_w )
next_state = READ_S;
end
READ_S:
begin
if( reading_is_finished )
next_state = WAIT_WRITING_S;
else
if( stop_reading )
next_state = WAIT_READIND_S;
end
WAIT_READIND_S:
begin
if( !stop_reading )
next_state = READ_S;
end
WAIT_WRITING_S:
begin
if( all_is_finished )
next_state = IDLE_S;
end
endcase
end
```
Всё, наш контроллер LCD готов.
### Настройка U-boot
В [прошлой статье](http://habrahabr.ru/company/metrotek/blog/248145/) я писал, что включение **fpga2sdram** интерфейса необходимо выполнять в **U-boot**. Иначе при транзакции чтения система полностью зависнет. Для этого нужно добавить в окружение следующие строки:
**u-boot-env.txt**
```
...
fpgadata=0x10000000
fpgafile=/lib/firmware/fpga/fpga.rbf
fpgaboot=setenv fpga2sdram_handoff 0x3fff; ext2load mmc 0:2 ${fpgadata} ${fpgafile}; fpga load 0 ${fpgadata} ${filesize}
bridge_enable_handoff=mw $fpgaintf ${fpgaintf_handoff}; go $fpga2sdram_apply; mw $fpga2sdram ${fpga2sdram_handoff}; mw $axibridge ${axibridge_handoff}; mw $l3remap ${l3remap_handoff}
bootcmd=run fpgaboot; run bridge_enable_handoff; run mmcboot
...
```
### Отладка
В принципе, всё должно заработать без проблем, поэтому отлаживать нам нечего.
Но, так как мы немного поленились и не стали писать для нашего FPGA модуля тестбенч, то для спокойствия стоит посмотреть на работу модуля в SignalTap'е.
Вот так выглядят транзакции от CPU:
[](https://habrastorage.org/files/ff4/1c1/ef7/ff41c1ef75484d7f8100ac68974d5e45.png)
Мы видим запись команд 0x29, 0x11, 0x36 и данных 0xE8. Всё верно.
А так выглядят транзакции от FPGA:
[](https://habrastorage.org/files/63f/8d7/f14/63f8d7f1411b43fd87e0647b77245bd7.png)
И тут тоже всё так, как мы и планировали.
Ура! У нас получился LCD-контроллер в FPGA.
Спасибо тем, кто дочитал до конца! Удачи!
### Полезные ссылки
[Исходники на github](https://github.com/Des333/soc-fb)
[Девайс, на котором проводились все работы](http://metrotek.spb.ru/ethond.html)
[Документация по написанию framebuffer драйверов](https://www.kernel.org/doc/Documentation/fb/framebuffer.txt)
[Документация по ILI9341](http://www.newhavendisplay.com/app_notes/ILI9341.pdf)
### Замечание по поводу предыдущей статьи
[В прошлой статье](http://habrahabr.ru/company/metrotek/blog/248145/) я измерял пропускную способность интерфейса **fpga2sdram**.
К сожалению, мной была допущена ошибка. А именно — клок PLL был задан равным 125 МГц, а не 25 МГц, как есть на самом деле.
Из-за этого коэффициенты умножителя и делителя для PLL были рассчитаны неверно.
В итоге DDR3 работал на 66 МГц вместо положенных 333 МГц.
При правильных коэффициентах и ширине интерфейса в 256 бит пропускная способность составляет около 16-17 Гбит/c, что соответствует теоретической для интерфейса DDR3 с шириной 32 бита и частотой 333 МГц.
Приношу свои извинения!
### Маленький опрос
Хочется узнать мнение сообщества. Если не сложно, прошу проголосовать. | https://habr.com/ru/post/263571/ | null | ru | null |
# Создание REST API с Node.js и базой данных Oracle. Часть 5
**Часть 5. Создание REST API: разбиение на страницы, сортировка и фильтрация вручную**
В [предыдущей статье](https://habr.com/ru/post/473560/) вы завершили построение базовой функциональности API CRUD.
И теперь, когда на маршруте сотрудников выдается запрос HTTP GET, возвращаются все строки таблицы. Это может не иметь большого значения только с 107 строками в таблице HR.EMPLOYEES, но представьте, что произойдет, если таблица будет содержать тысячи или миллионы строк. Такие клиенты, как мобильные и веб-приложения, обычно отображают только часть строк, доступных в базе данных, а затем выбирают больше строк, когда это необходимо — возможно, когда пользователь прокручивает вниз или нажимает кнопку «Далее» на каком-либо элементе управления разбиением на страницы в пользовательском интерфейсе.
Для этого API REST должны поддерживать средства разбиения на страницы возвращаемых результатов. После того, как разбиение на страницы поддерживается, становится необходима возможности сортировки, поскольку данные обычно должны быть отсортированы до применения нумерации страниц. Кроме того, средство фильтрации данных очень важно для производительности. Зачем отправлять данные из базы данных, через промежуточный уровень и полностью на клиент, если это не нужно?
Я буду использовать параметры строки запроса URL, чтобы клиенты могли указать, как результаты должны разбиваться на страницы, сортироваться и фильтроваться. Как всегда в программировании, реализация может варьироваться в зависимости от ваших требований, целей производительности и т. д. В этом посте я расскажу вам о ручном подходе к добавлению этих функций в API.
**Разбиение на страницы**
Параметры строки запроса, которые я буду использовать для разбивки на страницы: skip и limit. Параметр skip будет использоваться для пропуска указанного количества строк, в то время как limit будет ограничивать количество возвращаемых строк. Я буду использовать значение по умолчанию 30 для лимита, если клиент не предоставит значение.
Начните с обновления логики контроллера, чтобы извлечь значения из строки запроса и передать их в API базы данных. Откройте файл **controllers / employee.js** и добавьте следующие строки кода в функцию get после строки, которая анализирует параметр req.params.id.
```
// *** line that parses req.params.id is here ***
context.skip = parseInt(req.query.skip, 10);
context.limit = parseInt(req.query.limit, 10);
```
Теперь необходимо обновить логику базы данных, чтобы учесть эти значения и соответствующим образом обновить запрос SQL. В SQL предложение offset используется для пропуска строк, а предложение fetch — для ограничения количества строк, возвращаемых запросом. Как обычно, значения не будут добавляться непосредственно к запросу — вместо этого они будут добавлены как переменные связывания по соображениям производительности и безопасности. Откройте **db\_apis / employee.js** и добавьте следующий код после блока if в функции find, которая добавляет предложение where к запросу.
```
// *** if block that appends where clause ends here ***
if (context.skip) {
binds.row_offset = context.skip;
query += '\noffset :row_offset rows';
}
const limit = (context.limit > 0) ? context.limit : 30;
binds.row_limit = limit;
query += '\nfetch next :row_limit rows only';
```
Это все, что вам нужно сделать для нумерации страниц! Запустите API, а затем выполните несколько команд URL в другом терминале, чтобы проверить его. Вот несколько примеров, которые вы можете использовать:
```
# use default limit (30)
curl "http://localhost:3000/api/employees"
# set limit to 5
curl "http://localhost:3000/api/employees?limit=5"
# use default limit and set skip to 5
curl "http://localhost:3000/api/employees?skip=5"
# set both skip and limit to 5
curl "http://localhost:3000/api/employees?skip=5&limit=5"
```
**Сортировка**
Как минимум, клиенты должны иметь возможность указать столбец для сортировки и порядок (по возрастанию или по убыванию). Самый простой способ сделать это — определить параметр запроса (я буду использовать sort), который позволяет передавать строку типа 'last\_name: asc' или 'salary: desc'. Единственный способ гарантировать порядок набора результатов, возвращаемых из SQL-запроса — это включить предложение order by. По этой причине было бы неплохо иметь определение порядка по умолчанию, определяемое для обеспечения согласованности, когда клиент не указывает его.
Вернитесь в файл **controllers / employee.js** и добавьте следующую строку кода в функцию get после строки, которая анализирует параметр req.query.limit.
```
// *** line that parses req.query.limit is here ***
context.sort = req.query.sort;
```
Затем откройте **db\_apis / employee.js** и добавьте следующую строку под строками, которые объявляют и инициализируют baseQuery.
```
// *** lines that initalize baseQuery end here ***
const sortableColumns = ['id', 'last_name', 'email', 'hire_date', 'salary'];
```
sortableColumns — это whitelist столбцов, который клиенты смогут использовать для сортировки. Затем, внутри функции find, добавьте следующий блок if, который добавляет предложение order by. Это необходимо сделать после добавления предложения where, но до предложений offset и fetch.
```
// *** if block that appends where clause ends here ***
if (context.sort === undefined) {
query += '\norder by last_name asc';
} else {
let [column, order] = context.sort.split(':');
if (!sortableColumns.includes(column)) {
throw new Error('Invalid "sort" column');
}
if (order === undefined) {
order = 'asc';
}
if (order !== 'asc' && order !== 'desc') {
throw new Error('Invalid "sort" order');
}
query += `\norder by "${column}" ${order}`;
}
```
Первая часть блока if проверяет, передал ли клиент значение сортировки. Если нет, то к запросу SQL добавляется предложение order by по умолчанию, которое сортирует по last\_name в порядке возрастания. Если указано значение сортировки, то оно сначала разбивается на значения column и order, и каждое значение проверяется перед добавлением order by к запросу.
Теперь вы можете запустить несколько команд URL для его проверки. Вот несколько примеров, чтобы попробовать:
```
# use default sort (last_name asc)
curl "http://localhost:3000/api/employees"
# sort by id and use default direction (asc)
curl "http://localhost:3000/api/employees?sort=id"
# sort by hire_date desc
curl "http://localhost:3000/api/employees?sort=hire_date:desc"
# use sort with limit and skip together
curl "http://localhost:3000/api/employees?limit=5&skip=5&sort=salary:desc"
# should throw an error because first_name is not whitelisted
curl "http://localhost:3000/api/employees?sort=first_name:desc"
# should throw an error because 'other' is not a valid order
curl "http://localhost:3000/api/employees?sort=last_name:other"
```
Последние два примера должны выдавать исключения, поскольку они содержат значения, которые не были внесены в whitelist. Тут используется стандартный обработчик ошибок Express, поэтому ошибка возвращается в виде веб-страницы HTML.
**Фильтрация**
Возможность фильтрации данных является важной функцией, которую должны предоставлять все API REST. Как и в случае с сортировкой, реализация, может быть, простой или сложной в зависимости от того, что вы хотите поддерживать. Самый простой подход — добавить поддержку фильтров полного совпадения (например, last\_name = Doe). Более сложные реализации могут добавлять поддержку базовых операторов (например, <,>, instr и т. д.) И сложных логических операторов (например, и / или), которые могут группировать несколько фильтров вместе.
В этом посте я постараюсь упростить ситуацию и добавлю поддержку фильтров только для двух столбцов: department\_id и manager\_id. Для каждого столбца я разрешу соответствующий параметр в строке запроса. Логика базы данных, которая добавляет предложение where, когда GET-запросы отправляются на конечную точку с одним сотрудником, необходимо обновить, чтобы учесть эти новые фильтры.
Откройте **controllers / employee.js** и добавьте следующие строки ниже строки, которая анализирует значение req.query.sort в функции get.
```
// *** line that parses req.query.sort is here ***
context.department_id = parseInt(req.query.department_id, 10);
context.manager_id = parseInt(req.query.manager_id, 10);
```
Затем отредактируйте **db\_apis / employee.js**, добавив в базовый запрос предложение 1 = 1, как показано ниже.
```
const baseQuery =
`select employee_id "id",
first_name "first_name",
last_name "last_name",
email "email",
phone_number "phone_number",
hire_date "hire_date",
job_id "job_id",
salary "salary",
commission_pct "commission_pct",
manager_id "manager_id",
department_id "department_id"
from employees
where 1 = 1`;
```
Конечно, 1 = 1 всегда будет принимать значение true, поэтому оптимизатор просто проигнорирует это. Однако этот метод упростит добавление дополнительных предикатов в дальнейшем.
В функции find замените блок if, который добавляет предложение where при передаче context.id, следующими строками.
```
// *** line that declares 'binds' is here ***
if (context.id) {
binds.employee_id = context.id;
query += '\nand employee_id = :employee_id';
}
if (context.department_id) {
binds.department_id = context.department_id;
query += '\nand department_id = :department_id';
}
if (context.manager_id) {
binds.manager_id = context.manager_id;
query += '\nand manager_id = :manager_id';
}
```
Как видите, каждый блок if просто добавляет значение, переданное в объект binds, а затем добавляет соответствующий предикат в предложение where. Сохраните изменения и перезапустите API. Затем используйте эти команды URL, чтобы проверить это:
```
# filter where department_id = 90 (returns 3 employees)
curl "http://localhost:3000/api/employees?department_id=90"
# filter where manager_id = 100 (returns 14 employees)
curl "http://localhost:3000/api/employees?manager_id=100"
# filter where department_id = 90 and manager_id = 100 (returns 2 employees)
curl "http://localhost:3000/api/employees?department_id=90&manager_id=100"
```
Вот и все — API теперь поддерживает разбиение на страницы, сортировку и фильтрацию! Ручной подход обеспечивает много контроля, но требует много кода. Функция поиска теперь имеет 58 строк и поддерживает только ограниченные возможности сортировки и фильтрации. Вы можете рассмотреть возможность использования модуля, такого как построитель запросов [Knex.js](https://knexjs.org/), чтобы упростить эти операции. | https://habr.com/ru/post/473652/ | null | ru | null |
# Игра для самых маленьких — простая идея, которую не стыдно включить в резюме
#### Предыстория
Мой сын, как, наверное, все дети программистов, получил свою первую клавиатуру ещё когда не умел сидеть. Сейчас ему чуть меньше года, но он уже понимает разницу между «игрушечной» и «настоящей» (папиной) клавиатурой — если колотить по кнопкам настоящей, то на экране меняется картинка, а компьютер иногда издаёт какие-то звуки.
[](http://habrahabr.ru/post/264029/)
Поскольку лишиться всех своих данных мне пока не хочется, ребёнку иногда разрешается нажимать на кнопки заблокированного компьютера. К сожалению, для ребёнка это не очень весело, поскольку компьютер имеет всего два режима (две картинки) — экран ввода пароля и собственно экран блокировки.
Чтобы процесс освоения компьютера стал для детёныша более увлекательным, я решил написать ему простенькую игру. Будучи программистом со стажем, весь процесс решено было построить «правильно».
#### Требования
Заказчик (мой сын, возраст <1 года), как и все нормальные заказчики затруднился письменно изложить непротиворечивые и полные требования к продукту, поэтому пришлось ~~помочь~~ писать самому.
Функциональные:
* Приложение работает в режиме полного экрана.
* Можно нажимать на всё подряд, но самые доступные методы выхода или переключения программ должны быть заблокированы.
* Визуальная обратная связь — цвет фона меняется при нажатии, в центре экрана отображается нажатый символ.
* Звуковая обратная связь — приложение издаёт звук при нажатии на клавишу.
* Предсказуемое поведение — цвет фона, символ и звук должны быть всегда одинаковыми для одной и той же клавиши.
Не функциональные:
* Мне должно быть не стыдно за написанный код.
* Код должен быть ценен сам по себе.
* Архитектура и все решения должны быть «правильными» — как в заказном проекте.
Кроме того было принято решение использовать гибкий итеративный подход к разработке с малыми циклами разработки, заканчивающимися получением обратной связи (SCRUM).
В качестве языка программирования и среды разработки были выбраны C# и Visual Studio, так как они обеспечивали исполнителю наибольшую скорость работы.
#### Реализация
Из одного из старых проектов был извлечен код для создания приложения, развернутого на весь экран:
```
FormBorderStyle = FormBorderStyle.None;
WindowState = FormWindowState.Maximized;
var screen = Screen.PrimaryScreen;
Bounds = screen.Bounds;
```
Далее в дебрях интернета была найдена библиотека [MouseKeyHook](https://github.com/gmamaladze/globalmousekeyhook), с примерами, как заблокировать кнопку Windows. Аналогично примерам были заблокированы Alt-Tab и Ctrl-Esc. Теперь выйти из приложения можно только по Alt-F4.
Далее был написан код, который инициализирует рандомный цвет фона для нажатой клавиши:
* Использовался new Random(seed), чтобы при каждом запуске рандом выдавал одни и те же значения.
* Чтобы цвета были более-менее осмысленными, рандом выбирал значение из перечисления KnownColor, которое затем преобразовывалось в Color и присваивалось Form.BackColor.
* Поддерживались буквенные символы и цифры.
* Символ выводился «как есть» — клавиша Q могла вывести «Q», «q», «Й», «й», в зависимости от активного языка ввода и состояния CapsLock.
Первые альфа-тесты на себе выявили следующие недостатки реализации:
* Form.BackColor категорически не согласен принимать цвет Transparent.
* Чёрный цвет принимается, но символа на нём не видно.
* Есть ряд клавиш, которые могут быть нажаты, у них есть символ, но они не обрабатываются программой или не отображают символ — Enter, Tab, Space, блок цифр над буквами и блок цифровых клавиш справа на клавиатуре.
* Очень не нравился код обработки KeyDown/KeyPress — нужно было выделять диапазоны символов 'A-Z' и '0-9', пробел, Enter. Много не очень внятных блоков условий и сложный код расчёта размера массива рандомных цветов и выборки цвета из него.
Во второй итерации были внесены следующие изменения:
* Написана простенькая WinForm утилита, которая точно так же «слушает» нажатия, сохраняет их в словарь Клавиша-Символ. Это позволило разрешить проблему вывода русских/английских букв.
* У утилиты есть кнопка сохранения словаря в файл.
* Поскольку клавиши Space и Enter в этом случае вызывали срабатывание обработчика кнопки, а Tab вызывал переход на кнопку, даже если она не выбрана, пришлось эти случаи отдельно обработать — установить TabStop=false для кнопок и вставить ActiveControl = null везде, где только можно.
* Утилита помогла выявить все значимые клавиши — она запоминала клавишу при KeyDown, но добавляла её в словарь только по KeyPress, соответственно, всё, что не имеет символьного представления (Alt. Shift, Ctrl, Windows, функциональные клавиши) игнорировалось.
* Обработку клавиши в самой игре можно будет значительно упростить до поиска по словарю.
* Формат файла был самый простой — готовые наборы разделяются переводом строки, а поля (Клавиша-Символ-Цвет) в наборе разделяются символом \0 (пробел, табуляцию, и символы вроде запятой использовать не получилось, так как они могли быть элементом набора)
* После сохранения невидимые символы вручную были заменены на Unicode-символы, отсутствующие на клавиатуре.
* Цвет подбирался не случайным образом, а брался последовательно из enum KnownColor, начиная со следующего после KnownColor.Black (KnownColor.Transparent идёт немного раньше).
Альфа-тестирование на себе прошло вполне успешно и была проведена демонстрация заказчику.
Заказчик проявил интерес к продукту, выделил целых 2 минуты на тестирование, оценил работу в целом положительно и указал на следующие недостатки:
* Недостаточная звуковая обратная связь (звук издает только клавиша PrintScreen).
* Некорректно обрабатывается маленькая светящаяся кнопочка в правом дальнем углу ноутбука (экран гаснет).
Воодушевившись поддержкой заказчика, ~~команда~~ автор провел ретроспективу и сделал следующие выводы:
* Нужно использовать внешнюю клавиатуру без кнопок управления питанием или маскировать аппаратную кнопку рукой.
* Пора переходить к звуковой обратной связи.
Для звуковой обратной связи принято решение издавать звуки, соответствующие нотам (клавишам пианино). Быстрый поиск в интернете позволил найти формулу расчета частоты звука для каждой клавиши и данная формула была оперативно реализована в C# коде. Для непосредственного вывода звука на колонки использован Console.Beep (а что, работает же!).
Первый же прогон продемонстрировал недостатки:
* Автор невнимательно прочитал MSDN, а именно строку «ranging from 37 to 32767 hertz».
* Низкие звуки примерно до 110 Гц звучат отвратительно и их нельзя показывать заказчику.
* Длительность звука 300 мс — слишком долго.
* Звук выводится синхронно и вызывает задержку прорисовки фона.
По результатам были внесены следующие изменения:
* Формировать частоты от 110Гц (25-я клавиша пианино, A2).
* Длительность звука сделать 100мс.
* Выводить звук в отдельном потоке.
* Команда выразила подозрение, что нужно делать Lock во втором потоке на время выполнения Console.Beep. В дальнейшем подозрение не подтвердилось, но ~~удалять было лень~~ блокировка осталась для дидактических целей.
* Использовать [двойной буфер](https://msdn.microsoft.com/en-us/library/b367a457(v=vs.110).aspx) при смене цвета, чтобы не было полос на экране при быстром нажатии на клавиши.
Данная версия получила высокую оценку самой команды, а поскольку до демо для заказчика оставалось время, команда решила провести рефакторинг:
* Реализовать паттерн MVC, выделить логику игры в контроллер, во View оставить только код специфичный для работы с формой (переход в полный экран, обработчики событий).
* Покрыть контроллер юнит-тестами
* Вынести файл-словарь с тройками «Клавиша-Символ-Цвет» в ресурсы и реализовать русскую и английскую версии.
* Поскольку на рабочем ноуте (а на нём мы планировали провести демо) у меня стоит локаль английская, было реализована настройка локали через конфиг. При этом в конфиге добавлена своя секция и реализован простенький файл для доступа к этой секции, возвращающий типизированные значения переменных конфига.
#### Итог
В результате мы получили забавную игрушку для ребенка, которая развивает мелкую моторику и память (на любимые цвета и ноты), а также код, который можно использовать для демонстрации реализации «правильных» подходов. Например, для студентов или Junior-девелоперов.
Вот список того, что можно изучить по коду игрушки:
* Работа с WinForms (полный экран, двойной буффер, обработка событий клавиатуры)
* Работа с локализованными ресурсами.
* Применение паттерна MVC для WinForms (да, да вовсе не обязательно для этого переходить на WPF).
* Применение паттерна Singletone (многопоточного).
* Работа с Moq при разработке юнит-тестов.
* Работа с Shouldly при разработке юнит-тестов.
* Парсинг строк/файлов.
* Многопоточность и блокировка потоков.
* Работа с конфиг-файлом и создание своих секций.
* Правильный кодинг-стайл и использование комментариев и регионов.
* Работа с отладочной консолью (логгирование событий).
* Перечисление значений enum при помощи Enum.GetValues.
* Работа со статическими методами Array (Copy, IndexOf).
* Работа с unmanaged-объектами (using).
* «Отзывчивая» работа формы — подтверждение выхода, использование диалога сохранения файла.
* Работа с NuGet и выкачивание пакетов при сборке.
Готовый код выложен в виде [открытого репозитория на GitHub](https://github.com/igolets/EgorkaGame) и доступен с лицензией MIT.
p.s. КДПВ © [kobyakov](http://ru.depositphotos.com/5107450/stock-photo-little-child-is-typing-on.html) | https://habr.com/ru/post/264029/ | null | ru | null |
# Решение задачи кластеризации методом градиентного спуска
Привет. В этой статье будет рассмотрен способ [кластеризации данных](http://ru.wikipedia.org/wiki/Кластерный_анализ), используя [метод градиентного спуска](http://ru.wikipedia.org/wiki/Градиентный_спуск). Честно говоря данный способ носит больше академический характер, нежели практический. Реализация этого метода мне понадобилась в демонстрационных целях для курса по машинному обучению, что бы показать как одинаковые задачи можно решить различными способами. Хотя конечно если вы планируете осуществить кластеризацию данных, используя дифференцируемую метрику, для которой вычислительно труднее найти [центроид](http://en.wikipedia.org/wiki/Centroid), нежели подсчитать градиент на некотором наборе данных, то этот метод может быть полезным. Итак если вам интересно как можно решить задачу k-means кластеризации с обобщенной метрикой используя метод градиентного спуска, прошу под кат. Код на языке R.
#### Данные
В первую очередь давайте обсудим множество данных, на котором мы будем тестировать алгоритмы. Для тестирования используется [множество данных с датчиков смартфонов](http://archive.ics.uci.edu/ml/datasets/Human+Activity+Recognition+Using+Smartphones): всего 563 поля в 7352 наблюдений; из низ 2 поля выделены для идентификатора пользователя и типа действия. Множество создано для классификации действия пользователя в зависимости от показаний датчиков, всего 6 действий (WALKING, WALKING\_UPSTAIRS, WALKING\_DOWNSTAIRS, SITTING, STANDING, LAYING). Более подробное описание множества вы можете найти по вышеприведенной ссылке.
Как вы понимаете визуализировать такое множество, не уменьшая размерности, немного проблематично. Для уменьшения размерности использовался [метод главных компонент](http://habrahabr.ru/post/146236/), для этого можно использовать стандартные средства языка R, либо реализацию этого метода на том же языке из [моего репозитория](https://github.com/mephistopheies/ml-r). Давайте взглянем на то как выглядит исходное множество, спроецированное на первый и третий главный компонент.
**Код**
```
m.proj <- ProjectData(m.raw, e$eigenVectors[, c(1, 3)])
plot(m.proj[, 1], m.proj[, 2], pch=19,
col=rainbow(6)[unclass(as.factor(samsungData$activity))],
xlab="first", ylab="third",
main="Two components; actions")
```
Различными цветами обозначены различные действия, далее мы будем использовать это двухмерное множество для тестирования и визуализации результатов работы кластеризации.
#### Функция стоимости алгоритма k-means
Введем следующие обозначения:
*  — множество центроидов  соответствующих кластеров
*  — исходное множество данных, которое необходимо кластеризировать
*  — k-ый кластер, подмножество исходного множества
А теперь рассмотрим функцию стоимости [классического алгоритма k-means](http://ru.wikipedia.org/wiki/K-means):
т.е. алгоритм минимизирует суммарное квадратичное отклонение элементов кластера от центроида. Другими словами, минимизируется сумма квадратов Евклидова расстояния элементов кластера от соответствующего центроида:
, где ***f*** — в данном случае является Евклидовым расстоянием.
Как известно для решения этой проблемы существует эффективный алгоритм обучения [основанный на алгоритме expectation-maximization](http://habrahabr.ru/post/146556/). Давайте взглянем на результат работы этого алгоритма, используя встроенную в R функцию:
**Код**
```
kmeans.inner <- kmeans(m.proj, 3)
plot(m.proj[, 1], m.proj[, 2], pch=19,
col=rainbow(3)[unclass(as.factor(kmeans.inner$cluster))],
xlab="first", ylab="third",
main=paste(k, " clusters; kmeans \n cost = ", kmeans.inner$tot.withinss/2, sep=""))
```
#### Градиентный спуск
Сам [алгоритм градиентного спуска](http://ru.wikipedia.org/wiki/Градиентный_спуск) довольно таки прост, суть в том что бы двигаться небольшими шажками в сторону обратную направлению градиента, так например работает [алгоритм обратного распространения ошибки](http://habrahabr.ru/post/154369/), или [алгоритм contrastive divergence для обучения ограниченной машины Больцмана](http://habrahabr.ru/post/159909/). Перво-наперво необходимо рассчитать градиент целевой функции, или же частные производные целевой функции по параметрам модели.
, раз уж мы вышли из секции про классический k-means, то и ***f*** может быть в принципе любой мерой расстояния, не обязательно Евклидовой метрикой
Но тут есть проблема, мы не знаем на данном этапе каково разбиение множества ***X*** на кластеры. Давайте попробуем переформулировать целевую функцию так, что бы записать ее в виде одной формулы, что бы легко было продифференцировать: сумма минимальных расстояний от каждого элемента множества до одного из трех центроидов. Эта формула выглядит следующим образом:
Теперь давайте найдем производную новой целевой функции:
Ну что ж, осталось выяснить чему равна производная минимума, но тут оказывается все просто: в случае если ***a***-ый центройд это действительно тот, до которого расстояние минимально от текущего элемента множества, то производная выражения равна производной квадрата расстояния по элементу вектора, в противном случае равна нулю:
#### Реализация метода
Как вы понимаете все шаги из предыдущего пункта можно выполнить, не возводя расстояние в квадрат. Так и было сделано при реализации этого метода. Метод получает в качестве параметров функцию расстояния и функцию вычисления частной производной функции расстояния между двумя векторами по компоненту второго вектора, приведу для примера «половину квадрата Евклидова расстояния» (удобно использовать т.к. производная очень проста), а так же саму функцию градиентного спуска:
**Функции расстояния**Функция расстояния
```
HalfSqEuclidian.distance <- function(u, v)
{
# Half of Squeared of Euclidian distance between two vectors
#
# Args:
# u: first vector
# v: second vector
#
# Returns:
# value of distance
return(sum((u-v)*(u-v))/2)
}
```
Функция вычисления частной производной
```
HalfSqEuclidian.derivative <- function(u, v, i)
{
# Partial derivative of Half of Squeared of Euclidian distance
# between two vectors
#
# Args:
# u: first vector
# v: second vector
# i: index of part of second vector
#
# Returns:
# value of derivative of the distance
return(v[i] - u[i])
}
```
**Метод градиентного спуска**
```
KMeans.gd <- function(k, data, distance, derivative,
accuracy = 0.1, maxIterations = 1000,
learningRate = 1,
initialCentroids = NULL, showLog = F)
{
# Gradient descent version of kmeans clustering algorithm
#
# Args:
# k: number of clusters
# data: data frame or matrix (rows are observations)
# distance: cost function / metrics
# centroid: centroid function of data
# accuracy: accuracy of calculation
# learningRate: learning rate
# initialCentroids: initizalization of centroids
# showLog: show log
n <- dim(data)[2]
c <- initialCentroids
InitNewCentroid <- function(m)
{
c <- data[sample(1:dim(data)[1], m), ]
}
if(is.null(initialCentroids))
{
c <- InitNewCentroid(k)
}
costVec <- vector()
cost <- NA
d <- NA
lastCost <- Inf
for(iter in 1:maxIterations)
{
g <- matrix(rep(NA, n*k), nrow=k, ncol=n)
#calculate distances between centroids and data
d <- matrix(rep(NA, k*dim(data)[1]), nrow=k, ncol=dim(data)[1])
for(i in 1:k)
{
d[i, ] <- apply(data, 1, FUN = function(v) {distance(v, c[i, ])})
}
#calculate cost
cost <- 0
for(i in 1:dim(data)[1])
{
cost <- cost + min(d[, i])
}
if(showLog)
{
print(paste("Iter: ", iter,"; Cost = ", cost, sep=""))
}
costVec <- append(costVec, cost)
#stop conditions
if(abs(lastCost - cost) < accuracy)
{
break
}
lastCost <- cost
#calculate gradients
for(a in 1:k)
{
for(b in 1:n)
{
g[a, b] <- 0
for(i in 1:dim(data)[1])
{
if(min(d[, i]) == d[a, i])
{
g[a, b] <- g[a, b] + derivative(data[i, ], c[a, ], b)
}
}
}
}
#update centroids
for(a in 1:k)
{
for(b in 1:n)
{
c[a, b] <- c[a, b] - learningRate*g[a, b]/dim(data)[1]
}
}
}
labels <- rep(NA, dim(data)[1])
for(i in 1:dim(data)[1])
{
labels[i] <- which(d[, i] == min(d[, i]))
}
return(list(
labels = labels,
cost = costVec
))
}
```
**Тестирование**
```
KMeans.gd.result <- KMeans.gd(k, m.proj, HalfSqEuclidian.distance,
HalfSqEuclidian.derivative, showLog = T)
plot(m.proj[, 1], m.proj[, 2], pch=19,
col=rainbow(k)[unclass(as.factor(KMeans.gd.result$labels))],
xlab="first", ylab="third",
main=paste(k, " clusters; KMeans.gd \n cost = ", KMeans.gd.result$cost[length(KMeans.gd.result$cost)], sep=""))
```
Давайте взглянем на результат кластеризации и убедимся что он почти идентичен.
А так выглядит динамика значения функции стоимости от итерации у обоих алгоритмов:
#### Заключение
Давайте скажем сначала пару слов о том, что же получилось в нашем тесте. Мы получили приличное разбиение двухмерного множества на три кластера, мы визуально видим что кластеры не сильно пересекаются и можно вполне строить модели для распознавания действия для каждого кластера, тем самым получится некоторая гибридная модель (один кластер содержит в основном одно действие, другой два, а третий три).
Взглянем на сложности алгоритмов при кластеризации используя Евклидово расстояние, рассмотрим только одну итерацию (анализ же количества итераций является совсем не тривиальной задачей). Обозначим за k — количество кластеров, n — размерность данных, m — количество данных (k <= m). В экстремальном случае k = m.
* EM версия: 
* GD версия: 
В общем математически то оба алгоритма стоят на одной ступени, но мы то знаем что один чуть выше.
Весь код [вы можете найти здесь](https://github.com/mephistopheies/ml-r). | https://habr.com/ru/post/188638/ | null | ru | null |
# Итак, вы хотите оптимизировать gRPC. Часть 1
Часто возникает вопрос о том, как ускорить gRPC. gRPC позволяет реализовать высокопроизводительный RPC, но не всегда понятно как достичь этого быстродействия. И я решил попытаться показать ход своих мыслей при оптимизации программ.
Рассмотрим простой сервис "ключ-значение", который используется несколькими клиентами. Сервис должен корректно работать при параллельных операциях изменения данных. Также должна быть возможность масштабирования. И, в конце концов, он должен быть быстрым. Для реализации подобного сервиса gRPC будет идеальным вариантом. Давайте посмотрим, как его реализовать.
Я написал пример [клиента и сервера](https://github.com/carl-mastrangelo/kvstore) на Java. В примере три основных класса и protobuf-файл, описывающий API:
* [KvClient](https://github.com/carl-mastrangelo/kvstore/blob/01-start/src/main/java/io/grpc/examples/KvClient.java) — имитирует пользователя сервиса "ключ-значение". Он случайным образом создает, извлекает, изменяет и удаляет ключи и значения. Размер используемых ключей и значений также определяется случайным образом, используя [экспоненциальное распределение](https://en.wikipedia.org/wiki/Exponential_distribution).
* [KvService](https://github.com/carl-mastrangelo/kvstore/blob/01-start/src/main/java/io/grpc/examples/KvService.java) — реализация сервиса "ключ-значение". Он обрабатывает запросы от клиентов. Для имитации хранения данных на диске при операциях чтения и записи добавляются небольшие задержки в 10 и 50 мс, чтобы сделать пример похожим на настоящую базу данных.
* [KvRunner](https://github.com/carl-mastrangelo/kvstore/blob/01-start/src/main/java/io/grpc/examples/KvRunner.java) — организует взаимодействие между клиентом и сервером. Это основная точка входа, запускающая процессы клиента и сервера, и ожидающая, пока клиент выполнит свою работу. Runner работает в течение 60 секунд, а затем выводит количество выполненных RPC.
* [kvstore.proto](https://github.com/carl-mastrangelo/kvstore/blob/01-start/src/main/proto/kvstore.proto) — определение Protocol Buffers нашего сервиса. Здесь описывается, что клиенты могут ожидать от сервиса. Для простоты в качестве операций мы будем использовать Create, Retrieve, Update и Delete (широко известные как CRUD). Эти операции работают с ключами и значениями, состоящими из произвольных байт. Хотя это в некоторой степени похоже на REST, но у нас остается возможность добавить более сложные операции в будущем.
[Protocol Buffers](https://developers.google.com/protocol-buffers/) можно использовать и без gRPC — это удобный способ определения интерфейсов сервисов, а также генерации клиентского и серверного кода. Генерируемый код действует как клей между логикой приложения и библиотекой gRPC. Этот gRPC-код, используемый клиентом, мы называем стабом (stub, заглушка).
### Первоначальная версия
#### Клиент
Теперь, когда мы разобрались с тем, что программа должна делать, можно начать изучать, как она это делает. Как уже упоминалось выше, клиент выполняет случайные RPC. Например, следующий код делает запрос [create](https://github.com/carl-mastrangelo/kvstore/blob/f422b1b6e7c69f8c07f96ed4ddba64757242352c/src/main/java/io/grpc/examples/KvClient.java#L80):
```
private void doCreate(KeyValueServiceBlockingStub stub) {
ByteString key = createRandomKey();
try {
CreateResponse res = stub.create(
CreateRequest.newBuilder()
.setKey(key)
.setValue(randomBytes(MEAN_VALUE_SIZE))
.build());
if (!res.equals(CreateResponse.getDefaultInstance())) {
throw new RuntimeException("Invalid response");
}
} catch (StatusRuntimeException e) {
if (e.getStatus().getCode() == Code.ALREADY_EXISTS) {
knownKeys.remove(key);
logger.log(Level.INFO, "Key already existed", e);
} else {
throw e;
}
}
}
```
Создается случайный ключ и случайное значение. Запрос отправляется на сервер, и клиент ждет ответа. Когда ответ получен, проверяется, соответствует ли он тому, что ожидалось, и если не соответствует, то бросается исключение. Несмотря на то что ключи генерируются случайным образом, они должны быть уникальны, поэтому необходимо убедиться, что ключ еще не используется. Для проверки уникальности мы отслеживаем созданные ключи, чтобы не использовать один и тот же ключ дважды. Однако вполне вероятно, что какой-то другой клиент уже создал определенный ключ, поэтому мы его логируем и идем дальше. В противном случае выбрасывается исключение.
Здесь мы используем **блокирующий** gRPC API, который отправляет запрос и ждет ответа. Это самый простой gRPC-стаб, блокирующий поток. Получается, что клиент одновременно может выполнять не более **одного** RPC.
#### Сервер
На стороне сервера запрос [обрабатывает следующий код](https://github.com/carl-mastrangelo/kvstore/blob/f422b1b6e7c69f8c07f96ed4ddba64757242352c/src/main/java/io/grpc/examples/KvService.java#L34):
```
private final Map store = new HashMap<>();
@Override
public synchronized void create(
CreateRequest request, StreamObserver responseObserver) {
ByteBuffer key = request.getKey().asReadOnlyByteBuffer();
ByteBuffer value = request.getValue().asReadOnlyByteBuffer();
simulateWork(WRITE\_DELAY\_MILLIS);
if (store.putIfAbsent(key, value) == null) {
responseObserver.onNext(CreateResponse.getDefaultInstance());
responseObserver.onCompleted();
return;
}
responseObserver.onError(Status.ALREADY\_EXISTS.asRuntimeException());
}
```
Сервис извлекает из запроса ключ и значение как `ByteBuffer`. И для контроля, что одновременные запросы не повредят хранилище, метод объявлен как `synchronized`. После имитации записи на диск данные сохраняются в `Map`.
В отличие от клиентского кода, серверный обработчик является **неблокирующим**. Для отправки ответа вызывается `onNext()` у `responseObserver`. Для завершения отправки сообщения вызывается `onCompleted()`.
#### Производительность
Код выглядит корректным и безопасным — давайте посмотрим, как он работает. Я использую компьютер с Ubuntu, 12-ти ядерным процессором и 32 ГБ памяти. Давайте выполним сборку и запустим:
```
$ ./gradlew installDist
$ time ./build/install/kvstore/bin/kvstore
Feb 26, 2018 1:10:07 PM io.grpc.examples.KvRunner runClient
INFO: Starting
Feb 26, 2018 1:11:07 PM io.grpc.examples.KvRunner runClient
INFO: Did 16.55 RPCs/s
real 1m0.927s
user 0m10.688s
sys 0m1.456s
```
Ну и дела! На такой мощной машине только 16 RPC в секунду. Процессор почти не используется, и мы не знаем, сколько потреблялось памяти. Давайте выяснять, почему получился такой плохой результат.
### Оптимизация
#### Анализ
Прежде чем вносить какие-либо изменения, давайте разберемся, что делает программа. Нам нужно выяснить, где код тратит свое время, чтобы понять что необходимо оптимизировать. На этом этапе инструменты профилирования пока не нужны, мы можем просто проанализировать код.
Клиент запускается и последовательно выполняет RPC примерно в течение минуты. На каждой итерации он [случайным образом решает](https://github.com/carl-mastrangelo/kvstore/blob/f422b1b6e7c69f8c07f96ed4ddba64757242352c/src/main/java/io/grpc/examples/KvClient.java#L49), какую операцию выполнить:
```
void doClientWork(AtomicBoolean done) {
Random random = new Random();
KeyValueServiceBlockingStub stub = KeyValueServiceGrpc.newBlockingStub(channel);
while (!done.get()) {
// Pick a random CRUD action to take.
int command = random.nextInt(4);
if (command == 0) {
doCreate(stub);
continue;
}
/* ... */
rpcCount++;
}
}
```
Это означает, что **одновременно может выполняться не более одного RPC**. Каждый вызов должен ждать завершения предыдущего. А сколько времени занимает каждый RPC? После изучения кода сервера мы видим, что самая тяжелая операция занимает около 50 мс. При максимальной эффективности получится выполнить только 20 запросов в секунду:
20 запросов = 1000 мс / (50 мс / запрос)
Наш код может выполнять около 16 запросов в секунду, что кажется правдой. Мы можем проверить это предположение, посмотрев на вывод команды `time`, используемой для запуска кода. При выполнении запросов в методе [simulateWork](https://github.com/carl-mastrangelo/kvstore/blob/f422b1b6e7c69f8c07f96ed4ddba64757242352c/src/main/java/io/grpc/examples/KvService.java#L88) сервер просто спит (sleep). Получается, что программа в основном простаивает, ожидая завершения RPC.
Можно подтвердить это, посмотрев выше на реальное время выполнения между стартом и завершением (real) и на время использования процессора (user). Прошла одна минута, но процессор потратил только 10 секунд. Мой мощный многоядерный процессор был занят только 16% времени. Таким образом, если заставить программу выполнять больше работы в течение этого времени, то, похоже, можно увеличить количество RPC.
#### Гипотеза
Теперь мы четко видим проблему и можем предложить решение. Один из способов ускорить работу — убедиться, что процессор не простаивает. Для этого мы будем выполнять работу параллельно.
В gRPC-библиотеке для Java есть три типа стабов: блокирующие, неблокирующие и `ListenableFuture`. Мы уже видели блокирующий в клиенте и неблокирующий на сервере. ListenableFuture API — это компромисс между ними, предлагающий как блокирующее, так и не блокирующее поведение. До тех пор, пока мы не блокируем поток, ожидающий завершения работы, мы можем запускать новые RPC, не дожидаясь завершения старых.
#### Эксперимент
Для проверки нашей гипотезы давайте используем в клиенте `ListenableFuture`. А это значит, что теперь нам надо больше думать о конкурентности в коде. Например, при отслеживании используемых ключей на клиенте нам нужно безопасно читать, изменять и записывать ключи. Также необходимо убедиться, что в случае ошибки мы прекратим выполнять новые RPC (правильная обработка ошибок будет рассмотрена в следующем посте). Наконец, нам нужно увеличить счетчик выполненных RPC и не забыть, что RPC выполняются в разных потоках.
Все эти изменения усложняют код. Но это компромисс, на который мы идем для улучшения производительности. Часто простота кода противоречит оптимизации. Тем не менее приведенный ниже код по-прежнему вполне читабельный и поток выполнения идет сверху вниз. Вот исправленный метод [doCreate()](https://github.com/carl-mastrangelo/kvstore/blob/f0113912c01ac4ea48a80bb7a4736ddcb3f21e24/src/main/java/io/grpc/examples/KvClient.java#L92):
```
private void doCreate(KeyValueServiceFutureStub stub, AtomicReference error) {
ByteString key = createRandomKey();
ListenableFuture res = stub.create(
CreateRequest.newBuilder()
.setKey(key)
.setValue(randomBytes(MEAN\_VALUE\_SIZE))
.build());
res.addListener(() -> rpcCount.incrementAndGet(), MoreExecutors.directExecutor());
Futures.addCallback(res, new FutureCallback() {
@Override
public void onSuccess(CreateResponse result) {
if (!result.equals(CreateResponse.getDefaultInstance())) {
error.compareAndSet(null, new RuntimeException("Invalid response"));
}
synchronized (knownKeys) {
knownKeys.add(key);
}
}
@Override
public void onFailure(Throwable t) {
Status status = Status.fromThrowable(t);
if (status.getCode() == Code.ALREADY\_EXISTS) {
synchronized (knownKeys) {
knownKeys.remove(key);
}
logger.log(Level.INFO, "Key already existed", t);
} else {
error.compareAndSet(null, t);
}
}
});
}
```
Стаб был изменен на `KeyValueServiceFutureStub`, который создает `Future` вместо прямого возврата значения. В gRPC Java используется `ListenableFuture`, который позволяет добавить обратный вызов при завершении `Future`. Здесь нас не сильно беспокоит ответ. Нас больше волнует, выполнился RPC или нет. Поэтому код в основном обрабатывает ошибки, а не ответ.
Первое изменение в том как мы считаем количество RPC. Вместо того чтобы увеличивать счетчик в основном цикле, мы увеличиваем его по завершении RPC.
Далее для каждого RPC мы создаем новый объект, который обрабатывает как успешные, так и неудачные попытки. Так как `doCreate()`уже завершится к моменту запуска метода обратного вызова после выполненного RPC, нам нужен способ распространения ошибок, отличный от throw. Вместо этого мы пытаемся обновить ссылку атомарно. Основной цикл время от времени проверяет, не произошла ли ошибка, и останавливается при ее обнаружении.
И, наконец, в коде добавляется ключ в `knownKeys` только тогда, когда RPC действительно завершен, и удаляется тогда, когда известно, что произошел сбой. Мы синхронизируемся на переменной, чтобы убедиться, что два потока не конфликтуют. Примечание: хотя доступ к `knownKeys` потокобезопасный, но вероятность возникновения [состояния гонки](https://en.wikipedia.org/wiki/Race_condition) остается. Один поток может прочитать из `knownKeys`, потом второй удалить из `knownKeys`, а потом первый может выполнить RPC, используя прочитанный ключ. Синхронизация на ключах гарантирует только согласованность, но не их правильность. Исправление этого выходит за рамки данного поста, поэтому мы просто логируем это и двигаемся дальше. Вы увидите несколько таких сообщений в логе, когда запустите программу.
#### Запускаем код
Если вы запустите эту программу, то увидите, что она не работает:
```
WARNING: An exception was thrown by io.grpc.netty.NettyClientStream$Sink$1.operationComplete()
java.lang.OutOfMemoryError: unable to create new native thread
at java.lang.Thread.start0(Native Method)
at java.lang.Thread.start(Thread.java:714)
...
```
Что?! Зачем я показываю вам код, который не работает? Обычно в реальной жизни с первой попытки ничего не работает. В данном случае не хватило памяти. А когда программе не хватает памяти, начинают происходить странные вещи. И часто первопричину найти довольно трудно, так как бывает много сбивающих с толку моментов. Сообщение об ошибке говорит: "unable to create new native thread" (не удалось создать новый нативный поток), хотя мы не создавали никаких новых потоков. В устранении подобных проблем мне очень помогает опыт, а не отладка. Я часто встречался с OOM и понял, что Java говорит нам о последней капле, переполнившей чашу. Наша программа начала использовать много памяти и последнее выделение памяти, которое не удалось выполнить, случайно произошло при создании потока.
Итак, что же случилось? В блокирующей версии очередной RPC не запускался, пока не завершался предыдущий. Это было медленно, но это и помогало нам не создать тонны RPC, для которых у нас в итоге не хватило памяти. Мы должны учесть это в версии с `ListenableFuture`.
Для решения этой проблемы можно реализовать ограничение на количество активных RPC. Перед запуском нового RPC мы постараемся получить разрешение. Если мы его получаем, то выполняем RPC. Если нет, то ждем, пока оно не станет доступным. Когда RPC завершится (успешно или неудачно), разрешение возвращается. Для этого мы будем [использовать семафор (Semaphore)](https://github.com/carl-mastrangelo/kvstore/blob/02-future-client/src/main/java/io/grpc/examples/KvClient.java#L94):
```
private final Semaphore limiter = new Semaphore(100);
private void doCreate(KeyValueServiceFutureStub stub, AtomicReference error)
throws InterruptedException {
limiter.acquire();
ByteString key = createRandomKey();
ListenableFuture res = stub.create(
CreateRequest.newBuilder()
.setKey(key)
.setValue(randomBytes(MEAN\_VALUE\_SIZE))
.build());
res.addListener(() -> {
rpcCount.incrementAndGet();
limiter.release();
}, MoreExecutors.directExecutor());
/\* ... \*/
}
```
Теперь код работает успешно и память не заканчивается.
#### Результаты
После внесенных изменений все выглядит намного лучше:
```
$ ./gradlew installDist
$ time ./build/install/kvstore/bin/kvstore
Feb 26, 2018 2:40:47 PM io.grpc.examples.KvRunner runClient
INFO: Starting
Feb 26, 2018 2:41:47 PM io.grpc.examples.KvRunner runClient
INFO: Did 24.283 RPCs/s
real 1m0.923s
user 0m12.772s
sys 0m1.572s
```
Наш код выполняет на **46%** больше RPC в секунду, чем раньше. Также мы видим, что используется примерно на 20% больше процессора. Наша гипотеза оказалась верной, и внесенные изменения сработали. И при этом мы не делали никаких изменений на сервере. А также не использовали какие-то специальные профилировщики или трассировщики.
Есть ли смысл в этих цифрах? Мы ожидаем, что примерно 1/4 операций будут мутабельными (create, update и delete). И чтение также будет в 1/4 случаях. Среднее время RPC должно быть примерно равно средневзвешенному значению:
```
.25 * 50ms (create)
.25 * 10ms (retrieve)
.25 * 50ms (update)
+.25 * 50ms (delete)
------------
40ms
```
При среднем значении в 40 мс на один RPC мы ожидаем, что количество RPC в секунду будет:
25 запросов = 1000 мс / (40 мс / запрос)
Это примерно то, что мы и видим. Но сервер по прежнему обрабатывает запросы последовательно, поэтому в будущем нам предстоит еще поработать над ним. Хотя на данный момент наша оптимизация, похоже, сработала.
### Выводы
Есть много способов оптимизировать gRPC-код. Для этого необходимо понимать, что ваш код делает и что он должен делать. В этом посте показаны только самые основы того, как подходить к оптимизации. Всегда измеряйте производительность до и после внесения изменений и используйте эти измерения как руководство для оптимизации.
---
> *Перевод статьи подготовлен в преддверии старта курса* [*Java Developer. Basic*](https://otus.pw/tkit/)*. Приглашаем всех желающих посетить* [*бесплатный вебинар*](https://otus.pw/tkit/)*, в рамках которого наши эксперты расскажут о карьерных перспективах после прохождения курса, а также ответят на интересующие вас вопросы.*
>
> [***Записаться на вебинар.***](https://otus.pw/tkit/)
>
> | https://habr.com/ru/post/546142/ | null | ru | null |
# «Выстрелить и забыть» в Cats Effect
Последнее время меня часто спрашивают о паттерне "fire-and-forget": как его применить в Cats Effect и какие потенциальные проблемы могут возникнуть. Поэтому я решил написать небольшой пост. Надеюсь, вам понравится!
Подробнее о Cats Effect и конкурентности читайте в моей книге [Essential Effects](https://essentialeffects.dev/).
### Что значит «выстрелить и забыть»?
Чтобы понять принцип «выстрелить и забыть» (fire-and-forget), давайте сначала посмотрим на простой синхронный вызов метода или функции. При синхронной операции мы вызываем функцию и ожидаем, когда она вернет значение. Вычисления продолжаем только после получения результата.
```
def doSomething(i: Int): String = {
println(s"[${Thread.currentThread.getName}] doSomething($i)")
s"$i is a very nice number"
}
def doSomethingElse(): Int = {
println(s"[${Thread.currentThread.getName}] doSomethingElse()")
12
}
val doBoth = {
val result = doSomething(12)
println(s"[${Thread.currentThread.getName}] doSomething(12) produced: $result")
doSomethingElse
}
```
Обратите внимание: все `println` выполняются в одном потоке.
Теперь давайте разбираться с «выстрелить и забыть». Что значит «выстрелить»? Выстрелить — это запустить вычисление без ожидания результата, т.е. асинхронно. (Название «выстрелить и забыть» пришло от военных — запуск ракеты.)
Какая должна быть сигнатура типа для такой асинхронной операции? Она требует входные данные, и сразу же возвращает управление в точку вызова. Но здесь мы не получаем «фактический» результат вычисления — только сообщаем: «Вычисления запущены, вот вам некое значение, которое позволит получить конечный результат, когда он будет вычислен». Смоделируем это в виде трейта с методом fire, который возвращает «конечный результат» `EventualResult` (в виде функции):
```
trait Asynchronous {
type EventualResult[A] = () => A
def fire[A](run: => A): EventualResult[A]
}
```
Этот интерфейс можно реализовать, используя тип `Future`:
```
object Asynchronous {
import scala.concurrent._
import scala.concurrent.duration._
val global =
new Asynchronous {
implicit val ec = scala.concurrent.ExecutionContext.global
def fire[A](run: => A): EventualResult[A] = {
val res = Promise[A].completeWith(Future(run)) // start the computation
() => Await.result(res.future, Duration.Inf) // wait on demand
}
}
}
```
Затем преобразуем наш синхронный код для использования интерфейса `Asynchronous`:
```
val doBothAsync = {
val await = Asynchronous.global.fire(doSomething(12))
val result = await()
println(s"[${Thread.currentThread.getName}] doSomething(12) produced: $result")
doSomethingElse
}
```
Обратите внимание, что `println` в `doSomething` и `doSomethingElse` выполняются в разных потоках.
Теперь нам нужно "забыть" (forget). То есть после того, как мы начали вычисление (fire), мы ничего не делаем для обработки конечного результата. Мы "забываем" (forget) его:
```
trait Asynchronous {
type EventualResult[A] = () => A
def fire[A](run: => A): EventualResult[A]
def fireAndForget[A](run: => A): Unit =
fire(run) // игнорируем результат
}
```
```
object Asynchronous {
import scala.concurrent.
import scala.concurrent.duration.
val global =
new Asynchronous {
implicit val ec = scala.concurrent.ExecutionContext.global
def fire[A](run: => A): EventualResult[A] = {
val res = PromiseA.completeWith(Future(run)) // старт вычисления
() => Await.result(res.future, Duration.Inf) // ожидание
}
}
}
```
Метод `fireAndForget` вызывает метод `fire`, запускающий асинхронное вычисление, но игнорирующий возвращаемый `EventualResult`. То есть мы вообще не ждем никакого результата.
Давайте обновим наш пример:
```
val doBothFireAndForget = {
Asynchronous.global.fireAndForget(doSomething(12))
doSomethingElse
}
```
Обратите внимание, что здесь такое же асинхронное выполнение, как и в примере с "только fire", но мы не выводим никаких промежуточных результатов, потому что решили их не ждать.
### Используем Cats Effect
Для реализации паттерна "выстрелить и забыть" в Cats Effect необходимо выполнить следующее:
1. Определить синхронное вычисление как эффект.
2. Запустить выполнение эффекта асинхронно ("выстрелить").
3. Игнорировать возвращаемое значение ("забыть").
Давайте сделаем это:
```
import cats.effect._
import cats.implicits._
class Something extends IOApp {
def run(args: List[String]): IO[ExitCode] =
doBoth.as(ExitCode.Success)
def doSomething(i: Int): IO[String] = // <1>
for {
_ <- IO(println(s"[${Thread.currentThread.getName}] doSomething($i)"))
} yield s"$i is a very nice number"
def doSomethingElse(): IO[Int] =
for {
_ <- IO(println(s"[${Thread.currentThread.getName}] doSomethingElse()"))
} yield 12
val doBoth: IO[Int] =
for {
_ <- doSomething(12).start // <2> <3>
i <- doSomethingElse
} yield i
}
new Something().main(Array.empty)
```
1. Мы изменили тип возвращаемого значения со `String` на `IO[String]`, чтобы определить (синхронный) эффект.
2. И запустили эффект IO асинхронно с помощью start. Он возвращает тип `IO[Fiber[IO, String]]` (`Cats Effect 3 — IO[FiberIO[String]]`), который позволяет управлять асинхронным выполнением и получением конечного результата.
3. Мы также игнорируем `Fiber`, созданный `start`, "анонимизируя" его имя как *.*
### Безопасно ли «забыть»?
Когда мы "стреляли и забывали" с помощью Cats Effect, мы намеренно не отслеживали асинхронную операцию. Но безопасно ли это?
Чтобы ответить на этот вопрос, давайте вспомним, какие операции есть у файбера: можно дождаться его завершения (с помощью `join`) или отменить (с помощью `cancel`). Поскольку мы ожидаем асинхронного выполнения, то `join` нам не нужен, и мы поговорим о `cancel`. Потребуется ли нам когда-нибудь отменять вычисление, которое мы "запустили и забыли"?
Несомненно, нам это пригодится! Задача может быть очень долгоживущей. Например, цикл обработки событий. Здесь вы можете подумать: "О, этот эффект выполняется вечно, его не нужно отменять", поэтому просто "выстрелим и забудем". Но отмена может потребоваться! Асинхронный эффект существует в некотором контексте и важно убедиться, что он отменяется при отмене его "родительского" контекста:
```
val businessLogic =
for {
_ <- longLivedEffect.start
_ <- doSomeOtherStuff
} yield ()
```
В этом примере после завершения `businessLogic`, возможно, стоит отменить и `longLivedEffect`, но подход "выстрелить и забыть" исключает такую возможность. Нам нужно как-то связать время жизни этого долгоживущего эффекта с окружающей бизнес-логикой. Один из вариантов — использовать `guarantee`:
```
val businessLogic =
for {
fiber <- longLivedEffect.start
_ <- doSomeOtherStuff.guarantee(fiber.cancel) // <1>
} yield ()
```
1. Отмена файбера при успешном завершении дополнительной бизнес-логики, а также при ошибке или отмене.
Но использование guarantee не масштабируется на несколько эффектов. Например, мы хотим, чтобы файбер отменялся, если отменяется какой-либо эффект внутри `businessLogic`. В такой ситуации мы можем использовать [Resource](https://typelevel.org/cats-effect/docs/std/resource). Resource — структура, которая управляет аллокацией и деаллокацией ресурсов:
```
val longLived: Resource[IO, IO[Unit]] =
longLivedEffect.background // <1>
val businessLogic =
longLived.use { join => // <2>
doSomeOtherStuff
}
```
1. Вместо `start` мы используем метод `background`, возвращающий `Resource`, который управляет асинхронным файбером. Управляемое состояние само по себе является действием `IO[Unit]`, которое позволяет вам при необходимости выполнить join к нижележащему файберу.
2. Используя `Resource` через `use`, мы получаем доступ к управляемому состоянию, где можем выполнять другие эффекты. Он определяет статическую область, в которой доступно состояние, при этом за пределами этой области гарантируется корректное получение и освобождение состояния. В случае ресурса, возвращаемого `background`, эффект получения состояния — это "запуск файбера", а эффект освобождения — "отмена файбера".
### Резюме
Паттерн «выстрелить и забыть» (fire-and-forget) состоит из трех частей:
1. Определение синхронного эффекта.
2. Асинхронный запуск эффекта.
3. Контроль асинхронного выполнения эффекта: ожидание результата или отмена.
Вы можете смело запускать и забывать короткоживущие асинхронные эффекты! Но помните, что выполнение всегда происходит в каком-то контексте, и у вас есть такие методы, как `background`, для контроля асинхронного жизненного цикла.
---
> Материал подготовлен в рамках курса [«Scala-разработчик».](https://otus.pw/uNPB/)
>
> Всех желающих приглашаем на demo-занятие **«Scala и парсер-комбинаторы»**. На занятии мы:
> — Познакомимся с парсер-комбинаторами на Scala;
> — Будем парсить описание REST API написанное с помощью markdown.
> [>> РЕГИСТРАЦИЯ](https://otus.pw/BfMJ/)
>
> | https://habr.com/ru/post/589297/ | null | ru | null |
# Alljoyn: взгляд embedded разработчика. Часть 3: Портируем на МК SAMD21
В [предыдущих статьях](https://habrahabr.ru/company/rainbow/blog/273859/) мы разбирались с основами Alljoyn и средствами, помогающими отладке. Пришло время писать код для микроконтроллера. Кратко напомню архитектуру LSF (Lighting Software Framework).
В библиотеке LSF предусмотрено три сущности:
* Thin-лампочка (lamp service),
* Router (lighting controller service),
* «приложение» (lighting sample application).
Thin-лампочка это та часть, которая «крутится» непосредственно в микроконтроллере нашей умной лампочки. Именно ею мы сегодня и займемся. Остальное было весьма подробно описано ранее, очередной раз останавливаться не будем.
Главное, чтобы все действующие лица были в одной локальной сети, а Router был «правильный» (см. [первую часть цикла](https://habrahabr.ru/company/rainbow/blog/273859/)).
##### Наша конфигурация оборудования
В роли «лампочки» (физически) выступает отладочная плата с [samd21](http://www.atmel.com/tools/ATSAMD21-XPRO.aspx?tab=overview) и [wifi модулем winc 1500](http://www.atmel.com/tools/ATWINC1500-XPRO.aspx), в роли Router'а — программа в Ubuntu **lighting controller service**. В качестве управляющего приложения будем использовать sample app LSF на телефоне Android, которое можно скачать с сайта Allseen альянса со страницы соответствующей [рабочей группы](https://wiki.allseenalliance.org/tsc/connected_lighting).
Код для нашей отладки писался на базе кода для arduino (Thin Core) и открытого кода на [гитхабе для «лампочки»](https://git.allseenalliance.org/cgit/lighting/service_framework.git/tree/thin_core_library/lamp_service?id=v15.04). Как нам тогда казалось, это наиболее близкий к чистому Си и отсутствию операционки пример. Но как позже выяснилось, этот код во многом не доделан и не выполняет даже базовые функции Thin устройства. Так что доделывать/переделывать пришлось много.
Весь код делится на 3 части: поддержка Thin Core Alljoyn, поддержка «лампы» LSF, и все остальное (hal уровень, собственные функции).
##### Код для Thin Core
Первое, что нужно сделать, это реализовать hal уровень для возможности выхода в сеть. У нас он заключается в поднятии соединения по UDP (для первичного обнаружения Thin устройства в сети Alljoyn с помощью mdns), отправке/приеме данных по UDP, а также поднятии соединения по TCP и приеме/отправки данных для основного общения в сети.
Все эти функции прописываются в файле aj\_net.с.
Основной проблемой было то, что функции взаимодействия с сетью в arduino работают по флагу, а в библиотеке для winc по прерыванию, а также для работы библиотеки для winc обязателен постоянный вызов вспомогательной функции опроса флагов, выставляемых модулем. Подробно про работу с winc1500 мы писали в одной из наших предыдущих [статей](https://habrahabr.ru/company/rainbow/blog/275359/).
Начать модифицировать hal уровень проще всего с функций установки соединения по UDP и TCP. В них надо прописать необходимые строки для установления непосредственно соединения и настроить структуру, соответствующую соединению: указать функции приема/передачи и буферы приема/передачи.
**Код для UDP (соединение устанавливается в main)**
```
AJ_Status AJ_Net_MCastUp(AJ_NetSocket* netSock)
{
uint8_t ret = 1;
if (ret != 1)
{
return AJ_ERR_READ;
}
else
{
netSock->rx.bufStart = udp_data_rx;
netSock->rx.bufSize = sizeof(udp_data_rx);
netSock->rx.readPtr = udp_data_rx;
netSock->rx.writePtr = udp_data_rx;
netSock->rx.direction = AJ_IO_BUF_RX;
netSock->rx.recv = AJ_Net_RecvFrom;
netSock->tx.bufStart = udp_data_tx;
netSock->tx.bufSize = sizeof(udp_data_tx);
netSock->tx.readPtr = udp_data_tx;
netSock->tx.writePtr = udp_data_tx;
netSock->tx.direction = AJ_IO_BUF_TX;
netSock->tx.send = AJ_Net_SendTo;
}
return AJ_OK;
}
int main(void)
{
...
// Initialize socket address structure.
addr.sin_family = AF_INET;
addr.sin_port = _htons(MAIN_WIFI_M2M_SERVER_PORT);
addr.sin_addr.s_addr = _htonl(MAIN_WIFI_M2M_SERVER_IP);
src_addr.sin_family = AF_INET;
src_addr.sin_port = _htons(MAIN_WIFI_M2M_SERVER_PORT);
//_htons(52148);
src_addr.sin_addr.s_addr = _htonl(MAIN_WIFI_M2M_SERVER_IP);
// Initialize Wi-Fi parameters structure.
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
// Initialize Wi-Fi driver with data and status callbacks.
param.pfAppWifiCb = wifi_cb;
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret)
{
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1);
}
// Initialize socket module
socketInit();
registerSocketCallback(socket_cb, NULL);
// Connect to router.
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
printf("m2m_wifi_connect!\r\n");
...
}
```
**Код для TCP**
```
AJ_Status AJ_Net_Connect(AJ_BusAttachment* bus, const AJ_Service* service)
{
int ret;
if (!(service->addrTypes & AJ_ADDR_TCP4))
{
return AJ_ERR_CONNECT;
}
printf("AJ_Net_Connect()\n");
addr.sin_port = _htons(service->ipv4port);
addr.sin_addr.s_addr = _htonl(service->ipv4);
printf("AJ_Net_Connect(): ipv4= %x, port = %d\n",addr.sin_addr.s_addr, addr.sin_port);
tcp_client_socket = socket(AF_INET, SOCK_STREAM, 0);
ret=connect(tcp_client_socket, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
printf("AJ_Net_Connect(): connect\n");
while(tcp_ready_to_send==0)
{
m2m_wifi_handle_events(NULL);
}
printf("AJ_Net_Connect(): connect OK\n");
if (ret == -1)
{
return AJ_ERR_CONNECT;
}
else
{
bus->sock.rx.bufStart = AJ_in_data_tcp;
bus->sock.rx.bufSize = sizeof(AJ_in_data_tcp);
bus->sock.rx.readPtr = AJ_in_data_tcp;
bus->sock.rx.writePtr = AJ_in_data_tcp;
bus->sock.rx.direction = AJ_IO_BUF_RX;
bus->sock.rx.recv = AJ_Net_Recv;
bus->sock.tx.bufStart = tcp_data_tx;
bus->sock.tx.bufSize = sizeof(tcp_data_tx);
bus->sock.tx.readPtr = tcp_data_tx;
bus->sock.tx.writePtr = tcp_data_tx;
bus->sock.tx.direction = AJ_IO_BUF_TX;
bus->sock.tx.send = AJ_Net_Send;
printf("AJ_Net_Connect(): connect() success: status=AJ_OK\n");
return AJ_OK;
}
printf("AJ_Net_Connect(): connect() failed: %d: status=AJ_ERR_CONNECT\n", ret);
return AJ_ERR_CONNECT;
}
```
По UDP нам нужно фактически только отправлять mdns запросы и получать ответ на них. При получении посылки проверяется есть ли что-то на отправку. Если да, то отправляется, после чего вызывается вспомогательная функция обработки флагов. Если флаг успешной отправки установлен (он устанавливается в callback'е), то функция завершает свою работу успешно, иначе возвращает ошибку записи.
```
AJ_Status AJ_Net_SendTo(AJ_IOBuffer* buf)
{
int ret;
uint32_t tx = AJ_IO_BUF_AVAIL(buf);
if (tx > 0)
{
ret = sendto(rx_socket, buf->readPtr, tx, 0, (struct sockaddr *)&addr, sizeof(addr));
m2m_wifi_handle_events(NULL);
if (sock_tx_state != 1)
{
return AJ_ERR_WRITE;
}
buf->readPtr += ret;
}
AJ_IO_BUF_RESET(buf);
return AJ_OK;
}
```
При приеме в цикле с выходом по тайм-ауту или получении посылки вызывается обработчик приема и вспомогательная функция обработки флагов. Знатоки arduino заметят, что я использую функцию millis (она была переписана в соответствии с нашими реалиями). Если выход из цикла ожидания посылки произошел по тайм-ауту, то возвращается ошибка чтения, иначе статус AJ\_OK.
```
AJ_Status AJ_Net_RecvFrom(AJ_IOBuffer* buf, uint32_t len, uint32_t timeout)
{
AJ_Status status = AJ_OK;
int ret;
uint32_t rx = AJ_IO_BUF_SPACE(buf);
unsigned long Recv_lastCall = millis();
while ((sock_rx_state==0) && (millis() - Recv_lastCall < timeout))
{
recv(rx_socket, udp_data_rx, MAIN_WIFI_M2M_BUFFER_SIZE, 0);
m2m_wifi_handle_events(NULL);
}
ret=sock_rx_state;
if (ret == -1)
{
printf("AJ_Net_RecvFrom(): read() fails. status=AJ_ERR_READ\n");
status = AJ_ERR_READ;
}
else
{
if (ret != -1)
{
AJ_DumpBytes("AJ_Net_RecvFrom", buf->writePtr, ret);
}
buf->writePtr += ret;
status = AJ_OK;
}
printf("AJ_Net_RecvFrom(): status=%s\n", AJ_StatusText(status));
return status;
}
```
Теперь перейдем к реализации приема/передачи по TCP. Передача мало чем отличается от передачи по UDP.
```
AJ_Status AJ_Net_Send(AJ_IOBuffer* buf)
{
uint32_t ret;
uint32_t tx = AJ_IO_BUF_AVAIL(buf);
printf("AJ_Net_Send(buf=0x%p)\n", buf);
if (tx > 0)
{
send(tcp_client_socket, buf->readPtr, tx, 0);
buf->readPtr += tcp_tx_ready;
tcp_tx_ready=0;
}
AJ_IO_BUF_RESET(buf);
return AJ_OK;
}
```
А вот с приемом все немного интереснее. Общий подход, конечно, такой же, как в UDP, но в исходных кодах была еще куча проверок, разобраться, что они там делают и насколько они нужны мне не удалось, поэтому в большинстве оставила тот код.
**Прием по TCP**
```
AJ_Status AJ_Net_Recv(AJ_IOBuffer* buf, uint32_t len, uint32_t timeout)
{
AJ_Status status = AJ_ERR_READ;
uint32_t ret;
uint32_t rx = AJ_IO_BUF_SPACE(buf);
uint32_t recvd = 0;
unsigned long Recv_lastCall = millis();
// first we need to clear out our buffer
uint32_t M = 0;
if (rxLeftover != 0)
{
// there was something leftover from before,
M = min(rx, rxLeftover);
memcpy(buf->writePtr, rxDataStash, M); // copy leftover into buffer.
buf->writePtr += M; // move the data pointer over
memmove(rxDataStash, rxDataStash + M, rxLeftover - M); // shift left-overs toward the start.
rxLeftover -= M;
recvd += M;
// we have read as many bytes as we can
// higher level isn't requesting any more
if (recvd == rx)
{
return AJ_OK;
}
}
if ((M != 0) && (rxLeftover != 0))
{
printf("AJ_Net_REcv(): M was: %d, rxLeftover was: %d\n", M, rxLeftover);
}
while ((tcp_rx_ready==0) && (millis() - Recv_lastCall < timeout))
{
recv(tcp_client_socket, tcp_data_rx, sizeof(tcp_data_rx), 0);
m2m_wifi_handle_events(NULL);
}
if (tcp_rx_ready==0)
{
printf("AJ_Net_Recv(): timeout. status=AJ_ERR_TIMEOUT\n");
status = AJ_ERR_TIMEOUT;
}
else
{
memcpy(AJ_in_data_tcp, tcp_data_rx,tcp_rx_ready);
uint32_t askFor = rx;
askFor -= M;
ret=tcp_rx_ready;
if (askFor < ret)
{
printf("AJ_Net_Recv(): BUFFER OVERRUN: askFor=%u, ret=%u\n", askFor, ret);
}
if (ret == -1)
{
printf("AJ_Net_Recv(): read() failed. status=AJ_ERR_READ\n");
status = AJ_ERR_READ;
}
else
{
AJ_DumpBytes("Recv", buf->writePtr, ret);
if (ret > askFor)
{
printf("AJ_Net_Recv(): new leftover %d\n", ret - askFor);
// now shove the extra into the stash
memcpy(rxDataStash + rxLeftover, buf->writePtr + askFor, ret - askFor);
rxLeftover += (ret - askFor);
buf->writePtr += rx;
}
else
{
buf->writePtr += ret;
}
status = AJ_OK;
}
}
tcp_rx_ready=0;
return status;
}
```
Еще один важный момент — LocalGUID — уникальный идентификатор устройства (см. [вторую часть статьи](https://habrahabr.ru/company/rainbow/blog/278845/)), который мы честно позаимствовали (с небольшими изменениями) у лампочки, реализованной на линуксе.
Одно из важных исправлений: в исходном коде в запросе mdns ip адрес лампочки задается явно. Если вы не хотите переписывать его у каждого устройства ручками, то надо добавить считывание присвоенного ip адреса (мы будем использовать dhcp для получения адреса в сети) и его запись в пакет. Это делается в файле: aj\_disco.c в функции: ComposeMDnsReq(...).
##### Код для «лампочки»
Приступаем к реализации самой «лампочки» в терминах LSF. Для индикации работы как лампочки будем использовать пользовательский светодиод на отладочной плате. Соответственно в железе у нас будет реализована только возможность включать/выключать светодиод.
В ходе реализации этой части программы было сделано достаточно много изменений, которые «заставили» ее работать. Перечислять их все здесь не будем, отметим только важные моменты.
HAL уровень работы с «лампочкой» мы реализовали в функции **OEM\_LS\_TransitionStateFields**, файл **OEM\_LS\_Code.c**. Можно было это сделать менее локально, но так как hal уровень поддерживает только включение/выключение, не стали тратить на это много сил и времени.
```
LampResponseCode OEM_LS_TransitionStateFields(LampStateContainer* newStateContainer, uint64_t timestamp, uint32_t transitionPeriod)
{
//OEMs should do the following operations just before transitioning the state
LampState state;
/* Retrieve the current state of the Lamp */
LAMP_GetState(&state);
/* Update the requisite fields to new values */
if (newStateContainer->stateFieldIndicators & LAMP_STATE_ON_OFF_FIELD_INDICATOR)
{
state.onOff = newStateContainer->state.onOff;
printf("%s: Updating OnOff to %u\n", __func__, state.onOff);
printf("----------------state.onOff=%d-----------------------\n",state.onOff);
if (state.onOff==1)
{
port_pin_set_output_level(LED_0_PIN, LED_0_ACTIVE);
}
else
{
port_pin_set_output_level(LED_0_PIN, LED_0_INACTIVE);
}
}
...
}
```
Если хочется поменять название компании производителя устройства, имя устройства, поддерживаемые языки и другие параметры, то нужно изменить соответствующие строки в начале файла **OEM\_LS\_Provisioning.c**.
Все настройки изначально берутся и при изменении записываются в некую NVRAM. Как это реализовать в нашем случае, мы не придумали, поэтому везде где использовалась запись/чтение из NVRAM мы изменили код на работу в наших реалиях.
Перечислить все «грабли», на которые мы наступали просто невозможно (были и тупиковые ветви, часть забылась). Поэтому мы упомянули о главных и способах их «отлова» — брать заведомо работающие приложения (например под linux), и смотреть в WireShark обмен, который пытаться повторить.
Но когда все «грабли» пройдены, работающая система вызывает умиление своей продуманностью и, собственно работой (наконец-то!). Посмотреть можно на видео в начале статьи.
Код проекта выложен на [гитхаб](https://github.com/marus-ka/alljoyn_lsf_lamp) | https://habr.com/ru/post/278363/ | null | ru | null |
# Создаем TimePicker аналогичный стандартному в Harmattan
Этот пост участвует в конкурсе „[Умные телефоны за умные посты](http://habrahabr.ru/company/Nokia/blog/132522/)“
Слева на картинке вы можете увидеть, как выглядит *TimePicker* (компонент настройки времени) в стандартных приложениях *MeeGo Harmattan* от *Nokia*. А справа *TimePicker* из *MeeGo Qt Components (Extras)*, который предлагается разработчикам для использования. Различия на лицо.
Определенно, становится ясно, что существует некая несправедливость, потому что используемый Nokia компонент недоступен разработчикам сторонних приложений, несмотря на то, что он более красив и функционален. Честно говоря, на мой взгляд, это лучший вариант *TimePicker'а*, который я видел.
Итак, ниже я покажу, как реализовать такой компонент самому, и вы убедитесь, что все относительно просто.
#### QML
Что из себя представляет наш *TimePicker*? По сути это лишь, три картинки, две метки и одна активная область, для управления. Давайте просто нарисуем это в *QML*.
```
Item {
id: timePicker
width: 400
height: 400
property int hours: 0
property int minutes: 0
property alias backgroundImage: bg.source
property alias hourDotImage: hourDot.source
property alias minutesDotImage: minuteDot.source
Image {
id: bg
anchors.fill: parent
property int centerX: 200
property int centerY: 200
property int minuteRadius: 152
property int hourRadius: 65
property int minuteGradDelta: 6
property int hourGradDelta: 30
property int diameter: 73
Image {
id: hourDot
x: centerX
y: centerY - bg.hourRadius
width: bg.diameter
height: bg.diameter
Text {
font.pixelSize: 40
anchors.centerIn: parent
text: (timePicker.hours < 10 ? "0" : "") + timePicker.hours
}
}
Image {
id: minuteDot
x: centerX
y: centerY - bg.minuteRadius
width: bg.diameter
height: bg.diameter
Text {
font.pixelSize: 40
anchors.centerIn: parent
color: "#CCCCCC"
text: (timePicker.minutes < 10 ? "0" : "") + timePicker.minutes
}
}
}
MouseArea {
id: mouseArea
anchors.fill: parent
}
}
```
Получается примерно так, если сейчас использовать этот компонент, передав ему в качестве картинок, такие же кружочки как в оригинальном *TimePicker*, то мы увидим компонент, не реагирующий на наши действия, с временем установленным в 00:00.
Теперь надо сделать так, чтобы местоположение кружков с часами и минутами менялось в зависимости от значения переменных:
```
property int hours: 0
property int minutes: 0
```
Для этого добавляем компонентам *hourDot* и *minutesDot* следующие строки соответственно:
```
x: (bg.centerX - bg.diameter / 2) + bg.hourRadius * Math.cos(timePicker.hours * bg.hourGradDelta * (3.14 / 180) - (90 * (3.14 / 180)))
y: (bg.centerY - bg.diameter / 2) + bg.hourRadius * Math.sin(timePicker.hours * bg.hourGradDelta * (3.14 / 180) - (90 * (3.14 / 180)))
```
и
```
x: (bg.centerX - bg.diameter / 2) + bg.minuteRadius * Math.cos(timePicker.minutes * bg.minuteGradDelta * (3.14 / 180) - (90 * (3.14 / 180)))
y: (bg.centerY - bg.diameter / 2) + bg.minuteRadius * Math.sin(timePicker.minutes * bg.minuteGradDelta * (3.14 / 180) - (90 * (3.14 / 180)))
```
Ничего сверхъестественного — просто нахождение местоположения точки на окружности.
После того как мы все нарисовали, перейдем к главной части компонента а именно обработке действий пользователя и реакции на них.
#### Обработка
Наша *MouseArea* будет работать одна и сразу для обоих окружностей, а все потому, что круглых *MouseArea* не существует, а нам как то надо обрабатывать положение пальца именно в круге и в кольце. Таким образом мы перекладываем эту задачу на себя, и пишем такой простой метод для *MouseArea*:
```
function chooseHandler(mouseX, mouseY) {
if (bg.hourRadius + bg.diameter / 2 > Math.sqrt(Math.pow(bg.centerX - mouseX, 2) + Math.pow(bg.centerY - mouseY, 2)))
return 0
else if (bg.minuteRadius + bg.diameter / 2 > Math.sqrt(Math.pow(bg.centerX - mouseX, 2) + Math.pow(bg.centerY - mouseY, 2)))
return 1
return -1
}
```
Этот метод возвращает 0 если мы попали в малый круг (часы), единицу — если в кольцо (минуты) и -1 если никуда не попали — чтобы не обрабатывать углы квадрата.
Для того чтобы обработать жесты пользователя на потребуются три события *MouseArea*:
```
onPressed: {
currentHandler = chooseHandler(mouseX, mouseY)
previousAlpha = findAlpha(mouseX, mouseY)
}
```
Вызываем метод описанный выше и определяем с чем работаем и получаем угол точки нажатия относительно «12 часов».
```
onReleased: {
currentHandler = -1
previousAlpha = -1
}
```
Просто сбрасываем все.
```
onPositionChanged: {
var newAlpha = 0;
if (currentHandler < 0)
return
newAlpha = findAlpha(mouseX, mouseY)
if (currentHandler > 0) {
timePicker.minutes = getNewTime(timePicker.minutes, newAlpha, bg.minuteGradDelta, 1)
}
else
timePicker.hours = getNewTime(timePicker.hours, newAlpha, bg.hourGradDelta, 2)
}
```
Происходит, когда палец пользователя меняет свою позицию.
Получаем новый угол все также относительно «12 часов», и вызываем метод *getNewTime* (рассмотрим его ниже) с определенными параметрами — в зависимости от того с часами или минутами мы сейчас работаем.
Теперь посмотрим на метод *findAlpha*, он прост, и так же не выходит за рамки школьной геометрии:
```
function findAlpha(x, y) {
var alpha = (Math.atan((y - bg.centerY)/(x - bg.centerX)) * 180) / 3.14 + 90
if (x < bg.centerX)
alpha += 180
return alpha
}
```
Вычисляем угол в радианах и переводим его в градусы и добавляем дополнительную проверку, для того чтобы работать со всеми 360 градусами (а не только с первыми 180).
#### getNewTime
Этот метод является ядром вычислений и имеет следующие параметры:
* *source* — исходное значение счетчика;
* *alpha* — текущий угол;
* *resolution* — размер одного сектора в градусах (6 — для минут, 30 — для секунд) ;
* *boundFactor* — сколько раз нужно крутануться по окружности для сброса счетчика — 1 для минут, 2 — для часов, т. к. у нас 24 часа но в окружности все 12 делений.
Собственно метод:
```
function getNewTime(source, alpha, resolution, boundFactor) {
var delta = alpha - previousAlpha
if (Math.abs(delta) < resolution)
return source
if (Math.abs(delta) > 180) {
delta = delta - sign(delta) * 360
}
var result = source * resolution
var resdel = Math.round(result + delta)
if (Math.round(result + delta) > 359 * boundFactor)
result += delta - 360 * (source * resolution > 359 ? boundFactor : 1)
else if (Math.round(result + delta) < 0 * boundFactor)
result += delta + 360 * (source * resolution > 359 ? boundFactor : boundFactor)
else
result += delta
previousAlpha = alpha
return result / resolution
}
```
Сначала мы вычисляем разницу между текущим и предыдущим сохраненным положением пальца, если разница меньше размера одного сектора, то просто выходим, ничего не меняя.
Следующая проверка обрабатывает случай, когда проход пальца через 0 градусов (12 часов) возвращает слишком большую дельту, таким образом она корректирует ее.
В переменную *result* записывается исходное положение точки в градусах, после этого к нему прибавляется дельта.
Но не все так просто, группа условий служит для корректировки пограничных случаев, если бы этих проверок не было, мы бы могли увидеть на *TimePicker'е* некорректные значения типа 25:68.
После этого мы запоминаем новое положение пальца и возвращаем результат в правильных единицах.
#### Заключение
 Собственно, на этом все. Слева итоговый screenshot с девайса. Приводимые алгоритмы не являются верхом совершенства, это просто рабочее решение. Если вы сможете сделать лучше — милости прошу, сообщите мне об этом.
Код компонента [доступен на Gitorius](https://gitorious.org/harmattan-timepicker)
**P. S.** Первое (*неправильное*) решение этой задачи было еще проще — я просто смотрел в какой четверти окружности находится палец, и, в зависимости от одного из четырех направлений его движения, прибавлял или вычитал единицу. Возможно, для каких-то целей такой подход тоже мог бы иметь смысл, но я ставил задачу максимально соответствовать существующему решению от Nokia. | https://habr.com/ru/post/134397/ | null | ru | null |
# Развёртывание приложений в InterSystems Caché
[](http://habrahabr.ru/company/intersystems/blog/268767/)Введение
--------
Итак, вы разработали своё приложение на технологиях InterSystems. Теперь его надо развернуть у клиента и часто не один раз. В процессе разработки у вас появилась инструкция по установке – потому что недостаточно просто импортировать классы, нужно ещё и ~~доработать систему напильником~~ провести тонкую настройку среды под ваши нужды.
Для решения этих задач существует утилита [%Installer](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=GCI_manifest). Эта статья о ней.
%Installer
----------
Эта утилита позволяет определить манифест установки, который описывает целевую конфигурацию Caché, а не шаги к его достижению. Вы описываете, что должно быть, а Caché уже сгенерирует весь необходимый для этого код. Распространяете вы, соответственно, только сам манифест, кодогенерация происходит уже на месте в рамках конкретного сервера Caché.
Для написания манифеста вы создаёте блок XData с описанием желаемой конфигурации, а также метод, который генерирует COS код на основе блока XData (он всегда одинаков). После того, как вы написали манифест, его можно вызвать во время инсталляции Caché, из терминала или COS-кода. Манифест должен исполняться в области %SYS. Манифесту доступны как параметры системы (супер-порт, ОС, mgr директория и др.), так и произвольные параметры, переданные пользователем. Таким образом, класс установщика должен отвечать следующим требованиям:
* Включать ссылку на `%occInclude.inc`;
* Содержать блок `XData` с конфигурацией сервера Caché;
* Блок может называться любым корректным именем
* Добавьте `[XMLNamespace = INSTALLER]` после имени блока для включения подсказок в студии;
* Корневой элемент (может быть только один) – все остальные элементы расположены внутри него;
* Необходимо определить метод `setup()`, который выполняет кодогенерацию из блока XData.
Использование
-------------
Готовый манифест установки может быть запущен несколькими [способами](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=GCI_manifest#GCI_manifest_invoke):
* В области %SYS из терминала или COS кода
```
do ##class(MyPackage.MyInstaller).setup()
```
* Автоматически при установке Caché. Для этого экспортируйте класс установщика в файл DefaultInstallerClass.xml в папку с дистрибутивом Caché (где находится setup\_cache.exe, или cinstall). При установке Caché он будет импортирован в область %SYS и запущен (через метод setup())
Пример
------
Рассмотрим простой пример. Создадим класс `App.Installer` c установщиком, который создаёт область с названием, переданным пользователем:
**App.Installer**Include %occInclude
Class App.Installer
{
/// Сгенерированный код можно посмотреть в zsetup+1^App.Installer.1
XData Install [ XMLNamespace = INSTALLER ]
{
<Manifest>
<If Condition='(##class(Config.Namespaces).Exists("${Namespace}")=0)'>
<Log Text="Creating namespace ${Namespace}" Level="0"/>
<Namespace Name="${Namespace}" Create="yes" Code="${Namespace}" Ensemble="0" Data="${Namespace}">
<Configuration>
<Database Name="${Namespace}" Dir="${MGRDIR}/${Namespace}" Create="yes"/>
Configuration>
Namespace>
<Log Text="End Creating namespace ${Namespace}" Level="0"/>
If>
Manifest>
}
/// Метод, который вызывается для выполнения установки.
/// Во время компиляции класса происходит генерация COS кода
/// После этого установщик запускается с параметрами следующим образом:
/// Set pVars("Namespace")="TempNamespace"
/// Do ##class(App.Installer).setup(.pVars)
ClassMethod setup(ByRef pVars, pLogLevel As %Integer = 0, pInstaller As %Installer.Installer) As %Status [ CodeMode = objectgenerator, Internal ]
{
Quit ##class(%Installer.Manifest).%Generate(%compiledclass, %code, "Install")
}
}
В этом примере происходит следующее:
* Проверяем, существует ли область с именем равным значению переменной Namespace (например, значение равно NewNamespace);
* Если нет, то логируется факт начала создания области NewNamespace;
* Определение области:
+ C названием NewNamespace;
+ Область нужно создать;
+ БД кода NewNamespace;
+ Ensemble не включаем;
+ БД данных NewNamespace.
* Создание базы данных
+ C названием NewNamespace;
+ В папке mgr/NewNamespace (заметим, что переменная MGRDIR доступна нам по умолчанию).
* Запись в лог завершения создания области.
Для запуска из терминала, выполним следующие команды:
> Set pVars("Namespace")="NewNamespace"
>
> Do ##class(App.Installer).setup(.pVars)
**Что выведет**2015-10-16 16:26:18 0 App.Installer: Installation starting at 2015-10-16 16:26:18, LogLevel=0
2015-10-16 16:26:18 0: Creating namespace NewNamespace
2015-10-16 16:26:19 0: End Creating namespace NewNamespace
2015-10-16 16:26:19 0 App.Installer: Installation succeeded at 2015-10-16 16:26:19
2015-10-16 16:26:19 0 %Installer: Elapsed time .605257s
Список элементов
----------------
Манифест формируется из следующих элементов:
| | | | |
| --- | --- | --- | --- |
| **Элемент** | **Родительский элемент** | **Атрибуты (значение по умолчанию)** | **Описание** |
| Arg | Invoke, Error | Value – значение аргумена | Передаёт аргумент в метод вызываемый через Invoke или Error |
| ClassMapping | Configuration | Package – пакет для отображения
From – имя БД из которой отображаем | Создаёт маппинг классов из БД в облась, внутри элемента Configuration которой мы находимся |
| Compile | Namespace | Class – имя класс(ов) для компиляции
Flags – флаги компиляции (ck)
IgnoreErrors – игнорировать ошибки (0) | Компилирует классы. Вызывает [$System.OBJ.Compile(Class, Flags)](http://docs.intersystems.com/cache20152/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25SYSTEM.OBJ#METHOD_Compile) |
| Configuration | Namespace | | Необходим для создания области и баз данных. Закрывающий тэг активирует маппинги и обновляет cpf файл |
| CopyClass | Namespace | Src — исходный класс
Target — целевой класс
Replace — удалять исходный класс (0) | Копирует или перемещает исходный класс в целевой |
| CopyDir | Manifest | Src — исходная директория
Targe — целевая директория
IgnoreErrors — игнорировать ошибки (0) | Копирует директорию |
| CopyFile | Manifest | Src – исходный файл
Targe – целевой файл
IgnoreErrors – игнорировать ошибки (0) | Копирует файл |
| Credential | Production | Name – название реквизита доступа
Username – имя пользователя
Password – пароль
Overwrite – переопределить в случае существования | Создаёт или переопределяет реквизиты доступа |
| CSPApplication | Namespace | AuthenticationMethods – доступные методы аутентификации
AutoCompile – автокомпиляция
CSPZENEnabled – флаг CSP/ZEN
ChangePasswordPage – страница изменения пароля
CookiePath – путь для cookie сессии
CustomErrorPage – пользовательская страница ошибок
DefaultSuperclass – супер-класс по умолчанию
DefaultTimeout – таймаут сессии
Description – описание
Directory – путь к CSP-файлам
EventClass – класс события
Grant – список ролей, которые выдаются при входе
GroupById – группировать по идентификатору
InboundWebServicesEnabled – входящие веб-службы
IsNamespaceDefault – приложение для области по умолчанию
LockCSPName – блокировка на имени CSP
LoginClass – страница входа в систему
PackageName – имя пакета
PermittedClasses – разрешенные классы
Recurse – поддиректории (0)
Resource – требуемый ресурс
ServeFiles – служебные файлы
ServeFilesTimeout – таймаут у служебных файлов
TwoFactorEnabled – двухфакторная аутентификация
Url – название веб-приложения
UseSessionCookie – использовать cookie для сессии | Создаёт или изменяет веб-приложение. Подробное описание настроек в [документации](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=GCSP_config#GCSP_editwebapp) и классе [Security.Applications](http://docs.intersystems.com/cache20152/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=Security.Applications) |
| Database | Configuration | BlockSize – размер блока
ClusterMountMode – монтировать БД как часть кластера
Collation – сортировка
Create – создать БД — yes,no,overwrite (yes)
Dir – директория
Encrypted – зашифровать
EncryptionKeyID – ID ключа шифрования
ExpansionSize – расширение
InitialSize – начальный размер
MaximumSize – минимальный размер
MountAtStartup – монтирование при запуске
MountRequired – монтирование обязательно
Name – имя
PublicPermissions – общедоступные права
Resource – ресурс
StreamLocation – расположение потока | Создаёт или изменяет базу данных. Подробное описание настроек в [документации](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=GSA_config#GSA_config_databases_local) и классе [Config.Databases](http://docs.intersystems.com/cache20152/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=Config.Databases) |
| Default | Manifest | Name – имя переменной
Value – значение переменной
Dir – значение переменной, если это путь к папке/файлу | Определяет значение переменной, если она не определена |
| Else | Manifest, Namespace | | Выполняется, если проверка if-условия закончилась отрицательно |
| Error | Manifest | Status – код ошибки
Source – источник ошибки | Выкидывает исключение. ${} и #{} синтаксис недоступен |
| ForEach | Manifest | Index – название переменной
Values – список значений переменной | Оператор [совместного цикла](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D0%BA%D0%BB_(%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)#foreach) |
| GlobalMapping | Configuration | Global – имя глобала
From – имя БД из которой отображаем Collation – сортировка (Caché Standard) | Отображает глобал |
| If | Manifest, Namespace | Condition – условие | Оператор условного перехода |
| IfDef | Manifest, Namespace | Var – имя переменной | Оператор условного перехода, в случае если переменная определена |
| IfNotDef | Manifest, Namespace | Var – имя переменной | Оператор условного перехода, в случае если переменная не определена |
| Import | Namespace | File – файп/папка для импорта
Flags — флаги компиляции (ck)
IgnoreErrors — игнорировать ошибки (0)
Recurse – рекурсивный импорт (0) | Импортирует файлы. Вызывает:
[$System.OBJ.ImportDir(File,,Flags,,Recurse)](http://docs.intersystems.com/cache20152/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25SYSTEM.OBJ#METHOD_ImportDir) и [$System.OBJ.Load(File, Flags)](http://docs.intersystems.com/cache20152/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25SYSTEM.OBJ#Load) |
| Invoke | Namespace | Class – класс
Method – метод
CheckStatus – проверять возвращаемый статус
Return – записать результат в переменную | Вызывает метод класса, можно передавать аргументы и получить результат исполнения |
| LoadPage | Namespace | Name – путь к CSP странице
Dir – папка с CSP страницами
Flags — флаги компиляции (ck)
IgnoreErrors — игнорировать ошибки (0) | Загружает CSP файлы через [$System.CSP.LoadPage(Name, Flags)](http://docs.intersystems.com/cache20152/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25SYSTEM.CSP#METHOD_LoadPage) и [$System.CSP.LoadPageDir(Dir, Flags)](http://docs.intersystems.com/cache20152/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25SYSTEM.CSP#METHOD_LoadPageDir) |
| Log | Manifest | Level – уровень логирования от 0 (минимум) до 3 (подробно)
Text – текст, до 32000 символов | Добавляет сообщение в лог, если уровень логирования больше или равен атрибуту level |
| Manifest | | | Корневой элемент. Единственный в манифесте, все остальные элементы располагаются внутри него |
| Namespace | Manifest | Name – имя области
Сreate – создавать область – yes,no,overwrite (yes)
Code – БД с кодом
Data – БД с данными
Ensemble – включать Ensemble в области
Прочие атрибуты связаны с веб-приложениями Ensemble | Определяет область работы установщика |
| Production | Namespace | Name – имя продукции
AutoStart – автоматический запуск продукции | Настраивает продукцию Ensemble |
| Resource | Manifest | Name – имя ресурса
Description – описание
Permission – общедоступные права | Создаёт или изменяет ресурс |
| Role | Manifest | Name – имя роли
Description – описание
Resources – ресурсы в виде «MyResource:RW,MyResource1:RWU» RolesGranted – дать сопутствующие роли | Создаёт роль |
| RoutineMapping | Configuration | Routines – имя рутин(ы)
Type – один из типов «MAC,INT,INC,OBJ,ALL»
From – из какой БД | Создаёт маппинг рутин |
| Setting | Production | Item – настраиваемый элемент
Target – тип настройки: Item, Host, Adapter
Setting – название настройки
Value – значение настройки | Конфигурирует элемент продукции Ensemble. Вызывает метод [Ens.Production:ApplySettings](http://docs.intersystems.com/ens201512/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=ENSLIB&CLASSNAME=Ens.Production#METHOD_ApplySettings) |
| SystemSetting | Manifest | Name – класс.свойство пакета Config
Value – значение свойства | Устанавливает значение свойств пакета Config (через метод Modify) |
| User | Manifest | Username – имя пользователя
PasswordVar – переменная, содержащая пароль
Roles – список ролей пользователя
Fullname – полное имя
Namespace – стартовая область
Routine – стартовая рутина
ExpirationDate – дата, после которой пользователь перестанет быть активированным
ChangePassword – сменить пароль при следующем логине
Enabled – активирован ли пользователь | Создаёт или изменяет пользователя |
| Var | Manifest | Name — имя переменной
Value – значение переменной | Определяет значение переменной |
Переменные
----------
В качестве значений атрибутов могут выступать переменные, они определяются одним из трёх способов:
* ${<Имя\_переменной>} – во время выполнения манифеста вычисляется значение переменной (переданное пользователем или одна из переменных среды, см. далее);
* ${#<Имя\_параметра>} – во время компиляции заменяются на значение указанного параметра класса установщика;
* #{} — во время выполнения манифеста вычисляется значение указанного COS выражения. Не забывайте о кавычках.
Значения параметров определяются на этапе компиляции, поэтому они могут быть частью переменой или COS выражения. Интерпретация переменных происходит перед интерпретацией COS-кода, поэтому переменные могут входить в COS-выражение, например: `#{$ZCVT("${NAMESPACE}","L")}.`
Переменные среды
----------------
Всегда доступны следующие переменные:
| | | |
| --- | --- | --- |
| **Переменная** | **Описание** | **Пример значения** |
| SourceDir | (Только при установке Cache) Директория, где находится установщик (setup\_cache.exe or cinstall) | /InterSystems/distr/ |
| ISCUpgrade | (Только при установке Cache) Определяет, установка или обновление | 0 (установка)
1 (обновление) |
| CFGDIR | См. INSTALLDIR. | /InterSystems/Cache/ |
| CFGFILE | Путь к cpf файлу | /InterSystems/Cache/cache.cpf |
| CFGNAME | Имя инстанса | CACHE |
| CPUCOUNT | Количество ядер CPU | 4 |
| CSPDIR | Директория CSP | /InterSystems/Cache/csp/ |
| HOSTNAME | Имя веб сервера | SCHOOL15 |
| HTTPPORT | Порт веб сервера | 80 |
| INSTALLDIR | Директория, куда устанавливается Caché | /InterSystems/Cache/ |
| MGRDIR | Директория менеджмента (mgr) | /InterSystems/Cache/mgr/ |
| PLATFORM | Операционная система | UNIX |
| PORT | Порт суперсервера Caché | 1972 |
| PROCESSOR | Имя платформы | x86-64 |
| VERSION | Версия Caché | 2015.1.1 |
Отладка
-------
Бывает непонятно, какие значения могут принимать атрибуты. Для выяснения посмотрите на сгенерированный int-код метода setup. Как правило, основной вызов это метод:
`tInstaller.ElementName()`,
т.е. метод класса [%Installer.Installer](http://docs.intersystems.com/cache20152/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25Installer.Installer) который уже вызывает непосредственно системные методы. Альтернативно, можно посмотреть на код класса `[%Installer., атрибуты элемента это свойства его класса. Кодогенерация осуществляется в методах %OnBeforeGenerateCode, %OnGenerateCode, %OnAfterGenerateCode.
Для целей отладки, рекомендую оборачивать вызов установщика в транзакцию. Так с помощью команд TSTART](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_ctstart)/[TROLLBACK](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_ctrollback) можно легко отменить все изменения, сделанные внутри Caché (внешние к Caché изменения, например создание файла БД отменены не будут).
Пример использования
--------------------
Проект [MDX2JSON](https://github.com/intersystems-ru/Cache-MDX2JSON) содержит [установщик](https://github.com/intersystems-ru/Cache-MDX2JSON/blob/master/MDX2JSON/Installer.cls.xml). Для установки достаточно импортировать в любую область файл [installer.xml](https://raw.githubusercontent.com/intersystems-ru/Cache-MDX2JSON/master/MDX2JSON/Installer.cls.xml) с классом MDX2JSON.Installer. Импортировать можно или через [панель управления](http://localhost:57772/csp/sys/exp/%25CSP.UI.Portal.ClassList.zen?%24NAMESPACE=%25SYS) или просто переносом класса в студию.
Далее выполните в терминале:
```
do ##class(MDX2JSON.Installer).setup()
```
В результате произойдёт загрузка файлов из GitHub-репозитория, установка «по умолчанию» в область MDX2JSON с созданием базы MDX2JSON, маппинга пакета MDX2SJON в %All, создание REST-приложения /MDX2JSON и многое другое, о чём будет написано в терминале.
Ещё примеры
-----------
[Пример в документации](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=GCI_manifest#GCI_manifest_example).
Класс Sample.Installer в области Samples.
Проект CacheGitHubCI содержит [установщик](https://github.com/intersystems-ru/CacheGitHubCI/blob/master/CacheGitHubCI/Install.cls.xml).
Проект SYSMON Dashboards содержит [установщик](https://github.com/intersystems-ru/deepsee-sysmon-dashboards/blob/master/cls/kutac/monitor/utils/Installer.cls.xml).
Проект DeepSee Audit содержит [установщик](https://github.com/intersystems-ru/deepseeaudit/blob/master/_CLS/habra/Installer.xml).
Выводы
------
Утилиту %Installer можно использовать для поставки решений на InterSystems Caché и Ensemble.
Ссылки
------
[Документация](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=GCI_manifest)` | https://habr.com/ru/post/268767/ | null | ru | null |
# Простая программа на Python для гиперболической аппроксимации статистических данных
Зачем это нужно
---------------
Законы Зипфа оописывают закономерности частотного распределения слов в тексте на любом естественном языке[1]. Эти законы кроме лингвистики применяться также в экономике [2]. Для аппроксимации статистических данных для объектов, которые подчиниться Законам Зипфа используется гиперболическая функция вида:
(1)
где: a.b – постоянные коэффициенты: x – статистические данные аргумента функции (в виде списка): y- приближение значений функции к реальным данным полученным методом наименьших квадратов[3].
Обычно для аппроксимации гиперболической функцией методом логарифмирования её приводят к линейной, а затем определяют коэффициенты a,b и делают обратное преобразование [4]. Прямое и обратное преобразование приводит к дополнительной погрешности аппроксимации. Поэтому привожу простую программу на Python, для классической реализации метода наименьших квадратов.
Алгоритм
--------
Исходные данные задаются двумя списками где **n** ─ количество данных в списках.
Получим функцию для определения коэффициентов 
Коэффициенты a,b найдём из следующей системы уравнений:(3)
Решение такой системы не представляет особого труда:
(4),
(5).
Средняя ошибка аппроксимации  по формуле: (6)
Код Python
----------
```
#!/usr/bin/python
# -*- coding: utf-8 -*
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.rcParams['font.family'] = 'fantasy'
def mnkGP(x,y): # функция которую можно использзовать в програме
n=len(x) # количество элементов в списках
s=sum(y) # сумма значений y
s1=sum([1/x[i] for i in range(0,n)]) # сумма 1/x
s2=sum([(1/x[i])**2 for i in range(0,n)]) # сумма (1/x)**2
s3=sum([y[i]/x[i] for i in range(0,n)]) # сумма y/x
a= round((s*s2-s1*s3)/(n*s2-s1**2),3) # коэфициент а с тремя дробными цифрами
b=round((n*s3-s1*s)/(n*s2-s1**2),3)# коэфициент b с тремя дробными цифрами
s4=[a+b/x[i] for i in range(0,n)] # список значений гиперболической функции
so=round(sum([abs(y[i] -s4[i]) for i in range(0,n)])/(n*sum(y))*100,3) # средняя ошибка аппроксимации
plt.title('Аппроксимация гиперболой Y='+str(a)+'+'+str(b)+'/x\n Средняя ошибка--'+str(so)+'%',size=14)
plt.xlabel('Координата X', size=14)
plt.ylabel('Координата Y', size=14)
plt.plot(x, y, color='r', linestyle=' ', marker='o', label='Data(x,y)')
plt.plot(x, s4, color='g', linewidth=2, label='Data(x,f(x)=a+b/x')
plt.legend(loc='best')
plt.grid(True)
plt.show()
x=[10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86]
y=[0.1, 0.0714, 0.0556, 0.0455, 0.0385, 0.0333, 0.0294, 0.0263, 0.0238, 0.0217,
0.02, 0.0185, 0.0172, 0.0161, 0.0152, 0.0143, 0.0135, 0.0128, 0.0122, 0.0116] # данные для проверки по функции y=1/x
mnkGP(x,y)
```
Результат
---------
Мы брали данные из функции равносторонней гиперболы, поэтому и получили a=0,b=10 и абсолютную погрешность в 0,004%. Значить функция mnkGP(x,y) работает правильно и её можно вставлять в прикладную программу
Аппроксимация для степенных функций
-----------------------------------
Для этого в Python есть модуль scipy, но он не поддерживает отрицательную степень d полинома. Рассмотрим код реализации аппроксимации данных полиномом.
```
#!/usr/bin/python
# coding: utf8
import scipy as sp
import matplotlib.pyplot as plt
def mnkGP(x,y):
d=2 # степень полинома
fp, residuals, rank, sv, rcond = sp.polyfit(x, y, d, full=True) # Модель
f = sp.poly1d(fp) # аппроксимирующая функция
print('Коэффициент -- a %s '%round(fp[0],4))
print('Коэффициент-- b %s '%round(fp[1],4))
print('Коэффициент -- c %s '%round(fp[2],4))
y1=[fp[0]*x[i]**2+fp[1]*x[i]+fp[2] for i in range(0,len(x))] # значения функции a*x**2+b*x+c
so=round(sum([abs(y[i]-y1[i]) for i in range(0,len(x))])/(len(x)*sum(y))*100,4) # средняя ошибка
print('Average quadratic deviation '+str(so))
fx = sp.linspace(x[0], x[-1] + 1, len(x)) # можно установить вместо len(x) большее число для интерполяции
plt.plot(x, y, 'o', label='Original data', markersize=10)
plt.plot(fx, f(fx), linewidth=2)
plt.grid(True)
plt.show()
x=[10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86]
y=[0.1, 0.0714, 0.0556, 0.0455, 0.0385, 0.0333, 0.0294, 0.0263, 0.0238, 0.0217,
0.02, 0.0185, 0.0172, 0.0161, 0.0152, 0.0143, 0.0135, 0.0128, 0.0122,
0.0116] # данные для проверки по функции y=1/x
mnkGP(x,y)
```
Результат
---------
Как следует из графика, при аппроксимации параболой данных изменяющихся по гиперболе средняя ошибка возрастает, а свободный член квадратного уравнения обращается в ноль.
Полученные функции будут применены для анализа Законов Зипфа (Ципфа), но это будет сделано уже в следующей статье.
Ссылки:
1. Законы Зипфа (Ципфа) [tpl-it.wikispaces.com/Законы+Зипфа+%28Ципфа%29](http://tpl-it.wikispaces.com/Законы+Зипфа+%28Ципфа%29)
2. Закон Ципфа это. [dic.academic.ru/dic.nsf/ruwiki/24105](http://dic.academic.ru/dic.nsf/ruwiki/24105)
3. Законы Зипфа. [wiki.webimho.ru/законы-зипфа](http://wiki.webimho.ru/законы-зипфа)
4. Лекция 5. Аппроксимация функций по методу наименьших квадратов. [mvm-math.narod.ru/Lec\_PM5.pdf](http://mvm-math.narod.ru/Lec_PM5.pdf)
5. Средняя ошибка аппроксимации. [math.semestr.ru/corel/zadacha.php](http://math.semestr.ru/corel/zadacha.php) | https://habr.com/ru/post/322954/ | null | ru | null |
# Выборка из обновляемых материализованных представлений в PostgreSQL 9.3
Здравствуйте, хабрачеловеки! Вы, вероятно, уже пощупали [материализованные представления](http://www.postgresql.org/docs/9.3/static/rules-materializedviews.html), появившиеся в **PostgreSQL** 9.3. Одним из недостатков есть то, что в процессе обновления представления используется эксклюзивная (ACCESS EXCLUSIVE) блокировка, делающая невозможным запросы к представлению. В **PostgreSQL** 9.4 [планируется](http://michael.otacoo.com/postgresql-2/postgres-9-4-feature-highlight-refresh-concurrently-a-materialized-view/) добавить возможность чтения из представления во время его обновления. Ну, а пока, в этой небольшой заметке, я хочу показать один из способов выхода из этого положения.
Поможет нам в этом деле [двойная буферизация](http://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B9%D0%BD%D0%B0%D1%8F_%D0%B1%D1%83%D1%84%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F). Суть ее в том, что создаются два материализованных представления, пока одно обновляется (при этом сущности, от которых зависит это представление блокируются в режиме ACCESS SHARE, что позволяет делать запросы к ним), со вторым можно работать. Как только обновление завершится, меняем их местами.
Вспомогательные функции для создания и удаления представлений:
```
CREATE OR REPLACE FUNCTION public.create_materialized_view ( p_viewname text, p_basename text )
RETURNS void AS
$BODY$
BEGIN
EXECUTE 'CREATE MATERIALIZED VIEW ' || p_viewname || ' AS SELECT * FROM ' || p_basename;
EXECUTE 'CREATE MATERIALIZED VIEW ' || p_viewname || '_back AS SELECT * FROM ' || p_basename;
END
$BODY$
LANGUAGE plpgsql VOLATILE;
CREATE OR REPLACE FUNCTION public.drop_materialized_view ( p_viewname text )
RETURNS void AS
$BODY$
BEGIN
EXECUTE 'DROP MATERIALIZED VIEW ' || p_viewname;
EXECUTE 'DROP MATERIALIZED VIEW ' || p_viewname || '_back';
END
$BODY$
LANGUAGE plpgsql VOLATILE;
```
Функция для обмена буферов — обновляем *back*-буфер и переименовываем *back* в *front* и наоборот.
```
CREATE OR REPLACE FUNCTION public.swap_materialized_view ( p_viewname text )
RETURNS void AS
$BODY$
BEGIN
EXECUTE 'REFRESH MATERIALIZED VIEW ' || p_viewname || '_back';
EXECUTE 'ALTER MATERIALIZED VIEW ' || p_viewname || ' RENAME TO ' || split_part ( p_viewname, '.', 2 ) || '_temp';
EXECUTE 'ALTER MATERIALIZED VIEW ' || p_viewname || '_back RENAME TO ' || split_part ( p_viewname, '.', 2 );
EXECUTE 'ALTER MATERIALIZED VIEW ' || p_viewname || '_temp RENAME TO ' || split_part ( p_viewname, '.', 2 ) || '_back';
END
$BODY$
LANGUAGE plpgsql VOLATILE;
```
Также не помешает функция для создания индексов (так как приходится их дублировать для *back*-буфера):
```
CREATE OR REPLACE FUNCTION public.create_materialized_view_index ( p_viewname text, p_indexname text, p_columns text[] )
RETURNS void AS
$BODY$
BEGIN
EXECUTE 'CREATE INDEX ' || p_indexname || ' ON ' || p_viewname || ' ( ' || array_to_string ( p_columns, ',' ) || ' )';
EXECUTE 'CREATE INDEX ' || p_indexname || '_back ON ' || p_viewname || '_back ( ' || array_to_string ( p_columns, ',' ) || ' )';
END
$BODY$
LANGUAGE plpgsql VOLATILE;
```
Скрипт *update\_mv*, обновляющий представления (используется в задании cron):
```
#!/bin/bash
HOST="localhost"
PORT="5432"
USER="postgres"
DATABASE="mydb"
VIEWS=()
VIEWS+=('public.mv_order')
VIEWS+=('public.mv_delivery')
VCOUNT=${#VIEWS[@]}
for ((i = 0; i < ${VCOUNT}; i++))
do
VIEW=${VIEWS[$i]}
QUERY="SELECT public.swap_materialized_view('$VIEW')"
if psql -h $HOST -p $PORT -U $USER -d $DATABASE -q -c "SET client_min_messages = ERROR; $QUERY">/dev/null 1>&1; then
logger -p cron.notice -t update_mv Updated materialized view $VIEW
else
logger -p cron.notice -t update_mv Can\'t update materialized view $VIEW
fi
done
```
И, собственно, само cron-задание (для fcron) — обновляем раз в час:
```
@mail(false),runatreboot(true) 1h update_mv
```
Пример использования:
```
SELECT public.create_materialized_view ( 'public.mv_order', 'public.vw_order' ); -- public.vw_order - представление
SELECT public.create_materialized_view ( 'public.mv_delivery, 'public.vw_delivery' ); -- public.vw_delivery - представление
SELECT public.create_materialized_view_index ( 'public.mv_order', 'idx_mv_order_purchase', '{purchaser_name,order_date}'::text[] );
``` | https://habr.com/ru/post/209952/ | null | ru | null |
# Браузеры и app specific security mitigation. Часть 2. Internet Explorer и Edge
Internet Explorer & Edge
------------------------
Целью данной статьи является обзор специфичных, интегрированных в браузеры Internet Explorer и Edge, механизмов защиты от эксплойтов.
Мы решили объединить обзор механизмов безопасности IE и Edge в одну статью, поскольку, во-первых, оба они являются продуктами небезызвестной компании Microsoft, а, во-вторых, такой подход позволяет отследить, как менялся подход к защите и, соответственно, само развитие механизмов защиты у данных браузеров. Ну и также по той причине, что у IE и Edge общая кодовая база.
*Рисунок 1 — Развитие механизмов безопасности в браузере IE ([источник](https://www.blackhat.com/docs/us-16/materials/us-16-Weston-Windows-10-Mitigation-Improvements.pdf))*
Приведем данные механизмы в виде списка. Для IE перечень выглядит так:
* Isolated Heap — отдельная «куча» для HTML и DOM объектов;
* Memory Protection — механизм «отсроченного» освобождения памяти;
* Memory Garbage Collector (MemGC) — улучшение механизма Memory Protector, по сути, его наследник;
* Sandbox – механизм «песочницы»;
* Блокировка устаревших ActiveX-компонентов;
* JIT Hardening.
Для Edge:
* Memory Garbage Collector (MemGC);
* Sandbox;
* Attack surface reduction — произведено удаление устаревшего кода (toolbars, JScript, VBScript, ActiveX, BHO, VML, legacy document models);
* Целостность кода, ограничения загрузки модулей — блокирование загрузки DLL, которые не являются компонентами Windows или подписанными драйверами устройств. Бинарные модули не могут быть загружены с удалённых ресурсов;
* Kernel Attack Protection — сокращение количества ядерных компонент, доступных для обращения из браузера;
* JIT Hardening.
В рамках данной статьи мы рассмотрим следующие механизмы:
1. Isolated Heap & Memory Protection;
2. MemGC;
3. Реализация Sandbox в IE и Edge;
4. JIT Hardening.
Isolated Heap & Memory Protection & MemGC
-----------------------------------------
Одним из самых распространенных классов уязвимостей в рассматриваемых браузерах, да и в других браузерах тоже, являются UAF (use-after-free).
Любую эксплуатацию UAF-уязвимостей можно описать в виде следующей схемы:
*Рисунок 2 – Схема эксплуатации UAF-уязвимостей*
Т.е. эксплуатация UAF-уязвимостей производится в 2 шага:
1. **Free operation** – триггерится условие, при котором производится освобождение памяти объекта, при том, что остаётся указатель на этот объект – «висящий указатель» или dangling pointer. Он будет использован в дальнейшем для обращения к уже несуществующему объекту, например, для вызова его метода или записи какого-нибудь значения.
2. **Realloc operation** – производится реаллоцирование памяти и запись в нее нужных значений. На месте освобождённого старого объекта создаётся новый с подготовленными данными, которые будут ошибочно интерпретированы как компоненты старого объекта – уже после его освобождения.
Например, если вызывается метод объекта после его преждевременного освобождения, которое делает возможным занять освобождённую память и перезаписать указатель на таблицу виртуальных функций, таким образом, подменив адрес метода, который будет вызван. В результате, это может быть использовано для передачи управления по заданному адресу.
Ошибочное чтение данных из уже освобождённого объекта оставляет возможность взять из памяти уже своевременно подложенные туда значения, например, указатель на какую-либо функцию в кодовой секции релоцируемого ASLR модуля, т.е. осуществить утечку адреса и – далее – обход ASLR
Рассмотрим механизмы, с помощью которых осуществляется защита от подобного рода уязвимостей в браузерах IE и Edge.
### Isolated Heap
Защита Isolated Heap появилась в IE вместе с июньским обновлением 2014 года (MS14-035). Основная ее цель – это защита от UAF-уязвимостей. Теперь, при выделении памяти для объекта, она выделяется не из кучи процесса, а из специальной «изолированной кучи» (что понятно из названия):
*Рисунок 3 — Использование изолированной «кучи» при создании элемента `CImgElement`*
Практически все HTML и SVG DOM-объекты (CXXXElement) используют изолированную «кучу». Они с высокой долей вероятности могут иметь UAF-уязвимости, поэтому крайне важно изолировать данные объекты.
Благодаря внедрению отдельной «кучи», у атакующего появляются проблемы со вторым шагом эксплуатации UAF-уязвимостей, а именно с реаллоцированием памяти и записью в неё своих контролируемых значений или кода, потому что такие «удобные» объекты, как строки, выделяются в другой «куче» и не могут быть использованы для подмены значений в уязвимом объекте.
Как видно на рисунке ниже, указатель на изолированную «кучу» хранится в глобальной переменной, инициализация этой «кучи» происходит в функции DllProcessAttach():
*Рисунок 4 – Инициализация изолированной кучи*
Если отследить XREF-ы к \_g\_hIsolatedHeap, можно увидеть 2 функции-аллокатора, которые её используют:
1. `_MemIsolatedAlloc()`;
2. `_MemIsolatedAllocClear()`.
Второй вариант вызывает HeapAlloc с флагом HEAP\_ZERO\_MEMORY, что должно предотвращать от эксплуатации уязвимостей, использующих неинициализированную память.
Несмотря на то, что применение изолированной «кучи» помогает добиться уменьшения вероятности успешной эксплуатации UAF-уязвимостей, не всё так радужно, как кажется.
Во-первых, до сих пор присутствуют объекты, использующие «кучу» процесса – например, CStr. Во-вторых, есть теоретический путь обхода, связанный с тем, что имплементация изолированной «кучи» точно такая же, как и «кучи» процесса (нет проверки типов объектов при выделении им памяти), а также с тем, что выделенные объекты хранятся в отдельном месте.
Т.е. для обхода Isolated Heap атакующему необходимо выполнение следующих условий:
1. Найти объект, который аллоцируется в изолированной «куче»;
2. Данный объект должен иметь примерно тот же размер, что освобождаемый UAF-объект;
3. Атакующий должен легко контролировать содержимое данного объекта.
Ребята из ZDI в 2015 году представили доклад на Black Hat и пэйпер [1], в котором предложили несколько техник обхода Isolated Heap. Они имеют под собой одно общее основание, которое как раз удовлетворяет описанным выше условиям.
Разница между техниками лишь в деталях, а именно в предварительной работе с «кучей».
Рассмотрим основную технику.
### Техника обхода, основанная на использовании объекта другого типа (Type Confusion Bypass Techique)
Как было сказано ранее, изолированная «куча» точно такая же, как и обычная «куча» процесса, то есть при выделении памяти в ней не учитывается тип создаваемого объекта. Из-за этого у атакующего есть вариант заполнить освобождаемый объект объектом другого типа. Перезапись освобожденного объекта объектом другого типа приведет к условию type confusion.
Такой объект, по отношению к которому возможно создание условия type confusion, может иметь размер больший или даже меньший, чем размер объекта, которым мы собираемся перезаписывать память. Это важный факт, который позволяет атакующему контролировать определенные смещения внутри повторно используемого объекта. Например, если мы знаем, что UAF-уязвимость возникает при разыменовании указателя, по смещению 0x30, то всё, что нам нужно, это заменить освобождаемый объект таким, который содержит значение по смещению 0x30, которое мы можем контролировать.
Таким образом, последовательность действий такова:
1. Триггерим условие освобождения памяти «атакуемого» объекта;
2. Заменяем объект другим объектом, применяя heap spray;
3. Триггерим повторное использование «атакуемого» объекта.
PoC данной техники можно посмотреть у ребят из ZDI на [github](https://github.com/thezdi/abusing-silent-mitigations).
### Memory Protection
Если же внедрение Isolated Heap осложняет жизнь атакующему в эксплуатации UAF на втором шаге, шаге реаллоцирования и перезаписи памяти, то следующий механизм затрудняет выполнение первого шага, а именно освобождения памяти объекта. Называется данная защита **Memory Protection**.
Суть этого механизма в том, что он предотвращает освобождение участка памяти до тех пор, пока на него есть ссылка в стеке или в регистре (пока есть «висящие указатели»). Данный механизм впервые появился в IE с июльским обновлением безопасности в 2014 году (MS14-037). Проверку регистров добавили в августе 2014 года.
Для отслеживания участков памяти, которые нужно освободить, IE использует объект *CMemoryProtector*. Он создается для каждого потока, и указатель на него хранится в TLS (thread local storage).
Инициализация данного объекта производится в функции *MemoryProtection::CMemoryProtector::ProtectCurrentThread()* (стоит отметить, что при инициализации все поля объекта устанавливаются в 0).
*Рисунок 5 — Функция `ProtectCurrentThread()`*
Объект CMemoryProtector имеет следующую структуру (рисунок 6) [2]
*Рисунок 6 — Структура объекта `CMemoryProtector`*
Объект *CMemoryProtector* состоит из следующих полей:
1. **BlocksArray** – структура типа *SBlockDescriptorArray*, которая содержит информацию об освобождаемых участках памяти (wait-list);
2. **IsForceMarkAndReclaim** – флаг, применяемый для определения того, нужно ли вызвать операцию Reclamation Sweep (об этом ниже);
3. **StackHighAddress** – наибольший адрес стека в потоке. Используется для операции пометки (mark operation) участка при выборке значений указателей из стека;
4. **StackMarkerAddress** – наибольший адрес стека, когда вызывается функция `MemoryProtection::CMemoryProtector::ProtectCurrentThread()`. Применяется для определения того, полностью ли стек пройден, и, следовательно, будет ли выполняется операция *Reclamation Sweep* (об этом ниже).
Структура *SBlockDescriptorArray* содержит следующие поля:
1. **Blocks** – это список освобождаемых участков (wait-list). Каждый элемент wail-list – это дескриптор (*SBlockDescriptor*), содержащий информацию о блоке памяти: его базовом адресе, размере, содержится ли он в изолированной куче или в обычной.
2. **TotalSize** – это общий размер всех освобождаемых участков, находящихся в wait-list. Используется для определения, нужно ли выполнить операцию Reclamation Sweep;
3. **Count** – количество освобождаемых участков, находящихся в списке *Blocks*;
4. **Max Count** – максимальное количество элементов в wait-list;
5. **IsSorted** – флаг, определяющий отсортирован ли список *Blocks*.
Memory Protection при освобождении памяти использует функцию `MemoryProtection::CMemoryProtector::ProtectedFree()` вместо `HeapFree()`.
```
void __userpurge MemoryProtection::CMemoryProtector::ProtectedFree(void *a1@, void \*Dst, unsigned \_\_int32 a3, void \*a4)
{
void \*v4;
MemoryProtection::CMemoryProtector \*v5;
unsigned int v6;
MemoryProtection::CMemoryProtector \*v7;
size\_t Size;
v4 = a1;
if ( Dst )
{
if ( MemoryProtection::CMemoryProtector::tlsSlotForInstance != -1
&& (v5 = (MemoryProtection::CMemoryProtector \*)TlsGetValue(MemoryProtection::CMemoryProtector::tlsSlotForInstance),
(v7 = v5) != 0) )
{
MemoryProtection::CMemoryProtector::ReclaimMemory(v5, v6); //(1)
Size = 0;
if ( MemoryProtection::SBlockDescriptorArray::AddBlockDescriptor(v7, Dst, v4 != MemoryProtection::g\_heapHandles, &Size) )
{
MemoryProtection::SAddressFilter::AddBlock((MemoryProtection::CMemoryProtector \*)((char \*)v7 + 32), Dst, Size); //(2)
memset(Dst, 0, Size);
}
else
{
RaiseFailFastException(0, 0, 0);
}
}
else
{
HeapFree(v4, 0, Dst);
}
}
}
```
Функция `ProtectedFree()`
`ProtectedFree()` с некоторой периодичностью и при некоторых условиях осуществляет процедуру Reclamation Sweep (1). Важно отметить, что она осуществляется перед тем, как освобождаемый блок попадет в Wait-List.
Суть процедуры Reclamation Sweep:
1. Проверка суммарного количества участков памяти, находящихся в Wait-List, их суммарного объема;
2. Если суммарное количество участков больше, чем *CMemoryProtector.BlocksArray.TotalSize* или суммарный объем >= 100 000 байт или же установлен флаг *IsForceMarkAndReclaim*, произвести процедуру освобождения памяти для блоков, находящихся в Wait-List.
2.1. Если на блок памяти есть указатель в стеке или в регистре, то пропустить его;
2.2. Если на блок памяти указателей нигде нет, то освободить его.
Указателем на блок памяти считается как указатель на начало блока, так и на любое место внутри него.
За процедуру Reclamation Sweep отвечают несколько функций, которые вызываются внутри функции `MemoryProtection::CMemoryProtector::ReclaimMemory()` (там же и проверяются условия для запуска данной процедуры):
* `MemoryProtection::CMemoryProtector::MarksBlocks()`.
Данная функция сначала сортирует участки памяти в порядке увеличения адресов. Затем, она проверяет, существуют ли указатели на данные участки в стеке потока или в регистрах. В случае, если такой указатель существует, `MarksBlocks()` помечает такой блок.
* `MemoryProtection::CMemoryProtector::ReclaimUnmarkedBlocks()`
Данная функция осуществляет простой обход wait-листа и освобождает все непомеченные участки памяти. Счетчик в объекте `CMemoryProtection` также обновляется в процессе.
После проведения процедуры Reclamation Sweep, освобождаемый блок добавляется в wait-list и заполняется нулями.
*Рисунок 7 — Алгоритм функции `ProtectedFree()` (источник [[1]](https://www.blackhat.com/docs/us-15/materials/us-15-Gorenc-Abusing-Silent-Mitigations-Understanding-Weaknesses-Within-Internet-Explorers-Isolated-Heap-And-MemoryProtection-wp.pdf))*
Стоит отметить, что ранее существовала безусловная процедура освобождения всех участков памяти `MemoryProtection::CMemoryProtector::ReclaimMemoryWithoutProtection()` – это происходило каждый раз, когда вызывалась функция `mshtml!GlobalWndProc()` в результате получения сообщения от главного окна потока. Но позже эту возможность убрали.
Memory Protection — крайне эффективная техника против UAF-уязвимостей, когда указатель на освобожденную память остается в стеке или в регистре, поскольку Memory Protection гарантирует, что данный блок будет оставаться в wait-list до тех пор, пока его снова не используют (при выделении памяти) и будет находиться в wait-list, заполненный нулями.
Memory Protection также уменьшает вероятность эксплуатации других UAF-уязвимостей, не попадающих в категорию, описанных выше. В этом случае, когда «висящего указателя» нет ни в стеке, ни в регистре, атакующий должен решить следующие задачи:
**1) Задержка освобождения памяти**
Как было описано выше, освобождение памяти может пройти с некоторой задержкой, до тех пор, пока не будет осуществлена процедура Reclamation Sweep.
**2) Неопределенность из-за «мусора» в стеке**
Блок памяти может остаться в wait-list при процедуре Reclamation Sweep, поскольку может так получиться, что стек хранит значение, которое равно адресу где-нибудь внутри освобождаемого блока. Необязательно, что данное значение является указателем, но Memory Protection воспримет его именно так.
**3) Большая сложность в определении времени, когда произойдёт освобождение участка памяти.**
Процедура Reclamation Sweep осуществится только в том случае, если объем участков памяти в wait-list превысит 100 000 байт. Это может не произойти до тех пор, пока в wait-list не попадет действительно большой блок памяти.
**4) Более сложное поведение менеджера кучи при освобождении памяти**
Обобщая всё вышесказанное, стоит учитывать, что освобождаемый блок памяти сначала попадает в wait-list и находится там, пока объем wait-list не превысит 100 000 байт, а только затем освобождается при том, что на него нет указателей в стеке или в регистрах. При этом, невозможно предсказать состояние кучи после освобождения одновременно большого количества участков памяти разного размера из wait-list.
Несмотря на эти сложности, те же самые ребята из ZDI придумали несколько техник обхода механизма Memory Protection [1] – некоторые из них очевидные и простые, а некоторые нет.
Рассмотрим их дальше.
#### Элементарные техники
Наиболее очевидным решением является применение так называемого «memory pressure» для того, чтобы выполнилась процедура Reclamation Sweep, т.е. необходимо аллоцировать и затем сразу освободить память размером 100 000 байт.
```
// Здесь код для освобождения памяти некоторого объекта
...
// Конец кода освобождения памяти
// Цикл для форсирования очистки wait-list
var n = 100000 / 0x34 + 1;
for (var i = 0; i < n; i++)
{
document.createElement("div");
}
CollectGarbage();
// Код, который снова использует освобожденный объект
…
//
```
Но такой подход не освободит от всех проблем – мы решим проблему с задержкой освобождения памяти, но не избавимся от всех остальных. Вместе с нашим объектом будут освобождены многие другие объекты, причем непредсказуемым образом. Данное неопределенное поведение ведет к уменьшению надежности при попытке к установлению контроля за содержимым освобождаемой памяти.
Также ранее было возможно второе очевидное решение – это использование безусловной процедуры освобождения всех участков памяти, которая осуществляется, когда триггерится функция `GlobalWndProc()`.
Мы можем прервать выполнение эксплойта задержкой настолько большой, чтобы точно произошел новый вызов функции `GlobalWndProc()`, затем Memory Protection освободит все блоки в wait-list.
```
function step1() {
// Предварительный код начинается здесь…
...
// А заканчивается здесь
// Устанавливаем задержку для следующего шага, чтобы WndProc заново сработала,
// и произошла очистка wait-list
window.setTimeout(step2, 3000);
}
function step2() {
// Код освобождения некоторого объекта начинается здесь…
...
// А заканчивается здесь…
// Устанавливаем задержку для следующего шага, чтобы WndProc заново сработала,
// произошла очистка wait-list, и деаллоцируем наш объект
window.setTimeout(step3, 3000);
}
function step3() {
// Код для повторного использования объекта
…
}
```
Данное решение позволяет минимизировать число посторонних объектов, которые будут освобождаться вместе с нашим. Но оно имеет свои минусы – использование `setTimeout()` создает возможность для появления дополнительной непредсказуемой ветки кода, который исполняется в текущем потоке. В результате можно получить непредсказуемую и нежелательную модификацию «кучи».
#### «Продвинутая» техника
Исследователи на этом не остановились, подумали и решили, что для обхода Memory Protection необходимо стабилизировать wait-list — нужно построить последовательность таких действий скрипта, чтобы контролировать и знать состояние wait-list. Создав такую последовательность, мы уже сможем проводить эксплуатацию UAF-уязвимостей.
Для начала предположим, что мы можем выделить буфер А размером 100 000 байт. Затем мы пытаемся этот буфер освободить. В итоге, Memory Protection поместит наш буфер А в wait-list, и размер wait-list будет точно >= 100 000 байт.
*Рисунок 8 — Состояние wait-list после добавления в него буфера A (источник [[1]](https://www.blackhat.com/docs/us-15/materials/us-15-Gorenc-Abusing-Silent-Mitigations-Understanding-Weaknesses-Within-Internet-Explorers-Isolated-Heap-And-MemoryProtection-wp.pdf))*
Далее, мы снова выделяем и освобождаем буфер *B* уже необходимого нам размера *s*. Во время вызова `ProtectedFree()` Memory Protection увидит, что размер wait-list таков, что пора бы начать освобождать (реально освобождать) его элементы. После данной процедуры наш буфер размером *s* будет в wait-list.
*Рисунок 9 — Состояние wait-list после добавления в него буфера B (источник [[1]](https://www.blackhat.com/docs/us-15/materials/us-15-Gorenc-Abusing-Silent-Mitigations-Understanding-Weaknesses-Within-Internet-Explorers-Isolated-Heap-And-MemoryProtection-wp.pdf))*
Вполне возможно, что не все участки из wait-list будут освобождены и покинут его – на некоторые из них могут быть указатели в стеке (назовем такие *Wi*). Но, во-первых, мы можем с уверенностью сказать, что их суммарный размер гораздо меньше 100 000 байт. Во-вторых, неважно, каково их общее количество и суммарный размер для последующих шагов. Мы точно знаем, что пока на них есть указатели в стеке, эти участки будут в wait-list.
Итак, на данном этапе, мы знаем примерное состояние wait-list и готовы выполнить желаемые действия с «кучей» для эксплуатации уязвимостей.
Предположим, что мы хотим освободить блок памяти по адресу *C*. Вполне возможно, что даже с целью триггернуть UAF по этому адресу. Для того, чтобы блок памяти по этому адресу точно освободился, и сделал это предсказуемым образом:
1. Вызываем `ProtectedFree()` для блока *C*. Блок *C* попадает в wait-list и находится там вместе с блоками *Wi* и блоком *B* размера *s*;
2. Выделяем память под большой блок памяти *D* размером 100 000 байт и сразу же его освобождаем. Теперь этот блок памяти попадает в wait-list, и размер wait-list становится >= 100 000 байт;
3. Выделяем память под блок памяти *E* размером *s* и освобождаем его. После вызова `ProtectedFree()` для блока *E*, наш нужный блок *C* и блоки *B* и *D* попадут под процедуру Reclamation Sweep и будут освобождены.
*Рисунок 10 – Итоговое состояние wait-list (источник [[1]](https://www.blackhat.com/docs/us-15/materials/us-15-Gorenc-Abusing-Silent-Mitigations-Understanding-Weaknesses-Within-Internet-Explorers-Isolated-Heap-And-MemoryProtection-wp.pdf))*
Теперь привнесем практики в данную теоретическую стратегию. Необходимо определить объект, который выделяет буферы произвольного размера и освобождает их через `ProtectedFree()`. Парни из ZDI выбрали объект `CStr` – он имеет динамический размер и его можно аллоцировать из вне. Но всегда можно попытаться выбрать другой объект, благо на *ProtectedFree* 1100 xref-ов.
Также, анализуя MSHTML, они нашли, что `CStr` использует метод `CElement::var_getElementsByClassName`. Добраться до него можно через DOM-метод `getElementsByClassName` на любом HTML-элементе (что прямо то, что нужно).
Во время исполнения, данный метод создает `CStr`, содержащий строковые данные, которые передаются в качестве параметра `getElementsByClassName`, а затем удаляет этот `CStr`.
*Рисунок 11 – Код функции `CElement::var_getElementsByClassName`*
Таким образом, одним вызовом `getElementsByClassName` можно достичь цели выделения и освобождения буфера произвольного размера.
Одно небольшое ограничение заключается в том, что минимальный размер буфера со строковыми данными, который мы можем передать `getElementsByClassName`, составляет 0x28 байт. Поэтому `CStr` занимает 0x28\*2 + 6 = 0x56 байт (по два байта на символ, плюс 6 дополнительных байт).
```
var oDiv1 = document.createElement('div');
// Аллоцируем/ освобождаем через ProtectedFree буфер размером string1
oDiv1.getElementsByClassName(string1);
// ...
// Аллоцируем/ освобождаем через ProtectedFree буфер размером string1
oDiv1.getElementsByClassName(string1);
// ...
// Аллоцируем/ освобождаем через ProtectedFree буфер размером string2
oDiv1.getElementsByClassName(string2);
```
Таким образом, используя технику, описанную выше, атакующий может определить любой необходимый ему паттерн выделения и освобождения памяти на «куче». Сложность поведения Memory Protection при освобождении памяти устранена.
Ради интереса, крайне рекомендуется почитать в [1] как можно, используя механизм работы Memory Protection, обойти ASLR.
### Memory Garbage Collector (MemGC)
Следующий механизм, который мы рассмотрим, можно назвать наследником Memory Protection. Он называется Memory Garbage Collector (MemGC), и был представлен в новом движке Edge в Win10. Впоследствии появился и в IE11.
Цель внедрения MemGC такая же, как и у MP, – защита от эксплойтов типа UAF.
Ребята из Microsoft пишут [3], что MemGC работает в том же духе, что и MP, но еще и просматривает «кучу», помимо стека и регистров, на предмет ссылок на защищаемые типы объектов.
Но, конечно, они немного лукавят, и различие не только в дополнительном просмотре куче, но еще и в реализации. Рассмотрим ее подробнее [4].
MemGC использует отдельно управляемую «кучу», которая называется MemGC Heap (незамысловатое название). Она используется для выделения памяти объектам и сборки мусора – по сути, та же операция Reclamation Sweep, только еще и освобождются такие участки памяти, на которые нет ссылок в MemGC Heap. Реализация MemGC в Edge зависит от JavaScript-движка Chakra (новый JS-движок, про него в следующем разделе). Зависимость проявляется в том, что все функции для работы с памятью находятся в нем.
Кстати, Microsoft выложила в открытый доступ исходные коды ядра движка Chakra. Кому интересно, можете посмотреть [здесь](https://github.com/Microsoft/ChakraCore).
Схема выделения памяти, используемая MemGC, включает в себя создание кусков памяти, называемых *«сегменты»* (*Segments*), и затем деление данных *«сегментов»* на страницы (*Pages*) размером 4096 байт. Далее, страницы объединяются в блоки (*Blocks*), а те, в свою очередь, используются для выделения памяти объектам соответствующего размера:
*Рисунок 12 – Схема MemGC Heap (источник [[4]](https://www.blackhat.com/docs/us-15/materials/us-15-Yason-Understanding-The-Attack-Surface-And-Attack-Resilience-Of-Project-Spartans-New-EdgeHTML-Rendering-Engine-wp.pdf))*
EdgeHTML/MSHTML DOM объекты и многие другие внутренние элементы, которые рендерятся движком, управляются MemGC. И поскольку MemGC использует отдельную управляемую «кучу», Isolated Heap, описанная выше, становится не нужна и не используется.
Т.е. фактически, MemGC заменяет собой и Isolated Heap, и Memory Protector, и усложняет эксплуатацию UAF-уязвимостей на обоих шагах (смотри рисунок 1, если забыл о чем речь).
MemGC производит следующие операции:
1. Выделение памяти;
2. Освобождение памяти;
3. «Сбор мусора» (Garbage Collector).
Рассмотрим каждую операцию поподробнее.
**1. Выделение памяти.**
В имплементации MemGC в EdgeHTML, когда объекту, управляемому MemGC, необходимо выделить память, производится вызов функции `edgehtml!MemoryProtection::HeapAlloc<1>()` или `edgehtml!MemoryProtection::HeapAllocClear<1>()`, которая, в свою очередь, производит вызов `chakra!MemProtectedHeapRootAlloc()`.
*Рисунок 13 – Код функции `MemoryProtection::HeapAlloc<1>()`*
`chakra!MemProtectedHeapRootAlloc()` выделит кусок (chunk) из блока (Block) в подходящем «ведре» (Bucket), и затем на такой кусок памяти ставится флаг “root”. “Root”-флаг, в терминологии MemGC, такой объект/кусок памяти, который адресуется напрямую (directly referenced) программой и поэтому не должен попасть под «сборку мусора».
**2. Освобождение памяти.**
Когда необходимо освободить память объекта, вызывается функция `edgehtml!MemoryProtection::HeapFree()`, которая, в свою очередь, вызывает `chakra!MemProtectHeapUnrootAndZero()`.
*Рисунок 14 – Код функции `MemoryProtection::HeapFree()`*
`chakra!MemProtectHeapUnrootAndZero()` пытается определить блок (Block), в котором находится кусок освобождаемой памяти объекта, обнуляет его и сбрасывает флаг «root». Сброс флага «root» для участка памяти делает его кандидатом, попадающим под «сбор мусора» и будет освобожден, если MemGC не найдет ссылок на него.
**3. Сбор мусора (Garbage Collection)**
В тот момент, когда размер всех участков памяти, у которых сброшен флаг «root» превысит динамически вычисляемое пороговое значение, в дело вступит сборщик мусора, который стриггерится функцией `chakra!MemProtectHeap::Collect()`. При «сборке мусора» произведется операция Reclamation Sweep, когда участки памяти со сброшенным флагом “root” и на которые нет указателей, будут освобождены. Некоторые части операции Reclamation Sweep выполняются в отдельном потоке (`chakra!Memory::Recycler::ThreadProc`), который получает уведомление от `chakra!Memory::Recycler::StartConcurrent()`.
Первая фаза – это фаза поиска ссылок на освобождаемые участки памяти. Бит маркировки для всех участков сбрасывается, а затем все «root»-участки маркируются (всё это происходит в `chakra!Memory::Recycler::BackgroundResetMarks()`).
Затем, «root»-участки (т.е. те, что находятся в куче), регистры и стек проверяются на наличие ссылок на освобождаемый участок. Это производится посредством функций `chakra!Memory::Recycler::ScanImplicitRoots()` и `chakra!MemProtectHeap::FindRoots()`). Если на освобождаемый участок найдена ссылка, то он помечается. Участки, которые в итоге оказались непомеченными, освобождаются и становятся доступными для реаллокации.
Более подробно, со всеми структурами и кодом (с блэкджеком и ….), описание этих операций можно посмотреть в [5].
Стоит отметить, что механизм MemGC в IE реализован точно так же, как и в Edge, только все функции располагаются в либе mshtml.dll.
Итак, обобщим отличия между MemGC и Memory Protection:
1. MemGC имеет свою, отдельную от «кучи» процесса, со сложной структурой, и управляет операциями и выделения, и освобождения памяти – т.е. имеет свой менеджер «кучи»;
2. MemGC сканирует не только стек и регистры, но и саму «кучу» на предмет ссылок на освобождаемый блок памяти (скорее всего, в ответ на технику обхода ребят из ZDI :) );
3. Пороговое значение, когда стартует процедура Reclamation Sweep, определяется динамически, в отличие от Memory Protection, где пороговое значение имеет константное значение. Также сама процедура очистки памяти частично производится в другом потоке.
4. MemGC усложняет эксплуатацию UAF и на этапе освобождения памяти объекта, и на этапе реаллокации и перезаписи памяти.
Что касается способов обхода MemGC, то на данный момент неизвестны (про крайней мере, публичные) техники для обхода данного механизма.
Sandbox
-------
Следующий механизм, который мы рассмотрим – «песочница», когда процесс запускается с жестко ограниченными привилегиями. Делается это для снижения способности атакующего писать, изменять, читать данные на пользовательской машине и устанавливать вредоносный код.
В IE данный механизм впервые появился в 7 версии под Windows Vista, и назывался Protected Mode. Затем, в IE10 под Win8, Protected Mode получил своё новое развитие под новым именем – Enchanced Protected Mode (EPM).
Рассмотрим, как устроен EPM изнутри.
### Архитектура
IE и Edge в своей архитектуре «песочницы» следуют Loosely-Coupled IE (LCIE) модели, которая была представлена еще в 8 версии IE. Исполнение браузера происходит в раздельных процессах. Есть процесс-брокер, порождающий дочерние процессы для вкладок. Вкладочные процессы запускаются с урезанными привилегиями, это может быть Low Integrity Level для IE и AppContainer – новая технология изоляции приложений Microsoft — для Edge. Поговорим подробнее о механизмах управления доступом к объектам в Windows.
*Рисунок 15 — Архитектура Sandbox в IE и Edge (источник [[6]](https://www.blackhat.com/docs/asia-14/materials/Yason/WP-Asia-14-Yason-Diving-Into-IE10s-Enhanced-Protected-Mode-Sandbox.pdf))*
Классическая модель разграничения прав доступа к объектам Windows строится на основе ACL – access control lists – списков контроля доступа.
Для объекта доступа указывается или наследуется список DACL (discretionary access control list – дискреционный список контроля доступа), и он содержит такие записи (ACE – access control entries): кому предоставить или запретить доступ какого рода (чтение, запись, запуск и т.п.). При обращении к объекту система берёт маркер доступа (access token) потока, содержащий ряд SID-ов – идентификаторов субъектов: пользователя, групп пользователя и т.п., обходит список DACL объекта и проверяет компоненты списка в отношении субъекта доступа.
Microsoft расширила эту модель защиты доступа, добавив к ней т.н. MIC – mandatory integrity control – мандатный контроль доступа; здесь для субъектов и объектов доступа устанавливается т.н. integrity level – «уровень целостности» (не совсем очевидно, «уровень доступа» было бы точнее). Мандатный контроль доступа реализуется, как запрет обращений к объектам с более высоким уровнем привилегий, чем у субъекта. Мандатный контроль доступа выполняется перед дискреционным.
*Рисунок 16 — Понижение Integrity Level для вкладочных процессов IE*
Это обеспечивает изоляцию потенциально скомпрометированных процессов. При наличии уязвимости типа RCE в IE, это должно сократить импакт возможной атаки, например, помешать закрепиться в системе, записав что-то в критические области реестра или файловой системы.
AppContainer является последним расширением системы разграничения доступа Windows. Новая модель доступа создаёт собственное изолированное пространство объектов для каждого контейнера, ему уже, как полагается, недоступны глобальные объекты операционной системы. Области файловой системы и реестра, выделенные для сохранения данных приложения, имеют созданную для данного контейнера метку, разрешающую доступ специальному субъекту, ассоциированному с данным контейнером. В отличие от мандатного подхода, здесь процессы с сокращёнными привилегиями не имеют доступа к данным друг друга. Помимо индивидуального SID-а каждого контейнера, отдельно для изолируемого приложения специфицируются “capabilities”, такие как internetClient, location или microphone, ограничивающие его возможности.
Однако, для произвольного объекта могут быть заданы правила ACE в списке DACL, разрешающие доступ всем контейнерам, ссылаясь на SID «ALL APPLICATION PACKAGES». Это сохраняет возможность использования системных компонентов контейнизированными процессами, например, загрузки библиотек из системной директории.
*Рисунок 17 — права доступа к системной директории для всех контейнизированных процессов*
Таким образом, для приложения всё же остаётся возможность читать область файловой системы и, аналогичным образом, реестра, в которой хранятся объекты операционной системы и установленного ПО (для “Program Files” добавлен тот же SID). Это, как отмечает исследователь Mark Yanson [6], может применяться для извлечения такой информации, как лицензионные ключи, конфигурационные файлы установленного ПО, также возможно использование утечки об установленном ПО и версиях его компонентов для будущих атак.
Можно выделить основные способы побега из изолированного окружения и выполнения собственного кода вне контейнера:
1. Эксплуатация бинарных уязвимостей процесса-брокера, сервисных процессов, драйверов и ядра операционной системы;
2. Использование пробелов в имеющихся правах доступа, например, возможности запуска с высокими привилегиями доверенного системой приложения, которое определённым способом можно использовать для выполнения запланированных действий, например, через запуск произвольного скрипта.
В качестве примера можно привести недавно попавший во всеобщее внимание драйвер capcom.sys, являющийся запчастью от одной компьютерной игры. Этот драйвер предоставляет одну «замечательную» функцию:
*Рисунок 18 — Уязвимая функция драйвера capcom*
Здесь: отключается SMEP, передаётся управление по адресу, переданному драйверу. Фактически, это исполнение произвольного кода на уровне ядра.
Другой пример. В Windows 10 наличествует процесс dismhost.exe (Disk Cleanup), который может быть запущен непривилегированным пользователем, но при этом будет наделён системой повышенными привилегиями. После запуска он подгружал DLL библиотеки из директории в %TEMP%, доступной для записи текущему пользователю. Это позволяло, подложив туда свою библиотеку, получить исполнение её кода в привилегированном процессе.
Chakra JIT Hardening
--------------------
Реализация JS в современных браузерах Microsoft — IE 11 и Edge – называется Chakra, и содержит специфические для JS движка механизмы защиты от эксплуатации бинарных уязвимостей. Ключевым компонентом современных JS-интерпретаторов является JIT (just-in-time) компилятор, осуществляющий трансляцию JS-кода в машинный код, что положительно сказывается на производительности скриптов на web-страницах.
С точки зрения безопасности, приложения JIT открывают нам некоторые возможности. Мы можем форсировать компиляцию скрипта в машинный код, и получить исполняемые страницы в адресном пространстве процесса с полезным для нас содержимым. В прошлом были актуальны такие техники:
* Изначально код и данные JS не разделялись и размещались JIT компилятором в одном регионе памяти с правами на исполнение, что позволяло, разместив наш шелл-код в массиве в скрипте, сразу получить его исполняемым. Данную операцию можно повторить множество раз, реализовав т.н. «спрей» (JIT spray), заполнив адресное пространство процесса однородными данными – нашим шелл-кодом. Это снимает проблему неопределённости месторасположения нашего шелл-кода.
Теперь JIT отделяет код от данных, делая последние неисполняемыми.
* С течением времени были использованы оставшиеся возможности применения JIT-компиляторов. Константные значения в скрипте (инициализации переменных, например) заносились в машинный код в неизменном виде на известные места от начала скомпилированной функции. Это позволяло удобно заложить ROP гаджеты – маленькие фрагменты кода, которые выполняются последовательно, передавая управление по цепочке друг другу.
Теперь JIT накладывает на константы маски, используя xor, и раскодируя их обратно во время исполнения скомпилированного кода – это “**constant blinding**”. Вторая техника усложнения рандомизирует расположение возможных ROP-гаджетов в сгенерированной функции, вставляя немного мусорных команд в её прологе – это “**insert NOPs**”.
### Constant Blinding
Что у нас теперь осталось? Только возможность вставки маленьких, два байта или меньше, констант – они сохраняются в исходной форме.
Попробуем заложить этими скромными средствами набор ROP-гаджетов, которые потребуются для вызова функции VirtualProtect(addr, size, flags, oldflags). Задача осуществления такого вызова типична для построения эксплойта в Windows, это обычно необходимо для установки атрибутов доступа для страниц памяти с шелл-кодом, т.е. для того, чтобы сделать эту память исполняемой. Прототип функции заключает в себе четыре аргумента: адрес региона памяти, его размер, флаги требуемых атрибутов и указатель на переменную, куда сохранятся старые атрибуты.
Мы будем целиться на x64, где для вызовов WinAPI полагается использовать fastcall, что значит заносить первые аргументы в регистры – rcx, rdx, r8 и r9, а оставшиеся – в стек. Двух байтов, которые мы имеем, нам достаточно для инициализации значением из стека одного из восьми регистров общего назначения: pop R + ret. С rcx и rdx мы справимся, с r8 и r9 все не так просто. Чтобы закодировать команду “pop R”, где R – один из добавленных в x64 архитектуре регистров r8 — r15, придётся поставить перед однобайтовым опкодом инструкции pop префикс смены набора регистров – REX префикс, соответственно, в наши два байта ret уже не поместится. Кроме того, обратим внимание на то, что у нас получится из команды с двухбайтной константой:
```
81 C0 41 58 00 00 add eax, 5841h
___________________________________________
41 58 pop r8
00 00 add byte [rax], al
```
Сразу возникает вторая проблема: необходимо установить в регистр rax адрес на что-нибудь в памяти, куда можно писать, перед тем, как передать управление на такой гаджет. Не забываем о том, что потом нам надо передать управление на следующий гаджет...
По порядку:
* Избежать возникновения исключения при доступе по невалидному адресу в регистре rax мы можем, инициализировав его перед вызовом этого гаджета, тут нам целиком хватит маленькой незамаскированной двухбайтной константы **0xc358** :)
```
58 pop rax
C3 ret
```
* Передача управления. Если для JIT-а подготовить предельно простую JS функцию, то после нашего гаджета у функции останется относительно короткий «хвост».
```
function f(addr) {
return addr + 0x5841;
}
```
*Рисунок 19 — Хвост скомпилированной функции: a. выровненный по командам; b. выровненный с ROP гаджета в константе. Картинка взята из исследования [[7]](http://users.ics.forth.gr/~elathan/papers/ndss15.pdf)*
Этот «хвост» сможет исполниться до конца, если подготовить для него регистры и стек.
### Insert NOPs
Этот нехитрый способ рандомизации расположения скомпилированного кода в выходном буфере JIT-компилятора стоит проиллюстрировать листингами, полученными за несколько последовательных запусков браузера с тестовым скриптом.
```
0000 mov rax, 2B5C990h
000A cmp rsp, rax
000D jg loc_2AE0034
0013 mov rdx, 500790h
001D mov rcx, 990h
0027 mov rax, 7FEF3435450h
0031 jmp rax
0034 ; ---------------------------
0034
0034 loc_2AE0034:
0034 mov rax, 23D61A8h
003E inc byte ptr [rax]
0040 jnz loc_2AE0049
0046 mov byte ptr [rax], 0FFh
0049
0049 loc_2AE0049:
0049 mov [rsp+20h], r9
004E mov [rsp+18h], r8
0053 mov [rsp+10h], rdx
0058 mov [rsp+8], rcx
005D push rbp
005F mov rbp, rsp
0062 sub rsp, 10h
0066 push rdi
0068 push rsi
006A push rbx
006C sub rsp, 38h
0070 xor eax, eax
0072 mov [rbp-8], rax
```
*Тут NOP-ов нет.*
```
0000 mov rax, 33CC990h
000A cmp rsp, rax
000D jg loc_3160035
0013 mov rdx, 326890h
001D mov rcx, 990h
0027 mov rax, 7FEF3435450h
0031 jmp rax
0034 ; ---------------------------
0034 nop
0035
0035 loc_3160035:
0035 mov rax, 2FAC1A8h
003F inc byte ptr [rax]
0041 jnz loc_316004A
0047 mov byte ptr [rax], 0FFh
004A
004A loc_316004A:
004A mov [rsp+20h], r9
004F mov [rsp+18h], r8
0054 mov [rsp+10h], rdx
0059 mov [rsp+8], rcx
005E push rbp
0060 mov rbp, rsp
0063 sub rsp, 10h
0067 push rdi
0069 push rsi
006B push rbx
006D sub rsp, 38h
0071 xor eax, eax
0073 mov [rbp-8], rax
```
*Обратите внимание на смещение 34h. Всё сдвинулось.*
```
0034 nop dword ptr [rax]
0037 nop dword ptr [rax+00h]
003B xchg ax, ax
```
*Бывают и другие NOP-ы, разной длины.*
В данной ситуации установить действительное расположение данных возможно, разве что осуществляя чтение по произвольным адресам.
### JIT & CFG (Control Flow Guard)
Попутно замечен интересный момент — пробел в реализации CFG в Windows 8.1. Подробнее об этом механизме можно почитать в статье нашего коллеги [8].
Области памяти, занятые скомпилированным JIT-ом кодом, занесены в битовую карту процесса, допускается передача управления в них, как, например, выше — в опкоды, заложенные в константах.
Однако, проверка адреса CFG, хотя в данном случае и пропускает вызов, имеет побочный эффект — портит значение в регистре **rax**, которое для приведённой техники является необходимым. Для случая подмены таблицы виртуальных методов в контролируемом объекте это вызывает для нас неудобства: если мы решим сделать JIT ROP, сначала нужно будет перекинуть указатель стека **rsp** в наши данные для контроля потока управления, а поскольку пока мы стек не контролируем, то регистр **rsp** остаётся инициализировать только значением другого регистра, и весьма удобно, если бы это был **rax** — валидный указатель на память, куда можно писать (он указывал в vtable!), чтобы не обломаться на `add byte [rax], al`. Но теперь он необратимо испорчен.
```
mov rax, [rdi] ; this->vtable
mov rbx, [rax+208h] ; ptr = vtable[idx]
mov rcx, rbx ; _QWORD
call cs:__guard_check_icall_fptr
mov rcx, rdi ; this
```
Но JIT-компилятор существует не только для JS. Мы рекомендуем вам ознакомиться с замечательным исследованием слабостей компилятора WARP браузера Edge, который в своём развитии повторил проблемы JIT-компилятора JS [9].
Заключение
----------
На примере браузеров – IE и Edge — можно наблюдать процесс эволюционного усложнения техник атаки и механизмов защиты, непрерывное противоборство щита и меча. Баги остаются, но эксплуатация уязвимостей становится всё сложнее — увеличивается стоимость использования существующих ошибок. Однако, природа этих ошибок не меняется, поскольку применяются те же языки и среда исполнения. Не изменяется сам код уязвимых частей браузера, но накладываются механизмы, направленные на предотвращение существующих путей эксплуатации багов.
Источники
---------
1. <https://www.blackhat.com/docs/us-15/materials/us-15-Gorenc-Abusing-Silent-Mitigations-Understanding-Weaknesses-Within-Internet-Explorers-Isolated-Heap-And-MemoryProtection-wp.pdf>
2. <https://securityintelligence.com/understanding-ies-new-exploit-mitigations-the-memory-protector-and-the-isolated-heap/>
3. <https://blogs.technet.microsoft.com/srd/2016/01/12/triaging-the-exploitability-of-ieedge-crashes/>
4. <https://www.blackhat.com/docs/us-15/materials/us-15-Yason-Understanding-The-Attack-Surface-And-Attack-Resilience-Of-Project-Spartans-New-EdgeHTML-Rendering-Engine-wp.pdf>
5. <https://github.com/zenhumany/hitcon2015>
6. <https://www.blackhat.com/docs/asia-14/materials/Yason/WP-Asia-14-Yason-Diving-Into-IE10s-Enhanced-Protected-Mode-Sandbox.pdf>
7. <http://users.ics.forth.gr/~elathan/papers/ndss15.pdf>
8. <https://habrahabr.ru/company/dsec/blog/305960/>
9. <https://472ac6bb-a-62cb3a1a-s-sites.googlegroups.com/site/bingsunsec/WARPJIT/JIT%20Spraying%20Never%20Dies%20-%20Bypass%20CFG%20By%20Leveraging%20WARP%20Shader%20JIT%20Spraying.pdf>
Авторы
------
* Козорез Максим
* Турченков Дмитрий / [@d-t](https://habrahabr.ru/users/d-t/) | https://habr.com/ru/post/311616/ | null | ru | null |
# Как проходит интервью QA-инженеров в Тинькофф
Я Алексей Лапаев, руководитель команды обеспечения качества мобильного приложения Тинькофф и организатор гильдии интервьюеров веб-стрима найма QA. Расскажу, как проходит отбор на вакансии QA-инженеров, что спрашивают на первичном интервью и какие секции и задачи ждут в технических блоках.
Договоримся, что термины «тестировщик», «QA» и «инженер» равнозначны и используются с целью разнообразить слог. Профессионально мы строим команды фулстек-QA-инженеров, но идеологию затронем лишь вкратце. Материал будет полезен тем, кто интересуется процессами в крупных компаниях, видит свое будущее в качестве QA-инженера или хочет работать именно в Тинькофф. Если это про вас — добро пожаловать под кат!
Этапы отбора
------------
Мы ищем специалистов в первую очередь в Тинькофф. Определяемся с командой после того, как успешно пройдены этапы отбора. Сейчас мы набираем инженеров по трем разным стримам.
**Web** — все, что связано с тестированием сайтов, их бэкендов, админок и веб-экосистемы. QA в этом стриме обеспечивают качественную работу фронтов личных кабинетов клиентов, публичных порталов вроде tinkoff.ru и большого многообразия пользовательских интерфейсов, видимых только внутри.
**Mobile —** тестирование мобильных приложений и сервисов, которые нужны для работоспособности приложений. По этому стриму идут кандидаты, которых интересует тестирование мобильных приложений и сервисов за ними, нужных для работы этого вида фронтов.
**Backend**, который обеспечивает качество работы тех систем, которые не видны конечному клиенту. Без него не обходится работоспособность ни веб-части, ни мобильных приложений, ни других сложных частей экосистемы, которые работают с данными.
В Тинькофф для инженеров QA четыре этапа отбора: предварительное собеседование, профильное собеседование, техническое интервью и знакомство с командой. Вот как они выглядят в таблице:
**Первый этап** — интервью с рекрутером в «Зуме». Наш специалист спрашивает об опыте работы, о проектах, в которых удалось поучаствовать. Может спросить подробнее о мотивации, отношении к компании и ожиданиях от нее, о технических интересах, локации и прочем.
Рекрутер задаст несколько технических вопросов начального уровня, чтобы сразу понимать, насколько мы подходим друг другу. По каждому стриму у нас есть пул легких вопросов, что-то вроде технической базы, которую должны знать все QA-инженеры.
Обязательно будет вопрос «Кем вы видите себя через n лет?» Раньше спрашивали про пять лет, но пять — это очень долго, поэтому спрашиваем про два года. Нам важно, как человек мыслит и куда он хочет профессионально вырасти, потому что мы рассчитываем на долгосрочное сотрудничество.
Есть люди, которые через QA пытаются зайти в ИТ и стать разработчиком, иногда хотят примерить другую специальность. Часто мелькает, что тестирование — это легкий старт в ИТ-карьере. Здесь мы расходимся во взглядах и не приветствуем это.
В конце рекрутер попросит оценить свой профессиональный уровень по трем стримам найма. В зависимости от ответов выбираем приоритетную секцию технического собеседования. Например, если специалист говорит, что он хорош в бэкенде, а мобилка и веб — так себе, то мы направим его на собеседование в соответствующий стрим бэкенда. Отдаем приоритет выбранному стриму.
Если определиться с лидирующим направлением сложно, мы направляем на интервью по двум стримам и выбираем наиболее результативное — где получилось ответить на большее количество вопросов и где выше уровень владения навыками.
**Второй этап** — профильное собеседование, которое проходит по одному из трех стримов в формате созвона в «Зуме» и длится 1,5 часа. Секцию тестирования проводят действующие тестировщики соответствующего уровня. Чтобы пообщаться с джунами, мы зовем мидлов, для мидлов — старших тестировщиков. Стараемся, чтобы интервьюер был на один грейд постарше.
Для профильных собеседований у нас существует гильдия интервьюеров, ее задача — проводить собеседования по нашим стандартам профессиональных уровней. В первую очередь мы собеседуем в компанию Тинькофф, а потом уже профилируем на сами команды, где будет работать тестировщик.
В гильдию входят действующие QA-инженеры, которые делят свое рабочее время между задачами тестирования и собеседованиями. Они проводят технические секции и находят себе коллег в широком смысле этого слова — в свою команду или в соседние.
Гильдия тоже разделена на три стрима: ребята по веб-части, специалисты мобилок и профи на бэкенде. В зависимости от профиля тестировщика мы зовем того или иного интервьюера. Его задача — более углубленно поспрашивать по тому стриму, в котором у человека больше всего нужного опыта и знаний.
На этом этапе появляются технические вопросы по инструментам, которые используются в том или ином стриме: по фреймворкам автотестирования, по системам, из которых строится инфраструктура. Например, какие кейсы проверки знает тестировщик, как будет разбираться и какие специфичные знания у него есть. Оценивается, насколько хорошо человек владеет профильными знаниями.
В итоге проводится оценка, как получилось справиться с профильной секцией. Если что-то пошло не так и не получилось ответить на вопросы — дадим обратную связь, какие скиллы подтянуть и что почитать. Если все прошло успешно, пусть даже не на предполагаемый уровень, мы общаемся дальше и переходим на следующий этап. А о том, какие вопросы бывают на профильном собеседовании, расскажем в следующей части статьи.
**Третий этап** — технический. Он делится на две секции: теория и практика QA и программирование по 45 минут каждая.
Теория обеспечения качества — это проверка теоретических знаний: как построить пирамиду тестирования, как расписать тестовую модель, как писать тест-кейсы, где их хранить, что такое тестирование, что стоит проверять, а что не стоит, как можно побить проверки по функциональности приложения.
Можем поговорить про нефункциональные проверки: нагрузочное тестирование, тестирование производительности в более широком смысле, тестирование безопасности — то, что не связано напрямую с функциональностью приложения. Не про нажатие кнопок, а про какие-то технические свойства систем. Секцию проводят инженеры, которые проводят профильные секции и может так получиться, что один и тот же интервьюер будет на профильной секции и на теории обеспечения качества, а могут быть разные.
Второй блок — программирование. Этот блок наиболее пугающий, потому что мы просим кандидатов владеть каким-то языком программирования.
На самом деле блок страшный только по названию: мы не спрашиваем сложные паттерны или конструкции, владение алгоритмами или еще что-то. Просим написать простую функцию, которая делает какую-то простую вещь.
Например, возвращает копию строки, в которой каждое слово начинается с заглавной буквы — это базовая задача для тех, кто начинает изучать язык программирования. Ее описание есть во всех книжках по программированию, в тренировочных курсах или видео. Таких задач несколько — чтобы разнообразить то, что мы предлагаем тестировщикам, и не засветить их в открытом пространстве. Все задачки легкого уровня с действиями над строкой, числом или что-то похожее.
Суть этой секции — понять насколько человек не боится языка программирования, насколько он с технической точки зрения готов к тому, с чем предстоит работать, и тут цель стратегическая.
Мы хотим наших тестировщиков видеть fullstack-QA-инженерами. Под fullstack мы подразумеваем, что тестировщики могут не только руками проверить функциональность сервисов, но и смогут проверки автоматизировать. Чтобы руками делать как можно меньше и тратить время на более сложные и интересные задачи, развивать функциональность и развиваться самому специалисту.
Для автоматизации нужен язык программирования — для этого мы и проверяем его на входе. Если человек владеет языком на базовом уровне — он нам подходит, если не боится писать код — он нам подходит, если он потратил все 45 минут, чтобы решить пару задач — он нам подходит. Мы готовы вкладываться в обучение и развитие таких людей и показывать, как у нас все работает внутри, давать материалы для развития.
Тех, кто успешно прошел технические блоки, приглашают **на финальные интервью** с командами. Ответственные за подборы в командах знакомятся с результатами предыдущих этапов и оставляют заявку, что хотели бы познакомиться с кандидатом.
Финальных знакомств может быть несколько, если несколько команд будут искать именно такого специалиста.
Каждая встреча длится около 30 минут. Цель этих встреч не проверить какие-то знания, а пообщаться и проверить совместимость. Будущие коллеги знакомятся друг с другом, обсуждают особенности проекта и конкретные задачи.
Встреча состоит из двух частей: в первой мы расспрашиваем человека, а во второй рассказываем о команде, чтобы интересный кандидат пришел именно в нашу команду. Отвечаем на все вопросы, которые могут появиться.
Ждем вопросов о том, что беспокоит, какие-то боли на текущем месте работы, которые закрыть не получилось. На финальном знакомстве понимаем, можем ли мы быть перспективными для человека или не можем, чтобы не создавать обманутых ожиданий. Хотим, чтобы кандидату было комфортно работать в предлагаемой команде и команда сразу получила результат.
Если все складывается хорошо, то рекрутер создает оффер-встречу с выбранной командой. На этой встрече говорим предметно о зарплате, цифрах, проектах, обязанностях, графике и других рабочих моментах.
После оффер-встречи оставляем тестировщику время подумать и принять окончательное решение.
Бывают случаи, когда нужно закрыть дела на прошлом месте работы, и человек просит время. Мы готовы ждать и рассчитываем на то, что, если через несколько лет он будет покидать нашу команду, так же ответственно отнесется к передаче дел и возьмет продолжительную паузу.
Что оценивают на профильном и техническом собеседованиях
--------------------------------------------------------
На этих этапах нужно показать свои знания в профильных стриму технологиях и инструментах, теории обеспечения качества и немного покодить вживую. Все вопросы предполагают оценку глубины ответов, поэтому не стоит зубрить определения: у интервьюера есть возможность уйти чуть в сторону от прямого ответа и попросить кандидата раскрыть термины или решить минутный мысленный эксперимент. Чтобы было понятнее, приведу примеры вопросов и задач, которые встречаются в секциях.
**Цель профильной секции собеседования** — проверить знания стека технологий, инструментария и практик тестирования в выбранном кандидатом стриме. Вопросы могут быть как полностью специфичные стеку, так и из смежных областей. Например:
1. В чем отличие тестирования мобильного приложения от десктопного, от web?
2. Различия версий HTTP? Различия методов HTTP-запросов?
3. Что такое микросервис? Что такое брокеры сообщений?
Задаем классические вопросы по SQL о JOIN и предлагаем задачи на составление простых запросов. Можем задать и углубленные вопросы по оптимизации запросов для специалистов, претендующих на высокие позиции QA систем, обрабатывающих данные.
**Цель секции теории и практики QA** —проверить знания кандидата в области обеспечения качества, его умение пользоваться артефактами, техниками и подходами, сложившимися в нашей профессии. Мы спрашиваем:
1. Методологии разработки ПО, их преимущества и недостатки.
2. Практики shift left и shift right тестирования.
3. Задачи, например «Вы обнаружили дефект в своем функционале. Ваши действия?».
Это не исчерпывающий список, но многие вопросы неоднократно обсуждаются в профильных форумах, сообществах и рекомендуемых книгах.
**Цель секции по программированию** — проверить знания базовых структур данных, синтаксиса и умение писать код на том языке, который заявлен в резюме. Вот несколько примеров задач:
1. Определите, сколько рублей и копеек нужно заплатить за N пирожков, если пирожок в столовой стоит А рублей и В копеек. На вход 3 числа: рубли, копейки и количество пирожков. На выходе 2 числа: рубли и копейки.
2. Найти все полки в библиотеке, на которых стоят книги Ремарка.
```
using System;
using System.Collections.Generic;
public class Program
{
public static void Main()
{
var shelves = new Dictionary{
{"полка 1", new string[]{"1984", "три товарища"}},
{"полка 2", new string[]{"убить пересмешника",
"герой нашего времени"}},
{"полка 3", new string[]{"10 негритят", "на западном
фронте без перемен"}}
};
var books = new Dictionary{
{"1984","оруэлл"},
{"три товарища", "ремарк"} ,
{"убить пересмешника", "ли"},
{"герой нашего времени", "лермонтов"},
{"10 негритят", "кристи"},
{"на западном фронте без перемен", "ремарк"}
};
}
}
```
3. Что будет записано в переменную a?
```
s = 'iamstring'
a = s[3:5:1]
```
По каждой из секций подробные ответы кандидата собираются в отдельную карточку результатов. На эти результаты ориентируются нанимающие менеджеры, перед тем как позвать кандидата на знакомство с командой.
Карточка специалиста в начале отбораТак выглядит карточка, когда специалист уже ответил на вопросыВо время технического интервью кандидаты отвечают на вопросы и набирают баллы, а интервьюеры пишут свое заключение и передают его рекрутерамПосле этого интервьюер составляет саммари, отправляет его рекрутеру, и тот возвращается с фидбэком к кандидату.
Тайминг: сколько времени занимают этапы
---------------------------------------
Первичный телефонный разговор длится 30—40 минут, после этого рекрутер отправляет ответы техническим специалистам. Рекрутер возвращается через несколько дней, чтобы пригласить на профильное собеседование. Дата и время зависят от пожеланий кандидата.
Профильное собеседование длится до 90 минут, после него интервьюер сразу направляет обратную связь рекрутеру. Если все складывается хорошо, зовем на следующий этап — техническое интервью. Здесь дата и время также зависят от пожеланий тестировщика, а интервью длится 1,5 часа — по 45 минут на каждую секцию.
Фидбэк по техническому интервью мы получаем в тот же день. Дальше приглашаем на финальное интервью, чтобы познакомить с командами и решить, в какой проект пойдет QA-инженер. Обычно это занимает один день, но иногда может занять несколько. После этого начинаем согласовывать оффер и встречаемся на оффер-встрече, чтобы озвучить цифры, поговорить о задачах. После даем время на принятие окончательного решения и готовимся к выходу нового специалиста.
В среднем от первичной проверки до оффера проходит 27 календарных дней[Про QA в Тинькофф рассказали на нашей странице экспертизы](https://l.tinkoff.ru/qa-career-at-tinkoff) — присылайте резюме, если нам удалось заинтересовать. А 17 сентября проведем [One Day Offer для QA-инженеров (backend)](https://l.tinkoff.ru/qa-odo) с опытом от 2 лет — зарегистрироваться можно до 15 сентября. Если остались вопросы — разберем их в комментариях. | https://habr.com/ru/post/686996/ | null | ru | null |
# IP-адрес удостоверяющего центра Digicert внесен в реестр запрещенных сайтов
29 сентября Роскомнадзор, следуя решению Октябрьского районного суда г. Ставрополя от 2013 года, внес IP-адрес 93.184.220.29 в реестр запрещенных сайтов. Данное решение суда обязывает заблокировать сайты и мобильные приложения некоторых букмекерских контор, и если с блокировкой веб-сайтов все очевидно, то, по всей вероятности, с ограничением работоспособности приложений эксперты Ставропольской прокуратуры (от их имени было подано исковое заявление) сталкивались впервые, и просто задекларировали все IP-адреса, к которым обращалось приложение в момент запуска, включая адреса CRL (списка отзыва сертификатов) и серверов OCSP (сервер проверки состояния сертификатов) глобальных удостоверяющих центров, которые используются для шифрования по протоколу HTTPS.
Об этом решении суда стало известно благодаря блокировке ссылок на файлы CRL Comodo в июле этого года ([«Роскомнадзор заблокировал самого себя и некоторые сайты правительства (Comodo)»](https://geektimes.ru/post/278804/) от [BupycNet](https://geektimes.ru/users/bupycnet/)), теперь же в реестр внесен адрес, принадлежащий другому удостоверяющему центру — Digicert.
```
$ host crl3.digicert.com
crl3.digicert.com is an alias for cs9.wac.phicdn.net.
cs9.wac.phicdn.net has address 93.184.220.29
$ host ocsp.digicert.com
ocsp.digicert.com is an alias for cs9.wac.phicdn.net.
cs9.wac.phicdn.net has address 93.184.220.29
```
Так, при попытке открыть сайты, использующие сертификаты Digicert, в Firefox и Chrome, вы столкнетесь с 3 или 10-секундной задержкой из-за невозможности проверки статуса сертификата, или вовсе лицезреть ошибку в браузерах, которые не позволяют открыть сайт в случае проблем проверки сертификата на отозванность (Safari на OS X).
Автор и комментаторы сайта shortcut.ru в заметке [“Почему на Маке не работает Facebook”?](http://www.shortcut.ru/2016/10/03/when-in-doubt-use-sniffer/) отмечают неработоспособность Facebook.com и Github.com в Safari с 3 октября и предлагают отключить проверку отзыва в настройках ОС.
```
X509v3 Subject Alternative Name:
DNS:*.facebook.com, DNS:*.facebook.net, DNS:*.fb.com, DNS:*.fbcdn.net, DNS:*.fbsbx.com, DNS:*.m.facebook.com, DNS:*.messenger.com, DNS:*.xx.fbcdn.net, DNS:*.xy.fbcdn.net, DNS:*.xz.fbcdn.net, DNS:facebook.com, DNS:fb.com, DNS:messenger.com
X509v3 CRL Distribution Points:
Full Name:
URI:http://crl3.digicert.com/sha2-ha-server-g5.crl
Full Name:
URI:http://crl4.digicert.com/sha2-ha-server-g5.crl
```
[Запись в реестре на сайте Роскомсвободы](https://reestr.rublacklist.net/rec/108101/)
**UPD:** IP исключен из реестра 10.10.2016. | https://habr.com/ru/post/357196/ | null | ru | null |
# Стартап с другой планеты
Привет, Хабр! Мы стартап Deep.Foundation, и сегодня мы официально публикуем альфа-версию своей портальной пушки Deep.Case!
Что же мы такое создали?
Мы создали универсальную мультипарадигменную архитектуру, поставляемую в качестве кроссплатформенного приложения, которую можно описать так: дата-ориентированное операционное пространство ассоциативного представления данных.
Для чего?
Мы мечтаем жить в мире, где менять проект так же легко, как и создавать его с нуля.
Мы мечтаем жить в мире, где можно модифицировать бизнес-логику и расширять ее без полного рефакторинга системы даже на десятый год работы бизнеса.
Мы мечтаем жить в мире, где вы можете использовать свой код снова и снова, чтобы не приходилось выдумывать велосипед каждый новый проект.
Мы мечтаем вывести бизнес-логику за пределы кода.
Мы мечтаем, чтобы программисты занимались творчеством, а не рутиной.
И чтобы воплотить наши мечты в жизнь мы придумали Deep
Давайте вместе узнаем, получилось у нас или нет?
Просто представьте себе, что это сказка. Портал в другую реальность, куда вы можете прямо сейчас войти.
МультипарадигменностьАссоциативность в едином адресном пространстве, как универсальный язык, позволяет абстракциям взаимодействовать на принципиально ином смысловом уровне. Связями можно описать практически любую структуру, при этом не упираясь в потолок гибкости платформы.
АрхитектураDeep в версии alpha.0 - это среда хранения данных, реагирования на семантически обусловленные события в памяти, выполнения кода в изолированных контейнерах, управляемых нашим оркестратором. Таким образом, Deep предоставляет GraphQL API доступа к ассоциативной памяти с контекстнозависимой правовой системой и мультиязыковым мультиплатформенным стандартом выполнения кода в разных средах как docker/lxd/kuber/... в качестве реакций на события в связях или роутинге.
ПриложениеДля удобства разработки, система поставляется с приложением для Mac, Windows, Linux, как самостоятельное разворачиваемое решение в Docker и любыми другими способами. Вскоре добавим больше способов посадить семя глубины в таких средах как Kubernetes, Amazon, Azure, Heroku... и многие другие.
Дата-ориентированноData Driven Development - теория, тесно связанная с реактивностью и с Markov decision process в Reinforcement Learning, который используют в DeepMind.
Базовая идея: в центре всего сверхгибкое хранилище состояния. Все данные хранятся в нем. Большинство выполняемых вычислений - внутренние реакции на события в памяти, так как единственный API доступа - доступ к CRUD операциям над памятью.
И в пространстве ассоциативности Deep решает вопрос совместимости любых моделей данных в общем виде.
Пожалуйста, положите вилы, сейчас все подробно расскажем. И да, не надо верить нам на слово, идите и изучите, ниже будут ссылки на документацию.
Это полностью Open Source решение <https://github.com/deep-foundation>. Оно доступно всем, бесплатно. Основные системы разрабатываются под открытыми лицензиями. Каждый может использовать Deep в своей работе, без каких-либо дополнительный условий, или возникающих препятствий.
МонетизацияДля проектов, чьи нагрузки не умещаются на одну машину, мы будем поставлять продвинутый балансировщик для нашего оркестратора нагрузок, который будет автоматически распределять вычисления и хранение между машинами в разных регионах.
После выпуска релизной stable версии (сейчас только альфа) мы создадим Deep.Space облачное решение для быстрой развёртки, балансировки, быстрых переездов между регионами и экземплярами Deep, соблюдения международных принципов вычисления и хранения информации, и целостной работы системы сквозь все границы и стандарты. Выполнения платных пакетов с открытого рынка разработчиков в недоступной пользователю части его арендованных мощностей согласно трехстороннему договору с провайдером, так чтобы связи управляющие этим воспринимались как естественная часть экосистемы конкретного deep экземпляра.
### Для начала, что такое Deep?
Ранее мы публиковали две статьи на тему того, что есть ассоциативные связи. [Тык](https://habr.com/ru/post/576326/) и [тык](https://habr.com/ru/post/576398/)
Это пространство, состоящее из связей как из минимальных единиц смысла. В нем существуют законы, позволяющие с помощью связей определять деревья, селекторы и правила для операций над связями. В связях может храниться код, который Deep самостоятельно запускает в изолированных средах в качестве реакции как на внутренние ассоциативные события, так и на внешние раздражители.
СвязиСвязь - это хранимая единица смысла.
Каждый линк имеет тип - другой линк. Линк, играющий роль типа, типизирует то, каким может быть его дочерний линк экземпляр (созданный с type\_id полем указывающим на него). Например если у него не будет from\_id и to\_id линк экземпляр не сможет иметь from\_id и to\_id, а если они будут указывать на конкретные типы, линк экземпляр сможет указывать ими только на соответствующие типы. Подробнее про типизацию в главе [Typing](https://www.notion.so/Typing-e6c0bc26a4834efabe0ae44ece1deadc).
Над связями можно производить операции через GraphQL ([как открыть GraphQL playgroud в Deep](https://www.notion.so/GraphQL-12a676a2508541cf9a63cfeb564ffe7d)) и через [DeepClient](https://www.notion.so/DeepClient-ce72ce9537564cc283b45c83fd4b779f). Подробнее про операции [в главе Links](https://www.notion.so/Links-880c4be298c1457e8b82be992bc32144).
У связей могут быть value типа string, number и object. Возможность их существования так-же типизируется на уровне описания типа.
```
import { minilinks } from '@deep-foundation/deeplinks/imports/minilinks';
import { DeepClient } from '@deep-foundation/deeplinks/imports/deepclient';
apolloClient;
const deep = new DeepClient({ apolloClient });
// client methods select,insert,update,delete gets options as second argument
// options always contains: { table, returning, variables, name }
await deep.select(id); // { data: [Link] }
await deep.select([id]); // { data: [Link] }
await deep.select({ id: { _in: id } }); // { data: [Link] }
await deep.insert({}); // { data: [{ id }] }
await deep.insert({
id, // can be reserved with client.reserve(count)
from_id, to_id, type_id
});
// insert with nested links and values
await deep.insert({
type_id: 1,
string: { data: { value: 'Abc' } } // https://github.com/deep-foundation/deeplinks/issues/30
from: { data: { type_id: 1 } },
to: { data: { type_id: 1 } },
});
await deep.update({ link: { type: { _in: [1,2,3] } } }, { value: 'abc' }, { table: 'table123' }); // { data: [{ id }] }
await deep.update(id, { value: 'abc' }, { table: 'table123' }); // { data: [{ id }] }
await deep.update([id], { value: 'abc' }, { table: 'table123' }); // { data: [{ id }] }
await deep.delete({ type: { _in: [1,2,3] } }); // { data: [{ id }] }
await deep.delete(id); // { data: [{ id }] }
await deep.delete([id]); // { data: [{ id }] }
await deep.reserve(5); // reserve count: 5 ids // [167,168,169,170,171]
await deep.await(linkId); // await all link promises resolved and rejected
// get id by packageName/userId and contain names (as Promise)
await deep.id('@deep-foundation/core', 'Promise') // 9
// Promise link in core package have global id 9 in storage
// client types cache and minilinks deepclient integration coming coon...
// in react can be used hook
import { useDeep } from '@deep-foundation/deeplinks/imports/client';
const deep = useDeep();
```
ДеревьяАссоциативные связи могут строить множество разнообразных моделей данных, и деревья по связям могут быть представлены в любом направлении. Механика деревьев в Deep обеспечивает универсальный язык описания правил материализации путей, учитывая, что одна связь может быть как в нескольких деревьях, так и иметь множество родителей. Да, деревья не поддерживают рекурсию в структуре и предотвращают ее в рамках транзакции. Наличие таких деревьев позволяет получить предельную гибкость. Больше не нужно продумывать модель данных, исходя из оптимальной индексации. Можно построить модели данных, и лишь затем построить деревья по ним.
Теория и примеры деревьев в Deep [в документации](https://www.notion.so/Trees-2171e732508244fc9065a8367781bae8).
Исходный код в репозитории <https://github.com/deep-foundation/materialized-path>.
Мы постараемся вскоре выпустить статью с подробным разбором алгоритма.
Пример:
```
{
links(where: { id: { _eq: 345 } }) {
id # нашли связь 345
up(args: { tree: 353 }) {
# ищем все связи выше по дереву 353 (дерево как и все в системе тоже связь)
id type_id from_id to_id
}
}
}
```
```
{
"data": {
"links": [
{
"id": 345,
"up": [
{
"id": 343,
"type_id": 328,
"from_id": 0,
"to_id": 0
},
{
"id": 344,
"type_id": 328,
"from_id": 0,
"to_id": 0
},
{
"id": 345,
"type_id": 328,
"from_id": 0,
"to_id": 0
},
{
"id": 346,
"type_id": 330,
"from_id": 344,
"to_id": 345
},
{
"id": 347,
"type_id": 330,
"from_id": 343,
"to_id": 344
}
]
}
]
}
}
```
СелекторыЭто структура из связей, позволяющая хранить правило выделения ассоциативных связей. Это можно сравнить с хранимым запросом, только кроме SQL-like синтаксиса boolean\_expression(а) используется предварительная проверка на попадание связи в указанное под-дерево, что позволяет хранить в базе критерии для предикатов выполняемого кода (поиска входящих значений) или для прав в правовой механике.
Подробнее про селекторы в Deep в [документации](https://www.notion.so/Selectors-564c4e73c7094d96abe3587fab968fcd).
```
{
s1:selectors(where: {
# 340 связь входит в селектор 348
item_id: { _eq: 340 }, # A6
selector_id: { _eq: 348 },
}) {
selector_id item_id
}{
s2:selectors(where: {
# 345 связь не входит в селектор 348
item_id: { _eq: 345 }, # A5
selector_id: { _eq: 348 },
}) {
selector_id item_id
}
}
```
```
{
"data": {
"s1": [
{
"selector_id": 348,
"item_id": 340
}
],
"s2": [],
}
}
```
ПравилаЭто структура из связей, которая позволяет использовать разнонаправленные [деревья индексации](https://www.notion.so/Trees-2171e732508244fc9065a8367781bae8) и [селекторы](https://www.notion.so/Selectors-564c4e73c7094d96abe3587fab968fcd) по ассоциативной сети для установления правил. Она используется системой для свободной, зависимой от контекста, кастомизации правил select/insert/update/delete в зависимости от типа или попадания в селекторы по деревьям. [Подробнее о правилах.](https://www.notion.so/Rules-841005d9110e4d8b9402761d963f936c)
Пример из документации.
```
{
can1:can(where: {
subject_id: { _eq: 348 }, # User
object_id: { _eq: 340 }, # A6
action_id: { _eq: 349 }, # Dance
}) {
subject_id object_id action_id
}
can2:can(where: {
subject_id: { _eq: 348 }, # User
object_id: { _eq: 345 }, # A5 <==
action_id: { _eq: 349 }, # Dance
}) {
subject_id object_id action_id
}
}
```
```
{
"data": {
"can1": [
{
"subject_id": 348,
"object_id": 340,
"action_id": 349
}
],
"can2": [].
}
}
```
Deep - это концепция, некий мета-язык, который сам по себе ничего не значит, но через который могут быть выражены все другие концепции. От языковых до программных.
Это возможно за счет универсальности единицы смысла, вы, фактически, можете тут создать любой продукт на любом языке программирования, используя ассоциативную память как семантическое ядро.
Мы развиваем ассоциативный пакетный менеджер, который, аккуратно интегрируя их в систему, позволит устанавливать ассоциативные связи, публиковать и разрабатывать их, не покидая Deep.Case.
Проект может быть собран из пакетов, разрабатываемых для него на одном языке, может быть расширен на других языках, путем наслаивания новых ассоциативных пакетов и подменой старых. Через пять лет это все не потребуется рефакторить. Только подменить устаревшие элементы в единой архитектуре.
#### Больше никакого legacy!
Но, давайте теперь подробнее. Как оно работает.
Если в классическом микросервисном подходе программный код взаимодействует по API с программным кодом в этом или другом процессе, а данные служат лишь внутренним слоем хранения, то в Deep - все наоборот. Ассоциативные данные в центре всего. Код больше сам по себе не существует, кроме как в форме реакции на внешнюю среду или обработчика ассоциативных событий.
Что это значит:
Ассоциативные данные доступны по единому API, в котором любые действия в системе выражены созданием/изменением/удалением связей от имени (jwt) той или иной связи в качестве авторизованного “юзера”, как это обычно называлось.
Все абстракции вашего проекта, предприятия, науки, бизнес-плана, языка, юридической фикции, идеологической или философской формации описаны в одном месте, на одном языке и могут быть опубликованы и установлены как пакеты в пакетном менеджере ([подробнее о пакетах в документации](https://www.notion.so/Packager-3a20f835df004ee3ad55013bbe5bc5ca)).
В Deep код выполняется согласно механике Обработчиков, универсальных реакций на события, которые, как сигналы в мозгу реагируют, на любом языке и порождают новые изменения.
ОбработчикиЭто структура из связей, позволяющая описать способ запуска конкретного кода, выбирая стандарт изоляции и исполнения.
Такой подход позволит поддержать любые ранее существующие стандарты, языки, версии языков, прекомпиляторы и прочее на универсальном изолированном уровне.
Из исполняемого кода доступен [Deep.Client](https://www.notion.so/DeepClient-ce72ce9537564cc283b45c83fd4b779f) с gql-подключением от имени пакета или пользователя, от чьего имени выполняется код.
> В будущих версиях мы планируем добавить ассоциативные модели монтирования/обновления/демонтирования исполняемого кода в форме процессов/компонентов/контейнеров/подов/нодов и прямо изнутри ассоциативной памяти. Фактически, мы сделаем, чтобы сквозная архитектура Глубины могла выполнять поведение, хранимое и контролируемое отслеживание в едином пространстве. Так, чтобы средой для исполнения были не только виртуальные сервера и докеры, а не микроконтроллеры, js на клиенте, unity/unreal engine точку выполнения.
>
>
Подробнее про Handlers [в документации](https://www.notion.so/Handlers-b37c0f1b7d874806a9fe93753f8fa6f1).
> Да, вскоре мы добавим поддержку обработчиков, выполняющихся синхронно внутри транзакции, также с правовыми ограничениями и экземпляром Deep.Client. Это позволит писать бизнес-логику удобно как никогда прежде.
>
>
Какие выводы можно сделать?
Мы полностью убрали бизнес-логику из кода. Теперь проект любого размера, созданный на Deep, можно мутировать бесконечно, вы теперь независимы от модели данных.
Deep возьмет на себя ответственность за создание кроссплатформенной/кроссязыковой культуры дебага, мониторинга, балансировки и шардинга данных, чтобы можно было полностью сфокусироваться на настоящих инновациях и творчестве, которое просто работает.
#### Архитектура.
Deep - это не конкретная реализация хранилища или API работы со связями. Deep предполагается, как стандарт работы с ассоциативностью. Мы обеспечим обратную совместимость стандарта, и мультиязыковую культуру доступа к разным реализациям ассоциативных хранилищ одновременно. Его структура позволяет отказаться от конкретной семантики и предоставить конструктор гибких вариантов семантики. Благодаря этому структура, фактически, говорит на языке хранимого ею смысла. Это значит, что даже если мы будем говорить на сотнях диалектов для работы с ассоциативностью в коде, внутри она останется целостной совместимой структурой.
Мы работаем над несколькими нативными решениями, на C++, C#, Rust. Сейчас мы публикуем Deep 0.1.0-alpha.0 версию на базе нескольких надежных зависимостей:
* [PostgreSQL](https://www.postgresql.org/) в качестве стабильной и проверенной временем базы данных с поддержкой партицирования, транзакций, триггеров, и распределенного хранения.
* [Hasura](https://hasura.io/) в качестве GraphQL адаптера и поставщика реализации стандарта bool\_exp, берет на себя часть функционала postgresql storage engine.
> Deep.Foundation развивает свой диалект storage engines, на базе которого ведется разработка сразу нескольких конкурирующих реализаций хранилища, на C++, C# и Rust.
>
>
И это далеко не всё.
Подробнее с нашими планами можно ознакомиться в первой итерации дорожной карты.
ROADMAP#### А теперь о планах. И о нас.
Для начала, о нашей идеологии.
Наша цель не просто сделать прикольную штуку и заработать на ней денег. Успех, финансы и признание всего лишь инструменты, которые позволят нам достичь нашей настоящей цели:
Сделать мир иным, проторить в нем новые дороги, чтобы исследователи, романтики, мечтатели и просто творческие люди могли вплотную подойти к горизонтам познания и заглянуть за них.
При наличии единого языка который может излагать концепции любых форм информации, сначала мы создадим утилитарные инструменты для программистов, и вместе с ними, принесем ассоциативную культуру во все сферы жизни информации в обществе.
Мы хотим изменить мир так, чтобы его мог менять каждый!
### Deep - это философия открытости и прозрачности.
Мы всегда обо всем говорим публично. Все материалы в нашем Notion. Факт любых деловых контактов нашей корпорации всегда будет обнародован. Решение о публикации или не публикации разговора принимает только вторая сторона. Мы даем слово, что не имеем возможности отказаться от такой публикации.
Вы можете ознакомиться с нашими подкастами и встречами в нашем [YouTube](https://www.youtube.com/channel/UCWn8rWuwZ4ISFVNTgy0GEow/featured). Больше ссылок на сайте [deep.foundation](https://deep.foundation).
На подкастах “Пещера дракона” мы разговариваем с экспертами о Deep. Вы можете ознакомиться с квалификацией наших экспертов в описании файлов.
Любой желающий, кстати, может стать нашим гостем, просто приходите в наш [**Discord**](https://discord.gg/eYdg2G7q86) и напишите в канале #hi “Хочу на подкаст”.
> Если упомяните в сообщении слово “хабр” в любом очевидном начертании, получите тег habr и комнату только для тех, кто пришел на сервер таким образом.
>
>
Мы отрицаем кулуарность, как способ ведения бизнеса.
#### Теперь о наших надеждах
Мы хотим, чтобы Глубина объединила нас, позволила обмениваться своими механизмами творчества, чтобы ваши лучшие идеи и концепции стали доступны всем в единой среде.
Чтобы вы могли запускать стартапы так быстро и так легко, как было невозможно раньше.
Чтобы мы могли создавать проекты, которые изначально совместимы друг с другом, и говорят на одном языке, даже если в них нет одинаковых пакетов или моделей данных.
Чтобы собирать и поддерживать проект могли любые люди, знакомые с Deep, не приватизируя legacy часть.
Чтобы разумные, совместимые с ассоциативностью мыслящие существа, могли строить для себя третий слой памяти, дополненное восприятие. Не важно кто вы, человек или иная форма разума.
Мы верим в то, что мы сможем выдержать этот кризис, только если создадим нечто эпохальное. Это наш ответ всей глупости, всему невежеству и ненависти, которые сейчас царят в мире.
С одной из существующих точек зрения, мы банда сумасшедших. Чего о нас говорит один лишь тот факт, что мы взяли в качестве официального лица компании, маскота любимого писателя – фантаста нашей команды.
Или, например, что мы объединяем наших последователей в натуральный культ ассоциативности..
Но больше всего нас характеризует то, что мы создаем компанию, которая говорит публично на уровне ЛЮБЫХ деловых контактов. И делаем это в России.
Мы всегда говорили, говорим, и будем говорить с нашей аудиторией прямо и открыто.
**Наша цель** - создать полноценную экосистему вокруг теории ассоциативности. И вот уже благодаря ей мы сделаем так, что культура полной открытости станет не просто мудрым решением, а наиболее выгодным из всех. Мы монетизируем честность.
**Наша ценность** – люди. Любая, самая крутая идея обречена на забвение, если не найдется тех, кто эту идею перенесет в реальный мир.
Леди и джентльмены, в эти темные времена нам нужно сплотиться с самыми важными для нас людьми, с нашей аудиторией. Создавайте что-то на Deep, взаимодействуйте с нами, задавайте вопросы. Проект будет существовать, только если вы станете благодаря ему лучше и успешнее. Мы сможем вырасти только вместе с вами!
Хотим отдельно обратиться к тем, кого мы воодушевили. Те, кто уже увидели в Deep то, что видим мы. Нечто бездонное, неизведанное, чуждое как город в небесах. И столь же прекрасное.
Народ, вступайте в [Кадеты глубины](https://www.patreon.com/deepfoundation?fan_landing=true)! Испытайте наши ценности, посмотрите, как ваша работа становится эффективнее.
Господа! Важный момент. Мы планируем привлечь инвестиции на развитие. В нашей ситуации - это не самая сложная задача, НО!
Глубина - это Дело всей нашей жизни. И потому на первых этапах мы будем отдавать предпочтение тем, кто верит в нас, тем, кто разделяет наши ценности, а не просто видит крутой, выгодный, но безликий актив.
У нас еще нет юридической формы для подобных инвестиций, но желающие могут объявить своем намерении уже сейчас.
На Патреоне мы сейчас сделали кнопку для тех, кто готов стать членом клуба. Поверьте в нас, поверьте в чудо, и мы вас не разочаруем.
Короче, мир лучше захватывать в большой компании. [Присоединяйтесь.](https://www.patreon.com/deepfoundation?fan_landing=true)
В скором времени мы, кстати, выйдем на кикстартер.
> Ну, а пока есть такая возможность, расскажите, что нам не хватает в упаковке и позиционировании, чтобы в нас хотелось поверить при публикации проекта на KickStarter и аналогичных площадках. Будем рады пообщаться в комментариях.
>
>
Deep.
Творчество, которое просто работает.
> Команда Deep Foundation благодарит Руслана Бикмаева за помощь в публикации статьи, чувак, без тебя бы это было гораздо сложнее! Мы очень рады что такие люди как ты есть в нашем комьюнити!
>
> | https://habr.com/ru/post/656879/ | null | ru | null |
# Курс «Языки веб-программирования» (на основе Ruby) от МГТУ им. Н. Э. Баумана на канале Технострим
В этой статье мы расскажем о [курсе «Языки веб-программирования»](https://www.youtube.com/playlist?list=PLrCZzMib1e9odW1P2LnmGfe_dypZTxO3I), который читается на кафедре «Компьютерные системы и сети» (ИУ-6) МГТУ им. Н.Э. Баумана. Примеры приводятся на Ruby, а сам курс и представляет собой 16 видеолекций, доступных бесплатно на канале [Технострим](https://www.youtube.com/channel/UCmqEpAsQMcsYaeef4qgECvQ). В «Бауманке» курс читается для студентов второго курса, уже знакомых с высокоуровневыми языками программирования, такими как Pascal, C++ или Java. Основной акцент делается на системное понимание технологий, используемых в веб-программировании, а не на глубину освоения именно технологий Ruby. Поэтому курс также будет полезен слушателям, имеющим отрывочные знания о веб-технологиях на любых языках.
Содержание
----------
1. [О курсе «Языки веб-программирования»](https://habr.com/company/mailru/blog/419765/#1)
* [Цель курса](https://habr.com/company/mailru/blog/419765/#2)
* [Автор курса](https://habr.com/company/mailru/blog/419765/#3)
* [Длительность и формат](https://habr.com/company/mailru/blog/419765/#4)
* [Результаты](https://habr.com/company/mailru/blog/419765/#5)
2. [Содержание лекций](https://habr.com/company/mailru/blog/419765/#6)
* [Лекция 1. SGML, HTML, CSS](https://habr.com/company/mailru/blog/419765/#7)
* [Лекция 2. Javascript](https://habr.com/company/mailru/blog/419765/#7)
* [Лекция 3. Ruby. Основы](https://habr.com/company/mailru/blog/419765/#8)
* [Лекция 4. Ruby: Классы, Модули, Примеси](https://habr.com/company/mailru/blog/419765/#8)
* [Лекция 5. Особенности использования языка Ruby](https://habr.com/company/mailru/blog/419765/#8)
* [Лекция 6. Веб-серверы](https://habr.com/company/mailru/blog/419765/#9)
* [Лекция 7. Шаблоны. Model-View-Controller](https://habr.com/company/mailru/blog/419765/#10)
* [Лекция 8. Ruby on Rails](https://habr.com/company/mailru/blog/419765/#11)
* [Лекция 9. Асинхронный обмен данными](https://habr.com/company/mailru/blog/419765/#12)
* [Лекция 10. Тестирование веб-приложений](https://habr.com/company/mailru/blog/419765/#13)
* [Лекция 11. Языки запросов и преобразования XML](https://habr.com/company/mailru/blog/419765/#14)
* [Лекция 12. Хранение данных. ORM. Модели Rails](https://habr.com/company/mailru/blog/419765/#15)
* [Лекция 13. Cookies. Sessions. Проблемы безопасности](https://habr.com/company/mailru/blog/419765/#16)
* [Лекция 14. Веб-cервисы](https://habr.com/company/mailru/blog/419765/#17)
* [Лекция 15. CMS (Content Management Systems)](https://habr.com/company/mailru/blog/419765/#18)
* [Лекция 16. Веб-серверы](https://habr.com/company/mailru/blog/419765/#19)
3. [Как создать курс для вуза](https://habr.com/company/mailru/blog/419765/#20)
4. [Почему Ruby?](https://habr.com/company/mailru/blog/419765/#21)
5. [Почему Ruby не популярен?](https://habr.com/company/mailru/blog/419765/#22)
6. [Резюме](https://habr.com/company/mailru/blog/419765/#23)
#### Языки веб-программирования
Почему курс называется «Языки веб-программирования»? Ответ очень прост. Как 30 лет назад, когда Интернет только зарождался, так и сейчас нет возможности использовать один язык программирования.
* Языки разметки — это HTML и CSS.
* Языки конфигурирования и обмена данными — JSON, XML, YAML.
* Браузерное программирование — Javascript (Typescript, Coffeescript...).
* Серверное программирование — Ruby, PHP, Perl, Java, Javascript…
Чтобы понять веб-программирование даже в минимальном объёме требуется знать 4-5 языков разметки и программирования (хотя границы между ними сейчас уже размыты).
#### Цель курса
Основная задача курса — заложить понимание технологий, необходимых для веб-разработки, поскольку большинство современных проектов так или иначе связаны с веб-разработкой. Курс скомпонован так, чтобы в сжатом виде дать слушателям основы, которые могут быть использованы как каркас для углубленного изучения.
Конкретные навыки слушатели прорабатывают самостоятельно в ходе обучения, а степень проработки зависит от того, собираетесь ли вы в дальнейшем погружаться в веб-разработку.
#### Автор курса
Главный разработчик курса — кандидат технических наук, доцент кафедры «Компьютерные системы и сети» МГТУ им. Н. Э. Баумана Самарев Роман Станиславович. Программист с более чем 20-летним опытом (C++, C, Java, Perl, PHP, Ruby и др. для Windows, Linux, Embedded Linux, MacOS), руководитель программных разработок, исследователь в области СУБД, обработки данных и больших данных, работал в России, в Германии и в США.
#### Длительность и формат
Полный курс включает 192 академических часа: 16 лекций по 2 часа, 8 семинаров по 2 часа, 48 часов на 12 лабораторных работ. Остальное время выделено на самостоятельную подготовку. Видеоматериалы же включают только лекционную часть. Желающим глубже погрузиться в тему курса, материалы лабораторных работ и семинаров придется осваивать самостоятельно. Все вопросы можно задавать преподавателю: [samarev@acm.org](mailto:samarev@acm.org).
#### Результаты
В рамках учебного курса мы формируем у студентов понимание не только конкретных веб-технологий, реализованных на языке программирования Ruby, но, скорее, целостное восприятие проблем, возникающих при создании веб-приложений и всего, что им сопутствует, используя Ruby как очень удачную иллюстрацию. Сам язык Ruby является для студентов полезным дополнением, которое можно широко использовать и за пределами курса.
#### Содержание курса
**Лекции 1-2. Введение**
* Введение в веб-программирование с точки зрения базовой архитектуры.
* Минимальные сведения о языках разметки и таблицах стилей.
* Минимальное введение в Javascript.
Возможно, для Javascript следовало выделить гораздо больше времени, но поскольку браузерное веб-программирование не является основной целью курса, а технологии серверного программирования на Javascript еще не устоялись, то имеющегося материала достаточно для начального понимания.
**Лекции 3-5. Ruby**
Следующие три лекции посвящены Ruby, поскольку именно технологии на этом языке Ruby положены в основу курса. Лекции включают:
* Основы языка Ruby.
* Необходимые сведения о структуре типов и объектной модели.
* Функциональный стиль.
**Лекция 6. Принципы построения веб-приложений**
* Common Gateway Interface.
Кто-то скажет, что этот стандарт не актуален, но он лежит в основе всего современного веб-программирования. Поэтому любой веб-программист просто обязан знать, что это такое, и должен понимать, что простейшее веб-приложение — это всего лишь put 'Hello World'.
**Лекция 7. Rack**
* Rack — промежуточный слой для большинства веб-фреймворков на Ruby.
* Sinatra — распространенный фреймворк для создания простых приложений.
* Пример создания приложения.
**Лекция 8. Введение в Rails**
* Ключевые аспекты Rails-приложения.
Ruby on Rails — тот самый фреймворк, который сделал язык Ruby знаменитым и стал почти его синонимом. Это один из примеров глубоко проработанного фреймворка с концепцией Model-View-Controller, который послужил прототипом для создания множества других веб-фреймворков, включая Grails и Django. Отметим, что концепция Rails: генерировать как можно больше кода при помощи автоматических генераторов и меньше писать руками.
**Лекция 9. Асинхронное взаимодействие**
Большинство современных веб-приложений используют асинхронный метод, то есть запросы к серверу уходят в фоновом режиме для пользователя. Ответы отрабатываются где-то в глубине браузера. Что здесь надо знать?
* Обменные форматы — XML и JSON.
* Запуск асинхронного запроса из Javascript.
* Концепция ненавязчивого Javascript применительно к Rails.
**Лекция 10. Тестирование**
Любые современные программы должны быть покрыты автоматическими тестами. Ruby предполагает использование модульных тестов. И, естественно, Rails предполагает, что любое действие должно быть покрыто тестами. Лекция включает следующие темы:
* Тестирование различных аспектов веб-приложений.
* Введение в языки предметной области (поскольку RSpec и Cucumber — те самые примеры «человечности» в тестах: программа тестирования должна быть понятна не только для программиста, который «заточен» под используемый язык, но и для нормального человека). Обратите внимание, что подход, использованный как в RSpec, так и в Cucumber, сейчас широко растиражирован в средствах тестирования для многих других языков программирования.
* Средства типа SikuliX и Selenium, которые могут быть использованы для тестирования программ с графическим интерфейсом и браузерами соответственно.
**Лекция 11. Технологии XML**
* Языки запросов типа Xpath, Xquery.
* XSL и XSLT.
Казалось бы, какое это отношение всё это все имеет к веб-программированию? Но XML лежит в основе веб-технологий. То, что сейчас мы не используем XML в качестве обменного формата, вовсе не гарантирует, что через 5 лет мы опять не начнем это делать. До сих пор нет единого подхода к верификации данных в формате JSON. А в случае с XML схема разметки заложена самим языком.
Язык запросов Xpath — это, по сути, универсальный язык путевых запросов, который может быть использован для поиска любых элементов древовидных структур данных, куда входит и JSON.
Преобразования XSLT — это также еще один из способов трансформации документов XML, знание о котором позволит студентам не изобретать велосипеды в будущем, когда они столкнутся с ETL.
**Лекция 12. ORM (Object-Relational Mapping)**
Практически любой современный фреймворк для веб-программирования предоставляет какие-либо средства для объектно-реляционного преобразования. Студентам необходимо понимать:
* для чего нужен такой механизм;
* какие у него ограничения;
* как им пользоваться на практике.
В данном случае всё рассматривается в контексте Ruby on Rails.
**Лекция 13. Сессии, безопасность и всё, что с этим связано**
* Способ хранения состояния, основанный на cookies.
* Типовые способы аутентификации.
* Пример добавления авторизации в Rails.
* Вопросы безопасности веб-приложений как таковых.
**Лекция 14. Сервисы**
* Исторические аспекты.
* Конкретные рекомендации по разработке и размещению собственных сервисов для Web.
**Лекция 15. CMS (Content Management Systems)**
В веб-программировании важно не только уметь написать приложение, но и понимать, нужно ли его писать. Эта лекция — демонстрация основных типов уже созданных веб-приложений, которые можно настроить под требования конкретного заказчика и, при необходимости, доработать.
* Акцент на Ruby-средства.
* Самые распространенные CMS, написанные на PHP.
**Лекция 16. Размещение Ruby веб-приложений в Интернете**
Рассматривается общая идеология веб-сервисов. Объясняются истоки появления этой архитектуры с обменным форматом XML и её дальнейшая модификация в Web-API с JSON и REST или GraphQL.
* Веб-серверы.
* Методы виртуализации.
* Способы размещения приложения в Интернете.
#### Как создать курс для ВУЗа
Сложно создавать учебные курсы по темам, связанным с программированием, где технологии меняются каждые 5-10 лет. При создании курса для университета приходится балансировать между формированием практических навыков по конкретным языкам программирования и подачей теоретических основ, необходимых для понимания технологий как таковых. А кроме того, отличие университетского образования от учебных курсов заключается в системной подаче материала, что также накладывает ограничения на то, когда и в каком объеме может быть подан определенный материал.
В последние годы появилась тенденция записывать университетские лекции на видео и создавать видеокурсы. [Курс «Языки веб-программирования»](https://www.youtube.com/playlist?list=PLrCZzMib1e9odW1P2LnmGfe_dypZTxO3I) является первой такой официальной попыткой нашего ВУЗа. И на основе отзывов мы решим, как и в каком формате делать новые записи.
10 лет назад нужно было радикально обновить учебную программу, внедрив, в том числе, веб-программирование. На кафедре «Компьютерные системы и сети» на курсы, связанные с электроникой и проектированием ЭВМ, традиционно выделяют примерно столько же учебных часов, сколько и на программирование. Причем курсы по программированию включают в себя алгоритмическую подготовку на высокоуровневых языках Pascal, С, С++/Qt, подготовку на на различных ассемблерах, а также теорию языков программирования и компиляторы. И даже языки для программирования ПЛИС и специфического железа. То есть кафедра готовит универсальных специалистов, которые в дальнейшем сами выбирают специализацию.
Нам требовалось выявить перспективные веб-технологии, которые могут быть освоены за семестр, причем желательно, чтобы эти технологии могли быть спроецированы на другие языки программирования.
#### Почему Ruby?
Почему выбран Ruby? Выбор языков для веб-программирования достаточно богат. Помимо Ruby это PHP, Perl, Javascript, Java, Go и другие. Если же подходить с позиции высоконагруженных веб-приложений, то, отправляя сомневающихся в [Web Framework Benchmarks](https://www.techempower.com/benchmarks/), видим в первых рядах C++, Java, Rust, Ur, Go и пр. Ruby не является ни самым популярным для веб-разработки, ни самым быстрым для высоконагруженных решений. Однако у Ruby есть масса других достоинств, делающих его языком программирования, о котором должен иметь представление любой образованный программист.
Недавно Ruby отметил 25-летие, то есть это достаточно зрелый язык. Несмотря на то, что большинство упомянутых языков также перешагнули или близки к этому возрасту (Rust, Dart, Go пока «зеленые» по сравнению с ним), Ruby — один из немногих языков, сохраняющий обратную совместимость на протяжении этих лет.
В мире Ruby, можно сказать, не было революций и каких-то радикальных изменений. Он относится к изначально хорошо спроектированным языкам, базовые концепты которого дошли до сего дня без изменений. Претензии по производительности относились к старым версиям до 1.8.7, поддержка которых прекращена 10 лет назад. Современные версии каждый год демонстрируют кратный рост производительности. Претензии, что этот язык мало популярен, справедливы лишь для нашей страны. К сожалению, у нас крупные компании действительно незаслуженно обходят его стороной.
Почему Ruby хорош для университетского образования? Это чистый объектный язык. И поскольку он динамический, переопределить можно почти всё. Никаких простых типов в его модели нет (не будем здесь размышлять о системной реализации, речь только о модели). Любые данные — это объект. Код — это объект. То есть Ruby позволяет легко усвоить принципы объектно-ориентированного программирования. Кроме того, синтаксис языка достаточно прост и почти не имеет исключений. Любой код, написанный в программе, должен быть когда-то выполнен, причем не важно, где этот код написан — внутри объявления класса или снаружи. Что бы ни было написано, оно будет выполнено. Синтаксис Ruby очень гибкий, что делает его очень удобным для написания языков, ориентированных на предметную область (DSL/DSEL). Кроме того, базовый концепт Ruby — блок — это анонимная функция. Освоение этих принципов позволяет студентам легко овладеть функциональным программированием на чистых функциональных языках программирования.
И, скорее, декоративное достоинство Ruby — не нужно тратить время на объяснение обязательности форматирования кода отступами. Программа в любом случае четко размечена. Форматирование автоматически обеспечит rubocop, а писать правильно студенты научатся со временем.
#### Почему Ruby не популярен?
Почему же Ruby, обладая такими достоинствами, всё же не популярен и относится к языкам с высоким порогом вхождения?
Первое, что следует понимать: Ruby — это не очередной императивный язык программирования, на котором можно начать программировать за вечер, а за неделю постичь полностью. Это другой язык с другой философией.
Первый принцип Ruby: текст программы должен восприниматься как текст на естественном языке. То есть Ruby — язык для программиста, который является человеком, а не язык, для которого надо подобрать подходящего программиста. К сожалению, большинство современных языков программирования следуют принципу «программист всё стерпит», и отступление уже воспринимается с трудом.
Ruby часто критикуют за то, что одно и то же можно сделать десятком способов. Но в естественном языке мы имеем огромное количество синонимов, и именно выбор верного синонима делает нашу речь богатой. Так и в Ruby. Помимо того, что одни и те же действия можно совершить разными способами, на одни и те же методы существует множество синонимов, ассоциированных специальными методами `alias` и `alias_method`.
Простой пример ограниченности большинства других языков программирования. Допустим, есть массив products, и требуется определить, что он не пуст. В большинстве языков мы напишем что-то типа `if (products.size() > 0`)…. Но, придя в магазин, мы не спрашиваем продавца: «Если у вас больше нуля такого-то товара?». Мы задаем простой вопрос: «Есть ли у вас такой-то товар?». В Ruby надо использовать методы, выражающие смысл действия. Да, мы можем использовать проверку на «больше нуля», но естественный способ — спросить `if products.any`? То есть буквально: есть ли продукты? Отметим, что Ruby хорошо работает с Юникодом, поэтому при необходимости на базе этого языка можно создать специализированные языки с региональной адаптацией. Например, если требуется переопределить по-русски все имена классов и методов.
Интересный, хоть и не совсем прямой пример: [Bato: A Ruby port for Filipinos](https://www.theregister.co.uk/2018/03/21/philippines_ruby_bato/).
К вопросу об объектности языка: в Ruby четко разделяются переменные/константы и объекты. В силу динамической природы языка данные «живут» своей жизнью как объекты. Любой идентификатор представляет собой константу или переменную, которая всего лишь ссылается на объект. Непонимание этого принципа приводит к неожиданностям:
```
str1 = "Test"
str2 = str1
str1.sub! "Te", "La"
puts str2 # => "Last" ???? Мы же меняли str1, что случилось?..
```
Здесь мы всего лишь использовали модифицирующий метод объекта, ссылки на который хранили две переменные. Отмечу, что это не традиционный для Ruby способ изменения. Обычно объекты сохраняют неизменными, а изменения порождают новые объекты. Кроме того, использованный здесь метод `sub!` имеет суффикс — восклицательный знак, — что является принятой в Ruby схемой именования методов, которые изменяют сам объект. Без этого символа метод просто породит новый объект.
Еще одна особенность Ruby, которая очень часто ставит в тупик разработчиков, пришедших из других языков программирования: концепция «блока». Синтаксически блок выглядит так же, как и в других языках программирования, причем сразу в двух вариантах: `{…}` и `do..end` (не забывайте, что Ruby создан для человека, поэтому выбираем для лучшей читаемости скобки, если выражение однострочное, и слова, если строк много). Суть блока в Ruby — это код, который хранится как объект и может быть активирован вызовом `yield`. Прямой аналог в C и C++ — функции обратного вызова. В Javascript — анонимная функция типа `some_func('on_element_click', function(event) {…}`).
Именно благодаря этой концепции Ruby является одним из наиболее лаконичных и выразительных языков программирования. Например, преобразование элементов массива в соответствии с функцией возведения в квадрат будет выглядеть так:
```
(1..5).map { |x| x * x } # => 1, 4, 9, 16, 25,
```
где `{ |x| x * x }` — блок с объявленной локальной переменной `x`, то есть функция преобразования элементов массива. А метод, которому она передается, просто называется map (то есть «отобразить»). Причем не надо писать слово `return`, хотя это и возможно, потому что всё и так ясно (в Ruby результат последней операции всегда является возвращаемым значением). Причем код блока — это код, вызываемый автономно для каждого элемента массива. Именно поэтому бессмысленно пытаться заводить внутри блока переменные и надеяться, что их значение сохранится при обработке следующего элемента. Блок — это сохраненная функция обработки, и не более.
Если же мы хотим разобрать строку с числами, введенными с клавиатуры, достаточно написать:
```
gets.chomp.split.map(&:to_i)
```
То есть прочитать строку (gets), отбросить всякий мусор вроде символов перевода строк (`chomp`), разбить на слова (`split`), вызвать преобразование с функцией `to_i` (строго говоря, метода объектов типа «строка»). И ничего лишнего. Split знает, что в нормальном человеческом языке «разбить строку» означает разделить её по словам, где разделители — пробелы и знаки препинания. Map может быть использован в такой короткой форме с именем метода, который надо взять у объекта. Хотя можно было бы написать и полную форму `map { |x| x.to_i }`, или даже `{ |x| return x.to_i }`. Но это не улучшает читаемость, поэтому можно оставить просто `map(&:to_i)`.
Замечу, что концепция блока откровенно пронизывает Ruby. Даже код вида
```
class HelloWorld
(1..3).each { puts 'Hi from class declaration!' }
def hi
puts 'Hello World!'
end
end
HelloWorld.new.hi
```
выводит на экран:
`Hi from class declaration!
Hi from class declaration!
Hi from class declaration!
Hello World!`
Что здесь может показаться неожиданным? Цикл внутри объявления класса вывел сообщения. Потом получили сообщение из метода экземпляра этого класса. А секрет очень прост. Ruby — язык с регулярной моделью программирования. Типовой способ вызова любого метода с блоком:
```
method_with_block(args) do
...
end
```
Слова `class` и `def` в примере, по сути, являются именами методов, которым передаются аргументы `HelloWorld`, `hi`. Аргумент `HelloWorld` станет для нас константой-именем класса, а `hi` — именем метода. Остальная часть до слова `end` — это блок. А код блока активируется вызовом yield, после чего всё последовательно выполняется. То есть даже здесь практически нет разницы между вызовом обычного метода и объявлением методов, классов, модулей.
Также обратите внимание на активирующую конструкцию `HelloWorld.new.hi`. `HelloWorld` — константа — указывает на объект типа `Class`. У этого объекта есть метод `new`. Результатом вызова `new` является созданный объект типа `HelloWorld`, от которого вызываем метод `hi`. И даже здесь проявляется регулярность Ruby. Мы не пишем `something = new HelloWorld`, а просто вызываем метод конкретного объекта (`Class`, на который ссылается `HelloWorld`), который и порождает объект типа `HelloWorld`.
Непониманию языка способствуют и длинные цепочки вызовов:
Если вы знаете JavaScript или jQuery, то ничего особенно страшного здесь не видите. У тех же, кто пришел из C и C++, может возникнуть недоумение относительно количества точек. В Ruby применяется функциональное преобразование объекта. То есть вся эта цепочка — процесс преобразования строки, заключающийся в выделении слов, их преобразовании в числа, отборе только четных из них, возведении в квадрат и сложении результата.
Любой метод в Ruby порождает объект-значение. Исключений нет. Даже nil является объектом. Поскольку Ruby — динамический язык с автоматическим сборщиком мусора, нет необходимости заводить новые переменные. Промежуточные объекты будут удалены. То есть длинное выражение легко может быть разобрано на последовательность присвоения значений локальным переменным, которые последовательно вызывают соответствующие методы. Но зачем, если и так всё понятно?
В программах на Ruby крайне редко можно увидеть циклы типа `for`, `while`, `loop`. Они предусмотрены в синтаксисе, но почти не используются. Почему? Да потому, что не несут семантическую нагрузку.
Пример: в массиве товаров надо найти «булочку с маком». Для традиционных языков программирования можем воспользоваться примерно следующим Ruby-кодом:
```
products…# какой-то массив с объектами — товарами.
found_product = nil
for i in 0...products.size do
if products[i].name == 'булочка с маком'
found_product = products[i]
break
end
end
if found_product != nil
# Булочки нашли, делаем что-то полезное.
end
```
При этом нормальный Ruby-код выглядит как:
```
products… # какой-то массив с объектами-товарами
found_product = products.find { |product| product.name.eql? 'булочка с маком' }
unless found_product.nil?
# Булочки нашли, делаем что-то полезное.
end
```
То есть пишем буквально в одну строчку: товар найти по названию. И всё. Потому что реально нас интересует только отбор товара, а вовсе не индексы товаров и не их количество.
Пример из жизни: вы пришли в магазин и спросили несчастного продавца двумя способами: первый — «*Для всех товаров от нуля до 15143, если наименование товара равно булочка с маком, то дайте мне её*»; второй — «*Дайте мне булочку с маком*». Вроде бы оба варианта синтаксически правильны, но естественен второй. Большинство программистов почему-то считают нормальным первый вариант. А Ruby-программисты — второй. И метод `find` здесь просто как один из заменителей цикла. Обращаю на это внимание, упреждая замечания, что в других языках тоже есть поиск по массиву с функцией отбора.
Так вот, хотя в Ruby есть синтаксические конструкции `for`, `while` и `loop`, их почти никто не использует, потому что есть конкретные методы: `each`, `each_index`, `each_with_index`, `select`, `map`, `reduce`, `find`, `detect` и многие другие, выражающие конкретный смысл — для каждого индекса, для каждого элемента и его индекса, отобрать, преобразовать, свернуть, найти и пр. И если надо получить индексы, мы будем использовать `array.each_index`. А если надо отобрать элементы, воспользуемся `select`. Акцент на естественность. Запрашиваем только то, что реально нужно сделать. Не нужен индекс — незачем его просить. Подробнее см. [документацию по модулю Enumerable](https://ruby-doc.org/core-2.5.0/Enumerable.html).
#### Резюме
Ruby — синтаксически простой, но гибкий язык с развитой объектной моделью, основной акцент которого — лаконичный, но хорошо воспринимаемый код, ориентированный на живого человека. Ruby присутствует по умолчанию в комплекте любой современной операционной системы (или может быть доустановлен в Windows). На этом языке написано огромное количество программ, существуют стабильные сообщества, готовые помочь советом или действием. Программы на Ruby — это базовые скрипты администрирования для Linux и MacOS (OpenSuSE/SuSE и brew.io соответственно), это [математика и машинное обучение](http://sciruby.com/), это тесты (Rspec, Cucumber, Capybara...), это развертывание приложений (Puppet, Chef) и многое другое.
Если студенты будут знать Ruby, это существенно расширит их кругозор, позволит совершенно по-другому взглянуть на привычные вещи. Кроме того, после Ruby очень легко изучать другие скриптовые языки программирования, но вопрос: захочется ли их использовать. | https://habr.com/ru/post/419765/ | null | ru | null |
# Серьезная уязвимость прокси-сервера Squid позволяет «отравить кэш»
[](https://habrahabr.ru/company/pt/blog/283028/)
Цзянь-Цзюнь Чэнь (Jianjun Chen) — аспирант китайского Университета Цинхуа — обнаружил [опасную уязвимость](http://bugs.squid-cache.org/show_bug.cgi?id=4501) в популярном прокси-сервере Squid. Как ему удалось выяснить, система не соответствует стандарту RFC 7230, а также некорректно работает при парсинге и обработке заголовка Host в HTTP-запросах. В результате злоумышленник может сформировать зловредный пакет и с помощью него осуществить атаку cache poisoning.
#### В чем проблема
Исследователю удалось осуществить атаку «отравления кэша» Squid-3.5.12 для любых незашифрованных HTTP-запросов. Чтобы провести такую атаку, злоумышленник должен иметь возможность посылать запросы через прокси-сервер к своему сайту (скажем, attack.com). При таком сценарии сначала устанавливается TCP-соединение с веб-сервером сайта attack.com — поскольку Squid работает в режиме прозрачного прокси, он перехватывает и передает эти запросы дальше. На следующем шаге атакующий инициирует HTTP-запрос:
```
GET http://victim.com/ HTTP/1.1
Host: attack.com
```
Кэширующий модуль использует для ключа адрес узла из строки запроса (victim.com), однако модуль верификации использует для проверки связи между узлом и IP-адресом заголовок Host (attack.com). Это и делает атаку возможной.
Исследователь также опубликовал [демонстрационное видео](https://drive.google.com/file/d/0ByM36MBckzBaQUFES0VYRlZydUE/view).
Подобную атаку можно провести удаленно, например с помощью Flash-рекламы. Поскольку Squid используют в качестве прозрачного прокси многие интернет-провайдеры, эксплуатация обнаруженной уязвимости может привести к серьезным последствиям.
Изначально разработчики Squid посчитали, что обнаруженная уязвимость повторяет ошибку, описанную в CVE-2009-0801. Однако китайский исследователь доказал, что новая атака не связана со старой уязвимостью. В случае CVE-2009-0801 злоумышленник мог осуществить атаку SOP bypass: эта ошибка была связана с некорректной обработкой IP-адреса узла назначения. Проблема была исправлена начиная с версии Squid 3.3. Новая же уязвимость заключается в несогласованной работе модуля проверки маршрутов и модуля кэширования Squid 3.5.
#### Как защититься
В настоящий момент уязвимость устранена, однако CVE до сих пор нет, как и официального патча в виде отдельной версии Squid. Исправление включено пока только в daily-сборки для версий [4](http://www.squid-cache.org/Versions/v4/changesets/squid-4-14659.patch) и [3.5](http://www.squid-cache.org/Versions/v3/3.5/changesets/squid-3.5-14039.patch).
Эксперты Positive Technologies рекомендуют включить опцию **[host\_verify\_strict](http://www.squid-cache.org/Doc/config/host_verify_strict/)**, по умолчанию выключенную, а также использовать правило Suricata IDS для обнаружения попыток эксплуатации:
> New [#Squid](https://twitter.com/hashtag/Squid?src=hash) HTTP Cache Poisoning Attack detection rule
> Affected: <3.5.18 <4.0.10<https://t.co/D3hSUmaqnv>
> CVE:none
> CWE-345
> CAPEC-141[#squoison](https://twitter.com/hashtag/squoison?src=hash)
>
> — Attack Detection (@AttackDetection) [5 мая 2016 г.](https://twitter.com/AttackDetection/status/728237422643949569) | https://habr.com/ru/post/283028/ | null | ru | null |
# Сервер дома — AMD, Debian x64, Bind9, Apache 2, PHP5, MySQL5, Trac, Subversion и море удовольствия
Шило в известном месте всё никак не даёт мне покоя.
И решил я поэкспериментировать с установкой сервера дома.
**Итак, дано:**
1. Домашний интернет с внешним ip на роутере, канал туда/обратно — 8 мбит, провайдер — QWERTY \*
2. Бюджет не больше 10 тысяч рублей — чем меньше, тем лучше. \*\*
3. Жгучее желание экспериментов и **чего-нибудь эдакого** \*\*\*
**\*** К сожалению, мой дом не подключает Корбина, у которой более широкие каналы. Приходится довольствоваться тем, что есть
**\*\*** Получилось путём более-менее реального подсчёта стоимости комплектующих на среднестатический компьютер
**\*\*\*** Для тех, кто хмыкнет и скажет — «эка невидаль, я такое регулярно делаю» — я не так часто что-то настраиваю, больше пишу под уже настроенное, и для меня это чистой воды развлечение — что-то сделать своими руками=)
Ну, все процедуры тут, под катом.
**Сразу хочу сказать, что у меня это работает — так, как есть. Дополнительно с бубном я не плясал — но тут вытяжки из моих гуглений и мануалокурений.
Вероятно, что-то можно настроить более гибко или качественно, и я крайне буду рад советам или решениям=)**
Подумал, что надо покупать:
1. Материнская плата
2. Процессор
3. Жёсткий диск
4. Память
5. Корпус
6. Кулер на процессор
Выбрал магазин Oldi, собрал online комплектующих на сумму как раз около 10 тысяч — упирая на Intel. Всю ночь ворочался, думал, и на следующее утро пересобрал заказ, упирая на AMD. Разница в деньгах получилась около двух тысяч, а AMD-конфигурация — более подверженная будущим апгрейдам. Например, на Socket 775 в Oldi не было материнских плат до 2k, позволяющих добить оперативку до 16 гигабайт. В общем, решил попробовать — ибо с AMD давно не имел дела.
Проц — AMD x64 2.4 ггц, жёсткий диск взял один, SATAII на 320 гигабайт (как вариант — куплю ещё один расширю до рейд 1), памяти — Кингстон 800мгц, две планки по 2 гигабайта (поставились в Dual), самый дешевый корпус и кулер Igloo — не блистающий дороговизной, но вполне себе охлаждающий (за несколько дней температура не превысила 60 градусов, судя по sensors).
Торжественно с этим всем приехал домой, собрал, подключил к монитору, подключил клавиатуру, провод от роутера, внешний USB-привод, и через полчаса уже смотрел на свежепоставленный Debian.
Настроил переадресацию портов на роутере:
`53 порт => Bind9
80 порт => Apache
21 порт => FTP
22 порт => SSH`
После чего исполнил три команды:
`apt-get update
apt-get upgrade
apt-get install ssh`
и улёгся на диван с ноутбуком, продолжая диалог с сервером уже через Putty.
Цели были прозаичны:
1. Bind9
2. Apache2
3. PHP5
4. MySQL 5
5. SVN
6. Trac
Всё это предполагалось сделать на одном недавно купленном домене (предположим, habr.ru), который ещё не был нигде проделегирован.
Bind9. Настройка чайника.
==========================
Учитывая то, что о настройке Bind9 лишь слышал, — сразу полез в мануалы и примеры.
В итоге настройку произвёл [по этой инструкции](http://sudouser.com/ustanovka-i-nastrojka-dns-servera-bind9-ubuntu-debian-howto.html), изменив лишь настройку конкретной зоны для домена.
Кроме того, мне хотелось сразу подключить [Google Applications](http://www.google.com/a/) для домена, чтобы не иметь дел с настройкой sendmail — в настройках ниже они легко наблюдаются.
Получилось следующее:
1. Создал папку /etc/bind/sites
2. В настройках /etc/bind/named.conf, в самом конце:
`include "/etc/bind/named.conf.skazkin";`
3. В /etc/bind/named.conf.skazkin:
`zone "habr.ru" {
type master;
file "/etc/bind/sites/habr.ru";
};`
4. В /etc/bind/sites/habr.ru:
`$ORIGIN habr.ru.
$TTL 86400 ; 1 day
@ IN SOA habr.ru. master.habr.com. (
2008291104; serial
10800 ; refresh (3 hours)
3600 ; retry (15 minutes)
3600000 ; expire (1 week)
86400 ; minimum (1 day)
)
@ IN NS ns.habr.ru.
@ IN NS ns.vds.ru.
@ IN A 111.222.333.444
@ IN MX 10 ASPMX.L.GOOGLE.COM.
@ IN MX 20 ALT1.ASPMX.L.GOOGLE.COM.
@ IN MX 20 ALT2.ASPMX.L.GOOGLE.COM.
@ IN MX 30 ASPMX2.GOOGLEMAIL.COM.
@ IN MX 30 ASPMX3.GOOGLEMAIL.COM.
@ IN MX 30 ASPMX4.GOOGLEMAIL.COM.
@ IN MX 30 ASPMX5.GOOGLEMAIL.COM.
ns IN A 111.222.333.444
svn IN CNAME habr.ru.
trac IN CNAME habr.ru.
www IN CNAME habr.ru.`
На что хватило понимания мануала.
Непонятно было то, что при попытке прописать всё без @-знака, бинд переставал понимать, что от него хотят — ещё раз прорыв гугл, я подозреваю, что это из-за неправильных отступов (\*hic\*)?
В общем, тут я как-то вот выкрутился — факт остаётся фактом, домен проделегировался. Но об этом немного позже.
Помимо primary-зоны, мне понадобилось создать ещё и Slave. Пошёл на давно купленный VDS с как-то странно установленным дебианом, там прописал:
1. /etc/bind/named.conf
`zone "habr.ru" {
type slave;
file "/var/cache/bind/habr.ru";
masters {
111.222.333.444;
};
};`
2. Соответственно, в /var/cache/bind/habr.ru всё то же, что и на домашнем сервере:
`$ORIGIN habr.ru.
$TTL 86400 ; 1 day
@ IN SOA habr.ru. master.habr.com. (
2008291104; serial
10800 ; refresh (3 hours)
3600 ; retry (15 minutes)
3600000 ; expire (1 week)
86400 ; minimum (1 day)
)
@ IN NS ns.habr.ru.
@ IN NS ns.vds.ru.
@ IN A 111.222.333.444
@ IN MX 10 ASPMX.L.GOOGLE.COM.
@ IN MX 20 ALT1.ASPMX.L.GOOGLE.COM.
@ IN MX 20 ALT2.ASPMX.L.GOOGLE.COM.
@ IN MX 30 ASPMX2.GOOGLEMAIL.COM.
@ IN MX 30 ASPMX3.GOOGLEMAIL.COM.
@ IN MX 30 ASPMX4.GOOGLEMAIL.COM.
@ IN MX 30 ASPMX5.GOOGLEMAIL.COM.
ns IN A 111.222.333.444
svn IN CNAME habr.ru.
trac IN CNAME habr.ru.
www IN CNAME habr.ru.`
После чего и дома, и на VDS сделал
`/etc/init.d/bind9 restart # на всякий случай - не будет ли ошибок при рестарте
nslookup habr.ru 127.0.0.1`
От лукапа должен получиться успешный ресолв:
`bash:/etc/bind# nslookup habr.ru 127.0.0.1
Server: 127.0.0.1
Address: 127.0.0.1#53
Name: habr.ru
Address: 111.222.333.444`
После чего уже при следующих изменениях на домашнем сервере делал только
`rnds reload`
На VDS отчего-то такого не было, приходилось рестартить демон. Ну, правда, там Bind8.
Через 6 часов, в 23 часа, получив успешную делегацию и успев поужинать, попить чаю и посмотреть телевизор, пошёл настраивать всё прилагающееся.
Apache2, PHP, MySQL
===================
В дебиане установить апач — легче лёгкого.
`apt-get install apache2
apt-get install mysql-client mysql-server
apt-get install php5 php5-mysql php5-xmlrpc php5-cli php5-gd php5-curl php5-xsl`
В итоге я заполучил с пылу — с жару работающие Apache2, MySQL 5, PHP5 с нужными модулями.
Учитывая то, что MySQL по умолчанию ставится с пустым паролем —
`mysqladmin -uroot password мегасекурныйпароль`
Ну, и настроить виртуальные хосты.
Решаю всё хранить в /home/sites/
`mkdir /home/sites
mkdir /home/sites/habr.ru`
Иду в /etc/apache2/sites-availible
Создаю там
`touch habr.ru
ln -s /etc/apache2/sites-availible/habr.ru /etc/apache2/sites-enabled/habr.ru`
И в habr.ru:
`ServerAdmin master@habr.ru
DocumentRoot "/home/sites/habr.ru"
ServerName habr.ru
ServerAlias www.habr.ru
ErrorLog "/var/log/apache2/habr.ru.error.log"
CustomLog "/var/log/apache2/habr.ru.access.log" common`
Затем — рестарт апача
`/etc/init.d/apache2 restart`
Оставалось то, [о чём я уже писал раньше](http://skazkin.habrahabr.ru/blog/29716/), но про VDS и настраивая это в первый раз — а именно —
SVN + TRAC
==========
Как обычно —
`apt-get install subversion
apt-get install libapache2-svn
apt-get install trac`
Трак подтянул за собой свои зависимости, и я приступил.
Я выбрал для себя хранилищем сайта папку /home/sites/habr.ru, посему решил около этого и крутиться:
Начал с SVN, ориентируясь на [этот мануал](http://www.howtoforge.com/debian_subversion_websvn)
`mkdir /home/sites/svn
svnadmin create --fs-type fsfs /home/sites/svn
groupadd subversion
adduser svn_user --ingroup subversion`
Опустив строчки про авторизацию и генерацию авторизационных ключей, я сразу полез в Apache
Опять иду в /etc/apache2/sites-availible
`cd /etc/apache2/sites-availible
touch svn.habr.ru
ln -s /etc/apache2/sites-availible/svn.habr.ru /etc/apache2/sites-enabled/svn.habr.ru`
В svn.habr.ru:
`ServerAdmin master@habr.ru
DocumentRoot "/home/sites/svn"
ServerName svn.habr.ru
ErrorLog "/var/log/apache2/svn.habr.ru.error.log"
CustomLog "/var/log/apache2/svn.habr.ru.access.log" common
DAV svn
SVNPath /home/sites/svn`
Опять перезапускаю Апач:
`/etc/init.d/apache2 restart`
И — по [svn.habr.ru](http://svn.habr.ru) — у меня находится репозиторий.
Попил чаю, приступил к Trac.
Трак решил положить в /home/sites/trac
Сначала создать базу и пользователя:
`mysqladmin -uroot -p create trac
Выполнить запрос: GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP ON trac.* TO 'trac'@'localhost' IDENTIFIED BY 'tracmegapassword';
mkdir /home/sites/trac
trac-admin initenv /home/sites/trac`
СВН указывается тот, что уже сделали: /home/sites/svn
А когда trac спросил про БД-хранилище, ответил ему:
`mysql://trac:tracmegapassword@localhost:3306/trac`
Подправил руками /home/sites/trac/conf/trac.ini — всякие мелкие параметры, и в секции [trac] указал:
`[trac]
...
htdocs_location = /tracdocs/`
После чего полез в конфиг Apache — создавать хост.
`cd /etc/apache2/sites-availible/
touch trac.habr.ru
ln -s /etc/apache2/sites-availible/trac.habr.ru /etc/apache2/sites-enabled/trac.habr.ru`
В самом trac.habr.ru:
`ServerAdmin master@habr.ru
DocumentRoot "/home/sites/trac/htdocs"
ServerName trac.habr.ru
ErrorLog "/var/log/apache2/trac.habr.ru.error.log"
CustomLog "/var/log/apache2/trac.habr.ru.access.log" common
SetHandler mod\_python
PythonInterpreter main\_interpreter
PythonHandler trac.web.modpython\_frontend
PythonOption TracEnv /home/sites/trac
PythonOption TracUriRoot /
Alias /tracdocs /usr/share/trac/htdocs
SetHandler None`
После чего — рестарт апача
`/etc/init.d/apache2 restart`
И в итоге мы имеем **незапароленные** (внимательно с этим, я-то запаролил позже на глобальном уровне — а кто будет настраивать — не забудьте про секьюрность) SVN и Trac по соответствующим адресам:
[svn.habr.ru](http://svn.habr.ru)
[trac.habr.ru](http://trac.habr.ru)
В итоге у меня есть работающий (в ближайшем будущем на антресолях) сервер, на котором у меня поднят Trac, SVN, Apache2, MySQL, PHP, Bind9 и крутятся несколько сайтов.
А так же я хорошо поразвлекался и принёс пользу не только себе, но и семье — перевесив почту домашних на одном из моих доменов на гугл.апс.
Кроме того, я избавился от необходимости оплачивать медленную VDS (скоро перенесу secondary-зону к другу), теперь я знаю что происходит когда мои сайты недоступны (а не «у нас технические проблемы»), а так же могу делать столько доменов, субдоменов и прочего сколько хочется, а не сколько стоит в лимитах хостерского аккаунта.
А так же, теперь торрент качает без «технических» пауз (когда я с ноутбуком на работе).
Единственный минус всего этого — узкий обратный канал. Но у этого QWERTY, в котором я наблюдаюсь, есть трафиколимитированные «широкие» каналы — так что возможно, в скором будущем я буду им отстёгивать ещё 300 рублей за 100 мбит (если обратный трафик не тарифицируется), и буду проводить эксперименты с второй сетевой картой (чтобы торрент с сервера лил без лимитов по другому проводу)
Вот, как-то так.) Море удовольствия для меня и хорошее настроение на неделю=)
**Дополнительно, вопрос к телезрителям:** в какой блог лучше перенести для широкой публики — «Я умный», или «Linux для всех», или «Системное администрирование»?=) Учитывая не особо глубокие инструкции по применению?)
**UPDATE:** Вот только что немношка поседел — сервер перестал отзываться. Я забыл настроить самое главное — статический ip!
Позвонил жене, отдал инструкции о новых перенаправлениях, и — вуаля —
`mcedit /etc/network/interfaces
# удаляю всё, что относится к eth1 и добавляю:
auto eth1
iface eth1 inet static
address 192.168.1.5
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.0.255
gateway 192.168.1.1
#сохраняю, закрываю и потом...
/etc/init.d/networking restart`
На одну проблему стало меньше=)
Сегодня приду домой и воткну туда Wi-Fi — и обновлю этот пост с учётом Wi-Fi-настройки=)
**UPDATE2:**
Не проверил работоспособность ProFTPD извне!
Надо открыть /etc/proftpd/proftpd.conf и туда:
`DefaultAddress 111.222.333.444
Port 21
PassivePorts 60000 60010
MasqueradeAddress 111.222.333.444`
И внести соответствующие перенаправления портов на роутере! (для пассивных портов.). У меня их 10 — потому что не ожидается много коннектов | https://habr.com/ru/post/45921/ | null | ru | null |
# Без А/B результат XЗ, или Как построить высоконагруженную платформу А/B-тестов
Один из важных вопросов как в нашей жизни, так и в бизнесе, и в IT — вопрос эффективности. Эффективно ли мы планируем наше время, те ли задачи решает бизнес, тот ли код мы оптимизируем? Чтобы ответить на эти вопросы, **результат** должен обладать **главным критерием** — **измеримость**.Измеримость результата новых фич для бизнеса и IT обеспечивает **платформа** **А/B-тестов.** О том, как её можно построить, выдерживать большой RPS и при этом не ~~облажаться~~ уронить прод, я расскажу в этой статье.
В конце статьи вы узнаете, как мы задетектили проблемы инфраструктуры, оптимизация которых значительно повлияла на скорость всего Ozon.
Без А/B, как измерить результат ХЗ
----------------------------------
Приведём один из самых интересных и отчаянных примеров А/B-тестов, который может ответить на вопрос, интересующий как IT, так и бизнес:
— На фига мы упарываемся с оптимизацией времени ответа?
или
— Как скорость ответа влияет на деньги?
Чтобы ответить, мы можем сделать ухудшающий тест — деградацию скорости сайта (слабоумие и отвага) — и посмотреть, реально ли просядут денежные метрики.
Становится интереснее.
Давайте представим, что мы делаем фичу, в которой, к примеру, на 100 мс **замедляем** весь сайт, и хотим измерить, как это повлияет на наш GMV (оборот). Самый простой вариант: мы её просто выкатываем в прод и смотрим, как меняются метрики.
#### Ожидание
Как только мы включим нашу фичу, просядут бизнес-метрики:
#### Реальность
Метрики пошли вверх!
Возможно, просто наступил высокий сезон, и выручка за счёт распродаж стала больше. Непонятно, повлияло ли на это наше замедление.
Что же делать? Как измерить? На помощь приходит команда А/B-тестов с девизом:
Можно запустить А/B-тест — эксперимент, в котором нужно разделить (сплитовать) пользователей на две группы. Первой группе включать замедление (тестовая группа / слабоумие и отвага), второй группе — не замедлять (контрольная группа).
Не забываем также до запуска определить необходимые бизнес-метрики и рассчитать продолжительность эксперимента. По завершении эксперимента мы можем сравнить результаты в тестовой и контрольной группах и определить, были ли статистически значимые изменения или нет. Profit! 😎
Эксперимент с замедлением скорости интересен тем, что, замедляя на определённое время наш сайт, мы ожидаем, что **просядут бизнес-метрики**, а в **реальности** этого может **не происходить**. И проводя ряд экспериментов с разным замедлением, мы можем определить точку эластичности скорости ответа — точку, начиная с которой замедление сайта влияет на деньги. Тем самым вы можете найти критическое значение задержки, после которого может начаться ваш личный Армагеддон (о нашем Армагеддоне расскажу ниже).
Также могут быть полезны А/B-тесты на увеличение производительности — чтобы измерить явное влияние оптимизации IT на бизнес-метрики.
> Прочитать об экспериментах с деградацией скорости можно в главе 5 «Скорость имеет значение**»** книги «**Доверительное А/В-тестирование»** Кохави Р., Тан Д., Сюй Я.
>
>
В чем специфика А/B-тестов?
---------------------------
А/B-тесты находятся на пересечении трёх областей:
1. **Бизнеса**.Бизнесу важно иметь инструмент проверки своих гипотез и измерения эффективности новых фич.
2. **Аналитики** (статистики). Необходимо сформировать методологию проведения эксперимента, выбрать необходимый набор метрик, вычислить длительность эксперимента, определить критерии статистической значимости для каждой из метрик.
3. **Технической области**. Нужно обеспечить инфраструктуру для проведения А/B-тестов.
Техническую область можно разделить на две составляющие:
1. **Платформа сплитования пользователей.** Она предоставляет возможность в реалтайме делить пользователей на группы (тестовую и контрольную), определять, в какие эксперименты попал пользователь, возвращая включённые для него фичи. Система сплитования пользователей обеспечивает выдерживание большого RPS, инструменты интеграции с фронтенд- и бэкенд-микросервисами, отвечает за запуск и остановку экспериментов и выполняет другие функции.
2. **Стенд метрик.** Он обеспечивает расчёт метрик из разных источников данных, обрабатывая терабайты информации, вычисляет критерии статистической значимости и отдаёт результаты экспериментов.
В этой статье речь пойдёт о платформе сплитования пользователей. О стенде метрик, надеюсь, выйдет отдельная статья.
О платформе А/B-тестов в Ozon
-----------------------------
Нашей платформе А/B-тестов четыре года. За это время она прошла несколько этапов взросления (рефакторинга). На основе нашего опыта я опишу возможные подходы к построению платформы А/B-тестов и наши инсайты в области решения проблем, с которыми мы сталкивались во время эксплуатации платформы.
Вы можете увидеть, как за время существования платформы **кратно** выросло количество экспериментов — и, соответственно, увеличилась нагрузка на бэкенд и инфраструктуру:
 По вертикальной оси — количество тестов Первым клиентом платформы А/B-тестов в 2019 году стала наша команда, когда мы запускали сравнение рекомендательных алгоритмов. Помню, как ребята из Data Science думали, что сейчас будет суперпушка-алгоритм, запускали тест, а статистически значимых результатов часто не наблюдали. И это было хорошим стимулом для улучшения наших рекомендаций.
Если посмотреть на график выше, можно заметить, что в апреле этого года было запущено более **100 экспериментов**. И их становится только больше. Это происходит не только благодаря высокой скорости ответа платформы А/B-тестов, удобной интеграции и т. д., но также вследствие того, что меняются процессы в компании. Но это уже совсем другая история...
Как построить платформу А/B-тестов?
-----------------------------------
Далее я расскажу о подходах, используя которые можно построить платформу А/B-тестов. Мы рассмотрим их минусы и поймём, как прийти к «идеальной» архитектуре А/B-тестов.
Для этого обратимся к истории.
C чего всё начиналось?
А начиналось всё, как водится, с Exсel-ки. В ней была информация обо всех запущенных экспериментах для руководителя команды аналитики. Как известно, действительность может отличаться от ожиданий, а конфиг бэкенда с реально запущенными экспериментами — от прекрасной Exсel-ки.
Некоторые продукт оунеры могли проводить эксперименты, о которых не знал глава команды аналитики. Эти «подпольные» эксперименты могли оказывать влияние на бизнес-метрики других экспериментов — и об этом не знал **никто**.
Прикол в том, чтофайл с конфигом экспериментов был не один, а их было два. Был ещё один для мобильных приложений — и синхронизировать эти Excel-ки для аналитики экспериментов Ozon было больно.
Также из основных проблем можно выделить то, что не было единого стандарта учета экспериментов (описания их целей, метрик и т. д.), их реалтайм-запуска и остановки, истории запусков и возможности запуска мультисервисных экспериментов.
Для того чтобы определиться, как решить эти проблемы и построить А/B-платформу мечты, давайте рассмотрим возможные варианты её архитектуры.
OldSchool монолит
-----------------
Самый простой способ построения платформы А/B-тестов, который исторически был в Ozon, как и во всех компаниях того времени — это архитектура из 90-х и это конечно же монолит.
Пользователь при запросе токена авторизации автоматически получает А/B-группу как рандом с равномерным распределением от 0 до 99.
> `abGroup = random % 100`
>
>
Грубо говоря, пользователю присваивается процент распределения, в который он попал при авторизации. Далее этот процент сохраняется в куках и передаётся с фронта в каждом запросе.
Бэкенд-монолит при старте читает конфиг с указанием набора фич и указанием, для какого процента пользователей (набора А/B-групп) включается каждая фича.
Получая А/B-группу из кук, бэкенд определяет, какой набор фич включён для данного пользователя. На примере конфига ниже: если нам при авторизации выдали 40-ю А/B-группу, то нам вернулся следующий набор фич: `abGroupNewCheckout` (так как ей соответствует набор А/B-групп с 35-й по 65-ю) и `DeliveryVariant_1` (так как ей соответствует набор А/B-групп в интервале с 40-й до 54-й).
Пример конфига:
```
xml version="1.0" encoding="UTF-8"?
```
**Боль**: очень неудобно деплоить огромный монолит, чтобы включить или выключить небольшую фичу.
Давайте теперь представим, что мы перенеслись из 90-х — и у нас уже не монолит, а **современная** мультисервисная архитектура.
Молодёжная мультисервисная архитектура
--------------------------------------
Рассмотрим её на примере отображения карточки товара:
Запросы пользователей сначала идут на шлюз Ozon. Далее на шлюзе определяется, на какой бэкенд нужно пойти, чтобы отрисовать страницу. В нашем примере шлюз идёт в сервисы: PDP (product detail page), рекомендательный и отзывы. Мы этот бэкенд называем бэкендом первого уровня по удалённости от gateway.
Далее для того чтобы получить дополнительную информацию, бэкенд первого уровня идёт в бэкенд второго уровня. В нашем примере сервис Recoms (сервис первого уровня) запрашивает цены рекомендуемых товаров у price-api (сервис второго уровня) и описание товаров — у product service (сервис второго уровня).
Наложим паттерн с локальным конфигом и А/B-группой из 90-х на молодёжную мультисервисную архитектуру — и получим следующее решение:
Бэкенд первого и второго уровней при старте загружают конфиг с настройкой экспериментов по А/B-группам.
При обращении пользователя к сайту в момент авторизации он получает А/B-группу. Фронтенд передаёт её в gateway, gateway, проксируя запросы, передаёт А/B-группу в бэкенд первого уровня. Бэкенд первого уровня по А/B-группе определяет набор включённых фич, передаёт А/B-группу в бэкенд второго уровня, который по ней тоже определяет набор включённых фич.
**Минусы этого подхода:**
* нет истории экспериментов;
* нет возможности планировать эксперименты;
* информация об экспериментах разрознена;
* нет возможности остановки/запуска экспериментов в реалтайме: остановка/запуск производится только через деплой, так как для этих операций нужно менять конфиг и рестартить сервисы;
* пользователи могут неравномерно распределяться между экспериментами, так как одна и та же А/B-группа используется для разных экспериментов;
* нет возможности задавать условия попадания пользователей в эксперименты.
Один из ключевых минусов — отсутствие возможности запуска/остановки эксперимента в реалтайме.
EventDream
----------
Для того чтобы решить проблему с реалтаймом, мы можем сделать сервис `ab-test-api`, который будет оповещать сервисы о запуске экспериментов и их остановке.
Логика такая же, как в подходе выше, только информация об экспериментах может легко обновляться и всегда актуальная.
Однако остались другие минусы:
* нет истории экспериментов;
* нет возможности планировать эксперименты;
* информация об экспериментах разрознена;
* пользователи могут неравномерно распределяться между экспериментами, так как одна и та же А/B-группа используется для разных экспериментов;
* нет возможности задавать условия попадания пользователей в эксперименты.
Нас это не очень устраивает, поэтому попробуем другой подход, который решит сразу три проблемы. И этот подход конечно же...
Single Responsibility
---------------------
В этом подходе мы будем использовать архитектуру, в которой центральным сервисом будет `ab-test-api`.
Функции этого сервиса:
* хранить информацию обо всех экспериментах с историей для всех сервисов;
* отдавать для каждого сервиса набор включённых фич.
Общая логика с А/B-группой остаётся неизменной, только теперь бэкенд для получения данных о наборе включённых фич будет идти в сервис `ab-test-api`, передавая в него A/B-группу.
Таким образом, в каждом из сервисов самостоятельно не нужно определять, какая фича включена для какой А/B-группы, и хранить свой локальный конфиг.
**Минусы этого подхода:**
* высокий RPS, так как каждый сервис идёт за экспериментами;
* пользователи могут неравномерно распределяться между экспериментами, так как одна и та же А/B-группа используется для разных экспериментов;
* нет возможности задавать условия попадания пользователей в эксперименты.
Архитектура стала намного лучше, правда появилась проблема с высоким RPS: как говорится, за всё нужно платить.
Давайте рассмотрим, как мы можем решить важнейшую проблему для аналитики — неравномерное распределение пользователей между экспериментами.
Динамически определяемая А/B-группа, или Свой шейкер в каждом эксперименте
--------------------------------------------------------------------------
Для того чтобы убрать зависимость попадания пользователя в эксперименты от глобальной А/B-группы, вследствие чего может возникать неравномерное распределение пользователей между экспериментами. Мы будем вычислять в каждом эксперименте свою А/B-группу.
Для этого убираем поход в сервис авторизации (лишняя зависимость уходит — ура!) — и вместо А/B-группы будем передавать идентификатор пользователя.
Теперь в сервисе `ab-test-api` в каждом эксперименте мы можем определять динамически А/B-группу для пользователя. Вычислять её как хеш-функцию от идентификатора пользователя, подмешивая `salt`:
> `ABGroup = hash(userID + salt) %100`
>
>
Это позволяет также делать в A/B-тестах слои и равномерно размазывать пользователей между всеми экспериментами.
Какие остались минусы:
* высокий RPS, так как каждый сервис идёт за экспериментами;
* нет возможности задавать условия попадания пользователей в эксперименты.
Вместо тысячи ̶с̶л̶о̶в̶ каскадных запросов → gateway
----------------------------------------------------
Для того чтобы решить проблему каскадного увеличения RPS, мы будем запрашивать данные для всех сервисов в gateway и передавать их во все бэкенды.
Всё красиво. Правда, тут мы сталкиваемся с новой проблемой: а как именно нам передавать информацию обо всех экспериментах в бэкенд первого и второго уровней? Мы можем передавать её явно, но для этого нужно будет менять контракты всех хендлеров, что довольно проблематично и неудобно. К нам на помощь приходит смекалочка и идея для этого использовать header. В результате мы один раз пишем информацию об экспериментах в header-запросах gateway — и дальше она автоматически проксируется во все запросы бэкенда.
Для того чтобы реализовать фильтрацию пользователей в экспериментах, мы просто в gateway делаем дополнительный запрос к сервису user\_profile. Данный сервис отвечает за информацию о пользователе и отдает нам её. Далее gateway передаёт информацию о пользователе в сервис `ab-test-api` и запрашивает данные об экспериментах. `ab-test-api` находит эксперименты, удовлетворяющие данным пользователя, и только для них отдаёт набор включённых фич.
Минус:
* всё ещё остаётся высокий RPS, так как каждый запрос gateway идёт в платформу A/B-тестов.
Как мы справляемся с высоким RPS?
---------------------------------
Для ответа на этот вопрос давайте разберёмся, как происходит добавление эксперимента в платформу A/B-тестов.
При добавлении эксперимента в платформу A/B-тестов через веб-интерфейс запрос идёт в A/B-контроллер — сервис, отвечающий за справочник всех экспериментов. Он сохраняет данные о новом эксперименте в базу данных и добавляет их в `etcd`(key-value storage). На изменения в `etcd` подписан сервис `ab-test-api`, который отвечает за быстрый ответ на запросы бэкенда.
Поскольку данный сервис подписан на все изменения, касающиеся экспериментов, он сохраняет информацию в локальный кэш. В локальном кэше оказывается информация обо всех экспериментах, текущих и будущих, по которым можно быстро отдать информацию о попадании в них пользователей.
Благодаря тому, что у сервиса `ab-test-api` всё находится в оперативке и он подписан на все изменения, касающиеся экспериментов, мы его можем легко горизонтально масштабировать и выдерживать **любой RPS**.
**Минусы:**
* их нет 🤞
О чём мы забыли в архитектуре?
О том, без чего А/B-тесты лишены смысла, — об **аналитике.**
Отправка данных в аналитику
---------------------------
Для анализа данных эксперимента необходимо, чтобы информация о том, в какие эксперименты попал пользователь, была в Data Lake.
Мы это обеспечили следующим образом. Когда gateway получает ответ от бэкенда, он всю собранную информацию передаёт в мобильное приложение / фронтенд. Мобильное приложение / фронтенд отображает ответ бэкенда и, реагируя на действия пользователя, накапливает батч ивентов. В нужный момент времени они отправляют их в трекер аналитики. Он обогащает все ивенты информацией об экспериментах: для этого он передаёт информацию о пользователе в сервис `ab-test-api`, получает ответ и уже обогащённые ивенты отправляет в Data Lake.
Теперь любой аналитик может пойти в Data Lake и выцепить все интересующие его ивенты для каждого эксперимента. Profit! 😎
**Прекрасная архитектура, мы выдерживаем любой RPS.** Внимание, вопрос:
А дальше был...
У нас умер стейдж, и мы долго не могли понять, что произошло. Оказалось, что всё-таки у нашей архитектуры была проблема. И проблемой этой был header, в который мы не стеснялись писать данные и передавали информацию обо всех экспериментах, которые проходили в Ozon. И когда его размер превысил 4 Кбайт, мы превысили ограничение Nginx — и на каждый запрос возвращалась ошибка.
Чтобы понять, в чём была проблема, рассмотрим два сервиса, в которых проходят эксперименты:
* **сервис поиска** c параметром `rankingAlgorithm string`,
* **сервис корзины** с параметром `IsNewCart string`.
Если для этих сервисов представить JSON, который мы передавали в header, то он будет примерно следующего вида:
```
{
"search": {
"config": {
"rankingAlgo": "newAlgo"
},
"experiments": [{"ID":1,"variantID":2}]
},
"cart": {
"config": {
"isNewCart": true
},
"experiments": [{"ID":2,"variantID":4}]
}
```
И если экспериментов становится много, то этот JSON может набирать килобайтные размеры.
Для уменьшения гигантского размера JSON мы придумали следующий FastFix.
FastFix
-------
Идея: вместо этого прекрасного JSON в header будем передавать компактный UUID.
Для этого ab-test-api при получении запроса от gateway вычисляет JSON, генерит **UUID** и далее этот JSON по ключу UUID сохраняет в Memcached. Теперь по этому ключу бэкенд может получить данные.
Поэтому сервис `ab-test-api` вместе с конфигом бэкенда возвращает UUID в gateway и далее gateway передаёт в header UUID всем сервисам бэкенда. Когда бэкенд-сервису необходимо узнать, какие фичи включены для пользователя, он идёт в `ab-test-api`, передавая туда UUID. `ab-test-api` в свою очередь идёт по этому ключу в Memcached, получает JSON и из него отдаёт набор включённых фичей для сервиса.
Также для сервисов первого уровня можно передавать из gateway явным образом набор включённых фич в body, чтобы убрать лишнее обращение к `ab-test-api`.
Так мы решили проблему большого header — теперь его размер всегда фиксирован.
Кажется, можно было на этом остановиться, но у данного подхода есть минусы:
* дополнительный RPS сервисов второго уровня;
* дополнительная зависимость архитектуры от Memcached, который на стресс-тестах нужно масштабировать.
Поскольку мы упоротые инженеры и боремся за миллисекунды, то придумали, как избавиться от этих двух минусов и сделать **идеальную архитектуру**💎
Идеальная архитектура
---------------------
Как сказал Жак Пеше,
### Поэтому план такой:
* чтобы избавиться от Memcached, нужно передавать данные об экспериментах в header, как в старые добрые времена;
* чтобы решить проблему RPS сервисов второго уровня, нужно сделать на клиенте кэш;
* чтобы не наступил Армагеддон с размером header, нужно придумать минимальный формат сжатия данных об экспериментах.
Инструмент, который решает всё эти проблемы — **бинарный протокол** передачи информации об экспериментах, в которые попал пользователь.
Цель бинарного протокола — в как можно более сжатом виде представить информацию об экспериментах, в которые попал пользователь.
Реализация данного протокола даёт возможность использовать его как уникальный идентификатор включённых для пользователя экспериментов, то есть в качестве ключа кэша для клиентов бэкенда. Это позволяет нам реализовать кэш для клиентов бэкенда второго уровня, чтобы значительно уменьшить RPS.
Мы придумали следующий формат бинарного протокола:
* первые 10 бит используются для передачи идентификатора сервиса (мы отталкиваемся от того, что максимальное количество сервисов — 2^10);
* 4 бита номер ревизии, когда добавляются новые эксперименты/удаляются меняется номер ревизии. Таким образом мы решили одну из главных проблем в IT — проблему инвалидации кэша;
* n бит для передачи битовой маски вариантов экспериментов, в которые попал пользователь.
Таким образом, JSON из нашего примера конвертируется в этот красивый формат:
Получается прекрасная архитектура, в которой `ab-test-api` при получении запроса от gateway вычисляет для каждого пользователя значение нашего бинарного ключа (binary key) как набор уникальных экспериментов, в которые попал пользователь. Теперь по этому ключу бэкенд может взять данные из кэша или запросить их для прогрева.
Поэтому мы проксируем binary key вместо UUID из gateway во все сервисы бэкенда в header. Когда бэкенд-сервису необходимо узнать, какие фичи включены для пользователя, он смотрит, есть ли данные по бинарному ключу в кэше? Если есть, сразу берёт их, если нет — идёт в `ab-test-api` с binary key, получает набор включённых для пользователя фич и сохраняет их в кэш. Таким образом, если с таким же бинарным ключом придёт ещё один запрос, результат возьмём из кэша.
Также для сервисов первого уровня мы передаём из gateway явным образом набор включённых фич в body для каждого сервиса.
В результате мы убрали лишнюю зависимость от Memcached — и можете увидеть на сколько упал RPS для сервисов второго уровня: на примере сервиса `rtb-api`, в котором у нас было уменьшение RPS **в 500 раз** (с 5k до 9.87).
А/B на острие атаки RPS
-----------------------
Благодаря простоте, масштабируемости и красоте платформы А/B-тестов наша команда часто находила проблемы инфраструктуры и стояла у истоков больших открытий Ozon.
За время моей работы в компании были запущены революционные фичи, которые оказали большое влияние на оптимизацию скорости ответа всего бэкенда. И без стеснения могу сказать, что часто всё начиналось с нашей платформы А/B-тестов.
> **~~В начале было слово~~**
>
> **В начале был А/B-тест**
>
>
### Проблема клиентской балансировки
Вводная информация:
* время ответа ab-test-api по 99 квантили < **1 мс**;
* однако мы отваливались по тайм-ауту от gateway, который шёл со временем ожидания **10 мс.** Таких запросов было
4% ошибок А/B-тестов, прыгающих фич и проблем в аналитике — это беда.
Когда ты приходишь к команде инфраструктуры и говоришь, что вроде проблема в инфраструктуре, тебе всегда уверенно отвечают:
> «Ваш код — ~~💩~~ не очень, оптимизируйте».
>
>
Если ты отвечаешь, что архитектурочка — огонь, тебе отвечают: «См. п. 1».
Пришлось засучить рукава и доказывать, что проблема не на нашей стороне. Для этого было решено сделать два сервиса:
* `ab-poligon` c методом `Ping`, который не делает ровным счётом ничего, кроме того что сразу возвращает ответ, чтобы невозможно было придраться к неоптимальному коду;
* `ab-shooter`, чтобы стрелять по нашему сервису полигона с нужным RPS и измерять нужным образом скорость ответа (заданными бакетами в Prometheus).
Далее мы делали ряд стрельб из shooter и заметили, что сервис, который не делает ровным счётом ничего при 1k RPS, отвечает в 4% запросах дольше 10 мс при любом количестве подов, так же, как и мы.
Proof! 😎 То есть мы доказали, что **ни один сервис** не может отвечать быстрее **10 мс** по 96 квантили, даже не по 99.
Далее после общения с командой инфраструктуры мы решили попробовать делать запрос в наш в бэкенд минуя Ingress Controller:
Мы стали делать запросы по IP из shooter в полигон и это привело нас к следующему результату: **вместо 4% запросов**, которые отвечали дольше 10 мс, **их стало меньше 1%**. По 0,9 квантили время ответа Ping с 5 мс уменьшилось до 1 мс, то есть **в пять раз**, а по 0,99 — в **семь раз**.
В результате **процент ошибок** gateway по тайм-ауту уменьшился с 4% до 0,2% — то есть в **20 раз**.
Это привело к системному решению внутри компании: убрать балансировку на уровне Ingress Controller и перенести её на клиентскую сторону. Это в разы уменьшило время на Round Trip для ответов бэкенда **всего Ozon**.
Далее мы жили-не тужили ровно год, как к нам в дверь снова постучалось долгое время ответа и мы столкнулись со следующей ситуацией.
Проблема ядер сетевых карт
--------------------------
Мы заметили, что наш сервис отвечает дольше 40 мс по 99 квантили, что невозможно, учитывая нашу архитектуру. Всё находится в оперативке, и при хорошем масштабировании подов сервис просто по определению не может отвечать долго.
Мы пришли к команде инфраструктуры, история повторилась:
> «Ваш код — ~~💩~~ не очень, оптимизируйте. Если что-то непонятно, см. п. 1».
>
>
Нам пришлось расчехлить наши shooter с полигоном, которые показали, что Round Trip больше **40 мс** в **1,266%** ответов для сервиса, который ровным счётом ничего не делает. Это говорит о том, что по **99 квантили** скорость ответа **любого бэкенда** по априори не может быть **меньше 40 мс** и безусловно это аффектит **весь Ozon.**
Далее мы забили в колокол, собрали доказательную базу, передали все материалы ребятам из команды платформы, они взяли на вооружение наш шутер с полигоном, расследовали проблему и решили её. Это сильно оптимизировало скорость всего Ozon. А ребята написали [прекрасную статью](https://habr.com/ru/company/ozontech/blog/662758/) (рекомендую к прочтению), в которой есть пасхалочка о нашей платформе А/B-тестов:
Заключение
----------
Вне зависимости от того, какую именно систему вы строите:
• основываясь на опыте нашего Армагеддона, рекомендую заранее учесть все нюансы её пропускной способности и иметь перед глазами метрику, которая говорит о том, сколько времени/ресурсов осталось до огня на продакшене;
• основываясь на продемонстрированных **восьми** возможных подходах (модифицикациях) платформы А/B-тестов, рекомендую изо всех сил бороться за максимально простую архитектуру с минимальным количеством зависимостей, даже если для этого нужно упороться и придумать какую-то мульку (в нашем случае — свой бинарный протокол сжатия данных).
Если вы будете уверены в вашей архитектуре, то сможете доказать любой команде, что проблема не на вашей стороне. Тем самым помочь найти реальный батлнек, избавившись от которого, компания сможет получить большой профит, в нашем случае — уменьшение времени Round Trip по 99 квантили **в семь раз**.
За четыре года мы прошли огромный путь от двух до 100 экспериментов в месяц. Мы не раз оптимизировали нашу платформу, оперативно решали проблемы горящего продакшена, меняли процессы и придумывали инновационные решения. Хочу сказать большое спасибо всем бэкендерам, тимлидам, продукт оунерам, тестировщикам, фронтендерам, дизайнерам, аналитикам, которые вложили свою душу в нашу платформу А/B-тестов, продолжают её пилить и совершенствовать. Также отдельное спасибо руководству за доверие и наставничество.
Наша команда благодаря команде валидации, прекрасному продукт оунеру и нашему CTO [@AntonStepanenko](/users/antonstepanenko) пилит очень интересные инструменты А/B-тестирования, о которых, надеюсь, мы расскажем в следующих статьях.
> Cпасибо A/B Team: без вас не было бы прекрасной платформы и этой статьи 💪
>
>
> Отдельное спасибо за титанический труд редактору, вдохновителю и деврелу [@golden\_oar](/users/golden_oar) и главному коучу, контент-менеджеру и просто крутому аналитику [@p0b0rchy](/users/p0b0rchy), благодаря которому родился [доклад на Saint HighLoad](https://highload.ru/spb/2022/authors/14766) и эта статья 🤝
>
> | https://habr.com/ru/post/689052/ | null | ru | null |
# TextView и Spannable: выделение частей слова
**Привет, Хабрамир!** Меня зовут Оксана и я Android-разработчик в небольшой, но очень классной команде [Trinity Digital](https://www.facebook.com/trinitydigitalrus/).
Сегодня я буду рассказывать про маленькую часть большого проекта.
Проект зовется ***“Школа 2100”*** и представляет собой коллекцию электронных учебников с разными фичами: поиском, закладками-заметками, дополнительными материалами, тестовыми заданиями, etc. И как раз в том, что названо *“тестовыми заданиями”* кроется предмет обсуждения.
**Среди** прочих разных тестов есть необходимость реализовать задание на разбор слова по составу (он же морфологический разбор). Выглядеть оно должно примерно так:
**Вкратце:** есть набор слов — их нужно отобразить в виде прокручиваемого списка. Вверху списка должны быть кнопочки, которые позволяют ассоциировать части слова с определенными морфемами (приставка, корень, суффикс, окончание, основа).
Выделяем часть слова, жмем кнопочку — графическое обозначение морфемы отрисовывается. И, плюс, маленький крестик для удаления.
Чтобы сделать всю эту красоту, нам понадобится реализовать механизм выделения частей слова — собственно, дальше разбираемся именно с этой задачей.
**Правила выделения** нужны такие:
* кликаем на букву, она подсвечивается
* если подсвечена одна буква, и на нее кликнуть повторно — подсветка сбрасывается
* если подсвечена одна буква, и кликнуть на другую — будут подсвечены эти две плюс все что между ними
* если подсвечено больше одной буквы и кликнуть на любую — будет подсвечена только эта любая
**Вдобавок ко всему**, между буквами слова должно быть некоторое расстояние (трекинг), большее, чем в стандартном шрифте. Это для того, чтобы потом было удобно рисовать морфемы и они не “слипались” визуально.
**Для реализации** была выбрана комбинация *TextView + Spannable*, которая обладает достаточными возможностями и вместе с тем довольно проста в работе.
Вообще, *Spannable* — это такой интерфейс, который описывает маркировку текста объектами, связанными с форматированием этого текста. Форматирующие объекты — это экземпляры классов, которые реализуют интерфейс *ParcelableSpan*. Есть готовые реализации (например, UnderlineSpan, ForegroundColorSpan, StrikethoughSpan и прочие), но мы реализуем этот интерфейс сами, потому что нам нужны одновременно трекинг и цвет.
Собственно, только для того чтобы сделать трекинг, уже понадобится кастомная реализация (если и есть готовая, то она не была найдена).
**ДЕМО
----**
**Итак,** переходим на просторы уютненького демо-проекта, в котором будет:
* **WordAnswerView** — класс-наследник TextView, в котором и будет происходить все самое интересное
* M**ainActivity** — главный экран, там мы создадим экземпляр WordAnswerView
* **activity\_main.xml** — разметочка-контейнер
Начнем с **activity\_main.xml,** там все просто:
```
xml version="1.0" encoding="utf-8"?
```
Теперь **MainActivity**:
```
package ru.trinitydigital.textselecting;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.RelativeLayout;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
RelativeLayout container = (RelativeLayout) findViewById(R.id.container);
container.addView(new WordAnswerView(this, "hello", convertDpToPx(30)));
}
}
```
И наконец **WordAnswerView**, будем разбирать поэтапно. Создаем наследника *TextView* и определяем нужные свойства:
```
public class WordAnswerView extends TextView {
// тут будем хранить исходную строку
private final String originalText;
// это число определяет, сколько пикселей отведено на трекинг (расстояние между буквами)
private float tracking = convertDpToPx(16);
// цвет выделения
private int selectionColor = Color.parseColor("#5591F6");
// специальное значение для отсуттсвия выделения
private static final int NO_SELECTION = -1;
// начало и конец выделения (индексы символов в строке)
private int selectionBegin = NO_SELECTION,
selectionEnd = NO_SELECTION;
// та самая штука, которая отвечает за отрисовку трекинга и выделения
private SelectionTrackingSpan selectionTrackingSpan = new SelectionTrackingSpan();
// понадобится позже, чтобы определять, на какую букву был клик
private int baseWidth;
}
```
**В конструкторе** вот что:
```
public WordAnswerView(Context context, CharSequence text, float textSizePx) {
super(context);
// запоминаем текст
originalText = text.toString();
setTextSize(textSizePx);
setTextColor(Color.BLACK);
// это нужно для того, чтобы на каждую букву приходилась одинаковая ширина,
// так будет гораздо удобней отрисовывать морфемы
setTypeface(Typeface.MONOSPACE);
setPadding((int) tracking, 0, (int) tracking, 0);
// на всю строку устанавливаем наш спан, который будет отвечать за форматирование
SpannableString s = new SpannableString(originalText);
s.setSpan(selectionTrackingSpan, 0, originalText.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
setText(s);
}
```
**Еще** нужно ловить касания, так что добавим кода в конструктор:
```
public WordAnswerView(Context context, CharSequence text, float textSizePx) {
// …
setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
switch (event.getActionMasked()) {
case MotionEvent.ACTION_UP:
// считаем индекс символа, на который кликнули
int index = (int)(event.getX() / baseWidth);
// и устанавливаем границы выделения согласно описанным выше правилам
if (selectionBegin == index && selectionEnd == NO_SELECTION) {
selectionBegin = NO_SELECTION;
selectionEnd = NO_SELECTION;
invalidate();
break;
}
if (selectionBegin == NO_SELECTION) {
selectionBegin = index;
}
else if (selectionEnd == NO_SELECTION) {
selectionEnd = index;
if (selectionBegin > selectionEnd) {
int tmp = selectionBegin;
selectionBegin = selectionEnd;
selectionEnd = tmp;
}
} else {
selectionBegin = index;
selectionEnd = NO_SELECTION;
}
invalidate();
break;
}
return false;
}
});
}
```
**Кстати**, чтобы все у нас было хорошо с определением того, на которую букву кликнули, надо еще добавить вот это:
```
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
baseWidth = w / originalText.length();
}
```
Добираемся до самой сути — напишем класс **SelectionTractingSpan**:
```
public class SelectionTrackingSpan extends ReplacementSpan {
@Override
public int getSize(Paint paint, CharSequence text, int start, int end, Paint.FontMetricsInt fm) {
// размер будет достаточный для того чтобы нарисовать буквы + расстояния между ними
return (int)(paint.measureText(text, start, end) + tracking * (end - start));
}
@Override
public void draw(Canvas canvas, CharSequence text, int start, int end, float x, int top, int y, int bottom, Paint paint) {
float dx = x;
for (int i = start; i < end; i++) {
// если символ не попадает в выделенную часть, будем рисовать его просто черным
if (i < selectionBegin || i >= (selectionEnd != NO_SELECTION ? selectionEnd + 1 : selectionBegin + 1)) paint.setColor(Color.BLACK);
else paint.setColor(selectionColor);
canvas.drawText(text, i, i + 1, dx, y, paint);
dx += paint.measureText(text, i, i + 1) + tracking;
}
}
}
```
**Итого**, рецепт довольно прост:
* Наследуемся от TextView
* Ловим касания и запоминаем границы выделения
* Создаем наследника ReplacementSpan, который будет красить текст в зависимости от этих границ
+ делать трекинг
**Profit :)**
→ Исходники в [нашем github](https://github.com/39ty/word-answer-view) | https://habr.com/ru/post/340232/ | null | ru | null |
# MODx Revo, настройка авторизации Login. Базовая установка
Данная статья в большей части является переводом урока с [официального rtfm](http://rtfm.modx.com/display/ADDON/Login.Basic+Setup "официального rtfm"), а именно компонента «Login», но с вставками переводчика. На лучший перевод не иду, но суть в итоге должна быть понятной. Тем не менее, перевода на русский я до сих не нашёл.
Данный урок, хоть и называется «базовым», имеет много взаимосвязанных частей. В данном уроке мы будем обсуждать, какие страницы надо создать, какие чанки (фрагменты кода) и сниппеты нужно опубликовать на страницах для полноценной авторизации пользователей.
Номера в скобках — это ID ресурсов. Это page\_id, у вас он может отличаться. Здесь они выбраны просто для удобства.
Создаём нужные страницы
-----------------------
Перед тем, как выложим чанки с фрагментами кода, создадим пять страниц.
* **Страница входа (1):** страница, содержащая форму входа
* **Сброс пароля (2):** страница, где пользователи могут запросить восстановление пароля
* **Сброс пароля, обработчик (3):** скрытая страница, которая будет на самом деле сбрасывать пароль. Пользователи её видеть не будут.
* **Страница только для пользователей (4):** страница, содержимое которого видят только авторизованные пользователи сайта
* **Страница выхода (5):** страница, на которую переадресовывается пользователь после успешного выхода
Вот так у меня выглядит дерево ресурсов в данный момент. Имейте виду, что у вас ID ресурсов будет другой. В данном примере ничего кроме страниц для компонента «Login» нету.
Дальше, нам нужно назначить правильные права для пользователей и ресурсов.
Создаём необходимые группы пользователей и группы ресурсов
----------------------------------------------------------
MODX Revo имеет очень гибкую систему детализации прав, когда дело доходит до разрешений для пользователей, но в данной теме мы сделаем только то, что нам нужно не заходя глубоко в тему. И так, приступим.
**1. Безопасность → Группы Ресурсов**
Нажимаем на «Создать группу ресурсов» и называем её «Только для пользователей», например. Нажимаем «Сохранить» и всё, на данной странице больше ничего не меняем.
**2. Безопасность → Контроль доступа**
На первой вкладке «Группы пользователя» нажимаем на «Новая группа пользователей». Новую группу назовём «Пользователи» и нажмём «Сохранить». Группа пользователей будет иметь доступ к ресурсам «Только для пользователей». Зачем это нам, мы узнаем чуть позже в рамках этого урока.
3. На этой же странице (**Безопасность → Контроль доступа**), щелкнём правой кнопкой мыши на созданную группу пользователей и выберем «Редактировать группу пользователей».
Далее переходим на вкладку «Доступ к группам ресурсов» и щёлкаем на «Добавить группу ресурсов». Для правильной работы, должны быть как минимум такие параметры:
**Группа ресурсов:** Только для пользователей (тот, который мы только что создали)
**Минимальная роль:** Member-9999
**Политика доступа:** Load, List and View
**Контекст:** web
И сохраняем.
**4. Безопасность → Управление пользователями**
Создаём «нового пользователя» и тем самым проверяем, как будет работать разграничение прав доступа для пользователей.
В данном случае, используйте простой логин и пароль, ибо нам, как я уже выше писал — важно убедиться в том, что новый пользователь находится в группе «Пользователи». Для этого переходим на вкладку «Права доступа» и нажимаем на «Добавить пользователя в группу».
**Группа пользователя:** Пользователи
**Роль:** Member
Затем нажимаем «сохранить» у окошка, а затем **ещё раз** в правом углу панели управления.
Это должно нам гарантировать, что новый пользователь может войти в систему с правами «Пользователя», чтобы смотреть страницу с правами «Только для пользователей».
Теперь вернёмся назад к страницам, дабы добавить сниппеты и фрагменты кода на соответствующие страницы.
Добавляем сниппеты на страницы
------------------------------
### Страница входа (1)
Поместите следующий код вызова сниппета на странице входа пользователей.
```
[[!Login? &loginTpl=`lgnLoginTpl` &logoutTpl=`lgnLogoutTpl` &errTpl=`lgnErrTpl` &loginResourceId=`4` &logoutResourceId=`5`]]
```
Чанк (фрагмент кода), который отображает форму входа, должна также включать в себя ссылку на страницу с «восстановлением пароля». Разберём, что у нас в вызове формы:
&loginTpl=`lgnLoginTpl` — за форму входа отвечает чанк lgnLoginTpl, если пользователь не авторизован
&logoutTpl=`lgnLogoutTpl` — если пользователь авторизован, то ему будет выдаваться содержимое чанка lgnLogoutTpl
&errTpl=`lgnErrTpl` — при неправильном вводе данных для авторизации, или простым словом «ошибке», будет выводиться чанк lgnErrTpl
&loginResourceId=`4` — куда переадресовывать пользователя после успешной авторизации. Указано в виде ID ресурса, в данном случае 4.
&logoutResourceId=`5` — если пользователь авторизован, то при выходе будет переадресован на страницу с ID равным 5.
Так же, хочу отметить, что эти чанки стандартные, можно создать свои чанки, на любой вкус, вёрстку, и реализацию. Это предоставляет возможность выводить форму входа/выхода и прочее в любом желаемом виде, и причём, не устраивая хаоса с кодом. Стандартные шаблоны, кстати, тоже можно изменять.
Вот код, который будет отдаваться пользователям, которые ещё не авторизовались, другими словами — «форма входа». Чанк — **lgnLoginTpl**.
```
[[+errors]]
[[+actionMsg]]
[[%login.username]]
[[%login.password]]
[[+login.recaptcha\_html]]
[Забыли пароль?]([[~2]])
```
Вы можете поставить ссылку на «Забыли пароль» (Сброс пароля) внутри вашего шаблона и ссылаться на него по ID. В моём случае, ID ресурса с восстановлением пароля — 2.
### Сброс пароля (2)
Начнём с того, что это страница чаще всего скрыта из меню. Она является в большей части формой, с помощью которой пользователи могут сбросить пароль. Тут хочется вам объяснить то, что страница со сбросом пароля (с ID 2 в моём случае), предоставляет возможность сказать о том, что пароль нужно восстановить, а сам сброс делает страница «Сброс пароля, обработчик (3)».
Вызываем форму сброса пароля следующим кодом:
```
[[!ForgotPassword? &resetResourceId=`3` &tpl=`lgnForgotPassTpl`]]
```
Разберём вызов:
&resetResourceId=`3` — страница обработчик (в моём случае с ID 3), именно она сбрасывает.
&tpl=`lgnForgotPassTpl` — чанк с кодом, в котором есть форма сброса пароля.
Чтобы понять, зачем обработчик и как это работает, предлагаю взглянуть на картинку:
### Сброс пароля, обработчик (3)
Данная страница должна быть спрятана из всяких менюшек. Тем не менее, даже если ссылка на неё будет — она будет просто бессмысленная.
Суть её в следующем. Когда пользователь запрашивает сброс пароля, ему на почту приходит сообщение с этой ссылкой, а также с хэшем. Когда пользователь переходит по ссылке из почты, MODx сбрасывает пароль и переадресует пользователя на страницу с входом.
На странице обработчика, сниппет вызывается вот так:
```
[[!ResetPassword? &loginResourceId=`1`]]
```
— &loginResourceId=`1` указывает, на какую страницу переадресовывать, в нашем случае на страницу с ID 1, где есть форма входа.
### Страница только для пользователей (4)
Это страница, подтверждающая то, что пользователь успешно авторизовался. Содержимое данной страницы доступно только авторизованным пользователям.
Для того чтобы страница была доступна только авторизованным пользователям, нам нужно назначить для неё права. Для этого, в дереве ресурсов нажимаем на «Страницу только для пользователей». Затем, переходим на вкладку «Права доступа», там мы видим текст «Только для пользователей» и справа от него, в колонке «Доступ» видим не отмеченный чек-бокс. Отмечаем чек-бокс и нажимаем «сохранить».
### Страница выхода (5)
Это страница, на которую попадают пользователи после успешного выхода из аккаунта. Страница должна содержать только основное, например сообщение с прощанием, или ссылку на форму входа. Например:
```
Спасибо за посещение! Возвращайтесь скорее!
```
Дополнительно
-------------
### Страница выхода (5)
Это не является обязательным, но для тестирования и вообще, удобства при разработке, можно получить специальную ссылку для выхода. Для этого создаём «новую ссылку» (web-link) и заполняем её страницу с ID 1. Например, вызывать страницу со ссылкой вот так:
```
[[~1? &service=`logout`]]
```
Это можно использовать для выхода в таком виде:
```
[Выйти]([[~1? &service=`logout`]] "Выйти")
```
Возможные ошибки
----------------
После того, как мы собрали все страницы, связали их, настроили права доступа, мы должны всё проверить. Если всё работает по нашему плану, то при входе мы будет переправлены на страницу «Только для пользователей». Выйти из аккаунта мы может через страницу входа, так как, если мы авторизованы — то на странице входа появится ссылка на выход. После успешного выхода, вы должны быть переправлены на «страницу выхода».
### Я не могу авторизоваться!
Обычно, такие проблемы возникают при неправильном указании ID страниц, неправильно написанных имён чанков, или пропущенных квадратных скобок. Внимательно проверьте коды.
Кроме этого, стоит помнить, что все выше написанные сниппеты должны вызываться некэшированными. Конечно, некоторые возможно будут работать в кэшированном виде, но большинство — нет. Вызывать в некэшированном виде можно с помощью восклицательного знака, например надо писать вот так:
```
[[!Login]]
```
А не так:
```
[[Login]]
```
### Я не могу выйти из аккаунта!
Одной из причин, из-за которой никак выйти из аккаунта является то, что ссылка выхода указывает на страницу, где нету формы входа. Стоит помнить, что кнопка выхода должна указывать на страницу с формой входа.
Так же, может быть, что при сбросе пароля, на электронную почту не приходит сообщение. В данном случае стоит настроить отправка почты на вашем сервере.
Вопросы задавайте, если знаю ответ, несомненно помогу. Следующий урок будет переведён в свободное время. Ваши комментарии будут учтены :)
За оформление кода извиняюсь — в первый раз, а как оформлять — нигде не написано… | https://habr.com/ru/post/132743/ | null | ru | null |
# Открытый инструмент для аналитики бизнес-процессов и Process Mining’а
В предыдущих хабрапостах мы поделились open source инструментом [для сравнительного анализа метагеномных данных](https://habr.com/ru/company/spbifmo/blog/568338/) и рассказали об [открытых проектах](https://habr.com/ru/company/spbifmo/blog/572186/), которыми занимается наша лаборатория мультиагентных систем.
На этот раз представляем вашему вниманию [Process Flow Optimization Tool](https://github.com/Siella/ProFIT) от Национального центра когнитивных разработок Университета ИТМО.
Фото: Clayton Robbins. Источник: Unsplash.comЗачем он нужен
--------------
Инструмент позволяет извлечь из лог-данных оптимальную модель процесса — визуализировать его в понятном виде [с отображением главных сценариев исполнения] и — с помощью нахождения мета-состояний — интерпретировать и упростить модель процесса. Целевой аудиторией фреймворка являются не только организации, заинтересованные в аналитике бизнес-процессов *as is* и улучшении существующих решений в этой нише, но и ученые, работающие в области [Process Mining](https://ru.wikipedia.org/wiki/%2525D0%25259F%2525D1%252580%2525D0%2525BE%2525D1%252586%2525D0%2525B5%2525D1%252581%2525D1%252581%2525D0%2525BD%2525D0%2525B0%2525D1%25258F_%2525D0%2525B0%2525D0%2525BD%2525D0%2525B0%2525D0%2525BB%2525D0%2525B8%2525D1%252582%2525D0%2525B8%2525D0%2525BA%2525D0%2525B0) и в целом занимающиеся исследованиями в сфере data science.
Интеллектуальный анализ в целом — перспективный подход к работе с внутриорганизационными рабочими процессами, в частности там, где они нетривиальны, слабо структурированы и вариативны в силу особенностей рода деятельности. Например, присутствия человеческого фактора и отсутствия автоматизации. Допустим как зачастую и обстоят дела в здравоохранении, поэтому здесь есть место для интеллектуального анализа процессов.
Так, Process Flow Optimization Tool уже применили в проектах группы «Цифровое здравоохранение», использовали для формирования признакового пространства для кластеризации пациентов с артериальной гипертензией (АГ) и предсказания их состояния, предложив новые признаки для предсказательной модели, а результаты [опубликовали](https://link.springer.com/chapter/10.1007/978-3-030-77967-2_48) в журнале Computational Science — ICCS 2021. Однако Process Flow Optimization Tool или ProFIT, как его называют разработчики, показал свою валидность не только в сфере здравоохранения, поэтому может быть распространен на все области, где в том или ином виде присутствуют бизнес-процессы.
Как устроен этот инструмент
---------------------------
Модели процесса в ProFIT представляют собой графы прямых зависимостей (directly-follows graphs), где вершины — события (events) или действия (activities), связанные ориентированными дугами. Зелёная вершина обозначает начало процесса и показывает общее число случаев (cases) реализации процесса. Например, один случай — кейс конкретного пациента или работа врача, если посмотреть с другой перспективы. Терминальное состояние процесса, куда идут рёбра от завершающих событий, представлено красной вершиной. Также внутренние вершины и рёбра показывают абсолютные частоты появления событий и переходов между ними в логе. Чем больше абсолютное значение, тем темнее или жирнее выделен элемент.
Изображение: проект ProFITProcess Flow Optimization Tool включает в себя идеи алгоритма Fuzzy Miner. Он подходит для неструктурированных процессов и позволяет строить модели на разных уровнях детализации. Граф прямых зависимостей — как выходные данные — допускает присутствие циклов. Они имеют ключевую роль в концепции мета-состояний, о чем мы расскажем далее. Другие особенности решения:
* **Построение процесса за счет обхода в глубину**. Суть в том, что майнеры нечётких моделей процесса (fuzzy net) обладают определенным недостатком. С их помощью можно получить «висячие» вершины, тупиковые переходы (deadlocks) и даже несвязанный граф. Поэтому мы добавили в алгоритм двойную проверку: (1) все вершины должны быть потомками начальной (зелёной); (2) все вершины должны быть предками терминальной (красной). Так из начала процесса мы дойдем к любому событию, и из любой внутренней вершины — попадем в конец процесса. Если модель не удовлетворяет этим условиям, добавляем в неё переходы, пока не получим исполнимый процесс.
* **Автоматизация настройки модели процесса**. Здесь мы предлагаем доверить алгоритму найти оптимальное решение задачи математической оптимизации, где точность и сложность модели представлены в виде комбинированной целевой функции. Если говорить простыми словами, программа позволяет найти те параметры модели (число вершин и рёбер), которые выводят понятную и точную визуализацию процесса, вместо их ручного подбора.
* **Поиск мета-состояний в процессе и агрегация элементов**. Эта идея появилась во время работы над проектом из области здравоохранения, где пациенты были вовлечены в процесс. Рутинный комплекс процедур, который они повторяли несколько раз во время лечения, представляет собой мета-состояние (здоровья, этапа лечения и так далее). Поэтому мы ищем наиболее часто встречающиеся циклы в модели процесса и агрегируем их в одно событие. Таким образом — [можем](https://link.springer.com/chapter/10.1007/978-3-030-77967-2_48) интерпретировать и упростить модель.
От теории к практике
--------------------
Мы проверили функциональность ProFIT на двух логах:
* [**Для дистанционного мониторинга пациентов с АГ**](https://github.com/Siella/ProFIT/blob/master/demo/log_examples/remote_monitoring_eng.csv) — на данных от компании [PMT Online](https://pmtonline.ru/). Они содержат события-триггеры на измерения давления пациентов, страдающими артериальной гипертензией. Здесь присутствуют несколько клинических и неклинических типов событий: красная зона (превышение критических уровней), жёлтая зона (превышение целевых уровней), уведомления об отсутствии измерения и так далее.
* [**Для процесса возмещения командировочных расходов**](https://github.com/Siella/ProFIT/blob/master/demo/log_examples/DomesticDeclarations.xes) — данных в рамках BPI Challenge 2020. Они [содержат](https://icpmconference.org/2020/bpi-challenge/) данные по информационному процессу в Технологическом университете Эйндховена за 2017-2018 года.
Сейчас мы работаем с информационной системой [центра Алмазова](http://www.almazovcentre.ru) в Санкт-Петербурге. Это — один из крупнейших кардиологических и научных мед. центров в России. Мы используем данные из системы контроля управления, плюс — медицинской информационной системы, чтобы собрать журнал событий по перемещениям и действиям медицинского персонала. Процесс состоит из тысяч разнообразных активностей — например, проведения лабораторных анализов, процедур, перемещений по отделениям и так далее. Такая информация требует подготовки, и пока мы не используем ее в кейсах и демо-примерах.
Общее демо с описанием на русском языке можно посмотреть [тут](https://github.com/Siella/ProFIT/blob/master/demo/profit_examples_rus.ipynb). Чтобы начать использовать ProFIT, достаточно объявить и присвоить переменной экземпляр класса ProcessMap, а затем передать путь к логу в формате CSV/TXT/XES (либо сами данные в виде pandas.DataFrame) через метод set\_log. Выглядит это следующим образом:
```
declarations = "../ProFIT/demo/log_examples/DomesticDeclarations.xes"
pm = ProcessMap()
pm.set_log(FILE_PATH = declarations)
pm.update() # after series of settings
```
Что дальше
----------
Разработчики [фреймворка](https://github.com/Siella/ProFIT) открыты для обратной связи. В перспективе они рассматривают и другие нотации моделирования, плюс — подготовку веб-интерфейса для этого инструмента. Они считают, что для его полноценной работы необходимо реализовать функционал во всех подклассах Process Mining: а это process discovery (извлечение модели из данных), conformance checking (проверка модели на соответствие логу) и enhancement (оптимизация и улучшение процесса).
Пока проект охватывает первый и частично второй блок. Для третьего — можно найти применение системам ИИ и МО по нахождению и предсказанию узких мест (bottle-necks), количества необходимых ресурсов и так далее. Помимо этого — посмотреть на задачи предсказания следующего события (Predictive process monitoring) и улучшения лог-данных, полученных из не process-aware информационных систем (например, мед. карт пациентов), посредством NLP, онтологий.
---
**Что еще есть у нас в блоге на Хабре:**
* [Интервью с руководителем международной научной лаборатории «Фотопроцессы в мезоскопических системах» Университета ИТМО](https://habr.com/ru/company/spbifmo/blog/576368/)
* [Интервью с руководителем направления Digital Humanities — обсуждаем исследования на стыке компьютерных и гуманитарных наук](https://habr.com/ru/company/spbifmo/blog/570336/)
--- | https://habr.com/ru/post/577470/ | null | ru | null |
# Увеличиваем потенциал брошенного производителем сетевого хранилища
В процессе эксплуатации того или иного умного устройства пользователи зачастую сталкиваются с рядом проблем, которые решить может только производитель. Решение, казалось бы, рядом: сообщаем по официальным каналам о найденном баге, производитель исправляет, выкладывает новую прошивку, дает инструкции по обновлению, обновляемся и все счастливы.
На практике же все не так сказочно и зачастую достучаться до производителя бывает сложно или совсем невозможно. А может банально закончиться срок поддержки данной модели устройства, тогда заниматься исправлением точно никто не будет.
Эта история о том, что можно сделать самостоятельно, имея начальные навыки, желание и время разобраться в процессе обновления програмного обеспечения ПО встраиваемых устройств.
Для нетерпеливых: в конце получился полноценный аппарат с актуальной версией загрузчика [U-Boot](https://ru.wikipedia.org/wiki/Das_U-Boot),  [Debian Jessie](https://wiki.debian.org/ru/DebianJessie) и  [OpenMediaVault](http://www.openmediavault.org/) на борту.
**Содержание:**
1. [Устройство](#ustroystvo)
* [Глюки](#glyuki)
* [Выбор альтернативной ОС](#vybor-alternativnoy-os)
2. [Подготовка устройства](#podgotovka-ustroystva)
* [Дополнительное железо](#dopolnitelnoe-zhelezo)
* [Подключение преобразователя](#podklyuchenie-preobrazovatelya)
* [Пробный запуск](#probnyy-zapusk)
3. [Сборка и обновление](#sborka-i-obnovlenie)
* [Загрузчик](#zagruzchik)
* [Корневая система (этап первый)](#kornevaya-sistema-etap-pervyy)
* [Ядро](#yadro)
* [Initramfs](#initramfs)
4. [Установка и настройка](#ustanovka-i-nastroyka)
* [Переменные окружения загрузчика](#peremennye-okruzheniya-zagruzchika)
* [Корневая система (этап второй)](#kornevaya-sistema-etap-vtoroy)
* [Настройка сети](#nastroyka-seti)
* [Настройка вентилятора и кнопок](#nastroyka-ventilyatora-i-knopok)
* [Установка OMV](#ustanovka-omv)
5. [Заключение](#zaklyuchenie)
**Устройство**
--------------
Встречайте подопытного — [D-Link DNS-325](http://www.dlink.ru/ru/products/120/1400.html).
На устройстве установлен ARM процессор Marvell Kirkwood 88F6281 (EABI) архитектуры armel, NAND память на 128MB, RAM на 256MB. Оснащен двумя отсеками для HDD, сетевым и USB разъемом на задней панели.
Вещь не очень мощная, но даже в рамках домашнего использования накопились претензии, с которыми дальнейшее использование со штатной прошивкой стало неприятным.
#### **Глюки**
В порядке убывания важности:
1. Глюки UPnP AV медиа сервера. На хранилище настроен медиа сервер, который индексирует аудио и видео материалы и раздает их по [DLNA](https://ru.wikipedia.org/wiki/DLNA) протоколу. Проблема в том, что некоторые файлы, добавляемые на жесткий диск, не индексируются автоматически и не отображаются при заходе с телевизора/другого DLNA совместимого устройства. Помогает ручное переключение режима медиа сервера, тогда база создается с нуля, но это занимает пару часов. Не самое лучшее решение, когда хочется скачать и посмотреть фильм.
2. Внезапное пробуждение из состояния "сна" посреди ночи (шуршание диском, шум вентилятора) создает дискомфорт. И ни строчки в логе о том, какая же сервисная задача запустилась. Только событие запуска вентилятора:
`Apr 20 03:55:09 Set Fan Speed To "LOW".`
3. Веб-интерфейс. Наблюдаются зависания, отвалы сессии, и т. п.
4. Дополнения. Есть как [официальные](http://www.dlink.ru/u/faq/98/1253.html), так и [неофициальные](http://dlink.vtverdohleb.org.ua/Add-On/). Проблема в том, что никто не занимается поддержанием актуальности ПО. В таком виде исправления ошибок и уязвимостей ждать также не стоит.
5. Система логирования просто ужасна. Мало того, что она малоинформативна, так еще и с какими-то мифическими артефактами.
6. Linux. Как в основе многих ~~современных кофеварок~~ встраиваемых устройств, в основе лежит Linux. А это значит, что рядом стоят вопросы стабильности, уязвимостей и т. д. В стоковой прошивке крутится ядро Linux 2.6, а на дворе уже Linux 4.11.
7. Странный баг с USB принтером. Хранилище оснащено USB портом для подключения флешек, USB дисков, принтеров и сканеров. И мой USB принтер отлично расшаривался по сети, пока внутри был установлен 1 HDD на 2 TB. Как только я вставил в правый кейс HDD на 3 TB, принтер переставал работать. После ряда тестов с различными комбинациями различных дисков я выяснил, что работает он только с одним, установленном в левом кейсе.
#### **Выбор альтернативной ОС**
#### [Alt-F](https://sourceforge.net/projects/alt-f/)
Первым, что нашлось из адаптированных альтернатив, стала открытая прошивка Alt-F. Функционал не уступает фирменной прошивке, минималистичный веб-интерфейс, обновления выходят стабильно. Даже есть поддержка плагинов fun\_plug.
#### image [FreeNAS](http://www.freenas.org/) и image [NAS4Free](https://www.nas4free.org/)
Проекты интересные, но громоздкие. Основаны на FreeBSD. Слишком высокие системные требования.
Вот, например, [системные требования для FreeNAS 10 "Corral"](https://forums.freenas.org/index.php?threads/hardware-requirements.38929/):
* процессор с поддержкой 64-bit
* система с поддержкой загрузки через legacy BIOS или EFI
* 8 GB RAM
* 8 GB USB флешка или другой накопитель
* хотя бы один диск для хранения данных
* порт Ethernet для сетевого обмена
Кстати, недавно релиз FreeNAS 10 "Corral" [отозвали](https://www.opennet.ru/opennews/art.shtml?num=46377), в т.ч. и по причине повышения системных требований.
#### image [OpenMediaVault](http://www.openmediavault.org/)
OMV — система для NAS с открытым исходным кодом. Является [ответвлением от FreeNAS](http://www.opennet.ru/opennews/art.shtml?num=40587), но адаптированного под Debian Linux, в следствие чего мультиплатформенна. В сочетании с относительно невысокими системными требованиями делает себя единственным подходящим кандидатом. Функционал более чем достаточный, расширяемый своими плагинами, но самое главное, что полноценный Debian дает доступ к [репозиториям](https://wiki.debian.org/ru/DebianRepository), а значит можно поставить все что угодно установкой пары пакетов.
Для данной модели есть несложный способ [запустить Debian с помощью хака с fun\_plug](http://www.nasdestruction.com/tutorial-installing-debian-squeeze-sabnzbd-sickbeard-couchpotato-headphones-d-link-dns-320-dns-325/), но это всего лишь real-time расширение, к тому же не удастся запустить Debian версии старше Wheezy.
К сожалению, у OMV нет готовой сборки Debian со своим пакетом для архитектуры armel. Более того, разработчики пока признают стабильными только i386 и amd64 сборки. Поддержка ARM экспериментальная:
> Support for OpenMediaVault on Arm is experimental. In most situations you will need to determine how to install Debian Wheezy on you device.
**Подготовка устройства**
-------------------------
Встроенная NAND память не подходит для нашей задумки — слишком маленькая. Хранить систему на вставляемых в хранилище дисках желания нет совсем. Получится смешивание мозгов устройства с периферийными составляющими. А если я захочу диск поменять или он сломается?
Остался единственный адекватный вариант — установить USB-флеш-накопитель, на котором и будет установлена вся система. При таком подходе проще делать резервные копии системы, а флешку в случае поломки легко заменить.
Для USB устройств было решено взять отдельный [USB Network Hub](https://www.amazon.com/s/field-keywords=USB+Network+Hub), все равно одного слота не хватает :)
#### **Дополнительное железо**
Для доступа к мозгам извне на плате есть последовательный UART порт. Вместо того, чтобы перепрошивать ROM специальными программаторами, можно подключиться к контактам на плате и через специальный преобразователь общаться с устройством через эмулятор терминала.
Тема UART во встраиваемых устройствах довольно обширна, кому интересно, можете прочесть хорошую обзорную статью: <https://geektimes.ru/post/253786/>
Были выбраны и куплены следующие комплектующие:
* Преобразователь USB — UART на PL2303HX
* Провода "мама-мама" 20см, 20 шт.
* Вилка штыревая PLS-40 (DS1021-1x40), прямая черная
* SanDisk Ultra Fit USB 3.0 16GB
#### **Подключение преобразователя**
**Вскрываем устройство, достаем плату**
**Ищем UART порт (4 пина слева)**
Распиновка такая (в обратном порядке): { RXD, (пусто), 3.3v, GND, TXD }
**Припаиваем вилку, вставляем провода**
**Собираем корпус, оставляем снятой только крышку**
Теперь для доступа к встроенному микрокомпьютеру не надо будет доставать плату — провода уже выведены, останется снять переднюю крышку сетевого хранилища.
Так как это последовательный порт, то и соединяем последовательно.
**RX на TX, TX на RX**
На этом вся механическая работа с оборудованием закончена.
#### **Пробный запуск**
Для общения по протоколу UART нам понадобятся:
kwboot — утилита для запуска загрузчика на устройстве "на лету"
minicom — эмулятор терминала для UART протокола
Запускаем minicom на хост системе:
```
＃ minicom -D /dev/ttyAMA0 -b 115200 -8
```
Подключаем блок питания, включаем устройство, наслаждаемся выводом лога загрузки в консоль:
**Лог загрузки**
```
** MARVELL BOARD: DB-88F6281A-BP LE
U-Boot 1.1.4 (Jan 21 2011 - 09:42:39) Marvell version: 3.4.14.DNS-325.02
U-Boot code: 00600000 -> 0067FFF0 BSS: -> 006CEE80
Soc: MV88F6281 Rev 3 (DDR2)
CPU running @ 1200Mhz L2 running @ 400Mhz
SysClock = 400Mhz , TClock = 200Mhz
DRAM CAS Latency = 5 tRP = 5 tRAS = 18 tRCD=6
DRAM CS[0] base 0x00000000 size 256MB
DRAM Total size 256MB 16bit width
Flash: 0 kB
Addresses 8M - 0M are saved for the U-Boot usage.
Mem malloc Initialization (8M - 7M): Done
NAND:128 MB
***
NAND read: device 0 offset 0x100000, size 0x300000
load addr .... =a00000
3145728 bytes read: OK
NAND read: device 0 offset 0x600000, size 0x300000
load addr .... =f00000
3145728 bytes read: OK
## Booting image at 00a00000 ...
Image Name: Linux-2.6.31.8
Created: 2012-06-26 3:38:43 UTC
Image Type: ARM Linux Kernel Image (uncompressed)
Data Size: 2565784 Bytes = 2.4 MB
Load Address: 00008000
Entry Point: 00008000
Verifying Checksum ... OK
OK
## Loading Ramdisk Image at 00f00000 ...
Image Name: Ramdisk
Created: 2014-01-21 4:33:41 UTC
Image Type: ARM Linux RAMDisk Image (gzip compressed)
Data Size: 1581012 Bytes = 1.5 MB
Load Address: 00e00000
Entry Point: 00e00000
Verifying Checksum ... OK
Starting kernel ...
Uncompressing Linux.............................................................
**Linux version 2.6.31.8** (jack@swtest6) (gcc version 4.2.1) #8 Tue Jun 26 11:38:42
CPU: Feroceon 88FR131 [56251311] revision 1 (ARMv5TE), cr=00053977
CPU: VIVT data cache, VIVT instruction cache
Machine: Feroceon-KW
Using UBoot passing parameters structure
Memory policy: ECC disabled, Data cache writeback
Built 1 zonelists in Zone order, mobility grouping off. Total pages: 65024
Kernel command line: root=/dev/ram console=ttyS0,115200 :::DB88FXX81:egiga0:none
PID hash table entries: 1024 (order: 10, 4096 bytes)
Dentry cache hash table entries: 32768 (order: 5, 131072 bytes)
Inode-cache hash table entries: 16384 (order: 4, 65536 bytes)
Memory: 256MB = 256MB total
Memory: 246528KB available (4828K code, 323K data, 136K init, 0K highmem)
***
NAND device: Manufacturer ID: 0xec, Chip ID: 0xf1 (Samsung NAND 128MiB 3,3V 8-b)
Scanning device for bad blocks
Using static partition definition
Creating 6 MTD partitions on "nand_mtd":
0x000000000000-0x000000100000 : "u-boot"
0x000000100000-0x000000600000 : "uImage"
0x000000600000-0x000000b00000 : "ramdisk"
0x000000b00000-0x000007100000 : "image"
0x000007100000-0x000007b00000 : "mini firmware"
0x000007b00000-0x000008000000 : "config"
```
Если интересно, вот полный вывод:
<https://pastebin.com/6SRA6Qgq>
**Сборка и обновление**
-----------------------
Все действия по сборке будут проводиться на основной (хост) системе под управлением Debian Stretch (amd64).
Собирать и обновлять будем:
1. Загрузчик — [U-Boot](https://ru.wikipedia.org/wiki/Das_U-Boot)
2. Ядро — Linux Kernel 4.10
3. Корневую файловую систему [Debian Jessie](https://www.debian.org/releases/jessie/index.ru.html)
4. Образ начальной инициализации системы — Initramfs
Основные инструменты для сборки:
1. [Кросс-компилятор](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%BE%D1%81%D1%81-%D0%BA%D0%BE%D0%BC%D0%BF%D0%B8%D0%BB%D1%8F%D1%82%D0%BE%D1%80) для armel архитектуры. В Debian это пакет [gcc-arm-linux-gnueabi](https://packages.debian.org/stretch/gcc-arm-linux-gnueabi)
2. Вспомогательные утилиты:
* git — для скачивания нужных версий с репозиториев проектов
* make — для выполнения сборочных скриптов
* debootstrap — для скачивания корневой файловой системы
* mkimage — утилита для переформатирования файлов в формат, понятный загрузчику
* BusyBox — набор утилит для начальной инициализации системы
* сопутствующие зависимости и библиотеки.
#### **Загрузчик**
В данном устройстве установлен немного урезанный загрузчик U-Boot 2011 года. Обновлять будем до актуальной стабильной версии.
Скачиваем:
```
$ git clone --branch v2017.05 git://git.denx.de/u-boot.git
```
Настраиваем:
```
$ cd u-boot
$ nano u-boot/include/configs/dns325.h
```
Добавляем строки:
`#define CONFIG_CMD_BOOTZ` — для поддержки загрузки zImage ядра.
`#define CONFIG_CMD_EXT4` — для поддержки ФС [ext4](https://ru.wikipedia.org/wiki/Ext4) и связанных команд консоли загрузчика.
```
$ make dns325_defconfig
＃
＃ configuration written to .config
＃
$ make u-boot.kwb CROSS_COMPILE=arm-linux-gnueabi-
```
На этом этапе нужно знать, сколько весит этот файл:
```
$ printf "0x%x\n" `stat -c "%s" u-boot.kwb`
0x7315c
```
Выводим размер образа в шестнадцатеричной системе счисления (HEX), в таком виде он пригодится при записи в NAND память.
Записать полученный образ U-Boot в NAND память можно из работающего в памяти загрузчика. Я решил не делать это из текущего стокового загрузчика, так как хотелось сначала убедиться, что новый образ вообще загрузится на железе, да и поддержка ext4 была включена ранее в новом образе загрузчика, так что можно сделать финт ушами: скопировать этот образ на флешку и загрузить с этого же образа при помощи kwboot.
Есть несколько вариантов, как передать файл в память миникомпьютера: через [Kermit](https://ru.wikipedia.org/wiki/Kermit_(%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB)), через [TFTP](https://ru.wikipedia.org/wiki/TFTP), а также через физически подключенные накопители (наш выбор).
kwboot позволяет запустить плату с передаваемым ей загрузчиком, не записывая ничего физически (только в RAM) и вообще игнорируя NAND память. Этот механизм позволяет аварийно загружать устройство даже когда оно окирпичилось в следствие порчи NAND памяти или неудачной прошивки.
Выключаем устройство, запускаем kwboot, нажимаем на кнопку включения. Должен пойти процесс заливки образа с последующей загрузкой, которую надо будет прервать.
**Заливка и загрузка**
```
＃ tools/kwboot -p -b u-boot.kwb -B115200 -t /dev/ttyUSB0
Sending boot message. Please reboot the target.../
Sending boot image...
0 % [......................................................................]
1 % [......................................................................]
3 % [......................................................................]
***
96 % [......................................................................]
98 % [...........................................]
[Type Ctrl-\ + c to quit]
U-Boot 2017.05-dirty (May 10 2017 - 02:56:44 +0300)
D-Link DNS-325
SoC: Kirkwood 88F6281_A1
DRAM: 256 MiB
WARNING: Caches not enabled
NAND: 128 MiB
In: serial
Out: serial
Err: serial
Net: egiga0
IDE: ide_preinit failed
Hit any key to stop autoboot: 0
=>
```
Загрузились. Далее надо записать наш **u-boot.kwb** образ в область NAND. Но чтобы записать его в NAND память, надо сначала считать его и записать в RAM память.
Делаем ext4 флешку и даем разделу имя "rootfs" (чтобы монтировать корневую ФС по имени раздела):
```
＃ mkfs.ext4 /dev/sdb1
＃ e2label /dev/sdb1 rootfs
```
Копируем файл на флешку, вставляем флешку в NAS и инициализируем ее:
```
=> usb start
starting USB...
USB0: USB EHCI 1.00
scanning bus 0 for devices... 2 USB Device(s) found
scanning usb for storage devices... 1 Storage Device(s) found
```
Записываем образ в память. Адрес (смещение) не имеет значения, главное не выходить за пределы RAM). В данном случае будет 0x1000000.
```
=> ext4load usb 0:1 0x1000000 /u-boot.kwb
471388 bytes read in 77 ms (5.8 MiB/s)
```
Очищаем область NAND, в которой хранится загрузчик:
```
=> nand erase 0x000000 0x7315c
NAND erase: device 0 offset 0x0, size 0x7315c
Erasing at 0x60000 -- 100% complete.
OK
```
(с начала NAND памяти до смещения, равного размеру файла, который мы высчитали ранее)
Записываем загрузчик из области RAM памяти в область NAND памяти:
```
=> nand write 0x1000000 0x000000 0x7315c
NAND write: device 0 offset 0x0, size 0x7315c
471388 bytes written: OK
```
0x1000000 — откуда читаем в RAM
0x000000 — куда записываем в NAND
0x73044 — размер
Все, можно перезагружаться и наслаждаться запуском нового загрузчика:
```
U-Boot 2017.05-dirty (May 10 2017 - 02:56:44 +0300)
D-Link DNS-325
SoC: Kirkwood 88F6281_A1
DRAM: 256 MiB
WARNING: Caches not enabled
NAND: 128 MiB
In: serial
Out: serial
Err: serial
Net: egiga0
IDE: ide_preinit failed
Hit any key to stop autoboot: 0
=>
```
Если на данном этапе устройство окирпичилось и отказалось загружаться, например, как сначала получилось у меня (видимо, опечатался, когда вводил размер образа загрузчика при записи из RAM памяти в NAND), не спешите паниковать. Вы также можете загрузить устройство при помощи kwboot и повторить запись.
#### **Корневая система (этап первый)**
Воспользуемся инструментом debootstrap. Обычно формирование rootfs для систем с другой архитектурой делается в 2 этапа: скачивание в каталог с флагом --foregin, а потом настройка qemu и запуск в нем "debootstrap --second-stage". Мне не хотелось возиться с qemu, и я решил делать второй этап сразу на работающем NAS-е.
Скачиваем содержимое на флешку (примонтирована в /mnt/usb/):
```
＃ debootstrap --variant=minbase --foreign --arch=armel --include=dbus,nano jessie /mnt/usb/ http://ftp.ru.debian.org/debian/
```
Переименуем на время init файл, чтобы наполовину установленая система не запустилась:
```
＃ mv /mnt/usb/sbin/init /mnt/usb/sbin/init.bak
```
Первый этап готов.
#### **Ядро**
Пожалуй, самый сложный этап из всех. Очень важно настроить ядро, чтобы все желаемые функции и программы работали правильно. Иначе легко получить какую-нибудь мерзопакастную ошибку со странными симптомами.
Сначала мне посчастливилось найти уже [готовое ядро для Kirkwood](http://forum.doozan.com/read.php?2,12096), но оно всячески отказывалось монтировать флеш накопитель в любом из режимов (OHCI, EHCI), так что все равно пришлось собирать ядро самостоятельно.
Скачивание:
```
$ git clone --branch v4.10 git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc.git
```
Загружаем предустановленный конфиг для нашей платы (ARMv5). В моем случае это mvebu\_v5\_defconfig.
```
$ make ARCH=arm mvebu_v5_defconfig
＃
＃ configuration written to .config
＃
$ make ARCH=arm menuconfig
```
Настраиваем. Настраивать и проверять нужно все, в идеале изучить каждый параметр и решить, нужен он или нет. Мной был выставлен hostname, включена поддержка initramfs/initrd, отключена поддержка звука и USB 3.0, отключены драйвера для ext2 и ext3 (драйвер ext4 умеет монтировать все ранние версии), включены дисковые квоты, включена поддержка плат Kirkwood, Marvell Orion. Также включены [обязательные параметры для поддержки systemd](https://galileo.mailstation.de/?p=31). Скорее всего, есть есть что-то, чего я не упомянул, ибо настроек много. Вот мой конфиг ядра: <https://pastebin.com/MZrRXnXX>
Многие вещи могут вылезти в процессе установки, настройки и эксплуатации системы и OMV. В таком случае можно просто добавить нужные строчки, пересобрать ядро и заменить образ на флешке.
Сборка:
```
$ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -j5 zImage kirkwood-dns325.dtb
```
Получили само ядро zImage и файл kirkwood-dns325.dtb. Последний файл — [Device Tree](https://en.wikipedia.org/wiki/Device_tree) — нужен для правильной работы ядра конкретно с нашей платой.
Копируем эти файлы в каталог /boot на флешке:
```
＃ cp arch/arm/boot/zImage arch/arm/boot/dts/kirkwood-dns325.dtb /mnt/usb/boot/
```
#### **Initramfs**
Далее делаем легковесный образ, который будет загружаться в память и инициализировать нашу систему. Его делать вовсе необязательно, загрузчик умеет напрямую стартовать ядро с указанием корневого каталога (`root=`). Однако полезно, т. к. в случае отсутствия доступа к корневой ФС будет доступна консоль с минимальным набором команд.
Костяк образа составит джентльменский набор BusyBox.
Скачивание:
```
$ git clone --branch 1_26_2 git://git.busybox.net/busybox/
```
Настройка:
```
$ make defconfig
$ make menuconfig
```
Единственное, что лучше выставить в настройках дополнительно — это статическая линковка библиотеки glibc, чтобы не пришлось запихивать его отдельно в образ.
**Статическая линковка glibc**
Сборка:
```
$ make ARCH=arm
```
Далее создаем структуру образа, помещаем в него busybox:
```
$ mkdir -p initramfs/{bin,sbin,etc,proc,sys,newroot,usr/{bin,sbin}}
$ cp busybox/bin/bisybox initramfs/bin
$ ln -s initramfs/bin/busybox initramfs/bin/sh
```
Далее необходимо написать init скрипт. Именно тут будет происходить вся магия по инициализации устройств и передаче управлению Debian-у.
**init скрипт**
```
#!/bin/sh
/bin/busybox --install -s
#Mount things needed by this script
mount -t proc proc /proc
mount -t sysfs sysfs /sys
#Disable kernel messages from popping onto the screen
echo 0 > /proc/sys/kernel/printk
#Clear the screen
clear
#Create device nodes
mknod /dev/null c 1 3
mknod /dev/tty c 5 0
#Pause bebore USB Storage init
sleep 3
#Mount devices
mdev -s
#Defaults
init="/sbin/init"
#Mount the root device
mount LABEL=rootfs /newroot
#Check if $init exists and is executable
if [ -h "/newroot/${init}" ] ; then
#Unmount all other mounts so that the ram used by
#the initramfs can be cleared after switch_root
umount /sys /proc
#Switch to the new root and execute init
exec switch_root /newroot "${init}"
fi
#This will only be run if the exec above failed
echo "Failed to switch_root, dropping to a shell"
exec setsid sh
exec <"${console}" >"${console}" 2>&1
exec sh
```
Пакуем и преобразуем в понятный для U-Boot-а формат:
```
$ cd initramfs/
$ find . | cpio -H newc -o > ../initramfs.cpio
$ cd ..
$ cat initramfs.cpio | gzip > initramfs.igz
$ mkimage -n 'uInitramfs' -A arm -O linux -T ramdisk -C gzip -d initramfs.igz initramfs.uImage
```
Копируем initramfs:
```
＃ cp initramfs.uImage /mnt/usb/boot/
```
Со сборкой закончили.
**Установка и настройка**
-------------------------
#### **Переменные окружения загрузчика**
В процессе обновления загрузчика затерлись конфиги, надо настроить загрузку нового ядра, Initramfs, Device Tree, также восстановить настройки сети.
Загружаемся с minicom, выполняем на устройстве в консоли U-Boot:
```
=> setenv console ttyS0,115200
=> setenv bootargs console=${console}
=> setenv bootcmd usb start; run load_kernel; run load_init; run load_dtree; run boot_system
=> setenv load_kernel ext4load usb 0:1 0x1000000 boot/zImage
=> setenv load_init ext4load usb 0:1 0x1800000 boot/initramfs.uImage
=> setenv load_dtree ext4load usb 0:1 0x2000000 boot/kirkwood-dns325.dtb
=> setenv boot_system bootz 0x1000000 0x1800000 0x2000000
=> setenv ethaddr xx:xx:xx:xx:xx:xx
=> setenv ipaddr 192.168.0.32
=> saveenv
```
Тут все предельно просто: выставляем параметры консоли, загрузки ядра, прописываем куда будут копироваться (ext4load) в память файлы и откуда считываться (bootz). Прописываем ip и mac адреса (mac адрес можно посмотреть на наклейке устройства).
Вставляем флеш накопитель в NAS, перезагружаемся.
#### **Корневая система (этап второй)**
Загрузившись, попадаем в BusyBox. Можем завершить формирование rootfs:
```
＃ chroot /newroot
＃ mv /sbin/init.bak /sbin/init
＃ /debootstrap/debootstrap --second-stage
＃ passwd
```
Перезагружаем устройство, логинимся под root-ом. С этого момента мы загружаемся полностью и работаем в Debian-е.
#### **Настройка сети**
Далее следует настроить и включить сеть.
```
＃ touch /etc/systemd/network/wired.network
＃ nano /etc/systemd/network/wired.network
```
Пишем простой конфиг для статического ip на проводном интерфейсе eth0
[Match]
Name=eth0
[Network]
Address=192.168.0.32/24
Gateway=192.168.0.1
Включаем и запускаем сетевые службы
```
＃ systemctl enable systemd-networkd
＃ systemctl enable systemd-resolved
＃ systemctl start systemd-networkd
＃ systemctl start systemd-resolved
```
Сеть есть.
#### **Настройка вентилятора и кнопок**
Прежде чем делать высоконагруженные операции, необходимо настроить вентилятор на охлаждение. Обычно настройка происходит просто: при помощи команды pwmconfig находится датчик температуры ЦП, находится вентилятор, они связывается и выставляются граничные параметры активации режимов охлаждения.
В случае с домашним NAS так делать не стоит, ибо основную долю тепла выделяют жесткие диски, а не процессор.
Проблема вот в чем: fancontrol, служба которая занимается контролем вентилятора, позволяет следить только за датчиками, находящимися непосредственно на плате. На данном устройстве установлен один вентилятор и один датчик температуры.
Выход есть: можно обмануть fancontrol, заставив его считывать информацию из нужного нам места. Для считывания данных с HDD используем пакет smartmontools.
Устанавливаем:
```
＃ apt install fancontrol lm-sensors smartmontools
```
Настраиваем по умолчанию:
```
＃ pwmconfig
```
Тонкости настройки можно почитать, например, [здесь](http://dmzik.blogspot.ru/2013/05/fancontrol.html).
Далее открываем конфиг /etc/fancontrol, смотрим содержимое. Интересна переменная "FCTEMPS" — она ставит в соответствие устройству место, откуда следует брать температуру:
`FCTEMPS=hwmon0/pwm1=hwmon1/temp1_input`
Путь относительный, сам файл генерируется в /sys/class/hwmon/hwmon1/temp1\_input. Посмотрим в каком формате хранится информация:
```
＃ cat /sys/class/hwmon/hwmon1/temp1_input
41500
```
Значение в цельсиях, умноженное на 1000 (для точности). Значит нужен файл, в котором периодически будет обновляться значение температуры жестких дисков. Значение допускается одно, а жеских дисков у нас может быть 2. Значит, будем считать максимальное, записывать в файл.
Напишем небольшой скрипт:
```
#!/bin/bash
while sleep 60
do
TEMP1=`smartctl -A /dev/disk/by-id/ata-Hitachi_HDS723030ALA640_MK0311YHG1ZGJA | grep Temperature_Celsius | awk '{print $10 "000"}'`
TEMP2=`smartctl -A /dev/disk/by-id/ata-WDC_WD2003FYYS-02W0B1_WD-WMAY05168428 | grep Temperature_Celsius | awk '{print $10 "000"}'`
echo $(( $TEMP1 > $TEMP2 ? $TEMP1 : $TEMP2 )) > /etc/temp_hdd
done
```
Каждую минуту считывается S.M.A.R.T. информация с датчиков HDD, из всей информации выделяется только значение температуры, и в нужном формате наиболшее из 2-х записывается в файл /etc/temp\_hdd. Диски я указал по id, потому что буквы дисков /dev/sd[a-z] могут меняться в зависимости от порядка и кол-ва вставленных физических дисков.
Записываем скрипт в /etc/temp\_hdd.sh. Дальше нужно его каким-то образом запускать при старте. Для этого как раз подойдет файл /etc/rc.local
Прописываем прямо перед "exit 0" строчку
`/etc/temp_hdd.sh &`
Теперь процесс будет запускаться при старте системы и выполняться в фоне.
Когда есть файл с актуальной температурой, впишем это в конфиг /etc/fancontrol, настроив при этом граничные значения температуры. Получилось как-то так:
```
# Configuration file generated by pwmconfig, changes will be lost
INTERVAL=10
DEVPATH=hwmon0=devices/platform/gpio_fan hwmon1=devices/platform/ocp@f1000000/f1011000.i2c/i2c-0/0-0048
DEVNAME=hwmon0=gpio_fan hwmon1=lm75
FCTEMPS=hwmon0/pwm1=/etc/temp_hdd
FCFANS= hwmon0/pwm1=hwmon0/fan1_input
MINTEMP=hwmon0/pwm1=45
MAXTEMP=hwmon0/pwm1=55
MINSTART=hwmon0/pwm1=4
MINSTOP=hwmon0/pwm1=0
```
Реакцию на кнопки настроить гораздо проще. Устанавливаем пакет esekeyd и настраиваем:
```
＃ apt install esekeyd
＃ nano /etc/esekeyd.conf
```
Ставим команды на выключение и перезагрузку:
```
POWER:/sbin/shutdown -h now
RESTART:/sbin/reboot
```
Сохраняем, перезагружаем устройство. Теперь основные важные области системы установлены и настроены, остальные действия будут относиться к дополнительному ПО.
#### **Установка OMV**
Добавим репозиторий OMV и установим основной пакет:
```
＃ echo "deb http://packages.openmediavault.org/public erasmus main" > /etc/apt/sources.list.d/openmediavault.list
＃ apt update
＃ apt install openmediavault-keyring
＃ apt install openmediavault
```
Дальше apt предложит устрановить много пакетов (у меня 457), устанавливаем. В процессе установки будет задано несколько вопросов по настройке пакетов, можно везде оставлять дефолт.
В конце apt может сообщить об ошибке настройки collectd и nginx:
```
dpkg: dependency problems prevent configuration of openmediavault:
openmediavault depends on collectd (>= 5.1.0); however:
Package collectd is not configured yet.
openmediavault depends on nginx (>= 1.6.2); however:
Package nginx is not configured yet.
```
Для nginx надо убрать в файле /etc/nginx/sites-available/default строчку
`listen [::]:80 default_server;`
Такое происходит в случае невозможности использовать [IPv6](https://ru.wikipedia.org/wiki/IPv6) протокол.
Для collectd надо добавить строчку с hostname и ip в /etc/hosts. В нашем случае
`127.0.1.1 dns325`
Исправляем зависимости:
```
＃ apt install -f
```
Скрипт рапортует об успешной установке пакета. Запускаем скрипт инициализации:
```
＃ omv-initsystem
```
Все! Система установлена. Дальше заходим в веб панель по адресу 192.168.0.32, настраиваем все окружение по вкусу.
#### **Заключение**
Функционал полученной системы намного шире, чем в заводской прошивке, но пришлось пожертвовать единственным USB портом.
Конечно, это не единственный и не универсальный способ для всех устройств. Не на каждом устройстве можно вообще установить Linux. Здесь показывалась возможность большого апгрейда в рамках существующей концепции.
На момент написания статьи устанавливался OpenMediaVault 3.x ("Erasmus"), который еще не вышел из статуса бета-версии. Это означает, что возможны баги в работе, однако связаться с разработчиками OMV намного проще, чем пытаться достучаться по почте до производителя D-Link.
Что делать с системой после установки решает каждый для себя. Уже в таком виде она работоспособна, но важно не забыть проверить и настроить права доступа в системе, правильно настроить права при распределении доступа к каталогам по различным протоколам, проверить все параметры в настройках.
Из всех перечисленных глюков большинство перестало существовать сразу же: ядро свежей версии, устройство само не просыпается без надобности, в веб-панели есть целая вкладка с логами и фильтрами. Не удалось пока проверить стабильность DLNA плагина, но это вопрос времени. Также слегка подтормаживает веб-интерфейс, но не больше, чем было с заводской прошивкой, и это скорее вопрос точной настройки связки nginx + FastCGI.
Enjoy Embedding! | https://habr.com/ru/post/327076/ | null | ru | null |
# Как накрутить рейтинг на Хабре и уйти незамеченным
Как-то пятничным вечером я сидел за домашним компом с чашкой черного чая, писал статью и думал о жизни. Работа спорилась, но голова начинала к тому времени заметно притормаживать. И вот когда за окном стало уже совсем темно, я решил отправить статью отдыхать до завтрашнего дня, да и самому пойти спать. Но вместо того, чтобы сохранить все в черновик, как полагается, сонный мозг на автопилоте её зачем-то опубликовал...
Понял я это не сразу, а только спустя несколько минут, зайдя напоследок обновить свой профиль. Ощущение было, как будто не выключил газ на кухне и все вот-вот умрут. Я молился, чтобы ее можно вернуть в черновики или хотя бы удалить. Кстати, последнего, как оказалось, сделать уже нельзя, если материал попал в общее обозрение. Впоследствии говорил на этот счет с тех поддержкой, но мне порекомендовали просто смириться с провалом)
Не буду томить — статья в итоге успешно вернулась в гнездо — но какой-то добрый самаритянин уже успел поставить ей плюс. Но что самое интересное, несмотря на то, что статьи больше не было на сайте, рейтинг, полученный за нее, остался у меня в профиле.
Это не могло не натолкнуть на мысль воспроизвести ситуацию в промышленных масштабах.
У меня тогда как раз накопился один инвайт, которым я решил поделиться с другом и заодно проверить теорию. Разумеется, кликать по одной статье за раз — это скучно и, тем более, не подобает уважающему себя разработчику. К тому же, не слишком безопасно, потому что есть риск просто попасться.
Будем автоматизировать.
Подслушиваем Habrahabr
----------------------
Нам надо получить следующие методы: создание статьи, публикация, голосование и скрытие статьи в черновиках.
Процесс авторизации проходить не будем, поскольку он сложный, с кучей переадресаций, да и достаточно просто вытащить все cookie и прикинуться ~~ветошью~~ браузером.
В качестве веб прокси будем использовать [Charles](https://www.charlesproxy.com/) для Mac. Крайне удобная вещь. Если вы разработчик, то рекомендую иметь её в своем джентельменском наборе. Позволяет также слушать трафик с любого подручного девайса, если вы, например, отлаживаете мобильное приложение.
В рамках одной сессии успешно получаем все необходимые нам методы.
Как оказалось, за создание, публикацию и удаление статей отвечает один и тот же запрос, но с разными параметрами. Можно создать пост в качестве черновика или сразу его опубликовать. И именно здесь прописывается будет ли ваш пост в песочнице, переводом или ходовой публикацией. Может быть, это даст возможность обойти требования к публикации в песочнице, но не проверял. Скорее всего, сервер просто развернет домой с какой-нибудь забавной ошибкой.
Проверяем на практике
---------------------
Уже практически праздную победу, делаю запрос на создание поста:
```
params = {
:id => '',
:post_type => 'simple',
:flow => 5,
:hubs => [20742],
:title => 'test1',
:text => 'test1',
:tags_string => 'test1'
}
response = HTTParty.post('https://habrahabr.ru/json/topic/?action=save', headers: headers, body: params)
# Получаем id поста для последующего использования
params[:id] = JSON.parse(response.body)['redirect'].split('/')[2]
```
*Flow* равное 5 и *Hubs* равное 20742 — это не случайные числа, а вполне осознанно выбранный наименее популярный поток 'Разное' и хаб 'Читальный зал', чтобы снизить вероятность быть уличенным в афере.
Но тем не менее, Habr нам почему-то отвечает отказом:
```
{
"system_errors": [
"Неизвестный тип публикации"
]
}
```
Странно. Ведь все параметры верны, post\_type установлен и точно совпадает с нужным и все поля на месте. Проверяем запрос из прокси — работает. А из кода — ошибка.
Как оказалось после веселой отладки, если отсутствует заголовок *Referer*, то любой запрос к API падает. Юзабилити на высоте. И еще один забавный случай: независимо от того какое значение указано в поле draft, публикация все равно будет создаваться черновиком:
Даже если стоит 0 или вообще абракадабра.
Но если поля вообще нет, то статья уже публикуется в общий поток.
Хорошо, пост создали, можно голосовать. Тут все тоже довольно просто и завелось с первого раза:
```
vote_headers = {
'Cookie' => HTTP::Cookie.cookie_value(vote_jar.cookies(habr_uri)),
'User-Agent' => 'Mozilla/5.0',
'Referer' => 'https://habrahabr.ru/top/',
'Content-Type' => 'application/x-www-form-urlencoded',
'Accept' => 'application/json'
}
vote_body = {
# Помните прошлый запрос?
'ti' => params[:id],
'tt' => 2,
'v' => 1
}
uri = URI.parse('https://habrahabr.ru/json/vote/')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri.path, vote_headers)
request.body = URI.encode_www_form(vote_body)
# Только для отладки
puts http.request(request).body
```
Запрос через HTTParty отчаянно отказывался работать с голосованием, пришлось пилить его через net/http. Аргументы, конечно, не самые говорящие в API, но в целом все понятно: id публикации и два магических параметра. Элементарно.
Автоматизируем
--------------
Теперь все вместе. Достаем через прокси наши Cookies, сначала для одного аккаунта, с которого будем постить, а потом для второго, с которого будем голосовать.
Запускаем запросы последовательно друг за другом и все, вроде как, хорошо. И тут я понял, что для смены аккаунтов мне пришлось явно разлогиниться на сайте. Но при этом моя сессия все равно продолжала работать из кода. То есть, мои куки никто и не думал обнулять на бэкенде. Хабр, как-то нехорошо так поступать со своими пользователями. Не секьюрно.
Оставим все как есть, и запустим процедуру в цикле. Крутим без какого-либо delay, но на второй же итерации натыкаемся на забавную ошибку с пасхалкой:
```
{
"system_errors": [
"Повтор на втором игроке!"
]
}
```
Кто постарше помнит, что раньше была такая передача 'Пойми меня', где дети по цепочке объясняли друг другу слова. И если двое сделали это одинаково, то ведущий говорил: 'повтор на таком-то игроке!'. [Ссылка](https://www.youtube.com/watch?v=JRklNoCSL90) на запись игры. Мне кажется, это многое говорит о возрасте тех, кто разрабатывал Хабр.
Постепенно увеличиваем задержку, и методом перебора выясняем, что таймаут на создание постов стоит 30 секунд. Запускаем цикл и уходим пить ~~любимый кетчуп~~ чай.
Не будем наглеть, остановимся на 30 баллах, исчеркав все черновики Хабра:
122 место, неплохо. Осталось чуть-чуть до первой сотни. А вот и сами тестовые посты:
Как можно заметить, на сайте нет никакого упоминания о вашей деятельности, посты никто не видел, кроме вас самих, но рейтинг при этом присутствует.
Заключение
==========
Вот таким нехитрым способом можно незаметно накрутить своему товарищу рейтинг.
Возможно, Хабру стоит поставить ограничение на несколько публикаций в день, чтобы этой особенностью не злоупотребляли. И я бы еще все-таки сделал сброс сессии при логауте.
Спасибо за внимание.
**P.S.** Не баньте меня, пожалуйста. Баньте его — [sp1nfox](https://habrahabr.ru/users/sp1nfox/), это ему рейтинг накручивали.
**UPD:** Бана удалось избежать, а дырку залатали, введя лимит на количество постов в сутки. Спасибо команде Хабра и [Boomburum](https://habrahabr.ru/users/boomburum/) за оперативность!
**UPD2:** Лимит 3 поста в сутки. | https://habr.com/ru/post/332296/ | null | ru | null |
# Как сделать JSON Vulnerability Protection в ответе сервера под Yii2
В AngularJS [реализована](https://docs.angularjs.org/api/ng/service/$http#json-vulnerability-protection) поддержка JSON Vulnerability Protection, направленная на то, чтобы противодействовать ситуациям, когда злоумышленник может, при определённых условиях, превратить JSON в JSONP и выполнить какой-то код. В качестве меры противодействия на серверной стороне предлагается добавлять к JSON-данным такой префикс: `)]}',`
Под катом — моя короткая история генерации JSON-данных с префиксом. Но, я думаю, эта история так же хорошо иллюстрирует и более общий вопрос — как можно добавлять свои собственные форматы ответов сервера. В Yii Framework это делается довольно-таки просто — для этого достаточно описать в конфигурации, какой класс будет отвечать за генерацию ответа определённого формата.
Я начал с того, что добавил в конфигурацию (/путь\_к\_проекту/config/web.php — раздел components → response → formatters) новый тип ответа — «jsonvp», назначив для него класс, который я собираюсь создать.
```
php
// . . .
$config = [
// . . .
'components' = [
// . . .
'response' => [
'formatters' => [
'jsonvp' => 'app\components\JsonVpResponseFormatter',
],
],
],
// . . .
];
```
В классе `yii\web\Response` есть свойство `$formatters`, которое дополнится тем, что есть в конфигурации. И теперь, если в каком-то экшене задать `Yii::$app->response->format = 'jsonvp';`, то он будет использовать для форматирования ответа класс `app\components\JsonVpResponseFormatter`. Во фреймворке есть интерфейс `yii\web\ResponseFormatterInterface`, который регулирует правила написания таких классов, так что можно применить к моему новому классу этот интерфейс.
```
php
namespace app\components;
use yii\helpers\Json;
use yii\web\Response;
use yii\web\ResponseFormatterInterface;
class JsonVpResponseFormatter implements ResponseFormatterInterface
{
/**
* Format as Vulnerability Protected JSON.
* @param Response $response
*/
public function format($response)
{
$response-getHeaders()->set('Content-Type', 'application/json; charset=UTF-8');
if ($response->data !== null) {
$response->content = ")]}',\n" . Json::encode($response->data);
}
}
}
```
Осталось только проверить функционал:
```
php
namespace app\controllers;
use Yii;
use yii\web\Controller;
/**
* site/* actions.
* @package app\controllers
*/
class SiteController extends Controller
{
/**
* Test JSON output
* @return array
*/
public function actionJson()
{
Yii::$app-response->format = 'jsonvp';
return ['123', '456'];
}
}
```
При вызове `localhost/index.php?r=site/json` в браузере выводится такой результат:
```
)]}',
["123","456"]
```
#### Заключение
С помощью такого нехитрого способа можно создавать собственные форматы ответов. Например, как описано выше, — JSON с префиксом, позволяющим защититься от [уязвимости](http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx). ~~К сожалению, в [книге рецептов](https://github.com/samdark/yii2-cookbook/blob/master/book/response-formats.md) по фреймворку на текущий момент нет описания того, как создавать собственные форматы ответов, хотя раздел и помечен меткой «TBD».~~ **Upd:** Уже [есть](https://github.com/samdark/yii2-cookbook/blob/master/book/response-formats.md#custom-response-format).
Надеюсь, кому-нибудь эта статья будет полезной. Удачи! | https://habr.com/ru/post/256213/ | null | ru | null |
# Верстка интернет-магазина: список товаров
Требования к верстке каталогов интернет-магазинов имеют свойство повторяться из проекта в проект. Поэтому у меня выработался набор стандартных приемов, которыми я хочу поделиться в этой статье.
Некоторые приемы уже были рассмотрены в различных статьях. Однако у меня возникло желание объединить их и проиллюстрировать отдельными демо. Надеюсь, в таком виде наработки окажутся полезны верстальщикам, которым часто приходится работать над интернет-магазинами.
В качестве примера мы будем верстать список товаров для интернет-магазина комнатных растений. Демо готового каталога можно посмотреть по [ссылке](http://html.innova-media.ru/product_list/). В результате должен получиться список растений с фото, описаниями и всплывающими кнопками. Кроме того, вид списка можно будет переключать: товары будут выглядеть либо как плитка, либо как таблица.
Адаптивная сетка
----------------
Итак, начнем с создания адаптивных плиток — будущих карточек товаров. У нас будет 8 комнатных растений:
```
*
*
*
*
*
*
*
*
```
Оберткой для товаров послужат блоки, занимающие 100% ширины родителя на мобильных устройствах.
```
.product-wrapper {
display: block;
width: 100%;
float: left;
transition: width .2s;
}
```
Теперь используем медиа-запросы, чтобы разместить по две, три и четыре плитки в ряд при больших разрешениях монитора.
```
@media only screen and (min-width: 450px) {
.product-wrapper {
width: 50%;
}
}
@media only screen and (min-width: 768px) {
.product-wrapper {
width: 33.333%;
}
}
@media only screen and (min-width: 1000px) {
.product-wrapper {
width: 25%;
}
}
```
И зададим стили карточек товаров.
```
.product {
display: block;
border: 1px solid #b5e9a7;
border-radius: 3px;
position: relative;
background: #fff;
margin: 0 20px 20px 0;
text-decoration: none;
color: #474747;
z-index: 0;
height: 300px;
}
```
Из-за того, что карточки имеют `margin-right` равный `20px`, весь список имеет нежелательный отступ справа.
Исправим это с помощью отрицательного значения `margin-right` у родителя.
```
.products {
list-style: none;
margin: 0 -20px 0 0;
padding: 0;
}
```
Теперь все в порядке. Посмотреть на получившуюся сетку можно на страничке [демо](http://html.innova-media.ru/product_list/grid.html). Для наглядности блокам в демо задана фиксированная высота.
Фото товаров
------------
Следующим интересным моментом является верстка блоков с фотографиями растений. Разметка в данном случае будет такой:
```
```
Сделаем родителя тега `img` квадратом с помощью свойства `padding-bottom` со значением 100%. Вот все стили для данного блока.
```
.product-photo {
position: relative;
padding-bottom: 100%;
overflow: hidden;
}
```
В указанном блоке расположим картинку таким образом, чтобы при любых размерах она не выходила за пределы родителя, и отцентрируем ее горизонтально и вертикально.
```
.product-photo img {
position: absolute;
top: 0;
bottom: 0;
left: 0;
right: 0;
max-width: 100%;
max-height: 100%;
margin: auto;
transition: transform .4s ease-out;
}
```
Осталось немного увеличивать фото при наведении.
```
.product:hover .product-photo img {
transform: scale(1.05);
}
```
Как все это работает можно посмотреть на примере [демо](http://html.innova-media.ru/product_list/photos.html).
Описание товара
---------------
 | https://habr.com/ru/post/319280/ | null | ru | null |
# Vim-крокет
*Переводчик из меня совершенно никакой, но я просто не мог пройти мимо этой статьи, ибо она излучает волны крутости, а концентрация дзена в ней зашкаливает. Поэтому welcome.*
Введение
--------
Недавно я обнаружил интересную игру под названием [VimGolf](http://vimgolf.com/). Цель этой игры заключается в том, чтобы преобразовать кусок текста из одной формы в другую наименьшим возможным количеством нажатий клавиш. Пока я играл на этом сайте с разными пазлами, мне стало любопытно — а какие привычки редактирования текста есть у меня? Мне захотелось лучше понять способы манипулирования текстом в Vim и проверить, смогу ли я найти неэффективные моменты в моем рабочем процессе. Я провожу огромное количество времени в моем текстовом редакторе, поэтому устранение даже незначительных шероховатостей может привести к значительному увеличению производительности. В этом посте я расскажу о своем анализе и о том, как я уменьшил количество нажатий клавиш при использовании Vim. Я назвал эту игру Vim-крокет.
Сбор данных
-----------
Я начал мой анализ со сбора данных. Редактирование текста на моем компьютере всегда происходит с помощью Vim, так что в течении 45 дней я логировал любое нажание клавиши в нем с помощью флага scriptout. Для удобства я сделал alias для записи нажатий в лог:
```
alias vim='vim -w ~/.vimlog "$@"'
```
После этого необходимо было распарсить полученные данные, но это оказалось не так легко. Vim это модальный редактор, в котором одна команда может иметь несколько различных значений в разных режимах. Помимо этого команды зависят от контекста, когда их поведение может отличаться в зависимости от того, где внутри буфера vim они исполняются. Например, команда **cib** в нормальном режиме переведет пользователя в режим редактирования, если команда выполняется внутри скобок, но оставит пользователя в нормальном режиме, если она выполнена вне скобок. Если же **cib** будет выполнена в режиме редактирования, то она будет иметь совершенно другое поведение — запишет символы **«cib»** в текущий буфер.
Я рассмотрел несколько кандидатов для парсинга команд vim, включая промышленные библиотеки, такие как [antler](http://www.antlr.org/) и [parsec](http://legacy.cs.uu.nl/daan/parsec.html), а также специализирующийся на vim проект [vimprint](https://github.com/nelstrom/vimprint). После некоторых раздумий, я решил написать собственный инструмент, т.к. трата большого количества времени на изучение достаточно сложных парсеров казалось необоснованным для этой задачи.
Я написал сыроватый лексер на haskell'е для разбиения собранных мной нажатий клавиш на индивидуальные команды vim. Мой лексер использует [monoids](http://en.wikipedia.org/wiki/Monoid) для извлечения команд нормального режима из лога для дальнейшего анализа. Вот исходник лексера:
```
import qualified Data.ByteString.Lazy.Char8 as LC
import qualified Data.List as DL
import qualified Data.List.Split as LS
import Data.Monoid
import System.IO
main = hSetEncoding stdout utf8 >>
LC.getContents >>= mapM_ putStrLn . process
process = affixStrip
. startsWith
. splitOnMode
. modeSub
. capStrings
. split mark
. preprocess
subs = appEndo . mconcat . map (Endo . sub)
sub (s,r) lst@(x:xs)
| s `DL.isPrefixOf` lst = sub'
| otherwise = x:sub (s,r) xs
where
sub' = r ++ sub (s,r) (drop (length s) lst)
sub (_,_) [] = []
preprocess = subs meta
. DL.intercalate " "
. DL.words
. DL.unwords
. DL.lines
. LC.unpack
splitOnMode = DL.concat $ map (\el -> split mode el)
startsWith = filter (\el -> mark `DL.isPrefixOf` el && el /= mark)
modeSub = map (subs mtsl)
split s r = filter (/= "") $ s `LS.splitOn` r
affixStrip = clean
. concat
. map (\el -> split mark el)
capStrings = map (\el -> mark ++ el ++ mark)
clean = filter (not . DL.isInfixOf "[M")
(mark, mode, n) = ("-(*)-","-(!)-", "")
meta = [("\"",n),("\\",n),("\195\130\194\128\195\131\194\189`",n),
("\194\128\195\189`",n),("\194\128kb\ESC",n),
("\194\128kb",n),("[>0;95;c",n), ("[>0;95;0c",n),
("\ESC",mark),("\ETX",mark),("\r",mark)]
mtsl = [(":",mode),("A",mode), ("a",mode), ("I",mode), ("i",mode),
("O",mode),("o",mode),("v", mode),("/",mode),("\ENQ","⌃e"),
("\DLE","⌃p"),("\NAK","⌃u"),("\EOT","⌃d"),("\ACK","⌃f"),
("\STX","⌃f"),("\EM","⌃y"),("\SI","⌃o"),("\SYN","⌃v"),
("\DC2","⌃r")]
```
А вот пример данных до и после обработки:
```
cut -c 1-42 ~/.vimlog | tee >(cat -v;echo) | ./lexer
`Mihere's some text^Cyyp$bimore ^C0~A.^C:w^M:q
`M
yyp$b
0~
```
Лексер читает из стандартного потока ввода и отправляет обработанные команды в стандартный вывод. В примере выше примере необработанные данные расположены во второй строке, а результат обработки — на следующих. Каждая строка представляет собой группы команд нормального режима, выполненные в соответствующей последовательности. Лексер корректно определил, что я начал в нормальном режиме, перейдя в некоторый буфер с помощью метки **`M**, затем ввел **here's some text** в режиме редактирования, после чего скопировал/вставил строку и перешел на начало последнего слова в строке с помощью команды **yyp$b**. Затем ввел дополнительный текст и в итоге перешел в начало строки, заменив первый символ на прописной командой **0~**.
Карта использования клавиш
--------------------------
После обработки залогированных данных, я форкнул замечательный проект [heatmap-keyboard](http://www.patrick-wied.at/projects/heatmap-keyboard/) за авторством [Patrick Wied](http://www.patrick-wied.at/), и добавил в него собственный кастомный слой для чтения вывода лексера. Этот проект не определял большинство мета-символов, например, ESC, Ctrl и Cmd, поэтому мне было необходимо написать загрузчик данных на JavaScript и внести некоторые другие модификации. Я транслировал мета-символы, используемые в vim, в юникод и спроецировал их на клавиатуру. Вот что у меня получилось на количестве команд, близком к 500 000 (интенсивность цвета указывает на частоту использования клавиш).
На полученной карте видно, что чаще всего используется клавиша Ctrl — я использую ее для многочисленных команд перемещения в vim. Например, **^p** для [ControlP](http://kien.github.io/ctrlp.vim/), или цикл по открытым буферам через **^j ^k**.
Другая особенность, которая бросилась в глаза при анализе карты — это частое использование **^E ^Y**. Я повседневно использую эти команды для навигации вверх/вниз по коду, хотя вертикальное перемещение с помощью них неэффективно. Каждый раз, когда одна из этих команды исполняется, курсор перемещается только на несколько строк за раз. Более эффективно было бы использовать команды **^U ^D**, т.к. они смещают курсор на половину экрана.
Частота использования команд
----------------------------
Карта использования клавиш дает хорошее представление о том, как используются отдельные клавиши, но мне хотелось узнать больше о том, как я использую различные последовательности клавиш. Я отсортировал строки в выводе лексера по частоте, чтобы увидеть наиболее используемые команды нормального режима с помощью однострочника:
```
$ sort normal_cmds.txt | uniq -c | sort -nr | head -10 | \
awk '{print NR,$0}' | column -t
1 2542 j
2 2188 k
3 1927 jj
4 1610 p
5 1602 ⌃j
6 1118 Y
7 987 ⌃e
8 977 zR
9 812 P
10 799 ⌃y
```
Для меня было удивительно видеть **zR** на восьмом месте. После обдумывания этого факта, я осознал серьезную неэффективность в моем подходе к редактированию текста. Дело в том, что в моем **.vimrc** указано автоматически сворачивать блоки текста. Но проблема с данной конфигурацией была в том, что я почти сразу разворачивал весь текст, так что в этом не было смысла. Поэтому я просто удалил эту настройку из конфига, чтобы убрать необходимость частого использования **zR**.
Сложность команд
----------------
Другая оптимизация, на которую я хотел взглянуть — это сложность команд нормального режима. Мне было любопытно увидеть, смогу ли я найти команды, которые использую повседневно, но которые требуют излишне большого количества нажатий клавиш. Такие команды можно было бы заменить с помощью shortcut'ов, которые бы ускорили их выполнение. В качестве меры сложности команд я использовал [энтропию](http://en.wikipedia.org/wiki/Information_theory#Entropy), которую измерял следующим коротким скриптом на Python:
```
#!/usr/bin/env python
import sys
from codecs import getreader, getwriter
from collections import Counter
from operator import itemgetter
from math import log, log1p
sys.stdin = getreader('utf-8')(sys.stdin)
sys.stdout = getwriter('utf-8')(sys.stdout)
def H(vec, correct=True):
"""Calculate the Shannon Entropy of a vector
"""
n = float(len(vec))
c = Counter(vec)
h = sum(((-freq / n) * log(freq / n, 2)) for freq in c.values())
# impose a penality to correct for size
if all([correct is True, n > 0]):
h = h / log1p(n)
return h
def main():
k = 1
lines = (_.strip() for _ in sys.stdin)
hs = ((st, H(list(st))) for st in lines)
srt_hs = sorted(hs, key=itemgetter(1), reverse=True)
for n, i in enumerate(srt_hs[:k], 1):
fmt_st = u'{r}\t{s}\t{h:.4f}'.format(r=n, s=i[0], h=i[1])
print fmt_st
if __name__ == '__main__':
main()
```
Скрипт читает из стандартного потока ввода и выдает команды с наибольшей энтропией. Я использовал вывод лексера в качестве данных для расчета энтропии:
```
$ sort normal_cmds.txt | uniq -c | sort -nr | sed "s/^[ \t]*//" | \
awk 'BEGIN{OFS="\t";}{if ($1>100) print $1,$2}' | \
cut -f2 | ./entropy.py
1 ggvG$"zy 1.2516
```
Я отбираю команды, которые выполнялись более 100 раз, а затем нахожу среди них команду с наибольшей энтропией. В результате анализа была выделена команда **ggvG$''zy**, которая выполнялась 246 раз за 45 дней. Команда выполняется с помощью 11 достаточно неуклюжих нажатий клавиш и копирует весь текущий буфер в регистр **z**. Я обычно использую это команду для перемещения всего содержимого одного буфера в другой. Конечно, добавил в свой конфиг новый shortcut
```
nnoremap ya ggvG$"zy
```
Выводы
------
Мой матч в vim-крокет определил 3 оптимизации для уменьшения количества нажатий клавиш в vim:
* Использование команд навигации **^U ^D** вместо **^E ^Y**
* Предотвращение автоматического сворачивания текста в буфере для избежания **zR**
* Создание shortcut'а для многословной команды **ggvG$''zy**
Эти 3 простых изменения спасли меня от тысяч ненужных нажатий клавиш каждый месяц.
Части кода, которые я представил выше, немного изолированы и могут быть сложны для использования. Чтобы сделать шаги моего анализа понятнее, я привожу Makefile, который показывает, как код, содержащийся в моей статье, совмещается в единое целое.
```
SHELL := /bin/bash
LOG := ~/.vimlog
CMDS := normal_cmds.txt
FRQS := frequencies.txt
ENTS := entropy.txt
LEXER_SRC := lexer.hs
LEXER_OBJS := lexer.{o,hi}
LEXER_BIN := lexer
H := entropy.py
UTF := iconv -f iso-8859-1 -t utf-8
.PRECIOUS: $(LOG)
.PHONY: all entropy clean distclean
all: $(LEXER_BIN) $(CMDS) $(FRQS) entropy
$(LEXER_BIN): $(LEXER_SRC)
ghc --make $^
$(CMDS): $(LEXER_BIN)
cat $(LOG) | $(UTF) | ./$^ > $@
$(FRQS): $(H) $(LOG) $(CMDS)
sort $(CMDS) | uniq -c | sort -nr | sed "s/^[ \t]*//" | \
awk 'BEGIN{OFS="\t";}{if ($$1>100) print NR,$$1,$$2}' > $@
entropy: $(H) $(FRQS)
cut -f3 $(FRQS) | ./$(H)
clean:
@- $(RM) $(LEXER_OBJS) $(LEXER_BIN) $(CMDS) $(FRQS) $(ENTS)
distclean: clean
``` | https://habr.com/ru/post/211108/ | null | ru | null |
# Пример создания WCF-сервиса, работающего внутри службы Windows
Windows Communication Foundation – программная платформа от Microsoft для создания, настройки и развертывания распределенных сетевых сервисов. WCF-runtime и его пространство имен System.ServiceModel, представляющее его главный программный интерфейс, это преемник технологий создания распределенных систем, успешно применяемых разработчиками для создания распределенных приложений на платформе Windows в последнее десятилетие. Разберём тестовый пример создания WCF-сервиса.
Открываем Visual Studio 2015 и создаём новый проект типа Class Library. Проект назовём WCFMyServiceLibrary.
Файл Class1.cs переименуем в MyService.cs и добавим ещё один класс, файл для которого назовём IMyService.cs.
Добавим ссылку на сборку System.ServiceModel.
**В файле IMyService.cs опишем интерфейс:**
```
using System.ServiceModel;
namespace WCFMyServiceLibrary
{
[ServiceContract]
public interface IMyService
{
[OperationContract]
string Method1(string x);
[OperationContract]
string Method2(string x);
}
}
```
**В файле MyService.cs опишем реализацию интерфейса:**
```
namespace WCFMyServiceLibrary
{
public class MyService : IMyService
{
public string Method1(string x)
{
string s = $"1 You entered: {x} = = = 1";
return s;
}
public string Method2(string x)
{
string s = $"2 you entered: {x} = = = 2";
return s;
}
}
}
```
На этом разработка сервиса завершена. Переходим к созданию службы Windows, которая будет контейнером для данного сервиса.
В том же решении (Solution) создадим новый проект типа «Служба Windows». Называем проект WindowsServiceHostForMyService.
Затем файл Service1.cs (только что созданного проекта) переименуем в MyService.cs. В этот проект добавим ссылку на сборку System.ServiceModel, а также не забываем указывать в файле MyService.cs директивы:
```
using System.ServiceModel;
using System.ServiceModel.Description;
```
В классе MyService добавляем новый член:
```
private ServiceHost service_host = null;
```
Также необходимо добавить ссылку на проект WCFMyServiceLibrary, который находится в этом же решении:
Затем в классе MyService изменим метод OnStart таким образом, чтобы в этом методе добавлялись конечные точки нашего сервиса (endpoint):
**метод OnStart**
```
protected override void OnStart(string[] args)
{
if (service_host != null) service_host.Close();
string address_HTTP = "http://localhost:9001/MyService";
string address_TCP = "net.tcp://localhost:9002/MyService";
Uri[] address_base = { new Uri(address_HTTP), new Uri(address_TCP) };
service_host = new ServiceHost(typeof(WCFMyServiceLibrary.MyService), address_base);
ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
service_host.Description.Behaviors.Add(behavior);
BasicHttpBinding binding_http = new BasicHttpBinding();
service_host.AddServiceEndpoint(typeof(WCFMyServiceLibrary.IMyService), binding_http, address_HTTP);
service_host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), "mex");
NetTcpBinding binding_tcp = new NetTcpBinding();
binding_tcp.Security.Mode = SecurityMode.Transport;
binding_tcp.Security.Transport.ClientCredentialType = TcpClientCredentialType.Windows;
binding_tcp.Security.Message.ClientCredentialType = MessageCredentialType.Windows;
binding_tcp.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign;
service_host.AddServiceEndpoint(typeof(WCFMyServiceLibrary.IMyService), binding_tcp, address_TCP);
service_host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "mex");
service_host.Open();
}
```
Затем реализуем остановку сервиса в методе OnStop:
```
protected override void OnStop()
{
if (service_host != null)
{
service_host.Close();
service_host = null;
}
}
```
Затем в Обозревателе решения — двойной клик на файле MyService.cs (проекта WindowsServiceHostForMyService) откроет этот файл в режиме конструктора (Design Mode).
На пустом пространстве вызываем контекстное меню (щелчок правой кнопкой мыши) и выбираем «Добавить установщик».
При этом будет создан новый класс ProjectInstaller.cs
Переименуем файл ProjectInstaller.cs в MyServiceInstaller.cs.
При этом выйдет окно с вопросом, следует ли переименовать зависимые объекты – отвечаем «Да».
Добавим в файл ссылку
```
using System.ServiceProcess;
```
Затем изменим код конструктора класса MyServiceInstaller:
```
public MyServiceInstaller()
{
// InitializeComponent();
serviceProcessInstaller1 = new ServiceProcessInstaller();
serviceProcessInstaller1.Account = ServiceAccount.LocalSystem;
serviceInstaller1 = new ServiceInstaller();
serviceInstaller1.ServiceName = "WindowsServiceHostForMyService";
serviceInstaller1.DisplayName = "WindowsServiceHostForMyService";
serviceInstaller1.Description = "WCF Service Hosted by Windows NT Service";
serviceInstaller1.StartType = ServiceStartMode.Automatic;
Installers.Add(serviceProcessInstaller1);
Installers.Add(serviceInstaller1);
}
```
Заметим, что вызов метода InitializeComponent() мы заблокировали с помощью комментария.
На этом разработка службы Windows завершена. Собираем всё решение (Build Solution) и переходим к следующему этапу – установка службы Windows.
Для установки нашей службы создадим bat-файл (с произвольным названием, например Install\_Windows\_Service.bat) следующего содержания:
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\InstallUtil.exe WindowsServiceHostForMyService.exe
```
Нужно скопировать этот bat-файл в ту же папку, где находится скомпилированный файл WindowsServiceHostForMyService.exe (вам нужно заранее продумать, в какой папке будет лежать этот файл, который будет всегда запущен в качестве службы Windows).
Запускаем bat-файл, после чего наша программа WindowsServiceHostForMyService.exe будет установлена в качестве службы Windows.
Запустим эту службу с помощью стандартной программы управления службами.
Следующий этап – разработка клиентского приложения для использования предоставляемых сервисом услуг.
Для этого прежде всего нужно организовать так называемый «переходник» — Service Proxy – набор настроек, описывающих сервис для клиентского приложения.
Воспользуемся для этого стандартной утилитой SvcUtil.exe. Создадим файл Generate\_Proxy.bat следующего содержания
```
SvcUtil http://localhost:9001/MyService /out:MyServiceProxy.cs /config:App.config
```
Запустим этот файл (стандартная утилита SvcUtil.exe находится в папке C:\Program Files\Microsoft SDKs\Windows\v7.0\Bin).
Этот файл нужно запустить во время работы нашего сервиса, т.е. в данном случае, после успешного запуска службы Windows WindowsServiceHostForMyService.
В случае успешного запуска, программа SvcUtil.exe сгенерирует 2 файла — MyServiceProxy.cs и App.config.
Эти файлы необходимо добавить для клиентского приложения, чтобы это приложение могло вызывать методы нашей службы (чуть ниже вы узнаете, что файл App.config я решил не добавлять — обойдёмся и без него).
Примечание. Аналогичного результата можно было добиться, запустив
```
SvcUtil net.tcp://localhost:9002/MyService /out:MyServiceProxy.cs /config:App.config
```
Т.е. можно запускать эту утилиту, указав только одну конечную точку, либо http либо net.tcp.
В том же решении (Solution) создадим обычное приложение Windows Forms. Назовем его WindowsFormsApplication1
Добавим в этот проект ссылку на System.ServiceModel и, конечно же,
```
using System.ServiceModel в файле формы.
```
Добавим в этот проект файл MyServiceProxy.cs (именно его мы сгенерировали утилитой SvcUtil.exe). При этом следует добавить в файл MyServiceProxy.cs следующие строки:
```
namespace ServiceReference1
{
using System.Runtime.Serialization;
using System;
… затем идёт содержимое файла MyServiceProxy.cs …
и конечно, не забываем поставить завершающую скобку для namespace
}
```
После этого, мы сможем ссылаться на класс MyServiceClient (этот класс создан программой SvcUtil.exe), указав в файле формы директиву.
```
using ServiceReference1;
```
**Пример готового файла MyServiceProxy.cs (комментарии удалены):**
```
namespace ServiceReference1
{
using System.Runtime.Serialization;
using System;
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
[System.ServiceModel.ServiceContractAttribute(ConfigurationName="IMyService")]
public interface IMyService
{
[System.ServiceModel.OperationContractAttribute(Action="http://tempuri.org/IMyService/Method1", ReplyAction="http://tempuri.org/IMyService/Method1Response")]
string Method1(string x);
[System.ServiceModel.OperationContractAttribute(Action="http://tempuri.org/IMyService/Method2", ReplyAction="http://tempuri.org/IMyService/Method2Response")]
string Method2(string x);
}
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public interface IMyServiceChannel : IMyService, System.ServiceModel.IClientChannel
{
}
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public partial class MyServiceClient : System.ServiceModel.ClientBase, IMyService
{
public MyServiceClient()
{
}
public MyServiceClient(string endpointConfigurationName) :
base(endpointConfigurationName)
{
}
public MyServiceClient(string endpointConfigurationName, string remoteAddress) :
base(endpointConfigurationName, remoteAddress)
{
}
public MyServiceClient(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress) :
base(endpointConfigurationName, remoteAddress)
{
}
public MyServiceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) :
base(binding, remoteAddress)
{
}
public string Method1(string x)
{
return base.Channel.Method1(x);
}
public string Method2(string x)
{
return base.Channel.Method2(x);
}
}
}
```
Поступим неординарно – и не будем добавлять файл App.Config в проект клиента!
Затем набросаем на форму 3 кнопки, текстовое поле textBox1 (пользователь вводит сюда строку для отправки на сервер) и поле richTextbox1 (имитация подсистемы сообщений нашего приложения – именно в это поле будут поступать сообщения от программы, в том числе и те, что вернул нам сервис)
Кнопка btn\_Start – создаёт клиента
Кнопка btn\_Send – отправляет сервису текстовую строку из текстового поля
Кнопка btn\_Close – удаляет клиента из памяти и закрывает приложение
**Код формы:**
```
using System;
using System.ServiceModel;
using System.Windows.Forms;
using ServiceReference1;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
MyServiceClient client = null;
public Form1()
{
InitializeComponent();
}
private void Print(string text)
{
richTextBox1.Text += text + "\n\n";
richTextBox1.SelectionStart = richTextBox1.Text.Length;
richTextBox1.ScrollToCaret();
}
private void Print(Exception ex)
{
if (ex == null) return;
Print(ex.Message);
Print(ex.Source);
Print(ex.StackTrace);
}
private void Create_New_Client()
{
if (client == null)
try { Try_To_Create_New_Client(); }
catch (Exception ex)
{
Print(ex);
Print(ex.InnerException);
client = null;
}
else
{
Print("Cannot create a new client. The current Client is active.");
}
}
private void Try_To_Create_New_Client()
{
try
{
NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport);
binding.Security.Message.ClientCredentialType = MessageCredentialType.Windows;
binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Windows;
binding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign;
string uri = "net.tcp://192.168.1.2:9002/MyService";
EndpointAddress endpoint = new EndpointAddress(new Uri(uri));
client = new MyServiceClient(binding, endpoint);
client.ClientCredentials.Windows.ClientCredential.Domain = "";
client.ClientCredentials.Windows.ClientCredential.UserName = "Vasya";
client.ClientCredentials.Windows.ClientCredential.Password = "12345";
Print("Creating new client ....");
Print(endpoint.Uri.ToString());
Print(uri);
string test = client.Method1("test");
if (test.Length < 1)
{
throw new Exception("Проверка соединения не удалась");
}
else
{
Print("test is OK ! " + test);
}
}
catch (Exception ex)
{
Print(ex);
Print(ex.InnerException);
client = null;
}
}
private void btn_Start_Click(object sender, EventArgs e)
{
Create_New_Client();
}
private void btn_Send_Click(object sender, EventArgs e)
{
Print("sending message . . .");
string s = textBox1.Text;
string x = "";
if (client != null)
{
x = client.Method1(s);
Print(x);
x = client.Method2(s);
Print(x);
}
else
{
Print("Error! Client does not exist!");
}
}
private void btn_Close_Click(object sender, EventArgs e)
{
if (client != null)
{
Print("Closing a client ...");
client.Close();
client = null;
}
else
{
Print("Error! Client does not exist!");
}
this.Close();
}
}
}
```
Компилируем и запускаем с другой машины из той же сети – и тестируем сервис, нажав сначала btn\_Start, а затем отправляя сервису сообщения нажатием btn\_Send.
Заметим, что в данном примере на клиенте мы совсем не использовали конечную точку
`http://localhost:9001/MyService`
а работали только с
`net.tcp://localhost:9002/MyService`
(вы легко сможете это сделать самостоятельно – раз уж вам net.tcp по плечу, то уж http-то с закрытыми глазами сделаете).
Кроме того, мы не использовали файл App.config, создав на клиенте конечную точку не с помощью настроек, а с помощью кода C#. Причины тому – субъективные – автор не любит возиться с XML-настройками, а по возможности всё делает явно в коде. Спасибо за внимание!
Лирическое отступление. Автор статейки познакомился с языком C# в марте сего года, первое приложение на C# написал в мае (до этого много лет формошлёпил на Delphi и даже на MS Access). | https://habr.com/ru/post/331952/ | null | ru | null |
# Аллокаторы памяти
Всем привет! Не так давно, после очень плотного изучения аллокаторов и алгоритмов распределения памяти, а также в последующем применении их на практике мне в голову пришла идея написать статью, в которой будет максимально подробно рассказано о них. Считаю, что данная тема будет достаточно востребованной, так как в сети, особенно в русскоязычной части, на данный момент существует очень мало источников, посвященных этому вопросу.
Предисловие
-----------
Для начала, хотелось бы сразу отметить, что если кто-то впервые слышит термины «аллокатор», «алгоритмы распределения памяти» и не понимает, для чего это все нужно, то тогда, прежде чем читать данную статью, я рекомендую ознакомиться с [данным](https://habr.com/ru/post/274827/) источником. В данной статье достаточно хорошо рассказывается, какие существуют проблемы в стандартных аллокаторах памяти, и для каких целей стоит использовать другие способы распределения памяти, помимо стандартных. Здесь же я буду рассказывать только о самих алгоритмах распределения, ну и, конечно же, в конце приведу реализацию одного из аллокаторов, которая может быть без проблем использована в стандартных контейнерах С++.
---
Основы
------
Концептуально выделяется пять основных операции, которые можно осуществить над аллокатором (хочется отметить, что не все аллокаторы могут явно соответствовать этому интерфейсу):
* *create* – создает аллокатор и отдает ему в распоряжение некоторый объем памяти;
* *allocate* – выделяет блок определенного размера из области памяти, которым распоряжается аллокатор;
* *deallocate* – освобождает определенный блок;
* *free* – освобождает все выделенные блоки из памяти аллокатора (память, выделенная аллокатору, не освобождается);
* *destroy* – уничтожает аллокатор с последующим освобождением памяти, выделенной аллокатору.
Linear Allocator
----------------
Linear Allocator, он же «линейный» — это самый простой вид аллокаторов. Идея состоит в том, чтобы сохранить указатель на начало блока памяти выделенному аллокатору, а также использовать другой указатель или числовое представление, которое необходимо будет перемещать каждый раз, когда выделение из аллокатора завершено. В этом аллокаторе внутренняя фрагментация сведена к минимуму, потому что все элементы вставляются последовательно (пространственная локальность), и единственная фрагментация между ними — выравнивание.
Дальше предлагаю рассмотреть несколько примеров, в которых будет наглядно показано в деталях, как работает данный аллокатор. Возьмем некоторый блок памяти равный 14 байтам и отдадим его в управление аллокатору. Как видно из картинки ниже, мы сохраняем указатель на начало памяти (*start*), а также храним два указателя, либо два числовых представления, которые содержат информацию об общем (*end*) и используемом (*used*) размерах памяти.
Представим, что в аллокатор поступил запрос на выделение 4 байт памяти. Действия аллокатора на исполнения этого запроса будут следующие:
* проверить достаточно ли памяти для выделения;
* сохранить текущий указатель used, который в дальнейшем будет отдан пользователю, как указатель на блок выделенной памяти из аллокатора;
* сместить указатель used на величину равную объему выделенного блока памяти, т.е. на 4 байта.
Дальше, например, приходит запрос на выделение 8 байт и, соответственно, действия аллокатора будут точно такими же вне зависимости от размера выделяемого блока памяти.
А вот здесь уже будет немного интереснее, например, если приходит запрос на выделение только 1 байта, и если мы не хотим выравнивать блоки в памяти (например адреса кратные 2, 4, …), то действия аллокатора останутся точно такими же.
Но, если нам нужно выделять блоки памяти с определенным выравниванием (например выравнивание адресов кратных 2), то здесь действие аллокатора немного меняется. Меняется оно не в плане реализации, а в том, что помимо самих данных равных объему одного байта, мы еще забираем и один дополнительный байт из памяти аллокатора для выравнивания, который не несет никакой смысловой нагрузки. Как раз-таки это и есть та самая возможная минимальная фрагментация памяти внутри линейного аллокатора.
Отлично, теперь самое время поговорить об освобождении памяти. Как уже отмечалось ранее, данный вид аллокоторов не поддерживает выборочное освобождение определенных блоков памяти. То есть, если провести тонкую аналогию с *malloc/free*, имея указатель, скажем, на **0xFFAA00**, мы могли бы освободить этот блок памяти, но вот линейный аллокатор нам этого позволить не может.
Все, что мы можем сделать, это освободить всю занятую память целиком внутри аллокатора и продолжить работать с ним, как с совершенно пустым.
---
Pool Allocator
--------------
Идея блочного аллокатора заключается в том, что он разделяет некоторый большой участок памяти на более мелкие участки **одинакового размера**. По своей сути он также является очень простым аллокатором, так как, когда запрашивается выделение, он просто возвращает один из свободных участков памяти фиксированного размера, а когда запрашивается освобождение то, он просто сохраняет этот участок памяти для дальнейшего использования. Таким образом, распределение работает очень быстро, а фрагментация все еще очень мала.
Дальше, также, как и с линейным аллокатором, предлагаю рассмотреть все на примере, чтобы детальнее понять, как он работает, поэтому возьмем некоторый блок памяти равный 12 байт и отдадим его в управление аллокатору. Как видно из картинки ниже, мы сохраняем указатель на начало (*start*) и конец (*end*) памяти, которой управляет аллокатор, а также список (*freeblocks*) из адресов свободных блоков в аллокаторе. В качестве средства для хранения данных о том, что блок занят или свободен, можно использовать много средств, например массив из булевых значений, но я именно решил остановиться на выборе односвязного списка, так как он наиболее просто и наглядно характеризует данную концепцию (кстати, сами звенья списка можно хранить в свободных блоках памяти, тем самым убрав дополнительные расходы с памятью).
Если приходит запрос на выделение одного блока памяти, то действия аллокатора очень примитивные. Сначала он проверяет, есть ли звенья в списке свободных блоков, если их там нет, то не трудно догадаться, что память в аллокаторе уже закончилась. Если же там есть хотя бы одно звено, то он просто достает корневое или хвостовое (в данной реализации отдаются хвостовые звенья) звено списка и отдает его адрес пользователю.
Если приходит запрос на выделение нескольких блоков памяти, то аллокатор точно так же по очереди проделывает те же действия, описанные на предыдущем шаге.
Что касается освобождения блока, если приходит запрос на освобождение, то тогда аллокатор просто добавляет этот адрес в один из концов односвязного списка. Стоит отметить такой момент, что в качестве адреса блока для освобождения может прийти, например адрес, несоответствующий адресу памяти аллокатора, например **0xEFAB12**, и тогда будет возможна такая ситуация, что мы в дальнейшем отдадим пользователю тот участок памяти, который нам не принадлежит (конечно же, это приведет к undefined behavior или если очень сильно повезет, то просто к краху программы). Для избегания этой возможной проблемы как раз-таки и используются *begin* и *end*, которые позволяют проверить, не ошибся ли пользователь адресом во время запроса на операцию освобождения.
Помимо выхода за пределы памяти, которой не управляет аллокатор, есть еще одна возможная проблема. Пользователь может прийти с запросом освободить совершенно любой адрес, находящийся в области памяти аллокатора, но не равный адресу начала какого-либо из блоков, допустим блока с адресом **0xFFAA07**. Эта операция, конечно же, приведет к undefined behavior. Если есть необходимость дополнительно проверять, все ли правильно делает пользователь, то есть возможность это отслеживать. Для отслеживания этого существует множество решений, например хранить также адреса и занятых блоков или вообще проверять адрес на кратность размеру блоков в аллокаторе (все зависит от фантазии и от конкертной ситуации, в которой используется аллокатор).
---
Stack Allocator
---------------
На самом деле, это умная эволюция линейного распределителя, которая позволяет управлять памятью, как стеком. Все так же, как и раньше, мы сохраняем указатель вместе с «header» блоком (в дальнейшем будет употребляться, как **заголовок**) на текущий адрес памяти и перемещаем его вперед для каждого выделения. В отличие от линейного аллокатора, мы также можем переместить его назад, то есть выполнить операцию deallocate, которая линейным аллокатором не поддерживается. Как и прежде, сохраняется принцип пространственной локальности, а фрагментация все еще минимальная.
Предлагаю рассмотреть несколько примеров все с тем же блоком памяти в 14 байт. Как и с линейным аллокатором, мы точно также сохраняем указатели на начало памяти (*start*) и конец (*end*), а также указатель на конец используемой памяти (*used*).
Когда приходит запрос на выделение памяти, помимо выделения некоего ее объема памяти, запрашиваемого пользователем, мы еще дополнительно выделяем заголовок (пользователь с ним никак не будет взаимодействовать), в котором храним сведения о том, сколько было выделено байт (в данном примере размер заголовка составляет 2 байта). Например, если пришел запрос на выделение 2 байт, то состояние аллокатора будет точно таким же, как на рисунке ниже. Важно отметить то, что пользователю будет отдан указатель не на заголовок, а на блок, следующий сразу за заголовком, то есть в данном примере это блок с адресом **0xFFAA02**.
Аналогичная ситуация будет и, например с выделением 6 байт.
А вот с освобождением все немного поинтереснее (как уже обсуждалось ранее, выделять и освобождать память мы можем только с использованием алгоритма **LIFO**). Для начала от указателя, который пользователь просит освободить, нужно отнять размер заголовка, после чего разыменовать значение и уже только после этого сдвинуть указатель *used* на размер заголовка вместе с размером блока, полученного из заголовка. Здесь так же, как и с блочным аллокатором, возможна ситуация освобождения «рандомных» блоков памяти, которая также приведет к undefined behavior. Дополнять аллокаторы дополнительными проверками или нет – дело каждого. Самое главное — не забывать об этом моменте.
Теперь, разобравшись в основах, самое время освоить что-то более серьезное.
---
«Примитивный стандартный аллокатор»
-----------------------------------
Дальше будет представлена реализация аллокатора, который можно будет без проблем использовать с STL. Алгоритм распределения памяти в этом аллокаторе будет схож с алгоритмом, который используется стандартным аллокатором. Хочу сразу отметить, что не претендую на полноту реализации malloc, мною были взяты лишь основные концепции из него c добавлением в некоторых местах своей логики. Все его тонкости и нюансы, конечно же, не были учтены в этой реализации…
В основе алгоритма лежит взаимодействие с «chunks» (дальше будет употреблено, как **участок**, в данной реализации их размер статичен и должен быть кратен четырем, а также все выделения памяти из памяти аллоктора выравниваются на размер, кратный четырем), о которых дальше и пойдет речь. В качестве примера возьмем участок c размером 16 байт. Внутри себя он будет содержать указатели на начало (*start*) и конец (*end*) памяти, указатель на максимальный блок памяти (*maxblock*) и множество (*freeblocks*), в котором будут храниться заголовки свободных блоков. Размер заголовка в данной реализации занимает 4 байта, но он может без проблем варьироваться в размере для нужных вам целей. Например, если вы точно знаете, что размер выделяемых блоков памяти будет не больше, чем максимальное числовое значение, которое можно представить в одно или двухбайтной переменной, то можно будет использовать заголовок в размере 1 или 2 байт.
При операции выделения памяти из участка, прежде всего нужно проверить, достаточно ли памяти (в данной реализации, это константная операция, мы просто сравниваем с *maxblock* заголовком и, если размер аллоцируемой памяти меньше, чем максимальный блок, то значит у нас достаточно памяти для этого выделения). Если памяти достаточно, то мы просто отдаем адрес памяти, следующий за заголовком, как и в стековом аллокаторе, а также удаляем прошлый заголовок из множества свободных блоков и уже только после этого добавляем туда новый заголовок, только что выделенного блока памяти. Важно отметить, что если мы аллоцировали память из максимального блока, то нам нужно будет обновить значение максимального блока.
При последующих выделениях все происходит точно также, как и на предыдущем шаге.
Но вот как только память в участке закончилась, аллокатор берет и просто создает еще один участок того же или большего размера (в данной реализации все участки одинакового размера). Стоит также следить за тем, чтобы размер возможного блока для выделения не превышал размер участка с вычетом размера заголовка.
Дальше уже в новом участке можно без проблем выделять нужные блоки памяти. Выделение памяти будет происходить по точно такому же сценарию, как и в предыдущем участке.
Теперь немного о том, почему именно в данной реализации размер участка должен быть кратен четырем. Ответ очень просто – это делается для простоты реализации и восприятия алгоритма. Так как возможна такая ситуация, что в конце участка может остаться некоторая область памяти, в которой просто на просто не поместится заголовок (пример этого продемонстрирован на следующем рисунке). Чтобы решить эту проблему, можно будет заполнять эту память дополнительным выравниваем, либо делать размер заголовка меньшим или же использовать дополнительные средства для отслеживания этой возможной проблемы, иначе эта память будет потеряна и самая главное, что в дальнейшем потерянная память сможет накапливаться!
Прежде, чем освободить память, нужно определить, в каком участке находится блок (в текущей реализации эта операция с линейной сложностью относительно общего количества участков, если подразумевается, что будет большое количество участков, то ее можно будет сделать константной, добавив в заголовок индекс участка, в котором была выделена память). В последующем операция освобождения идентична со стековым аллокатором, за исключением того, что нужно будет добавить адрес заголовка освобожденного блока во множество свободных блоков, а также обновить *maxblock*, если размер только что освобожденного блока больше, чем *maxblock*.
Важно отметить, что в данной реализации, при каждом последующем освобождении памяти происходит попытка дефрагментации в том участке из которого была освобождена память. Дефрагментация нужна для того, чтобы объединять свободные блоки в большие по размеру. Например, в данной ситуации, как на рисунке ниже, мы не сможем выделить 6 байт, пусть даже размер свободной памяти нам и позволяет это сделать, но зато фрагментация говорит нам твердое и решительное «нет»!
Операция дефрагментации очень примитивная. Суть ее заключается в том, что после операции освобождения памяти идет проверка, не свободны ли два соседних блока слева и справа от освобожденного. Если два соседствующих блока свободны, то они объединяются в один единый.
Еще хотелось бы отметить, что данная реализация будет катастрофически ужасно работать с выделением маленьких блоков памяти, например равных 1 байту. В такой ситуации мы получаем +7 лишних байт на выделение всего лишь одно байта памяти из-за того, что размер заголовка равен 4 байтам и еще плюс 3 байта для вырывания адресов, которые должны быть кратны четырем. Этим я хочу сказать, что не стоит слепо использовать какой-либо алгоритм распределения памяти, так как вместо долгожданной оптимизации иногда можно получить только лишь дополнительные затраты.
Думаю, теории будет достаточно и поэтому, как сказал Линус Торвальдс: «*Болтовня ничего не стоит. Покажите мне код*». Ну что ж, приступаем…
---
Реализация
----------
Требования к аллокаторам приведены в стадарте С++ в главе "*Allocator requirements [allocator.requirements]*". Исходя из тех требований самый примитивный интерфейс аллокатора, который может использоваться в STL, должен выглядеть примерно вот так:
```
template
class Allocator
{
typedef T value\_type;
Allocator(аргументы конструктора);
template
Allocator(const & other);
T\* allocate(std::size\_t count\_objects);
void deallocate(T\* ptr, std::size\_t count\_objects);
};
template
bool operator==(const Allocator&, const Allocator&);
template
bool operator!=(const Allocator&, const Allocator&);
```
Предполагается, что STL контейнеры обращаются к аллокатору не напрямую, а через шаблон std::allocator\_traits, который предоставляет значения, такие как:
```
typedef T* pointer;
typedef const T* const_pointer;
…
```
Отлично, с требованиями разобрались, теперь наконец приступаем к написанию аллокатора. Для начала напишем некоторый интерфейс или адаптер, на самом деле это трудно назвать и тем, и другим, поэтому пусть это будет некая «прослойка», в которой при помощи стратегий мы сможем без проблем менять алгоритм аллоцирования памяти для определенных целей:
```
// Common interface for interaction with STL
// containers and algorithms. You can manually change
// allocation algorithm with different 'AllocationStrategy'
//
// In this implementation was not implented 'adress' and 'max_size'
// unnecessary functions for.
template
class Allocator
{
static\_assert(!std::is\_same\_v, "Type of the allocator can not be void");
public:
using value\_type = T;
template
friend class Allocator;
template
struct rebind
{
using other = Allocator;
};
public:
Allocator() = default;
explicit Allocator(AllocationStrategy& strategy) noexcept
: m\_allocation\_strategy(&strategy) {}
Allocator(const Allocator& other) noexcept
: m\_allocation\_strategy(other.m\_allocation\_strategy) {}
template
Allocator(const Allocator& other) noexcept
: m\_allocation\_strategy(other.m\_allocation\_strategy) {}
T\* allocate(std::size\_t count\_objects)
{
assert(m\_allocation\_strategy && "Not initialized allocation strategy");
return static\_cast(m\_allocation\_strategy->allocate(count\_objects \* sizeof(T)));
}
void deallocate(void\* memory\_ptr, std::size\_t count\_objects)
{
assert(m\_allocation\_strategy && "Not initialized allocation strategy");
m\_allocation\_strategy->deallocate(memory\_ptr, count\_objects \* sizeof(T));
}
template
void construct(U\* ptr, Args&&... args)
{
new (reinterpret\_cast(ptr)) U { std::forward(args)... };
}
template
void destroy(U\* ptr)
{
ptr->~U();
}
private:
AllocationStrategy\* m\_allocation\_strategy = nullptr;
};
template
bool operator==(const Allocator& lhs, const Allocator& rhs)
{
return lhs.m\_allocation\_strategy == rhs.m\_allocation\_strategy;
}
template
bool operator!=(const Allocator& lhs, const Allocator& rhs)
{
return !(lhs == rhs);
}
```
Благодаря стратегии для распределения памяти, мы сможем делать примерно вот так:
```
template
using AllocatorForSmallObjects = Allocator;
template
using AllocatorForBigObjects = Allocator;
```
То есть мы можем гибко менять алгоритмы распределения для необходимых целей в той или иной ситуации. Единственное требование к AllocationStrategy — у них должны быть операции *allocate* и *deallocate*.
```
// Strategy for manipulation memory chunks, like
// a primitive malloc allocator.
//
// Warning: if you try to deallocate some random block
// of the memory, most of all it will be an undefined behavior,
// because current implementation doesn't check this possible situation.
template
class CustomAllocationStrategy
{
static\_assert(CHUNK\_SIZE != 0u, "Chunk size must be more, than zero");
static\_assert(CHUNK\_SIZE <= std::numeric\_limits::max(),
"Chunk size must be less or equal max value of the uint32\_t");
public:
void\* allocate(std::size\_t size)
{
assert(size < CHUNK\_SIZE && "Incorrect chunk size for future usage");
if (size == 0u)
{
return nullptr;
}
for (auto& chunk : m\_chunks)
{
void\* allocated\_block = chunk.tryReserveBlock(size);
if (allocated\_block) //if the block was not reserved, then memory in the chunk has run out
{
return allocated\_block;
}
}
m\_chunks.push\_back(details::Chunk{});
auto& chunk = m\_chunks.back();
std::uint8\_t\* allocated\_block = chunk.tryReserveBlock(size);
return allocated\_block;
}
void deallocate(void\* memory\_ptr, std::size\_t size)
{
if ( (!memory\_ptr) || (size == 0u) )
{
return;
}
std::uint8\_t\* deallocation\_ptr = static\_cast(memory\_ptr);
for (auto& chunk : m\_chunks)
{
if (chunk.isInside(deallocation\_ptr))
{
chunk.releaseBlock(deallocation\_ptr);
}
}
}
private:
std::deque> m\_chunks{ 1u };
};
```
Здесь и дальше используются стандартные контейнеры. Согласен, что будет очень много выделений из кучи. Думаю, что для тех, кто будет писать свои аллокаторы, это будет неприемлемо. В качестве альтернативы, конечно же, можно писать свои контейнеры или использовать чужие, заточенные под определенные нужды, но в данной реализации я старался как можно проще преподнести материал, поэтому мой выбор лег именно на стандартные контейнеры.
```
namespace details
{
std::size_t getAlignmentPadding(std::size_t not_aligned_address, std::size_t alignment)
{
if ( (alignment != 0u) && (not_aligned_address % alignment != 0u) )
{
const std::size_t multiplier = (not_aligned_address / alignment) + 1u;
const std::size_t aligned_address = multiplier * alignment;
return aligned_address - not_aligned_address;
}
return 0u;
}
// Current chunk implementation works only with size
// aligned by 4 bytes, because HEADER_SIZE now also 4 bytes.
// You can modify it with HEADER_SIZE without problems for your purposes.
template
class Chunk
{
static constexpr std::size\_t HEADER\_SIZE = 4u;
static\_assert(CHUNK\_SIZE % HEADER\_SIZE == 0, "CHUNK\_SIZE must be multiple of the four");
static\_assert(CHUNK\_SIZE > HEADER\_SIZE, "CHUNK\_SIZE must be more than HEADER\_SIZE");
public:
Chunk()
{
m\_blocks.resize(CHUNK\_SIZE);
std::uint32\_t\* init\_header = reinterpret\_cast(m\_blocks.data());
\*init\_header = CHUNK\_SIZE - HEADER\_SIZE;
m\_max\_block = init\_header;
m\_free\_blocks.insert(init\_header);
}
bool isInside(const std::uint8\_t\* address) const noexcept
{
const std::uint8\_t\* start\_chunk\_address = reinterpret\_cast(m\_blocks.data());
const std::uint8\_t\* end\_chunk\_address = start\_chunk\_address + CHUNK\_SIZE;
return (start\_chunk\_address <= address) && (address <= end\_chunk\_address);
}
std::uint8\_t\* tryReserveBlock(std::size\_t allocation\_size)
{
const std::size\_t not\_aligned\_address = reinterpret\_cast(m\_max\_block) + allocation\_size;
const std::size\_t alignment\_padding = getAlignmentPadding(not\_aligned\_address, HEADER\_SIZE);
const std::uint32\_t allocation\_size\_with\_alignment = static\_cast(allocation\_size + alignment\_padding);
if ( (!m\_max\_block) || (allocation\_size\_with\_alignment > \*m\_max\_block) ) // Check on enaught memory for allocation
{
return nullptr;
}
// Find min available by size memory block
const auto min\_it = std::min\_element(m\_free\_blocks.cbegin(), m\_free\_blocks.cend(), [allocation\_size\_with\_alignment] (const std::uint32\_t\* lhs, const std::uint32\_t\* rhs)
{
if (\*rhs < allocation\_size\_with\_alignment)
{
return true;
}
return (\*lhs < \*rhs) && (\*lhs >= allocation\_size\_with\_alignment);
});
assert(min\_it != m\_free\_blocks.cend() && "Internal logic error with reserve block, something wrong in implementation...");
assert(\*\*min\_it >= allocation\_size\_with\_alignment && "Internal logic error with reserve block, something wrong in implementation...");
std::uint32\_t\* header\_address = \*min\_it;
std::uint32\_t\* new\_header\_address =
reinterpret\_cast(reinterpret\_cast(header\_address) + HEADER\_SIZE + allocation\_size\_with\_alignment);
if (m\_free\_blocks.find(new\_header\_address) == m\_free\_blocks.cend()) // check if there is free memory in the current block
{
const std::uint32\_t old\_block\_size = \*header\_address;
const std::uint32\_t difference = old\_block\_size - HEADER\_SIZE;
if (difference >= allocation\_size\_with\_alignment) // check if there is enough space for another block
{
const std::uint32\_t new\_block\_size = difference - allocation\_size\_with\_alignment;
\*new\_header\_address = new\_block\_size;
m\_free\_blocks.insert(new\_header\_address);
}
}
m\_free\_blocks.erase(header\_address);
\*header\_address = static\_cast(allocation\_size);
if (header\_address == m\_max\_block) // if the maximum block were changed, then need to find the maximum block again
{
// Find max block by size
const auto max\_it = std::max\_element(m\_free\_blocks.cbegin(), m\_free\_blocks.cend(), [] (const std::uint32\_t\* lhs, const std::uint32\_t\* rhs)
{
return (\*lhs) < (\*rhs);
});
// If there are no free blocks, therefore the memory in this chunk is over
m\_max\_block = (max\_it != m\_free\_blocks.cend()) ? (\*max\_it) : (nullptr);
}
return reinterpret\_cast(header\_address) + HEADER\_SIZE;
}
void releaseBlock(std::uint8\_t\* block\_ptr)
{
std::uint8\_t\* header\_address = block\_ptr - HEADER\_SIZE;
const std::uint32\_t size\_relized\_block = \*header\_address;
if ( (!m\_max\_block) || (size\_relized\_block > \*m\_max\_block) ) // if the relized block is greater than the maximum, then need to replace it
{
m\_max\_block = reinterpret\_cast(header\_address);
}
m\_free\_blocks.insert(reinterpret\_cast(header\_address));
auto forward\_it = m\_free\_blocks.find(reinterpret\_cast(header\_address));
auto backward\_it = tryDefragment(forward\_it, m\_free\_blocks.end());
tryDefragment(std::make\_reverse\_iterator(backward\_it), m\_free\_blocks.rend());
}
private:
template
constexpr DstIterator getIterator(SrcIterator it) const
{
using iterator = std::set::iterator;
using reverse\_iterator = std::set::reverse\_iterator;
if constexpr ( (std::is\_same\_v) && (std::is\_same\_v) )
{
return std::make\_reverse\_iterator(it);
}
else if constexpr ( (std::is\_same\_v) && (std::is\_same\_v) )
{
return it.base();
}
else
{
return it;
}
}
template
Iterator tryDefragment(Iterator start\_it, Iterator end\_it)
{
// primitive defragmentation algorithm - connects two neighboring
// free blocks into one with linear complexity
auto current\_it = start\_it++;
auto next\_it = start\_it;
std::uint32\_t\* current\_header\_address = \*current\_it;
if ( (current\_it != end\_it) && (next\_it != end\_it) )
{
std::uint32\_t\* next\_header\_address = \*next\_it;
const std::uint32\_t current\_block\_size = \*current\_header\_address;
const std::uint32\_t\* available\_current\_block\_address =
reinterpret\_cast(reinterpret\_cast(current\_header\_address) + HEADER\_SIZE + current\_block\_size);
if (available\_current\_block\_address == next\_header\_address)
{
const std::uint32\_t next\_block\_size = \*next\_header\_address;
const std::uint32\_t new\_current\_block\_size = current\_block\_size + HEADER\_SIZE + next\_block\_size;
\*current\_header\_address = new\_current\_block\_size;
if (new\_current\_block\_size > \*m\_max\_block)
{
m\_max\_block = reinterpret\_cast(current\_header\_address);
}
auto delete\_it = getIterator::iterator>(next\_it);
return getIterator(m\_free\_blocks.erase(delete\_it));
}
}
return current\_it;
}
public:
std::vector m\_blocks;
std::set m\_free\_blocks;
std::uint32\_t\* m\_max\_block;
};
}
```
Теперь немного о том, как можно украсить использование аллокаторов вместе со стандартными контейнерами:
```
template
using CustomAllocator = Allocator>;
template
using CustomAllocatorWithStackChunks = Allocator>;
template
using CustomAllocatorWithHeapChunks = Allocator>;
template
using custom\_vector = std::vector>;
template
using custom\_list = std::list>;
template
using custom\_set = std::set, CustomAllocator>;
template
using custom\_unordered\_set = std::unordered\_set, std::equal\_to, CustomAllocator>;
template
using custom\_map = std::map, CustomAllocator>>;
template
using custom\_unordered\_map = std::unordered\_map, std::equal\_to, CustomAllocator>>;
using custom\_string = std::basic\_string, CustomAllocator>;
```
Можно также использовать аллокаторы и с умными указателями, но для этого придется написать небольшую прослойку:
```
template
using custom\_unique\_ptr = std::unique\_ptr>;
template
custom\_unique\_ptr make\_custom\_unique(Allocator allocator, Args&&... args)
{
const auto custom\_deleter = [allocator](T\* ptr) mutable
{
allocator.destroy(ptr);
allocator.deallocate(ptr, 1u);
};
void\* memory\_block = allocator.allocate(1u);
if (memory\_block)
{
T\* object\_block = static\_cast(memory\_block);
allocator.construct(object\_block, std::forward(args)...);
return custom\_unique\_ptr{ object\_block, custom\_deleter };
}
return nullptr;
}
```
Ну и теперь, наконец, пример использования всего этого:
```
int main(int argc, char** argv)
{
CustomAllocationStrategy allocation_area{};
CustomAllocator custom\_int\_allocator{ allocation\_area };
custom\_vector vector{ custom\_int\_allocator };
for (int i = 0u; i < 100; ++i)
{
vector.push\_back(i);
std::cout << vector.at(i) << " ";
}
vector.resize(16u);
for (int val : vector)
{
std::cout << val << " ";
}
CustomAllocator custom\_int\_allocator\_copy = vector.get\_allocator();
custom\_unique\_ptr ptr1 = make\_custom\_unique>(custom\_int\_allocator\_copy, 100);
custom\_unique\_ptr ptr2 = make\_custom\_unique>(custom\_int\_allocator\_copy, 500);
custom\_unique\_ptr ptr3 = make\_custom\_unique>(custom\_int\_allocator\_copy, 1000);
custom\_unique\_ptr ptr4 = make\_custom\_unique>(custom\_int\_allocator\_copy, 1500);
std::cout << \*ptr1 << " " << \*ptr2 << " " << \*ptr3 << " " << \*ptr4 << " ";
CustomAllocator custom\_float\_allocator { custom\_int\_allocator };
custom\_list list{ { 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f }, custom\_float\_allocator };
for (float val : list)
{
std::cout << val << " ";
}
CustomAllocator> custom\_pair\_allocator{ allocation\_area };
custom\_map map{ { { 1.0, 100.0 }, { 2.0, 200.0 } }, custom\_pair\_allocator };
for (const auto& it : map)
{
std::cout << "{" << it.first << " : " << it.second << "} ";
}
CustomAllocator custom\_double\_allocator{ allocation\_area };
custom\_set set{ { 1000.0, 2000.0, 3000.0 }, custom\_double\_allocator };
for (double val : set)
{
std::cout << val << " ";
}
CustomAllocator custom\_char\_allocator{ allocation\_area };
custom\_string string1{ "First allocated string without SBO ", custom\_char\_allocator };
custom\_string string2{ "Second allocated string without SBO ", custom\_char\_allocator };
custom\_string string3{ "Third allocated string without SBO ", custom\_char\_allocator };
custom\_string result\_string = string1 + string2 + string3;
std::cout << result\_string;
return EXIT\_SUCCESS;
}
```
Хотелось бы заострить внимание на том, что данная реализация является самой примитивной, но она может быть без проблем расширена в ту сторону, которая вам необходима, поэтому все в ваших руках!
---
Заключение
----------
Спасибо за внимание, очень надеюсь, что данная статья оказалась кому-то полезной. Также желаю всем успехов в тесном взаимодействии с памятью, и самое главное, не забывать очень важные слова Дональда Кнута: «*Преждевременная оптимизация — корень всех зол*».
Ссылка на [репозиторий](https://github.com/VladimirBalun/std_allocators) с полной реализацией аллокатора.
---
Используемые источники
----------------------
1. [habr.com/ru/post/274827](https://habr.com/ru/post/274827/)
2. [github.com/mtrebi/memory-allocators](https://github.com/mtrebi/memory-allocators) | https://habr.com/ru/post/505632/ | null | ru | null |
# Single Responsibility Principle. Не такой простой, как кажется
 Single responsibility principle, он же принцип единой ответственности,
он же принцип единой изменчивости — крайне скользкий для понимания парень и столь нервозный вопрос на собеседовании программиста.
Первое серьезное знакомство с этим принципом состоялось для меня в начале первого курса, когда молодых и зеленых нас вывезли в лес, чтобы сделать из личинок студентов — студентов настоящих.
В лесу нас разделили на группы по 8-9 человек в каждой и устроили соревнование — какая группа быстрее выпьет бутылку водки при условии, что первый человек из группы наливает водку в стакан, второй выпивает, а третий закусывает. Выполнивший свою операцию юнит встает в конец очереди группы.
Случай, когда размер очереди был кратен трем, и являлся хорошей реализацией SRP.
Определение 1. Единая ответственность.
--------------------------------------
Официальное определение принципа единой ответственности (SRP) говорит о том, что у каждого объекта есть своя ответственность и причина существования и эта ответственность у него только одна.
Рассмотрим объект "Выпивоха" (**Tippler**).
Для выполнения принципа SRP разделим обязанности на троих:
* Один наливает (**PourOperation**)
* Один выпивает (**DrinkUpOperation**)
* Один закусывает (**TakeBiteOperation**)
Каждый из участников процесса ответственен за одну компоненту процесса, то есть имеет одну атомарную ответственность — выпить, налить или закусить.
Выпивоха же, в свою очередь является фасадом для данных операций:
```
сlass Tippler {
//...
void Act(){
_pourOperation.Do() // налить
_drinkUpOperation.Do() // выпить
_takeBiteOperation.Do() // закусить
}
}
```
#### Зачем?
Человек-программист пишет код для человека-обезьяны, а человек-обезьяна невнимателен, глуп и вечно куда-то спешит. Он может удержать и понять около 3 — 7 термов в один момент времени.
В случае выпивохи этих термов три. Однако если мы напишем код одной простыней, то в нем появятся руки, стаканы, мордобои и бесконечные споры о политике. И все это будет в теле одного метода. Уверен — вы видели такой код в своей практике. Не самое гуманное испытание для психики.
С другой стороны, человек-обезьяна заточен на моделирование объектов реального мира в своей голове. В своем воображении он может их сталкивать, собирать из них новые объекты и точно так же разбирать. Представьте себе старую модель машины. Вы можете в воображении открыть дверь, открутить обшивку двери и увидеть там механизмы стеклоподъемников, внутри которых будут шестерни. Но вы не можете увидеть все компоненты машины одновременно, в одном "листинге". По крайней мере "человек-обезьяна" не может.
Поэтому человеки-программисты декомпозируют сложные механизмы на набор менее сложных и работающих элементов. Однако, декомпозировать можно по-разному: во многих старых машинах — воздуховод выходит в дверь, а в современных — сбой электроники замка не дает запуститься двигателю, что доставляет при ремонте.
Так вот, **SRP — это принцип, объясняющий КАК декомпозировать, то есть где провести линию разделения**.
Он говорит, что декомпозировать надо по принципу разделения "ответственности", то есть по задачам тех или иных объектов.
Вернемся к выпивохе и плюсам, которые получает человек-обезьянка при декомпозировании:
* Код стал предельно ясен на каждом уровне
* Код могут писать несколько программистов сразу (каждый пишет отдельный элемент)
* Упрощается автоматическое тестирование — чем проще элемент, тем легче его тестировать
* Из этих трех операций, в будущем, вы сможете сложить обжору ( используя только **TakeBitOperation**), Алкоголика (используя только **DrinkUpOperation** напрямую из бутылки) и удовлетворить многие другие требования бизнеса.
И, конечно же, минусы:
* Придется создать больше типов.
* Выпивоха впервые выпьет на пару часов позже, чем мог бы
Определение 2. Единая изменчивость.
-----------------------------------
Позвольте господа! Класс выпивохи же также выполняет единую ответственность — он выпивает! И вообще, слово "ответственность" — понятие крайне размытое. Кто-то ответственен за судьбу человечества, а кто-то ответственен за поднимание опрокинутых на полюсе пингвинов.
Рассмотрим две реализации выпивохи. Первая, указанная выше, содержит в себе три класса — налить, выпить и закусить.
Вторая, написана через методологию "Вперед и только вперед" и содержит всю логику в методе **Act**:
```
//Не тратьте время на изучение этого класса. Лучше съешьте печеньку
сlass BrutTippler {
//...
void Act(){
// наливаем
if(!_hand.TryDischarge(from:_bottle, to:_glass, size:_glass.Capacity))
throw new OverdrunkException();
// выпиваем
if(!_hand.TryDrink(from: _glass, size: _glass.Capacity))
throw new OverdrunkException();
//Закусываем
for(int i = 0; i< 3; i++){
var food = _foodStore.TakeOrDefault();
if(food==null)
throw new FoodIsOverException();
_hand.TryEat(food);
}
}
}
```
Оба этих класса, с точки зрения стороннего наблюдателя, выглядят абсолютно одинаково и выполняют единую ответственность "выпить".
Конфуз!
Тогда мы лезем в интернет и узнаем другое определение SRP — Принцип единой изменчивости.
Это определение гласит, что "**У модуля есть один и только один повод для изменения**". То есть "Ответственность — это повод для изменения".
Теперь все встает на свои места. Отдельно можно изменять процедуры наливания, выпивания и закусывания, а в самом выпивохе мы можем поменять только последовательность и состав операций, например, переместив закуску перед выпиванием или добавив чтение тоста.
В подходе "Вперед и только вперед", все что можно поменять — меняется только в методе **Act**. Это может быть читабельно и эффективно в случае, когда логики немного и она редко меняется, но зачастую это кончается ужасными методами по 500 строк в каждом, с количеством if -ов большим, чем требуется для вступления России в нато.
Определение 3. Локализация изменений.
-------------------------------------
Выпивохи часто не понимают, почему они проснулись в чужой квартире, или где их мобильный. Пришло время добавить подробную логировку.
Начнем логировку с процесса наливания:
```
class PourOperation: IOperation{
PourOperation(ILogger log /*....*/){/*...*/}
//...
void Do(){
_log.Log($"Before pour with {_hand} and {_bottle}");
//Pour business logic ...
_log.Log($"After pour with {_hand} and {_bottle}");
}
}
```
Инкапсулировав ее в **PourOperation**, мы поступили мудро с точки зрения ответственности и инкапсуляции, но вот с принципом изменчивости у нас теперь конфуз. Помимо самой операции, которая может меняться, изменчивой становится и сама логировка. Придется разделять и делать специальный логировщик для операции наливания:
```
interface IPourLogger{
void LogBefore(IHand, IBottle){}
void LogAfter(IHand, IBottle){}
void OnError(IHand, IBottle, Exception){}
}
class PourOperation: IOperation{
PourOperation(IPourLogger log /*....*/){/*...*/}
//...
void Do(){
_log.LogBefore(_hand, _bottle);
try{
//... business logic
_log.LogAfter(_hand, _bottle");
}
catch(exception e){
_log.OnError(_hand, _bottle, e)
}
}
}
```
Дотошный читатель заметит, что **LogAfter**, **LogBefore** и **OnError** также могут меняться по отдельности, и по аналогии с предыдущими действиями создаст три класса: **PourLoggerBefore**, **PourLoggerAfter** и **PourErrorLogger**.
А вспомнив, что операций для выпивохи три — получаем девять классов логирования. В итоге весь выпивоха состоит из 14 (!!!) классов.
Гипербола? Едва ли! Человек-обезьянка с декомпозиционной гранатой раздробит “наливателя” на графин, стакан, операторы наливания, сервис подачи воды, физическую модель столкновения молекул и следующий квартал будет пытаться распутать зависимости без глобальных переменных. И поверьте — он не остановится.
Именно на этом моменте многие приходят к выводу, что SRP — это сказки из розовых королевств, и уходят вить лапшу...
… так и не узнав о существовании третьего определения Srp:
"**Схожие для изменения вещи должны храниться в одном месте**". или “**То, что изменяется вместе, должно храниться в одном месте**”
То есть, если мы меняем логировку операции, то мы должны это менять в **одном** месте.
Это очень важный момент — так как все объяснения SRP, которые были выше, говорили о том, что надо дробить типы, пока они дробятся, то есть накладывало "ограничение сверху" на размер объекта, а теперь мы говорим уже и об "ограничении снизу". Иными словами, **SRP не только требует "дробить пока дробится", но и не перестараться — "не раздробить сцепленные вещи"**. Не усложнять без надобности. Это великая битва бритвы Оккама с человеком-обезьяной!
Теперь выпивохе должно стать полегче. Помимо того, что не надо дробить логировщик IPourLogger на три класса, мы также можем объединить все логировщики в один тип:
```
class OperationLogger{
public OperationLogger(string operationName){/*..*/}
public void LogBefore(object[] args){/*...*/}
public void LogAfter(object[] args){/*..*/}
public void LogError(object[] args, exception e){/*..*/}
}
```
И если нам добавится четвертый тип операции, то для нее уже готова логировка. А код самих операций чист и избавлен от инфраструктурного шума.
В результате у нас 5 классов для решения задачи выпивания:
* Операция наливания
* Операция выпивания
* Операция заедания
* Логировщик
* Фасад выпивохи
Каждый из них отвечает строго за одну функциональность, имеет одну причину для изменения. Все схожие для изменения правила лежат рядом.
Примеры из реальной жизни
-------------------------
**Сериализация и десериализация**В рамках разработки протокола передачи данных нужно сделать сериализацию и десериализацию некоторого типа "User" в строку.
```
User{
String Name;
Int Age;
}
```
Можно подумать, что сериализацию и десериализацию нужно делать в отдельных классах:
```
UserDeserializer{
String deserialize(User){...}
}
UserSerializer{
User serialize(String){...}
}
```
Так как у каждого из них есть своя ответственность и один повод для изменения.
Но повод для изменения у них общий — "изменение формата сериализации данных".
И при изменение этого формата всегда будут меняться и сериализация и десериализация вместе.
Согласно принципу локализации изменений мы должны объединить их в один класс:
```
UserSerializer{
String deserialize(User){...}
User serialize(String){...}
}
```
Это избавиляет нас от излишней сложности, и необходимости помнить, что при каждом изменении сериализатора, нужно помнить и о десериализаторе.
**Посчитай и сохрани**Необходимо посчитать годовую выручку компании и сохранить ее в файл C:\results.txt.
Быстро решаем это при помощи одного метода:
```
void SaveGain(Company company){
//Код по подсчету выручки компании
//и сохранению результатов
}
```
Уже из определения задачи видно, что есть две подзадачи -"Посчитать выручку" и "Сохранить выручку". Каждая из них имеет по одному поводу для изменений — "изменене методики подсчета" и "изменение формата сохранения". Эти изменения никак не пересекаются. Так же, мы не можем односложно ответить на вопрос — "что делает метод SaveGain?". Этот метод **И** считает выручку **И** сохраняет результаты.
Потому нужно разделить этот метод на два:
```
Gain CalcGain(Company company){..}
void SaveGain(Gain gain){..}
```
Плюсы:
* можно отдельно протестировать CalcGain
* проще локализовать баги и вносить изменения
* повысилась читабельность кода
* уменьшился риск ошибки в каждом из методов из-за их упрощения
**Сложная бизнес логика**Однажды мы писали сервис автоматической регистрации b2b клиента. И появился GOD -метод на 200 строк подобного содержимого:
* Сходи в 1С и заведи счет
* С этим счетом сходи к платежному модулю и заведи его там
* Проверь, что аккаунт с таким счетом не создан в главном сервере
* Создай новый аккаунт
* Результат регистрации в платежном модуле и номер 1с добавь в сервис результатов регистрации
* Добавь в эту таблицу информацию об аккаунте
* Создай номер точки для этого клиента в сервисе точек. Передай в этот сервис номер счета 1с.
В этом списке было еще около 10-ти бизнес операций с жуткой связанностью. Объект счета нужен был почти всем. Идентификатор точки и имя клиента нужны были в половине вызовов.
После часового рефакторинга, мы смогли отделить инфраструктурный код и некоторые нюансы работы с аккаунтом в отдельные методы/классы. God метод полегчал, но осталось 100 строк кода, которые распутываться никак не хотели.
Лишь через несколько дней пришло понимание, что суть этого "полегчавшего" метода — и есть бизнес алгоритм. И что изначальное описание ТЗ было довольно сложным. И именно попытка разбить на куски этот метод будет нарушением SRP, а не наоборот.
Формализм.
----------
Пришло время оставить в покое нашего выпивоху. Вытрите слезы — мы обязательно вернемся к нему как-нибудь. А сейчас формализуем знания из этой статьи.
#### Формализм 1. Определение SRP
1. Разделяйте элементы так, чтобы каждый из них был ответственен за что-то одно.
2. Ответственность расшифровывается как "повод для изменения". То есть каждый элемент имеет только один повод для изменения, в терминах бизнес логики.
3. Потенциальные изменения бизнес логики. должны быть локализованы. Изменяемые вместе элементы должны быть рядом.
#### Формализм 2. Необходимые критерии самопроверки.
Мне не встречались достаточные критерии выполнения SRP. Но есть необходимые условия:
1) Задайте себе вопрос — что делает этот класс/метод/модуль/сервис. вы должны ответить на него простым определением. ( благодарю [Brightori](https://habr.com/ru/users/brightori/) )
**пояснения**Впрочем иногда подобрать простое определение очень сложно
2) Фикс некоторого бага или добавление новой фичи затрагивает минимальное количество файлов/классов. В идеале — один.
**пояснения**Так как ответственность (за фичу или баг) инкапсулированна в одном файле/классе, то вы точно знаете где искать и что править. Например: фича изменения вывода логировки операций потребует изменить только логировщик. Бегать по всему остальному коду не требуется.
Другой пример — добавление нового UI-контрола, схожего с предыдущими. Если это заставляет вас добавить 10 разных сущностей и 15 разных конвертеров — кажется, вы “передробили”.
3)Если несколько разработчиков работают над разными фичами вашего проекта, то вероятность мердж -конфликта, то есть вероятность того, что один и тот же файл/класс будет изменен у нескольких разработчиков одновременно — минимальна.
**пояснения**Если при добавлении новой операции "Вылить водку под стол" вам нужно затронуть логировщик, операцию выпивания и выливания — то похоже, что ответственности разделены криво. Безусловно, это не всегда возможно, но нужно стараться снизить этот показатель.
4) При уточняющем вопросе про бизнес логику (от разработчика или менеджера) вы лезете строго в один класс/файл и получаете информацию только от туда.
**пояснения**Фичи, правила или алгоритмы компактно написаны каждая в одном месте, а не разбросаны флагами по всему пространству кода.
5) Нейминг понятен.
**пояснения**Наш класс или метод ответственен за что-то одно, и ответственность отражена в его названии
AllManagersManagerService — скорее всего, God-класс
LocalPayment — вероятно, нет
#### Формализм 3. Методика разработки "Оккама-first".
В начале проектирования, человек-обезьянка не знает и не чувствует всех тонкостей решаемой задачи и может дать маху. Ошибаться можно по разному:
* Сделать слишком большие объекты, склеив разные ответственности
* Передробить, разделив единую ответственность на много разных типов
* Неверно определить границы ответственности
Важно запомнить правило: "ошибаться лучше в большую сторону", или "не уверены — не дробите". Если, например, ваш класс собирает в себе две ответственности — то он по прежнему понятен и его можно распилить на два с минимальным изменением клиентского кода. Собирать же из осколков стекла стакан, как правило, сложнее из-за размазанного по нескольким файлам контекста и отсутствия необходимых зависимостей в клиентском коде.
Пора закругляться
-----------------
Сфера применения SRP не ограничивается ООП и SOLID. Он применим к методам, функциям, классам, модулям, микросервисам и сервисам. Он применим как к “фигакс-фигакс-и-в-прод”, так и к “рокет-сайнс” разработке, везде делая мир чуточку лучше. Если задуматься, то это едва ли не фундаментальный принцип всей инженерии. Машиностроение, системы управления, да и вообще все сложные системы — строятся из компонентов, и “недодробление” лишает конструкторов гибкости, “передробление” — эффективности, а неверные границы — разума и душевного спокойствия.
SRP не выдуман природой и не является частью точной науки. Он вылезает из наших с вами биологических и психологических ограничений.Это всего лишь способ контролировать и развивать сложные системы при помощи мозга человека-обезьяны. Он рассказывает нам, как декомпозировать систему. Изначальная формулировка требовала изрядного навыка телепатии, но надеюсь, эта статья слегка развеяла дымовую завесу. | https://habr.com/ru/post/454290/ | null | ru | null |
# Статический анализ и property-based тестирование: вместе мы сила
 Как известно, баги есть во всех программах. Есть множество способов борьбы с ними: юнит-тесты, ревью, статический анализ, динамический анализ, дымовое тестирование и так далее. Иногда для искоренения определённого бага полезно сочетать разные методики.
Я разрабатываю Java-инспекции в IntelliJ IDEA, которая большей частью написана на Java. В некотором смысле я нахожусь в привилегированном положении по сравнению с другими программистами: доработать статический анализатор IDE, чтобы находить новый класс ошибок — это моя прямая рабочая обязанность, которая при этом же позволяет найти и обезвредить баги в этой же самой IDE. Хочу поделиться одной такой историей успеха.
В начале октября коллега мне скинул отчёт с зависшим [property-based-тестом](http://hypothesis.works/articles/what-is-property-based-testing/). Этот тест делает примерно следующее: открывает случайный Java-файл из исходников IDEA, делает некоторые случайные правки, ставит курсор в случайное место, применяет какой-нибудь случайный quick-fix, который в данном месте доступен и тому подобное. Такую штуку коллеги сделали на летнем хакатоне и благодаря ей удалось выловить и обезвредить много багов в инспекциях до того как о них сообщили пользователи. Также воспроизвелись ошибки, о которых когда-то сообщали пользователи, но они почему-то не воспроизводились у нас. В общем, очень полезная штука. Если кому-то интересно, исходники все доступны в community-версии IDEA на [GitHub](https://github.com/JetBrains/intellij-community/blob/282e4ff321a0d0014e977c5602f1baee80a148f1/java/java-tests/testSrc/com/intellij/java/propertyBased/JavaCodeInsightSanityTest.java#L51).
Так вот, отчёт. Тест упал по таймауту, но он выдаёт начальное значение генератора псевдослучайных чисел, по которому можно воспроизвести поведение. Посмотрев стек-трейс, удалось выяснить, что тест завис в довольно простом [бесконечном цикле](https://github.com/JetBrains/intellij-community/blob/f73a5572c092c04a95793836d4a501b81a08eb94/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/performance/StringConcatenationInLoopsInspection.java#L179) внутри инспекции, сообщающей о конкатенации строк в цикле:
```
PsiElement parent = PsiUtil.skipParenthesizedExprUp(expression.getParent());
while (parent instanceof PsiTypeCastExpression ||
parent instanceof PsiConditionalExpression) {
parent = PsiUtil.skipParenthesizedExprUp(expression.getParent());
}
```
Давайте я расскажу, зачем нужен этот цикл. Конкатенация строк в цикле, как известно, вредна, и часто заменима на StringBuilder. Однако в некоторых случаях предупреждать о такой конкатенации смысла нет. Например, если после каждой конкатенации текущий результат используется:
```
String dots = "";
for(int i=0; i<10; i++) {
dots += ".";
pacman.eatSomeDots(dots);
}
```
Никакого смысла заменять на `StringBuilder` здесь нет, так как каждая промежуточная строка нужна для передачи в метод. Оптимизировать если и можно, то нетривиально. Вот тут (а точнее чуть ниже) мы и проверяем, как используются вхождения ссылок на строковую переменную. Здесь `expression` — это очередная ссылка на строку в исходном тексте анализируемой программы (в нашем примере — параметр метода `eatSomeDots`). Понятно, если мы вызовем `eatSomeDots((dots))`, или `eatSomeDots((String)(dots))`, или даже `eatSomeDots(flag ? dots : "***")`, то строку `dots` всё равно стоит считать всегда используемой. Поэтому мы и поднимаемся по иерархии выражений вверх, пропуская возможные скобки, приведения типов (PsiTypeCastExpression) и условные операторы (PsiConditionalExpression).
Однако в цикл вкралась банальная опечатка: внутри должно быть не `parent = PsiUtil.skipParenthesizedExprUp(expression.getParent());`, а `parent = PsiUtil.skipParenthesizedExprUp(parent.getParent());`. Получилась неприятная ситуация: если всё-таки условие цикла истинно, то `parent` переприсваивается тому же значению, которое и так имел, в результате чего цикл становится бесконечным.
Иронично, что код, предназначение которого — бороться с проблемами производительности в циклах, сам содержит проблему в цикле, хоть и совсем иного толка. Это не заметили на ревью и почему-то оказалось, что такой случай не покрыт юнит-тестом. Это неприятно. Код я, конечно, [исправил](https://github.com/JetBrains/intellij-community/commit/8e19d90cd752fb8385f41706d2d4e36319f108ba#diff-c06bda8ab87602ddc556cd8fb5e8146d) и юнит-тест написал. Стоит ли на этом остановиться? Нет, каждую ошибку надо проанализировать на предмет того, почему она возникла, почему оставалась незамеченной и что мы можем сделать, чтобы ситуация не повторилась.
Не было подходящего юнит-теста, значит, в тестах в тело цикла никогда не заходили — это плохо. Следили бы регулярно за code coverage, такой проблемы вероятно удалось бы избежать сразу. Но просто так начать требовать 100% покрытия тестами тоже дорога в никуда. Ревью было, это хорошо, но такую ошибку легко проморгать, возлагать вину на ревьювера тоже неправильно. То что property-based-тест отловил это, причём раньше пользователей — вообще отлично. Значит, такие тесты действительно полезная штука и мы не зря их сделали. Но меня, как автора IDE, обеспокоил другой вопрос: почему ни одна из наших инспекций не могла предупредить о такой ошибке? Можно ли написать инспекцию, которая пометит этот код? Или может улучшить существующую?
У нас имеется несколько инспекций, которые позволяют обнаружить бесконечные циклы. Например, если бы переменная `parent` не присваивалась в цикле, то могла бы сработать инспекция «Loop variable is not updated inside loop». Но она присваивается. Если бы условие было заведомо всегда истинным, сработала бы инспекция «Constant conditions & exceptions». Но оно может быть и ложным, если мы ни разу не войдём в цикл. Интересно, что методы `skipParenthesizedExprUp` и `getParent` не имеют видимых побочных эффектов, и анализатор знает об этом, потому что они помечены аннотацией `@Contract(pure = true)`. Также условие цикла не имеет побочного эффекта. Выходит, что весь побочный эффект одной итерации цикла — это присваивание в локальную переменную `parent`.
Назовём побочный эффект, который изменяет только локальные переменные (сами переменные, а не, например, поля объектов, на которые ссылаются эти переменные) «локальным побочным эффектом», а всякий прочий побочный эффект — нелокальным. Локальный побочный эффект может повлиять только на поведение текущего метода. Если у цикла есть только локальный побочный эффект, а его условие побочных эффектов не имеет вовсе, соберём все переменные, в которые осуществляется запись за время одной итерации цикла. В нашем случае это только переменная `parent`. Напомню, тело цикла выглядит так:
```
parent = PsiUtil.skipParenthesizedExprUp(expression.getParent());
```
Теперь посмотрим, используется ли значение этой переменной до факта присваивания. Это мы умеем делать с помощью простого анализа потока управления. Это вообще необходимая операция для выдачи правильных сообщений об ошибках в Java: если локальная переменная используется до первого присваивания, такая Java-программа считается некорректной. Но мы можем этот анализ применить только к телу нашего цикла. Если записываемая в теле переменная используется до присваивания, значит, значение с прошлой итерации влияет на следующую итерацию. Иначе следующая итерация сделает то же самое, что и предыдущая, и новых эффектов от последующих итераций мы не получим!
В нашем цикле ситуация довольно простая: значение `parent` с предыдущей итерации в теле цикла не используется вообще. Однако такой подход позволит отловить более сложные случаи. Например, представьте, что в цикле записывается другая переменная:
```
PsiExpression immediateParent = null;
while (parent instanceof PsiTypeCastExpression ||
parent instanceof PsiConditionalExpression) {
immediateParent = expression.getParent();
parent = PsiUtil.skipParenthesizedExprUp(immediateParent);
}
```
Теперь мы записываем две переменные и одну из них во время итерации читаем. Но читаем гарантированно после того она была записана, а значит, значение с предыдущей итерации мы всё равно никогда не используем.
Как охарактеризовать такой цикл? Цикл без побочных эффектов? Но побочный эффект есть. Проблема в том, что этот эффект после первой итерации всегда одинаков. То есть либо мы в цикл не зайдём вообще, либо выполним одну итерацию. Если же после первой итерации условие цикла останется истинным, то ничего нового на последующих итерациях не произойдёт, и мы зациклимся. Тут у меня в голове всплыло слово «[идемпотентность](https://ru.wikipedia.org/wiki/%D0%98%D0%B4%D0%B5%D0%BC%D0%BF%D0%BE%D1%82%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C)». Тело такого цикла идемпотентно: повторное выполнение тела не даёт никакого эффекта. Так и появилась новая инспекция «[Idempotent loop body](https://github.com/JetBrains/intellij-community/blob/5bed8f61eb5aed8177ad5a8f2a37ffae60faac8c/java/java-impl/src/com/intellij/codeInspection/IdempotentLoopBodyInspection.java)».
Мы убедились, что инспекция подсвечивает изначальный ошибочный цикл. Однако стоит проверить, что ещё она подсвечивает и не даёт ли ложных сработок. Ложные сработки могут свести на нет всю пользу инспекции, такая инспекция будет только раздражать, и её выключат. На исходном коде IDEA Ultimate нашлось ещё четыре сработки и оказалось, что они все правильные: это действительно четыре потенциально бесконечных цикла. Вот такая тривиальная ошибка, например, обнаружилась в рефакторинге, конвертирующем Groovy в Java:
```
private static String getNewFileName(GroovyFile file) {
...
String prefix = FileUtil.getNameWithoutExtension(file.getName());
String fileName = prefix + ".java";
int index = 1;
while (fileNames.contains(fileName)) {
fileName = prefix + index + ".java";
}
return fileName;
}
```
Довольно стандартный код для генерации уникального имени файла. Вообще странно, что он написан прямо в коде рефакторинга. По хорошему для этого должно быть переиспользуемое утилитное решение. Кстати, ещё один способ избегать багов — не изобретать велосипеды. Лучше отладить единственный эталонный велосипед и всем на нём ездить.
В коде, очевидно, ошибка, которая как раз описывается нашим сценарием. Если файла с именем `prefix + ".java"` нет, то это имя и будет использовано. Если файл с таким именем есть, то будет сгенерировано имя `prefix + "1.java"`. А вот если и такой файл есть, то у нас случится бесконечный цикл, потому что последующие итерации не дадут новых эффектов (здесь эффект — это изменение `fileName`). Вероятно первые два случая протестировали, а третий пропустили. [Исправление](https://github.com/JetBrains/intellij-community/commit/5993d859f6ad866b6c9d091c13fa459b6caeb1da#diff-f2d7bf9fe3d77999a1150ada93905a1eR151) довольно простое — надо увеличивать переменную `index` в цикле.
Эта история показала, как важно анализировать найденную ошибку. Property-based-тест выявил один бесконечный цикл, это хорошо. Но такие тесты тоже покрывают не всё. В данном случае оказалось, что ошибку можно также находить статически и после соответствующей доработки статического анализатора мы нашли ещё четыре подобных ошибки. Значит ли это, что статический анализ в пять раз лучше property-based-тестов? Нет, ведь без теста мы бы вообще не узнали об этой проблеме (по крайней мере, пока пользователи на неё не наткнулись). Кроме того, property-based-тест может найти ошибки, которые вообще не опишешь статическими правилами. Различные методики поиска и предотвращения ошибок сильны, когда они работают вместе. Если задуматься, как обнаружить найденную ошибку статически, можно сэкономить много времени и сил в будущем. Конечно, не каждый может легко доработать статический анализатор. Но простые случаи можно искать в IDEA с помощью [Structural search](https://www.jetbrains.com/help/idea/structural-search-and-replace-examples.html) (вы можете и инспекцию настроить, чтобы она вам ваш собственный шаблон подсвечивала). Если же вы напоролись на более сложную, но потенциально формализуемую ситуацию, вы всегда можете подкинуть идею в официальный баг-трекер вашей IDE.
Инспекция «Idempotent loop body» доступна в [EAP-версиях](https://blog.jetbrains.com/idea/2018/01/intellij-idea-starts-2018-1-early-access-program/) IDEA 2018.1, поэтому вы можете попробовать её уже сейчас. Программируйте с удовольствием! | https://habr.com/ru/post/347676/ | null | ru | null |
# Клавиатурный шпион на Arduino
#### Предисловие
Стоит сказать, что область применение данного устройства не так уж и велика. Для работы это мониторинг, контроль за рабочим временем, защита от утечки информации и, наверное, всё.
В быту эта вещь может хорошо облегчить жизнь. Например, нажали определённое сочетание клавиш — Arduino их распознало и… послало сигнал включить чайник. Если не чайник, то что-нибудь другое.
Но всё же, это банальное слежение (возможно, даже скрытое) за сотрудником, что с моральной точки зрения не есть хорошо. Но всё же, юридическая справка даёт «добро», если это прописано в трудовом договоре, если этот мониторинг происходит в трудовое время и на рабочем месте и если, конечно, сотрудник проинформирован и поставил свою галочку.
Ну а в личной жизни вы вольны делать всё, что захочется, пока это касается вашей собственности.
Всё, юридически мы защищены, теперь я расскажу и покажу, что нам необходимо и как собрать вместе, чтобы получился простой перехватчик нажатий клавиш с клавиатуры.
#### Начнём
Итак, нам понадобится десяток проводов и две платы:
1) [Arduino Leonardo](https://www.arduino.cc/en/Main/ArduinoBoardLeonardo)
2) [USB Host Shield](https://www.arduino.cc/en/Main/ArduinoUSBHostShield)
Почему Arduino Leonardo? Потому что она относительно дешёвая и в отличие от своих предшественников на ATmega32u4 имеет встроенную поддержку для USB соединения.
USB протокол определяет два типа устройств: хост (master, server) и периферия (slave, client). USB Host Shield управляет периферийными устройствами и обеспечивает их питанием. Например, когда вы подключаете клавиатуру к ПК, то ПК — это хост, который управляет клиентом, а клиент, в данном случае, — клавиатура.
А поддерживаемой перифирии довольно много. Самые интересные из них это:
1) HID устройства: клавиатура, мышь, джойстик и т. д.
2) Игровые контроллеры
3) ADK-совместимые Android телефоны и планшеты.
А за более подробной информацией прошу на [официальный сайт](https://www.arduino.cc).
В нашем случае – это клавиатура. Она относится к классу HID устройств. HID код для клавиатуры кодируется 8 байтами:
1) 1 байт – каждый бит соответствует своему модификатору (L Ctrl, R Ctrl, L Shift, R Shift и т. д.).
2) 2 байт – зарезервирован и нам не нужен, обычно он занулён.
3) 3-8 байты – содержат коды 6ти клавиш.
Более подробно об этом можно почитать [здесь](https://ru.wikipedia.org/wiki/USB_HID).
Всё, с теорией покончено, теперь можно и схему собрать.
Кстати, очень удобная программа для рисования схем, в которой и была нарисована эта схема, [здесь](http://fritzing.org/).
Теперь стоит пояснить, что к чему.
У Arduino Leonardo есть небольшая особенность из-за которой мы не можем просто подключить её сверху: SPI разъёмы расположены на ICSP (те 6 разъёмов посередине справа) и из-за этого их приходится выводить на цифровые разъёмы USB Host Shield.
1) Жёлтый провод: пин 4 MOSI (подключён к 11 пину на USB Host shield).
2) Серый провод: пин 1 MISO (подключён к 12 пину на USB Host shield).
3) Зелёный провод: пин 3 SCK (подключён к 13 пину на USB Host shield).
Обеспечиваем питание нижними пятью проводами и одним фиолетовым:
1) Reset к Reset
2) 3.3V к 3.3V
3) 5V к 5V
4) GND к GND
5) VIN к VIN
6) Reset к D7
Теперь нам нужно подключить управляющие пины:
1) D7 к D7
2) D10 к D10
Это необходимый минимум, чтобы заставить её работать.
Так, схема есть, теперь нам нужно её как-то запрограммировать и это делается с помощью IDE от Arduino. Она совершенно бесплатна и находится в открытом доступе. Примеры программ и саму IDE можно найти на официальном сайте.
Для работы с USB Host Shield нам понадобится дополнительная библиотека ([здесь](https://github.com/felis/USB_Host_Shield_2.0)).
Сам код максимально прост:
```
#include
#include
#include
// Отправляет коды клавиш на ПК.
class KeyboardOut
{
private:
KeyReport \_keyReport; // Собственно наши 8 байт для кодировки.
void send\_report();
public:
size\_t press(uint8\_t mod, uint8\_t key);
size\_t release(uint8\_t mod, uint8\_t key);
};
KeyboardOut keyboard\_out;
// Отправляет код нажатия на компьютер.
size\_t KeyboardOut::press(uint8\_t mod, uint8\_t key) {
uint8\_t i;
\_keyReport.modifiers |= mod;
if (\_keyReport.keys[0] != key && \_keyReport.keys[1] != key &&
\_keyReport.keys[2] != key && \_keyReport.keys[3] != key &&
\_keyReport.keys[4] != key && \_keyReport.keys[5] != key) {
for (i=0; i<6; i++) {
if (\_keyReport.keys[i] == 0x00) {
\_keyReport.keys[i] = key;
break;
}
}
if (i == 6) {
return 0;
}
}
send\_report();
return 1;
}
// Отправляет код отжатия на компьютер.
size\_t KeyboardOut::release(uint8\_t mod, uint8\_t key) {
uint8\_t i;
\_keyReport.modifiers &= mod;
for (i=0; i<6; i++) {
if (0 != key && \_keyReport.keys[i] == key) {
\_keyReport.keys[i] = 0x00;
}
}
send\_report();
return 1;
}
void KeyboardOut::send\_report()
{
HID\_SendReport(2, &\_keyReport, sizeof(KeyReport)); // Отправляем код клавиши на ПК.
}
// Принимает коды клавиш с USB Host Shield.
class KeyboardIn : public KeyboardReportParser
{
protected:
void OnKeyDown (uint8\_t mod, uint8\_t key);
void OnKeyUp (uint8\_t mod, uint8\_t key);
};
KeyboardIn keyboard\_in;
// Принимает код нажатия с USB Host Shield.
void KeyboardIn::OnKeyDown(uint8\_t mod, uint8\_t key)
{
keyboard\_out.press(mod, key);
uint8\_t c = OemToAscii(mod, key); // Собственно наш символ с клавиатуры
PrintHex(key, 0x80); // А это его шестнадцатеричное представление
}
// Принимает код отжатия с USB Host Shield.
void KeyboardIn::OnKeyUp(uint8\_t mod, uint8\_t key)
{
keyboard\_out.release(mod, key);
uint8\_t c = OemToAscii(mod, key);
PrintHex(key, 0x80);
}
USB UsbHost;
HIDBoot HidKeyboard(&UsbHost);
void setup()
{
UsbHost.Init();
delay( 200 );
HidKeyboard.SetReportParser(0, (HIDReportParser\*)&keyboard\_in);
}
void loop()
{
UsbHost.Task();
}
```
Осталось только подключить через USB Arduino к ПК, а клавиатуру к USB Host Shield, загрузить программу на Arduino при помощи IDE и всё! Key Catcher готов!
Итоги:
1) Arduino даёт множество возможностей при своей низкой цене и множеству разнообразных модулей и датчиков.
2) Данное устройство может позволить превратить вашу клавиатуру в пульт управления, например, телевизором, электрочайником, лампой, только докупить пару модулей придётся. | https://habr.com/ru/post/388335/ | null | ru | null |
# ConstraintLayout 101 и новый редактор компоновок в Android Studio
Данная статья является переводом поста из блога Android-разработчицы из ЮАР Ребекки Фрэнкс [riggaroo.co.za](http://riggaroo.co.za/), подготовленным Android-отделом компании [Лайв Тайпинг](http://livetyping.com). Оригинальная статья доступна [здесь](http://riggaroo.co.za/constraintlayout-101-new-layout-builder-android-studio/).
Недавно мне посчастливилось принять участие в конференции [Google I/O](https://events.google.com/io2016/), где я познакомилась с ConstraintLayout. Я была так потрясена его возможностями, что не могла дождаться, когда приеду домой и попробую всё сама.
Что же такое ConstraintLayout?
==============================
ConstraintLayout — это новый вид layout, который вы можете использовать в ваших Android-приложениях. Эта компоновка обладает обратной совместимостью вплоть до API Level 9 и является частью Support Library. Цель ConstraintLayout — уменьшить количество иерархий layout, улучшить производительность layout, а также заменить работу с RelativeLayouts. Она совместима с другими компоновками, так что они могут прекрасно гармонировать друг с другом.
Первые шаги с ConstraintLayout
==============================
Чтобы начать работу, вам нужно скачать Android Studio 2.2 Preview 1. Помимо новой layout в комплект входит также новый Layout Editor, который, как мне сказали, пришлось создавать с нуля, потому что прежний стал совершенно бесполезным.
Теперь вам нужно добавить одну строку в раздел dependencies файла build.gradle (или Android Studio сделает это автоматически, когда вы создадите новый layout, использующий его):
```
compile'com.android.support.constraint:constraint-layout:1.0.0-alpha1'
```
Для того, чтобы воспользоваться ConstraintLayout, кликните на папку res/layout. Выберите New > Layout Resource Folder. В опции root element удалите LinearLayout и начните вводить ConstraintLayout — так вы создадите новый файл с вашей ConstraintLayout, который по умолчанию состоит из Blueprint Mode  и Design Mode  и выглядит примерно так:
Как работает новый Layout Editor
================================
### Constraints
Constraints — это правила, которые вы определяете для виджета. Constraints предоставляют опции, во многом идентичные 'toLeftOf, toRightOf' в RelativeLayouts. Также при помощи ограничений задаются выравнивания для виджетов.
Виды constraints:
=================
* ### Resize Handle
Меняйте размер виджета, растягивая его за углы 
* ### Size Constraint Handle
Маленькие кружочки, расположенные по сторонам виджета, позволяют задавать его положение внутри контейнера 
* ### Baseline Constraint Handle
Позволяет вам выровнять две строки текста в виджетах.
* ### Bias
Определяет смещение вашего виджета. Вы можете задать вертикальное или горизонтальное смещение.
Управление размерами виджета
============================
В окне Properties находится схематичное изображение, с помощью которого вы можете управлять размерами виджета. Здесь вы можете определить поля и то, как виджет будет менять свой размер, а именно:
* ### Any Size
Аналогично match\_parent. Единственное отличие в том, что эта опция подчиняется constraints.
* ### Wrap Content
Виджет будет большим настолько, насколько это необходимо, чтобы вместить всё содержимое.
* ### Fixed Size
Позволяет задать фиксированный размер виджета в dp.
Для переключения между этими типами достаточно кликнуть по одной из опций на изображении.
Вы также можете задавать смещение, перетаскивая ползунок по вертикальной или горизонтальной оси.
Autoconnect
===========
Autoconnect — это опция, которая автоматически начинает рассчитывать оптимальные значения для виджета, исходя из его местоположения.
Как только вы переместите виджет в layout, вы увидите линии, которые начнут расходиться от него в разные стороны — так работает Autoconnect. Опция включена по умолчанию и может быть выключена и включена обратно по нажатию на иконку с магнитом 
Constraints, заданные вручную
=============================
Для создания своих собственных constraints кликните по кружочку на одной из сторон виджета, который вы хотите разместить. Не отпуская кнопку мыши, прочертите линию к виджету, к которому вы хотите его привязать — как только виджет позеленеет, он создаст constraint. Вы можете удалить constraint, кликнув по нему, когда он подсвечен красным.
Inference
=========
Inference создает constraints для всех виджетов внутри вашей компоновки. Он действует наподобие Autoconnect, только он работает не с одним виджетом, редактируемым в данный момент, а со всем layout сразу. Он использует математические расчёты, чтобы определить, какие виджеты нужно привязать к другим, исходя из их местоположения на экране.
Чтобы воспользоваться Inference, нажмите иконку с лампочкой 
Кое-что ещё на заметку:
=======================
* новый layout editor работает и со старыми layout, однако некоторые опции, такие, как Inference, могут не работать;
* этот редактор создает XML-файл за вас. Но если вы не ищете лёгких путей и хотите написать XML самостоятельно — флаг вам в руки;
* Вы можете задать массу других свойств layout, например задать все значения margin по умолчанию или выровнять группу виджетов по левому краю, ширине или центру.
Что делать с моими старыми разметками? Мне нужно их переделывать?
=================================================================
Я бы не стала бросаться с головой в омут и переделывать всё на свете без особой необходимости. Если вы считаете, что ваш старый layout работает медленно или вам трудно вносить туда какие-то изменения, то, возможно, вам стоит задуматься о том, чтобы использовать ConstraintLayout. Учитывайте, что она находится в состоянии ранней альфы.
Одна из особенностей новой Android Studio состоит в том, что вы можете автоматически конвертировать старые layout в новые, использующие ConstraintLayout. Когда вы выбираете файл с вашей компоновкой и находитесь в design view, нажмите правой кнопкой мышки `>'Convert...Layout to ConstraintLayout'`.
Может быть, я делала что-то не так, но все три раза, когда я пыталась проделать эту манипуляцию, ConstraintLayout был добавлен в мой layout, но результат отличался от того, который я ожидала. Похоже, что нужно подождать какое-то время, пока разработчики окончательно допилят эту опцию.
Мои мысли:
==========
Новый layout editor и ConstraintLayout потрясли меня до глубины души. Я на самом деле думаю, что нам очень не хватало чего-то подобного. При всей своей мощности и пользе они выглядят очень простыми в освоении.
Надеюсь, что однажды из всего этого сделают отдельный инструмент, при помощи которого дизайнеры смогут создавать полноценные интерфейсы. | https://habr.com/ru/post/302106/ | null | ru | null |
# Google Chrome перестал доверять сертификатам WoSign и StartCom
Как [сообщалось ранее](https://habr.com/post/398161/) Google Chrome заблокировал сертификаты WoSign и StartCom.
Сегодня вышла новая версия Google Chrome 56, и начиная с нее браузер больше не доверяет сертификатам WoSign и StartCom выпущенным позднее `October 21, 2016 00:00:00 UTC`.
При посещении сайта с таким сертификатом выдается ошибка:
```
NET::ERR_CERT_AUTHORITY_INVALID
```
Хоть сама система считает сертификаты валидными.
Больше информации тут:
* [Distrusting WoSign and StartCom Certificates](https://security.googleblog.com/2016/10/distrusting-wosign-and-startcom.html)
Если ваши сервисы до сих пор используют бесплатные сертификаты от WoSign или StartCom, стоит всерьез задуматься над переходом на [Let's Encrypt](https://letsencrypt.org/). | https://habr.com/ru/post/400953/ | null | ru | null |
# Микро автоматизация банка [обмен данными между банком и ИФНС в исполнение 440-п ЦБ РФ]
### Или рассказ о том, что «мал золотник, да дорог»
**Этот пост Вам интересен, если:**
* Вы сотрудник Банка;
* Вы работаете в ИТ подразделения Банка;
* Задача, о которой пойдет речь, еще не автоматизирована;
* Банк обслуживает физических лиц;
* В Банке используется ПО АБС «Диасофт»;
* В Банке используется ПО КОМИТА;
* Банк ежедневно взаимодействует с ИФНС согласно 440-п ЦБ РФ.
### Интро
С этой задачей я столкнулся абсолютно случайно. Мне ее подкинул старый знакомый, сотрудник ИТ не очень крупного универсального Банка, уверенно входящего в ТОП 100, но находящийся ближе к концу данного списка. Задача относится именно к Розничному сегменту бизнеса. В Банке есть команда своих программистов, но они расписаны на несколько месяцев вперед на исполнение более крупных и приоритетных (с точки зрения «бизнеса» задач. А сама задача организации обмена согласно 440-п ЦБ РФ, упала на моего знакомого неформально, когда пользователи пожаловались на свою тяжелую внутрибанковскую жизнь и он по доброте душевной решил им помочь.
### Верхнеуровневый бизнес-процесс
Бизнес-процесс, о котором пойдет речь далее, выглядит следующим образом:
Если его тезисно описать словами, то он выглядит следующим образом:
Ежедневно, в рамках исполнения 440-п ЦБ РФ:
*(»О порядке направления в банк отдельных документов налоговых органов, а также направления банком в налоговый орган отдельных документов банка в электронной форме в случаях, предусмотренных законодательством Российской Федерации о налогах и сборах»*
ИФНС отправляет по электронной почте запросы в Банк по ФЛ (Физическим Лицам) у которых открыты счета в вашем Банке. Данные запросы попадают в Диасофт, обрабатываются там, и после этого с использованием системы защищенного документооборота КОМИТА, улетают по электронной почте обратно в ИФНС. При этом, в зависимости от клиентской базы банка, таких запросов ежедневно может приходить 100 | 1 000 | 10 000. А так же существуют штрафные санкции регулятора за непредоставление ответа и\или за несвоевременное предоставление ответа. И, понятное дело, Банк заинтересован этого избежать.
### Шаги бизнес-процесса
Алгоритм действий пользователя следующий:
* каждое утро (365 дней в году) производится выгрузка данных для отправки данных из Диасофт;
* производится шифрование и подписание файлов для отправки. Учет самих файлов для отправки по составу и количеству осуществляется в документообороте КОМИТЫ;
* т.к. АРМ обмена данными с ИФНС и сервисы банка находятся в разных сегментах сети, разделенных на физическом уровне, перенос зашифрованных и подписанных файлов производится ногами и руками сотрудника на flash-носителе в защищенную сеть Банка;
* после этого на защищенном АРМ производится создание писем в MS Outlook с файлами отчетности, Пользователь вручную создает каждое письмо с предопределенным адресом получателя, темой письма и последовательно вкладывает в письмо соответствующий архив с данными и производит отправку email.
*(безумное колличество ручной работы пользователя и отсутствие полноценной системы контроля отправок, собственно и являются предметом нашей микро-автоматизации).*
* далее производится получение квитков из ЦБ РФ обратным письмом ИФНС подтверждающим факт доставки и получения корреспонденции;
*(здесь, к сожалению, мы и не сможем их обрабатывать и учитывать, поскольку файлы ответа о факте доставки зашифрованы и содержимое их нам недоступно)*
* далее происходит обратный поток бизнес-процесса, в рамках которого производится выгрузка полученных квитков из MS Outlook в папку для переноса в рабочую сеть Банка;
* перенос файлов производится на flash-носителе, руками и ногами ответственного сотрудника Банка;
* происходит загрузка квитков в КОМИТУ, расшифровка и снятие ЭЦП;
* Комита сопоставит отправленные файлы с полученными квитками, статус документов в КОМИТЕ поменяется, все Ok.
* Подгрузка квитанций в Диасофт уже является штатной автоматизированной процедурой и не требует нашего участия.
### ROI или то, почему мы взялись за реализацию задачи
Лень, двигатель прогресса. Поэтому, перед любой автоматизацией, предполагающей затраты - сроки \ деньги, мы смотрим и пытаемся понять экономическую эффективность. Наш расчет производится через трудозатраты и ФОТ сотрудников Банка.
#### Расчетные трудозатраты персонала Банка на взаимодействие с ИФНС
Расчет выполнен исходя из получения 500 ежедневных запросов. Но, как я упомянул выше, для каждого Банка своя экономика — *ежедневно может приходить 100 | 1 000 | 10 000*. В данном случае Банк небольшой, поэтому запросов ИФНС приходит от 400 до 600 ежедневно.
### Расчёт ROI
В расчете ROI (от англ. return on investment) мы исходим из следующих допущений и ограничений:
Сама по себе задача низкоквалифицированная, но требующая внимательности и педантичности ее исполнения. Поэтому ЗП сотрудника по логике небольшая, порядка 60 000 рублей ежемесячно. Фактически не знаю, это мое предположение, но реально может быть и выше. С учетом налогов на ЗП (48%), содержание одного такого сотрудника обходится Банку в 88 800 рублей в месяц, или 1 065 600 рублей ежегодно.
Далее считаем КПД сотрудника, т.к. он не робот и это значение не может равняться 100%. Примем допущение, что это очень работоспособный и ответственный сотрудник и его КПД составляет оптимистичные 75%, хотя по факту значительно ниже. Пруф по статистике КПД находится [здесь](https://studref.com/467241/menedzhment/koeffitsient_poleznogo_deystviya_rabotnika). Таким образом, наш рассчитанный фонд трудоемкости увеличивается на 25% и составит 11,25 рабочих часов ежедневно.
Становится понятно, что для решения этой задачи банку требуются минимум 2-е штатных единицы, + 1 для резервирования, на случай отпусков и болезней. Общий годовой ФОТ группы из 3-х человек составит 88 800 х 12 х 3 = **3 196 800** рублей ежегодно. Это стоимость для Банка функции дистанционного общения с ИФНС по теме 440-П ЦБ РФ. Для упрощения оставляем за бортом человеческий фактор (ошибки отправки \ несвоевременная отправка ответов на запрос ИФНС) и как следствие репрессивные штрафы регулятора. По моей информации штрафы за одно нарушение менее 500 000 выписываются крайне редко, чаще больше.
Кстати говоря, в Диасофт есть модуль, отвечающий за решение этой простой задачи, но стоимость решений Диасофт, как моно-вендора, обычно космическая, требует затрат на приобретение ПО, внедрение и ежегодное сопровождения. Т.е. в варианте Диасофт «малой кровью» обойтись не получится.
 Таким образом сравнение возможных затрат Банка выглядит таким образом:
Опираясь на этот реалистичный расчет, мы ушли в Банк договариваться по цене и срокам разработки скрипта, а также формировать Техническое задание.
*«Хорошие люди всегда могут договориться.» Макс Фрай — Сборник Чужак*
### Техническое задание
Описание целевого бизнес-процесса автоматизации приведу кратко, выдержками из ТЗ:
1. ПАО «ХХХ Банк» обеспечивает получение входящего запроса со стороны ИФНС и обеспечивает его последовательную обработку внутри банковских систем. Результатом обработки каждого запроса ИФНС является результирующий файл, выгружаемый ответственным исполнителем банка из АБС (Диасофт).
2. Файл или набор файлов содержащий ответ на запрос ИФНС, относящихся к запросу или нескольким запросам выгружается в локальную исполнителем банка в выделенную директорию, после чего загружается в программу ПО КОМИТА с помощью которой шифруется подписывается ЭЦП.
3. Результатом исполнения п.2 является выгруженный готовый к отправке результирующий файл (архив) \ либо набор файлов, который ответственный исполнитель банка копирует на флеш-носитель информации предназначенный для физической транспортировке между сегментами сети ПАО «XXX Банк» и последующей отправки в ИФНС.
4. Ответственный исполнитель банка переносит файл \ пакет сформированных файлов с помощью флеш-носителя на АРМ IP: ХХХ.ХХ.ХХ.ХХ и перемещается посредством проводника Windows в директорию C:\IFNS\_in, запускает скрипт отправки.
5. Результатом работы запущенного скрипта является автоматизированное взаимодействие с почтовым клиентом MS Outlook, в рамках исполнения которого:
* создается электронное письмо с темой – «Отчет для ФНС» и адресом получателя fns440@ext-gate.svk.mskgtu.cdr.ru.
* происходит вложение в тело письма файла из директории C:\IFNS\_in;
* происходит отправка письма.
* при этом, в случае если в директории C:\IFNS\_in содержится набор из нескольких файлов, скриптом обеспечивается последовательная отправка каждого файла с исполнением п.п. a, b, c;
В зоне ответственности Исполнителя находится:
* Разработка Технического задания;
* Согласование Технического Задания с Заказчиком;
* Разработка скрипта с использованием языка программирования Python;
* Установка скрипта на АРМ Заказчика и его настройка, либо разработка инструкции администратора по установке скрипта на АРМ пользователя силами Заказчика;
* Разработка инструкции пользователя;
* Разработка описания скрипта для обеспечения возможности доработки скрипта исполнителями Заказчика;
* Приемка-сдача работ.
Ограничения рамок проекта:
В ответ на каждое письмо, отправленное в рамках исполнения скрипта, из ИФНС приходит ответное письмо, содержащее две вложенные квитанции:
* транспортная;
* с результатом обработки.
Данные ответные квитанции (файлы) должны быть сохранены ответственным исполнителем Банка на Flash-носителе и перемещены для целей загрузки обратно ПО КОМИТА, с целью контроля результатов отправок. Количественная и качественная сверка полученных со стороны ИФНС запросов, ответов, отправленных со стороны Банка в ИФНС производится средствами ПО КОМИТА.
### Результат работ
Результатом наших работ явился небольшой исполняемый файл — run\_transport.bat, в котором зашита вся бизнес-логика рабочего бизнес-процесса. Исполняемый файл по умолчанию помещается в папку С:\transport. И для удобства пользователя, ярлык с run\_transport.bat помещается на рабочий стол.
Согласитесь, все любят большую красную кнопку, нажав на которую без лишних усилий получаешь результат.
Все настройки находятся в файле config.ini:
`[OUTLOOK]
IFNS_OUT=C:\transport\IFNS_OUT*.txt
LOGDIR=C:\transport\LOG
ARCHIVE=C:\transport\ARCHIVE
SEND_FROM=
SEND_TO=email@example.ru
BODY_TEXT=Тело сообщения
SUBJECT=Заголовок сообщения`
Скрипт отправляет файлы из папки IFNS\_OUT через настроенный OUTLOOK на адрес SEND\_TO, а все действия логируются в папку LOGDIR. Все передаваемые файлы после отправки помещаются в папку ARCHIVE, в подпапку соответствующего дня.
Вуаля, разработка закончена и инсталлирована на АРМ, клиент счастлив и готов подбрасывать новые темы "на подумать".
### Резюме
Если у вас стоит подобная задача, welcome в комментарии.
*Felix Leiter to James Bond : «Мы не жадные и не бедные.» Мартин Кэмпбелла Казино Рояль 2006* | https://habr.com/ru/post/694866/ | null | ru | null |
# Использование OpenFeint в Unity3d
OpenFeint — достаточно популярная социальная сеть для игроков. Социальная составляющая всегда важна для казуальных (да и не только) игр, ведь она добавляет интерес к игре со стороны пользователей, да и способствует распространению.
Итак, наша задача на текущий момент — **встроить OpenFeint в наш проект игры на Unity3d**. Итак, все по порядку.
Для начала нужно зарегистрироваться на сайте OpenFient в [разделе разработчиков](https://api.openfeint.com/dd/signup). После регистрации создаем новую игру, просто кликнув кнопку «Add new game». Надо выбрать платформы, на которых вы собираетесь издавать игру и ввести ее название. Все, полдела сделано.
Если рассматривать в кроссплатформенном разрезе (iOS и Android), то OpenFeint поддерживает игровые достижения (achievements, или ачивки в простонародье) и лидерборды (leaderboards). На те и другие можно перейти, кликнув закладку Features в так называемом дешборде разработчика. Остальные возможности на текущий момент поддерживаются только для iOS.
Добавляем нужные лидерборды, заполняем ачивки. У каждого из них есть очень важный параметр — Unique ID. Он-то нам и понадобится, с его помощью будем открывать ачивки и заполнять лидерборды.
Переходим к делу. Тут все просто: качаем OpenFeint Unity SDK [для iOS](http://support.openfeint.com/dev/unity3d-ios/) или [для Android](http://support.openfeint.com/dev/unity3d-android/). Содержимое SDK надо поместить в папку Plugins проекта (через добавления ассетов или путем перетаскивания в иерархию проекта). Класс OpenFeintFacade представляет основной набор функций для работы с функциями социальной сети OpenFeint.
В примере, который прилагается к SDK, делается как описано ниже (исходный код может несколько отличаться от оригинала примера, однако он рабочий).
Создаем свой класс, который на старте создает объект-фасад для опенфейнта. В нем и будем использовать функции OpenFeint. Класс обзовем OpenFeintController и поместим скрипт на GameObject в нужную нам сцену Unity3d. Через него и будем вызывать всё, что нам надо.
```
private static OpenFeintFacade openFeint;
private static OpenFeintController instance;
private const string appName = "";// Имя вашего приложения, отобразится в дешборде
private const string key = ""; // Уникальный ключ
private const string secret = ""; // Секретный ключ
private const string id = ""; // ID приложения
void Awake()
{
if (instance == null)
{
instance = this;
DontDestroyOnLoad(this); //это нужно для присутствия объекта OF в каждой сцене
}
else
{
Destroy(gameObject);
}
}
void Start()
{
openFeint = new OpenFeintFacade();
Init();
}
public static void Init()
{
if (!Application.isEditor) //не вызываем ничего в редакторе, это нам не надо
{
if (!openFeint.isUserLoggedIn()) //проверка на авторизацию
{
if (!openFeint.isInitialized()) // проверка соединения
{
openFeint.Init(appName, key, secret, id, 1);
}
}
}
}
```
Добавим пару функций для открытия дешборда, заливки хайскора в нужный лидерборд и разлочки ачивок:
```
public static void ViewDashboard()
{
if(!Application.isEditor)
{
openFeint.OpenDashboard();
}
}
public static void ReportScore(int score, string leaderboard)
{
if (!Application.isEditor)
{
if (openFeint.isUserLoggedIn())
openFeint.SubmitScore(leaderboard, score);
}
}
public static void UnlockAchievement(int achievementID)
{
if (!Application.isEditor)
{
if (openFeint.isUserLoggedIn())
openFeint.UnlockAchievement(achievementID);
}
}
```
Можно добавить еще одну функцию, если ваше приложение использует ачивки, которые открываются постепенно (то есть можно задать прогресс зарабатывания ачивки — от 0 до 100%). OpenFeint и на такое способен, и это очень интересно:
```
public static void UpdateAchievement(int achievementID, float percentage,
bool showNotification)
{
if (!Application.isEditor)
{
if (openFeint.isUserLoggedIn())
openFeint.UpdateAchievement(achievementID, percentage, showNotification);
}
}
```
В классе OpenFeintFacade содержится еще множество полезных функций, которые в значительной степени повысят социальность разрабатываемой игры, но я люблю только по существу. Кстати, указанный пример работает только на Android. Для iOS дела обстоят несколько по-другому. Чтобы узнать подробнее, обратитесь к документации по [iOS](http://support.openfeint.com/dev/unity3d-ios/) и [Android](http://support.openfeint.com/dev/unity3d-android/) интеграции OpenFeint в Unity3d.
Всем успехов, спасибо за уделенное время
Ссылки по теме:
* [OpenFeint;](http://openfeint.com "Мобильная социальная игровая сеть OpenFeint")
* [раздел для разработчиков OpenFeint;](https://api.openfeint.com/dd/signup "Разработчикам мобильных игр пригодится")
* [OpenFeint Unity3d SDK для iOS;](http://support.openfeint.com/dev/unity3d-ios/ "iOS Unity3d SDK")
* [OpenFeint Unity3d SDK для Android;](http://support.openfeint.com/dev/unity3d-android/ "Android Unity3d SDK")
* [официальный Unity3d форум.](http://forum.unity3d.com/ "Unity3d форум") | https://habr.com/ru/post/127909/ | null | ru | null |
# Один из способов поиска неэкранированных символов с помощью новых средств JavaScript
### 1. C чего всё началось
Недавно у меня возникла необходимость написать очередную утилиту, обрабатывающую текстовый файл в формате, похожем на упрощённый BBCode, а именно в формате исходников для словарей ABBYY Lingvo — DSL (Dictionary Specification Language). (Не путать с другим [DSL](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%B4%D0%BC%D0%B5%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA) (Domain-specific language) — интересный случай, когда гипоним является омонимом к гиперониму).
Достаточно сказать, что в языке используются теги в квадратных скобках и что квадратные скобки можно экранировать обратной косой чертой, если нужно использовать их как часть обычного текста.
Одной из задач утилиты было как раз нахождение этих тегов с исключением экранированных сочетаний.
Поскольку в регулярных выражениях JavaScript с недавнего времени можно пользоваться lookbehind assertions (в личных целях), я подумал, нельзя ли реализовать поиск при помощи этого средства, — тем более что в данной разновидности lookbehind можно использовать выражения переменной длины.
### 2. Предварительные замечания
Чтобы оценить дальнейший эксперимент, необходимо знакомство с некоторыми новыми возможностями JavaScript.
1. [Template literals](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) — долгожданные строки с интерполяцией переменных.
2. [String.raw()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw). Возможности этой функции можно сравнить с одинарными кавычками в Perl и префиксом `r''` в Python: все они помогают создавать строки с буквальной интерпретацией спецсимвола экранирования.
3. [Lookbehind assertions](https://habrahabr.ru/post/281270/) (в том числе см. способы активизации их в Google Chrome и Node.js).
### 3. Реализация
Код скрипта с пробной (наивной) реализацией поиска и проверки:
```
/******************************************************************************/
'use strict';
/******************************************************************************/
const r = String.raw;
const startOfString = '^';
const notEscapeSymbol = r`[^\x5c]`;
const escapedEscapeSymbols = r`(?:${startOfString}|${notEscapeSymbol})(?:\x5c{2})+`;
const tag = r`\x5b[^\x5d]+\x5d`;
const tagRE = new RegExp(
`(?<=${startOfString}|${notEscapeSymbol}|${escapedEscapeSymbols})${tag}`, 'g'
);
console.log(r`[tag]text[/tag]`.match(tagRE));
console.log(r`\\[tag]text\\\\[/tag]`.match(tagRE));
console.log(r`\[tag]text\\\[/tag]`.match(tagRE));
/******************************************************************************/
```
Сперва мы создаём синоним для `String.raw`, чтобы можно было использовать короткую форму, подобно префиксу `r''` в Python.
Затем мы создаём составные части будущего регулярного выражения.
Я исходил из предположения, что правильному тегу может предшествовать один из трёх вариантов: начало строки, любой символ кроме обратной косой черты и экранированная обратная косая черта (то есть сочетание двух обратных косых черт). При этом нужно следить за тем, чтобы экранирующий косую черту символ сам не подвергся экранированию: иными словами, предшествовать тегу может лишь чётное количество обратных косых черт, перед которыми, в свою очередь, может быть или начало строки, или любой отличный от них символ.
Таким образом, нам нужно четыре ключевых элемента сложного регулярного выражения: сам тег и три его допустимых предшественника — начало строки, любой символ за исключением обратной косой черты и экранированная косая черта или её повторение любое количество раз. Третий предшественник тега может быть представлен как сочетание одного из первых двух предшественников и пары обратных косых черт в любом количестве.
Чтобы не рябило в глазах, я все буквальные символы обратных косых черт и квадратных скобок заменил на шестнадцатеричные литералы (`[ — \x5b, \ — \x5c, ] — \x5d`).
Эквивалентом скомпилированного из частей регулярного выражения будет следующее сочетание (его можно использовать вместо всей первой части, присвоив его переменной `tagRE` напрямую):
`/(?<=^|[^\x5c]|(?:^|[^\x5c])(?:\x5c{2})+)\x5b[^\x5d]+\x5d/g`
В конце скрипта полученное выражение тестируется на минимальном наборе правильных и экранированных тегов. Первая строка содержит тег после начала строки и после символа, отличного от обратной косой черты. Вторая строка содержит теги после экранированной обратной косой черты, которую (или которых) предваряет или начало строки, или символ, отличный от них самих. Третья строка содержит экранированные теги.
В консоль выводится следующий результат:
`[ '[i]', '[/i]' ]
[ '[i]', '[/i]' ]
null`
При оценке решения следует иметь в виду две оговорки:
1. Это реализация для домашнего использования, а не для выпуска в массовую продукцию (пока lookbehind assertions не выйдут из-под флага в Node.js и Google Chrome и не будут реализованы в других браузерах).
2. Данное выражение не призвано проверять правильность содержимого самих тегов, только отличить их от экранированных сочетаний.
Буду благодарен за указания на незамеченные риски и за советы по оптимизации. | https://habr.com/ru/post/282275/ | null | ru | null |
# Пишем платежный метод для Magento на примере Robokassa
Добрый день, Хабровчане!
Сегодня я хочу поделится опытом написания платежного метода в Magento. Платежный метод как пример был выбран не случайно, а как одна из самых важных и в тоже время сильно зависящих от страны пользователя частей интернет магазина. А так как в стандартной поставке Magento присутствуют методы в основном направленные на западного пользователя, возможно, эта статья пригодится кому то на просторах СНГ. Изначально в качестве подопытного хотелось написать поддержку QiWi, но тестовых учетных записей там создавать не разрешено, поэтому был выбран способ оплаты через [Robokassa](http://robokassa.ru/ru/).
Прежде всего нам необходимо создать новый модуль, о том как это сделать более подробно можно почитать здесь — <http://habrahabr.ru/blogs/php/80108/>. Мы же попытаемся сконцентрироваться именно не платежном методе.
#### 1. Создание XML фалов
Итак, для начала мы должны объявить о своем существовании, положив соответствующий xml файл в директорию app/etc/modules/.
Sample\_Robokassa.xml:
```
xml version="1.0"?
true
local
```
Эти строки подскажут Magento где искать наш модуль. Далее нам необходимо создать конфигурационный файл нашего модуля и положить его в соответствии с предыдущим фалом.
app/code/local/Sample/Robokassa/etc/config.xml:
```
xml version="1.0"?
1.0.0.0
Sample\_Robokassa\_Model
Sample\_Robokassa\_Block
Sample\_Robokassa\_Helper
standard
Sample\_Robokassa
robokassa
```
И последний XML файл — это файл настроек, которые будут добавлены в админку.
```
xml version="1.0"?
Robokassa
text
1
1
1
1
Enabled
select
adminhtml/system\_config\_source\_yesno
10
1
1
0
Title
text
20
1
1
1
Merchant Login
obscure
adminhtml/system\_config\_backend\_encrypted
30
1
1
0
Merchant Password #1
obscure
adminhtml/system\_config\_backend\_encrypted
40
1
1
0
Merchant Password #2
obscure
adminhtml/system\_config\_backend\_encrypted
45
1
1
0
Test Mode
select
adminhtml/system\_config\_source\_yesno
50
1
1
0
Sort Order
text
60
1
1
0
```
После добавления всех этих файлов в админке по пути System->Configuration->Payment Methods->Robokassa должно появится что-то наподобие этого:
#### 2. Модели
При написании модели платежного метода стоить обратить особое внимание на секцию атрибутов абстрактного класса Mage\_Payment\_Model\_Method\_Abstract, от которого мы и будем наследоваться. Из всех этих свойств нам понадобится только 3:
```
protected $_canUseForMultishipping = false;//Не использовать доставку на многие адреса
protected $_canUseInternal = false;//Не использовать в админке
protected $_isInitializeNeeded = true;//Вызвать процедуру инициализации до перенаправления пользователя
```
В процедуре инициализации заказу будет проставлен специальный статус — «pending\_payment», который означает, что пользователь был перенаправлен на сторону платежной системы, но платеж все еще не произведен. В этом статусе из админки с заказом ничего делать нельзя.
Основной задачей нашей модели будет составление правильного запроса для робокассы, и проверка ответа от нее же. Для этого реализуем два метода, которые будем вызывать из контроллеров:
```
public function getRedirectFormFields()
{
$result = array();
$session = Mage::getSingleton('checkout/session');
$order = Mage::getModel('sales/order')->loadByIncrementId($session->getLastRealOrderId());
if (!$order->getId()) {
return $result;
}
$result['MrchLogin'] = $this->getConfigData('login');
$result['OutSum'] = $order->getBaseGrandTotal();
$result['InvId'] = $order->getIncrementId();
$result['Desc'] = 'Shopping in' . Mage::getStoreConfig(Mage_Core_Model_Store::XML_PATH_STORE_STORE_NAME);
$result['IncCurrLabel'] = 'AlfaBankR';//можно вынести в настройки
$result['SignatureValue'] = md5(
$result['MrchLogin'] . ':'
. $result['OutSum'] . ':'
. $result['InvId'] . ':'
. $this->getConfigData('password1')
);
return $result;
}
public function validateRequest($request)
{
if (!isset($request['OutSum']) || !isset($request['InvId']) || !isset($request['SignatureValue'])) {
return false;
}
$crc = md5($request['OutSum'] . ':' . $request['InvId'] . ':' . $this->getConfigData('password2'));
return strtoupper($request['SignatureValue']) == strtoupper($crc);
}
```
Тут я вырезал PHPDoc в целях экономии места. В первом методе у нас возвращается набор полей необходимых для передачи на робокассу в форме массива, во втором — заново генерируется сигнатура и сравнивается с переданным значением для того чтобы не дать злоумышленникам подделать ответ от робокассы. К слову, в робокассе используется 2 пароля: один для генерации ключа при комуникации magento->robokassa, второй — наоборот. Так же для того, чтобы система расшифровывала пароли при загрузке через стандартный метод getConfigData, нужно упомянуть, что эти поля являются зашифрованными в файле config.xml.
Кроме того здесь присутствует важный метод getOrderPlaceRedirectUrl, который позволит перенаправить пользователя после размещения заказа на нужную нам страницу. На этой странице мы нарисуем форму с данными из нашей модели и отправим ее яваскриптом на страницу робокассы. После этого пользователь увидит долгожданную форму оплаты.
На этом шаге наш платежный метод должен отображаться в списке методов на странице оплаты.
#### 3. Контроллеры
Контроллер у нас будет один и будет нацелен на 3 основных задачи:
1. Поставить заказу нужный статус после подтверждения покупки:
```
$request = Mage::app()->getRequest()->getPost();
$paymentMethod = Mage::getModel('robokassa/redirect');
if (!$paymentMethod->validateRequest($request)) {
return;
}
$order = Mage::getModel('sales/order')->loadByIncrementId($request['InvId']);
/*Переводим заказ в режим позволяющий дальнейшую работу с ним через админку*/
$order->setState(Mage_Sales_Model_Order::STATE_PROCESSING);
$order->setStatus('processing');
$order->setIsNotified(false);
$order->save();
echo 'OK' . $request['InvId']; //Говорим робокассе, что мы удачно приняли запрос
```
2. Обработки удачного возврата пользователя:
```
$session = Mage::getSingleton('checkout/session');
$session->setQuoteId($session->getRobokassaQuoteId());
/* Все прошло хорошо, можно деактивировать корзину */
Mage::getSingleton('checkout/session')->getQuote()->setIsActive(false)->save();
$this->_redirect('checkout/onepage/success', array('_secure'=>true));
```
3. Обработка возврата с ошибкой:
```
$session = Mage::getSingleton('checkout/session');
$session->setQuoteId($session->getRobokassaQuoteId());
if ($session->getLastRealOrderId()) {
$order = Mage::getModel('sales/order')->loadByIncrementId($session->getLastRealOrderId());
if ($order->getId()) {
$order->cancel()->save();//Отменяем заказ, который имеет "pending_payment" статус
}
}
$quote = Mage::getModel('sales/quote')->load($session->getRobokassaQuoteId());
if ($quote->getId()) {
$quote->setActive(true);//Возвращаем корзину к жизни
$quote->save();
}
/* Выводим пользователю ошибку */
$session->addError(Mage::helper('robokassa')->__('Payment failed. Pleas try again later.'));
$this->_redirect('checkout/cart');
```
Вот в принципе и все, данный модуль будет позволять размещать заказы и снимать деньги через робокассу. Еще в нем можно реализовать поддержку XML API робокассы, это позволит более гибко работать с валютами. Так же можно реализовать другие стандартные возможности платжных методов как: отладка, выбор статуса ордера при размещении и многое другое.
В статье опубликована бóльшая часть исходников. Отсутствует только уровень view и не совсем важные участки кода, которые вместе с остальными исходниками можно найти в [diff файле](http://www.sendspace.com/file/st1m0v). Дифф файл можно установить на существующую копию Magento командой patch в Linux, либо программой TortoiseSVN в Windows. | https://habr.com/ru/post/127916/ | null | ru | null |
# Оптимизация оплаты Webmoney посредством Paymer
 Выкладываю статью о webmoney и паймере [из своего блога.](http://galkin.in.ua) На днях пополнял на очень популярном сайте свой баланс посредством webmoney. Было крайне удивительно обнаружить, что администрация сайта оставила в мерчанте настройки по умолчанию. Результат — 0.8% моих денег им не дошли. Более того, они могли их **заработать два раза**, если бы сделали на своем сайте прием чеков Paymer правильно.
Чек Paymer, он же wm-карта, это номер и код на владение определенной суммой титульных знаков вебмани. Следовательно, его передача от одного субъекта другому не облагается 0.8% за транзакцию. Это если по-умному, а по-простому — купил wm-карту и активировал ее не себе, а продавцу. Благо все инструменты для этого есть.
Но хватит теории, перейдем к практике. И так у нас есть биллинг с приемом оплаты вебмани посредством мерчанта.
**Проверяем, а работает ли прием Paymer-а.**
Начинаем процесс оплаты, доходим до мерчанта, выбираем методом оплаты паймер или вм-карту.
И если видим вот такое, тогда статью я написал для Вас.
**Быстрый способ**
Заходим в [настройки кошелька](https://merchant.webmoney.ru/conf/purses.asp), на который Вы принимаете оплату. И включаем *Прием чеков Paymer.com (ВМ-карт) или WM-нот*.
Все теперь Ваш пользователь не будет вынужден тратить лишние 0.8%, что бы деньги дошли до Вас.
`**Программисту на заметку:**
Стоит перед этим добавить в обработчик оповещения о платеже запись в базу данных доп. данные касательно паймера. Подробней тут`
**Выгодный способ**
Мало кто знает, что у паймера есть [свой мерчант](https://www.paymer.com/merchant/default.aspx?t=g1&lang=ru-RU). Настолько мало, что с его использованием в 2009 году среднемесячное количество платежей было всего лишь 200. Как он работает:
* Мы создаем на сайте еще один вариант метода оплаты, например WMR-карточкой;
* Пользователь оплачивает товар так же как в быстром способе;
* В нашем специальном чекохранилище становиться на чек больше;
`**Программисту на заметку:**
Идеологии работы с мерчантом паймера и вебмани очень похожи. Перестройки логики приложения минимальна и по сути совпадает с добавлением новой валюты.`
Полученные чеки можно или активировать на любой кошелек (не обязательно свой), или получить его с номером и кодом. Конечно они будут отличны от тех, что вводил покупатель. Вообще чеки удобны тем, что их можно объединять друг с другом, разбивать на части, перебивать номер и код, создавать свои за 1% суммы.
Лично, я делаю так — раз в месяц объединяю сразу все имеющиеся чеки и вывожу их у своего местного дилера вебмани с комиссией на 1% меньше обычной. У внимательного читателя возникнет вопрос, почему 1%, а не 0.8%? Дилер продает WM-карты. И ему выгоднее купить у меня готовый паймер, что создавать свои.
Надеюсь эта статья поможет Вам снизить транзакционные издержки Вашего бизнеса
**В заключении**, просьба — проверьте значения по умолчанию Ваших продуктов, на то что они будут оптимальны для конечных потребителей.
[Первоисточник](http://galkin.in.ua/optimizaciya-oplaty-webmoney-posredstvom-paymer/) | https://habr.com/ru/post/78688/ | null | ru | null |
# Цифровая модель рельефа с использованием SRTM данных
При создании картографического сервера у меня возникла необходимость в создании высотных профилей местности. В качестве данных для цифровой модели рельефа я решил использовать SRTM (NASA Shuttle Radar Topography Mission). Хотя есть и [альтернативные наборы данных](http://vterrain.org/Elevation/global.html), SRTM наиболее распостранен и вполне удовлетворял меня по точности. Данные поставляются в нескольких вариантах — сетка с размером ячейки 1 угловая секунда и 3 угловые секунды. Более точные односекундные данные (SRTM1) доступны на территорию США, на остальную поверхность земли (между 60 градусов северной широты и 54 градусов южной широты) доступны только трехсекундные данные (SRTM3). Файлы представляют собой матрицу из 1201х1201 (или 3601х3601 для односекундной версии) значений.
Для удобной закачки данных с [официального источника](http://dds.cr.usgs.gov/srtm/version2_1/SRTM3) набросал небольшой скрипт **srtm\_download**#!/bin/bash
usage() {
echo «Usage: » $0 "-region -lat\_semisphere -lon\_semisphere -min\_lat -max\_lat -min\_lon -max\_lon"
echo «Region one of: Africa Australia Eurasia Islands North\_America South\_America»
echo «Example: srtm\_download Eurasia N E 43 53 21 142»
exit 1
}
if (( "$#" < 7 )); then
usage
else
REGION=$1
LATITUDE\_SEMISPHERE=$2
LONGITUDE\_SEMISPHERE=$3
MIN\_LATITUDE=$4
MAX\_LATITUDE=$5
MIN\_LONGITUDE=$6
MAX\_LONGITUDE=$7
SERVER\_ADDRESS=«[dds.cr.usgs.gov/srtm/version2\_1/SRTM3](http://dds.cr.usgs.gov/srtm/version2_1/SRTM3/)${REGION}»
mkdir srtm
for i in $(seq $MIN\_LATITUDE $MAX\_LATITUDE)
do
for j in $(seq $MIN\_LONGITUDE $MAX\_LONGITUDE)
do
wget -P srtm -nv "$SERVER\_ADDRESS/$LATITUDE\_SEMISPHERE$i$LONGITUDE\_SEMISPHERE`printf %03d $j`"".hgt.zip"
done
done
fi
Все доступные файлы с матрицами высот будут сохранены в папку srtm.
При построении высотных профилей за основу был взят [проект](http://wiki.openstreetmap.org/wiki/Route_altitude_profiles_SRTM) голландского osm-юзера [Sjors Provoost](http://wiki.openstreetmap.org/wiki/User:Sjors).
Начал я с установки osm-сервера тайлов. Под Ubuntu 12.04 есть удобный и быстрый [способ](http://wiki.openstreetmap.org/wiki/Ubuntu_tile_server) обойтись без ручной сборки всех необходимых компонентов. Сборка под Debian, тоже особых проблем не вызвала. Как это сделать можно посмотреть [тут](http://switch2osm.org/serving-tiles/manually-building-a-tile-server-12-04/) и [тут](http://habrahabr.ru/post/144675/).
Чтобы хранить и работать с этими наборами используется PostgreSQL. Для начала нам необходимо создать в PostgreSQL пользователя и базу данных с именем srtm
`sudo -u postgres -i`
`createuser username # answer yes for superuser (although this isn't strictly necessary)`
`createdb -E UTF8 -O username srtm`
`exit`
Для создания и наполнения таблицы удобно использовать psycopg2 (PostgreSQL адаптер для Python), а для чтения SRTM — библиотеку GDAL. Небольшой python-скрипт запускать который нужно в ранее созданной и наполненной данными папке SRTM.
**srtm2pgsql**#!/usr/bin/python
import pg, psycopg2
from osgeo import gdal, gdal\_array
import os
import zipfile
import re
import sys
from math import sqrt
def getLatLonFromFileName(name):
# Split up in lat and lon:
p = re.compile('[NSEW]\d\*')
[lat\_str, lon\_str] = p.findall(name)
# North or south?
if lat\_str[0] == «N»:
lat = int(lat\_str[1:])
else:
lat = -int(lat\_str[1:])
# East or west?
if lon\_str[0] == «E»:
lon = int(lon\_str[1:])
else:
lon = -int(lon\_str[1:])
return [lat,lon]
def loadTile(filename):
# Unzip it
zf = zipfile.ZipFile(filename + ".hgt.zip")
for name in zf.namelist():
outfile = open(name, 'wb')
outfile.write(zf.read(name))
outfile.flush()
outfile.close()
# Read it
srtm = gdal.Open(filename + '.hgt')
# Clean up
os.remove(filename + '.hgt')
return gdal\_array.DatasetReadAsArray(srtm)
def posFromLatLon(lat,lon):
return (lat \* 360 + lon) \* 1200 \* 1200
class DatabasePg:
def \_\_init\_\_(self, db\_name, db\_user, db\_pass):
self.db = pg.DB(dbname=db\_name,host='localhost', user=db\_user, passwd=db\_pass)
def createTableAltitude(self):
tables = self.db.get\_tables()
if not('public.altitude' in tables):
self.db.query(" \
CREATE TABLE altitude ( \
pos bigint NOT NULL, \
alt int NULL, \
PRIMARY KEY ( pos ) \
); \
")
return True
class DatabasePsycopg2:
def \_\_init\_\_(self, db\_name, db\_user, db\_pass):
self.db\_name = db\_name
conn = psycopg2.connect(«dbname='» + db\_name + "' host='localhost' user='" + db\_user + "' password='" + db\_pass + "'")
self.cursor = conn.cursor()
def insertTile(self, tile, lat0, lon0):
# I use the Psycopg2 connection, with its copy\_to and
# copy\_from commands, which use the more efficient COPY command.
# This method requires a temporary file.
# Calculate begin position
begin = posFromLatLon(lat0,lon0)
# First we write the data into a temporary file.
f = open('/tmp/tempcopy', 'w')
# We drop the top row and right column.
for row in range(1, len(tile)):
for col in range(0, len(tile) — 1):
f.write(str(\
begin + (row-1) \* 1200 + col\
) + "\t" + str(tile[row][col] ) + "\n")
f.close()
# Now we read the data from the temporary file and put it in the
# altitude table.
f = open('/tmp/tempcopy', 'r')
import subprocess
psqlcmd = "/usr/bin/psql"
p = subprocess.Popen('psql ' + self.db\_name + ' -c «COPY altitude FROM STDIN;»', stdin=f, shell=True);
p.wait()
f.close
def main():
if len(sys.argv) != 2:
print «Error! \nUsage: strm2pgsql username»
sys.exit()
else:
db\_pg = DatabasePg('srtm', sys.argv[1], '')
db\_psycopg2 = DatabasePsycopg2('srtm', sys.argv[1], '')
db\_pg.createTableAltitude()
for file in os.listdir('.'):
if (re.search('hgt', file)):
tilename = file.split('.')[0]
print «Load tile » + tilename + " to srtm database"
[lat,lon] = getLatLonFromFileName(tilename)
tile = loadTile(tilename)
db\_psycopg2.insertTile(tile, lat, lon)
if \_\_name\_\_ == '\_\_main\_\_':
main()
Для создания непосредственно высотного профиля использовал Qt. Создаем коннект с базой (может понадобится [драйвер доступа к базе](http://doc.qt.digia.com/stable/sql-driver.html))
```
db = QSqlDatabase::addDatabase("QPSQL");
db.setHostName("localhost");
db.setDatabaseName("srtm");
db.setUserName("user");
db.setPassword("pass");
bool ok = db.open();
```
Маршрут, высотный профиль которого мы хотим создать, состоит из точек GeoPoint, которые хранят широту, долготу и высоту
**geopoint.h**class GeoPoint
{
public:
GeoPoint();
GeoPoint(double latitude, double longitude, double altitude);
double latitude();
double longitude();
double altitude();
void setLatitude(double latitude);
void setLongitude(double longitude);
void setAltitude(double altitude);
private:
double m\_latitude;
double m\_longitude;
double m\_altitude;
};
Для получения необходимого количества точек нужно выполнить интерполяцию и получить оценку высоты для каждой точки маршрута.
```
interpolateRoute(route, numberRoutePoint);
foreach (GeoPoint point, route)
{
point.setAltitude(altitude(db, point.latitude(), point.longitude()));
}
```
Для интерполяции нахожу общую длину маршрута (использую формулу [Винсенти](http://en.wikipedia.org/wiki/Vincenty's_formulae)) и добавляю необходимое количество новых точек в маршрут
**Интерполяция**
```
void interpolateRoute(QVector &route, int number)
{
// Получаем длину всего маршрута
double length = routeLength(route);
double minRes = length / number;
// Добавляем необходимое количество точек между заданными точками маршрута:
int i = 0;
while (i < route.size() - 1)
{
QPair pair = qMakePair(route[i], route[i+1]);
int number = numberExtraPoints(pair, minRes);
addPointsToRoute(route, i, number);
i = i + number + 1;
}
}
double routeLength(const QVector &route)
{
double length = 0;
Geo geo;
for (int i=0; i pair, double minRes)
{
Geo geo;
double length = geo.distance(pair.first, pair.second);
return qMax(int(floor(length / minRes) - 1), 0);
}
void addPointsToRoute(QVector &route, int index, int number)
{
double lat1 = route[index].latitude();
double lat2 = route[index+1].latitude();
double lon1 = route[index].longitude();
double lon2 = route[index+1].longitude();
double latRes = (lat2 - lat1) / number;
double lonRes = (lon2 - lon1) / number;
for (int i=0; i 10e-12) && (iterLimit > 0))
{
double sinLambdaLng = sin(lambdaLng);
double cosLambdaLng = cos(lambdaLng);
sinSigma = sqrt((cosReduced2\*sinLambdaLng) \* (cosReduced2\*sinLambdaLng) +
(cosReduced1\*sinReduced2 - sinReduced1\*cosReduced2\*cosLambdaLng) \*
(cosReduced1\*sinReduced2 - sinReduced1\*cosReduced2\*cosLambdaLng));
if (sinSigma == 0)
return 0; // Точки совпадают
cosSigma = sinReduced1\*sinReduced2 + cosReduced1\*cosReduced2\*cosLambdaLng;
sigma = atan2(sinSigma, cosSigma);
double sinAlpha = cosReduced1\*cosReduced2\*sinLambdaLng/sinSigma;
cosSqAlpha = 1 - sinAlpha\*sinAlpha;
cos2SigmaM = 0.; // Линия экватора
if (cosSqAlpha != 0)
{
cos2SigmaM = cosSigma - 2\*(sinReduced1\*sinReduced2/cosSqAlpha);
}
double C = f / 16. \* cosSqAlpha \* (4 + f \* (4 - 3 \* cosSqAlpha));
lambdaPrime = lambdaLng;
lambdaLng = (deltaLng + (1 - C)\*f\*sinAlpha\*(sigma + C \* sinSigma \*
(cos2SigmaM + C \* cosSigma \*(-1 + 2\*cos2SigmaM\*cos2SigmaM))));
--iterLimit;
}
if (iterLimit == 0)
{
return 0;
log->info() << "Geo, calculate distance: Vincenty formula failed to converge!";
}
double uSq = cosSqAlpha \* (major\*major - minor\*minor) / (minor\*minor);
double A = 1 + uSq / 16384. \* (4096 + uSq \* (-768 + uSq \*(320 - 175 \* uSq)));
double B = uSq / 1024. \* (256 + uSq \* (-128 + uSq \* (74 - 47 \* uSq)));
double deltaSigma = (B \* sinSigma \*(cos2SigmaM + B / 4. \*(cosSigma \* (-1 + 2 \* cos2SigmaM\*cos2SigmaM) -
B / 6. \* cos2SigmaM \* (-3 + 4 \* sinSigma\*sinSigma)\*(-3 + 4 \* cos2SigmaM\*cos2SigmaM))));
return minor \* A \* (sigma - deltaSigma);
}
```
Для получения оценки высоты каждой точки маршрута, находим в базе четыре ближайшие точки и производим [билинейную интерполяцию](http://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%BB%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D0%BF%D0%BE%D0%BB%D1%8F%D1%86%D0%B8%D1%8F)
**Оценка высоты**
```
double altitude(PostgreSqlDatabase db, double latitude, double longitude)
{
qulonglong tl, tr, bl, br;
double a, b;
posFromLatLon(latitude, longitude, tl, tr, bl, br, a, b);
int atl = db.fetchAltitude(tl);
int atr = db.fetchAltitude(tr);
int abl = db.fetchAltitude(bl);
int abr = db.fetchAltitude(br);
return bilinearInterpolation(atl, atr, abl, abr, a, b);
}
int PostgreSqlDatabase::fetchAltitude(qulonglong pos)
{
QSqlQuery query;
if (query.exec("SELECT * FROM altitude WHERE pos = " + QString::number(pos)))
{
while (query.next())
{
return query.value(1).toInt();
}
}
return Geo::undefinedAltitude;
}
void posFromLatLon(const double &latitude, const double &longitude,
qulonglong &tl, qulonglong &tr, qulonglong &bl, qulonglong &br, double &a, double &b)
{
double lat0 = floor(latitude);
double lon0 = floor(longitude);
qulonglong pos0 = (lat0*360 + lon0) * 1200*1200;
double latPos = (1199./1200 - (latitude - lat0)) * 1200*1200;
double lonPos = (longitude - lon0) * 1200;
double latPosTop = floor(latPos / 1200) * 1200;
double latPosBottom = ceil(latPos / 1200) * 1200;
double lonPosLeft = floor(lonPos);
double lonPosRight = ceil(lonPos);
a = (latPos - latPosTop) / 1200;
b = (lonPos - lonPosLeft);
tl = qulonglong(pos0 + latPosTop + lonPosLeft);
tr = qulonglong(pos0 + latPosTop + lonPosRight);
bl = qulonglong(pos0 + latPosBottom + lonPosLeft);
br = qulonglong(pos0 + latPosBottom + lonPosRight);
}
double bilinearInterpolation(const double &tl, const double &tr, const double &bl, const double &br, const double &a, const double &b)
{
double b1 = tl;
double b2 = bl - tl;
double b3 = tr - tl;
double b4 = tl - bl - tr + br;
return b1 + b2*a + b3*b + b4*a*b;
}
```
Таким образом на выходе мы будем иметь набор точек маршрута с оценкой их высоты.
Если тема использования STRM-данных интересна сообществу, в следующей статье могу поделиться тем как я делал цветную подложку рельефа для использования совместно с osm-данными. | https://habr.com/ru/post/161201/ | null | ru | null |
# Настоящий многопоточный веб-сервер на ассемблере под Linux
Добрый день, хабр!
Сегодня я вам расскажу как написать свой настоящий веб-сервер на асме.
Сразу скажу, что мы не будем использовать дополнительные библиотеки типа libc. А будем пользоваться тем, что предоставляет нам ядро.
Уже только ленивый не писал подобных статей, — сервер на perl, node.js, по-моему даже были попытки на php.
Вот только на ассемблере еще не было, — значит нужно заполнить пробелы.
#### Немного истории
Как-то раз мне нужно было хранить мелкие файлы (меньше 1Kb), их было ооочень много, я боялся за ext3, и решил я хранить все эти файлы в одном большом, а отдавать посредством веб-сервера, задавая в get параметре смещение и длину самого файла в hex виде.
Времени было прилично, решил я немного извратиться и написать это на асме.
#### Итак, приступим
Писать будем на FASM, т.к. нравится он мне, да и к Intel-синтаксису я привык.
Итак, стандартная процедура создания elf:
```
format elf executable 3
entry _start
segment readable writeable executable
```
Далее некоторые данные для заголовков:
```
HTTP200 db "HTTP/1.1 200 OK", 0xD,0xA ;
CTYPE db "Content-Type: application/octet-stream", 0xD,0xA ;
CNAME db 'Content-Disposition: attachment; filename="BIGTABLE"',0xD,0xA,0xD,0xA ;
SERVER db 'Server: Kylie',0xD,0xA ;
KeepClose db 'Connection: close',0xD,0xA,0xD,0xA
; и переменные для sendfile
off_set dd 0x00
n_bytes dd 0x00
```
А также путь к тому самому большому файлу в котором хранятся все картинки:
```
FILE1 db "/home/andrew/FILE.FBF",0
```
Определим несколько констант для удобства:
```
IPPROTO_TCP equ 0x06
SOCK_STREAM equ 0x01
PF_INET equ 0x02
AF_INET equ 0x02
```
Подключим самописную функцию перевода из str в hex
```
include 'str2hex.asm'
```
Принцип работы данной функции прост:
Забиваем в google.com.ua «Таблица ASCI», — распечатываем, и смотрим на нее…
Замечаем, что значения в ASCII от 0 — 9 соответствуют значениям от 30h до 39h
А значения от A до F в диапазоне от 41h до 46h
Входной параметр для макроса — адрес буфера в esi (по этому адресу — строка, которую надо перевести из str в hex)
Макрос просто проверяет код ASCII символа и если он больше 39h, — то работаем с A — F, если меньше или равно ему то с 0 — 9
Вот его полный код:
```
; esi,- адрес на строковый id
Возвращаемые значения:
; eax - результат работы
Macro STR2HEX4
{
local str2hex,bin2hex, out_buff, func, result, nohex
; // Локальный макрос для определения (строка больше 9 (т.е. A..F) или меньше)
cld ;// Флаг направления (в сторону увеличения)
mov edi,out_buff ;
jmp func
;// Та самая проверка
str2hex:
cmp al,39h
jle nohex
sub al,07h
nohex:
sub al,30h
ret
out_buff dd 0x00
func:
; // Будем считать 4 раза (32 бит)
mov ecx,4
bin2hex:
lodsb ;// Загрузим первое значение
call str2hex ;// Конвертируем его ASCII код в значение
shl al,4 ; // Сдвинем на 4 (это будут старшие 4 бита)
mov bl,al ; // Сохраним его в bl
lodsb ; // Загрузим следующий
call str2hex ; // Конвертируем (Это будут младшие 4 бита)
xor al,bl ; // Объединим старшие и младшие биты
; // Все готово, теперь в AL у нас результат от первой пары символов
stosb ; // Сохраним его в edi на всякий пожарный
sub ecx,1 ; // Уменьшим счетчик на 1
jecxz result ; Продолжаем пока ecx != 0
jmp bin2hex ;
result:
;// В результате все аккуратно сложим в регистр eax
xor eax,eax
cld
mov esi,out_buff
lodsb
shl eax,8
lodsb
shl eax,8
lodsb
shl eax,8
lodsb
; На выходе - значение в eax
}
```
P.S. Функция лишена обработчиков ошибок, поэтому надеюсь вы будете правильно задавать размер-смещение (обратите внимание, параметры регистрозависимы. Т.е. A != a, B =! b и т.д.)
Также максимальный размер и максимальное смещение = 32 бит.
Разобрались, поехали дальше:
Теперь наконец пришло время создать сокет
```
; // Заполняем структуру для сокета
push IPPROTO_TCP ; IPPROTO_TCP (=6)
push SOCK_STREAM ; SOCK_STREAM (=1)
push PF_INET ; PF_INET (=2)
;socketcall
mov eax, 102 ; // Функция 102 (работа с сокетами)
mov ebx, 1 ; // 1 говорить что нужно создать сокет
mov ecx, esp ; // Указатель на нашу структуру в стеке
int 0x80
mov edi,eax ; // Сохраним значение в edi, т.к. он нам еще пригодится
cmp eax, -1
je near errn ; // Проверим на ошибки
```
Сокет создан, биндим его на адрес 0.0.0.0 (в простонароде — INADDR\_ANY) и порт 8080 (т.к. на 80м у меня работает lighttpd, и если поменять на 80й то в eax вернется 0 и произойдет ошибка -EADDRINUSE говорящая о том что порт уже занят)
```
; binding
push 16 ; socklen_t addrlen
push ecx ; const struct sockaddr *my_addr
push edi ; int sockfd
mov eax, 102 ; socketcall() syscall
mov ebx, 2 ; bind() = int call 2
mov ecx, esp ; // Указатель
int 0x80
cmp eax, 0
jne near errn ;// Проверим на ошибки (если порт занят например...)
```
Кстати про использование INADDR\_ANY. Если вы хотите использовать localhost, или любой другой адрес вы должны написать его «наоборот». Т.е.
localhost = 127.0.0.1 = 0x0100007F
habrahabr.ru = 212.24.43.44 = 2C2B18D4
Тоже самое каcается и номеров порта:
8080 = 901Fh
25 = 1900h
Конечно вам ничего не мешает указать ip как-то так:
localhost db 127,0,0,1
habrahabr.ru db 212,24,43,44
и т.д.
Ну и наконец начинаем прослушивать сам сокет на принятие новых соединений:
```
push 1 ;// int backlog
push edi ;// int sockfd
pop esi
push edi
mov eax, 102 ; // syscall
mov ebx, 4 ;// указывает что необходимо прослушивать сокет (listen)
mov ecx, esp ; // указатель на нашу структуру
int 0x80
```
Теперь важный момент. Т.к. мы будем работать с процессами, то родительский процесс будет ожидать код возврата от дочернего после fork, и при завершении дочернего процесса родитель так и будет «думать» что он еще есть. Таким образом из дочерних процессов появляются зомби. Если мы скажем родителю что будем игнорировать эти сигналы то никого никто ждать не будет, и зомби появляться также не будут:
```
mov eax,48
mov ebx,17
mov ecx,1 ; SIG_IGN
int 0x80
```
Создаем структуру для accept и начинаем принимать соединения:
```
push 0x00
push 0x00 ; struct sockaddr *addr
push edi ; int sockfd
sock_accept:
mov eax, 102 ; socketcall() syscall
mov ebx, 5 ; accept() = int call 5
mov ecx, esp
int 0x80
; // Проверка на ошибки:
cmp eax, -1
je near errn
mov edi, eax ; Теперь в edi будет хранится
mov [c_accept],eax
```
Если ошибок никаких не возникло и мы оказались в этой части кода, значит подключился новый клиент
Создадим процесс для обработки:
```
mov eax,2 ; // Системный вызов sys_fork()
int 0x80
cmp eax,0
jl exit ; if error
```
Теперь выясним кем мы тут являемся, форком или родительским процессом:
```
test eax,eax
jnz fork ; Переходим на отработку запроса от клиента (дочерний процесс)
; edi - accept descriptor
; // Закрываем коннекшн в родителе и возвращаемся к принятию других клиентов
mov eax, 6 ; close() syscall
mov ebx, edi ; The socket descriptor
int 0x80 ; Call the kernel
jmp sock_accept
fork:
;// Дальше - код обработки запроса
```
Все! «Голова» нашего сервера готова.
Дальше идет код исключительно для дочернего процесса
Отправим клиенту статус 200 OK
```
mov eax, 4 ; write() syscall
mov ebx, edi ; sockfd
mov ecx, HTTP200 ; Send 200 Ok
mov edx, 17 ; 17 characters in length
int 0x80 ;
```
Также тип контента. «application/octet-stream» — самый универсальный в данном случае
```
mov eax, 4 ; write() syscall
mov ebx, edi ; sockfd
mov ecx, CTYPE ; Content-type - 'application/octet-stream'
mov edx, 40 ; 40 characters in length
int 0x80 ; Call the kernel
```
Название сервера:
```
mov eax, 4 ; write() syscall
mov ebx, edi ; sockfd
mov ecx, SERVER ; our string to send
mov edx, 15 ; 15 characters in length
int 0x80 ; Call the kernel
```
Так как наш сервер пока не поддерживает Keep-Alive то признаемся в этом:
```
mov eax, 4 ; write() syscall
mov ebx, edi ; sockfd
mov ecx, KeepClose ; Connection: Close
mov edx, 21 ; 21 characters in length
int 0x80 ; Call the kernel
```
Обратите внимание, необходимо отправить в конце два раза 0xD 0xA (мы это сделали вместе с отправкой Connection: Close) и можно считать что с заголовками покончено
Ну а теперь собственно узнаем какой файл хочет скачать клиент. Для этого поместим в буфер запрос GET со сдвигом в 5 байтов влево, тем самым обрезая ненужную информацию(‘GET /’), оставляя только чистый ID размером в 16 байт.
Ах да, я все об id, id … А что он из себя представляет? Я решил все сделать просто, указав в GET 32-битное значение для смещения в файле, и сразу за ним 32 битное значение равное размеру файла.
Т.е. если запрос URL выглядит таким образом:
[127.0.0.1/00003F480000FFFF](http://127.0.0.1/00003F480000FFFF)
То смещение в файле равно 00003F48 а размер запрошенных данных — 0000FFFF
```
mov esi,buffer ; // Поместим адрес откуда читать наш id (для STR2HEX)
push edi ; Сохраним edi т.к. макрос его очищает
STR2HEX4 ; Макрос принимает буфер по адресу esi
pop edi ; возвратим edi
mov [off_set],eax ; // функция возвратила значение в eax, сохраним ее в переменной
```
Теперь нам нужно открыть большой файл, где начало файла будет с заданным смещением:
Сейчас просто откроем его (дескриптор будет сохранен в eax):
```
; Open BIG file
mov eax,5
mov ebx,FILE1
mov ecx, 2
int 0x80
```
Теперь для полного удовлетворения пришло время использовать функцию sendfile.
Как пишут в мануалах:
> Because this copying is done within the kernel, sendfile() is more efficient than the combination of read(2) and write(2), which would require transferring data to and from user space.
>
>
```
; Send [n_bytes] from BIGTABLE starting at [off_set]
send_file:
mov ecx,eax ; file descriptor from previous function
mov eax,187
mov ebx,edi ; socket
mov edx,off_set ; pointer
mov esi,[n_bytes] ;
int 0x80
```
Как вы поняли дескриптор из eax мы скопировали в ecx для функции sendfile, не сохраняя его в промежуточных регистрах\памяти.
**success**
Вот здесь в свое время я долго не спал по ночам, потому что не мог понять почему же после отправки всех байт файл не скачивается полностью, а за секунду до полного скачивания браузер пишет «Сетевая ошибка» и его не сохраняет. В sendfile ошибок не возникало, пришлось научится пользоваться chrome developer tools.
Оказывается что после отправки самого файла, браузер шлет заголовок, который сервер должен принять. Не важно какие там данные, — его все равно можно отослать в /dev/null но очень важно что бы сервер его прочел. Иначе браузер посчитает что с файлом что-то не то. Зачем именно так сделано — на 100% мне неизвестно. Мне кажется что это связано с возможным отсутствием Content-Length в заголовках, когда файл принять надо, а сколько данных браузер заведомо не знает. Буду признателен если кто-то откроет тайну )))
Итак, принимаем браузерный хедер:
Читаем из адреса в edi, в адрес buffer
```
; Read the header
mov eax,3
mov ebx,edi
mov ecx,buffer
mov edx,1024
int 0x80
```
Если заголовки не слишком большие то 1024 байта вполне хватит
(Если на этом домене не используете длинных кук и т.д.)
Закрытие файла и завершение:
```
mov eax, 6 ; close() syscall
mov ebx, edi ; The socket descriptor
int 0x80 ; Call the kernel
; end to pcntl_fork ()
mov eax,1
xor ebx,ebx
int 0x80
```
Вообще файл можно держать открытым какое-то время в родителе, и использовать его остальными форками, для экономии времени. Но это не совсем правильный вариант.
И самое главное!
Никаких внешних библиотек!
> root@server:/home/andrew# ldd server
>
> not a dynamic executable
>
>
Ссылка для скачивания (можно проверить работает\нет, протестить бенчмарком ab например)))
<http://ubuntuone.com/3yNexPG0yewlGnjNd6219W>
P.S. В коде упущено множество проверок на ошибки, также в некоторых кусках кода не подчищается стек, наличие некоторых переменных подобрано вручную (за отсутствием нормальной документации), и в общем код не претендует на звание самого «чистого».
Сервер хорошо работает на многоядерных системах (проверено на Core I7 2600). Он обгоняет lighttpd у меня на сервере по статике почти в 4 раза, хотя я думаю что мой lighttpd просто не настроен на многоядерность.
Что быстро можно добавить:
Ну например cgi для любого языка (php, perl, python) и т.д. Также возможно убрать считывание из файла, и написать работу с файловой системой а также добавить виртуальные хосты. А вообще все ограничено только вашей фантазией. | https://habr.com/ru/post/188114/ | null | ru | null |
# Про создание платформера на Unity. Часть третья, долгожданная
Привет, Хабр!
Холодная питерская осень штабелями укладывает людей в кровать с температурой и прочими прелестями той части вселенной, которая отвечает за болезни. Но всему плохому, к счастью, приходит конец. Поэтому, как вы поняли из вступления, сегодня в нашем курсе от начинающего для начинающих мы поговорим о создании врагов, уровней и физики. Больше физики!
Осторожно: объемы гифок под катом становятся просто нечеловеческими!
[Предыдущие](http://habrahabr.ru/company/microsoft/blog/236125/) [части](http://habrahabr.ru/company/microsoft/blog/236135/) были опубликованы почти две недели назад, поэтому советую немного освежить знания :)
*Дисклеймер: весь показанный в статье код не является образцом для подражания, примером идеального кода и прочих вымышленных и не существующих в природе вещей. Практики, примененные в статье, могут являться одними из множества решений конкретной проблемы. А могут и не являться.*
Начнем с конца, добавив максимально простую физическую штуку — коробку. Нам нужны спрайт коробки, rigidbody2D и boxcollider2D. Приступим!
Как видите, все еще ничего сложного. Приготовим из получившейся коробки префаб и перенесем еще раз на форму. Следите за руками: у одной из коробок поставим галку isKinematic у rigidbody2D и запустим начинающееся веселье:
Коробка с установленным rigidbody2D.isKinematic = true не двигается. Ее нельзя сдвинуть с места применением сил или коллизий, так что эта коробка будет выполнять роль неподвижного препятствия. Идем дальше.
В лучших традициях super meat boy, добавим в нашу пока\_еще\_не игру врага-пилу. Пила будет крутиться и… всё.
Невероятной сложности скрипт для этого действия выглядит так:
```
using UnityEngine;
using System.Collections;
public class sawScriptNew : MonoBehaviour {
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
transform.Rotate (new Vector3(0f,0f,-3f));
}
}
```
Поясню: transform.rotate вращает спрайт на заданные в vector3 углы вокруг, соответственно, осей x, y и z. В случае с 2D игрой первые две оси мало применимы для нашей задачи, и вот почему:
transform.Rotate (new Vector3(-3f,0f,0f));
transform.Rotate (new Vector3(0f,-3f,0f));
К слову, о 2D режиме. Внимательный читатель заметил, что пила некрасиво торчит перед платформой и загораживает весь вид. Для того, чтобы это исправить, достаточно знать простую вещь — в 2D режиме объекты на экране упорядочиваются (вот тут не очень уверен насчет терминологии, поправьте) по z-уровню. Вот вам наглядная гифка о том, как это работает.
Теперь сделаем так, чтобы герой умирал при взаимодействии с пилой. Исправим characterController.cs следующим образом:
```
void OnTriggerEnter2D(Collider2D col){
if ((col.gameObject.name == "dieCollider")||(col.gameObject.name == "saw"))
Application.LoadLevel (Application.loadedLevel);
```
Бинго! Теперь, имея звезды, коробки, препятствия и dieCollider'ы давайте попробуем собрать уровень. Делается это очень быстро и легко, так как все объекты уже существуют в виде префабов, и их не нужно каждый раз настраивать заново.
**Краткий гайд по гейм-дизайну**При создании уровня мотивируйте игрока знакомиться с миром. Поставьте перед ним приз, а следующий расположите так, чтобы за ним нужно было, например, прыгнуть. Имея, например, двигающиеся коробки, поставьте их так, чтобы очередную звезду нельзя было достать без них. И так далее.
Обучайте игрока максимально эффективно: не стоит растягивать введение на несколько уровней. Вспомните классический мир 1-1 из Super Mario Brothers. Его (как правило) достаточно, чтобы познакомиться с основными механиками игры и самыми часто встречаемыми врагами.
Идем дальше. Когда есть один уровень, нужен и второй. Сохраним сцену как scene1.unity и создадим новую. Построим, аналогично примеру выше, еще один уровень и сохраним (уже догадались? молодцы) как scene2. Теперь идем в File -> Build Settings и ставим галки на обеих сценах. Примерно так:
Рядом с названием сцены отображается номер — по нему мы можем обращаться к сцене для ее загрузки. Или по имени, кому как удобнее. Создадим пустой объект и запрограммируем его так, чтобы после сбора всех звезд и столкновения с ним (объектом) игрок переходил на вторую сцену. Для этого в методе OnTriggerEnter будем проверять, есть ли еще звезды на сцене.
```
if (col.gameObject.name == "endLevel") {
if (!(GameObject.Find("star"))) Application.LoadLevel ("scene2");
}
```
Вот так он будет выглядеть на сцене. При желании, можно добавить спрайт с помощью компонента sprite renderer.
**Как выглядит переключение уровней (gif, 3.7 MB)**
На этом основная часть статьи заканчивается и начинается бонус-трек по вашим заявкам.
Соответственно, немного про веселье и про физику! Добавим пару спрайтов — платформу и файрбол из Super Mario, и попробуем сделать из этого машину для разрушения кучи коробок.
В этом нам поможет первый представитель семейства Джойнтов, с которым мы познакомимся — Distance Joint, который, по сути, позволяет превратить что угодно в игре в математический маятник. Добавляем его на объект, выбираем, что будет с другой стороны маятника (здесь пригодится объект с rigidbody2d.isKinematic = true), какое расстояние между ними и в итоге получится то, что получилось выше. Коробки, кстати, все те же, что использовались в нашем платформере. Смотрите!
Объект, к которому прицеплен наш разрушающий шар, имеет компонент rigidbody2D со включенным атрибутом isKinematic. Это нужно для того, чтобы он не падал сразу после запуска игры (и вообще никогда).
А вот на этом действительно всё! Спасибо за внимание, приходите еще, задавайте вопросы! В следующей статье я покажу как анимировать героя, звездочки и рисовать нормальные надписи на экране. В общем, займемся всякими украшательствами.
Предыдущие серии:
[Часть первая, в которой обаятельный носач учится ходить](http://habrahabr.ru/company/microsoft/blog/236125/)
[Часть вторая, в которой проигрывать — весело.](http://habrahabr.ru/company/microsoft/blog/236135/)
p.s. [Больше веселья с физикой (GIF, 3.1 MB)](http://habrastorage.org/files/ca6/cb4/bdc/ca6cb4bdc7c74a3ebe220ad86a0553fb.gif) | https://habr.com/ru/post/238071/ | null | ru | null |
# GStreamer: кодеки с привкусом Linux
Вы когда-нибудь задумывались о том как работают Gnome-плееры, такие как Totem, Rhythmbox или Banshee? Наверное каждый из вас в новоустановленной Ubuntu, при попытке проиграть AVI-шку видел сообщение о необходимости установить дополнительный пакет gst-ffmpeg или gst-plugins-ugly. Под катом — моя попытка прояснить свет на то, как работает этот мультимедийный фреймворк и на что он способен.
Основное отличие от VLC или FFmpeg в том, что первоначально среда разрабатывалась не для определённого приложения, а для всех программ, которые могут работать с мультимедиа. Данный фреймворк интегрирован в такие языки: С, С++/Qt, Python, Ruby, Perl.
##### GStreamer позволяет создавать приложения, которые способны:
* Принимать и передавать аудио-видео, используя практически любой протокол: HTTP, RTSP/RTP, MMS, RTMP и другие.
* Разбирать/Собирать потоки в разных форматах: MPEG,AVI,ASF,FLV,MKV и другие.
* Вытягивать и вставлять метаданные в файлах.
* Декодировать/Кодировать потоки практически в любой комбиации кодеков.
При этом можно использовать не только open-source решения (libavcodec, libmp3lame, libfaac), но и проприетарные, которые можно купить. Так-же можно задействовать декодеры с аппаратной поддержкой c использованием технологий CUDA/VAAPI/CrystalHD.
* Выводить потоки на экран или звуковую карту, используя самые разнообразные решения, начиная от DirectFB, и заканчивая X-ами.
Для решения таких задач, как перекодирование фильма в другой формат, большую популярность имеют такие программы как mencoder или VLC. Но сделать то-же самое при помощи GStreamer — не на много сложнее.
Ниже представлены примеры для Linux, демонстрирующие возможности фреймворка. В этих примерах мы будем использовать основные программы gst-launch и gst-inspect — чем-то напоминающие Windows-приложение GraphEdit. Для тех, кому нужна графическая оболочка — есть [gst-editor](http://2developers.net/post/gst_editor.html). Но учтите, что эти программы предназначены для отладки, поэтому не ожидайте от них удобства в использовании.
Для начала работы с GStreamer необходимо уяснить некоторые понятия:
* **element** — Элемент-объект GStreamer'а, который может принимать/отправлять данные.
* **source** — Генерирует поток (файл, поток или устройство).
* **filter** — Элемент, который трансформирует поток (парсеры, мультиплексоры, кодеки).
* **sink** — Принимает поток и не перенаправляет его.
* **pipeline** — Коллекция соединённых между собой элементов.
В классическом виде мы получаем такого вида цепочку: source -> parser -> decoder -> filter -> sink.
Если вам лень собирать всю цепочку кодеков и мультиплексоров вручную, GStreamer может сделать это за вас:
> `$ gst-launch playbin uri=file:///home/me/audo.mp3`
Элемент «playbin» сам разбирает файл, находит нужный кодек и элемент вывода. Всё что нужно — указать путь к файлу, который нужно проиграть. Если-же вам интересно какой элемент за что отвечает, вы можете запустить gst-inspect и увидеть все доступные элементы, а «gst-inspect lame» — покажет парамерты mp3-кодера. Так-же стоит отметить полезность элемента «decodebin2», который сам находит нужный декодер.
Простейший аудиоплеер:
> `$ gst-launch filesrc location=audio.mp3 ! decodebin2 ! alsasink`
Простейший аудиоплеер (выбираем кодек вручную, и согласовываем форматы):
> `$ gst-launch filesrc location=audio.mp3 ! mad ! audioconvert ! audioresample ! alsasink`
Плеер посложнее (со звуком и видео):
> `$ gst-launch filesrc location=audovideofile.mpeg ! decodebin2 name=decoder \
>
> decoder. ! ffmpegcolorspace ! xvimagesink \
>
> decoder. ! audioconvert ! audioresample ! alsasink`
Если вам нужно перекодировать AVI-файл в MOV, можно воспользоваться следующей командой:
> `$ gst-launch-0.10 filesrc location=film.avi ! \
>
> decodebin2 name=decoder { qtmux name=muxer ! filesink location=film.mov } \
>
> { decoder. ! ffmpegcolorspace ! jpegenc ! queue ! muxer. } \
>
> { decoder. ! queue ! audioconvert ! queue ! muxer. }`
Хочется сделать вещание, одновременно с записью в файл и отображением на экране вещаемого видео? Без проблем:
> `$ gst-launch v4l2src ! queue ! \
>
> ffmpegcolorspace ! tee name=t1 ! \
>
> queue ! xvimagesink sync=false t1. ! \
>
> queue ! theoraenc quality=1 ! \
>
> queue ! oggmux name=mux \
>
> alsasrc ! audio/x-raw-int,rate=8000,channels=1,depth=8 ! \
>
> queue ! audioconvert ! vorbisenc ! \
>
> queue ! mux. mux. ! \
>
> queue ! tee name= t ! \
>
> queue ! filesink location=test.ogg t. ! \
>
> queue ! shout2send ip=<наш-icecast-сервер> port=8000 password=hackme`
Любители повещать во флеше — тоже не остались в стороне, благодаря librtmp (надо пересобрать пакет gst-plugins-bad):
> `$ gst-launch v4l2src ! \
>
> queue ! ffmpegcolorspace ! ffenc\_flv ! \
>
> queue ! flvmux name=muux is-live=true ! \
>
> rtmpsink location='rtmp://localhost/path/to/stream live=1' \
>
> alsasrc ! audio/x-raw-int,rate=22050,channels=1,depth=16 ! \
>
> queue ! audioconvert ! lame bitrate=48 ! \
>
> queue ! muux.`
Так-же разработчики позаботились об использовании «родных» мультимедийных фреймворков (QuickTime/DirectShow), если вы используете MacOS или Windows, благодаря «мостам».
Ну и в заключение хочется сказать, что есть немало проблем, которые ещё предстоит решить разработчикам (рассинхронизации, проблемы с утечками памяти и производительности). Большинство из них связано с использованием сторонних библиотек, которые не всегда качественно написаны. Вот поэтому разработчики и придумали интересный приём — плагины разделены на 5 категорий:
* **gst-plugins-base** — Основные плагины, идущие в комплекте: CDDA, RTP, RTSP, ogg, theora, vorbis, Xvideo, V4L.
* **gst-plugins-good** — Плагины, не вызываюшие сомнения в своей надёжности: FLAC, speex, JPEG, PNG.
* **gst-plugins-bad** — Рабчие, но возможны проблемы: VP8, XVID, FAAC, dirac, RTMP, VDPAU, DirectShow.
* **gst-plugins-ugly** — Не обойтись без проблем при использовании: ASF, real, DVDSub, a52, AMR, x264.
* **gst-ffmpeg** — Отдельный набор кодеков «всё в одном».
##### Хозяйке на заметку (источники):
1. [GStreamer features](http://gstreamer.freedesktop.org/features/)
2. [Live stream with GStreamer](http://mcs.hackitectura.net/tiki-slideshow.php?page=live%20stream%20with%20gstreamer&slide=1) примеры для gst-launch
3. [Howto](http://gentrans.sourceforge.net/docs/head/manual/html/howto.html)
4. [GStreamer, RTP and live streaming](http://blog.abourget.net/2009/6/14/gstreamer-rtp-and-live-streaming/), примеры для python
5. [Коллекции платных кодеков](http://www.fluendo.com/shop/category/end-user-products/)
6. [Hello World GStreamer](http://felipec.wordpress.com/2008/01/19/gstreamer-hello-world/) на языке С | https://habr.com/ru/post/127023/ | null | ru | null |
# Как нарисовать графики и диаграммы в Atlassian Confluence
[Atlassian](https://www.atlassian.com/) [Confluence](https://www.atlassian.com/software/confluence) — мощное решение для развертывания Enterprise Wiki в организации (хотя, нет никаких технических проблем с тем, чтобы использовать его и дома — лицензия на 10 пользователей стоит всего 10 американских долларов в год). И лично мне Confluence нравится тем, что имеет дружелюбный интерфейс и позволяет интуитивно понятно редактировать контент, с легкостью дополняя его визуальными составляющими, что позволяет в итоге получить красивые и удобные для просмотра страницы. Кстати, этот пост тоже написан в Confluence.
Как известно многим, визуализация имеет большое влияние на то, как контент будет восприниматься. В последнее время в любых соцсетях и тематических сообществах прослеживается четкий тренд: если ваш пост не содержит визуальной информации, например, тех же картинок с котиками, его мало кто будет читать. А если он еще и длиннее одной страницы… Итак, пользоваться графикой нужно. И тут я сошлюсь на [пост комрадов из DevExpress](http://habrahabr.ru/company/devexpress/blog/240325/), где они привели интересные факты о визуализации (увы, без пруфов, но цифры на мой взгляд очень похожи на правду):
* 90% информации человек воспринимает через зрение
* 70% сенсорных рецепторов находятся в глазах
* около половины нейронов головного мозга человека задействованы в обработке визуальной информации
* на 19% меньше при работе с визуальными данными используется когнитивная функция мозга, отвечающая за обработку и анализ информации
* на 17% выше производительность человека, работающего с визуальной информацией
* на 4,5% лучше воспоминаются подробные детали визуальной информации
Учитывая столь очевидную полезность грамотной визуализации и корпоративную направленность Confluence, попробуем немного порисовать прямо на страничках вики. Рисовать там можно достаточно много вещей, но вот «из коробки» функционал позволяет разве что нарисовать графики и вставить картинки. Но это нас не остановит, поскольку в экосистеме Atlassian силами сторонних вендоров производится огромное количество аддонов на любой вкус и цвет, причем даже самый крутой и дорогой продукт можно взять и попробовать бесплатно в течение месяца. И так, если память не изменяет, до шести раз подряд, что дает совершенно легальные полгода на раздумья, что будет легче — начать себе отказывать в удобстве от аддона или ~~задушить проклятое земноводное~~ прописать затраты в бюджет и купить наконец продукт.
**#### Диаграммы в Confluence**
Как я упоминал выше, «из коробки» порисовать не очень-то получится. Зато, если мы обратим свое внимание на аддоны, то для рисования разного рода диаграмм их найдется немало. Попробуем рассмотреть те, которые больше всего на слуху и первые попались в заботливые руки поисковой выдачи. В этот список попали:
* [Confluence Diagramming](https://marketplace.atlassian.com/plugins/com.cinergix.confluence.plugins.creately.CreatelyConfluence/server/overview) by Creately
* [Draw.io Diagrams](https://marketplace.atlassian.com/plugins/com.mxgraph.confluence.plugins.diagramly/server/overview) for Confluence
* [Lucidchart](https://marketplace.atlassian.com/plugins/com.lucidchart.confluence.plugins.lucid-confluence/server/overview) for Confluence
* [Gliffy Diagrams](https://marketplace.atlassian.com/plugins/com.gliffy.integration.confluence/server/overview) for Confluence
* [Graphviz Diagrams](https://marketplace.atlassian.com/plugins/com.atlassian.confluence.extra.graphviz/server/overview) for Confluence
Первые четыре продукта, с моей точки зрения, очень похожи друг на друга. Возможно, даже имел факт «заимствования» тех или иных элементов функциональности друг у друга. Они понимают формат Visio, что позволяет не ломать голову над вопросом «а зачем нам все наши диаграммы перерисовывать» — можно просто импортировать имеющиеся файлы. Очень похож и процесс рисования диаграмм — из библиотек изображений на страницу добавляются элементы, связи между ними, подписи. Многие из поставщиков аддонов предлагают использовать их веб-версии диаграмм.
Несколько особняком стоит Graphviz Diagrams от [Боба Свифта](https://marketplace.atlassian.com/vendors/90). Этот продукт несколько нарушает принципы экосистемы Atlassian, где все реализовано очень просто и интуитивно понятно, но в нем есть свой особый шарм. Да, вам потребуется не просто добавить аддон в Confluence, но еще и поставить на ваш сервер библиотеку визуализации графов [graphviz](https://ru.wikipedia.org/wiki/Graphviz). Зато потом вы сможете использовать мощный язык [DOT](https://ru.wikipedia.org/wiki/DOT_(%D1%8F%D0%B7%D1%8B%D0%BA)) для автоматической визуализации ваших данных (наверняка на Хабре есть люди, которые без графов и DOT жизни не представляют).
Примеры того, как можно нарисовать диаграммы при помощи аддонов для Confluence и веб-версий диаграмм:
Объединяет эти аддоны тот факт, что с помощью любого из них можно нарисовать недурственные диаграммы и схемы (или просто импортировать из Visio), но вот графики у них как-то не задались. Либо такая функциональность (построение графиков по таблице с данными) отсутствует, ограничиваясь схематичными представлениями графиков, либо реализована неудобно и рядовому пользователю будет непросто этим воспользоваться.
Пример того, как можно использовать язык DOT и библиотеку Graphviz:
```
A -> B
C -> B
B -> C
D -> A
A -> D
```
```
e;
subgraph clusterA {
a -- b;
subgraph clusterC {
C -- D;
}
}
subgraph clusterB {
d -- f
}
d -- D
e -- clusterB
clusterC -- clusterB
```
Трудно сказать, какой аддон лучше выбрать. Скорее всего, на выбор повлияют какие-то вторичные для функционала вещи. Например, способность работать на сервере автономно без доступа в Интернет или гибкое лицензирование, позволяющее не покупать сразу 500 лицензий в большой организации, где рисованием подобных диаграмм занимается пять человек. В наше время и цена лицензии часто имеет решающее значение. Я попытался свести основные нефункциональные характеристики в таблицу:
| Аддон | Поддержка
Server/Cloud | Необходим
Интернет | Гибкое
лицензирование | Цена лицензии
500 пользователей
Server/Cloud | Поддержка
импорта/экспорта
файлов Visio | Наличие
веб-версии |
| --- | --- | --- | --- | --- | --- | --- |
| [Confluence Diagramming](https://marketplace.atlassian.com/plugins/com.cinergix.confluence.plugins.creately.CreatelyConfluence/server/overview) by Creately | Да/Нет | Да | Нет | $2000/Нет | Да | Нет |
| [Draw.io Diagrams](https://marketplace.atlassian.com/plugins/com.mxgraph.confluence.plugins.diagramly/server/overview) for Confluence | Да/Да | Да | Нет | $3000/Бесплатно | Да | Да |
| [Lucidchart](https://marketplace.atlassian.com/plugins/com.lucidchart.confluence.plugins.lucid-confluence/server/overview) for Confluence | Да/Да | Да | Да | Гибкая/Бесплатно | Да | Да |
| [Gliffy Diagrams](https://marketplace.atlassian.com/plugins/com.gliffy.integration.confluence/server/overview) for Confluence | Да/Да | Нет | Нет | $6000/$3000 | Да | Да |
| [Graphviz Diagrams](https://marketplace.atlassian.com/plugins/com.atlassian.confluence.extra.graphviz/server/overview) for Confluence | Да/Нет | Нет | Нет | $580/Нет | Нет | Нет |
**#### Графики в Confluence**
Погуглив "[confluence charts](https://www.google.ru/search?q=confluence+charts&oq=confluence+charts)", на первой странице я получил вот что (откровенно говоря, негусто):
* [Chart Macro](https://confluence.atlassian.com/doc/chart-macro-163415075.html) от [Atlassian](http://atlassian.com/) (самое приятное, что этот продукт уже включен в Confluence «из коробки» и за него не нужно доплачивать)
* [Table Filter and Charts](https://marketplace.atlassian.com/plugins/com.stiltsoft.confluence.plugin.tablefilter.tablefilter/server/overview) от [StiltSoft](http://stiltsoft.com/)
* [Lucidchart](http://lucidchart.com/) (этот продукт упоминался выше, к сожалению, графики с его помощью быстро и удобно не порисуешь, иначе он был бы однозначным моим фаворитом)
Поэтому будем рассматривать первые два.
В любом случае, для того, чтобы нарисовать график, вам потребуется таблица с данными. Эта таблица может появиться в Confluence совершенно разными способами, например быть созданной с нуля, импортированной из CSV, копипастой из Excel и даже сформированной запросом из СУБД при помощи [SQL for Confluence](https://marketplace.atlassian.com/plugins/org.swift.confluence.sql/server/overview). Как сформированы данные в таблице — решающего значения не имеет, они просто должны быть. А из уже имеющихся данных мы можем построить графики.
**##### Chart Macro из поставки Confluence**
Это встроенный в Confluence макрос, который умеет отрисовывать следующие типы графиков:
* Pie Chart
* Bar Chart
* 3D Bar Chart
* Time Series Chart
* XY Line Chart
* XY Area Chart
* Area Charts
* Gantt Chart
Макрос имеет [большое количество настроек](https://confluence.atlassian.com/doc/chart-macro-163415075.html) для того, чтобы ваш график выглядел именно так, как вам нужно. Он покрывает все распространенные сценарии, в которых вам нужно нарисовать графики, но есть ложка дегтя (даже две) — это обязательный переход в режим редактирования страницы, даже если нужно только немного поменять настройки графика, и огромное количество этих самых настроек, что неподготовленного пользователя может напугать. Правда, эти ложки дополняются бочкой меда — бесплатность и документация с примерами, которая позволяет понять, как же оно работает и построить самые простые графики.
Вот так, например, выглядит Area chart:
… а вот так 3D Bar chart:
… можно посмотреть соотношение продаж разной рыбы в виде наглядной диаграммы Pie chart (круговой диаграммы):
**##### Table Filter and Charts**
Аддон разработан компанией [StiltSoft](http://stiltsoft.com/), которая является Atlassian Expert и Atlassian Verified Vendor. У него есть свои плюсы и минусы. В плюсах отмечу следующее:
* аддон позволяет не только строить графики, а еще и имеет мощный механизм фильтрации таблиц (и даже умеет строить сводные таблицы с аггрегацией данных)
* очень просто настраивается
* настройки можно менять прямо из режима просмотра, не переходя в режим редактирования страницы (и сохранять их из режима просмотра)
* график можно скачать в один клик
Но, как водится, должен быть и минус. Он всего один — за аддон нужно платить (процесс установки аддона в Confluence очень прост и считать его минусом трудно).
Аддон нам предлагает три макроса:
* [Table Filter](https://docs.stiltsoft.com/display/TableFilter/Table+Filter+for+Confluence)
* [Pivot Table](https://docs.stiltsoft.com/display/TableFilter/How+to+use+Pivot+table+macro)
* [Chart from Table](https://docs.stiltsoft.com/display/TableFilter/How+to+use+Chart+from+Table+macro)
Первый из них позволяет «на лету» прямо из режима просмотра фильтровать сложные таблицы в Confluence. Фильтрация есть и в режиме редактирования, что иногда может быть удобно. Макрос Pivot Table позволяет построить сводную таблицу, содержащую аггрегированные и суммированные значения из больших таблиц с повторяющимися значениями. И, наконец, самое интересное — Chart from Table. Вот он-то и умеет рисовать графики, вот список возможных графиков:
* Pie
* Donut
* 3D Donut
* Column
* Stacked Column
* Bar
* Stacked Bar
* Line
* Area
* Time Line
* Time Area
**##### Примеры графиков, полученных с помощью Chart from Table**
Уже знакомая по Charts круговая диаграмма про рыбу:
| Fish Type | 2011 |
| --- | --- |
| Herring | 9500 |
| Salmon | 2900 |
| Tuna | 1500 |
Вот так выглядит график типа stacked column ([гугл утверждает](https://support.google.com/docs/answer/190718?hl=ru), что это гистограмма):
| | 2009 | 2010 | 2011 |
| --- | --- | --- | --- |
| Revenue | 12.4 | 31.8 | 41.1 |
| Expense | 43.6 | 41.8 | 31.1 |
… а вот так выглядит столбчатая диаграмма с накоплением (multi-column chart):
| Period | Opened
Tickets | Pending
Tickets | Succesfully
Closed Tickets | Tickets Closed
w/o Response | Unsuccesfully
Closed Tickets | Total
Tickets |
| --- | --- | --- | --- | --- | --- | --- |
| Q1 2015 | 207 | 42 | 381 | 20 | 14 | 664 |
| Q2 2015 | 278 | 31 | 247 | 58 | 39 | 653 |
| Q3 2015 | 227 | 27 | 200 | 23 | 31 | 508 |
| Q4 2015 | 257 | 20 | 237 | 58 | 40 | 612 |
Получившийся график можно скачать в один клик как картинку, или можно прямо из режима просмотра поменять настройки графика, используя панель настроек. Панель настроек можно скрыть, равно как и таблицу с исходными данными.
**##### К-к-к-комбо!**
Самая мякотка, непосредственно затрагивающая тему графиков. Компоненты аддона (три макроса, входящие в комплект — графики, фильтрацию и сводные таблицы) можно смело и умело комбинировать. Что позволяет строить графики уже недоступные стандартному макросу Charts в достаточно легкой и непринужденной манере. Можно запросто построить график по отфильтрованной сводной таблице, например. Для этого вкладываем таблицу в макрос Table Filter (здесь можно будет фильтровать данные, уменьшив их количество), затем вкладываем Table Filter с таблицей в макрос Pivot Table (он построит сводную таблицу), и в качестве вишенки на торте получившуюся конструкцию помещаем в макрос Chart from Table (этот макрос нарисует график). Звучит страшновато, конструкция похожа на известную всем по сказкам Кощееву смерть. Тем не менее, в реальности все это делается достаточно быстро.
После того, как мы один раз выстроили иерархию данных и макросов — мы можем прямо из режима просмотра страницы менять настройки фильтрации исходных данных, настройки сводной таблицы и настройки графика — все будет тут же пересчитываться и перерисовываться. Настройки можно тут же сохранить, а можно поиграться и оставить как есть — страница вернется в исходное состояние при перезагрузке.
**#### Погодите, а как же JIRA?**
И здесь у ребят из Atlassian есть решение прямо «из коробки». Для начала, если вы еще не настроили — вам потребуется [application link](https://confluence.atlassian.com/doc/linking-to-another-application-360677690.html) между Confluence и JIRA, стандартный для продуктов Atlassian. После этого Confluence сможет получать данные из JIRA. Для визуализации же этих данных в состав Confluence включен макрос JIRA Charts (который, к слову, поддерживает фильтры JIRA и даже [jql](http://blogs.atlassian.com/2013/01/jql-the-most-flexible-way-to-search-jira-14/)-запросы для получения нужных вам данных). А для графического отображения полученных данных есть три типа графиков:
* Pie Chart from JIRA (стандартная круговая диаграмма)
* Created vs Resolved Chart from JIRA (созданные и решенные задачи)
* JIRA Two-Dimensional Chart (двумерная диаграмма)
Пример стандартной круговой диаграммы, отражающей количественное соотношение задач по товарищам, которые их выполнили:
… а вот так выглядит сравнительная диаграмма созданных и решенных задач:
Пример двумерной диаграммы (по сути простая таблица):
Разумеется, полученные из JIRA данные можно обработать и отрисовать при помощи макросов, входящих в состав Table Filter and Charts. Можно, разумеется, применять фильтры уже в процессе получения данных из JIRA, чтобы не тащить и потом не фильтровать лишнее. А можно по-простому затянуть минимально отфильтрованные данные и дофильтровать их по месту, потом привести к формату сводной таблицы и построить график либо по исходным отфильтрованным данным, либо по уже получившейся сводной таблице. А если что-то выглядит не так, как ожидается — аккуратно и быстро поменять настройки фильтров или графиков. Комбо!
**#### Вместо заключения**
Навыки правильной визуализации данных, когда все графики и картинки приходятся к месту и помогают, а не мешают восприятию информации, нужно нарабатывать. Но с хорошими инструментами их нарабатывать гораздо проще, потому что отвлекаться на сам процесс рисования придется меньше. Надеюсь, после этой статьи кто-нибудь перестанет считать Confluence очередной унылой корпоративной википедией и начнет использовать всю мощь этого решения, вовлекая в процесс окружающих. | https://habr.com/ru/post/273353/ | null | ru | null |
# Golang + Phaser3 = MMORPG — Клиент и Сервер
В прошлой статье мы сделали с вами заготовку, так сказать основу, на чем будет создаваться наша вселенная, визуализация с помощью консоли может быть и выглядит хорошо, но текстовые символы это скучно и не очень красиво, в этой статье мы займемся визуализацией наших тайлов с помощью Phaser.js
В прошлой статье наш проект выглядел так:
Теперь мы будем использовать и другие инструменты для веб-разработки, надеюсь у вас установлен Node.js и npm, если нет, то срочно установите. И так открываем терминал и запускам:
```
$ npm install phaser@3.22.0
```
При удачном завершении команды мы должны увидеть следующее:
```
+ phaser@3.22.0
added 15 packages from 48 contributors and audited 20 packages in 4.38s
```
Так отлично, появились модули, теперь мы создадим директорию для нашего клиента
В Content мы будет хранить ресурсы игры, т.е. наши спрайты. Так же создадим два файла game.js и MainScene.js, в корневом каталоге(где лежит файл main.go) создадим index.html
game.js — хранит основные настройки для игры
MainScene.js — будет содержать класс основной сцены игры
index.html — страница где будет происходить рендер сцены
Сразу подключим в index.html наши скрипты и больше мы к данному файлу возвращаться не будем:
```
```
В MainScene.js сделаем небольшой шаблон класса нашей будущей сцены:
```
export {MainScene}
class MainScene extends Phaser.Scene{
constructor() {
super({key: 'MainScene'})
}
preload() {
}
create() {
}
update() {
}
}
```
В game.js добавьте типовые настройки по своему вкусу, вот мои:
```
import {MainScene} from "./MainScene.js";
let config = {
type: Phaser.AUTO,
width: 800,
height: 600,
disableContextMenu: true,
background: 'black',
physics: {
default: 'arcade',
arcadePhysics: {
overlapBias: 1
}
},
scene:[MainScene],
pixelArt: true,
roundPixels: true,
antialias: true
}
let game = new Phaser.Game(config);
```
Теперь нам нужен HTTP сервер, на го это делается в несколько строк. Переходим в main.go и создадим сервер:
```
package main
import (
"fmt"
"html/template"
"net/http"
)
func main() {
// Роутер для доступа к клиенту
http.HandleFunc("/", indexHandler)
// Открываем доступ к статичным ресурсам (скрипты, картинки и тд.)
http.Handle("/node_modules/phaser/dist/", http.StripPrefix("/node_modules/phaser/dist/", http.FileServer(http.Dir("./node_modules/phaser/dist/"))))
http.Handle("/Client/", http.StripPrefix("/Client/", http.FileServer(http.Dir("./Client/"))))
http.Handle("/Client/Content/", http.StripPrefix("/Client/Content/", http.FileServer(http.Dir("./Client/Content/"))))
// Запускаем сервер. Указываем любой порт, я выбрал 8080
err := http.ListenAndServe(":8080", nil)
if err != nil {
fmt.Println(err.Error())
}
}
// Обработчик для index.html, здесь мы просто отдаем клиент пользователю
func indexHandler(w http.ResponseWriter, r *http.Request) {
fmt.Println("indexAction")
t, _ := template.ParseFiles("index.html")
err := t.Execute(w, "index")
if err != nil {
fmt.Println(err.Error())
}
}
```
Ну вот, у нас есть собственный веб-сервер и клиент! Давайте уже запустим! Открываем консоль:
```
$ go run main.go
```
Открываем браузер и попробуем подключиться к нашему серверу, в моем случае это
> localhost:8080
Если вы увидели черный экран, значит вы все сделали правильно.
И так, давайте создадим еще один обработчик, по которому мы будем получать наш чанк в json формате. Создадим отдельную директорию и назовем ее GameController, здесь у нас будут все обработчики работающие с игровыми данными, создадим файл Map\_Controller.go
Так же нам понадобится улучшенный
**Chunk.go**
```
package Chunk
import (
"exampleMMO/PerlinNoise"
"fmt"
)
var TILE_SIZE = 16
var CHUNK_SIZE = 16 * 16
var PERLIN_SEED float32 = 160
type Chunk struct {
ChunkID [2]int `json:"chunkID"`
Map map[Coordinate]Tile `json:"map"`
}
/*
Тайтл игрового мира
*/
type Tile struct {
Key string `json:"key"`
X int `json:"x"`
Y int `json:"y"`
}
/*
Универсальная структура для хранения координат
*/
type Coordinate struct {
X int `json:"x"`
Y int `json:"y"`
}
/*
Создает карту чанка из тайлов, генерирует карту на основе координаты чанка
Например [1,1]
*/
func NewChunk(idChunk Coordinate) Chunk {
fmt.Println("New Chank", idChunk)
chunk := Chunk{ChunkID: [2]int{idChunk.X, idChunk.Y}}
var chunkXMax, chunkYMax int
var chunkMap map[Coordinate]Tile
chunkMap = make(map[Coordinate]Tile)
chunkXMax = idChunk.X * CHUNK_SIZE
chunkYMax = idChunk.Y * CHUNK_SIZE
switch {
case chunkXMax < 0 && chunkYMax < 0:
{
for x := chunkXMax + CHUNK_SIZE; x > chunkXMax; x -= TILE_SIZE {
for y := chunkYMax + CHUNK_SIZE; y > chunkYMax; y -= TILE_SIZE {
posX := float32(x - (TILE_SIZE / 2))
posY := float32(y + (TILE_SIZE / 2))
tile := Tile{}
tile.X = int(posX)
tile.Y = int(posY)
perlinValue := PerlinNoise.Noise(posX/PERLIN_SEED, posY/PERLIN_SEED)
switch {
case perlinValue < -0.01:
tile.Key = "Water"
case perlinValue >= -0.01 && perlinValue < 0:
tile.Key = "Sand"
case perlinValue >= 0 && perlinValue <= 0.5:
tile.Key = "Ground"
case perlinValue > 0.5:
tile.Key = "Mount"
}
chunkMap[Coordinate{X: tile.X, Y: tile.Y}] = tile
}
}
}
case chunkXMax < 0:
{
for x := chunkXMax + CHUNK_SIZE; x > chunkXMax; x -= TILE_SIZE {
for y := chunkYMax - CHUNK_SIZE; y < chunkYMax; y += TILE_SIZE {
posX := float32(x - (TILE_SIZE / 2))
posY := float32(y + (TILE_SIZE / 2))
tile := Tile{}
tile.X = int(posX)
tile.Y = int(posY)
perlinValue := PerlinNoise.Noise(posX/PERLIN_SEED, posY/PERLIN_SEED)
switch {
case perlinValue < -0.12:
tile.Key = "Water"
case perlinValue >= -0.12 && perlinValue <= 0.5:
tile.Key = "Ground"
case perlinValue > 0.5:
tile.Key = "Mount"
}
chunkMap[Coordinate{X: tile.X, Y: tile.Y}] = tile
}
}
}
case chunkYMax < 0:
{
for x := chunkXMax - CHUNK_SIZE; x < chunkXMax; x += TILE_SIZE {
for y := chunkYMax + CHUNK_SIZE; y > chunkYMax; y -= TILE_SIZE {
posX := float32(x + (TILE_SIZE / 2))
posY := float32(y - (TILE_SIZE / 2))
tile := Tile{}
tile.X = int(posX)
tile.Y = int(posY)
perlinValue := PerlinNoise.Noise(posX/PERLIN_SEED, posY/PERLIN_SEED)
switch {
case perlinValue < -0.12:
tile.Key = "Water"
case perlinValue >= -0.12 && perlinValue <= 0.5:
tile.Key = "Ground"
case perlinValue > 0.5:
tile.Key = "Mount"
}
chunkMap[Coordinate{X: tile.X, Y: tile.Y}] = tile
}
}
}
default:
{
for x := chunkXMax - CHUNK_SIZE; x < chunkXMax; x += TILE_SIZE {
for y := chunkYMax - CHUNK_SIZE; y < chunkYMax; y += TILE_SIZE {
posX := float32(x + (TILE_SIZE / 2))
posY := float32(y + (TILE_SIZE / 2))
tile := Tile{}
tile.X = int(posX)
tile.Y = int(posY)
perlinValue := PerlinNoise.Noise(posX/PERLIN_SEED, posY/PERLIN_SEED)
switch {
case perlinValue < -0.12:
tile.Key = "Water"
case perlinValue >= -0.12 && perlinValue <= 0.5:
tile.Key = "Ground"
case perlinValue > 0.5:
tile.Key = "Mount"
}
chunkMap[Coordinate{X: tile.X, Y: tile.Y}] = tile
}
}
}
}
chunk.Map = chunkMap
return chunk
}
```
Мы просто добавили json ключи к нашим структурам и немного улучшили создание чанка
Возвращаемся к Map\_Controller,
```
package GameController
import (
"encoding/json"
"exampleMMO/Chunk"
"fmt"
"net/http"
)
func Map_Handler(w http.ResponseWriter, r *http.Request) {
c:= Chunk.NewChunk(Chunk.Coordinate{1,1})
js, e :=json.Marshal(c)
if e!= nil {
fmt.Println(e.Error())
}
fmt.Println(string(js))
}
```
и добавьте строчку в main.go
```
http.HandleFunc("/map", GameController.Map_Handler)
```
Попробуем запустить сервер и перейти по адресу localhost:8080/map
Вывод в терминале:
```
New Chank {1 1}
json: unsupported type: map[Chunk.Coordinate]Chunk.Tile
```
Да, мы забыли что в Golang при сериализации, ключи карты должны быть строкой. Для сериализации Go проверяет соответствует ли тип интерфейсу TextMarshaler, и вызывает его метод MarshalText(), нам нужно просто создать метод MarshalText() для нашего типа Coordinate
Возвращаемся в Chunk.go и добавляет следующий код:
```
func (t Coordinate) MarshalText() ([]byte, error) {
return []byte("[" + strconv.Itoa(t.X) + "," + strconv.Itoa(t.Y) + "]"), nil
}
```
Вы можете написать свою реализацию, самое главное, чтобы данный метод возвращал уникальную строку. Данный ключ мы будем использовать для управления чанками на клиенте, давайте теперь проверим как работает наш контроллер, запустим еще раз сервер и посмотрим вывод в консоль
Да, все отлично, давайте теперь сделаем вывод в поток, добавим в конце нашего контроллера две строчки:
```
w.Header().Set("Content-Type", "application/json")
w.Write(js)
```
Пока закончим с Golang и вернемся к клиенту. нам потребуются три тайтла, хотя по факту у нас их 4, но нам пока что хватит трех, а то и двух.
Добавим наши тайлы в директорию Content и начнем работать с MainScene.js, для первых результатов нам хватит нескольких функций:
```
class MainScene extends Phaser.Scene{
constructor() {
super({key: 'MainScene'})
}
preload() {
// Загружаем наши ресурсы в игру
this.load.image("Ground", "Client/Content/sprGrass.png")
this.load.image("Water", "Client/Content/sprWater1.png")
this.load.image("Sand", "Client/Content/sprGrass.png")
}
create() {
this.getGameMap()
}
update() {
}
// Получаем карту чанка
async getGameMap() {
let res = await fetch("/map")
let result = await res.json()
this.drawChunk(result.map)
}
// Рисуем наши тайлы на игровом поле
drawChunk(map) {
for (let chunkKey in map) {
this.add.image(map[chunkKey].x,map[chunkKey].y, map[chunkKey].key)
}
}
}
```
Сервер возвращает нам наш чанк в виде json объекта, вы можете посмотреть в консоли браузера его структуру:
А вот так Phaser его отрисовал в браузере:
Мы рассмотрели простейшую работу между сервером и клиентом, в следующей статье мы уже будем сразу отрисовывать 9 чанков и перемещаться по миру. Весь код и ресурсы из статьи смотрите [здесь](https://github.com/Lolodin/HabrMMO). | https://habr.com/ru/post/488794/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.